We present a design technique for generating rigidly foldable quadrilateral meshes (RFQMs), taking as input four arrays of direction angles and fold angles for horizontal and vertical folds. By starting with angles, rather than vertex coordinates, and enforcing the fold-angle multiplier condition at each vertex, it is possible to achieve arbitrarily large and complex panel arrays that flex from unfolded to flatly folded with a single degree-of-freedom (DOF). Furthermore, the design technique is computationally simple, reducing for some cases to a simple linear-programming problem. The resulting mechanisms have applications in architectural facades, furniture design, and more.

Introduction

Many techniques of origami, the art of paper-folding, have found their way into technological applications. However, many of those applications require materials that are a good deal stiffer than paper: polymers, metal, wood, and composites. Realization in such materials commonly requires the creation of regions of localized compliance, e.g., hinges, along fold lines, and between otherwise rigid panels. The need to reproduce the folding motion of the original origami—going from an unfolded or flat-folded state to a deployed state—with such stiff materials restricts the range of usable patterns to those that are rigidly foldable: those in which, throughout the folding motion,

  • planar facets remain planar and

  • creases and vertices remain geodesically fixed.

Consequently, the topic of rigid foldability in origami mechanisms has been of great interest for many years [113].

Origami models can be considered to be compliant mechanisms because their motion comes from the deflection of flexible materials [14]. Rigidly foldable origami can be modeled using the pseudo-rigid-body model concept [15] where creases are modeled as revolute joints and panels as rigid links. This results in rigid-link spatial mechanisms that can be modeled using the methods traditionally employed to model the kinematics of rigid-link mechanisms [1619].

Major progress in the field of rigid foldability came in the 2009–2010 work of Tachi [7,9,10], who developed a theory of rigidly foldable quadrilateral meshes (RFQMs) composed of developable vertices—those whose surrounding sector angles sum to 360 deg, or, equivalently, those that unfold to a flat sheet. Notably, he identified an invariant that existed for flat-foldable degree-4 vertices; the ratio of half-angle tangents between all fold pairs was a constant, independent of the folded state. This led to the result that in any quadrilateral mesh of developable flat-foldable vertices, if there existed a single intermediate folded state, one between unfolded and flat-folded, then the entire pattern formed a single degree-of-freedom (DOF) mechanism that flexed from fully unfolded to fully flat-folded, limited only by self-intersection avoidance. Based on this idea, Tachi developed a software tool, rigidorigamisimulator [13], in which one could design rigidly foldable mechanisms (as well as nonrigidly foldable structures) by manipulating selected vertices of a general quadrilateral array subject to computer enforcement of developability and/or flat-foldability at each vertex.

The requirement of existence of some intermediate state is nontrivial, however. In a paper analyzing origami twist patterns, Evans et al. [4] showed that there were meshes consisting entirely of flat-foldable vertices for which no such intermediate state existed. We introduced the term fold-angle multiplier to describe the invariant ratio and showed that for many twist fold patterns, dependencies within the pattern created closed inequality loops of the form a > b > c > a among fold angles, which were unsatisfiable. That work underscored the importance of fold angles (versus vertex coordinates) in the design of developable flat-foldable RFQMs. Indeed, a complete description of the kinematics of such structures can be built just from its angles: the fold angles at the vertices and the sector angles around each degree-4 vertex (D4V).

In this paper, we present a design algorithm for developable locally flat-foldable rigidly foldable quadrilateral meshes—henceforth, DLFF-RFQMs—that is built from angles. We take as our design inputs two arrays of fold angles and direction angles that, together, fully specify a single degree-of-freedom rigidly foldable mechanism. We begin with a brief recap of the relevant kinematic relationships and then present a step-by-step design algorithm that proceeds from the angle arrays to a fully constructed mechanism. The full design algorithm requires the solution of a constrained optimization problem. We show that for rectangular crease patterns, this step reduces to a simple linear-programming problem. We show how various design goals may be incorporated naturally as additional constraints in the optimization and then present several design examples that show the diversity of possible mechanisms that can be achieved. We then close with some discussion of applications and prospects for the future.

Background

Fold angles are the angles at folds, are conventionally defined as the deviation from flatness [20], and are characterized as valley folds for positive fold angle and mountain folds for negative fold angle. Figure 1 shows an example of each and the convention for how it is defined.

The kinematic relationships for a flat-foldable D4V are shown in Fig. 2. The vertex has fold angles γ1γ4 and sector angles α1α4, where a sector angle is the angle between consecutive folds around a vertex.

The vertex being flat-foldable, the sector angles satisfy the Kawasaki–Justin condition [21] 
α1α2+α3α4=0
(1)

A flexible D4V will have three fold of one mountain-valley assignment, one of the other. The two fold opposite each other with the same assignment are the major folds; in Fig. 2, γ2 and γ4 are the major fold angles. The two opposite folds with different assignment are the minor folds; in Fig. 2, γ1 and γ3 are the minor fold angles. Major fold angles are equal to each other (γ2 = γ4); minor fold angles are equal and opposite sign (γ1 = −γ3).

There is an inequality relationship between major and minor fold angles 
|γ2,4||γ1,3|
(2)
with the relationship being equality at unfolded and flat-folded and strict inequality at all fold angles in between. These and related relationships may be found in Ref. [5].
The key relationship for our purposes is that of the fold-angle multiplier μ, the ratio between adjacent fold half-angle tangents. For the configuration of Fig. 2, we define 
μi,jtan12γjtan12γi
(3)
All of the {μi,j} are invariants of the crease pattern. Multiplier μ1,2 is given by Evans et al. [4] as 
μ1,2=sin12(α1+α2)sin12(α1α2)
(4)

and Eq. (3) must be satisfied for all folded states. From Eq. (2), it is clear that |μ1,2|1 for all fold angles.

An equivalent formula was given by Tachi [7,10]; similar angular relationships between adjacent fold angles for developable vertices have been presented by others [22,23], and a similar relationship applies to the vertices of the nondevelopable discrete Voss surface [24]. This particular form has the desirable features of simplicity and validity for all combinations of signs of the fold angles.

Since γ2 = γ4, we also have that μ1,4=μ1,2, and so μ1,4 is also given by Eq. (4). Substituting α1=πα3 and α2=πα4 into Eq. (3) gives another form 
μ1,4=sin12(α4+α3)sin12(α4α3)
(5)
Note, though, that this does assume that γ2 and γ4 are the major-fold angles. It is straightforward to rearrange vertex indices to obtain the equivalent ratio for γ1 and γ3 major. If we cyclically permute the indices 12,23,34,41, then μ1,4μ2,1, and its value becomes 
μ2,1=sin12(α1+α4)sin12(α1α4)
(6)
Thus, for γ1 and γ3 major, we have that |μ1,2|1 and 
μ1,2=sin12(α1α4)sin12(α1+α4)
(7)

Quad Meshes

In a rigidly foldable quad mesh whose vertices are all developable and flat-foldable D4Vs, since the magnitude of the fold angle is constant across each vertex, the folds can be organized into continuous chains running vertically and horizontally in which the fold-angle magnitude is constant for each entire chain. However, the sign may or may not switch at any given vertex, depending on whether the chain is major or minor at that particular vertex. A chain of fold angles could be major at one vertex, minor at the next, depending on the relative magnitudes of the fold angles of the two chains intersecting at the vertex.

Because of Eqs. (3), (4), and (7), the fold angles and sector angles at a vertex cannot be chosen entirely independently. In the conventional way of looking at crease patterns, the sector angles {αi} are given, setting the value of μi,j; then by choosing one fold angle, Eq. (3) implicitly determines the adjacent fold angles.

However, there is another way to look at this: we could instead take the two fold angles as given. In this case, we can choose only one of the sector angles; the other three must be set to satisfy the Kawasaki–Justin condition, Eq. (1), and Eqs. (4) and (7).

If we carry out this procedure for the vertex of Fig. 2 with γ2 and γ4 major, the fold-angle multiplier μ1,2 is given by Eq. (3) and the four sector angles can be shown to be 
α1=arbitraryα2=2cos1|1+μ1,2|cos12α11+μ1,22+2μ1,2cosα1α3=πα1α4=πα2
(8)
If, however, γ1 and γ3 are major, then we will have 
α1=arbitraryα4=2cos1|1+μ1,2|cos12α11+μ1,22+2μ1,2cosα1α3=πα1α2=πα4
(9)

We can use these relationships to define an entire RFQM, because they imply a directional flow of design information: we can choose design parameters along two edges of the pattern that fully define the relevant angles at those edges and then use the relationships in Eqs. (8) and (9) to propagate the fold angles and sector angles across the pattern.

Specifically, if we come in from left and bottom with two fold with angles γ1 and γ2 traveling at specified direction angles, the angle between the two fold will determine the sector angle α1; this will, in turn, determine the other three sector angles, and thus, the direction angles and fold angles of the two outgoing folds. By selecting initial conditions of fold angle and direction angle along two sides of an RFQM, we can then propagate the fold angles and direction angles throughout the entire mesh, thereby completely determining its kinematic behavior. Furthermore, by ensuring that the flow of information is unidirectional, we can completely avoid the unsatisfiable inequality loops that arise in, for example, rigidly foldable twists [4].

Note, however, one constraint implicit in this formulation. If two adjacent folds have the same fold-angle magnitude, then we will have |μ1,2|=1, which will make one of the sector angles zero. This is not allowed; thus at any interior vertex, no two adjacent folds can have the same fold-angle magnitude.

Kinematic Design

Equations (8) and (9) are the heart of the algorithm, but some care must be taken to ensure information flow directionality and to determine what quantities may be chosen and which ones are determined by equations and constraints. We take as our architecture a mesh of quadrilateral panels, with nh panels in the horizontal direction and nv panels in the vertical direction. We index vertices, edges, and faces as shown in Fig. 3.

We partition the edges into two sets: those running predominantly horizontally (shown in gray) and those running predominantly vertically (in black). Each index pair (i, j) applies to the facet it is drawn in, the edges to left and below, and the vertex to lower left, as indicated in the figure. Note that each of the horizontal or vertical pair could be major or minor, depending on the relative fold-angle magnitudes.

With each horizontal and vertical edge, we associate direction anglesϕh,i,j and ϕv,i,j, respectively, which are the angles with respect to the x-axis of each edge from one vertex to the next in the unfolded state, as illustrated in Fig. 4. Similarly, we associate fold angles γh,i,j and γv,i,j with their corresponding edges.

The kinematic behavior is constrained for creases that touch interior vertices of the pattern. Thus, we take as initial conditions the fold angles and direction angles along the bottom and left sides of the pattern of the creases that extend into the pattern. That is, we take as our inputs 
ϕh,i,0:i=1,,nh1γh,i,0:i=1,,nh1ϕv,0,j:j=1,,nv1γv,0,j:j=1,,nv1
(10)
The last condition in Sec. 3 translates into a condition on the input angle arrays 
|γh,i,0||γv,0,j|fori=1,,nh1,j=1,,nv1
(11)

At each vertex, inputs come from the bottom and left; outputs are the top and right. We show the (i, j) vertex as an example, illustrated in Fig. 5.

The direction angles ϕh,i1,j and ϕv,i,j1 and their corresponding fold angles γh,i1,j and γv,i,j1 are known. That sets two of the fold angles of the vertex 
γ1=γh,i1,jγ2=γv,i,j1
(12)
The sector angle α1 is given by 
α1=ϕv,i,j1ϕh,i1,j
(13)

If |γ2|>|γ1|, then γ2 and γ4 are major; Eq. (8) gives the other three sector angles and γ4=γ2,γ3=γ1. Otherwise, if |γ2|<|γ1|, then γ1 and γ3 are major; Eq. (9) gives the other three sector angles and γ4=γ2,γ3=γ1. Note that no horizontal fold-angle magnitude can be equal to any vertical fold-angle magnitude.

Once we have all four sector angles, then we can construct the outgoing direction angles by inspecting Fig. 5  
ϕh,i,j=ϕh,i1,j+π(α3+α4)ϕv,i,j=ϕh,i,j1+π(α2+α3)
(14)
The outgoing fold angles are 
γh,i,j=γ3γv,i,j=γ4
(15)

By following this procedure, working from the bottom upward and rightward, we can construct fold angles and direction angles for all interior creases of the crease pattern. This fully defines the kinematic behavior of the entire mechanism.

On the boundary, there is no fold angle. For simplicity and definiteness, we can set all boundary fold angles to zero. The boundary direction angles, however, have meaning and need to have values. There are two possible approaches:

  • Choose their values.

  • Leave their values as variables to be optimized.

A fixed-value strategy would arise if, for example, we would like to force the paper to be rectangular. In this case, we would set 
(bottom)ϕh,i,0=(top)ϕh,i,nv=0,fori=0,,nh1(left)ϕv,0,j=(right)ϕv,nh,j=π/2,forj=0,,nv1
(16)

Leaving them as values to be optimized brings up the obvious question: what are the variables to be optimized over? And another question: what are the coordinates of the vertices? These two questions are related, as it turns out, and we turn now to them both.

Embedding

There remain several quantities in the design still to determine. In particular, we must determine the lengths of all of the creases. We introduce length variables lh,i,j and lv,i,j for each of the horizontal and vertical edges.

Let pi,j be the (i, j)th vertex. We can choose one vertex arbitrarily; for simplicity, we take 
p0,0=(0,0)
(17)
We can then construct the remaining vertices from the edge lengths and direction angles. For example, traveling up the left side, we will have 
p0,j=p0,j1+lv,0,j1û(ϕv,0,j1)
(18)

where û(ϕ)(cosϕ,sinϕ) is the unit vector at direction angle ϕ.

Then, marching across each horizontal chain of creases, we will have 
pi,j=pi1,j+lh,i1,jû(ϕh,i1,j)
(19)

It is important to note that each of the {pi,j} is a linear combination of the edge-length variables. Figure 6 shows schematically how the vertices are constructed relative to one another, by following the shaded lines of the spanning tree of the crease pattern.

Each shaded line in Fig. 6 indicates a crease at which by construction, the positions of the two vertices at each end are consistent with the length and direction of the crease. However, that leaves the unshaded edges. For each of these, there is an equality constraint that must be satisfied. The individual constraints are 
pi,jpi,j1=lv,i,j1û(ϕv,i,j1),fori=1,,nh,j=1,,nv
(20)

Each of these constraint equations is also linear in the edge-length variables.

The resulting system is generally underconstrained with respect to the edge-length variables; there are (nh)(nv+1) horizontal edges, (nh+1)(nv) vertical edges, and (nh)(nv) equality constraints, leaving nhnv+nh+nv degrees-of-freedom in the system.

We also have inequality constraints. The edge lengths must be non-negative; otherwise, there would be crease lines crossing each other at places other than vertices. So we must have at the very least inequality constraints on every edge length of the form li,j,k0.

In fact, at least some of the edge lengths must be strictly positive to prevent the entire system from collapsing to a point. We might well wish to set a minimum nonzero edge length on every edge or on some subset. If the edge length is nonzero on every edge, then it guarantees that all facets are quadrilateral and all vertices are degree-4. If we allow some edges to be zero length, it will collapse some facets to triangles (or to vanish) and merge some vertices into vertices of higher degree. This might well give useful and desirable folding patterns, and the resulting patterns will be guaranteed of at least one degree-of-freedom in their motion, but they might well have picked up additional degrees-of-freedom by the merging of vertices into vertices of higher degree.

The choice of minimum edge length and other constraints will be driven by esthetic choices, but there is one particularly simple and useful set of choices:

  • We set a minimum edge length of one on all edges, to ensure that all edges participate visibly in the folding mechanism.

  • We choose to make the paper rectangular, which thereby sets all of the boundary direction angles.

  • Since it is esthetically undesirable to have enormous contrast between edge lengths, we take the total of all edge lengths as the figure-of-merit to minimize.

This choice gives a system where the figure-of-merit, equality constraints, and inequality constraints are all linear in the edge-length variables. Hence, the problem reduces to a linear-programming problem, for which fast and efficient solutions are readily available.

We have constructed a Mathematica function that takes as input four angle arrays—direction angles and fold angles, along the bottom and left side—and returns a crease pattern and folded form for a rectangular-paper pattern with the specified angles.

The input angle arrays—direction and fold angles for left and bottom—serve as a concise encoding of the kinematics. We give them as ordered lists. For the left side (l), the inputs initiating the folds that propagate roughly left-to-right will be 
ϕl=(ϕh,0,1,,ϕh,0,nv1)γl=(γh,0,1,,γh,0,nv1)
(21)
and for the bottom (b), the inputs initiating the folds that propagate bottom-to-top will be 
ϕb=(ϕv,1,0,,ϕv,nh1,0)γb=(γv,1,0,,γv,nh1,0)
(22)
A simple example is shown in Fig. 7, to illustrate how the direction angles and fold angles are mapped to and determine the crease pattern and folded form. They are 
ϕl=(30deg,20deg)γl=(25deg,35deg)ϕb=(80deg,100deg)γb=(85deg,95deg)
(23)

Each pattern is a single-DOF mechanism, so there are multiple sets of fold angles that will give the same crease pattern, but a different folded state somewhere between unfolded and flatly folded.

Suppose we have a fold pattern characterized by sector angles {αi} and fold angles {γi}. The fold-angle multiplier between any two fold angles is given by Eq. (3) as 
μi,j=tan12γjtan12γj
(24)

Any transformation of all fold angles that preserves this ratio will also preserve all sector angles and so constitutes a valid set of fold angles for the same sector angles and thus for the same crease pattern.

We define the fold-angle transformation functionfm(γ), parameterized on a scaling factor m, by 
fm(γ)2tan1(mtanγ2)
(25)

It is readily verified that making the substitutions γifm(γi),γjfm(γj) in Eq. (24) leaves the value of μi,j unchanged. Thus, for any real number m, applying fm to all of the fold angles of a design set will give the same crease pattern, but a different state of the folded form. Figure 8 shows four different states of the folded form of Fig. 7 for different values of m.

Figure 9 shows two examples that reproduce known DLFF-RFQMs: the Miura-ori [25] and Barreto's Mars [26] (also known as Sakoda's Staircase [27]), defined by angle arrays 
ϕl=(30deg,30deg,30deg,30deg)γl=(90deg,90deg,90deg,90deg)ϕb=(90deg,90deg,90deg,90deg)γb=(53.13deg,53.13deg,53.13deg,53.13deg)
(26)
for the Miura-ori and 
ϕl=(0deg,0deg,0deg,0deg)γl=(90deg,90deg,90deg,90deg)ϕb=(90deg,90deg,90deg,90deg)γb=(60deg,60deg,60deg,60deg)
(27)
for Mars/Staircase. Direction angles ϕl and fold angles γl apply to the creases incident to the left edge (going from bottom to top); angles ϕb and fold angles γb apply to the creases incident to the bottom edge (going from left-to-right).
Using exactly the same direction angles and fold-angle magnitudes as Mars but swapping some fold-angle signs as in Eq. (28) gives a very different pattern, shown in Fig. 10  
ϕl=(0deg,0deg,0deg,0deg)γl=(90deg,90deg,90deg,90deg)ϕb=(90deg,90deg,90deg,90deg)γb=(60deg,60deg,60deg,60deg)
(28)

The internal fold directions are different, of course owing to how the fold-angle signs affect the sector angles of the interior vertices; the spacings between folds also differ, owing to the different influences of the minimum edge length set on all edges.

If we allow (or force) selected edges to go to zero length, then we can achieve patterns that have vertices of higher degree. Figure 11 shows two such patterns, with design angles 
ϕl=(0deg,0deg,0deg,0deg)γl=(20deg,20deg,20deg,20deg)ϕb=(90deg,90deg,90deg)γb=(75deg,150deg,75deg)
(29)
and 
ϕl=(0deg,0deg,0deg,0deg)γl=(120deg,120deg,120deg,120deg)ϕb=(90deg,90deg,90deg)γb=(45deg,90deg,45deg)
(30)
respectively.

In isolation, degree-6 vertices have three degrees-of-freedom, so such a pattern is not a priori constrained to a single-DOF. However, if a degree-6 vertex is surrounded by D4Vs, as is the case in both of these mechanisms, the surroundings will constrain the vertex so that the entire mechanism is single-DOF; this is the case for both mechanisms shown in Fig. 11.

Optimization Constraints

As long as the vertical and horizontal fold-angle set has no fold-angle magnitude in common, the procedure outlined in Sec. 5 is guaranteed to produce a kinematic set of sector angles that gives a single degree-of-freedom mechanism. However, there is no corresponding guarantee that the linear programming problem that defines the edge lengths gives a noncrossing crease pattern, i.e., a crease pattern with all-non-negative edge lengths. In fact, it is quite easy to find sets of angle values for even quite small patterns for which no solution can be found under the rectangular-paper assumption.

The reason for this is simple: once we have chosen the input angles, all of the angles in the crease pattern are fully specified, and the input choices might well have caused the quad mesh to distort so much that the boundary direction angles are constrained to ranges that don't include the values of 0 and π/2 specified earlier.

To avoid this problem, we can eliminate the rectangular-paper constraints and now allow the boundary direction angles ϕh,i,{0,nv+1} and ϕv,{0,nh+1},j to become variables in the optimization. In this case, the constraints of Eq. (20) are now not all linear in the variables, and the optimization becomes nonlinear. However, such system can still be solved with conventional nonlinear constrained optimization routines, and in practice, finding a solution that minimizes total edge length with unconstrained angles on the boundary (if one exists) is usually straightforward. (We qualify “usually” because successfully finding a solution often depends on the initial position within the search space.)

If we remove all constraints from the boundary, it is possible to have the corners entirely vanish (i.e., their incident edges become collinear). This may be avoided (for esthetic reasons) by setting additional constraints on the corner angles: for example, ϕv,0,0ϕh,0,0=π/2 to get a right angle at the lower left corner and similarly for the other three corners.

Figure 12 shows an example of a set of angle arrays that cannot be achieved with rectangular paper but that gives a straightforward solution with unconstrained boundary. Angles are 
ϕl=(0deg,0deg)γl=(90deg,45deg)ϕb=(80deg)γb=(135deg)
(31)
We note as well that it is possible to build a parametric model of the folded form prior to optimization, thereby allowing one to set constraints on the folded form as part of the overall optimization. One especially useful constraint applies to mechanisms to be used for paneling or facades, for which it is desirable to have many parallel panels be coplanar, to facilitate attachment to a backing surface. We show in Appendix  A how to construct the vertices of the folded form in a way that supports incorporating such constraints into the optimization. Figure 13 shows an example of the application of a coplanarity constraint to the pattern 
ϕl=(0deg,0deg,0deg,0deg)γl=(135deg,135deg,135deg,135deg)ϕb=(90deg,90deg,90deg,90deg,90deg)γb=(108deg,72deg,72deg,72deg,108deg)
(32)

Most of the examples we have shown are, more or less, planar, and that is a useful property for many applications, but there is no particular restriction to planarity. Figure 14, for example, shows a rigidly foldable pattern that forms a polyhedral tube. Because the pattern is periodic, it can be extended arbitrarily in the obvious way.

Note the qualification mentioned earlier for a solution to the unconstrained-boundary case: “if it exists.” For the rectangular-boundary problem, the optimization is a linear-programming problem, and so if the solver finds no solution, we can be assured that none exists. For the unconstrained boundary, the solution is a general nonlinear constrained optimization, and so lack of finding a solution does not mean that one does not exist; it might just mean we started the search in the wrong place.

However, we can show that there are definitely combinations of angles for which there is no noncrossing solution, even in the unconstrained-boundary case. We show this by considering the form of a vertex when one of the fold angles is very much smaller than the other or very much closer to flat-folded than the other. These two configurations are illustrated in Fig. 15.

In both cases, in the limit as ε0, the vertex approaches the straight-major condition, with collinear major folds.

That means that every rectangular-boundary problem can be embedded within a larger unconstrained-boundary problem, as illustrated in Fig. 16.

In the limit as ε0, if there is no solution to the rectangular-boundary problem, then there can be no solution to the larger unconstrained-boundary problem. This establishes that there must be some particular combinations of angles for which even the unconstrained-boundary case has no noncrossing solutions.

Fabrication

In order to verify the theory and computed models (and to show some more complex patterns than the simple illustrations of principle mentioned earlier), we have fabricated several examples from wood veneer laminate. We used Sanfoot wood veneer from Hokusan Ltd., Tokyo, Japan [28], and laser-scored the material, cutting through the wood (but not the backing) to produce a pattern with rigid panels joined by flexible hinges. The material is quite thin (approximately 0.23 mm), and so no thickness-accommodating techniques [2] were required: the zero-thickness model gives a very good representation of the actual behavior.

Figures 17 and 18 show two fabricated examples, crease patterns and photographs of the finished figures.

Many more pattern examples may be found in the supplementary material of Ref. [29].

Conclusions

We have developed a design methodology for the creation of rigidly foldable quadrilateral meshes that by choosing as inputs the fold angles and direction angles along two sides of the array is guaranteed to produce a single-DOF mechanism that flexes smoothly from unfolded to flat-folded, with the range of motion limited only by self-intersection and the crease patterns limited by the possibility of self-crossing faces.

There is particular application for the construction of decorative architectural features, facades, and design elements. We illustrate the possibilities in our examples created from folded wood veneer. This technique allows the creation of deeply incised complex patterns with minimal material and wastage; realizing such forms by, e.g., milling would be extremely challenging.

Because such patterns move kinematically, they may be used in applications that undergo repeated motion from stowed to deployed, including arrays, shelters, and adaptive architecture to provide dynamic shade and/or rain protection.

We note that the single-DOF mechanism makes the assembly of one of these patterns a bit delicate, since every crease within the pattern must fold at once (albeit at varying rates). Each vertex is individually in a singular state at flatness; there are four (or more) possible mountain-valley assignments, and once a vertex has started to collapse with one assignment, it will resist flipping to a different assignment. In practice, a good way to collapse such a pattern is to apply compression forces around the four sides, then carefully “pop” each vertex to its intended mountain-valley assignment. Once all vertices are initiated “going the right direction,” the entire pattern will smoothly fold together.

For hand-folding, this behavior presents a challenge. For production fabrication, the single-DOF motion could be taken advantage of. By creating a fixed custom jig to initiate the individual vertices into their proper directions, the entire pattern could then be assembled with relatively simple compression forces, rather than requiring individual actuators on each and every fold.

We have implemented the algorithm in the Mathematica environment; the code, including code for all figures presented in this paper, many more computed examples, and score patterns for the examples presented herein, is available in the supplemental material of Ref. [29]. The algorithm presented here is simple enough that it could readily be incorporated into mechanical engineering and/or architectural design tools, e.g., grasshopper/rhino.

Since every possible DLFF-RFQM of developable locally flat-foldable vertices can be described in this framework, this methodology is guaranteed to give them all, allowing systematic exploration of configuration space.

We note, though, that there is no guarantee that any particular set of angles {ϕl,ϕb,γl,γb} will give rise to a nonself-crossing crease pattern. Indeed, as we saw, if we impose the rectangular constraint, one can readily find angle sets for which only self-crossing crease patterns exist. If we relax the rectangular-paper constraint, making the equation set nonlinear, there may well be nonself-crossing solutions, but finding them often depends on the initial conditions of the numerical search, and, as we have seen, there will still be some sets of angles for which no nonself-crossing crease pattern exists.

As we build up a pattern from a set of input angle arrays, the fold lines propagate rightward and upward, but they change direction at each vertex, and because of the complex dependence of outgoing direction angle upon incoming fold angle and direction angle, it can be difficult to predict the overall shape of a pattern, even qualitatively, without carrying out the calculation. We have found, though, that an effective design strategy is to focus on developing small “building blocks” of creases—tiles, as described in Ref. [20]—that can then be combined by matching fold angles and directions into arbitrarily extensible arrays.

One interesting question is: how many topologically distinct DLFF-RFQMs are there for given (nh, nv), where the topology is characterized by the mountain-valley assignments of the creases? The problem of counting mountain-valley assignments can be quite complex: see, e.g., Ginepro and Hull [30] on counting mountain-valley assignments in Miura-ori patterns and related problems cited therein. The problem of counting mountain-valley assignments for DLFF-RFQMs is more tractable; we have given a solution in Appendix  B.

Adopting the topology of a quadrilateral mesh is convenient for indexing and describing the topology of the planar graph that is the mesh. However, our approach could readily be generalized to arbitrary networks of crossing chains of folds incorporating triangular and/or higher-order polygons. Dealing with the complex interplay between the mesh topology (determining which chain intersects which other chain, and where) and the sector angle dependence on input fold angles seems nontrivial but does suggest that there are further avenues to pursue within the framework outlined here.

Funding Data

  • National Science Foundation and Air Force Office of Scientific Research (Grant Nos. EFRI-ODISSEI-1240441, EFRI-ODISSEI-1332249, EFRI-ODISSEI-1332271, and EFRI-ODISSEI-1240417).

Appendix A: Construction of the Folded Form

The algorithm presented in the main body of this paper provides a rigidly foldable crease pattern. In order to complete the design algorithm (including applying constraints to the folded form, such as the coplanar-facet constraint illustrated in Fig. 13), we need expressions for the vertex coordinates of the folded form in terms of the optimization variables. We provide these here. A complete design code for both crease pattern and folded form is given in the supplemental materials of Ref. [29].

The folded-form vertices can be built up by following a spanning tree on the facets, similarly to how we built the vertex coordinates of the crease pattern. However, in order to keep the symbolic expressions for vertex coordinates tractable, we need to be careful about the order in which we build up the three-dimensional form.

The first quantities to build are the direction vectors for the creases and the surface normals of the facets. In two-dimensional, the direction vectors were simply given by û(ϕi,j,k). In three-dimensional, they will be unit three-vectors, as will be the surface normal vectors. We denote by dh,i,j and dv,i,j the edge direction vectors and denote by ui,j the facet normal vectors.

We introduce the matrix rotation R(θ,a) as the 3 × 3 matrix that rotates a vector through angle θ about axis a.

We fix the overall orientation of the folded form by choosing one direction vector and one facet normal vector. We choose 
u0,0(0,0,1)dv,1,0(0,1,0)
(A1)
Then 
dh,0,1=R(ϕh,0,1ϕv,1,0,u0,0)·dv,1,0dh,0,0=R(ϕh,0,0ϕv,1,0,u0,0)·dv,1,0dv,0,0=R(ϕv,0,0ϕh,0,1,u0,0)·dh,0,1
(A2)
to complete the direction vectors around the (0, 0) facet.
Next, we march along the bottom edge, i=1,,nh,j=0 
ui,0=R(γv,i,0,dv,i,0)·ui1,0dh,i,0=R(ϕh,i,0ϕv,i,0,ui,0)·dv,i,0dh,i,1=R(ϕh,i,1ϕv,i,0,ui,0)·dv,i,0dv,i+1,0=R(ϕv,i+1,0ϕh,i,1,ui,0)·dh,i,1
(A3)
Then, row by row upward, we fill in the rest. For i=0,j=1,,nv, we have 
u0,j=R(γh,0,j,dh,0,j)·u0,j1dv,0,j=R(ϕv,0,jϕh,0,j,u0,j)·dh,0,jdv,1,j=R(ϕv,1,jϕh,0,j,u0,j)·dh,0,jdh,0,j+1=R(ϕh,0,j+1ϕv,1,j,u0,j)·dv,1,j
(A4)
And finally, for i=1,,nh,j=1,,nv, we have 
ui,j=R(γv,i,j,dv,i,j)·ui1,jdv,i+1,j=R(ϕv,i+1,jϕh,i,j,ui,j)·dh,i,jdh,i,j+1=R(ϕh,i,j+1ϕv,i,j,ui,j)·dv,i,j
(A5)
With all of the direction vectors constructed, we can now construct vertices of the crease pattern {pi,j}. We can choose one of them to fix the position 
p0,0(0,0,0)
Then build the rest sequentially. Along the left side, i=0,j=1,,nv, 
pi,j=pi,j1+lv,0,j1dv,0,j1
(A6)
and then for each horizontal chain, i>0,j=1,,nv, 
pi,j=pi1.j+lh,i1,jdh,i1,j
(A7)

If one keeps track of the variables through all of those (or allows a symbolic manipulation program like Mathematica to do the bookkeeping), it is possible to use these expressions to build constraints on the folded form, like the coplanar back-plane example shown in Fig. 13.

Appendix B: Counting Mountain-Valley Assignments

Here we count the number of topologically distinct mountain-valley assignments for a DLFF-RFQM with flat-foldable vertices.

We note that the assignment of fold angles γh,0,j and γv,i,0 fully determines the mountain-valley assignment via two steps:

  • At vertex (i, j), which fold-angle magnitude is greater determines whether the vertex is major-horizontal or major-vertical.

  • Once the major direction is determined for all vertices, the signs of all fold angles in both vertical and horizontal chains are uniquely determined by the major direction at each vertex and the signs of the fold angles at left and bottom.

Thus, the number of distinct mountain-valley assignments is the product of the number of distinct major-direction assignments times the number of distinct sign assignments along the left and bottom. Since there are nv1 and nh1 folds to be assigned, respectively, those last two quantities are, respectively, 2nv1and2nh1.

To compute the number of distinct major-direction assignments, we construct a graph whose vertices represent the fold-angle magnitudes for the horizontal and vertical chains and that contains an edge for each interior vertex (i, j). Clearly, this graph is the complete bipartite graph [31], conventionally denoted by K(n, k), with in our case n=nh1,k=nv1. An example is illustrated in Fig. 19.

A major-direction assignment of a DLFF-RFQM corresponds to an orientation of this graph, assigning the edge γh,0,jγv,i,0 if the vertex is major-horizontal and γh,0,jγv,i,0 if it is major-vertical.

Since the major-direction assignment of the DLFF-RFQM comes from the total ordering of the fold-angle magnitudes, it follows that the only possible orientations of K(n, k) that give rise to DLFF-RFQMs are those that are sortable, i.e., those in which the vertex fold-angle magnitudes can be ordered consistently with the edge orientations. A digraph is sortable if and only if it contains no cycles.

Thus, the topologically distinct DLFF-RFQM major-direction assignments correspond one-to-one with those orientations of the complete bipartite graph that are acylic, and so the number of major-fold assignments is the number of acyclic orientations out of the 2(nh1)(nv1) possible orientations of K(nh1,nv1).

That number is known. Bényi and Hajnal [32, Theorem 10] present a result of Cameron [33] establishing that the number of acyclic orientations of K(n, k) is 
Bn(k)
(B1)
where Bn(k) is the poly-Bernoulli number introduced by Kaneko [34]. Thus, the number of major-direction assignments will be 
B(nh1)((nv1))
(B2)

Table 1 lists the first several values for combinations of nh and nv.

Thus, taking into account the possible fold signs along left and bottom edge, the total number of topologically distinct mountain-valley assignments for DLFF-RFQMs is 
2(nv+nh2)B(nh1)((nv1))
(B3)

References

References
1.
Chen
,
Y.
,
Peng
,
R.
, and
You
,
Z.
,
2015
, “
Origami of Thick Panels
,”
Science
,
349
(
6246
), pp.
396
400
.
2.
Edmonson
,
B. J.
,
Lang
, R. J.
,
Magleby
, S. P.
, and
Howell
,
L. L.
,
2014
, “An Offset Panel Technique for Thick Rigidly Foldable Origami,”
ASME
Paper No. DETC2014-35606.
3.
Evans
,
T. A.
,
Lang
,
R. J.
,
Magleby
,
S. P.
, and
Howell
,
L. L.
,
2015
, “
Rigidly Foldable Origami Gadgets and Tessellations
,”
R. Soc. Open Sci.
,
2
(
9
), p.
150067
.
4.
Evans
,
T. A.
,
Lang
,
R. J.
,
Magleby
,
S. P.
, and
Howell
,
L. L.
,
2016
, “
Rigidly Foldable Origami Twists
,”
Origami 6: Sixth International Meeting of Origami Science, Mathematics, and Education
, American Mathematical Society, Providence, RI, pp.
119
130
.
5.
Lang
,
R. J.
,
Magleby
,
S.
, and
Howell
,
L.
,
2015
, “Single-Degree-of-Freedom Rigidly Foldable Origami Flashers,”
ASME
Paper No. DETC2015-46961.
6.
Miura
,
K.
, and
Tachi
,
T.
,
2010
, “
Synthesis of Rigid-Foldable Cylindrical Polyhedra
,”
Symmetry: Art and Science
, pp.
204
213
.http://origami.c.u-tokyo.ac.jp/~tachi/cg/FoldableCylinders_miura_tachi_ISISSymmetry2010.pdf
7.
Tachi
,
T.
,
2009
, “
Generalization of Rigid Foldable Quadrilateral Mesh Origami
,” Symposium of the International Association for Shell and Spatial Structures (
IASS
), Valencia, Spain, Sept. 28–Oct. 2, pp. 1–8.http://www.tsg.ne.jp/TT/cg/RigidFoldableQuadMeshOrigami_tachi_IASS2009.pdf
8.
Tachi
,
T.
,
2009
, “
One-DOF Cylindrical Deployable Structures With Rigid Quadrilateral Panels
,” Symposium of the International Association for Shell and Spatial Structures (
IASS
), Valencia, Spain, Sept. 28–Oct. 2, pp. 2295–2305.http://origami.c.u-tokyo.ac.jp/~tachi/cg/RigidFoldableCylindricalOrigami_tachi_IASS2009.pdf
9.
Tachi
,
T.
,
2010
, “
Freeform Rigid-Foldable Structure Using Bidirectionally Flat-Foldable Planar Quadrilateral Mesh
,”
Advances in Architectural Geometry 2010
,
Springer-Verlag
,
Vienna, Austria
, pp.
87
102
.
10.
Tachi
,
T.
,
2010
, “
Geometric Considerations for the Design of Rigid Origami Structures
,” International Association for Shell and Spatial Structures Symposium (
IASS
), Shanghai, China, Nov. 8–12, pp.
458
460
.
11.
Tachi
,
T.
,
2011
, “
Rigid-Foldable Thick Origami
,”
Origami 5: Fifth International Meeting of Origami Science, Mathematics, and Education
, CRC Press, Boca Raton, FL, pp.
253
264
.
12.
Tachi
,
T.
,
2013
, “
Composite Rigid-Foldable Curved Origami Structure
,”
First International Conference on Transformable Architecture (Transformables 2013)
, Seville, Spain, Sept. 18–20, pp.
18
20
.
13.
Tachi
,
T.
, 2018, “Software: Freeform Origami, Origamizer, Rigid Origami Simulator,” Tomohiro Tachi, Tokyo, Japan, accessed Jan. 23, 2018, http://www.tsg.ne.jp/TT/software/
14.
Greenberg
,
H. C.
,
Gong
,
M. L.
,
Magleby
,
S. P.
, and
Howell
,
L. L.
,
2011
, “
Identifying Links Between Origami and Compliant Mechanisms
,”
Mech. Sci.
,
2
(
2
), pp.
217
225
.
15.
Howell
,
L. L.
,
2001
,
Compliant Mechanisms
,
Wiley
,
Hoboken, NJ
.
16.
Yan
,
C.
,
Weilin
,
L.
,
Junlan
,
L.
, and
Zhong
,
Y.
,
2017
, “
An Extended Family of Rigidly Foldable Origami Tubes
,”
ASME J. Mech. Rob.
,
9
(
2
), p.
021002
.
17.
Klett
,
Y.
, and
Middendorf
,
P.
,
2016
, “
Kinematic Analysis of Congruent Multilayer Tessellations
,”
ASME J. Mech. Rob.
,
8
(
3
), p.
034501
.
18.
Qiu
,
C.
,
Zhang
,
K.
, and
Dai
,
J. S.
,
2016
, “
Repelling-Screw Based Force Analysis of Origami Mechanisms
,”
ASME J. Mech. Rob.
,
8
(
3
), p.
031001
.
19.
Yasuda
,
H.
,
Chen
,
Z.
, and
Yang
,
J.
,
2016
, “
Multitransformable Leaf-Out Origami With Bistable Behavior
,”
ASME J. Mech. Rob.
,
8
(
3
), p.
031013
.
20.
Lang
,
R. J
.,
2017
,
Twists, Tilings, and Tessellations: Mathematical Methods for Geometric Origami
,
CRC Press
,
Boca Raton, FL
.
21.
Justin
,
J.
, 1997, “
Towards a Mathematical Theory of Origami
,”
Origami Science and Art: Second International Meeting of Origami Science and Scientific Origami
, Seian University of Art and Design, Otsu, Japan, pp.
15
30
.
22.
Huffman
,
D. A.
,
1976
, “
Curvature and Creases: A Primer on Paper
,”
IEEE Trans. Comput.
,
C-25
(
10
), pp.
1010
1019
.
23.
Thomas
,
H.
,
2006
,
Project Origami: Activities for Exploring Mathematics
,
A K Peters
,
Natick, MA
.
24.
Schief
,
W. K.
,
Bobenko
,
A. I.
, and
Hoffmann
,
T.
,
2008
, “
On the Integrability of Infinitesimal and Finite Deformations of Polyhedral Surfaces
,”
Discrete Differential Geometry
,
Springer
,
New York
, pp.
67
93.
25.
Miura
, K.
, and
Natori
,
M.
,
1985
, “
2-D Array Experiment on Board a Space Flyer Unit
,”
Space Sol. Power Rev.
,
5
(
4
), pp.
345
356
.
26.
Barreto
, P. T.
,
1997
, “
Lines Meeting on a Surface: The ‘Mars’ Paperfolding
,”
Origami Science and Art: Second International Meeting of Origami Science and Scientific Origami
, Seian University of Art and Design, Otsu, Japan, pp.
343
359
.
27.
Sakoda
,
J. M.
,
1997
, “
Hikari-Ori: Reflective Folding
,”
Origami Science and Art: Second International Meeting of Origami Science and Scientific Origami
, Seian University of Art and Design, Otsu, Japan, pp.
333
342
.
28.
Hokusan
,
2017
, “Sanfoot Wood Veneer,” Hoxan Corporation, Chiba, Japan, accessed Jan. 23, 2018, https://www.hoxan.co.jp/english/products/
29.
Lang
,
R. J.
,
2017
, “Rigidly Foldable Quad Mesh+Tessellatica,” Robert J. Lang Origami, Alamo, CA, accessed Jan. 23, 2018, http://www.langorigami.com/publication/rigidly-foldable-quadrilateral-meshes-angle-arrays
30.
Ginepro
,
J.
, and
Hull
,
T. C.
,
2014
, “
Counting Miura-Ori Foldings
,”
J. Integer Sequences
,
17
(
2
), pp. 1–15.http://emis.ams.org/journals/JIS/VOL17/Hull/hull.pdf
31.
Harary
,
F.
,
1994
,
Graph Theory
,
Westview Press
,
Boulder, CO
.
32.
Bényi
,
B.
, and
Hajnal
,
P.
,
2015
, “
Combinatorics of Poly-Bernoulli Numbers
,”
Stud. Sci. Math. Hung.
,
52
(
4
), pp.
537
558
.http://publicatio.bibl.u-szeged.hu/5940/1/2340311.pdf
33.
Cameron
,
P.
,
2014
, “Poly-Bernoulli Numbers,” Peter Cameron, Toowoomba, Australia, accessed Jan. 23, 2018, https://cameroncounts.wordpress.com/2014/01/19/poly-bernoulli-numbers/
34.
Kaneko
,
M.
,
1997
, “
Poly-Bernoulli Numbers
,”
J. Théor. Nombres Bordeaux
,
9
(
1
), pp.
221
228
.