Osseous Truss Pavilion

In some of the courses I’ve taught, people asked me how to make the structures of these workshop poster images. In this post I show the osseous truss pavilion that I generated to be the image of the workshop at SIGraDi 2009 that I taught along with Gonçalo Castro Henriques.

It is a system originally developed in Grasshopper 0.60019, based on the Surface Box-Box Morph combination explained in section "11.2 Paneling Tools" of the Grasshopper Primer, by Andrew Payne and Rajaa Issa (p.79-83). The first difference is in the prototype that makes the unit of the truss (or geometric pattern, as is referred in the tutorial). In the beginning it was made directly on Rhino, from NURBS curves of degree 2, closing the three points of the triangle of the diagonal division of a square. For this update, the prototype is generated entirely in Grasshopper, using only the grids of control points.

But the key for this to work as the structure from the image is on the topology of the base surface. The base surface of this pavilion is designed in Rhino, lofting between curves that were previously oriented, point by point, to begin longitudinal, grow to become transversal and end longitudinal again, bending over to make a sort of bridge with two supports. The deformation of these surface isocurves was inspired by the stereographic projections of Cartesian grids.

Posted in Parametricismo.

Download here the updated definition for Grasshopper 0.60059.

Phyllotaxis Tower

This is an idea for a skyscraper based on spiral phyllotaxis, like the sunflower system, that exhibits spiral pods always in Fibonacci numbers.

Monocoque from single list definitions

This is a simple example of a monocoque generated from points on a surface. With just a few components, sixteen points are inputted to draw an interpolated curve on the surface. This was done before the implementation of data-trees in Grasshopper, so, from a single list of points a zigzag curve is drawn. In order to have two directions to work structurally, the sixteen points are inputted once again, resembling the other order needed.

In general, single list have been seen as a limitation when working with surface sub-parameters, but in this case I was taking advantage of them to get this aesthetic output.

Honeycomb script published in aU

On April, 2009, in number 181 of Brazilian aU Magazine, Affonso Orciuoli published the article: TI aplicada à arquitetura: o antes e o depois (IT applied in architecture: before and after), in which he exposes the uses of scripting, parametric modeling and digital fabrication in architecture. He mentions some experiences like our Tooling workshop or the Radiolarian Walls project and shows one of my experiments: the Honeycomb script. This is a simplification of Andrew Kudless’ script that I’ve originally prepared for teaching RhinoScript. Here is shown in a mid stage. Recent versions have improved efficiency making a more elegant code.

Thanks to Affonso for inviting me to collaborate in his article.

---

Em abril de 2009, no numero 181 da brasileira Revista aU, Affonso Orciuoli publicou o artigo: TI aplicada à arquitetura: o antes e o depois, no cual ele expõe os usos do Scripting, a modelagem paramétrica e a fabricação digital na arquitetura. Ele menciona algumas experiencias como o nosso Tooling workshop ou o projeto das paredes radiolárias e mostra um dos meus experimentos: o script do Honeycomb. Este é uma simplificação do script do Andrew Kudless, que preparei originalmente para dar aula de RhinoScript. Aqui mostra-se numa etapa média. Versões recentes têm uma eficiência melhorada, providenciando um código mais elegante.

Obrigado ao Affonso por invitar-me a colaborar no seu artigo.

Inside Staircase example

One of the most known examples David Rutten was used to show when was presenting Grasshopper was the Staircase example, because is relatively simple to assemble, it's amazing to see the fast-and-easy interactive feedback of parameter changes and, at the end, it's a parametric architectural element. But when teaching Grasshopper, I rather to follow the same constructive approach to generative design —from points, to curves to surfaces— that I've used in RhinoScript, and the Staircase is a good example to introduce Orientation. Therefore, I use it as a fourth or fifth example.

And for not repeating the exact definition that everyone can find on Internet, here is another example (with more components, but still simple), in which four points are inputted to construct a control point Nurbs curve of 2^nd degree (instead of an interpolated curve), not used as axial but as an external border generative curve, so that the location of input points can also respond to external parameters like surrounding spaces of a building.

Update 2018-02-13:

As requested by readers, I've updated the definition and you can download it: InsideStaircase-180213.gh (26.5 KB).
Runs in Grasshopper 0.9.0076 (and above, if developers keep backwards compatibility).

This work is licensed under a Creative Commons Attribution 4.0 International License.

Vertical Milling problem

In some moment in the Radiolarian Walls project, I came out with a zigzag joint solution to the continuity issue in the wall tessellation. That implies that we no longer leave the original boundaries of the provided material for the finished panels, but we had to mill in a vertical way to get our custom borders.

As part of planning for machining, I developed a series of simulations in which we could visualize a problem in this cases that require vertical cuts. The study showed that depending on the depth of cut, the head of the tool may collide with the material, breaking it. It also showed that in cases of milling a surface with a certain slope, the milling itself provided enough space for the movement of the tool head (that’s the reason why it hadn’t happened before). Thanks to this, we could foresee the purchase of a longer tool.

Incremental Random Surface script

Once I get to introduce arrays and loops to work with points, I’m used to introduce nested arrays and loops to follow the constructive geometry logic of going to the next level: curves. And since is pretty obvious by itself, I go one more step to surfaces. The key concept to understand here is that a curve needs an array of points —which are arrays of numbers, so is an array of arrays— and a surface needs an array of curves —an array of arrays of arrays!

To set this level of nested arrays with loops, you have to nest the loop as well. The simplest example to understand this in RhinoScript is presented here. I’m using $x$ and $y$ as iteration variables, so the relation with the point arrays and the geometrical output is more clear. For the $z$ component, I’m using the pseudo random function (Rnd) in order to get a differentiated output without adding more lines of code.

A student once told me that it looks like a tsunami and remembering it I did this second image, with 21 iterations in $x$ and 51 in $y$ dimension. Notice that Rnd has no specified seed, so it’ll generate a different surface every time it runs. The script:

Call IncrementalRndSrf()
Sub IncrementalRndSrf()
    Dim Pts(20)
    Dim Crvs(50)
    Dim x, y
    
    For y = 0 To 50
        For x = 0 To 20
            Pts(x) = Array(x, y, Rnd*x)
        Next
        Crvs(y) = Rhino.AddCurve(Pts)
    Next
    Call Rhino.AddLoftSrf(Crvs)
End Sub

Learning more scripting

I had the opportunity to be on an official RhinoScript workshop taught by David Rutten, as part of the events of a symposium on emergent architecture, at ESARQ – UIC, on April, 2008. I improved some skills and learned to work with recursion and meshes, among other things. David also gave us a demonstration of Grasshopper (then called Explicit History).

The image is from one challenge exercise I accomplished. From a given mesh and a base script, we had to do a proximity sensor that colors the mesh as another object gets closer to it.

Helicoidal entity

Experimenting with vector growth, by mistake I assigned the same final vector to the whole field and I got this interesting outcome. Then, the rendering colors where just for having some deep effect for a desktop image. That’s other positive side of experimenting in a trial-and-error way.

Growing helicoidal curves on a surface

I was learning some vector operations for the Iterative Branching Systems project, and doing that I came out with this experiment to grow curves on a surface, like hairs on a skin.

After calculating an array of points on the given surface, on each point, the algorithm creates a vertical vector, and iteratibly scales a duplicate of it, rotate it and put it on top of the last one. Then, uses these vectors as control points to create a curve, which is used to construct cone-pipes with a modified version of the Andrew Kudless’ PipeAll script (with 0 end radius).

The first image shows helix growth, in the second, the vectors have a pseudo-random rotation, and in the last one, the array on the surface is also random.