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

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

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.

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

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.

For further details, see the monograph "An introduction to computational geometry" \cite{ida:2020}Now coming back to the issue of folding rules, we use Huzita-Justin rules , cut, glue, create arbitrary points on the face, and some more commands by which we rotate faces. We will explain as we go along.

Operation | Huzita-JustinruleinOrikoto |

FoldalongPQ | HO[PQ] |

FoldtobringPtoQ | HO[P,Q] |

FoldtobringPQtoRS | HO[PQ,RS] |

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

3. Classical Folds

### Mountain fold and Valley fold

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

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

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

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 has four faces; faces 6 and 4 are superposing, and so are faces 7 and 5. Moreover, faces 6 and 4 share edge CE.

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[]:=

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.

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.

We can rotate the Graphics and see the the inside of the stack of layers .

#### Outside-reverse fold

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.

### Squash fold

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.

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

Squash fold rightwards

Let us start with the origami at step 5.

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.

#### Squash fold leftwards

Squash fold leftwards

We give SquashFold["L"]["Square"] without further explanation, as we can infer the parameters easily.

## 4. Flying crane

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

Start of construction

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

Petal fold

#### Preparation for a petal fold

Preparation for a petal fold

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

Squash fold rightwards on the front side

Point F4 has moved to the above-left corner, and F3 appears at the position where F4 was.

#### Squash fold leftwards on the back side

Squash fold leftwards on the back side

The following squash fold moves the target faces leftwards and then make the squashed part a square.

We now have four-layered square.

#### Preparation for constructing legs

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.

Similarly, we obtain the crease BH1.

#### Left leg by inside reverse fold

Left leg by inside reverse fold

Similarly, we prepare the arguments of a face-Id list {17,19} and ray H1B, to make the left part of △ BG1H1.

When we rotate the faces 18 and 26 by -π degree along ray H1G1, the petal shape appears on the front side. Note that the fold is a valley-fold along H1G1.

#### Right leg by inside reverse fold

Right leg by inside reverse fold

The subsequent steps 31 - 42 are operationally the same as steps 16 - 28.

We have obtained the desired petals.

## 5. Texture Variations

5. Texture Variations

With another pattern of textures, we can generate various flying cranes. We do not have to change the values of parameters, such as the coordinate of the points. We have only three free parameters in this construction.

## 6. Concluding remarks

6. Concluding remarks

This post has shown 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 use the new modeling of origami described in our article \cite{ida:2021}. By introducing operations of cutting and gluing the edges of origami faces, we can clarify the notion of fold in classical origami. We provide new functions that simulate classical folds. Those functions are implemented in Mathematica \cite{wolfram:2022} They will be available to Mathematica programmers.

## Acknowledgements

Acknowledgements

This work is supported by JSPS research grant Kakenhi 16K00008.

## BibTex Reference

BibTex Reference

1

.@book {hestenes : 1986, author = {{D . Hestenes}}, publisher = {Kluwer Academic Publishers}, title = {New Foundations for Classical Mechanics (Second Edition)}, year = {1986}}

2

.@inproceedings {Ida : 2016, address = {Strasbourg, France}, author = {T . Ida and J . Fleuriot and F . Ghourabi}, booktitle = {Proceedings of ADG 2016 : The 11 th International Workshop on Automated Deduction in Geometry}, date - modified = {2018 - 03 - 16 07 : 35 : 46 + 0000}, editor = {J . Narboux and P . Schreck and I . Streinu}, month = {June}, pages = {117-- 136}, title = {A New Formalization of Origami in Geometric Algebra}, year = {2016}}

3

.@inproceedings {Huzita : 1989 a, address = {Ferrara, Italy}, author = {H . Huzita}, booktitle = {Proceedings of the First International Meeting of Origami Science and Technology}, editor = {H . Huzita}, month = {December}, pages = {143-- 158}, title = {Axiomatic Development of Origami Geometry}, year = {1989}}

4

.@inproceedings {Justin : 1989, address = {Ferrara, Italy}, author = {J . Justin}, booktitle = {Proceedings of the First International Meeting of Origami Science and Technolog}, editor = {H . Huzita}, month = {December}, pages = {251-- 261}, title = {R {\' e} solution par le pliage de l' {\' e} quation du 3 e degr {\' e} et applications g {\' e} om {\' e} triques}, year = {1989}}

5

.@inproceedings {ida : 2021, author = {T . Ida and H . Takahashi}, booktitle = {Proceedings of the 13 th International Conference on Automated Deduction in Geometry}, editor = {P . Jani {\v c} i {\' c} and Z . Kov {\' a} cs}, month = {September}, number = {352}, publisher = {Elsevier Inc .}, series = {EPTCS}, title = {A new modeling of classical folds in computational origami}, volume = {352}, year = {2021}}

6

.@book {ida : 2020, author = {T . Ida}, month = {September}, publisher = {Springer International Publishing Switzerland}, series = {Texts and Monographs in Symbolic Computation}, title = {An introduction to Computational Origami}, year = {2020}}

7

.@misc {wolfram : 2022, author = {{Wolfram Research {, } Inc .}}, title = {Mathematica}, year = {2022}}