dual meshes in blender

Thanks to introduction of b-mesh it’s possible in blender, starting from a triangulated, to obtain a polygonal mesh in blender. This kind of polygonal mesh is called dual mesh.

Create a generic mesh surface in blender and then triangulate that. You can use the shortcut ctrl+T. Generally I suggest to start from a regular quad-grid, in order to achieve a more regular dual mesh:

Now, add and apply a subsurf modifier, leaving the default settings. Now your mesh contains vertices of both starting and dual mesh. We need to surgically remove the starting mesh:

For do that, we must select a vertice of the dual mesh. You can recognize it because it’s conected only to three edges. Now prest ctrl+ for “select more”:

Use now “select similar” tool (shift+G), and choose the option “Amount of Adjacent Faces” for select all similar vertices.
Invert the selection with ctrl+I and “Dissolve” the selected vertices:

Now select one of the vertices connected to only two edges and use again the tool “select similar”. This time use the option “Amount of Connecting Edges”, and then dissolve all the selected vertices:

Sometimes it’s possible that some quad faces must to be clean in a second moment, in this case you can use the same procedure for select all similar vertices. Furthermore, if your mesh is open, probably you have to clean the borders. To doing that quickly, you can simply use “Select Non Manifold” for select and delete the border vertices.

Here you can see the resulting mesh:

If you are lazy like me, you can also use a script that I created in order to automatically calculate the dual mesh: dual_mesh.py. For do that, simply copy and paste the code inside the blender’s text editor, select your mesh and run the script.

cheers!

spectrum { embodiments } – processing workshop in Rovinj (Croatia)

spectrum { embodiments }
Hotel LONE | Rovinj | Croatia | 27th – 31st August 2012

The more we explore the architecture of matter, the more what we get looks more and more like information; yet, infor-
mation needs a body in order to express itself as such. Architecture starts when the embodiment process takes place,
from the set of relations that define a system, by defining relations among independent objects (which, in turn, are
information systems on a finer scale). By coding the behavioral rules of interacting autonomous agents and topological
manifolds, emergent hierarchies and differentiated yet coherently related spatial and geometric conditions flourish form-
ing a spectrum (a condition that is not limited to a specific set of values but can vary infinitely within a continuum), with
a cascade of local symmetries, gradients and singularities emerging from pure information systems.
The workshop will speculate through codes written in Processing on autonomy of form and the relation among behavioral
rules and morphogenesis. Rather than trying to reductively solve dualities like autonomy/dependency, whole/parts, het-
erogeneity/homogeneity the workshop aims to exploit them as a fuel for dynamic, competitive or collaborative creation of
higher complexity and the source of a spectrum of possibilities in finding novel forms.seeable forms with no precedents.
We will write our own unconventional programming strategies in the scripting- framework Processing.

SUPERVISION
Alessio Erioli, Tommaso Casucci, Alessandro Zomparelli
Affiliations
Co-de-iT – Computational design Italy – www.co-de-it.com
a collaboration between Co-de-iT and MLAUS / proto/e/co/logics

INFORMATION & REGISTRATION info@mlaus.net

Blender: Random Material Assigner (to BMesh N-gons)

This is a simple script for assignement of random materials to different faces (n-gons) of a single object. It works differently to the existing Random Material Assigner and the mine is a version very rough. I wrote this script because for the particular job that I had to do it was more comfortable handling a single object to be fixed as a random mosaic, rather than a very large number of different objects. Here is the code:

import bpy
import bmesh
import random

obj = bpy.context.active_object
mesh = obj.data

bm = bmesh.new()
bm.from_mesh(mesh)

for f in bm.faces:
    f.material_index = int(random.random()*len(obj.material_slots))

bm.to_mesh(mesh)

Blender Real-time Exporter (simple version)

Sometimes, working with tools like Processing or Grasshopper I’ve felt the lack of maneuverability of blender meshes modeling. I therefore decided to develop a small script for export my mesh refreshing it in real-time. This will make it possible to read information from different software programs interactively with the ability to store files prefix.vertices and prefix.faces, containing respectively the vertices and faces of the mesh.
Is also possible to simultaneously export multiple objects with the ability to apply the modifiers before exporting. The export deals only with the mesh, so there are not applied the transformations like translation / rotation / scale of the object.

 

 

Following is a brief description of the syntax adopted for export .vertices file:

n_vertices
vertex_01_x vertex_01_y vertex_01_z
vertex_02_x vertex_02_y vertex_02_z
vertex_03_x vertex_03_y vertex_03_z
vertex_04_x vertex_04_y vertex_04_z
vertex_05_x vertex_05_y vertex_05_z
...


and .faces file:

n_faces
face_01_vertex_01_ID face_01_vertex_02_ID face_01_vertex_03_ID face_01_vertex_04_ID
face_02_vertex_01_ID face_02_vertex_02_ID face_02_vertex_03_ID face_02_vertex_04_ID
face_03_vertex_01_ID face_03_vertex_02_ID face_03_vertex_03_ID face_03_vertex_04_ID
face_04_vertex_01_ID face_04_vertex_02_ID face_04_vertex_03_ID face_04_vertex_04_ID
...


In the future, the intention would be to expand export opportunities allowing you to export files with different formats and reporting information about the vertex-colors.

Installation of Blender Real-time Exporter:
Download realtime_mesh_exporter.py and open it with blender text editor, press Alt-P for run the script and in Object Data menu it will appear the new panel: Real-time Mesh Exporter.

You can also try the exporter with my simple Processing sketch BlenderToProcessing.pde. I don’t use libraries like toxiclibs or hemesh, but only Processing function beginShape(). So with particular quad faces it gives some errors of visualization.

Happy Blending

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 Faces.gh

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

This script was developed to be used in succession to the components of simple subdivision and Catmull-Clark subdivision introduced in Grasshopper thanks to the plugin WeaverBird developed by Giulio Piacentino.

One of the difficulties of working with subdivided meshes is the not easy acces to different faces. The difficulty stems from two fundamental aspects: the order of the vertices of the individual faces is not always the same, but it was caracterized by a different shift in each subdivision for each face. The second aspect concerns the order of indexing of individual faces and vertices. In fact, these orders do not coincide with the rows and columns of the corresponding grid.

To solve the first problem you need to go and investigate the slip rule, which follows a rule for incremental four faces derived from the mesh of departure according to their order and the number of subdivisions.

Look at the image to better understand the difference in output, if we decide for example of triangular faces using vertices [0, 1, 2] of each quad-face:

tessellation by triangles (0, 1, 2): before and after rearranging of relative order of the vertices

It is possible to download the Grasshopper definition for vertices shifting. It includes my script in C # together with an explanation and a different version of the process with standard GH components both edited by Mirco Bianchini

download Shift Vertex Order.gh

Because the orientation of vertices depends on the order of faces of starting low-poly mesh, I insert in my c# component vertex the possibility to correct manually through a list of integers containing the individual shifting values for faces of starting mesh. By default I give a shifting value of 1 for the first face. Disconnecting the panel it turns off automatically.

Benchmark in processing.org

Trying to better understand the functioning of the Java language (in particular of processing) I decided to build a small class of benchmark with which to keep monitored the duration of some operations computationally expensive. The usage of the class is very simple: copy the file. pde in the folder of your sketch and open the main file (for example mySketch.pde in a folder with the same name “mySketch”). The usage that I suggested (but you are free to adapt it to your taste and your needs) is to declare an instance of the class benchmark at the beginning of the code, then the instance will be initialized at the beginning of phase to be monitored specifying the subject of control (a simple string that will be reported in the console) and successively is close. Will then appear on the console the duration of the operation (or loop of operations), in milliseconds. You don’t need to create a new instance of the benchmark class for each control, just overwrite the same every time.

usage example:

benchmark myBenchmark;

... code ...

myBenchmark = new benchmark("myOperation time");
...operations...
myBenchmark.end(); //return in console "myOperation time: ###ms"

...code...

myBenchmark = new benchmark("myAnotherOperation time");
...another operation...
myBenchmark.end(); //return in console "myAnotherOperation time: ###ms"


This is really simple, but I hope useful.

download benchmark.pde


[edit]
I improved my benchmark using class method static instead of default instance. In this way it is not possible to output nested benchmark controls (you can have a nested control copying the class with a different name for every hierarchy level) on the other hand it is possible to access to benchmark methods without having to instantiate the generic class benchmark.
I also insert a memory control that display total memory used by virtual machine and a delta memory that, after the calling of garbage collector, evaluate the memory used by myOperation.

usage example:

...
benchmark.begin("myOperation");
... operations ...
benchmark.end();
...


example of benchmark output

download benchmark_static.pde

voxel analysis for implicit surfaces

This is my first test with implicit surfaces. I tried to voxelize a sort of rheotomic surface, defined by rules of iso-distance between nearest elements of two differtent groups (1 point+2 curves for first group and 2 points+1 curve for the second one).

In a first moment, I tested the brute-force samplyng method, in order to search for a way to sample points belonging to implicit surfaces. This expensive method consists of analyzing all possible solutions and the subsequent evaluation of results. In this case I needed to verify each point of my 3D grid and improving the resolution, i obtained  8^n points every n divisions of main domain.

A better solution consists in a progressive analysis: starting from a domain, and progressively dividing positive matched cubes (later I learned that this approach already exists with the name of Quadtree):

Explanation of progressive sampling method.

Coding it with c# in grasshopper, I obtained a relatively complex point cloud:

Point Cloud otup in grasshopper

This coarse approximation isn’t at the moment enough accurated for obtaining clean surfaces, however I tried to connect resulting point-cloud with MeshLab. After a quick editing in Blender, I rendered the output:

Final Mesh

At the moment I’m working on the improvement of the quality of point-cloud and subsequent elegance of the resulting mesh.