In this second part I explain a possible solution to the problem of rearranging the order of faces and vertices. The default order from subdivision components of WeaverBird is presented in a non-intuitive form. The default order of the mesh after three levels of subdivision of one quad-face looks like this:

This distribution comes from the progressive rotation and repetition of the basic counterclockwise order:

----------

| |

| 3 2 |

| |

| 0 1 |

| |

----------

So what I’m looking for is a rearrangement of the order of faces and vertices that is similar to a grid arranged in rows and columns. To obtain this I have decomposed the problem into two steps.

In the first step I hypothesized a more simple distribution:

Now we consider the coordinates of every face in function of their parents faces. For exemple:

0 ==> {0;0;0}

1 ==> {0;0;1}

2 ==> {0;0;2}

3 ==> {0;0;3}

4 ==> {0;1;0}

5 ==> {0;1;1}

...

26 => {1;2;2}

...

64 => {3;3;3}

Looking for a rule rows for columns we can describe the progression of individual rows via binary numbers. For exemple the first row looks like:

{0;0;0}, {0;0;1}, {0;1;0}, {0;1;1}, {1;0;0}, {1;0;1}, {1;1;0}, {1;1;1}

This sequence represents the paths of the faces belonging to the first row from the bottom. If we consider the same sequence for every row and a similar one for columns then we will be able to describe every number in function of its row and columns index. For exemple we can write 26 like:

26 => (4, 3) => ({1;0;0}, {0;1;1})

and we can easily get the global path:

26 => {1;0;0} + 2*{0;1;1} = {1;2;2}

now we are ready for second step.

In second step we will switch from linear to counterclockwise distribution. To do that simply flip the 2 with 3, getting a new distribution:

Then we see the correspondence between the new order and flipped paths. Looking at our friend 26:

26 => {1;2;2} ==flip==> {1;3;3}

Now there is a last step. We have to consider the progressive rotations of subdivided faces. Every new subdivision level new faces rotate around the center of the parent face of one position counterclockwise (+) for every level and a number of positions corresponding to superior path index clockwise (-). For exemple:

n: {A0; B0; C0}

A1 = (A0 + 0)%4

B1 = (B0 + 1 - A1)%4

C1 = (C0 + 2 - B1)%4

```
```

`26 => {1;3;3} ==rotating==> {1;3;2}`

At this point we can take the numbers from paths {A;B;C} and give them a new index:

ID = A*4^2 + B*4^1 + C*4^0

At the end of the process the output looks like that:

If you want you can try my C# script. To work, it must be placed in succession to my previous script for rearranging single face’s vertices order. Look at my Ghrasshopper definition for better understand how it works: