PROFESSOR: All right,

so this lecture we talked about lots of cool

origami design software, all written by Tomohiro Tachi. We had Origamizer, Freeform

Origami Designer, Rigid Origami Simulator. And then he talked about

a bunch of other things that he’s built using

that kind of technology, like cylinder folding and so on. And I got a bunch of questions. So first is an exercise. If you haven’t picked

up handouts, grab them. Let’s fold something

from Origamizer. And I made the pretty much

the simplest possible thing you can make, which is four

squares coming together. And so this is the

crease pattern, and we’re going to fold it. You can start folding

now if you like. So I’ll do it too. So the first step in folding

a crease pattern like this is to precrease all the folds. The easiest way to do that is

to precrease them all mountain. And these black guys, we’re

actually going to fold– I’m going to make a

rectangular region here, because I didn’t trim

the paper to the square. So you’ve got a fold along

these two black lines and all of these guys. So it’s a good exercise in

folding crease patterns, if you didn’t already do one

NP set two, which is due today. When you’re mountain folding,

you can pretty easily guide along a straight line. So you just fold,

unfold, fold, unfold. Don’t worry about the mountain

valley pattern at this point. It’s really hard to

precrease a valley. When you’re precreasing the

non-horizontal and vertical folds, make sure you only

crease the part that’s marked. Don’t go too far. How we doing? How many people have precreased? No one, all right. I win. It helps that I’ve already

made a couple of these. This is what it’s going to

look like when it’s folded. On the back, you’ll have

the four rectangles. Beautiful. And then on the front

where all the color is, you see all the crease pattern. And so we’re going to–

as Origamizer always does, it adds these tabs, the tuck

parts, along each of the edges. And that the vertex you’ve got

a slightly more complicated thing. So that’s what we’re

going to be making. This is an example of the tried

and tested advanced origami folding of almost anything. First precrease all the creases,

then fold all the creases. Then you have your

model, pretty much. But the precreasing is usually

the really tedious part. When we’re feeling

high tech, we’ll precrease with a

sign cutter, which is a computer-controlled

robotic knife blade. We’ll score along the creases. Or a laser cutter, which can

burn halfway through the paper. Or pick your favorite tool. The fanciest is a

computer-controlled ball burnisher. Once you’ve precreased

everything mountain, you want to reverse in

particular the black lines. Those are really the

only important ones to reverse, I find,

in this model. So those are all

going to be valley. You want to invert

them to be valleys. Once you’ve got those guys,

you can collapse your flaps. Here’s the fun part. Ideally, you can collapse

maybe all four of them at once. Let’s see. It’s been hours since

I’ve folded one of these. I’ve forgotten how it’s done. You get this kind

of floppy version. These polygons aren’t flat

like they’re supposed to be. And this is where we have too

much material at the vertex here. And so there’s

these tucks, which are just crimps, as

we’ve been calling them. And the blue here is mountain,

the way I’ve set it up. So you just do all

of those crimps. Mountain valley. Mountain valley. It’s kind of like

little simple folds but in this

three-dimensional state. And when you put

them all in, it just makes exactly the desired form. That’s because this

is has been designed to have exactly the right

angles after you do the crimps. And there’s only one–

if your paper was rigid, there’d be only one possible

shape this could take on. And there it is. This is supposed

to be– usually, you fold it this way so that all

the crease lines that you print are on the backside,

so you can’t see them. So then you have your

perfect model out here. Not so perfect. You’d just be exposing

the origami side with the tucks hidden

on the backside. Usually, you also want

to hide the tucks. But of course, if you want to

get it the other way around, you just fold the blue valleys. The red’s mountains. But I find it’s a little

easier to fold this way, where you can see

what you’re doing. You can see all the crease

lines you’re making. I can see the advanced

folders are already going on to the next one. This one is six squares,

all coming together. When folded, it looks

something like this. But note that the crease

pattern as I’ve drawn it kind of requires you to cut

out this outer shape, because I haven’t drawn the

creases that are outside there, to make it easier to fold. So if you’re folding

ahead, ideally, you cut along all the black

lines in the outside. Those guys. And then when you want to put in

these tucks– you see how these are lined up– you just

want to crimp that. All right. You can keep folding at home. I want to show you a little

bit about the process of making that crease pattern. It’s pretty easy

once you know how, but if you haven’t

done it before, the first time is a

little bit challenging. I use a 3D– first you

draw your 3D squares that you want to make. I use a program called

Rhinoceros 3D, which has a pretty cheap

academic license, and it’s commonly used

around here in architecture. You get a top-down view

and a perspective view, and all these great things. In this case, I just wanted to

draw four squares in a plane, so it was pretty simple. I should have the file here. Four squares. So it looks like this. I’ve got my four

squares like that. Very exciting. Here’s what it looks

like in three dimensions. Wow. Then you export that

into DXF format. Or sorry, into OBJ format. So you save as OBJ. You’ve got a zillion options. You want to polygon mesh. Polylines. UNIX. That works for me, though

some variations may also work. Then you’ve got your OBJ file. You run Origamizer,

which looks like this. And you can drag in

your new OBJ file. Here it is. Exciting model here. This is in three dimensions. And then you say develop. Actually, first you should

probably do angle condition, and then develop. Now you’ve got something

like a crease pattern. It’s actually just

placing the squares, and you can change how the

squares are placed here. I spread them out a little

bit so that this tuck was not super tiny. This model isn’t

very constrained. And then you say crease

pattern generation, and you get your crease pattern. And you can adjust

how spread out you want these, how big

you want your tucks to be. I made it nice and square,

and something like that size. Then when you save, you get a

crease pattern in DXF format. And then hopefully your

drawing program can edit DXF. I think I opened it in

Rhino, then exported to Adobe Illustrator, and

then open in Illustrator. I removed all this

stuff on the outside, because I just wanted

this square boundary. But you can do

whatever you like. So that’s Origamizer in action. Wow, 900 frames a second. That’s fast. Of course, if you do

more complicated models, it can be a little

more involved. We’ve seen the bunny. What haven’t we seen? A mask. Never done this one. You should see develop. Boom. There it goes. And spreading them out, trying

to solve all the constraints, at some point it will converge. In the lower left, you can

see its current error value. When that gets down to zero you

have a perfect crease pattern. Except for these green regions. The green regions means that

the tucks in the 3D model, some of the– it’s a little

hard to turnaround. Some of the tucks

may be intersecting. So if we look closely

we can probably find some tucks that

are crossing each other. And if you want to deal

with that in the software– not just somehow fiddle

around with it with origami– there’s a tool which is

split extra wide tucks. If you look at one of

these, the green thing is the edge-tucking molecule. If you look at that,

it will subdivide into two edge-tucking molecules. Now they’re half this tall. They don’t go as

deep into this model. And they’re less

likely to intersect. As long as you’ve

got a green thing, there’s potential intersection. When you’re done, this is

probably a valid crease pattern, at this point. A little bit of green. Hopefully they’re OK. You can keep splitting if it

continues to be a problem. It just adds more

and more creases. So that’s how to use Origamizer,

if you haven’t used it already. And go back to slides. And the slide

progression of that. Cool . So the next question is

about– essentially, it’s a question about what

makes a convex vertex versus a concave vertex. Concave is a little

bit ambiguous, so usually we say non-convex,

to mean the opposite of convex. So I’ll use non-convex. Essentially, there are two

or three kinds of vertices, depending on how you count. We’ve got something like

this vertex of a tetrahedron. This would be convex,

meaning that if you look at the sum of the angles

of material at that vertex, that sum of angles

is less than 360. You could also

have a flat vertex, where it’s equal to 360. That’s what we just made. I’ve got four squares

coming together, four 90-degree angles. Sum of those angles is 360. Or you could have a

non-convex vertex. Non-convex, it’s

bigger than 360. And that’s a little

harder to draw. So I made what I

call the canonical– it’s a nice clean orthogonal,

meaning all the bases are horizontal, vertical,

or the other way. Non-convex vertex. This has six 90-degree

angles coming together. Six times 90 is bigger than 365. It’s 540. So this is, of course, inspired

by the video game Q’bert. Play it back in the day. And when you put

it into Origamizer, it gives you some kind

of layout like this. Then you ask for the creases. And boom, you’ve got it. And the thing that I printed

out had this removed, which requires you to

cut here, unfortunately. I also made the squares

go all the way to the tip. Place them differently,

and you end up with this crease pattern. And this is a little

trickier, because you’ve got some extra tucks in here. They’re quite small. And depending on how

accurate you want to be, it’s a little hard to fold it

in exactly the right shape. Looks pretty good. It’s got some– little bit

messy here in the center. If I use better paper,

it’ll be a little easier. So that’s a non-convex vertex. And in some sense, the

point of Origamizer was to deal with non-convex

vertices, not just convex ones. Convex ones, you can kind

of wrap around the paper, and just tuck away

the extra material. Non-convex, you really

have to tuck away material in a clever way in

order to get all of these guys to come together. Because normally, on a sheet of

paper, everything looks flat. Everything should add up to 360. But if you hide

away material, you can get more corners

to come together, and that’s what lets you

get non-convex vertices. So that’s where that came from. You can’t just take

a convex vertex and flip it inside, because

intrinsically, on the surface, it’ll still look

like a convex vertex, even if it’s popped inside out. Some of the angles won’t change. Still be less than 360. Cool. Next thing I wanted to

show is Freeform Origami. In particular, there’s a bunch

of different modes in Freeform Origami, and they weren’t really

showing much in the videos. So I’m going to show you a

little bit about how it works. So you download

Freeform Origami . All this software is

Windows only at the moment. So then you open

your favorite model. It can be a 3D

model or a 2D model. Miura-ori is a really

nice example to work with. This is just straight

lines in one direction, and then a zigzag in

the other direction. I’ve got your 3D view

on the left and right. Now these views are

not enabled, because I haven’t turned on a

lot of constraints. Now, as you see, there’s a

lot of different constraints I can turn on or off. In this case, I will

turn on developable, which means that each of these

vertices in this 3D model are flat, according

to this model, so you want to constrain some

of the angles to add up to 360. That means that it came

from a sheet of paper. That makes it a folding. So this is different from

the target in Origamizer, where it’s just a 3D model. And now you can see up

here the crease pattern, which will actually

fold into that. Because a developable, you

can just locally unfold it, and you’ll get a

picture like that. The other thing I want to

turn on is flat foldability. This is Kawasaki’s condition. So it’s going to enforce that

this angle plus this angle equals 180. Or the sum of the odds

equals the sum of the evens. When you add that constraint

you guarantee a flat folding, and then this picture

is the shadow pattern, if you make that flat

folding, and just draw them on top of each other. OK, so those are my

constraints, and that turns on all of my views. Now I can do– currently,

I am in simulation mode. This means it’s acting like

a physical piece of paper. So when I drag on

a corner, it’ll try to fold that

up, or unfold it. But this stuff on the

right, the crease pattern, is not changing. So this model, because it

has a lot of boundary edges, it has a bunch of

degrees of freedom. So I was like number of

degrees– number of boundary edges minus 3 is the number

of degrees of freedom, in this general picture. They’re crushed. So that’s the idea. You can also hold down

spacebar, and it’ll just try to fold everything,

kind of uniformly. Or you can hit B, and it’ll

unfold everything uniformly. So this is all, again, not

changing the crease pattern up here. If I move away from

simulation mode, if I turn this check

box off, now I’m allowing the crease

pattern up here to vary. So if you watch this upper right

corner, as I drag on this guy, crease pattern changes. It’s now allowing the

whole thing to be flexible. And I can do things

like, oh, maybe I want to make this

really high up here. And this is stuff you could

not do with Miura-ori. We’re changing the

Miura-ori pattern. Zoom out over here. See what’s going on. Maybe I want to bring

these guys up as well. I can’t make any

3D shape, because I am constrained by– a

little too exciting. You can always hit

Control-Z to undo. Sometimes it’s hard to

satisfy all the constraints that I give it. We can do things

like snap there. And wow, cool. So you have to be

a little careful. This requires some finesse. Because the constraints

are not always satisfiable. But this, whatever I’m

making, at all times will come from one

piece of paper– and you can print out

this crease pattern– and it will be flat foldable. And the cool theorem

by Tomohiro is that if you have

a valid 3D state, like the one on the left, and

you know it’s flat foldable, and it came from a

sheet of paper, then it will actually be

rigidly foldable. And so we can unfold this thing. Whoa. Or fold it, in theory. I see. The problem is I should first

turn on simulation mode. I don’t want the

pattern to change. Then I let it fold,

or unfold, and then it will be well behaved. This is guaranteed to work. When I have simulation mode

on, anything could happen. So it could explode. But that’s how

Freeform Origami works. So this question here was–

yeah, if you pull on a point when you’re in

simulation mode, you won’t change the crease pattern. But if you turn off

simulation mode, which is called design mode, then you

can really change the pattern, and get it to fold into

something that you want. And here’s an

example of something designed with this method. And then we waterjet

cut it with little tabs. And this only folds once. You can’t unfold it, or

else the tabs will break. But it’s pretty cool. And you can just

print out these– this is made from one sheet

steel and folded by hand. This was made back

when Tomohiro was visiting for that guest lecture. So first we made a paper model,

made sure it looked good. And this one,

we’ll fold rigidly. And we made another version,

which I couldn’t find. It was metal, but [INAUDIBLE]

ridges folds rigidly, like the videos that he showed. AUDIENCE: Erik, what is the name

of the program you’re using? PROFESSOR: This is

called Freeform Origami. Or maybe Freeform

Orgami Designer. All of these, if you search

for Tomohiro Tachi software. It’s also linked in

some of these slides. You will find all three

of these programs. I haven’t yet shown

Rigid Origami Simulator. Because it’s, in some sense,

assumed by Freeform Origami, because Freefrom

Origami can also do the folding with keeping

all the panels rigid. But they have some differences,

which I might talk about now. Next question is, on

the slides, Tomohiro showed there were

tons of equations. He didn’t talk

about any of them, and some people

really wanted to know about these great equations

or the conditions. What are the constraints that go

on in Origamizer, Rigid Origami Simulator, and Freeform Origami. And there are a bunch. And I don’t want to go into

them in lots of detail, because it can get complicated. But I’ll give you a high-level

picture of what’s going on. So first one, this is

Rigid Origami Simulator, which I didn’t show you. But basically, you take

in a crease pattern. You can hit spacebar to

make everything fold. You can hit B to make

everything unfold. And it keeps all

the panels rigid. That’s its goal. And there’s essentially– this

software is written in a way that the geometry of

each of these faces is determined by the

original crease pattern. So you don’t– that’s

just given to you. And the only thing

really that’s free are the bend angles

at each crease. So it parameterizes this 3D

model by the bend angles. And when you parameterize

by bend angles, there’s one key

constraint you need, which is that if you

walk around a vertex and you say, OK I bend by this. And then I bend by this,

and bend, bend, bend. I should end up back

where I started. Otherwise, there’ll be a tear

in the paper, at the corner. So if you’re going to

prioritize by bend angles, you have a cyclic constraint

around each vertex. And that is the one

constraint you have. This was originally described

by Belcastro and Hull. I know some of you know. And so around a

vertex, basically, every time you have a face of

paper, you turn by that amount. There’s matrix B.

It’s a rotation. Then you rotate around

that crease by however much the crease angle is. And then you rotate

around the face, and you rotate, rotate, rotate. You take the composition

of all these rotations. That should end up with

the trivial rotation, which is do nothing. Otherwise, there

would be a tear here. So this is a constraint

on the angles it’s a somewhat

complicated constraint. It involves sines and

cosines of the angles. But otherwise, if you ignore

the sine, cosine, stuff, this is actually linear. This is a bunch of

matrices, rotation matrices. You’re just composing them. So it’s relatively clean. And then you get

your folding motion. A little tricky to do by hand,

but very easy on a computer to solve that linear system. OK, next we have Freeform

Origami Simulator, what I just showed you. This has two constraints. Or there are two constraints

that I turned on. There are, in general, more

that you could turn on. One of them is developability. So here, we want to start

from a piece of paper. And so we want the sum

of the angles to be 360. So that is just

a sum constraint. The other condition we

want is flat foldability, which is the Kawasaki condition. If you satisfy both

of these, we know that you’ll be rigidly

foldable, and that’s kind of what Freeform

Origami is about. You can turn them off. You can turn on other

constraints as well. There are bunch in there, but

those are kind of the core two that you typically want to use. And so it’s always

solving these constraints. So those two systems have

relatively simple constraint systems, although

Freeform Origami has a lot of extra

bells and whistles. So you could do cool design. You can try to

force two vertices to come together, and so on. You can try to make mountains

be folded as mountains, and valleys folded as valleys. You can constrain

which way creases go. Those are inequality

constraints. The last one I want to

talk about is Origamizer. This has a lot of

constraints, and this is where it’s probably more

insightful to go through them. So remember we’re trying

to place these polygons into the plane so that these

edge-tucking molecules are very simple. They’re just a single crease. So that’s our–

first we’re going to just sort of paramaterize

how things are set up. Suppose you’ve got

two faces, which share an edge in the

polyhedron, the thing you’re trying to make. We want to place those

two faces somewhere in the piece of paper. And there’s a rotation. So here, we’ve separated

this edge from this edge. And if we extend those

lines, they form some angle. We’re going to call

that angle theta ij. That’s one of our variables

that we get to play with. The other thing is

how distant are they. There’s wij. Here, and wji here. And just for that

prioritization to make sense, you’ve got to satisfy

a couple of conditions, that if you look at theta

ji versus ij, it’s negated. And if you look at

the w’s, you can take the sine of

half the angle theta, and that tells you how much

this w differs from this w. So these are two relatively

simple constraints. Then, like in the previous

two– like in Rigid Origami Simulator, you have to have

closure around a vertex. If we’re placing these two

parameters, w and theta, denote how this guy’s

placed relative to this guy. And then you can– if you

look around a vertex where all these faces

meet, there’s the way this is parameterized

with aspect to this, and this to this,

and this to this. Those should be consistent. And in terms of the

thetas, it means that you should do one full

turn around the vertex. You’ve got these theta i’s. Then you’ve got these

alpha i’s, which are the angles of the face. Then you turn by theta. Turn by alpha. Theta, alpha, blah, blah, blah. In the end, you should get 360. And the equation’s

written this way because these are the variables

that you want to constrain. These quantities are all known. You know all the

alphas ahead of time. Those are the angles

of your surface. So this is a linear

constraint on the thetas. So there’s also a similar

constraint on the w’s. This is a little bit messier. It involves rotations,

involving these angles and this other

angle, capital theta, which is the sum of

thetas and alphas. But it’s essentially

saying the same thing, that this closed loop

is actually a polygon. It should come back

to where it started. So if you do this walk, you end

up back at your origin, 0, 0. Next constraint is the

convexity of the piece of paper. So you’re trying to– you want

the polygons on the outside to form a nice convex polygon,

because you can always fold the convex

polygon from a square. And so this is just a

very simple constraint that, at the boundary,

you have these– the thetas should be

greater or equal to 180. That’s very simple. Next one, these get

a little bit more technical to make the

molecules guaranteed to work. And so, in particular,

an edge-tucking molecule, we want this to be a

nice convex polygon. And so this is actually

fairly easy to constrain, but all these angles should

be in the right range. Don’t want any giant angle. You don’t want

these to basically flip open to be more than 180. That would be bad. The vertex-tucking molecule

is a little trickier. There are two main

constraints we need. One is that the thing that you

fold, which is kind of floppy and has too much

material, you want it to have too much material,

not too little material. You want each of these

angles in the tabs to be greater than or equal to

the desired angle over here, so that you can just add

in a tuck, like these guys. Add in one of

these little pleats to reduce the angle

to whatever you need. If it’s too small, no

matter how much you fold it, it’ll stay too small. So it’s like the guy who

keeps cutting the board and he says, “I keep cutting

it, but it’s still too short.” So you want it to be

too long initially, so you can cut it to

just the right length. The angle to just

the right length. This involves all these angles,

which I don’t want to define, but you can compute

what the angle is here. It’s easy to compute

what the target angle is. You just measure

it on the 3D model after you compute

the type proxy. And so you’re

constraining the thetas, or constraining this fee value. All right, so then

the other constraint is this tuck depth

condition, which says this is the

non-intersection parts. So you want these tucks

to not hit each other. They’re not so deep that

they penetrate each other. And I don’t want to go into

the details of how that’s specified, but it’s

another constraint. Now over all, these

constraints are fairly complicated

and non-linear. But Origamizer solves

them approximately. And if you let it converge, and

if it says it’s got zero error, it has solved them. But it can take a while. So one of the questions was,

can we do an example by hand to solve all of these systems? And the short answer is no. You really need a computer

to solve something like this. At least I would. The solution method is

essentially Newton’s method, that you may have

seen in some context. But this is a high-dimensional

version of Newton’s method to solve non-linear systems,

and it involves the Jacobian– I’ll just wave my

hands– which is partial derivatives with respect

to all the different parameters you have. These are vectors, so

this is a big matrix. And then you do a

sequence of iterations using this method, which

is a little easier to see in this picture. Essentially there are

two things going on. So you’re reacting to– suppose

you have a valid solution right now. Then someone drags on a vertex. When they drag on

a vertex, let’s say they drag it

along a straight line. That’s a linear

motion of a vertex. And that will start

violating constraints. If you go in that direction,

probably not very good for all these constraints. In Freefrom Origami,

you have– the edge lengths should

all stay the same. If you’re in simulation mode. So as you drag crazy,

you’re invalid. So the first thing

you do is project. And this is, I

call, an oiler step. You project that direction

to be a direction that is perpendicular to all

of your constraints, which means that

it preserves all the constraints to

the first order. And that’s, I think,

this first red step. Sorry. In general, these

green steps would be if you just preserve

things to the first order. But if you keep

following motions that are kind of correct– they’re

correct to the first order– you’ll eventually drift

away from correctness. And so you have to correct

with the second derivative– and that’s these

yellow steps– to try to get back to a solution. So as you’re

dragging, first, you correct to be correct

to the first order. You make a step

in that direction. Then you do the sequence

of second order steps to get closer and closer to

where things are actually correct. If that made sense, great. If not, you should take a

course on numerical methods in computer science. A little beyond

what we can do here. And so I’m just going

to leave it at that. Cool. Couple other questions

about things Tomohiro said. So he said, it

seems you don’t need to worry about NP completeness

of flat foldability. That’s actually

something we’ll be covering in the next lecture. So if you don’t know what

that means yet, don’t worry. We’ll be talking about it. But it means, at

the high level, it says it’s competitionally

intractable to make things fold flat. And yet, he’s solving it. Why is that OK? There’s a couple

things going on. In some sense

here, we don’t care about true flat foldabilities. Sometimes, he’d like

to fold all the way to the flat state for

compactness, and so on. That would be nice. But in particular, he just

wants local flat foldability. He knows that if you have

Kawasaki’s condition, then you guarantee

a rigid motion to fold for a little bit of

time, and you can prove that. And so if you’re just trying

to get rigidly foldable things, it’s enough to have local

flat foldability, which we do know how to

solve in linear time. And that’s the

Kawasaki condition, and that’s what he’s solving. And so, essentially,

whatever he makes will fold for at least

a little bit of time. And if he’s lucky, it’ll

fold all the way to flat. Sometimes not. Sometimes might get

collision in between. So you always get

something that folds. And then if it doesn’t fall the

way, you can try tweaking it until it does. So that’s the high

level version. But you can, in some sense,

sidestep NP completeness here. I think there’s still some

interesting open problems. In this setting, it seems like,

say, Freeform Origami Designer. It seems like you really– yeah. I have to leave it at that. I don’t know exactly how to

formulate the open problem here. But I think there are

interesting questions about proving NP completeness

doesn’t matter as much here. OK, another cool question. This is getting a

bit higher level. This is rather tedious to fold

by hand, as you’ve now learned, especially if you’re going to

make something like a bunny. Can we make a

machine to do this? And so I wanted to show you

a couple examples of machines for folding that

have sidestepped the printing by hand. This is an origami robot

made at CMU by Devin Balkcom. He was a Ph.D.

student at the time. And he’s taking

a piece of paper. It’s a robot. It’s open loop. It has no feedback, has

no censors, or anything. It is preprogrammed like an

assembly machine to fold. Essentially, it can

do simple folds. So it’s got a

little suction guy, to move things around, crease. Eventually it accumulates error

if it does a ton of steps, so you’d need a closed-loop

system with a camera or something to get that. But it actually does

a pretty decent job. This is real time. In this case, I

think it’s finished. One more fold. Crunch. It’s pretty impressive

what it can do it. But it can really

only do simple folds. It’s going to have an issue if

things really unfold it a lot. It might accidentally

hit something. And this should

be a samurai hat. Tweaking it a

little bit by hand. Wow, it looks like

a tetrahedron. OK, so that was one example. Here’s a more modern example. This was done at

Harvard just last year. And this is a process involving

laser-cutting individual components, aligning

them with these tabs. Sorry, these pins. Assembling them

together to make hinges. So they use laser

cutting, and to get two-dimensional surfaces, they

use folding to make 3D shapes. Kind of like pop-up cards. This is what a typical

hinge looks like. They’ve got all the

different materials here to attach different parts. And these piezoelectric

folding actuators. This is their overall design. They’re trying to make

a bee robotic bee. And this is what the final

created thing looks like. It’s mostly carbon fiber. And then these are the

piezoelectric actuators. So this is the thing

they want to make. They build a scaffold around

it that causes the whole thing to fold into its

desired 3D shape. So they’re taking flat parts. And they want to do things

like take this flat part and raise it. So what do they do? They add two hinges

to make this part move along this straight

up and down motion. And then each of–

that’s just a scaffold. Each of the gray parts they

actually want to build. They add the appropriate

hinges to cause it to fold in exactly

the way they like. So here, for example, the

wing is staying vertical. This part– it keeps

moving around on me– is turning 90 degrees. You do that with all the parts. You get them all

to fold like that. Here’s a prototype in real life. And then here’s

the final version. This is actually in real

time, so it folds really fast. Zoom. And then you’ve got

your assembled thing. One more. And then they add

this particular metal that fuses the

hinges together, so that they will no longer unfold. So that’s what it

looks like locked. It’s all done in an

automatic process. And then you laser cut

all of the scaffold away, and you’ve got

your finish thing. A sense of scale, this

is super, super tiny. It’s tedious to

fold these by hand. And in this way, they

can mass produce them. Here’s what it looks like

when you connect a battery. Either it will fold at 1

Hertz or at 30 Hertz, which you can barely see, because

it’s a 30 Hertz video. So you get your robotic bee. It’s not yet controllable. It doesn’t have a

battery attached, but it’s extremely

lightweight, and very powerful. This is a 3D printed

prototype they made first. And you can use it to

mass produce your objects. Essentially,

automatic procedure. And it’s all by

layering up flat layers, and then getting it to

fold into 3D things. And so you could imagine

something like this to execute some

complicated foldings, although that’s future work. This is, in some sense, a

fairly simple thing to build. And we’re working on making

more complicated things. So that was some

robotic folding for you. Next question is, any

cool open problems here? So I have two related

to rigid origami. One of them is, if I give

you a crease pattern, tell me whether it is rigidly

foldable at least a little bit or to the first

order or something. So I’ll just give you something,

like this will fold rigidly. I want to say yes or

no, does this fold? Seems like a pretty

natural question. And indeed, if all the vertices

are degree four like this, only four four edges

coming together, we can solve it efficiently. But given a more

complicated general pattern, characterize when

that is possible. We don’t have a good

algorithm for that. I don’t know if there is one. The more general question is–

that’s kind of an analysis question. The design problem is, I want

to design cool rigid origami. And we’ve seen bunches of

examples of rigid origami. Here’s a new one

I wanted to show. The Hexa Pot. I believe this is rigid origami,

as a kick starter on this. And here is one of them. It folds nice and flat. And it has this 3D state,

where you can boil water on your camping stove. And they have a video

of cooking noodles. It cooks noodles. It cooks pasta. It cooks sausages. Anything you could imagine,

you can cook in here, as long as it fits

in this space. That’s waterproof, obviously. We saw the telescope lens. We saw this origami stent. How are these designed? Inspiration. Some human had a cool

idea, tried it out, proved that it actually

folded rigidly. Great. But can we come

up with algorithms to design things like this? Could you close the door? Here’s another just

one-off example. You may have seen these. These are called shopping

bags, and they’re usually paper shopping bags. They’re usually folded

along this crease pattern. It turns out that’s not possible

if all the panels are rigid. This thing cannot fold at all. It’s rigid, if the

panels are made of steel. And it’s actually

fairly easy to see that, if you look

at this corner, these are four 90-degree

angles coming together. And if you look at four

90-degree angles, two straight lines, like in a map,

you could fold one of them. But only when you get

all the way to 180 can you fold the other way. So right now, this guy

is folded 90 degrees. This can’t fold at all, which

means this fold angle is zero. And we know from

Tomohiro’s lecture that a degree four vertex

has one degree of freedom. So this if this is zero,

they all have to be zero. And so the whole thing is rigid. Of course, if you

add extra creases, this is done with that

Devin Balkcom and Marty. So the same robotic folding guy. Here’s a visual proof

of what goes wrong. You end up with a tear here. You can fold everything

except one of those guys. If you add extra

creases, you can kind of roll the lip of the

bag down, and repeat that until it’s really short. And then once it’s below

this height of one to two, you can just crush it

like a garment box. And so you can do that. You can actually

fold this thing flat, and you can undo

it and unfold it. An interesting open question

is, these paper bags are manufactured in

their flat state. If I give you a flat

paper bag, can you open it by adding creases? I don’t think we know

the answer to that. But we conjecture

the answer is yes. There are a bunch of

different designs out there. This is done with–

it’s hard to read. But this is with

[INAUDIBLE] in particular, who did the origami stent. It’s kind of a twisting box. Works up to a cubicle box. And he just had a paper

with Woo this year on a more practical folding. So when we roll the lip, we get

a lot of layers of material. This one works for

fairly a tall bag. I forget exactly heart how tall. Maybe three to one. And it has a fairly

small number of layers. They even built one

out of sheet metal to prove this is a practical

way to make rigid shopping bags. And the last question

here is, could you make one crease

pattern that folds into two different shapes? Could you make an

Origamizer that at one point will make one shape? And then you super-impose

another crease pattern, ideally sharing lots of creases,

to make a different shape? And the answer is,

watch the next lecture. Yes, we will be talking about

universal hinge patterns, where you take a different

subset of the creases. You can fold anything, provided

it’s made up of little cubes. And that’s one answer

to that question. Any other questions? Yes. AUDIENCE: Erik, going back

to the rigid foldability, you do understand

rigid foldability has a single vertex, right? It’s just a global [INAUDIBLE]. PROFESSOR: Right. Rigid foldability of the

single vertex is easy. Almost anything is

rigidly foldable. But yeah, its general

crease pattern [INAUDIBLE]. AUDIENCE: So it’s very similar

to the flat foldability [INAUDIBLE]. PROFESSOR: Yeah, it’s

like flat foldability, except for flat

foldability, we know that testing a single

vertex is easy. Testing a whole crease

pattern is NP hard. What’d we’d like to prove

is either NP hardness, or get an algorithm

for rigid foldability. AUDIENCE: There’s no

such result [INAUDIBLE]. PROFESSOR: Right,

there’s no such result for rigid foldability yet. Other questions? All right. Enjoy folding.