Page 1

EXLABCAST workshop manual

EXLAB:CAST Introduction EXLAB: CAST  6 Workshop Research Agenda  7 Elseware 8 NURBS in Rhino  10 Grasshopper 11 Elseware & Web Resources  12 Workshop Structure & Schedule  14 Cast Lace  16 Fabrication Research 19 Exhibition 30 Thanks 31

Seminar Guides Seminar 1 -

Rhino Modelling Introduction

Grasshopper: Interface, Geometry and Data Types

Seminar 2 -

Association, Space, Mapping and Functions  50

Seminar 3 -

Input, Association and Output Clusters 51

Seminar 4 -

Fabrication and Protoyping  90

Seminar 5 -

Data Structures and Documentation 91

Datatree Resources  127 Seminar 6 -

Project One Construction  128

Seminar 7 -

Analysis and Response  129

Seminar 8 -

Simulation  130

Seminar 9 -

Documentation and Discussion  131


Exercise Files Tutorial 1 - Make a polyline from points  34 Tutorial 1 - Rotate with multiple angles using a Range  39 Tutorial 1 - Move an object with a Series component 43 Tutorial 1 - Section a surface with horizontal Planes  47 Tutorial 2 - Association with an attractor Point 52 Tutorial 2 - Using the Image Sampler 56 Tutorial 2 - Association with a Curve attractor 59 Tutorial 3 - Combining INPUT, ASSOCIATION and OUTPUT clusters 62 Tutorial 3 - Transform with multiple attractors  67 Tutorial 3 - Orient objects around a circle  72 Tutorial 3 - Move a grid of points using a mathematical function  75 Tutorial 3 - Move a grid of points using a graph  79 Tutorial 3 - Move a grid of points using a random function  83 Tutorial 3 - Compound transformations using an attractor  86 Tutorial 4 - Isolate contained Curves


Tutorial 4 - Offset cell Curves 95 Tutorial 4 - Outline stroke (In Adobe Illustrator) 98 Tutorial 4 - Map Curve pattern onto 3d Surface


Tutorial 5 - Extract specific collections (items, branches)   104 Tutorial 5 - Create tool to display datastructure  108 Tutorial 5 - Labelling a 3d model using text tags  112 Tutorial 5 - Orient objects to a grid  115 Tutorial 5 - Draw curves through a grid of points in two directions  118 Tutorial 5 - Interpolate between a list of polylines  122 Tutorial 8 - Convert curves to spring objects  132


ExLab is a design and research collective that promotes creative utilisations of computation in art, architecture, engineering and related design disciplines. Based in Melbourne, Australia, the collective organises experimental collaborative research projects and exploratory workshops that focus on learning through making with digital fabrication at its core. CAST will explore the potential to enhance the process of casting by coupling flexible modelling and fabrication technologies with established techniques used in architecture and other design desciplines. It is the second in a series of workshops coupling parametric tools with a specific fabrication process. The workshop aims to use parametric tools to allow a new way of communicating with existing processes. The workshop will begin by introducing students to digital and parametric geometry and investigate approaches to generate forms through solid and perforated molds utilising prototypes designed and documented using Grasshopper and realised through a series of setting materials. Participants will be asked to engage in a series of esquisses which speculate on the advantages of using a CNC driven process and more advanced parametric tools to extend their own ideas and what was previously considered possible.


Workshop Research Agenda

The CAST workshop will explore interrelationships between design, data mapping, associative geometry, simulation and fabrication. It will do so within computationallysupported experimental casting workflows benefitting from a combination of crafted effects and parametric modelling. Participants will explore a design approach that employs digital simulation to anticipate complex, doubly-curved formal outcomes possible through an innovative casting jig developed for the workshop. Practical prototypes will be produced as wearable objects that analyse and use the geographies of the human body as sites for interventions. The ambition of this workshop is to introduce its participants to the radical creative potentials of the hybrid, digital/physical design processes while providing an introduction to the fundamentals of parametric design in Grasshopper and digital fabrication.



Gwyllim JAHN - completed his B.EnvDes at the University of Western Australia before completing his Masters of Architecture at RMIT in 2010. He practiced at Minifie Nixon architects and LAB Architecture Studio. He leads workshops and studios at RMIT, Melbourne and Monash universities, extending his design expertise in complex architectural geometry and behavioural systems, parametrics and digital fabrication. Jas JOHNSTON - is the Digital Fabrication Facility Coordinator at the Faculty of Architecture Building and Planning, University of Melbourne. He also tutors, assists with design studios and facilitates workshops focused upon digital design techniques through the Experimental Design Lab and digital fabrication techniques through the FabLab. Jas is particularly interested in new forms of digital art and their interaction and enhancement of architecture.


David LISTER - completed a Masters in Architecture in 2010 at the University of Melbourne. His academic pursuits include research into the modes of adoption of digital fabrication techniques in architecture, and tutoring design and the use of parametric and other digital tools in workshops, at the University of Melbourne and RMIT. Main areas of interest are in the use of digital and parametric design, analysis, feedback systems and integrating ideas and techniques of craft with flexible fabrication technologies. Stanislav ROUDAVSKI - Is a Lecturer in Digital Architectural Design at the University of Melbourne, he holds degrees of MArch/MFA from the Academy of Arts in St. Petersburg (Russia), MSc CABD from the University of Strathclyde (UK) and PhD from the University of Cambridge (UK). His current interests include generative designing of complex architectural geometries, bioinspiration, virtual and augmented environments, place and performance studies, spatial narrative, practice-based research methodologies and participatory, distributed creativity.


NURBS in Rhino

Rhino is a NURBS (Non Uniform Rational Bezier Splines) modelling package produced by McNeel. Modelling using NURBS is well suited to describing complex geometries for fabrication, as curved forms are not approximated to faces or segments as they are when modelling using meshes/polygons (3ds Max, Maya) or splines (AutoCAD). Instead curves and curved surfaces are described by interpolating between ‘control points’. This characteristic of NURBS geometry is most evident by the fact that no matter how far you zoom in on a nurbs curve or surface, it will never appear exactly flat or faceted. As such we have a lot of control over how we manipulate the parameters of objects in Rhino, and how we use them to generate and connect to the geometries of further objects. For example, curves and surfaces can be divided into exactly equal segments, simplified accurately, used to precisely measure angles and curvature etc.



Grasshopper is a plugin for Rhino that makes the history of all of your modelling operations and geometric properties explicit to the designer (in early stages of development it was called ‘Explicit History’). This flow of geometry and data is represented as a graph of connected nodes, and is commonly referred to as a Visual Programming Interface. Modification of a node in the graph causes this change to flow through to all connected nodes downstream, updating the output of each of these nodes. This allows designers to retrospectively modify parameters and operations and instantly1 observe their influence on the final design, without the need to redraw the geometry. Grasshopper (and other scripted design processes) allows you to draw using data. A few key international practices whose designs will be discussed during the workshop are: Asymptote - (Hani Rashid) TheVeryMany - (Mark Fornes) Matsys - (Andrew Kudless) Neri Oxman

Not always. Grasshopper creates a plethora of traps for beginners to fall into, especially when generating polysurfaces or calculating intersections. 1


Elseware Resources

DDA Repository - A collection of student work, scripts, reference projects and inspiration digital design work. Previous teaching material is also available on the site. Exlab - Grasshopper tutorials The Leda Atomicus - Gwyll’s digital design blog. Contains links to other digital design portfolios, blogs, studios, workshops and practice.


Web Resources

Grasshopper3d - Official grasshopper web page and resource for tutorials, events, downloads and discussion. Food4Rhino - Grasshopper and Rhino third party plugins. Kangaroo, MeshEdit, GHowl etc can all be found here and are frequently updated. Giulio Picantino - His 3rd party plugin Weaverbird can be found here as well as a number of handy C# scripted components we use frequently. Designreform - Video tutorials on series, lists, datatrees and common grasshopper functions.



Workshop classes run from 10am - 1pm and 2pm - 5pm each day. Participants are encouraged to attend all classes and commit additional time outside out of these times to get the most out of the workshop and utilise support from the ExLab team for technical guidance for problems encountered in exercises suggested to complete at home. The structure of the workshop is geared more towards collectively working towards project outcomes. While some sessions retain elements of technical focus directly presented by instructors to the group the workshop will predominantly function like a design studio where skills are acquired via practical application with access to one-onone support to expediate the production of these projects. Participants are free to use the studio out of workshop hours and time has been allocated for further software and fabrication help.





1pm 2

10am 9

3 8

4 7









Assembly &


Mass Casting




Design Esquisse Project Development



Interface &

Input, Output,

Data Structures

Analysis &



Association Clusters

& Development


& Presentations

Introduction Design Esquisse Seminar Development/Help Assembly/Casting Fabrication


Cast Lace

Throughout the workshop participants will be involved in the continuation of a research agenda exploring the potentials of casting as a technique for producing complex three dimensional patterned surfaces as designed objects to be worn on the body. With the body being the chosen site, designs can become responsive to localised conditions and desires of the body, such as curvature, performance, rigidity, flexibility, elasticity and ventilation whilst allowing these considerations to vary across the surface. Designers can also engage with aesthetic notions of volume, texture, transparency, form, expression and pattern, attempting to integrate some or all of these practical and ephemeral notions into one material. This project will investigate these possibilities by exploring material responses to clothing the human body through surfaces that consider aesthetic and functional requirements.


Model 1 - Pattern and Performance

The design project will begin by exploring patterns generated using the techniques learned in the seminars. Participants are asked to design and fabricate a patterned resin cast. Method: With the guidance of tutors, participants will identify areas of material exploration. Facilitated through seminars and provided content participants will be introduced to ways of exploring their selected material qualities and asked to speculate on potential outcomes. The process will be facilitated through the use of parametric and digital design tools to develop a range of physical outcomes that investigate their chosen area of investigation. Participants have been provided with a range of grasshopper definitions that can be used to investigate these notions. Using these as a starting point participants will develop their own designs and responses to their selected area of investigation. Possible areas of exploration: · Variable flexibility, directional flexibility · Elasticity · Form · Transparency and reveal · Texture · Pattern Elements: Distortion Jig - developed during initial rhino modelling tutorial as the first exercise. Constrained to a set dimension with a waffle structure created using a provided GH definition. Fabricated and cast moulds Resin cast


Model 2 - Garment Forming

Material pattern and texture are traditionally subservient in fashion to structural considerations such as darts, pleats and seams required to provide the shape of the garment. Elseware have a developed a workflow for the workshop which employs a particle based physics simulation which is used to distort an input piece of geometry to a desired shape in a way that is replicatable in a fabrication process. Using this process we can then form from the flexible moulds intricate patterned casts. The casting jig is a perspex cube with 5 closed sides (open to the top) which have gridded perforations for the purpose of providing anchor points for tension cables and mounted obstructions. The surface is stretched over the mounted obstructions (polystyrene spheres impaled on dowel) and anchored in position. By maintaining a set of physical constraints that can be embedded to some degree of accuracy in the simulation we are able to fit the cast to a digital mannequin. The final full scale cast of the workshop is to be produced using this process.


Fabrication Research

During May and June research was undertaken into a number of fabrication and casting techniques to inform the direction of the workshop. It is encouraged that participants discuss potentials they may identify in the models documented with instructors to acquire the knowledge gained from these practical trials.


Silicone Drips: Laser-cut / perforated perspex drip mould, silicone drip cast.


Resin Wave: Laser cut box-board jig, elastic / flexible silicone drip textured mould (cast in perforated perspex), resin cast over silicone drip mould.


Reformed Resin: Laser cut perspex mould, flexible/elastic silicone cast-mould, resin (reformed in flexible silicone mould).


Reformed Resin 2: Laser cut mount board texture cast w/ perspex base, flexible silicone texture mould, resin (cast semi-set and reformed).


Silicone flexi-extrusions: Laser cut perspex MDF mould, silicone cast.


Fabric-formed Plaster: MDF Box jig, polystyrene spheres on dowel, spandex lycra, plaster of Paris. 25

Resin Skin: Laser cut/perforate mount-board mould, silicone cast-mould, reformed/ stretched resin cast.


Stretched Resin: MDF Box jig, laser cut /textured perspex mould, silicone cast-mould, reformed/stretched resin cast.


Stretched Resin 2: MDF Box jig, laser cut /perforated perspex mould, silicone castmould, reformed/stretched dyed resin cast.




Work produced during the seminar will be collated and presented at the end of the workshop. The content will also be curated into a final document and published online. This document will show both digital content generated during the workshop and photography of models.



The National Institute for Experimental Arts (NICA) at the College of Fine Arts (COFA) for the invitation to run a workshop in another city within a culture of fine art at UNSW. The University of Melbourne for the donation of the use of equipment in preparations for the workshop. Bradley Elias; intern extraordinaire, for his aid in research, documentation and running the workshop. SONA, McNeel & for publicising the workshop on their websites and newletter.


Monday, July 9th

Introductions and Research

Morning seminar: Introduction to the members of Elseware, facilitators of the ExLab workshop series, and work previously complete or presently engaged in illustrating the relationship to the workshop and contemporary design thinking. Introduction to computational and parametric techniques and how we perceive its value in design. Presentation of CAST research to date to inform the workshop explorations and the outline of the first project. Demonstration of the silicone and resin casting process to familiarise participants with the qualities of the materials beign used during the workshop. Participants will then get involved by taking part in a design esquisse; sketching and diagramming potential designs or areas of exploration for project 1. Outcomes: Understand some of the discourse surrounding the application of techniques the workshop focuses on through our own work and other professional examples. Understand some of the material and design constraints and opportunities for the workshop projects through our research already undertaken. Start to develop a design concept for the first project with an element to be identified to be digitised as part of the afternoon seminar.


Interface, Geometry and Data Types

Afternoon seminar: General Rhino3D introduction including interface, navigation and toolbars. introduction to creating basic geometry types explored through the digitisation of elements of participants designs from the earlier design exercise. Walk through the grasshopper toolbars, context menus and icons. Learn how to use parameter components to begin working with Rhino geometry in Grasshopper. Generate a parametric loft from referenced geometry in Rhino, and from points created in grasshopper. Use Panels to observe how Grasshopper components process inputs and outputs, and to document the definitions workflow and learning process. Outcomes: Understand the basic geometry types within Rhino and how they are created. Understand the advantages and disadvantages to generating objects parametrically. Develop an aptitude for using the graphical interface and viewing data. Document a definition for later use. Discussion: Why might we reference certain types of geometry rather than defining it within grasshopper? When might defining even primitive data types be advantageous? What are the strengths and weaknesses of a parametric design process? Homework: Further develop your surface geometry. Using the provided Fabrication Grasshopper definitions create the fabrication templates for laser cutting. Additional instruction Videos: (highly recommended) BEND 00. GH Introduction BEND 01. Geometry and Data Types Further exercises and tutorials to complete: 1.1 - Make Polyline from Points 1.2 - Rotate with multiple angles using range 1.3 - Move an object with a series component 1.4 - Section a surface with horizontal planes



Tutorial 1.1 - Make a polyline from points

This tutorial introduces students to the Grasshopper (GH) interface and some concepts of parametric design by creating a simple polyline. Most objects in cad software are combinations of simpler data types, or ‘primitive’ types. In this instance a line is defined by the shortest distance between two points. A polyline is composed of a series of lines connecting a sequence of points. The primitive data required to define a line are points located using coordinates within 3d space, or x,y,z locations. Rhino geometry, in this case the points, will be ‘referenced’ into Grasshopper and used to create the polyline. Grasshopper doesn’t change referenced geometry, it will always remain, as is, in Rhino. In fact, Grasshopper won’t make any Rhino geometry until we transfer the Grasshopper geometry back into Rhino geometry. This process is known as ‘Baking’ a component. Variable sliders will then be used to define the primitive geometry, or points, used to create the polyline. Note.* At the bottom of each section the location path for the newly added component is detailed. For instance (PARAMS/ GEOMETRY/POINT) indicates that you will find the POINT component in the GEOMETRY drop down menu, on the PARAMS tab. In time, you will come to know where (almost) everything is but sometimes it is good to search via these menus rather than just double clicking and using the ‘find’ tool so that you get exposed to other ‘like’ components.


Exercise Create a number of points in Rhino. These can be randomly placed within the model space on a 2D plane or in a 3D space. These points will be the verticies used to define the polyline by referencing them into Grasshopper.

Add a POINT parameter component to the Grasshopper canvas.


The point component displays with an orange fill. This warning indicates that the component is under defined and more information is required. To assign the points you created in Rhino to this component, right-click on the component and select ‘set multiple points’. Within rhino model space select the points you wish to use to define the polyline.

The points have now been referenced to the component and should appear in the standard display colours (Gh default is grey).

Note that the order you select the points in Grasshopper will be how they are stored in the component. This order is displayed by a line drawn between the points as they are referenced into grasshopper.


Exercise To create a polyline, add the POLYLINE component from the curve/spline menu to the canvas. You can also double-click in the canvas and search ‘polyline’. The component will appear on the canvas with two available inputs. Hover the mouse cursor over the ‘V’ or the ‘C’ to see what the component requires.

(CURVE/SPLINE/POLYLINE) The ‘V’ input indicates that the input requires the points that will be the vertices of the polyline. Click and drag on the output of the point component to create a wire. Attach this to the ‘V’ input. Note that the path of the polyline follows the order the points were selected (The preview shown as they were selected). This is because the data is stored in a list ordered in the sequence the points were selected.

Grasshopper will now display the polyline. You will notice that it is green when the polyline component is selected and red when another component is selected (i.e. the points are red in the image to the right). This allows you to easily identify what geometry is being created by each component. The geometry preview for each component can also be switched off by rightclicking the component and deselecting ‘Preview’.

When a component has multiple inputs it is good practice to find out and experiment with additional functionality. In this case, the ‘C’ input gives an option to ‘Close Polyline’. Right-click on the input, go to set boolean and select ‘True’.

View your polyline which has a display preview in Rhino. This geometry only exists in Grasshopper for now. Click and drag your points within rhino model space and watch the preview update. Referencing geometry like points into Grasshopper allows for greater interaction within the Rhino interface by being able to drag the points by hand. Another option is to generate the points within Grasshopper. This lets us be specific in defining the point’s exact coordinates.


Exercise Add POINT XYZ from the vector/point menu to the canvas. Note that if you double-click and search ‘point’ there are a number of options presented. You will become familiar with these with time. Like before, hover the mouse cursor over inputs to decipher what the component is expecting you to pass to it.


This component allows the user to define a point via its Cartesian coordinates. Connect a number slider to one of the inputs to provide the required data for the coordinates. You can also double-click and enter a number into the ‘search by keyword’ (I.e.. 3.5) To obtain a slider with that value set as current

(PARAMS/SPECIAL/NUMBER SLIDER) By right-clicking on a slider you can ‘edit’ the properties of the slider to control the type of numbers (floating point, integers, even,odd), degree of accuracy/rounding, the numeric domain and the current value set.

Copy and paste these components (Ctrl+c, ctrl+v or holding alt+click/drag) to define 3 more points. Check in rhino to see them move as you change a value on a slider. Note that some inputs have default values assigned to them. The default coordinates for the x and y-axis are set to 0.0

Connect the first point xyz component to a polyline component. The polyline component needs a minimum of two points to create a line and therefore remains orange as a warning.



Exercise Now connect the remaining 3 point xyz components. To do this you will need to hold down the shift key if you wish to connect multiple wires to a single input. Like when we referenced earlier, the order in which points are connected to the polyline determines the path of the polyline.

Change the value of the sliders and watch the display update in rhino simultaneously.

As mentioned above, most objects in cad software are created using combinations of primitive data types through a hierarchy of the manipulation of this data. For example; points are used to define lines, lines are used to define surfaces. In this workshop participants will be generating a series of lines which will combine to define a surface which can be used to fabricate a mold to be cast from. This tutorial introduces participants to the primitives required to define a line which will be expanded upon in future exercises



Tutorial 1.2 - Rotate with multiple angles using a Range

This tutorial will illustrate how to rotate a curve profile around a central axis a number of times using a range component so that they are always evenly spaced. This may be used to create a repeating element within a larger pattern.


Exercise In Rhino front view model space draw a curve that will become the profile to be rotated around an axis. Also designate the origin of the axis of this rotation using a Point.

Reference both the Curve and Point into Grasshopper using a CURVE and POINT component.

(PARAMS/GEOMETRY/CURVE,POINT) Add a ROTATE 3D component to the canvas.

(CURVE/UTILITY/ROTATE 3D) To specify the axis of rotation add a X UNIT VECTOR component to the canvas and connect it to the axis of rotation input (X). This will rotate the curves on the YZ plane.

(VECTOR/VECTOR/X UNIT) The amount the curve is to be rotated around the axis can be specified by providing a rotation angle in radians to the (A) input. This angle can be passed into the (A) input via a slider.



Exercise Right click on the slider and select ‘edit’. Set the slider to a max of 360 using floating numbers. The slider must be converted into degrees for the ROTATE 3D component to operate as expected.

(PARAMS/SPECIAL/SLIDER) The RADIANS component converts degrees into radians allowing you to specify the rotation angle in degrees. Place the ‘radians’ component between the slider and the ‘rotate 3d’ component.

(MATHS/TRIG/RADIANS) As the slider is moved from 0 - 360, the curve will rotate around the axis of rotation. The original referenced curve is also still displayed in red as the ‘CRV’ componet is still on preview mode.

A specified number of copies of the original curve could also be created that are rotated around the axis. To achieve this a ‘Range’ Component is use. The ‘Range’ component creates a range of numbers spaced equally within a numerical domain by defining the start and end of the domain of numbers.

Define the domain of the numeric domain by using a ‘DOMAIN’ component specifying the minimum and maximum values of the domain. In this case as there are 360 degress the domain is ‘0’ and ‘360’


Exercise To specify the number of steps within the range at a slider onto the canvas and connect it to the ‘N’ input of the RANGE component. Change the rounding of the slider to Integers by double clicking the label and selecting ‘N’ (PARAMS/SPECIAL/SLIDER) As the integer in the slider increases, the number of curves rotated around the axis increases accordingly.


Further development: Try altering the direction of the axis of rotation by using a different unit vector X,Y or Z. Input a different reference curve from Rhino.



Tutorial 1.3 - Move an object with a series component

This tutorial introduces using a sequence generated with a series component as an input parameter for a simple geometric transformation, in this case a move transform. Creating a uniform array of components we can easily create a larger pattern of the same or selfsimilar repeating elements.


Exercise Model a 2d element in the top view of Rhino to be the basic for your pattern. This will be arrayed in 2 directions to create a basic pattern. Use the CURVE geometry component to reference the curve from Rhino.

(PARAMS/GEOMETRY/CURVE) In Grasshopper, ‘move’ is effectively the same as ‘copy’ as it creates a new geometry in the same or a different location. To array a geometry, simply move it a number of times.

(TRANSFORM/EUCLIDEAN/MOVE) Geometry is moved with a vector which is defined with a direction and a magnitude (ie. Move ‘n’ far in a ‘m’ direction). Use a unit vector (magnitude 1.0) In the direction of the x-axis to move the original curve. You will now see two curves. We can change the amplitude (or magnitude) of this vector by assigning a factor of multiplication.

(VECTOR/VECTOR/UNIT X) Rather than using a series of numerical inputs like sliders or integer parameters, use a series component to generate a sequence of variables. A series is a sequence of numbers where the first number is defined (S), each subsequent number in the series increases by a step size (N), and the number of values in the sequence is constrained (C).

(SETS/SEQUENCES/SERIES) This component has default settings to generate a series from 0 to 9, step size of 1. Ten links should now be previewed in Rhino model space.


Exercise The step size for your pattern is dependant on its dimensions. There needs to be sufficient overlap for the pattern to be structural if it is to be realised as a cast. Use a slider component to adjust the spacing of the arrayed components.

(PARAMS/SPECIAL/NUMBER SLIDER) Now create copies of this row in the other direction to create a two dimensional array.

(TRANSFORM/EUCLIDEAN/MOVE) This time use a unit vector component in the y-axis direction.

(VECTOR/VECTOR/UNIT Y) Connect the same series as was used in the initial move and view the results. You will notice some unexpected results. Instead of copying all of the 1d array up the distances specified it has moved the first copy up zero, the second copy up 1.0 and so on.

Right-click on the output ‘G’ from the first MOVE component and select ‘Graft’. This changes the structure of the data being passed into the second MOVE component. (for more information see later tutorials on structure and manipulation of data) Check the results. Now every link is moved by every distance specified into a 2 dimensional array.


Exercise Again, adjust the array to match the dimensions of your pattern. You can also manipulate your initial curve so that adjoining elements properly intertwine / relate to one another.




Tutorial 1.4 - Section a surface with horizontal planes

This tutorial introduces students to intersection component in Grasshopper. This example uses horizontal planes as the intersecting geometry, commonly utilised in architecture to generate floor plates from the geometry of a building envelope. We will be using this to create a jig to drape or stretch our lace pattern over. The parallel sections will form a rationalisation of a more complex form.


Exercise Reference a group of curves from Rhino into Grasshopper using a CURVE geometry component. These curves will be used as the primitive input to create the surface from and to extract the isocurves.

(PARAMS/GEOMETRY/CURVE) Add a LOFT component to the canvas and pass the CURVE output to the curve (C) input of the loft component. This will create a nurbs surface flowing between the primitive or defining curves.

(SURFACE/FREEFORM/LOFT) Add a SECTION component to the canvas. This component will solve intersection events between a plane and a brep, in this case the lofted surface, and will produce a curves and points where the intersections occur. For this component to work the planes to intersect through the surface need to be created and inputted into the component. (INTERSECT/MATHEMATICAL/BREP/PLANE) Add a BOUNDING BOX component to the canvas. Pass the lofted surface (L) output to the geometry (C) input. The bounding box creates a box around oriented geometry and will be used to specify where these intersecting planes are to occur by placing perpendicular planes along two perpendicular edges of the box.

(SURFACE/PRIMITIVE/BOUNDING BOX) To specify the edges of the box to be we will need to decompose the box into its constituent points and create lines along the desired edges. This is achieved by using the BOX CORNERS component.



Exercise To specify the edges to place the intersecting planes on lines will be created between box corners. Add a LINE between two points component to the canvas. As you connect different outputs of the ‘box corners’ component you can specify the edges of the box to be used. (CURVE/PRIMITIVE/LINE) Perpendicular frames which the planes of intersection will be located at can then be solved along the curve at specified locations.

(CURVE/ANALYSIS/PERP FRAME) To specify these locations we will create a range of numbers within a numeric domain using the RANGE component. The numbers within domain will be spaced evenly to give equal distribution of the intersection planes. The domain (D) of the component is set to 0.0 1.0 By default. By connecting a slider to the (N) input you can specify the number of steps, or number of frames. (SETS/SEQUENCE/RANGE) Pass the output (F) of the PERPENDICULAR FRAME component to the section plane (P) input of the section component and section curves through the surface will be created running in one direction.

To create section curves running perpendicular to the previous section curves copy the LINE, SLIDER, RANGE and PFRAME components. Pass different points from the BOX CORNER component in the line components until you have found to required edge.


Tuesday, July 10th

Association, Space, Mapping and Functions

Morning Seminar: At the end of this class, students will have hopefully selected a direction informed by earlier sketches/physical modelling to digitise and develop. Modelling parametrically enables the designer to explicitly inform the geometry that is generated. Explicit information can also be extracted from objects higher up the data flow. The seminar will present various approaches to associating these parameters (points, images, graphs etc) with the properties of another - in this case finally resulting in vector lines used for fabrication. This allows designs to become responsive to conditions: site conditions (body curvature), required performance (rigidity/flexibility for movement), intended viewing angles, fabrication constraints etc. Outcomes: Experiment with vectors, planes, transforms, images, functions and graphs as means for creating relationships between geometrical properties of two objects. Learn about surface (uv) and curve (t) space and how to map objects from one space to another. Discussion: Associating form with data allows architects and designers to evaluate the strengths of their designs - a reduction in cost, a gain in structural efficiency, better solar performance etc. What are other advantages to ‘materialising the invisible’? Exercises: 2.1 - Attractor Point 2.2 - Image Sampler 2.3 - Curve Attractor


Afternoon Seminar: Introduce participants to the prepared INPUT, ASSOCIATION and OUTPUT clusters. Discuss or present design ideas and identify ways to explore potential outcomes by combining and extending the prepared definitions. *Groups may be formed into themed areas of interest to enable a series of progressive prototypes. Outcomes: Putting the mornings seminar into action in personal design scenarios. Submit selected prototypes for fabrication. Excercises: 3.1 - Combining INPUT, ASSOCIATION and OUTPUT clusters 3.2 - Multiple Attractor Points Homework: Additional instruction Videos: (highly recommended) BEND 03. Association BEND 04. Data Structures Further exercises and tutorials to complete: 3.3 - Orient objects around a circle 3.4 - Move a grid of Points using a mathematical function 3.5 - Move a grid of points usign a graph 3.6 - Move a grid of points usign a random function 3.7 - Compound transformation using an attractor



Tutorial 2.1 - Association with an attractor Point

One of the most common techniques used to create an associative relationship is to use an point geometry and analyse its proximity to a set of other geometries. The set can be manipulated in numerous ways such as scaling up or down the closer they are to the point or to orient to face in that direction. The focal point of this relationship is commonly referred to as an ‘attractor’ point. This tutorial demonstrates how to set up a scaling transformation but the data created can be easily used and adapted for other scenarios.


Exercise Create a 2D surface on the xy-plane in Rhino and reference this surface into Grasshopper using a ‘Surface’ component.

(PARAMS/GEOMETRY/SURFACE) Reparameterise the surface by right-clicking on the ‘S’ input and selecting reparameterise. This will change the domain of the surface to between 0 and 1 in both the U and the V directions. With Grasshopper, it is preferable to be able to use definitions again and again in differing situations to save the time taken to create them. By reparameterising the surface the definition will work on any surface we create in the future. This will be explained further in later tutorials. To create a 2D grid of points use the ‘Divide Surface’ component. The number of divisions in the U and V directions of the surfaces domain are variable and can be specified via slider inputs. Rename the sliders by right-clicking the label. Disable the preview for the referenced surface.

(SURFACE/UTILITY/DIVIDE SURFACE) Circles will be located at the points created by dividing the surface. The ‘Circle’ component is defined by a base plane ‘P’ or location and a radius ‘R’. The radius of each circle at each grid point will be defined by its distance to an attractor point . As each point will be a different distance to the attractor point, each circle will be a different radius or size.

(CURVE/PRIMITIVE/CIRCLE CNR) Add a DISTANCE component to the canvas. This component will find the distance between the the attractor point and the grid points created by the ‘Surface Divide’ component. Add a ‘Point’ component to the canvas and reference a Rhino point in from Rhino. This will be the attractor point. Righ click on the comonent and relabel it ‘Attractor Pt’.




Pass the output of the ‘Dist’ component to the ‘R’ input of the ‘Circle’ component.

The distances between the attractor point may be too large or small to output the desired effect. The image to the right provides an illustration of the outcome when the distances between the grid points and attractor points are too large creating circles that overlap each other. The size of these numbers can be controlled by controlling the domain of the distances, or largest and smalled values.

Add a ‘Remap’ component to the canvas and connect them as shown in the image. The ‘Remap’ component, as the name suggests, allows the remapping of a domain of numbers into a new numeric domain. This enables the specification of the bounds of the domain, or in this case the minimum and maximum radiai of the circles.

(MATH/DOMAIN/REMAP NUMBERS) Add a ‘Bounds’ component to the canvas and connect them as shown in the image. The ‘Bounds’ component will determin the source domain by finding the smallest and largest number in the list. Make sure the data is flattened into one list by righ-clicking on the ‘N’ input and selecting ‘Flatten’.

(MATHS/DOMAIN/BOUNDS) Specify the new domain, or minimum and maximum, using the ‘Domain’ component. Input ‘Slider’ components for further control. Complete the definition by connecting the output of the REMAP component to the R input of the CIRCLE component. Move the attractor point around in Rhino to alter the size of the circles.



Exercise Complete the definition as shown below. The definition is composed of an INPUT (the grid of points), ASSOCIATION (the attractor point) and OUTPUT (the radius of circles located at the grid points. These elements will be reused within other definitions and can easily be copied and pasted into new definitions.

Extension: The images above illustrate the change in the pattern when the attractor point is moved in Rhino. Try moving it around yourself. Try using the data to control other OUTPUT geometry such as polygons. Can you think of other geometry it might control?



Tutorial 2.2 - Using an Image Sampler

Another good association technique is to link the properties of an image to a set of geometry. The ‘Image Sampler’ references an image from a location on your computer and can sample a number of properties from its pixels. Red, blue and green colour values can be sampled collectively or in isolation, as well as alpha (transparency), hue, saturation and brightness (most easily discerned in black and white images). These values can then be used to operate upon a like number of geometries. Having the image open in photoshop and painting with a soft edged paintbrush creates an interactive design environment where the user can essentially ‘paint geomety’ and can result in smooth variational results.


Exercise Divide a 2D surface on the xy plane into a specified number of points in the U and V direction. This INPUT can be copied from the Attractor Point tutorial.

This definition will require the grid point coordinates to located the geometry to be defined by the ‘Image Sampler’ and the UV coordinates for intput into the ‘Image sampler’.

Circles will be the output geometry for this tutorial located at the grid points created by dividing the surface. The ‘Circle’ component is defined by a base plane ‘P’ or location and a radius ‘R’. The radius of each circle at each point will be defined by the data outputed by the image sampler.

(CURVE/PRIMITIVE/CIRCLE CNR) Add the ‘Image Sampler’ component from the ‘Special’ menu and connect the UV points output from the ‘Divide Surface’,

(PARAMS/SPECIAL/IMAGE SAMPLER) The ‘Image Sampler’ comes without an image loaded. Righ click on the component and click ‘image...’ to select and image from your computer.



Exercise This can also be done by selecting ‘settings’ and setting the file path. Here the domain of the image is also set, the tiling options and what channel of informationis being sampled from the image. Ensure your image domain is set to 0.0 - 1.0 in both directions and choose ‘Clamp’ from the tiling methods.

Choose a channel to sample. This tutorial uses ‘Value (brightness)’. This can be changed at any time generating different results.

A multiplication operator with a slider is used to moderate the final amplitude value for the radius of the circles.

(MATHS/OPERATORS/MULTIPLICATION) The radius of the circles can be more accurately controlled by remapping the domain of the data output from the image sampler. Use the same remap component setup from the Attractor Point Tutorial. In this instance the source domain does not have to be specified as it was reparameterised to 0.0 - 1.0.

Extension: Try different OUTPUT components.


Tutorial 2.3 - Association with a Curve Attractor

A curve attractor works in the same way as the point attractor, generating data from the proximity of a location from the curve geometry for future use. This definition does this by using a component which finds the closest point on the curve to it which returns the distance between.


Exercise Draw a curve in Rhino over a 2D surface on the xy plane in Rhino. This curve will be used as the attractor curve. Divide the 2D surface into a specified number of points in the U and V direction. This INPUT can be copied from the Attractor Point tutorial. As in previous tutorials circles will be located at the points created by dividing the surface. The ‘Circle’ component is defined by a base plane ‘P’ or location, and a radius ‘R’. The radius of each circle at each point will be defined by its distance to the closest point on the attractor curve . As each point will be a different distance to the attractor curve, each circle will be a different radius or size.

(CURVE/PRIMITIVE.CIRCLE CNR) The ‘Surface Divide’ grid point’s proximity to the attractor curve is established by using the ‘Crv CP’ or Closest Point on Curve component. This divides the curve into points and established the distance between the ‘Surface Divide’ grid points and the closest point on the curve.

(CURVE/ANALYSIS/CRV CP) Connect the points from the ‘Surface Divide’ component to the ‘P’ input of the ‘Crv CP’ component. Add a ‘Crv’ component to the canvas and reference the attractor curve from Rhino. Connect this to the C input of the ‘Crv CP’ component.

(PARAMS/GEOMETRY/CRV) The ‘D’ output of the Crv CP component provides the distance between each grid point, and the closest point on the curve. Pass this output into the R input of the ‘Circle’ component.


Exercise To control the maximum and minimum radius of the circles at each point use the ‘Remap Domain’ components described in previous tutorials. Extension: Change the shape of the attractor curve, experiment with different OUTPUT components to create different geometry.


Tutorial 3.1 - Combining INPUT, ASSOCIATIONS and OUTPUT clusters

This tutorial will describe how to combine the INPUT, ASSOCIATION and OUTPUT component clusters in different configurations. By reconfiguring these clusters the conceptual understanding of how Grasshopper uses data is explored. In addition to replacing a cluster of a selected input, association or output components with another, these transformations can compound upon one another.


Exercise Start by uploading the previously Attractor Point definition and referencing in a 2d surface on the xy plane.

Attractor Point Definition

Open the Arbitrary Point - INPUT definition in grasshopper and copy the INPUT cluster (circled below) into the Attractor Point definition. This INPUT will find the closest point on the surface to the associated attrator points. Create some points in Rhino around or ontop of your surface and reference these into the ‘P’ input of the ‘SrfCP’ component.

‘Arbitrary Points’ INPUT

You will notice that the radius of the circles located at each closest point on the surface will be defined by the distance to the closest referenced Rhino point. This is because the previous ‘Association’ cluster is still creating this effect.


Exercise Boolean Pattern INPUT Open the Boolean Pattern INPUT definition. Copy the INPUT cluster into the previous definition and connect it up as illustrated in the image below repalcing the Arbitrary Points INPUT. The Boolean pattern INPUT manipulates the input data in a repeating pattern by keeping data when the pattern reads ‘True’ and removing data when the pattern reads ‘False’.

The INPUT pattern results in an attractor point pattern when each second circle is removed. Math Function ASSOCIATION Open the Maths Function ASSOCIATION definition. Copy the ASSOCIATION cluster (circled below) into the previous definition and connect it as illustrated in the image below replacing the Attractor Point ASSOCIATION cluster of components.


Exercise Image Sampler ASSOCIATION Open the Image Sampler ASSOCIATION definition. Copy the ASSOCIATION cluster into the previous definition and connect it up as illustrated in the image below replacing the Maths Function ASSOCIATION cluster. Now in addition to the boolean pattern, the radii of each circle is defined by the ‘brightness’ of the sampled image at that location.

The INPUT pattern results in an attractor point pattern when each second circle is removed. Rotation OUTPUT Open the Rotation OUTPUT definition. Copy the OUTPUT cluster (circled below) into the previous definition and connect it as illustrated in the image below replacing the Circle OUTPUT cluster of components.


Exercise Extrusion OUTPUT Open the Extrude OUTPUT definition. Copy the OUTPUT cluster (circled below) into the previous definition and connect it as illustrated in the image below replacing the Rotate OUTPUT cluster of components.



Tutorial 3.2 - Transform with multiple attractors

This tutorial used mathematical functions and flow control to create a single transformation created from the proximity of an object to multiple locations occupied by an attractor point. These methods will create a ‘cutoff’ distance where an attractor no longer influences the transformation and a blend of influence when multiple attractors influence a single transformation.


Exercise Create a point and a 2d surface in the xy-plane in Rhino and reference both into Grasshopper using their respective geometry components.

(PARAMS/GEOMETRY/SURFACE OR POINT) To create a 2d grid of points use the DIVIDE SURFACE component with number sliders specifying number of rows and columns.

(SURFACE/UTIL/DIVIDE SURFACE) Right-click on the ‘s’ of the surface input. Select ‘reparameterize’. This redefines the parameters used to describe/analyse/transform the geometry. In this case, it remaps the domain of the surface to be between zero and 1 in both u and v directions. The reparameterize icon will remain next to the input while this function is activated.

Use the MOVE component as the transformation that will respond dynamically to the point’s proximity to the multiple attractor points.

(TRANSFORM/EUCLIDEAN/MOVE) To remove the list structure created by the SURFACE DIVIDE component and so that every point will move independently, use the GRAFT component to put all items in their own list.



Exercise Create vectors between each of the points in the grid to each of the attractor points.

(VECTOR/VECTOR/VECTOR 2PT) The AVERAGE component finds the arithmetic mean of a set of values. This works with vectors retaining both direction and amplitude information. Use this to embed association to each of the attractor points to the transformation.

(MATH/UTIL/AVERAGE) The values passed to the AVERAGE component need to be mediated with a mathematical function so that we can set a cutoff distance to an attractors influence, a falloff in influence and overall amplitude of the move transform. Add a MULTIPLICATION operator.


Use a function component with two variables (x,y). Within this component we can set conditional statements to filter out selected data and make alterations. Use the vector length output as the x variable and create a number slider to set the cutoff value in the y input.


Use a PANEL component to enter the statement ‘if(x<y, (y-x), 0.01)’ This reads: if ‘x’ is smaller than ‘y’, then subtract the ‘x’ value from the ‘y’ otherwise make the output 0.01. Use another PANEL component to view and compare outputs (PARAMS/SPECIAL/PANEL)


REMAP the values to a domain from zero to the cutoff value.


Use another function with two variables, this time to be able to effectively scale the vector outcome to the desired size relative to the grid of points. Input the function â&#x20AC;&#x2DC;y/log(x)â&#x20AC;&#x2122; and add a numeric slider to input y.


Multiply the original vectors with the new, mediated amplitude values and use the AVERAGE component to combine the forces from the multiple attractors into one vector for each point.


Exercise In the example below circles have been located at the distored grid points. Compound associations can now be accomplished where multiple elements of geometry are defined by their association to other elements.



Tutorial 3.3 - Orient objects around a circle

This tutorial introduces ‘Orient’ and ‘Perpendicular Frames’ components to create a revolved form from an initial 2d profile curve.


Exercise Reference a profile curve from Rhino into Grasshopper.

(PARAMS/GEOMETRY/CURVE) We will use the orient tool to array the initial curve around a circle. Connect the curve component to the geometry input of the orient component. Hover the mouse cursor over the other inputs to see what the other inputs require.

(TRANSFORM/EUCLIDEAN/ORIENT) Input ‘A’ requires a plane which will be source location for the orient command. To give this plane an origin we can manipulate, we will create a point in the same viewport of Rhino and reference it into GH. Create a Point geometry component and reference the point from Rhino by right-clicking and selecting ‘Set one point’

(PARAMS/GEOMETRY/POINT) Create a plane in the YZ axis. This plane is infinite but we can assign an origin point to be the one we referenced from rhino. Then pass this plane to the orient component input ‘A’ to be the source plane.

(VECTOR/PLANE/YZ) Now create the circle to orient our curve around. Note that there are a number of components for creating a circle. Select ‘CIRCLE CNR’ which requires a centre point, a normal (vector direction) and an input radius.



Exercise Create a point from x,y, z coordinates and pass it into the centre point input for the circle. This component has default values set to zero for all inputs, so unless a variable is connected to one of the inputs, a point will be created at the origin point.

(VECTOR/POINT/POINT XYZ) There is also a default value set for the normal direction of the circle (a vector in the z direction) which we will keep. Create a number slider and connect it to the input for the circle radius. You may need to right-click on the slider and edit its properties to ensure it is at an appropriate scale for the profile curve you created earlier.

(PARAMS/SPECIAL/NUMBER SLIDER) Input ‘B’ of the orient component asks for the ‘final plane’ which the geometry will be oriented to. In this case we will create multiple planes which are perpendicular to the circle we created so that our profile curve appears to revolve around a central axis. Add a ‘perpendicular frames’ component. (Note the plural)

(CURVE/DIVISION/PERP. FRAMES) Connect these frames to the orient component to be the goal locations of the orient command.

Pframes has a default value of 10 for ‘N’ which will divide the curve ‘10’ times, creating frames evenly spaced along the circle. Add a slider to increase/ decrease this number and view the outcomes in Rhino. You can edit how large these planes appear in the view menu (view/ plane radius)




Tutorial 3.4 - Move a grid of points using a mathematical function

This tutorial introduces the use of a mathematical function to create a complex set of numerical data from a simpler range of numbers. This number set will then be used to inform multiple transformations on a set of points. This tutorial applies these transformations to a 3 dimensional grid purely for illustration purposes of the technique. It is considered more applicable to our process in 2 dimensions only.


Exercise Reference a Point from Rhino into Grasshopper.

(PARAMS/GEOMETRY/POINT) Create a 2d grid of points with the Square Grid component. The number of grid cells have default values of 5 and a cell size of 1. Add number sliders to these inputs personalise them.

(VECTOR/GRIDS/SQGRID) Use a ‘flatten’ component to remove the data structure created by the component. For more information on this topic see Tutorial 4 Data Matching.

(PARAMS/SPECIAL/NUMBER SLIDER) Connect the points from the ‘flatten’ component to the geometry input of a move component.

(TRANSFORM/EUCLIDEAN/MOVE) To affect a move transformation, the operation requires the geometry to be moved and a vector (direction and magnitude). To begin, create a unit vector in the z direction. All points should move up by 1 unit.



Exercise Rather than moving all points the same distance in the z direction, we want to use a maths function to generate difference across the moved field of points. Use a function component with 3 variable inputs (f with an x, y and z)

(MATH/SCRIPT/F3) The ‘f’ input requires an expression to solve. We will use a sine function to create outcomes which fluctuate smoothly up and down. Use a ‘panel’ component to enter the expression “sin(x+y)*z” and connect to the expression input.

(MATH/SCRIPT/F3) To create differentiation across the moved points, one of the inputs to the expression needs to be varied. Use a range component leaving the default domain as between zero and 1.

(SETS/SEQUENCE/RANGE) As trigonometric (or circular) functions such as sine, cosine and tangent are functions of an angle we will make a transformation of the range sequence as if it was in radians, to degrees.

(MATH/TRIG/DEGREES) Use a ‘list length’ component to return the total number of points in our grid. This figure is then passed to the ‘n’ input of the range component to match the number of points to the number of different vector lengths we provide the move component.



Exercise Finally, add two number sliders to the y and z inputs. This will allow for user control over the output size and range of numbers generated by the math function.




Tutorial 3.5 - Move a grid of points using a graph

This tutorial introduces sampling a range of values from a Graph Mapper and using the values to achieve transformation gradations.


Exercise Reference a 2d surface in the xy-plane from rhino into grasshopper.

(PARAMS/GEOMETRY/SURFACE) To create a 2d grid of points use the ‘divide surface’ component.

(SURFACE/UTIL/DIVIDE SURFACE) Add number sliders to the inputs of the ‘surface divide’ component and rename them.

(PARAMS/SPECIAL/NUMBER SLIDER) Connect the points from the ‘p’ output to the geometry input of a move component.

(TRANSFORM/EUCLIDEAN/MOVE) Create a unit vector in the z direction. All points should move up by 1 unit.



Exercise To create differentiation among the moved points, the magnitude of the ‘move’ vector needs to provide this change. Add two ‘graph mapper’ components. We will sample these to affect the difference in vertical movement in the x and y direction across the grid of points.

(PARAMS/SPECIAL/GRAPH MAPPER) When a graph mapper component is added the default state has no graph loaded. To change this, right-click on the component and select the select a ‘Graph Type’ from the sub-list of options.

Connect each of the ‘Rows’ and ‘Columns’ number sliders to a range component. The domain of both the range component and the graph mapper are set from 0 to 1 and therefore will sample the graph at the desired number of places. (Entering a sample value greater than 1 won’t work) Red vertical lines in the graph mapper visualises where samples are being taken.

(SETS/SEQUENCE/RANGE) Use the multiplication component to combine the sampled values.


The output of the ‘Divide Surface’ component returns all division points, but each row is grouped into a separate list of data. To match the structure of the group of vectors to their appropriate points, graft the output of the top graph mapper. For more information on data matching, see Tutorial 4 - Data Structures.



Exercise Finally, another multiplication operator is used to moderate the final amplitude values for the move.




Tutorial 3.6 - Move a grid of points using a random function

This tutorial introduces the random numeric generator component to easily create a number of iterations from random movement transformations.


Exercise Reference a 2d surface in the xy-plane from rhino into grasshopper.

(PARAMS/GEOMETRY/SURFACE) To create a 2d grid of points use the ‘Divide Surface’ component. The number of divisions in the u and v directions of the surfaces domain are variable but have default values of 10. Disable the preview for the referenced surface.

(SURFACE/UTIL/DIVIDE SURFACE) Add number sliders to the inputs of the ‘Surface Divide’ component and rename them.

(PARAMS/SPECIAL/NUMBER SLIDER) Flatten the tree structure of the list of points with a ‘flatten’ component. For more information see Tutorial 4 - Data Matching.

(SETS/TREE/FLATTEN TREE) Connect the points from the ‘flatten’ component to the geometry input of a move component.



Exercise Create a unit vector in the z direction. All points should move up by 1 unit.

(VECTOR/VECTOR/UNIT Z) Rather than moving all points the same distance in the z direction, we want to use a set of randomly generated numbers to move the field of points. Select the random generator from the ‘sets’ menu

(SETS/SEQUENCE/RANDOM) Use a ‘list length’ component to return the total number of points in our grid. This figure is then passed to the ‘n’ input of the random component. This sets the number of numbers generated, matching the number of points to the number of different vector lengths we provide the move component.

(SETS/LIST/LIST LENGTH) Attach a number slider to the ‘s’ input of the random generator. This is the ‘seed’ of the generation and changing this will change the set of numbers generated.

(PARAMS/SPECIAL/NUMBER SLIDER) The domain of the set of numbers generated is using the default values of 0 to 1 so add a multiplication component to adjust the amplitude of the vector length.




Tutorial 3.7 - Compound transformations using an attractor

This tutorial introduces the use of transformation information from components rather than the procedural geometric nature of most definitions. This allows for group and compound transformations.


Exercise This tutorial uses the definition from the earlier tutorial ‘Create a 3d Grid of Points’.

Draw a curve in Rhino and create a Point at one end. Reference these geometries from Rhino using Curve and Point geometry components in Grasshopper and rename as Crv(objects to transform) and Pt(reference). Create another point near to the 3d grid of points and reference, renaming the component Pt(attractor)

(PARAMS/GEOMETRY/POINT) (PARAMS/GEOMETRY/CURVE) Begin by creating an ORIENT component. Pt(reference) will be the source plane for this transformation. The target planes will come from the location of the points in the 3d grid.

(TRANSFORM/EUCLIDEAN/ORIENT) Graft the grid points so each point is in a separate list. Pass the attractor point to the first input of a VECTOR 2PT component.

(SETS/TREE/GRAFT TREE) (VECTOR/VECTOR/VECTOR 2PT) Create a vector from the attractor point to every point in the grid.


Exercise Create a plane at each point facing away from the attractor using the ‘plane normal’ component.

(VECTOR/PLANE/PLANE NORMAL) Connect the planes to the orient component to make them the target planes for the operation.

The second transformation will be to scale the curves. Connect the grafted points to the scale centre point input ‘c’.

(TRANSFORMATION/AFFINE/SCALE) We want to scale the arrayed curves relative to the distance they are from the attractor point but the actual distance would be too large a factor so we will remap the values to a more applicable domain. Pass the vector lengths to the component as the numbers to be remapped.

(MATH/DOMAIN/REMAP) Set the source domain of the remap component by finding the bounds (largest and smallest numbers) of the distances. As each distance is in a separate list we need to flatten the tree to a single list so they are compared and return a single domain. Right-click on the input and select ‘flatten’.



Exercise A multiplication operator with slider is used to moderate the final scaling factors that now are all between zero and 1.

(MATH/OPERATORS/MULTIPLICATION) The transform component allows us to transform a group of objects with a single transformation or multiple transformations at once.

(TRANSFORM/UTIL/TRANSFORM) Connect the ‘Transformation Data’ outputs from both the orient and scale components to a ‘Compound’ component. Note that the data contained isn’t scaled or oriented geometry but a description of the transformation.

(TRANSFORM/UTIL/COMPOUND) Pass the reference curve into a group component.

(TRANSFORM/UTIL/GROUP) Connect the ‘Group’ and the ‘Compound Transformation’ to complete the definition.


Wednesday, July 11th

Fabrication and Prototyping

Morning seminar: Discuss design feedback loops (Design, prototype, feedback) Assembly and casting of prototypes prepared the previous day. Demonstration of requirements for fabrication and how to produce appropriate files. Outcomes: First fabricated object from design process. Evaluation of prototypes so results can be fed back into design definitions to improve the final outcomes. Participants will experience the flexible nature of the modelling program to enable visualisations and fabricated prototypes in an iterative and variational design process. Understand the requirements of the fabrication machinery used for the workshop. Be able to produce a file with correct scale, sizing, colours, lineweights etc. Discussion: How might we engage with the constraints of fabrication within the design process? How does fabrication technology affect the design and production industries? How can we use the qualities of a fabrication technology as a driver for design? How can we extend the outcomes beyond the dimension of the digital fabrication technology available? Exercises & Tools: 4.1 - Isolate Contained Curves 4.2 - Offset Cell Curves 4.3 - Outline Stroke (in Adobe Illustrator) 4.4 - Remap curve pattern onto 3D surface


Data Structures and Documentation

Within grasshopper data is stored in a structured system of items, lists and trees with path information which shows a particular itemâ&#x20AC;&#x2122;s location. To apply an algorithm to a single or collection of items we must organise this structure appropriately. Afternoon seminar: Discuss analogous systems to grasshoppers data structures. View and manipulate lists using common grasshopper components. Make a tool to display the data path of items and then modify this for use in documentation. Final evaluation of designs intended for fabrication is required. Small prototypes fabricated in the morning provide feedback for revisions made to proposals. Final proposals will again be translated into fabrication files for evening processing. Jig geometry will be translated into a file ready for fabrication. Outcomes: Understand the limitations of Grasshopperâ&#x20AC;&#x2122;s data structures compared to a scripting environment. Be able to perform operations on specific items and lists of items. Recognise how structure effects the operations and outputs of Grasshopper components. Final project 1 designs will be submitted for fabrication for assembly and casting the following morning. Exercises & Tools: 5.1 Extract specific collections 5.2 Create tool to display data structure 5.3 Label a 3d model using text tags 5.4 Orient objects to a grid Additional instruction Videos: (highly recommended) BEND 05. Paths FABRICATE 07. Waffle_For a surface FABRICATE 08. Waffle_For solid geometry Further exercises and tutorials to complete: 5.5 - Draw curves through a grid of points in two directions. 5.6 - Interpolate through a list of polylines


Tutorial 4.1 - Isolate Contained Curves

For the purposes of fabrication it is necessary to extract the correct geometry from our definitions and to arrange them in an appropriate manner for the fabrication technology to be used. There are a number of considerations to be taken into account. Raw material sizes, limits to fabrication tooling beds (ie. the laser cutters used for this workshop have 900 x 600mm beds) are final physical considerations. In terms of design we can extract areas of our patterns which are the most interesting or remove problem areas. This tutorial shows how to select a series of cell curves dependant on whether their centrepoints are situated within a curve of extents. This produces an irregular edge compared to simply trimming.


Exercise The definition created in this tutorial will allow you to isolate parts of a pattern within a specified area. This will allow you to only focus on the most interesting sections of the pattern generated or to remove problemmatic or undesired areas, like the bottom left area of the pattern.

Reference/connect the pattern curves that were generated by a different process into a ‘Crv’ component. Draw a curve in Rhino that delineates the extents of the pattern that you want to isolate and reference this into another ‘Crv’ component.


Pass this bounding crv into a ‘Containment’ component. The ‘Containment’ component will test all points passed into the ‘P’ input to see if they fall within the containment curve. This component will return values we can use to sort through the pattern curves and only keep the ones we want.

(CURVE/ANALYSIS/CONTAINMENT) Pass the pattern curves into a ‘Dispatch’ component. This will split the list of pattern curves into two lists; those that are within the containment curve and those that fall outside it. This achieved via the creation of a dispatch pattern ‘P’ which will determine the pattern of the two lists created.


Exercise Now we need to create a point with which to test whether a cell is contained within the curve. Place a ‘Discontinuity’ component onto the canvas and pass the pattern curves into the ‘C’ input. This will find all the discontinuities, or vertices of the curves.

(CURVE/ANALYSIS/DISCONTINUITY) Pass the ‘P’ output into the ‘Average’ component. This ‘averages’ the cartesian coordinates of the discontinuity points and returns a central point. We will use these as the test points of the ‘Containment’ component.

(CURVE/ANALYSIS/CONTAINMENT) The Containment component returns three values: 0 if the point is coincident, 1 if the point is within the test curve and 2 is the point is without. For the dispatch component to work for us we need to create a boolean pattern (True/False). We can use zeros and ones in there place however so we will use a function component to filter the results. Make the function a conditional statement where 2’s become 0 (False) and all other numbers 1.


Pass this list of 1’s and 0’s to the Dispatch component as the dispatch pattern. The ‘A’ output will pass out the curves whose centrepoints occur within your referenced curve.


Tutorial 4.2 - Offset Cell Curves

In the case shown previously, additional transformations need to be applied to achieve geometry suitable for fabrication to create a mold. If we want a final cast that resembles a network of lines, we need this initial cast to be the same; the lines must have thickness. There are two approaches shown here, the first is to offset cells of a grid inwards. This is not appropriate for all geometries however and creates some annoying errors in some cases. A second method, utilising Adobe Illustrator is shown where line â&#x20AC;&#x2DC;outlinesâ&#x20AC;&#x2122; are created.


Exercise In order to create a pattern that can be laser cut the curves of the pattern must be offset to create a boundary. This tutorial will provide the steps to achieve this.

Reference or pass the pattern curves into a ‘Curve’ component.

Place an ‘Offset’ component on the canvas passing the pattern curves to the ‘C’ input. Connect a slider to the ‘D’ input to specify the offset distance. Connect an ‘XY PLane’ component to the ‘P’ input to specify the plane the offset it to occur.

(CURVE/UTILITY/OFFSET) The offset distance may need to be negative for the correct offset direction. To set the ‘D’ input as a negative right-click on the ‘D’ and select expression. Write ‘-D’ into the expression editor and press the green tick.


Exercise To generate an outline for the entire pattern all the curves need to be connected using the ‘Region Union’ component. Use the same offset setup for the pattern curves when they have been unioned together.

(INTERSECT/SHAPE/REGION UNION) To smooth the corners of the pattern add a ‘Fillet’ component and alter the radius of the fillet via a slider until the desired outcome is reached.

(CURVE/UTILITY/FILLET) The offset pattern can be further distored by adding an attractor point ASSOCIATION cluster and connecting this to the fillet output as illustrated.

The dimensions of the desired pattern can be determined by drawing the curve outline in rhino and trimming/deleting th eexterior or using the Isolating Contained Curves definition.


Tutorial 4.3 - Outline Stroke (in Adobe Illustrator)

This tutorial shows how to create stroke outlines in Illustrator. As there is a required migration between software packages, this is also documented.


Exercise To process pattern curves in Illustrator, firstly we need to export the curves from Rhino. Select everything you want to work on and while you have the appropriate viewport active, use the ‘Export’ command in Rhino. From the ‘Save as type:’ drop down menu, select Adobe Illustrator, (with the file extension .ai).

It is important that we preserve the scale from our model (assuming the input surfaces etc were created with this in mind). So set the output scale at 1 to 1. If this is not an option, then you are not exporting form an orthographic viewport. For obvious reasons, this will not work from a perspective viewport.

When you open the file in Illustrator, nothing may appear. Make sure you zoom right out as often the geometry is not in the default view. Move the geometry over the central artboard and make the artboard larger than all your curves by going to File>Document Setup and clicking on ‘Edit Artboards’. Click the arrow on the left hand menu to complete.

Select curves and alter lineweight to appropriate value. This is how thick the final cutout will be so be mindful of how strong it needs to be.


Exercise Go to Object>Path>Outline Stroke.

Note that now each previous stroke is now composed of two â&#x20AC;&#x2DC;outlinesâ&#x20AC;&#x2122;. This is a step in the right direction but if fabricated now it would all fall to pieces.

Go to Window>Pathfinder. You may already have this in your righthand side toolbar, but if not this will load it.

Unite these regions by clicking on the button on the far left.

Once complete, save the file as an Illustrator file (extension .ai) and exit. Illustrator files can be opened directly by Rhino or imported back into your existing file.


Exercise These operations can be used in many ways to create a number of effects. Experiment with combining closed curves into larger silhouettes. Small connection points may cause the fabricated object to distort with respect to its material properties in interesting ways.

Simply outlining all objects results in a file applicable for fabrication. Be aware that disconnected curves will fall off and should be removed.


Tutorial 4.4 - Map Curve Pattern onto 3D Surface

The intent of the first design project is to create a 3 dimensional lacework but we have restricted ourselves to 2 dimensional CNC machinery. While there are a number of ways to exhaustively simulate, as accurately as possible, the physical outcome we can also approximate quite quickly by remapping our patterns from a flat initial surface under the pattern to a more complex 3 dimensional one. It is important to note however that the pattern is mapped between the domains of the surfaces and therefore will stretch to the new surface. To be an accurate representation the target surface must be of the exact same dimensions but will serve for our initial purposes.


Reference the initial pattern crvs, the initial surface and the target surface into geometry components in Grasshoper. Pass these into the â&#x20AC;&#x2DC;Map Srfâ&#x20AC;&#x2122; component.



Tutorial 5.1 - Extract specific collections (items, branches)

This tutorial introduces how to extract specific items and collections (branches) from a data tree.


Exercise Reference a 2d surface in the XY-plane from Rhino into Grasshopper. and create a 2d grid of points use the ‘divide surface’ component.

(SURFACE/UTIL/DIVIDE SURFACE) Use the PANEL component and the PARAM VIEWER to view properties of the data output from the divide component. Not only can we see the cartesian coordinates of the division points but also that they are grouped into lists (or branches in GH tree talk). In fact each ‘row’ is on its own branch, making 6 branches each containing 4 points.

(PARAMS/SPECIAL/PANEL OR PARAM VIEWER) To extract items from a list we use the LIST ITEM component and its index. The index of each item is shown on the left of the panel and is like a count but like most numeric systems in the digital realm, begins counting from zero. Using a slider and comparing the panel outputs extract the first item with a zero index, second with one and so on.

(SETS/LIST/LIST ITEM) Another way to extract pieces of data from a tree is to extract an entire branch. This is more complicated than just taking an item from a list as it requires the complete path describing it.

(SETS/TREE/TREE BRANCH) The PANEL and PARAM VIEWER show that the address of the first branch of our tree is {0;0;0}. This is the syntax of the path structure we must use to retrieve the branch and the data it contains.


Grasshopper has a number of instances of translation logic with which when something is passed to an input, the program tries to convert it into the correct data type for the component. In this instance, we pass the PARAM VIEWER to a PATH primitive component it converts the strings

Like previously, use the LIST ITEM component to extract one of the data paths. A number slider makes this easily changeable.


Use the path retrieved with the LIST ITEM as the path input into the BRANCH RETRIEVAL component.


(alphanumeric characters) to data paths. We now have a list of all of the branch data paths.


From this branch we can extract more specific data, again using the LIST ITEM component.


Alternatively, now we have this amount of specific item path and location information we can retrieve a single item in one step using the TREE ITEM component.




Tutorial 5.2 - Create tool to display datastructure

This exercise will demonstrate how to convert grasshoppers Data Structure objects to Strings (text) for displaying in the rhino viewport. It will introduce concepts of string operations such as concatenation that will be integral to later tutorials.


EXERCISE The exercise will produce a definition that works with any type of geometry, but as an example create several points in rhino and reference them into a POINT component. To remind ourselves that the definition will work with other geometry, connect the points to a GEOMETRY component. Finally, connect the output of the geometry component to a PARAM VIEWER to display its tree structure.

(PARAMS/SPECIAL/PARAMVIEWER) Next we use a neat trick in grasshopper to extract the path objects from the viewer. If you connect the param viewer output to a PATH component, the path component will contain a list of all of the branches in the tree. We then GRAFT this list, to ensure that for each branch in our datastructure, we can still map a list of indexes to it (This sounds confusing - it will become more clear later in the tutorial). Finally we connect our grafted list to a PANEL component, which will convert any input to Strings (text). This gives us half of the structure information we need - telling us which branch our geometry is on. We still need to find out which index our geometry is located at on each branch.


List indexes cannot be created using clever tricks like with the param viewer, so to find the index of the geometry, we need to create a new list that mimics the length of the one we are trying to display. Use a LIST LENGTH component to calculate the total number of items in a list, then use the SERIES component to create a series of numbers from 0 to the total number of items in our list. The series component generates decimal numbers, which in this case are superfluous to our needs as we are only counting indexes and therefore only need whole numbers. Connect the output of the series to an INTEGER component to convert the decimal numbers to whole numbers.



EXERCISE Now we are going to use a function component in order to present our data in a more readable way (we are going to do the fairly menial task of adding a space to the beginning of each of our strings). This joining of one string (“ “) to another (the string representing the index of our geometry in a list) is called concatenation, and using the “&” syntax in a function component is one way to achieve this in grasshopper.

Now, as a means of demonstration, we can use a CONCATENATE component to join our path information string to our list index string. You could also use an F(2) component and use the “&” syntax to concatenate the x and y inputs to the function. Likewise you could also do it with a script component...



Connect the output of our INTEGER component to a panel to convert the numbers to strings. Then create a F(1) component, and connect the strings to its x input. Create a panel (shown in grey) to define the function for the component to run, and input (“ “ & x) without the brackets.


EXERCISE Finally, we are going to display this structure information in the rhino viewport using a TEXT TAG 3D component. Drop one of these onto the canvas and take a look at its inputs. Most importantly it requires a location (L) for the text - we don’t necessarily have this yet, and the text to display (T) which will be the output of our concatenated strings. Connect this to the T input.


To produce a point to display our structure at, we are going to use some bounding box components. We do this so that if we are trying to display data structure of more complex objects (such as curves or surfaces), the structure information will always be displayed in the corner of the geometries bounding box. Create a BOUNDING BOX component to find the bounds of an object, then create an EVALUATE BOX component to find the point at (0,0,0) in ‘box space’. This will be one of the corners. Lastly, we can connect out PT output from the evaluate box component to the L input of our tag component. Depending on the size of your model you may need to specify a different size for the text using the (S) input.




Tutorial 5.3 - Labelling a 3d model using text tags

Within grasshopper geometry is stored in lists with path information that helps us to identify, extract and manipulate specific items. We can use this organisation to label parts on a model and add this to documentation produced for fabrication to aid assembly. This tutorial introduces 3d text tags.


Exercise This exercise uses geometry generated using the Waffle_Type2 (For Solid Geometries) on a sphere.

Pass the curves from the waffle cluster into two new curve components. Right-click the components and select ‘Internalise Data’. Note that the input wires have disappeared. This handy option means we can now disable all the preceding components by selecting them and typing CTRL+E.

(PARAMS/GEOMETRY/CURVE) To label geometry in our display we use the Text Tag components. There are two of these but the ‘3D’ option lets us specify the size of the display text; handy when we want to use this definition repeatedly to label geometry of many sizes.

(VECTOR/POINT/TEXT TAG 3D) The AREA component calculates area properties of BREPS, meshes and planar regions, but handily also returns the centrepoint. We will use this as the location of our text tags.

(SURFACE/ANALYSIS/AREA) We also need to supply the text (data type ‘string’) associated with each location point. A series component will effectively ‘count’ for us.



Exercise Use the LIST LENGTH component to define how many numbers we want the series component to produce. Right-click on the ‘S’ input and select ‘Set Number’ option. Set this as 1. Leave the default value for the step size (input ‘N’) as 1. This means we will count up from one in steps of one.

(SETS/LIST/LIST LENGTH) The series component creates floating point (decimal) numbers with precision to one decimal place. As we only want whole numbers we can get rid of this extra information by passing the data through an INTEGER component.

(PARAMS/PRIMITIVE/INTEGER) Use a NUMBER SLIDER to define the text size.


As we have geometry oriented in two directions we can also add additional information to the labelling to reflect this. We use the CONCATENATE component to join two strings together. In this case we will add the character ‘A’ (supplied in a panel).

(SETS/STINGS/CONCATENATE) We can then replicate this process, this time with B as the concatenated character.



Tutorial 5.4 - Orient objects to a grid

As part of the process of preparing geometries for fabrication it is often necessary to array the objects into a grid of evenly spaced geometries. This aids the sequencing and labelling procedures of parts pre and post manufacture.


Exercise This exercise uses geometry generated using the Waffle_Type2 (For Solid Geometries) on a sphere.

Pass the curves from the waffle cluster into two new curve components. Right-click the components and select â&#x20AC;&#x2DC;Internalise Dataâ&#x20AC;&#x2122;. Note that the input wires have disappeared. This handy option means we can now disable all the preceding components by selecting them and typing CTRL+E.

(PARAMS/GEOMETRY/CURVE) Pass both curves into a single CURVE component and flatten the data structure into a single list. This is then input as the geometry to an ORIENT component.

(TRANSFORM/EUCLIDEAN/ORIENT) The target planes will be created from a grid of points. Use a rectangular grid component and create number sliders to manipulate the size of the grid cells. A rectangular grid is often best as it gives dimensional control in both directions to improve the efficiency of the layout.

Use the AREA component to find the centrepoints of the grid cells.



Exercise In grasshopper there are a number of instances where the program can translate how it recognises a geometry depending on what it requires. To illusatrate, pass the curves to a PLANE component. As it is planar, grasshopper will recognise it as a vector plane.

(PARAMS/GEOMETRY/PLANE) The planes that the curves are translated to are oriented in different directions and overlap so some more work is needed.

We will define the PLANE ORIGIN with the centrepoints of the curves, again found with the AREA component.

(SURFACE/ANALYSIS/AREA) Some adjustment of the size and number of grid cells will be required to efficiently layout the geometry.



Tutorial 5.5 - Draw curves through a grid of points in two directions

This tutorial introduces interpolation of points and some of the functionality of the path mapper to invert a data matrix.


Exercise This tutorial uses the definition from Tutorial 04 - Part 02, Multiple Attractors.

After the move transformation there are 144 branches with 1 item in each. To draw a polyline through each row of points we need to return the data tree to the structure it had after the surface divide component, where each row of points was contained on its own branch.

(PARAMS/SPECIAL/PARAM VIEWER) The PATH MAPPER component is used to manipulate data structures through lexical operations. Double-click the component to open up the expression editor.

(SETS/TREE/PATH MAPPER) The source notation is the existing path structure and should match what is shown in the param viewer with variable alphabetic placeholders. Ie {0;0;1;1} becomes {a;b;c;d} or {g;h;i;j}, Which placeholder letters used does not matter. If you are using the data within the lists themselves to manipulate the structure, this should also be included. ie. {0;1} N = 4 BECOMES {A;B}(i) The target notation uses the same lexical placeholders to represent the intended structure. Changing the order of and removing placeholders will change how data is grouped into branches.


Exercise Looking closely at the param viewer diagram, we can see that the rows of points are grouped when the data path has three placeholders before being split into individual branches.

As discussed earlier, the source notation needs to match exactly with the path shown in the param viewer but with placeholders. Enter {a;b;c;d}(i) as the source code and {a;b;c} as the target. Note that semicolons must be used as the separators and curly brackets (or braces) enclosing the path rather than parentheses.

The PARAM VIEWER should now show the list length as being the number of points in a row as specified with the column slider for the DIVIDE SURFACE component plus one.

Use a POLYLINE COMPONENT to create a curve through each list of points.

(CURVE/SPLINE/POLYLINE) A common request is to change the direction of these polylines without extensive additional work. By including a placeholder to represent the index of data items in parentheses we can sort like indices into lists (ie items with index â&#x20AC;&#x2DC;0â&#x20AC;&#x2122; into the first list and so on) SOURCE CODE - {a;b;c}(i) TARGET CODE - {a;b;i}(c)


Exercise Note that now we have a list of points on each branch the same length as the number of branches we had previously, and vice versa.

Use a component to generate a polyline through each list of points.




Tutorial 5.6 - Interpolate between a list of polylines

Interpolation involves creating new data points within the range of a discrete set of known data points. Here we will create these points between known discontinuity points and use them to recreate â&#x20AC;&#x2DC;betweenâ&#x20AC;&#x2122; polylines which blend between two input polyline shapes..


Exercise Create a number of curves in Rhino and move them so that they are some distance apart. Reference them into Grasshopper using a CURVE geometry component. Rename the component as keyframe curves.

(PARAMS/GEOMETRY/CURVE) Rebuild the curves as polylines. To do this, use the REBUILD component and ensure the degree (input d) for the new curve is set to 1. Either attach a integer component set to 1 or right-click the letter and go to â&#x20AC;&#x2DC;set integerâ&#x20AC;&#x2122;. Use a number slider to set the resolution of the new curve (number of control points).

(CURVE/UTIL/REBUILD) To create the interpolation points between succeeding curves we need to be able to compare a curve to its neighbour. To do this we need to make a list from the original with all items minus the last, and one with all items minus the first. Use two SHIFT LIST components with the shift offset (input S) set to -1 and +1 respectively. Wrap (W) must be set to false.

(SETS/LIST/SHIFT LIST) Find the points of discontinuity along each of the polylines.

(CURVE/ANALYSIS/DISCONTINUITY) To create the between-points, we need to move the first list of points in the direction of the second using a MOVE component.



Exercise Create a vector between lists of points using VECTOR 2PT.

(VECTOR/VECTOR/VECTOR 2PT) Graft both the list of points and the list of vectors.

(SETS/TREE/GRAFT TREE) Rather than a single vector the length of the distance between the points we want a number of between points, so use a MULTIPLICATION operation to create vectors a fraction of the initial magnitude.

(MATH/OPERATOR/MULTIPLICATION) Use a RANGE component with default domain (zero to 1). ‘N’ input, controlled by an integer number slider, will now control how many points are interpolated between curves.

(SETS/SEQUENCE/RANGE) Connect the range of vectors to the MOVE component and view the points created.


Exercise Connect the geometry output of the MOVE component to a PARAM VIEWER. This will display how the data is structured both in text form or graphically using a ‘tree’ diagram. Double-click the component to toggle between these views. The data is arranged in a number of lists, (or branches in GH tree-talk) the number being the product of the number of control points we assigned to the rebuilt curves and the number of

spans between curves (we have used 3 curves in this example ie. 9Points x 2spans = 18branches). The number of items on each branch has been informed by the number of steps we assigned our range component (Note. 6 Steps = 7 values including 0.0)


As each branch contains 7 items (n = 7) we know that the points are arranged in branches related to the original points of discontinuity and the range of vector amplitudes we supplied the move component.

Use a POLYLINE component to confirm this as it will create a straight interpolation through the points in each list.

A common request is to be able to change the direction of these polylines without extensive additional work. Using the PATH MAPPER we can manipulate how the data is structured. Doubleclick the component to open up the expression editor.

definition we want the indices of the items in each list to be sorted into their own lists. All the items with index ‘0’ in their own list and so on.


Enter {a;b;c;d}(i) into the source notation and {c;i}(d) to the target

(SETS/TREE/PATH MAPPER) The source notation is the existing path structure and should match what is shown in the PARAM VIEWER with variable alphabetic placeholders. Ie {0;0;1;1} becomes {a;b;c;d} or {g;h;i;j}, The placeholder letters don’t matter. If you are using the data within the lists themselves (as we will next) to manipulate the structure, this should also be included. Ie. {0;1} N = 4 becomes {a;b}(i) The target notation uses the same lexical placeholders to represent the intended structure. To flip the direction of the polylines created in the


Exercise Connect the moved points to the input and then onto the polyline. The data matrix should now have been flipped.


Datatree Resources

Understanding how to access and manipulate data is essential to use Grasshopper as an effective design tool. We highly recommend looking at additional external resources to help aid your understanding of its nature and techniques to control it.

TU Delft wiki page - Pretty good description of the way grasshopper operates on data and the differences between a visual programming environment and scripting. Modelab primer files - Grasshopper definitions available for download that outline the functionality of some of the common list and tree manipulation components. Pathmapper Help Thread - Discussion on the grasshopper forum with some very useful images and explanations of how the pathmapper works.


Thursday, July 12th

Project 1 Construction

Morning seminar: At the beginning of this class, participants will received the fabricated components of Project 1 casting moulds. These will be assembled during the seminar and finally cast. Outcomes: Fabricated designed object for each participant as a result of an iterative design process informed by previous prototypes. An understanding of the opportunities and limitations of this design process. Discussion: How did you find this process? How can it be used to improve past, present and future processes and projects? What is lost or gained in the process?


Analysis and Response

During the research undertaken exploring the material possibilities for the workshop, digitally generated patterns were cast as networks. This opened further avenues of speculation and exploration including how such networks can respond and be generated from rule based systems such as structural requirements or contextual data. Early prototypes instigated speculation on wearable objects and workshop projects intend to contribute to recent work by others by investigating how pattern networks interact with the physiological systems of the human body (such as the printed garments Neri Oxman) or as purely decorative speculations without being subservient to the traditional techniques of dart, pleat and seam to achieve form (works by Iris van Herpen with Daniel Widrig, and Jorge Ayala). To access this information a workflow was developed with meshes generated from rigged figures; those used for animation that can be posed while a skeletal â&#x20AC;&#x2DC;rigâ&#x20AC;&#x2122; where forward and inverse kinematic relationships aim to avoid abnormal posturing. A series of meshes were taken from staged movements to be analysed and compared to generate a data set. This data can then be used to create informed relationships between qualities of the pattern network. Afternoon seminar: Demonstration of the analysis and association process. Participants can elect to use the generated data set to further explore their previously generated pattern or speculate on new designs. Outcomes: Understand how algorithms can produce complex designs that emerge from simple rules and design constraints. Develop a methodology for evaluating the strength of the chosen algorithm. Discussion: Should all designers be able to code? How do we translate design complexity to fabrication simplicity?


Friday, July 13th

Formal Simulations

One of the main subjects of the research agenda was to explore methods to fabricate the patterned and complex doubly curved surfaces of the virtual world. This seminar will be based around demonstrations of a workflow developed for the workshop which employs a particle based physics simulation which is used to distort an input piece of geometry in a way that is replicatable in a fabrication process. Morning seminar: Demonstration of the formal simulations and further links between live data set and pattern networks. Introduction to the 3rd party plugin Kangaroo, developed by Daniel Piker. Participants can run simulations on their own surfaces and with the aid of instructors speculate on future design outcomes. Outcomes: Specifications for the locations of anchor points and obstructions (size and height)within the jig for large scale casts. Discussion: What are the repercussions of this style of form finding? How could this be taken further? How might designing with Daniel Piker’s ‘pseudophysical materials’ facilitate a new design process?


Documentation and Discussion

Afternoon seminar: At this point in the workshop most of the design and fabrication constraints will have been discussed and explored through a series of digital and physical prototypes. Unfabricated designs can still be developed and images generated for a final presentation. The workshop will wrap up with the collation and informal presentation of the work produced during the week and the unveiling of the final cast for inspection, discussion and documentation. Outcomes: A final designed cast which illustrates knowledge gained throughout the research and workshop explorations.



Tutorial 9 - Convert curves to spring objects REQUIRES KANGAROO PLUGIN

This exercise will demonstrate how to extend grasshoppers â&#x20AC;&#x2DC;iterativeâ&#x20AC;&#x2122; capacity using the Kangaroo Physics plugin. We will learn how to convert nurbs geometry to Kangaroo Force objects for input into the physics engine, and how to run, pause and reset the simulation.


Exercise We begin by referencing some curves drawn in rhino (or created in some other way using grasshopper) into a curve component.

Kangaroo springs are defined by two particles whose attraction to one another is a product of the distance between them (REFER TO THE KANGAROO MANUAL). What we want to do is convert our nurbs curve to a series of straight segments of equal length. To do this we use the DIVIDE LENGTH component, and use a number slider to parametrically set this even length. Next we connect the resulting list of points to a polyline component to create the faceted curve.

(CURVE/DIVISION/DIVIDELENGTH) Next we EXPLODE the polyline to get the individual line segments. We could just as easily create these segments using a combination of shift list and line components - it is up to you. Next we make sure that we have not accidentally produced any duplicate lines (this will break kangaroo) using kangaroos REMOVE DUPLICATE LINES component, and connect the output to a line component for ease of use later.

(CURVE/UTILITIES/EXPLODE) (KANGAROO/UTILITIES/REMOVEDUPLICATELINES) Now lets add the KANGAROO PHYSICS component and take a look at its inputs. Flatten the FORCE OBJECTS input, as kangaroo only accepts single lists of force objects - these we will create in a minute. The component also has inputs for anchor points - points that remain fixed, specific settings, geometry, and a reset toggle. Connect our line component to the geometry input, and create a new BOOLEAN TOGGLE to turn the simulation on and off.



Exercise Add a SPRINGS FROM LINE component to the canvas. Connect our lines to the Connection input - this will tell kangaroo how construct the springs. If we also connect the lines to the Rest Length input of the springs component, kangaroo will use the Length of the line as the rest length. This simulates rigid behaviour as the two ends of the spring will attempt to maintain the same distance apart throughout the simulation.

If we connect a number to the rest length input that is LESS than the original length of the spring, we will be simulating tensile behaviour (elastic bands, stockings, membranes etc). Lengths over the original length cause networks to explode and reorganise. For now, we are not interested in the remaining inputs, so connect the output from the spring object to the force objects input of the kangaroo component.


Lastly we are going to anchor the end points of our original curves to prevent the springs flying all over the place. To do this we use an END POINTS component, with a REMOVE DUPLICATE POINTS component to avoid overlapping points that would otherwise break the simulation. We can connect the points to the ANCHOR POINTS input of the physics engine.

Now we are ready to run the simulation. We want to see Kangaroo continuously update, so to do this create a TIMER component, right click it and set its interval to 20ms, then drag and drop from its on/ off indicator on the right of the component onto the Kangaroo Physics component. This makes sure that the timer only updates the physics engine, not everything else in our definition.


The timer can make everything run VERY slowly, so you can turn it on and off in the windows task bar if something goes awry. You can double click your toggle to set it to False in order to start running the simulation. Setting it to True will reset. Our original curves are now springs - try moving a control point in rhino and see what happens while the simulation is running.



CAST workshop manual  

Manual for the EXLAB workshop run at the National Institute for Experimental Arts (NIEA) at the College of Fine Arts (COFA) in Sydney, July...

Read more
Read more
Similar to
Popular now
Just for you