PROFESSOR: So we are honored to have Professor Tomohiro
Tachi here today visiting from the University of Tokyo.
We first met in SIGGRAPH 2006, which
was in Boston, big graphics conference,
when he was a PhD student.
And Tomohiro has very quickly become a star
in the area of computational origami,
and it's really exciting to see in particular his perspective
coming from an architecture background
and how that influences his work.
He's going to talk about lots of exciting things
in the context of architectural origami for our grand finale
lecture.
So please welcome Tomohiro.
[APPLAUSE]
PROFESSOR: Thank you very much, Eric.
So I'm Tomohiro Tachi from the University of Tokyo,
and I'm going to talk about architecture origami, which
is architectural form design systems based
in computational origami.
So first, introduction.
I have been doing origami as a hobby, as well as my research.
Well, it was before my research started that I began folding.
These are examples of folding using a traditional way
of box pleating or a 3D curved surface.
This is pure origami, and there is also
applied origami, which is applying
origami for engineering purposes.
For example, we can use sheet folding
for manufacturing a 3D surface or use it
for increasing the structure's stiffness.
These are examples of a formed 3D surface
from a sheet of metal.
We can use a dynamic property of origami
for deployable structure, such as this
is folding of solar panels used for spatial structures.
A good thing about origami is that unlike the truss structure
or scissors structure, you can form basically
a continuous surface, and that continuity
is preserved all the way of the transformation.
So this makes origami potentially
useful for adaptive environment, which
includes context customized design or personal design
so that you can make some kind of origami structures
that fit customized to your body or customised to the design
context.
And you can, of course, do fabrication oriented design
so that you can efficiently use the material
to build the 3D structure that you want.
What I'm proposing with the architectural origami,
it's different from origami architecture.
I have been using the word "origami architecture," which
might mean the application of origami to design.
So this is the direction of application.
We start from some kind of shape or pattern
and see how it is folded or see the behavior
by simulating, or directly applying in physical world.
But that can result in very restricted design
because origami is very constrained,
and that would just result in just
a copy of some known origami pattern to design.
Or sometimes, there are lots of origami inspired designs
that don't use any of the origami properties that
might be useful for engineering purpose.
So what I am proposing with the word
"architectural origami" is that origami theory for design
and a design system that uses that.
So the idea is in this direction.
We want to get some kind of designed property,
like how it behaves in 3D or in time, also,
and we want to extract the characteristics of origami
and obtain the solution from that required condition,
and also design contexts that are
given by the design purpose.
This is the outline.
First is Origamizer.
I'm going to talk about basically the software I've
been developing, the systems.
One is Origamizer.
Some of you have attended Eric's class,
so the theoretic side of the Origamizer altorithm,
but I'm going to talk about the software itself
and the algorithm that efficiently works.
So first, Origamizer.
This is the software is available on my web page.
It's freely available.
It's about origami design.
This is my oldest work as research.
We had a tree method or circle river packing method
developed by Meguro and Lang, which
is using stick figure for representing the model
and designed by packing circles and rivers.
I think Jason has talked in the class.
So this is existing method for origami design,
and what I wanted to do is make 3D
instead of this kind of 1D figure.
So this is what we can get from the circle river packing
method, and with Origamizer or Freeform Origami,
we can get this kind of 3D form.
You can say that what you see is what you fold.
In this case, what you see is not what you fold, actually.
So I manually designed something like that.
It's a laptop PC.
Well, I think it's the most complicated one.
So for example, you can see there is an RGB output here
and USB outputs here, and this is the touch pad,
and this is keyboard.
Good thing about that is the function key
is a little bit narrower than the normal key here.
Anyway, this is what I've been working on.
Well, I think it was my hobby, but I
was trying to make some kind of box pleating to make anything.
And also, this is more three dimensional figure.
The body is represented basically by blocks of cubes.
And I did more purely geometric things with concave vertex.
This was very important for me.
It's very easy to make a convex polyhedron with paper.
Just wrapping paper will result in folding.
But it's very hard to make concave vertex.
When I finished this model, I thought everything is possible,
so I did a software to do this for me.
The program is to realize arbitrarily given polyhedra
surface with a developable surface by folding.
The geometric constraints is, of course,
developability so that it can be folded from a sheet of paper.
In this case, we forget about continuous motion
from a sheet of paper to the resulting state.
We believe that physically it exists, so it works.
It can be applied in engineering sense for fabrication
by folding and bending.
We put arbitrary polyhedron and get the crease pattern,
and by only folding this part, you
get the folded state that's the same as this arbitrarily given
polyhedron.
The idea is to use tuck.
This is a given polyhedron, and this grey area is our tucks.
By folding a tuck, it's hidden.
It's flat folded and it's hidden behind a polyhedron's surface,
like in this movie.
When it's in developed state, it forms
a plane with a surface polyhedron.
This is good because we can make a negative curvature
vertex, a concave or negative curvature vertex.
The basic algorithm is to start from making the problem
into laying out the surface polygons onto a plane.
By properly aligning, we can get the edge tucking molecule that
folds the edge to edge and vertex tucking molecule which
folds vertices to vertex, and we can pack them and tesselate
the surface with these elements.
We can parameterize this configuration,
and we can solve it by solving non-linear equation
and inequality conditions.
That's the basic idea.
What we have is geometric constraints,
which are represented by equations.
So these are the equations, where
this one represents the total sum, sums up 2 pi,
and this shows that this forms a closed loop for each vertex.
We assign these conditions for each vertex,
and we solve that by two step linear mapping, which
is basically solving this equation and this equation.
Good thing about that is that it becomes linear,
which means that you can pre-compute
and you can go around the solution space.
I will show you later the design system.
I don't go into details, but there are several inequality
conditions, which are for making crease pattern
and for making it to fit into 3D configuration of the polyhedron
and tuck property, which is assumed
place of the tuck that's hidden.
So this is a system.
You put the input here in this window,
and you have the layout of the surface polygons,
and then you get the crease pattern like that.
It automatically generates the crease pattern,
and here you see it's edited in real time.
By the way, this is real time.
The linear equations are represented
by linear equations, so you can pre-compute the linear matrix
and then you can calculate the configuration interactively.
You can also do some kind of boundary editing.
Do you have questions?
AUDIENCE: Yes.
Does this maximize the amout of paper on the outside?
PROFESSOR: It's about maximizing the size
of the model with respect to the paper size.
It's not.
Yes, you can, of course, implement
some kind of optimization onto the program,
but I keep it more free so that the software user can search
within the solution space that satisfies these origamizing
conditions.
So this is a series of results that are folded.
This is how to fold an origami bunny.
First thing you do is to get crease pattern
using Origamizer, and then fold along
the given crease pattern like this.
Interesting thing about that is that it's
changing the lighting conditions.
It starts from natural light and it
becomes into artificial light.
It takes about 10 hours or something.
And it's done.
And I have this one.
[APPLAUSE]
There are two existing models, not one,
so it's very easy to reproduce.
One thing that I'm doing with Eric
is to prove that anything is possible.
The software is a little bit approximation,
or it doesn't work in some cases,
so we are doing really make it possible.
This is the part of the Origamizer,
so if you have questions for Origamizer.
Yes?
AUDIENCE: So for the input of the model
that you can use, does it take [INAUDIBLE], the format?
AUDIENCE: It's polygons.
AUDIENCE: What's the file format that you
have to import in in order to--
PROFESSOR: Format of 3D input.
It's basically OBJ file that this particular software
accepts, but basically, it's OK if it's
a polyhedral surface with actually any topology
because you can basically assign the boundary of paper onto it
so that it always becomes a disk.
Yes?
AUDIENCE: You mentioned that earlier on in the process,
you need to properly lay out the polygons onto the plane.
What constitutes proper layout?
PROFESSOR: Your question is, what is a proper layout?
This is basically given by these conditions.
In an intuitive way, if you lay out polygons,
I want to fold this line onto this line with, actually,
a single line, so you have to keep
this symmetric against some line.
So that gives a constraint.
This is the basic equations that you have to solve,
and there are several others, such as the boundary
should be convex because we don't want to end up
in some kind of very complex boundary.
If it's foldable form a convex paper,
then it's foldable from a square,
so that's the convexity of paper.
No intersection, of course, between polygons.
It's a little bit difficult, but when you place crease lines,
then it might hit adjacent crease lines.
That's pretty bad, so you have to avoid that.
Also, you have to fit to the 3D surface.
Sometimes a tuck that's coming inside
is bad, so you have to adjust that,
and in order to do that, you need a condition.
AUDIENCE: Did you find that you were moving around
where the edges of the [INAUDIBLE] model,
or can you just start anywhere and randomly come up
with a solution?
PROFESSOR: It's how to solve?
AUDIENCE: Yeah.
Does it get a lot harder as the polygons increase?
PROFESSOR: It's not a step by step approach to laying out
one piece at a time, but it's more
like solving all the equations all at the same time using
big vector equation.
AUDIENCE: Maybe what he means is, is it numerically well
conditioned?
PROFESSOR: No.
That's why we need extra work for proving.
AUDIENCE: That it's always [INAUDIBLE].
PROFESSOR: That's a question.
Well, it's not always.
There are sometimes that produces
some kind of over constrained part and free part.
AUDIENCE: Also, are the tucks under mechanical tension?
Does it want to stay tucked or does it want to come apart?
PROFESSOR: Physical property of the tuck.
AUDIENCE: Yes.
PROFESSOR: Because of the crimping
that's done to each of these vertices to fit the curvature,
it stays in this form.
You don't have any glues or crimps here.
This is actually a good property of this design method.
Yes?
AUDIENCE: To approximate a curve,
you're breaking it down into smaller straight edge segments.
Is that useful or plannable as to what the lower bound is
to how granular you make the curve approximation?
PROFESSOR: About the condition for the input.
In this system, I don't give any kind
of numerical upper boundary for the regularity
of triangles or something.
But I think it's good if we can do for anything,
so that's why I'm working with Eric on proving.
AUDIENCE: Is there a Mac version of the program?
PROFESSOR: Mac version?
No, it's still Windows version only.
It's written with cross platform library, so sometime in future.
So let's move on to the next topic and software, which
is Freeform Origami.
So the objective of Freeform Origami
is that we don't want to spend too much time to make
this kind of 3D form, and also, we
want some kind of conditions, not only developability.
We want some condition that most origami has.
This is flat foldability so that it
folds flat, and also transformability or elastic
properties.
We want to use these good properties from origami
while we want to make some kind of freeform surface.
So the approach here is start from existing origami models
and then modify that to a different shape
while keeping the origami conditions
with direct, straightforward user interface.
Here, I used triangular mesh for representing the origami model,
and we represent the origami models
by the vertex coordinates of the model.
These variables are constrained by developability and flat
foldability This is a very direct way of implementing
origami deformation.
First thing we want to keep is developability,
which is that you can fold from a sheet of paper.
In engineering sense, it means that it
can be manufactured from a sheet material, which
is very nice, by folding and bending only.
The condition is globally represented
that there exists some isometric mapping to a plane,
but if the surface is a topological disk,
it can be represented by a local condition of every point.
So every point on the surface, the Gauss curvature is zero.
Actually, we are thinking of a non-smooth surface,
but we are thinking of a piecewise linear surface, which
allows variation.
Smooth developer surface is only allowed to be in these forms,
but we have lots of different form variations
if we allow creases.
Even in this case, we have to think about Gauss area,
and it's very easy to define Gauss area
for a C2 version of surface by multiplying curvatures,
but for polyhedra case, we use instead Gauss area, which
is represented by this, which is 2 pi minus sum of angles
around the vertex.
It's a very simple way to express
that it's folded from a plane.
This sums up to 2 pi.
This is what you can use for developability.
We want to also have flat foldability for the surface.
This is applicable for compactly packaging a surface
from 3D to 2D and from 2D to 3D.
It's also represented by isometric condition,
like in developability.
And also, we have a little bit of layering condition, which
is actually NP complete, which is hard,
but for practical purposes, we can avoid that.
The first one is isometry.
That can be similarly represented
by angle condition, which is called Kawasaki's theorem, so
that the alternating sum of each vertex is zero.
And the layer ordering is NP complete,
but we can use, for example, sufficient condition given
by Kawasaki or empirical condition,
which basically given for each local adjacent angle,
so it's very easy to implement.
And it works, so we forget about NP complete part.
And also, we can give several constraints.
For example, this fold doesn't want
to fold so that it forms a planar surface,
or you can fix the point to a point in 3D space,
or we can make some edge to be rigid.
So we have these coordinates, and these are the variables
to represent the configuration, and be assign developability,
flat foldability, or other constraints.
This forms an under-determined system,
which means that it gives you a multi-dimensional solution
space.
Within the solution space, we move.
We transform the surface so that you
will get the always valid solution.
That's the method we are applying.
In order to solve that, we can use
the Jacobian of the constraints and calculate it numerically.
So for each step, it's a given assumed transformation mold,
and this gives you a valid transformation mold
by using the generalized inverse or pseudo inverse.
You can implement software like this.
The top is what happens with Freeform Origami.
This is a crease pattern of the paper
and this is the folded pattern when it's X-rayed.
You can see that if you drag this point up,
then all the crease pattern and the flat folded pattern
changes at the same time.
This is for comparison.
This is kind of a simulation.
In this case, the model cannot change the crease pattern,
which makes a less flexible motion for origami.
So we want to do some mesh modification
because if you change the crease pattern, then
it will end up being degenerate triangles,
so that we need to do some kind of edge collapse operation.
However, in order to do that, we have several conditions.
We have to keep Maekawa's theorem
if the surface is flat foldable, and we
use that for doing edge collapsing
and mesh modification.
You see these patterns change, and these
are getting very degenerate triangles
that are removed by this operation.
This is interesting because you will end up
in different patterns.
This part is similar to diamond pattern or Yoshimura pattern,
and this part is kept the same as Miura-Ori pattern.
Mesh modification enables to transform
to produce more variations for pattern.
From now, I will show some examples of Freeform Origami.
First one is starting from Miura-Ori.
I think it's well known.
This is actually very old, you can see from napkin folds.
For paper models, I think you can see pictures from Bauhaus.
Anyway, this is called Miura-Ori,
and it gives you expansive motion,
and also it can be compactly packaged
and it's developable, of course.
So this is a variation of that, and this is another example.
This model is called Melting Ice Cream.
The idea is that using a variation of Miura-Ori,
it forms a 3D surface that is irregular and asymmetric,
while it can be folded flat so that you can roll it up,
carry out.
This is a model.
This is another example.
Here, I wanted to start from regular Miura-Ori
and then to transform into a more free form surface.
You can also generalize Ron Resch pattern.
This is one of Ron Resch's designed triangular
tessellations.
Good thing about this is that it forms
a kind of composite surface when its folded.
So it's composed with top surface and tucks
inside, just like this bunny, but it's more flexible
and you can fold from a sheet to the 3D form.
In order to design this, we assigned the condition
that in 3D state, these three vertices form one vertex.
That's extra constraints to enable generalization
of Ron Resch pattern.
So for example, you can get this kind
of asymmetric polyhedral surface with this generalized pattern,
or this form with this pattern.
Each triangle has different shapes.
A little bit of differentiated shape.
Or you can just apply to some regular triangular mesh
and then get some nice crumpled paper like that.
I think this is a good way for using this software.
You can design crumpled paper.
It's very hard to crumple paper in real life.
If you feel it's very difficult, then you
can use this software to crumple up paper.
This is a generalized version of Yoshimura pattern or diamond
pattern that you can use for a kind of shell-like structure.
This is another pattern called waterbomb pattern.
It's supposed to be playing the puffer fish
motion by [INAUDIBLE].
Anyway, this type of pattern is called waterbomb pattern.
I think the oldest known is by Shuzo Fujimoto.
It's kind of a flexible pattern.
Because it's flat foldable, it can
be used for deployable structure,
and because of the elastic property
that the folding gives, you can use for textured material
or cloth folding.
This is an example of deformation.
This is the normal waterbomb pattern.
This is based on triangles.
This one forms more planar surface when it's in 3D,
and this is some generalization.
This is the folded form.
I think it's a little bit too small to show.
This is the pattern, and you fold it
into a kind of a butterfly shape,
and it forms a hyperbolic paraboloidal shape,
but it's a subtle shape.
This is another way to make a [INAUDIBLE] in paper,
and this exists.
This was Freeform Origami.
Do you have any questions about Freeform Origami?
AUDIENCE: Why can't you solve directly for the final shape
that you want?
PROFESSOR: The question is, why do I not
search for the 3D shape instead of gradually changing?
This is because the constraints are non-linear,
and that makes it possible that the solution doesn't exist.
If you do it continuously, then it
is always true that you get the right answer.
This is a demonstration.
This is good because basically, you
can interact with the geometry of the origami
to find some new results.
It's more similar to when you design with paper, like when
you interact with real material, but this
gives more flexible change of material than simulation.
I wanted to make that kind of interaction possible,
so this moves like that, and that changes the pattern.
That's the reason I do it in this way,
solve the equation by deformation.
Any questions?
AUDIENCE: I'm just curious, how long
did it take you to develop both this and the Origamizer?
PROFESSOR: The time for developing the software.
Well, it's always continuing.
I'm always containing developing,
so it's very hard to say.
I don't know.
I think basically it starts to work in half a year,
and then polish a lot of times.
AUDIENCE: Did you want to show the demo one?
PROFESSOR: No.
Not yet.
So then we talk about the rigid origami.
Question?
AUDIENCE: I might not understand it correctly,
but in either of these programs, or is there a program that
exists that allows the user to design dynamically
like this curved crease origami?
PROFESSOR: So curved crease origami is quite hard.
I have tried with this software, and it works for some cases,
and it doesn't work for most of the cases
because there are too much degrees of freedom.
If you simulate curve folding by very thin quadrilateral strips,
so that's a future work so that the software
can work with curve folding.
If it's a coarse approximation, then it works.
So rigid origami.
This is the closest part of computational origami
to architecture.
So rigid origami is plates and hinges model
for origami like this.
So each rigid panel is connected to adjacent panel
with a rotational hinge, one axis hinge.
The panels do not deform, and it produces a synchronized motion.
So that's a model when you want to apply
origami's dynamic features to some designs.
And this is a comparison, and this illustrates the energy
that's caused by the distortion of facets.
For example, this model falls to this state,
but there is no path that gives you zero energy deformation.
But this is rigid foldable, which
keeps each of the faces not deforming.
And it's useful for a self deployable structure
or architectural structure that is very large.
You can substitute panels with thick panels.
I will talk in the last part.
So like this.
So rigid origami.
Here, we want to apply rigid origami to design purposes.
In order to do that, we want to think about first
to also generalize rigid foldability
to different shapes, and also to generalize into cylinders
and other topology, like compound structures.
Before that, I would like to show example of rigid folding.
This is the simulation of folding.
AUDIENCE: Could you play the lower left again?
PROFESSOR: So this is a triangulated model
of a tesselation designed by Ray Schamp.
This is a waterbomb tessellation.
So first thing we want to do is to simulate folding
to understand the geometry, the kinematics of rigid origami.
This can be represented.
First easy representation is a truss model,
which you basically use vertex coordinates as the variables
and then constrain them with rigid bars that
are connected to vertices.
And this one is different representation
that uses folding angle.
This is a more direct way, and I have a software
called Rigid Origami Simulator which basically
is based on this constraint and representation.
The configuration is represented by folding angles,
and then the folding angles are constrained at each vertex
by this equation, which is a three by three matrix
form, which actually gives nine equations,
but only three of them are independent.
We have three equations for each vertex.
That will give also under-determined system
so that you can simulate folding using also generalized inverse
so that you can search within the solution space
by giving some pieces kind of a force that's asserted to each
of the edges, and then this results
in the deformation that is valid.
In generic case, because there are
three constraints for each vertex
and one variable for each edge, we have this degree of freedom.
First way to design rigid origami is
to use this information from Euler's polyhedral formula,
we can say that any triangular mesh-- well, not any.
It's a generic triangular mesh-- produces a degree of freedom,
which is number of edges on the boundary minus 3.
So for example, in this [? hyper ?] triangular model,
this gives one degree of freedom because the boundary
edges are four.
And we can generalize it to cases
where there are holes also.
With this idea, you can make hexagonal tripod shell, which
is using six edged, hexagonal boundary,
so that the degree of freedom is three,
and then we pin joint three of the vertices, which
gives nine constraints.
Because of the rigid body degree of freedom, which is six,
we have nine degrees of freedom of transformation,
and then that's our constraint by nine,
so it produces static structure.
By changing the position of these points,
you can get the different forms.
For example, this is the shape, triangular form.
The position of these pods changes the overall shape,
and it's static when it's fixed, it's all pin joint.
This is an example.
If you change the position of the leg,
then you get the different shapes,
3D configuration like this.
This is one way to build rigid origami structures.
This is quite obvious result.
Theoretically, it's more interesting to think about
the one that you cannot imagine the transformation,
for example, quadrilateral mesh.
So for quadrilateral mesh, each vertex
has also three constraints so that this itself
forms a one DOF structure.
Think about when you form a mesh with this, like Miura-Ori.
Basically, if you define this folding angle,
then all the folding angles here are defined.
If you have another degree for vertex,
then everything is here defined, and you
want to have another vertex here that
is defined by this folding angle.
Then you will have a problem here because this folding angle
and this folding angle contradict.
In general, it contradicts so that you cannot make an array
of folding by quadrilateral mesh.
However, as you can see from this figure,
there exist examples like Miura-Ori
that give one degree of freedom motion.
This is actually a very interesting thing happening.
And also, this is great because all the constraints
are redundant.
You can remove this part, so you can put a hole in the center,
but still, it results in the same motion.
You can design more freely with this kind
of robust, redundant constraint structure.
What I want to do is to generalize this to a freeform.
We start from Miura-Ori and also start
from this pattern, which is not a developable surface,
but also gives one degree of freedom motion
with redundant constraints in its quadrilateral mesh design.
These can be generalized to rigid, non-symmetric forms.
Miura-Ori is something like that,
and we can extract the property of rigid folding
by looking at these vertex.
If it's a flat foldable vertex, it's
a degree four vertex with flat foldability,
and this gives a folding motion where
the opposite folding angle are the same
and these are the same, and also,
that the folding angle here and here are related.
If you look at the tangent of half of the angle,
then it's linearly related.
This is very useful because if you find one configuration that
works, then you will have continuous folding that works.
In this way, you can make sufficient condition
for making a quadrilateral mesh rigid foldable.
This is easy to get because it's only the finite folding motion.
So the continuous folding motion from a sheet
to the folded state is guaranteed
by one 3D configuration that satisfies these conditions.
In order to get one configuration that
satisfies this configuration, we can use the Freeform Origami,
so it's very easy for us to do that.
This is an example of rigid origami
that's using redundant constraints.
It produces one degree of freedom motion
and it's very light because this part and this part
counterbalance the gravity.
This is another example.
Quadrilateral mesh can be a rigid folding motion.
You can apply to something like curve folding.
It's rigid foldable curve folding.
This is kind of contradictory, but we
can rationalize curve folding into quadrilateral mesh.
Then you can produce one degree of freedom motion like that.
Another example with thickness is here.
It's interesting that it's one degree of freedom motion
so that every motion is coded in the pattern here.
Another example is using Eggbox pattern.
This actually has the same property
as the Miura-Ori vertex or flat foldable degree for vertex,
so that you can use the same idea
to produce rigid foldable variations.
You can actually combine with origami structure
if you define this mountain fold, valley fold,
and also add complementary mountain fold
and complementary valley fold, defined here.
If you use that kind of extension of the origami,
then you will get design variations
that combine origami.
This part is origami vertex but this is not.
This can have positive Gaussian curvature
while this part is zero Gaussian curvature.
The interesting point is that you
can develop the flat folded state
or actually, in this case, it's two flat folded states because
in this case, it's not totally developed,
but complementary fold lines are folded.
So that's why I call it bidirectionally flat foldable
planar quadrilateral mesh, and that can be rigidity foldable.
This is an example.
This was about a disk, and we can
develop into a cylindrical structure.
And cylinder is not trivial because, for example, this
is known origami pattern, but this
doesn't transform to this pattern
because this is has a different number or edges.
You cannot produce this kind of motion in rigid folding
mechanism.
You can see what's the problem by looking at this kind of disk
surface that is rigidly foldable,
and it forms a cylinder at one state
but it doesn't produce in a continuous motion that
fix this loop.
But there exists.
So the idea is to mirror reflect one part of Miura-Ori vertex.
Actually, you can see from the origami model by Thoki Yenn.
It's called Flip Flop.
It's a very interesting model.
You can develop more generalized origami cylinders like these.
I think this is rigid foldable cylinders.
Since it's using quadrilateral panels,
it similarly produces one degree of freedom motion.
And you can see, for example, like that.
This is the motion produced.
Any part produces the whole motion.
And also, you can make some kind of design variations.
This is using grasshopper on rhinoceros.
This is the given shape, the section, and from the section,
you can make a rigid foldable cylinder and also
composite structures like this.
So we can make composite structures
like this, so it's great that it fills the space.
It tessellates while preserving the one
degree of freedom motion.
This is an implementation with thick panels.
Think I have got the cylindrical tessellation model.
This is a tessellated model, which moves like that.
It's kind of a volume that flattens into two states,
and it's good that it's rigidly foldable
and it's one degree of freedom mechanism.
I want to generalize more.
This is symmetric.
There exists one axis that repeats the unit structure.
I want to make it more general.
I like the asymmetry than symmetry.
I think you do also.
But you have to think about the conditions around a hole,
and actually, this is a difficult condition
to be solved then the disk version.
However, you can do that by fixing the first loop,
then you know that this part is rigid foldable,
so you can continue deformation from there.
This is kind of sufficient condition,
but useful for designing something like this.
It's more free form.
For example, this is also one degree
of freedom rigid foldable cylinder.
This is an example folded.
It folds like that.
This is also an example.
This forms a torus when it's unfolded.
Or this type of structure.
So it's also cylindrical.
And for kind of architectural image.
This is a rigid origami for cylinder.
And how to implement rigid origami to real model,
because in architecture design or any other designs,
we want some kind of finite thickness model.
There's no ideal origami.
Well, probably Origamido can produce.
Anyway, we want some thick panels and rotating hinges
to produce rigid origami.
This is the typical way to do that.
So you put the hinge on the valley side.
The main problem of this one is that each vertex, there
are several fold lines that are joining at the vertex,
but this will no longer be concurrent.
But rigid origami mechanism assumes that the fold lines are
concurrent, which means that it includes translation
constraints and it increases the number
of constraints for each vertex.
So previously, it was three constraints there,
but it becomes six constraints because it includes
transformation, which is very bad,
but there is asymmetric vertex that allows that.
So using asymmetry, you can make something like that.
Also, there is a way that you can slide the hinge like that,
but there is a problem in the case like this.
The problem of sliding is in global accumulation of errors.
So what I do is instead of shifting hinge,
you can trim the volume of the vertex valley
side of the model.
This is actually very easy.
You assume that this folds to pi minus delta,
and you can just remove this part
according to this maximum folding angle.
And you can define this point by offsetting the edges, which
is basically calculating with a straight skeleton.
This also can be applied to constant thickness
panels, which is more easy to be manufactured,
only with three axis milling machine.
This is a thick panel, thick rigid origami
using this method.
This is an example using a constant thickness model
where no error is accumulated, like this model,
a slideable hinge.
This is implemented by using grasshopper again.
Grasshopper is a good tool to implement something
that does not require iterative optimization calculation,
but it's very good for forward calculation of geometry.
That calculates the pattern, and then you
can lay out the pattern.
This is a cloth, and we put the thick panels
on both sides of the cloth to make a rigid foldable structure
like this.
In the center, there is a cloth that
represents the ideal origami.
This is what happens.
I would like to give an example of rigid origami
design for architecture.
So this example is that we are given existing building
openings, and we want to connect these openings temporarily.
I want that to be compactly folded to fit to this facade,
but because this is quite large like that,
you cannot make from a flexible material.
That will be a problem if you make it as a structure.
So in order to solve that kind of problem,
we can use freeform origami to design to fit the condition.
So these red lines are the openings of two buildings that
are actually not parallel, and the sizes are different.
But still, you can connect it on freefrom origami,
and also, you can keep the boundary to fit on the ground,
and then you can get these form variations
and you can choose one of them and calculate the paneling
patterns.
This is a rendering representation,
but basically, you can make this kind of structure
that can connect to buildings.
Thank you very much.
[APPLAUSE]
This was more hand craft thing.
I did this with Dukes there, and we
wanted to test the metal folding,
whether curved folding is useful for manufacturing things.
I think that's true, but this model
required a lot of hammering and it wasn't so easy.
I think you can have a way to make
it more easily constructed.
So this is a table just by folding
a sheet of metal or chair.
This one?
So this one is a combination of four papers.
In this case, I did not restrict to be
foldable from one sheet of paper.
Well, for design, I do not do that.
You can only find it by simulating
and see the collision.
Basically, there will be no local collision
for this quadrilateral mesh, but there
might be some global collisions where this and this part
are colliding.
AUDIENCE: For example, for Ron Resch pattern.
PROFESSOR: Ron Resch pattern.
I only do a local collision test,
which is between facets that are adjacent,
which still works for that kind of good model.
I think I will show all of the things here.
Like that.
PROFESSOR: Any other questions?
All right.
Thanks again.
PROFESSOR: Thank you very much.
[APPLAUSE]