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.
