Spaceframe from two surfaces, featuring parametric struts and nodes (Grasshopper)

Here's a solution for generating spaceframes from two surfaces. Struts and joints are real reactive components. As mentioned before, surfaces are first segmented by quad-mesh-faces, from which i derive lists of respective vertices. Since this is done for two surfaces, corresponding points on both of them can easily be connected with struts. For these, an additional script component had to be added, since there's no way i know of that can get me groupwise lofts from one large list of profiles. (And even if there was one, a tiny script definitely is the cleaner way, at least until david will come up with more advanced ways of dealing with data-streams).

Due to the topology of meshes, i get lots of redundant surfaces, which, because of their opposing orientation, can't be detected automatically. Also, some unecessary cross-wise struts show up. These issues could be addressed by skipping a strut where there is already another differently oriented one, which on the other hand leads to missing parts at the structure-boundaries. However, i might take care of that later.


Parametric Openings between two Surfaces (Grasshopper)

By applying the previously described way of scripted data-splitting (introduced with real reactive components in one of my earlier posts) on two surfaces, it is possible to connect these in various ways. This is an example featuring parametric 'openings', steerable via attractors along with two individual scaling factors.


Real Reactive Components (Grasshopper)

For anyone interested in real reactive components: here is a way this can be done in grasshopper with very little c# scripting involved:

The script-part segments a NURBS-patch into quad-mesh-faces, which are used to derive meaningful vertex-pointsets from:

As a very simple result, a pyramid-component whose corner-vertices sit on derived UV-points can be steered via attractors. the height of a pyramid depends on the distance of its base-barycenter to an attractor-point.

This kind of workflow implies some very interesting applications, which will be subject to successive posts.


Ruled Surfaces #3: Reactive Facade (Grasshopper)

Nothing spectacular, facade reacting on attractor-point. Ruled surfaces in any case. One single C# component was used for splitting the loft-profiles for an arbitrary number of level-curves. Definition-file will be added later.

Ruled Surfaces #2: Generate Ruled Surfaces from a surface-UV-grid for Lasercutting (Grasshopper)

This is my version of something i have seen on www.liftarchitects.com. In addition to their solution, i come up with the possibility to choose my own vector for loft-rulings. I use one C# script component for the separation of lofts, along with another which just lets me choose between three methods (see below) of providing a generic list of vectors defining the directions of rulings, before they are passed through the component based on the status of an integer-slider. I didn't find an easier way to do this, although the script itself is piece of cake ;)

rulings are parallel to global z-direction (developable)

an appropriate ruling-direction can be chosen explicitly (developable)

rulings are surface-normals. general ruled surfaces. (non-developable)

Note that the third variant, the one based on surface normals, consists of non-torsal ruled surfaces, which in general are non-developable, meaning that they cannot be projected to a plane without distortion, and one will get some irregularities when trying to produce the structure this way.

What i didn't add yet is a method for the production of vertical slots at intersections of struts, but since i am going to lasercut such a construction soon, i will have to add it within the next days. I'm also planning to add a fourth method which will average rulings for each loft individually. This could come in handy if the input-surface is not too twisted. Watch out for that.

Ruled Surfaces #1: D-Form Explorer (Grasshopper)

Here are some examples i am currently preparing for a set of lectures on Architectural Geometry to be held at TU Vienna starting in about two weeks. Since the main focus will lie on ruled surfaces, which are especially interesting for architectural applications when it comes to actually building a freeform design, these definitions will generate models based on these special surfaces.

First, we have a rather simple, but nevertheless very nice application. 'D-Forms' consist of two non-elastic surfaces-patches (e.g. paper) sharing the same perimeter. You can produce such objects by cutting out these patches from e.g. paper, starting to glue them together at arbitrarily chosen points along the two perimeters. The rest will follow automatically such that the shape will be closed. (Note that for the first image i just couldn't resist to apply some filleting onto the edges ;)

In grasshopper, i select two closed bspline-curves, which serve as bases for two extrusions. These are then centered around the coordinate origin, after which they are assigned a boolean difference. To alter the result, you can change the height of one of the extrusions, as well as its rotation angle. Of course, it is also possible to alter the input curves.

In order to easily arrange nice results without leaving the context of grasshopper, i added two sliders allowing the user to shift their design to a free parking slot before baking it.

Using the 'unroll surface' command in rhino, the surfaces can be projected onto the base plane without distortion (since they are developable), after which you can cut them out and glue them together.

Have a look at Tony Wills' webpage, who is the source of the D-Forms concept. Thanks to Georg Suter for some valuable feedback on this one !