Lecture 6: Architectural Origami

Lecture 6: Architectural Origami


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]

1 thought on “Lecture 6: Architectural Origami

Leave a Reply

Your email address will not be published. Required fields are marked *