# Message Boards

Answer
(Unmark)

GROUPS:

13

# A New Modeling of Classical Folds in Computational Origami

Posted 3 months ago

Posted for the users’ of Mathematica. We present an application of Eos-implementation of classical origami “flying crane.” Eos (E-origami system) extensively uses Mathematica’s powerful symbolic, algebraic, and graphics capabilities. We employ a new modeling of origami described in the article \cite{ida:2021}. By introducing operations of virtually cutting and gluing the edges of origami faces, we can clarify the notion of fold practised in classical origami. We provide functions that simulate classical folds. Those functions are implemented entirely in Mathematica. We construct a flying crane by programming in Eos programming language Orikoto embedded to the Wolfram Language
Article Abstract This paper shows a cut along a crease on an origami sheet makes simple modeling of popular traditional basic folds such as a squash fold in computational origami. The cut operation can be applied to other classical folds and significantly simplify their modeling and subsequent implementation in the context of computational origami.
1. Introduction This post shows an application of the idea that we presented in the paper titled “A New Modelling of Classical Folds in Computational Origami”\cite{2021:ida}. We observe that an origami artwork is a complicated arrangement of bounded two-sided flat planes called faces. They are connected and superposed sophisticatedly by repeated folds of a single shheet of paper. The collection of the faces becomes a remarkable object at the end of construction. We showed in the article that cutting an edge shared by two faces enables a class of classical folds. To glue the faces divided by the cut, we restore the connection of the separated faces. Application of the cut and glue opens the possibility of discovering new folds that are impossible by Huzita-Justin folds~\cite{Huzita: 1989} and~\cite{Justin: 1986}. The inside-reverse fold is one of the simplest examples of the classical folds but is not in the set of Huzita-Justin folds. Many interesting classical folds are realized by the Huzita-Justin folds plus the cut-and glue operations. This article shows a further development of the Orikoto programming language based on the new modeling and the construction of a flying crane.
2. Computational Modeling Origami is a term meaning “folding paper.” It also refers to a sheet of paper used for origami. Folding an origami along a fold-line and unfolding the folded one to the previous shape leaves a line segment on the origami. It is a part of the fold-line and is called a crease.When we freely choose fold-lines and allow overlaps of faces without breaking the original sheet, we will be able to construct a variety of interesting geometrical objects. On the other hand, when we impose rules of fold-line construction that are mathematically plausible, we can also define an origami geometry that deserves deep mathematical investigation. The Greeks defined Euclidean geometry around 400 B.C. with that spirit. They only used a straightedge and a compass as a tool for constructing geometrical objects. The origami geometry does not use tools but only introduce rules of folding. Huzita-Justin's rules are such rules. Below we list some of Huzita-Justine rules as implemented in Orikoto (3 out of 7 rules) that we use in this post.
Wedenotetheorigamiatstepiby O i To run all the programs in this notebook, we need Mathematica 13, the Eos package, and the ClassicalFold package. The latter two will soon be available from the Eos project webpage https://www.i-eos.org. Alternatively, we can enjoy the flying cranes in 3D graphics using Wolfram Player (Wolfram Inc.’s product that we get free of charge).
3. Classical Folds
Mountain fold and Valley fold The most elementary fold operations are mountain fold and valley fold. They are called so because the crease looks figuratively like the mountain ridge and valley path. The crease is made by the unfold operation that follows the mountain (or valley) fold. To see how we perform those elementary folds, we try to write a tiny Orikoto program and run it. Let us suppose at the outset a piece of e-origami colored blue on the front and green at the back. First, we perform a valley fold on the flat origami along the directed line CA, i.e., half-line starting from point A and passing through point C, as shown below (the leftmost one). In[]:= EosSession["elementary folds"]; Out[]= The result of the valley fold is shown in Fig.1(b). The origami is now two- layered, but the back layer is not visible since the top triangle face completely overlaps the back triangle face. Next, we unfold the origami shown in Fig. 1(c). Unfold does not mean “undoing,” although we recover the shape of the origami to the one in Fig.1(a) except for the dotted line segment CA. We call the line segment valley crease. The line segment looks like a path in the valley if we have a good imagination. In our e-origami, we simulate the situation by looking at the origami lying on the plane precisely from the top right angle. To see the configuration in a way that models the physical space and the origami, we switch to the three-dimensional view mode. Out[]= We construct the origami in Fig.2 (c) by executing the command FO[-0.95 π] [“AC”] instead of Unfold. By this command, we rotate the face ACD by angle of -0.95 π along the half-line AC. we use the right-handed system and select the face to the right of the rotation axis. Rotating an object by angle θ is equivalent to rotating it in a right-hand screw manner. In this case, FO[- π] [“AC”]is operationally Unfold[ ] since the fold-line used by the previous fold (one in Fig.2 (b)) is CA. Similarly, we have a mountain fold below. Out[]= We noticed that line segment AC is dot-dashed, which represents a mountain crease. Valley Fold and mountain Fold are also called Inside fold and outside fold, respectively. These names are sometimes more intuitive and help understand the insideReverse fold and outsideReverse fold, which we discuss shortly.
FO FO, standing for Fold Origami, is a command FO[θ] [faces,ray] for rotating target faces along ray by angle θ. It is a generalization of mountain and valley folds. Note that FO is defined as a Curried function. Using FO, we could define short commands VFold for ValleyFold and MFold for MountainFold. We define them as follows: In[]:= VFold=FO[-π];MFold=FO[π]; If faces are omitted, Eos infers the target faces. With θ other than ± π, command FO constructs a 3D origami in general. In such cases, we need careful use of FO. Usually, we use FO[ θ ] at the end steps of the construction.
Inside-reverse and outside-reverse Folds The inside-reverse and outside-reverse folds are often used methods of folds. Both work on a pair of superposed faces that share an edge. They are combinations of an inside fold and an outside fold. However, each uses inside and outside folds oppositely. In the case of performing the inside-reverse fold by hand, we push the shared edge between the faces and make a valley-like shape. On the other hand, in the case of the outside-reverse fold, we make a triangle cover on the faces. We show simple examples of both folds below.
Inside reverse fold In[]:= $markPointOn Out[]= {True} EosSession["Inside-reverse fold"]; In[]:= NewOrigami[10]; Steps 1 ~ 4 are preparatory. We want two overlapping faces that shared an edge. In[]:= VFold["CA"] Inside reverse fold: Step 2 Out[]= In[]:= NewPoint[{"E"{5,5},"F"{10,7}}] Inside reverse fold: Step 2 Out[]= In[]:= HO["FE"]! Inside reverse fold: Step 4 Out[]= We have constructed the desired faces. Origami O 4 To examine the configuration of faces, we provide a special visualization command ShowLayeredFace. It works as follows. In[]:= ShowLayeredFace[] 1: {6,7} During evaluation of In[]:= 2: {4,5} During evaluation of In[]:= We should note that the faces form a stack of layers. We slice the collection of faces, and show each slice from top (level 1) to bottom. We push edge EC and insert faces 6 and 4 in between faces 7 and 5. Our next task is to make the superpositions precise. We see that there are two levels of the stack of faces. The top-level slice consists of two faces, i.e., ΔCEF and polygon ADFE. The numbers placed in the center of the polygons identify the faces and are called face id. The second level, i.e., the bottom level layer, consists of two polygons (one is a triangle). Each is identified by face id 5 or 4. In geometry, vertices are often represented by the point’s name by identifying the edge and the point. It would be too inconvenient to name the faces by the sequence of point names. Eos generates unique numerals to denote the faces, and we use those numerals, i.e., face Ids, in the Orikoto language. Now we are ready to invoke InsideReverseFold command with list of faces and the fold line as its arguments. In[]:= InsideReverseFold[{4,6},"FE"] Inside reverse fold: Step 8 Out[]= The command performs two folds; one mountain fold along line EF and the other valley fold along EG. However, this would be impossible, if we simulate “fold by hand,” since edge EC is shared by faces 4 and 6. To do the two folds, we need to cut the faces 4 and 6 along edge EC. Since we are practicing e-origami, we will cut EC. When we finish the two folds. We glue the moved) edge and, we are done. The InsideReverseFold command performs this sequence of operations at one stroke. To examine the result of the operation, we use ShowLayers command. In[]:= ShowLayers[Gap1,HingeTrue] Inside reverse fold: Step 8 Out[]= We can rotate the Graphics and see the the inside of the stack of layers .
Outside-reverse fold An outside-reverse fold is similar to the inside-reverse fold. The only difference is that the outside-reverse fold applies mountain and valley folds to different sides of face layers. Below, we show an example of the use of OutsideReverseFold command in a verbose mode. In this mode, the output of each sub-steps of the command execution are displayed. In[]:= EosSession["Outside-reverse fold"]; In[]:= NewOrigami[10];VFold["CA"];NewPoint[{"E"{7,7},"F"{10,3}}];HO["FE"]! Outside-reverse fold: Step 4 Out[]= In[]:= Block[{$probeFold=True},OutsideReverseFold[{4,6},"FE"]] CutEdges[{{4,6}}] MountainFold[4,FE] ValleyFold[6,FE] GlueEdges[$cutEdges] Outside-reverse fold: Step 8 Out[]= In[]:= ShowLayers[HingeTrue,Gap0.5,Frame->False] Outside-reverse fold: Step 8 Out[]= In[]:= EndSession[];
Squash fold Examples best describe squash fold. Orikoto provides four kinds of squash fold commands: 1. Squash rightwards to make a square. 2. Squash leftwards to make a square. 3. Squash rightwards to make a triangle. 4. Squash leftwards to make a triangle. We show (1) and (2 ) as we will use them to construct a flying crane. In the session below, Steps 1 - 5 are preparatory to construct the four layers. Each layer has a shape of a right triangle, which consists of (smaller) right triangles.
Squash fold rightwards Let us start with the origami at step 5. In[]:= EosSession["Squash fold rightwards to square"]; NewOrigami[];HO["A","C"];HO["D","B",Mark{"DB","E"}];HO["C","D"]! Squash fold rightwards to square: Step 5 Out[]= Origami O 5 In[]:= ShowOrigami[ShowFaceIdTop,Gap0.1] Squash fold rightwards to square: Step 5 Out[]= Now, we slide the face 10 rightwards (looking leftwards from the right edge CD) onto face 11 such that segment DE moves onto segment BE. This fold is realized by command SquashFold. We define SquashFold as a Curried function that is to be applied to direction (“L” or “R”), shape (“Square” or “Triangle”), a face list and an an edge list. In this example, {11,10} and {“EC”,”DE”}, respectively. Drawing an analogy of mountain and valley folds, we consider segment DE a ridge and the segment EC as a bottom path. Both segments run on the newly constructed square. Taking those parameters in a structures manner, the SquashFold command here is SquashFold[“R”][“Square”][{11,10},{“EC”,”DE”}] When we call the command in the verbose mode, we can see the sub-steps of the command execution. The result of the squash fold is below the message of "Step 10 . " The graphics outputs are displayed in 2D view mode. To see the inner structure of the face layers, we use commnds ShowLayers and ShowLayeredFace. In[]:= Block[{$probeFold=True},SquashFold["R"]["Square"][{11,10},{"EC","DE"}]] CutEdges[{{11,10}}] ValleyFold[11,Ray[E,C]] ValleyFold[10,Ray[D,E]] HO[D,C] GlueEdges[$cutEdges] Squash fold rightwards to square: Step 10 Out[]= In[]:= ShowLayers[HingeTrue,Gap0.2,ShowFaceIdTop,Frame->False,ImageSize->200] Squash fold rightwards to square: Step 10 Out[]= In[]:= ShowLayeredFace[] 1: {10,14} During evaluation of In[]:= 2: {15} During evaluation of In[]:= 3: {12,13} During evaluation of In[]:= 4: {8,9,11} During evaluation of In[]:= In[]:= EndSession[];
Squash fold leftwards We give SquashFold["L"]["Square"] without further explanation, as we can infer the parameters easily. In[]:= EosSession["Squash fold leftwards to square"]; In[]:= NewOrigami[];HO["D","B"];HO["A","C",Mark{"AC","E"}];HO["A","B"]!;Block[{$displacement=0},ShowOrigami[ShowFaceIdTop,Gap0.1]] Squash fold leftwards to square: Step 5 Out[]= In[]:= Block[{$probeFold=True},SquashFold["L"]["Square"][{10,11},{"EA","BE"}]] CutEdges[{{10,11}}] ValleyFold[10,Ray[B,E]] ValleyFold[11,Ray[E,A]] HO[A,B] GlueEdges[$cutEdges] Squash fold leftwards to square: Step 10 Out[]= In[]:= ShowLayers[HingeTrue,Gap0.2,ShowFaceIdTop,Frame->False,ImageSize->200] Squash fold leftwards to square: Step 10 Out[]= In[]:= EndSession[];
4. Flying crane A flying crane origami is an exciting example. It is one of the most popular artworks, and it requires the classical folds that we discussed. Making a fine flying crane by hand is a challenge for beginner origami hobbyists. It involves a considerable degree of skill and gives us a sense of accomplishment when we complete the construction. In the context of computational origami, this example poses yet another challenge in modeling a new class of folds. In the following, we give the entire steps of constructing a flying crane in Orikoto. Some program codes are added in the description to help us view the internal origami structure. In this example, we specify the origami surfaces as yellow and textured patterns to make the origami more artistic. A short program code to specify the colors and patterns is not included here,however.
Start of construction In[]:= EosSession["Flying crane"]; In[]:= NewOrigami[16] Flying crane: Step 1 Out[]= The essential steps in constructing the crane are to make two overlapping rhombuses. We make them using the petal folds. The rhombuses stretch from NW to SE of the original sheet of paper. Many constructed shapes are symmetric along the diagonal line from NW to SE of the rhombuses. We will have pairs of similar operations; one operates on the left of the diagonal line and the other on the left.
Petal fold
Preparation for a petal fold We first valley-fold O 1 In[]:= VFold["DB"] Flying crane: Step 2 Out[]= We bring point D to point B by valley-fold O 2 In[]:= HO["D","B",Mark->{{"DB","E"}}] Flying crane: Step 3 Out[]= We then fold O 3 O 3 O 4 O 4 O 5 In[]:= HO["B","C",Mark->{{"DC","F4","F3","F2","F1"}}]! Flying crane: Step 5 Out[]= Origami O 5 The execution of the following command ShowLayeredFace gives the list of the face Ids on each layer. It displays the layer of faces, and the current origami, i.e., O 5 O 5 In[]:= ShowLayeredFace[BaseView->True] 1: {10,11} 2: {14,15} 3: {12,13} 4: {8,9} We are about to apply a squash fold to make a square on the upper half of the right triangle. We have already seem this situation in the subsection of Squash fold rightwards to square.
Squash fold rightwards on the front side In[]:= SquashFold["R"]["Square"][{10,11},{"EC","DE"}] Flying crane: Step 10 Out[]= Point F4 has moved to the above-left corner, and F3 appears at the position where F4 was. The following command, TurnOver[1], rotates origami O 10 O 10 In[]:= TurnOver[1] Flying crane: Step 11 Out[]= Next, we apply Squash Fold to make a four-layered square to prepare for a petal fold. We check the top layer face Ids of origami O 11 In[]:= ShowLayeredFace[Level->{1}] 1: {8,9,10}
Squash fold leftwards on the back side The following squash fold moves the target faces leftwards and then make the squashed part a square. In[]:= SquashFold["L"]["Square"][{8,9},{"EB","CE"}] Flying crane: Step 16 Out[]= We now have four-layered square.
Preparation for constructing legs We are in the second phase of the petal construction. We bisect the ∠ EBF2 to make one side of a petal. We superpose the two lines to bisect an angle formed by them. One of Huzita-Justin’s rules can do this. The following command tries to superpose the lines extending segments F2B and EB. In[]:= HO["F2B","EB"] Flying crane: Step 16 Out[]= , The result would be surprising since we are asked to choose one of the two possibilities. However, it is natural since there are two angle-bisectors. In this case, we want to use the second one and execute the following command, with additional named arguments to mark, with G1, the intersection of the fold-line and the segment F2E. Then, we unfold origami O 17 In[]:= HO[FoldLine->2,Mark->{{"F2E","G1"}}]! Flying crane: Step 18 Out[]= Similarly, we obtain the crease BH1. In[]:= HO["F1B","EB",FoldLine->2,Mark->{{"F1E","H1"}}]! Flying crane: Step 20 Out[]=
Left leg by inside reverse fold The next step is to make half of the petal, i.e., BG1H1, on the front side. We want to apply InsideReverseFold since we want to use the backside of triangle BG1H1 as the other half of the petal. To apply InsideReverseFold, we need the target face Ids. For this purpose, we execute the command ShowLayeredFace[ and find that face Ids 25 and 27 are the required arguments of InsideReverseFold. We fold origami O 20 Expand the following cell to see the output. In[]:= ShowLayeredFace[] In[]:= InsideReverseFold[{25,27},"BG1"] Flying crane: Step 24 Out[]= |