3. Computer-Controlled Cutting

As the assignment is to work with parametric design I wrote down what variables we were going to work with.

In Grasshopper I put all my variables on the far left so I could easily tweak them and try them.

Global variables

Thickness of the material I’d be cutting (which controls the width of the notches)
Depth of the notches

For the circular pieces

Radius
Number of notches

For the living hinge

The total width and height of the piece
The distance between the hinges
The length of the hinges cut
The number of hinges (minimum of 5 in total)

Connecting pegs

Width and height

Ok, let’s type all these variables into sliders, roughly guessing what we need.

Adding the variables

The Number Slider component

Simple double click with a number creates a slider by entering a number. If you enter 2, it creates a range from 0 to 10. If you type in 0.45 it creates a slider from 0 to 1 with 2 digits after the decimal. In many cases I right-clicked on the Slider component and clicked Edit.

That allows you to change the settings of the slider, to add or remove digits after the comma, change the minimum and maximum value of the range.

Starting with the circular piece

The Circle (Cir) Component

Double-click and type in Circle, make sure to choose the one with the orange background, as that is an actual circle. The black icons are holders for collections of objects.

Drag the radius variable to the Radius (R) input.

Creating a rectangle for the notch and copying it around the circle

I started creating a Rectangle for the notch (again, make sure to use the component with the orange background), setting an X and a Y to determine its size.

Then moving creating a Polar Array (ArrPolar).

Then trying to place it by using a Move component on the X axis.

And the same on the Y axis.

Actually there’s a better way to do it… Horizontal Frames (HFrames) component

I asked Arman to help and he pointed me to a Horizontal Frames (HFrames) rather than using Polar Array, which when being plugged in with the Circle creates a local plane to work from, with its own origin. There you can build the Rectangle as you wish. Let’s try it.

The HFrames takes in a Curve (C) input, to which we plug in the Circle, and a Count (N) input, to which I plug in the # of notches variable.

I was giving the rectangle a width and height, and then I was trying to move it up or down to align with the center of the circle, but it didn’t work.

Once again Arman came to the rescue and explained how with the Domain component you can set two values as the minimum and maximum value for the size of the Rectangle, in relation to the HFrame.

The Construct Domain (Dom) component

Having a variable for the width and height of the notch, I had to do a Division by 2, and plug in that value to the Maximum (B) input of the Domain.

I now need to feed it the Minimum value, which is the same value but its negative equivalent. How to do that? Plug the value of the Division above to a Negative component, and then plug its output to the Minimum (A) input of the Domain.

The result of Domain is then plugged into the X of the Rectangle component.

Note //this technique is used multiple times in the project, so I won’t explain it everytime, I’ll just mention “the Domain technique”.

As for the Y value of the Rectangle, it simply is the depth of the notch (just realised I miss named the sliders).

Wondering how to cut the notches out of the circle

Ok… we have the circle, and rectangles that go around it. Now I want to cut out those rectangles out of the circle.

How to do that… *Arman the Grasshopper wizard*

“Armaaaaaaaaan?! How do you do… things?”
“Oh, yeah, it’s simple, add a boundary to the circle then just do a surface split with the rectangles. Finally sort the faces by area with the sort list, list the item and get the last index, apply a simple brep deconstruction to them, grab the edges and that’s it.”
“...”
“What?”

He explained to me step-by-step and that actually helped me a lot understanding Grasshopper in general.

With Grasshopper you have to see everything deconstructed to the simplest… it’s not a rectangle, it’s 8 vertices, 8 edges and 8 surfaces. If you want to manipulate them you have to filter them with different modules.

Back to trimming the circle with the rectangle, let’s explain it step-by-step.

The Boundary Surfaces (Boundary) component

Double-click and create a Boundary Surfaces component which creates a surface out of Edges, in this case the Edge of the Circle. That’ll allow us to have something to subtract from later, in this case the rectangles/notches.

Tip: Press Space to show a quick menu, and from there you can Enable and Disable Preview to keep the essentials in Rhino.

The Surface Split (SrfSplit) component

Next you have to split the newly created surface with Surface Split, and Grasshopper describes it nicely with “Split a surface with a bunch of curves”.

It takes in two inputs: S, the Surface to split, in our case the Boundary Box, and C, a list of Curves to use to do the splitting. The output of this component is F, a list of Fragments, in other words a bunch of surfaces.

Note //You can check the result of any component with a Panel component by doing Double-click + //.

That means that now the Circle is broken down to multiple surfaces of different areas. Visually you can tell it’s x amount of surfaces of equal area (created by the rectangles), then one big surface which is the rest of the circle. We want to get that big surface and extract its edges into one curve.

That calls for a few steps.

The Area component, combined with the Sort List (Sort) component

As we said, Surface Split outputs multiple Fragments, aka Surfaces. We want to get their Areas and Sort them into a list. We only want to extract the surface with the biggest area, so it’ll be either at the start or at the end of the list.

Let’s add the Areas component and plug in the Fragments from the previous step to get a list of the areas of the surfaces.

That list can then be used as a Key for the Sort List component, which puts them in order from smallest area to biggest. But first you also need to input what you want to sort in the Values A (A) input, so let’s drag the Fragments from the SrfSplit component.

The List Item (Item) component

As all the areas from the rectangle are equal and obviously smaller than the rest of the circle, the surface of the circle is at the end of the list.

To pick that last Item of the list add the List Item component and for the Index (i) input, input -1.

Note //you can use the Panel component to input specific values. Double-click // -1.

The ouput of the of the List Item component is the biggest surface. We now want to access its Edges.

The Deconstruct Brep (DeBrep) component

Input the result of the previous step to the Deconstruct BRep component, which outputs F, E & V, or Faces, Edges and Vertices respectively. In this case we want to take all its Edges.

P.S. Before using the Sort List, I had tried to feed in the value of the Area component to the DeBrep, which didn’t work as it expects a geometry, not a number.

The Curves (Crv) component

Finally add a Curve component, input the Edges from the previous step and here you are! A continuous curve tracing the outline of the circle with notches in it.

Now, onto the connecting peg.

Connecting peg

After the previous step, the connecting peg is pretty straight forward.

Create a rectangle and define its width and height.

Create another rectangle that has a width defined by the notch depth variable and a height defined by the thickness of the material.

Using the Domain technique align to the right (or left) of the main rectangle, and then mirror it to the YZ plane.

Using the same technique as above with SrfSplit, Area, Sort Items, List Item, etc. pick the biggest surface, Deconstruct it, grab the edges, and here you are, a curve to cut.

The living hinge

Now to the challenging part, creating the living hinge.

My plan for creating the living hinge was to have a line in the middle, like you see in the designs, then create the interchanging pattern on one side and then mirror it to the other side… then somehow copy that pattern over… before doing the mirroring… ok let’s see about that when we get there.

P.S. the science behind living hinges

Creating the base of the hinge

To start, as always, create the base of the hinge, which is just a rectangle and set its width and height with the variables we defined using the Domain technique.

Creating the first slit of the living hinge

I’m going for the basic interchanging pattern, so I need to create points that I will then join into a line. This step is all about placing the points in specific coordinates, relative to the height of the living hinge.

I created a variable called Slit Length (how long the slits are) which I then subtract from the Height variable after dividing it by 2. That positions the point in the Y axis.

I can then Mirror it to the XZ plane.

And connect those points into a Line (Ln) component.

Creating the second, shifted Line

The interlocking pattern is built by adding a point with a Y value of Hinge Height divided by 2, which puts it on the edge of the hinge.

Then another point with a Y value of the Hinge Height divided by 2, minus the Slit length divided by 2.

That gives a line that goes from the top of the hinge down. Both of them has is moved on the X axis by the Slit Distance.

Again, mirror it on XZ plane and plug these two points into a line.

Creating the same line as in in the center

Create the same line as the one in the middle, but change it’s X value to twice the Slit Distance.

I added the three lines created into a Line Collection module as I’m planning to use that collection to copy it over.

Copying over the lines x amount of times

Now, it’s time to copy the 3 previous lines we created. I tried by doing Duplicate Data (which has a funny icon).

I had to ask the good ol’ Arman to help with it again, because I was getting lost…

- “Eaaaassyyy. Basically you want to know the width of the living hinge slits, right? So then you can move them x times by that width. So, you create a bounding box of all the lines, then deconstruct it so you can get the edges… yeah? Then measure them with Length, do that thing we did before by sorting it then picking the shortest value, which will be the distance between the two slits. Get that distance, multiply by two (because otherwise they are just touching each other rather than being separated). Then you connect to Series module which allows you to repeat a component a certain amount of times… that component take in the number of times you want to repeat it, and as well the amount, which is the 2*width we just calculated”... ok so you want to move it on the X axis, so add an Unit X, plug that into the Move component… wait it’s being weird… Ah yeah, Graft the input… here you are! That’s it. Easy right?”
- “Uuuuuh, yes, I’ll go through it and understand later”.

Later, to myself …
- “Why are we trying to calculate the width of the two slits when I’m giving them explicitly through the width variable…”

alt_text

Still, it was interesting to learn about these new components, so here’s the long way to get the same result.

Creating a bounding box of the lines

This allows us to work with the pair of hinges’ slits (the 3 lines) as one object, therefore allowing us to get it’s Edges, Surfaces and Vertices .

The aim here is to get the width between these slits (which were set in the width variable). To get the width you Deconstruct (BRep) the Bounding Box that we created and use it’s Edges output.

We use the Length component to get the length of the Edges, and then use that to sort them to get the 2 smallest Edges first (the width) and then the 2 biggest Edges second (the height of the hinge piece).

Add a List Item component to pick the first result, and multiply that result by 2 so that when we move it, we move it the same distance away on the right, so it isn’t stuck to itself.

Now we come to the part where we can’t get around it. The good part. Moving it, multiple times.

The Series Component

S for Start, the first value to start from, by default 0
N for Step, which is the amount we want to do whichever operation after, that’s where we plug in the result from the previous step, so 2 x width of hinge
C for Count, which is how many hinges we want to add (essential!)

The series component tells the next components to do what they do, C amount of times, with specific values (N).

In our case it tells the Unit X component the value to be multiplied with, which then tells the Move component the direction and amount.

The Move component

The Move component has for input the Geometry (G) and the Motion (T). The Geometry is the collection of lines from earlier (the hinges’ slits to copy) and the Motion is Unit X component from the previous step.

Note //these values are lists, and therefore there are 5 items of an Unit X which is given from the Series component

We have some weird results though...

Grafting, what the hell is it?

Arman told me I had to Graft the Geometry parameter for it to work… and it did! but I don’t understand why.

I remember Edu showing us in our first Grasshopper class that if you do an operation on a list with another list, for example have a list of [1, 2, 3, 4] and you multiply it by another list, for example [1, 2, 5, 7, 2], then you’d run into a “problem”.

Each item of both lists multiply with it’s “twin-item” in the other list, but what happens when one list is bigger than the other? The operations continue, but the last item of the shorter list is used. See table below.

List 1	List 2	Resulting List
1	3	3
2	1	2
2	3	6
	4	8

You notice that the Resulting List has the multiplication of the two numbers on the left. You also notice that despite having no 4^th value in the first list, there’s a value in the last row.

You can see it in Grasshopper… by creating two lists of integers, and displaying them in the Panel components.

… but if you Graft the first list before sending it to the multiplication component, you can see that the multiplication outputs 3 lists.

That’s because Grafting basically creates a list with each item of the list you are grafting, so [1, 2, 2] becomes [1] [2] [2].

I think that is what is happening to our lines. The last line gets repeated multiple times because it’s the last item in the Line collection.

If we Graft the Line collection, then each line is passed independently, and the Move component is applied X amount of times to each line.

Mirroring the slits

Nice, the hard part is done. We’ve managed to copy the elements on the right, using a slider to decide how many times, and then being able to adjust the width between the hinges. Now, we can use the Mirror component to copy that to the other side of the design.

Add the Mirror component, by default the Plane it uses is the YZ plane, which is what we want, so leave it like that.

I read online that it’s good to add circles at the end of the slits because it relieves stress and avoids breaking. With my understanding of Grasshopper so far I had an idea of how to do it.

The Explode component

First, you have to get all the lines of the hinges into a Curve collection, and then collect all the vertices to use as the center of some circle objects. By browsing the Grasshopper bar I found an icon with “Explode” on it. It seems like it could help, let’s drag it on.

The Explode component takes in Curves and gives out Segments and Vertices.

Adding the circles to the Vertices

The Circle component asks for Plane and Radius as inputs, but I need to decide the center of it. I visited the Curve tab and looked in the Primitive dropdown… There’s something called a Circle CNR component, which when hovering says “Create a circle defined by center, normal and radius.”. That’s perfect, let’s drag it on.

I drag the vertices from the Explode output to the Center input, and tada!, circles appear. I added a slider to decide it’s Radius.

One thing though… there are circles on the edge of the hinge, which I don’t really want to. I need to be able to say something like “Only do the ones that are not on the edge, or that are in the rectangle”. So, WWGD? (What would Grasshopper do?). Inside the rectangle means inside the edge of it, and the edges are curves, so, maybe say if the point is inside a curve? Let’s double-click and see if there’s something that comes up…

alt_text

Ha! Yes, that was easier than I thought.

The Point in Curve (InCurve) component

It takes two inputs, the Points you want to check are in the curve, and of course, the Curve itself.

Let’s drag the Rectangle we created earlier as the base of the hinge to the Curve parameter, and of course the Vertices from the Explode component to the Points parameter.

The outputs of the Point in Curve component are Relationship (R), which gives 0 if a point is outside, 1 if the point is on the curve or 2 if the point is inside the curve, and P’ which are the “points projected on the region plane”... It’s the same amount as the ones intaken, so I guess it just outputs them all out.

We want to check that the point is inside the curve, not coincident or out, so let’s check with the list of Relationship that it outputs (you can see some 2s and 1s).

I struggled with the step above but found the solution while Googling, the answer is available here.

Basically you add a Equality (Equals) component, input the Relationship output from InCurve into A, and then input 2 into the input B. It outputs True or False.

Then add a Dispatch component which separates its input, a List (L), into two different lists depending on the condition. The condition is given in the Dispatch pattern (P) input. If true, it comes out of A. Let’s plug the = output of Equality to the P input of Dispatch, and finally the A output of Dispatch to the Center (C) input of Circle…

Boooom! It works! Making Grasshopper work on my own, oh yeah.

That’s it! Just need to compile all the curves/lines I created in this project into one big Curve collection which I can now Bake into Rhino. Beautiful. It’s been emotional Grasshopper.

Baking

I love baking. It’s simple and easy, you can either right-click > Bake, or press the spacebar above the component, and then click on the egg icon. Tada!

Conclusion & how it could be improved

I really enjoyed doing this. Once you get how Grasshopper works, you can quite quickly get the hang of it and design stuff.

Here are is my Grasshopper file for download.

Download Grasshopper project

How it could be improved?

The length of the living hinge could automatically adapt to the number of hinges and how wide it is, as well as the depth of the notch (number of hinges * width of hinges + 2 * notch depth).

The living hinges could go to infinity and then create a rectangle of which you control the width, and if the living hinges are within this rectangle they show. That means that you don’t have to add 4 hinges at a time.