Design & Fold a Tessellating Origami Structure With Grasshopper

In this project, we'll use parametric design tools and a physics solver to simulate folding tessellation origami models, then fabricate them from paper. These can be used as scale models for architectural paneling in a room-scale installation. They can be fabricated at full scale, too! Since we're starting from flat sheets, a design can be printed at any size and folded into place - no complicated assembly required.

This tutorial uses Grasshopper in Rhino with the Crane plugin. Basic familiarity with the Rhino and Grasshopper interfaces is assumed. We'll work with some intermediate-level concepts, but a beginner can follow along.

We will start with a flat shape and create a series of mountain and valley folds, then simulate folding them using Crane. This allows us to preview how our design will fold and gives us a printable pattern, as well as a mesh to use in our renders.

Project Files:

1. Grasshopper definition
2. Rhino scene model

Software:

1. Rhino 7 or newer
2. Crane (install through the Rhino package manager)
3. Vector editor (Inkscape or Illustrator)

Materials:

1. Printer (color optional)
2. Paper - a higher weight copy paper is nice (I used Hammermill 32#), but regular printer paper will work
3. Cardboard or chipboard
4. Glue or tape
5. A dry ballpoint pen, dull craft knife, or other scoring tool
6. A ruler
7. Craft knife or scissors

Tessellation origami involves creasing all of the mountain and valley folds that will be used in a model, then carefully collapsing it into a geometric form. The patterns can be intricate and create a lot of dimension. They're useful for making things that can be fabricated out of flat sheets, fold down to a very small size, and then deploy into a larger shape. The Miura-ori fold is perhaps the most famous, owing to its use in spacecraft.

These patterns tend to be highly regular and repeating. Even the simplest, when tiled and folded, result in stunning complexity. I wanted to introduce some irregularity to a tessellation pattern to explore what kinds of organic, chaotic forms might emerge.

I started with a hexagonal tile, for no other reason than it being a little more interesting than the standard quadrilateral, and just as easy to implement procedurally. The crease pattern is very simple: mountain folds connecting the corners, valley folds connecting the segment midpoints. I don't know if this pattern has a name, but it's obvious enough that it's likely been discovered many times.

To introduce irregularity, I used an attractor. This is a technique that varies the properties of geometry by proximity to a point. Here, we're using the attractor to scale our hexagons. The farther away from an attractor they are, the bigger and more distorted they get.

We'll start with a hexagonal grid in Grasshopper. Actually, any set of points will work, since the Voronoi diagram creates hexagons, but starting with a hex grid gives us a regular tiling we can subtly adjust. For a more chaotic output, use Pop2D.

We need a couple of attractor points - we'll use 2, but more or just one works. Using two MD sliders and piping them both into a single Point object is an easy way to do it. Double-click the number display on your sliders to remap them to be big enough to cover your hex grid.

Add a Closest Point node and connect the hex grid points and the attractor points. This will give us a list of which attractor is closest to each grid cell, so it's only affected by the closest one.

Now for the math. We'll use a Distance node to compute the distance from each grid cell to its closest attractor point, and a Vec2Pt to decide what direction to move it.

Use a number slider with a range from -0.100 to 0.100 (make sure to use 3 digits of precision). This determines the strength of our attractor system - how far to move the grid cells towards and away. It's very sensitive to small changes, so we'll be working with a tiny value.

We need to transform our hex grid cells so their centers are moved by the attractors. Since we'll no longer have hexagons with sides of equal length, we need to recompute them. This would be complicated for other regular polygons, but for hexagons, we can simply use Voronoi cells.

Use a Move node to move the grid centers, and a Bounding Box to get a boundary for the Voronoi diagram. Connect the Voronoi node, drag your attractor strength slider, move your attractor points, and watch the cells transform.

We've got our transformed Voronoi cells now, but they don't all have six sides. While we could go ahead and use all of them, it would defeat the purpose of using a regular tiling for our folds. This step and the next get into some less straightforward list operations, which I won't go into detail about here.

Basically, we need to get the number of sides of each cell by exploding them, removing every branch that doesn't have exactly 6 items, and recombining them into closed curves.

We'll connect opposite corners of our hexagons to create our mountain lines, and opposite midpoints of the edges for our valley lines. It's helpful to add an extra Curve node to hold both sets of lines.

Not all of these nets of Voronoi cells will work with the Crane solver. It's important they don't have any holes (empty cells) or islands (cells unattached to the rest). You'll have to play with the locations and strengths of the attractors to get contiguous, solid geometry.

Connect the Join output from your culled Voronoi cells to a Region Union to get their outline. Turn that into a surface. Use Surface Split to split it up with your fold lines and the cell boundaries. Join the resulting breps, use a Simple Mesh to turn it into a mesh, then weld to remove duplicates. Splitting and rejoining the surface seems redundant, but it's necessary for the Crane solver to work.

Finally, we can add a CMesh_MVLines node. Connect your mesh, mountain lines, and valley lines.

Add a Crane Solver and Preview Crane Solver node. Set your Fold Speed to somewhere between 0 and 1 (I like to keep mine a little slower so I can see what's going on). Rigidity should be 0. Add a Developable constraint to make sure everything the solver outputs is actually possible to fold from a flat sheet.

Set Solver On, Rigid Mode On, Quad Flat Off, and 180 Fold Blocking Off. Hold down Press to Fold and watch the magic happen.

Any time you update your input geometry, you will need to hit Reset Solver, as it doesn't update the CMesh input automatically. It's also a good idea to turn the solver back off when you're changing other parts of the project.

In Rhino, create five new layers: Meshes, Mountain, Valley, Boundary, and Triangulation. Give all of them except Meshes a unique color. I used red for Valley and blue for Mountain to match the Crane preview, then green for Boundary and yellow for Triangulation.

Back in Grasshopper, add a DeconstructCMesh node. This lets us see everything that makes up the CMesh and bake the folded mesh. Output the mesh to a Triangulate Mesh to fix any weird geometry. Right click to bake the Triangulate output to the Meshes layer. Reset the solver to make the lines flat again, and bake the Mountain, Valley, and Boundary curves to their respective layers. Make sure to group each of them to keep everything easy to work with.

Finally, bake the Unassigned Lines output to the Triangulation layer. These aren't exactly the same as the lines we drew - if you look closely at the folded output, you may notice that it's actually folding in some places that don't have fold lines we added. That's because in order to give us a rigid, developable surface, it needs more fold locations across the faces. We actually specified these when we added the Voronoi cells to the Split Surface. The Crane solver handles these in a way that can be hard to understand, and for some reason tends to put them in Unassigned instead of the Triangulation lines when deconstructing the CMesh.

Export your Mountain, Valley, Triangulation, and Boundary layers to use in the vector editor of your choice (I used an .ai file and Adobe Illustrator). Lay them out to print and set the line weight to 0.5pt. If you're not using a color printer, you can represent the fold types with dashed line styles or different weights.

Placing our baked meshes in a simple environment in Rhino lets us explore how these forms might come together before building a physical model. I kept this quick and didn't focus too much on the details of placement or how the panels sit on the walls - that's what the paper models are for. I've included my empty Rhino scene in the project files. Experiment with different configurations of your meshes here. Set your display mode to Rendered and use ViewCaptureToFile to save them at high resolution.

I wanted to visualize this installation in a large, open space where it appears to be growing organically and interacting with light coming through the windows. I chose five of the meshes I generated and arranged them to suggest continuity.

Score all of your mountain fold lines, then pre-fold them all and flatten the sheet out. Do the valley folds next. Finally, score your triangulation lines. On thinner paper you can probably skip pre-folding them, but I suggest folding them both mountain and valley. This will allow the model to flex as needed.

Collapsing the tessellation can be tricky and quite time-consuming. At first, it will feel like the model wants to stay flat. Keep folding pairs of mountain and valley folds and allow the triangulation score lines to buckle. Focus on the triangles, diamonds, and hexagons that make up the pattern. Eventually, it will start to pop out and become flexible. In a rigid model, every fold and flex affects everything around it, so work carefully and patiently. It will help to watch some videos of people folding tessellation origami.

Unlike in our Rhino model, we don't need to make our folds all perfectly regular. In fact, doing so would be much harder (certainly beyond my skill level). Instead, take advantage of the paper model to experiment and see how variations in the pattern affect the folded form.

Tiny dots of superglue at the corners of folds can help keep your folds at the angles you want. Avoid gluing entire faces together; the interesting shapes come from having the lines only partially folded. Going too far will cause it to curl in on itself.

Construct a simple cardboard or chipboard model, as we did in Rhino. As you tape or glue your paper form in place, remember that each attachment point constrains the overall shape of the model.

Stage and photograph your model, and appreciate your work.

If you're interested in learning more about Crane, check out the whitepaper. It's worth noting that Crane has constraint functions that allow you to keep vertices of the folded meshes on a surface, like the walls of our render environment. The solver constraints are rather complicated to implement and ended up being outside the scope of this project, but would be very useful if you need an accurate CAD model for full-scale fabrication.

Folding Techniques for Designers by Paul Jackson is an incredible resource for tessellated origami, and provided the inspiration and background knowledge for this project.