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: