gennaio 18, 2014

Colors/Groups Exchanger (add-on)

Working in parametric design with a particular focus on blender’s parametric features, and the possibilities to exchanging information from/to other softwares I started to develop this new add-on.

During last workshop adaptABILITY in Bratilsava, Andrea Graziano and me introduced participants to some strategies for connecting blender to grasshopper through informations stored in vertex colors that can be exported as .ply file without need of scripting.

In blender there are quite interesting tools for working with vertex colors and vertex groups (vertex weight) but there is no an easy way for create a connection between these two layers of information stored inside the vertices of the mesh.

The add-on that I prepared is called Colors/Groups Exchanger and it allows to use two different commands: Vertex Colors to Vertex Groups and Vertex Group to Vertex Colors.

Vertex Colors to Vertex Groups

Sometimes can be useful to use informations of vertex colors in order to control some modifiers, physics or the behaviour of shape-keys.

vertex_colors_to_vertex_groups_command

 

Using this command it is possible to store one or more colors channels inside vertex groups (gray, red, blue, green, inverted).

colors_to_weight_options

For instance vertex colors are pretty useful for creating a grayscale map containing informations about mesh curvature. This tool is called Dirty Vertex Colors:

 colors_to_weight_dirty

Or maybe you prefer to use light shading for parametrically control some particular effect on the surface of your geometry:

 colors_to_weight_light

Or simply use some colors information incoming from external softwares for interact with your geometry.

 

Vertex Group to Vertex Colors

The second command that I’m going to explain is Vertex Group to Vertex Colors. It allows to move information from vertex-weight groups to colors, maybe because you want to export these informations to external softwares or simply because you want to render vertex groups.

vertex_group_to_vertex_colors_command

 weight_to_colors_options

One of the coolest way to work with vertex weight is to use some dedicated modifiers, like for instance Vertex Weight Proximity:

 weight_to_colors

We are waiting to do a new workshop about Blender and Grasshopper in order to going deeper in this interesting topic. Check Co-de-iT website for updates, or tell us if you would like that we organize one in your city.

 Cheers

Alessandro

novembre 11, 2013

Adaptive DupliFaces (add-on)

dupli_morph_03b_gray

During the adaptABILITY workshop in Bratislava, Co-de-iT‘s team (Andrea Graziano and me) focused on several strategies about the connection between Blender and Grasshopper as tools for computational design in architecture. In latest years the development of blender went very fast and a lot of very useful features in computational design emerged, thanks to the community of developers. Looking at some very diffused panelizations strategies in grasshopper I decided to propose something similar in blender, that I called “Adaptive DupliFaces”.

In this rought version it’s possible to define one or more component meshes, and a base mesh. Select at first the components and then the base mesh, therefore run the command “Adaptive DupliFaces” for moving and adapting the panels for every face of the base mesh. Currently there are no options, but as soon as possible I’ll implement more feature for controlling the proliferation. Until then there are some rules to observe:

dupli_morph_04_base

dupli_morph_04

. the base mesh must be composed by quadrilateral faces. Triangles and polygons can give some weird results;

. the component mesh coordinates in x and y will be reproduced in faces UV, considering both x and y going from 0 to 1;

panel_scheme

. until now there is no control on the component rotation, it depends on face’s indexing;

. at moment, z coordinate is fixed and must be resized in original component before Dupli Morph operation.

You can download the addon at the link: adaptive_duplifaces.py

Following you can check some quick tests that show some applications of Adaptive DupliFaces. It was developed for architectural works, but I think that it could be useful also in different fields.

examples

Pleas post your questions or your works done with Adaptive DupliFaces!

Cheers ;-)

ottobre 8, 2013

adaptABILITY _ blender + grasshopper workshop

ParametricBratislava is proud to present our latest collaboration with www.co-de-it.com.
This time after listening to the request of many of our followers we finally decided to break the lines and design for you a 5 days workshop concentrated on the parametric learning and implementation of blender in architectural modeling. How can we create and interpolation between blender and Grasshopper for rhino? Keep reading and maybe join us to find out!
——————————————————————————————————-

adaptABILITY

Blender + Grasshopper workshop

Bratislava, Slovakia
30 Oct – 3 Nov 2013

[.] Brief

“Intelligence is the ability to adapt to change.”― Stephen Hawking
The human ability to adapt to changing environments depends on human behavior as well as on the tools we create and use; we are, in fact, symbiotic with the tools we create and in turn they change our mindset and behavior, fostering the creation of new ones to solve upcoming challenges as well as to satisfy our need to explore the new. Embracing the technological evolution to the fullest as designers means embedding toolmaking as a necessary part of the design process, thus making us more adaptable in front of new design challenges, and in the present day the word “tools” in design and architecture implies directly software.
No single software fits all the situations and needs of our daily job or research; we must learn to play with many different tools with their own peculiar features, extending and combining them seamlessly in order to expand our toolset and enhance our tools sensibility.
The workshop will explore how to use and combine two powerful design tools and exploit their synergies. Blender is one of the most powerful and famous free, open source 3d modeler (and much more – just check the 2013 reel …don’t forget it’s a free software!) and Grasshopper is the well renowned graphic programming editor and generative modeling tool. The synergistic potential of these tools could lead to new opportunities for custom design strategies and provide new advanced features in our skills set.

[.]Software & skills:

Basic modeling skills in Rhino and Grasshopper [Primer level] are required.
No specific Blender skills are required (although an introductory knowledge of 3D modeling is welcome).
Participants should bring their own laptop with pre-installed software. The software package needed has no additional cost for the participant (Rhino can be downloaded as evaluation version, Grasshopper and Blender are free), but since they are subject to frequent updates a download link to the version used in the workshop will be sent to the participants a few days before the workshop.

[.]Tutors:

Andrea Graziano + Alessandro Zomparelli – Co-de-iT.

[.]Venue:

Academy of Fine Arts and Design – Bratislava, Slovakia
Hviezdoslavovo námestie
811 02 Bratislava
Slovakia

[.] Academic credits:

The participants will be provided with a certificate stating that they took part in an official workshop of the Academy of the Fine Arts and Design, Bratislava, which is worth 3 ECTS credits. The credits themselves will be awarded by the participants domestic institution based on this certificate. We advise the participants to discuss the procedure with the domestic institution n advance. Even though this is a standard and only possibility, there might be additional requirements from the various universities.

[.] Organized by:

This workshop is organized by Co-de-iT in collaboration with:
3D Dreaming – Architecture from a digital point of view
rese arch
. Academy of Fine Arts and Design in Bratislava

[.] Contact: 

3ddreaming@gmail.com
aprile 24, 2013

dual meshes in blender

000 - cover_fx

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:

001 - starting mesh

002 - triangulate

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:

003 - subsurf modifier

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

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

005 - select similar

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:

006 - select similar

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:

007 - final result

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!

luglio 23, 2012

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

luglio 23, 2012

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)

Image

novembre 15, 2011

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

[UPDATE]

Here is an updated versione of the script to blender 2.69:

simple_realtime_mesh_exporter_v269.py

settembre 5, 2011

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:

scheme_mesh_subdivisions_3

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:

scheme_mesh_subdivisions_1

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:

scheme_mesh_subdivisions_2

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:

rearrange_faces

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

settembre 4, 2011

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:

tidyng vertices of single faces

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.

maggio 15, 2011

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();
...

benchmark_example

example of benchmark output

download benchmark_static.pde

Iscriviti

Ricevi al tuo indirizzo email tutti i nuovi post del sito.

Unisciti agli altri 26 follower