Rearrange the mesh after WeaverBird’s subdivisions (part 2)

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:


default distribution of faces after three levels of subdivision

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:


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:


counterclockwise 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:


rearranging of four faces after three subdivision levels


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:

download Rearrange



Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:


Stai commentando usando il tuo account Chiudi sessione /  Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )


Connessione a %s...

%d blogger hanno fatto clic su Mi Piace per questo: