On Computer Simulation of Origami

by
Liudmila I. Zamiatina

Mathematica in Education
Vol.3 No.3
Summer 1994
(c) TELOS/Springer-Verlag

The principal constructions of Origami (the Japanese Art of Paper-folding) have reasonably simple mathematical descriptions. Using Mathematica it is shown in the paper how these descriptions facilitate learning the Origami Art and develop appreciasion of geometric modeling in students.

Introduction.

The idea of using Origami in teaching is fairly old. In Europe for instance it captured attention of the famous German educator Friederic Froebel as early as in the mid nineteenth  century[11]. The most remarkable work of using paper folding as an aid in teaching geometry to children was published in Madras, India, in 1893 ,it has been "Geometric Exercises in Paperfolding" written by Sundara Row[10].  The most commonly accepted current classification of Origami bases dates back to 1960 to the works of Japanese teachers and the credit for introduction of the English terminology should be given to Samuel Randlett [9 ].

In our times the Origami while developing on its own within the Japanese tradition becomes increasingly popular all over the world and constitutes a favorite recreation for children and mathematicians.

Among the Origami connoisseurs and fans we find both adepts of the intuitive side of the ancient art and "rationalists" who find pleasure in mathematical  investigation of Origami masterpieces.

Computer simulation of Origami may unveil new facets in this activity: in addition to obvious impetus it gives to geometric imagination, it also gives ample material for studying geometric and graphic primitives in a picturesque and eye-catching context.

The first attempt  at  computer design for Origami, known to the Author, was made in 1971 by  Arthur Appel at the IBM World Trade Corporation. This attempt  is mentioned in [6] , however without exact reference.

The goal of the present work is to create a set of Mathematica tools that would provide for appreciating both creative and educational sides of Origami.

Within the scope of this paper and at this stage of the project only a part of this work is done.Selected basic concepts, functions and  examples of what is already available are given in the paper.

Basic Geometry Constructions

Analyzing the basic operations involved in creating Origami masterpieces out of a plain 6-inch paper square, one may list the following geometric constructs, involved in most of the composition steps: reflection, rotation, casting perpendiculars, drawing bisectors, proportional division, extending segments, computing intersections  etc.

Quite common operations of vector and matrix algebra are employed in the respective implementations.

Note that all the constructions are done in 3-D space and that the respective Mathematica definitions implementing these constitute polymorphic functions applicable to diverse geometric objects (represented as collections of Mathematica geometric and graphic primitives).

One of the most heavily used tools is the 3-D rotation by a given angle with respect to a line. This is implemented as the undergoing rotate3D[]  function.

rotate3D[Line[{pt1_List,pt2_List}],
         line_Line,angle_]:=
   Line[{rotation3D[pt1,line,angle],
        rotation3D[pt2,line,angle]}]

rotate3D[Point[pt_List],line_Line,angle_]:=
   Point[rotation3D[pt,line,angle]]

rotate3D[Polygon[lis_List],line_Line,angle_]:=
   Polygon[Map[rotation3D[#,line,angle]&,lis]]
  
rotate3D[other_,line_Line,angle_]:=
            other

Where   rotation3D    is the basic procedure, turning an individual point by a prescribed angle with respect to the given line.

Here is the Mathematica code for this function resulting from a simple matrix algebra:

rotation3D[{x0_,y0_,z0_},
Line[{{x1_,y1_,z1_},{x2_,y2_,z2_}}],fi_]:=
Module[{a,b,c,len},
       {a,b,c}={x2,y2,z2}-{x1,y1,z1};
       len=Sqrt[a^2+b^2+c^2];
       {a,b,c}={a,b,c}/len;
       M={{a^2 + Cos[fi] - a^2*Cos[fi], 
           a*b - a*b*Cos[fi] - c*Sin[fi], 
           a*c - a*c*Cos[fi] + b*Sin[fi]}, 
          {a*b - a*b*Cos[fi] + c*Sin[fi], 
           b^2 + Cos[fi] - b^2*Cos[fi], 
           b*c - b*c*Cos[fi] - a*Sin[fi]}, 
          {a*c - a*c*Cos[fi] - b*Sin[fi], 
           b*c - b*c*Cos[fi] + a*Sin[fi], 
           1 - a^2 - b^2 + a^2*Cos[fi] + 
           b^2*Cos[fi]}};
       {x1,y1,z1}+M.({x0,y0,z0}-{x1,y1,z1})]

Rotation is one of the most important tools in paper fold simulation. For instance, simultaneous rotation with respect to two parallel axes gives the pleat folding, while two consecutive rotations with respect to intersected axes gives the swivel folding (see, for instance, [6] for traditional definitions of these foldings).

Symmetric reflection with respect to a line is implemented as the reflection[] function and that with respect to a plane as reflection3D[] . In the latter the reflection plane is represented by a polygon that spans it.

reflection[P_List,Line[{P1_List,P2_List}]]:=
  Module[ {t,Pt},
          Pt=P2-P1;
          t=Dot[P-P1,Pt]/Dot[Pt,Pt];
          Pt=P1+t*Pt;
          2*Pt-P
        ]
reflection3D[ p_List, Polygon[{ p1_List,p2_List,
 p3_List}]]:=
   Module[ {vp,lvp},
           vp=VectorProduct[p2-p1,p3-p1];
           lvp=segLength[{0,0,0},vp];
           vp=vp/lvp;
           p - 2*Dot[p-p1,vp]*vp
         ]
reflection3D[Line[{p11_,List, p12_List}],
   Polygon[{ p1_List,p2_List,p3_List}]]:= 
   Line[{reflection3[p11,Polygon[{p1,p2,p3}]],
      reflection3[p12,Polygon[{p1,p2,p3}]]}]

reflection3D[Polygon[lis_List],
   Polygon[{ p1_List,p2_List,p3_List}]]:=
   Polygon[Map[reflection3[#,
              Polygon[{p1,p2,p3}]]&,lis]]


reflection3D[other,
 Polygon[{ p1_List,p2_List,p3_List}]]:=other

(Note that the reflection3[], as well as the earlier rotate3D[] function is explicitly built as a polymorphic function, acting on all the relevant graphics primitives.)

Casting the perpendicular out of a point onto a line is implemented as the perpendicular[] function, whereas the function for casting the perpendicular onto a plane is called perpendicular3D[] (again the plane is defined by a polygon as explained above).

perpendicular3D[P_List,
   Polygon[{P1_List,P2_List,P3_List}]]:=
   Module[ {vp,lvp},
           vp=VectorProduct[P2-P1,P3-P1];
           lvp=Sqrt[Plus@@Map[#^2&,vp]];
           vp=vp/lvp;
           lvp=Dot[P-P1,vp];
           Line[{P,P-lvp*vp}]
         ]

Bisector of an internal angle in a triangle is understood as the line segment connecting the vertex with the corresponding point on the opposite edge of the triangle. The function
computing this line is called bisector[].

bisector[Polygon[{p1_List,p2_List,p3_List,
  rest___}]]:= (* Builds the bisector    of *)
               (* the internal angle <p2>   *)
   Line[{p2, p1+ (p3-p1)*segLength[p1,p2]/
        (segLength[p1,p2]+segLength[p3,p2])}]

The cross3[] procedure finds the intersection point of two straight lines.

Proportional subdivision of two edges of a triangle is done by the procedure called  proportionalLine[].

Angles between  two concurrent planes and between two concurrent lines  are computed  using bookAngle[] and lineAngle[] functions respectively.

The rest of the utilities are more specialized and are Origami-specific.

Guidelines for Origami Constructions

In the computer implementation of Origami it is most important to be able to render the actual movement of the paper segments in each constituent operation.

Movement not only provides for detailed and automated animation of the essential Origami step, but it also allows to take advantage of the capabilities of the Mathematica notebook as opposed to a printed page.

All the Mathematica rules implementing Origami steps are based on the simulation of the actual physical movement. Therefore the implementation is based on the systematization and geometric description of the actual moving paper segments.

Within the scope of the present paper only some of the classical Origami moves and folds may be described.  For a reasonably complete English terminology and descriptions the reader is referred to [5 ].

Below  we briefly describe only the following procedures, essential for the present discourse: bookFold[] , bookFoldTwo[], preliminaryFold[],  reverseFold[],  reverseFoldAuxOne[],  reverseFoldAuxTwo[], buildTail[],  basicBird[],  WingStep[].  Each of these procedures has an "angle" parameter, that controls the extent of rotation/folding and provides for capturing of a potentially infinite number of intermediate positions in each operation. The last named WingStep[] utility is very much specialized and fairly different. It is a recursive function giving a number of subsequent  "wing flexions" in the flapping bird model.

Book Fold. Pleat. Swivel (Crimp).

Single-line book folding is probably the simplest possible folding. One part of the model is rotated about the specified line and folded over the other.

The proposed bookFold[] function, however is applicable to arbitrarily complicated models and generates a prescribed number of graphical images.

bookFold[stationary, moving, line, angle, QTY ]

The first two arguments describe the stationary and moving parts of the model respectively,  `line`  specifies the rotation axis, `angle` is in fact the desired angle increment on each step and  QTY is the desired number of steps .

Figure 1

It is possible to obtain the  pleat folding by using bookFold[]  consecutively  twice for rotating the corresponding parts of the polygons about two parallel lines. To obtain the swivel (crimp), the two rotations are executed about  concurrent  lines. The examples are shown below.

Figure 2

bookFoldTwo[stationary, moving1, moving2,
            line1, line2, angle, QTY ]

is a very similar procedure, but it has two moving parts rotating simultaneously about the two specified lines .

Here is a fairly sophisticated example of applying the bookFoldTwo[]  in the  final stage of the "Angel" model.

At this point the moving "wings" already constitute fairly complicated polygonal compounds.

Figure 3

Preliminary Fold. Squash Fold.

The preliminary fold is a "cusp" folding with a high degree of symmetry. When fully fold, the figure looks like one forth of the original paper square. When being fold, the model is described as the union of eight moving triangles (as one can see in the pictures below).

The usage of this function is as follows:

preliminaryFold[triangle, pivot, angle]

where `triangle` is one of the abovementioned eight triangles, `pivot` is the (stationary) vertex of the configuration  and the `angle` controls the extent to which the configuration is "opened". Changing this angle parameter one generates pictures for different folding stages, an d these pictures can be then animated.

There is no special function for the squash folding. It is done by applying the preliminaryFold[]  to a certain part of the model.

We will show how it is applied to get the preliminary fold ("hana no kihon-kei") while building the "Space Shuttle" model.

Figure 4

This is the initial preliminary fold for the  "Space Shuttle" and the dashed lines above are bisectors of the respective angles. Now we apply the same preliminaryFold[]  function to the smaller triangular creases thus getting the "Squash" folding as shown below .

Reverse Folds

These folds are essential in many models and especially in the flapping bird model, described in the next section. Geometrically, the final stage of an inverse folding is reached by a simple reflection of polygons w.r.t. the appropriate mirror plane. The goal, however, is  to simulate intermediate steps of the folding process. Both the inverse folding and outside inverse folding implemented here are highly symmetrical, so it suffices to specify only one of the participating triangles and the point about which it is folded.

Accordingly, the functions have the following descriptions

reverseFold[triangle1, triangle2, angle]

reverseFoldAuxOne[triangle1, triangle2, angle, 
                  flag]

reverseFoldAuxTwo[triangle1, triangle2, angle]

where the triangles are the ones to be folded in or out (normally, these are adjacent triangles), flag is a boolean, True when inward folding is required, and angle, as usual, controls the extent of folding.

The pictures below show three different stages of reverse folding and are generated using the reverseFold[] with three different values of the angle parameter.

Rabbit-Ear Fold. Fold Tail.

Surprisingly, the simple task of pinching paper in form of a "rabbit ear" or that of a "jet  tail" turns out to have a less simple mathematical description.  The foldable part of the "ear" or  "tail" appears to require a minimum of seven linked polygons. The configuration is symmetric with respect to a certain plane, so only  four of these polygons have to be traced, the other three being just mirror reflections.

Here more detailed explanation is given for the case of the Space Shuttle's tail.

The configuration is best started from a diamond-shaped quadrangle, consisting of two symmetric triangles as shown in the picture below.

The recommended auxiliary construction starts with one of the triangles and gives the base of seven points used on the subsequent steps. The first three points are the vertices of the traingle. Assuming the first and the third are the ends of the common edge of  the two triangles shown above, then the forth point is the base of the perpendicular cast from the second point onto this edge, the fifth is the base of the perpendicular cast form the forth point onto the other side of the traingle ( here: connecting the fist and the second points ) , the sixth is the base of the perpendicular cast from the fifth point onto the common edge of the two triangles again and the seventh is the base of the perpendicular cast from the fifth onto the perpendicular drawn first ( thus connecting the second and the forth points ). The configuration of the seven points looks as follows.

To animate the further "pinch and fold" procedure, we suggest using the buildTail function with the following description:

buildTail[p1,p2,p3,p4,p5,p6,p7,angle]

where p1 through p7 are the seven pivotal points as indicated above and, as usual the angle parameter controls the extent of the folding for animation purposes.

Shown below is an animation of the tail folding using  biuldTail[].

Flapping Wings

We implement a specialized function that simulates the flexibility of paper. To generate animated graphics of the "wing flapping" this function iteratively flexes the "wing" portions of the model over a set of lines, each line connecting a common stationary point with a point moving along the edge of the "wing".
This function called WingStep, unlike the others, previously defined, is applied to the whole model and transforms its current state into the subsequent state. Thus the output of the function has the same format as its input and its description is:

WingStep[{{stationary, leftwing, rightwing},pivot},
         angleincrement,mirror]

The list argument  here decribes the stationary part of the current figurine, its wings and the point about which the left wing is flexed. The `mirror` argument describes the symmetry plane of the model and is a merely technical utility. The angle increment  determines the choice of the next pivotal point on the edge of the wing. The usage of the WingStep function is shown in the end of the next section.

The Flapping Bird

In this section we show the power of computer paper folding as applied to the most traditional and classical model, that serves as a synonim of the art of Origami for many people around the world .

A classical Japanese legend tells about a magician who folded a paper bird so realistically that in came to life and flew away.

Now Mathematica animation will allow a computer image of this model to actually fly on the screen of your computer.

Below we show stage by stage how to do it. The pictures are taken from the actual complete notebook that will be available as an electronic supplement to this paper.

Preliminary Fold

We skip the description and images of the preliminary fold stage of this model, since it is quite similar to the one shown in the previous section. Here is the preliminary base (only the final picture with dashed lines required for the next stage is shown).

New lines for folding

b1= {EdgeForm[{RGBColor[0.1,0.,0.9],
        Thickness[0.005]}],
        SurfaceColor[RGBColor[1,1,1]],
  Polygon[{t0,t5,t4+{0,0,0.05},t6}],
        SurfaceColor[RGBColor[1,1,1]],
  RGBColor[1,0,0.3],Thickness[0.007],
  Dashing[{0.03,0.03}],
     Line[{(t0+t6)/2,t4+{0,0,0.05}}],
     Line[{t4+{0,0,0.05},(t0+t5)/2}],
 Line[{(t0+t6)/2,t4}], Line[{t4,(t0+t5)/2}],
 Line[{(t0+t6)/2,t4-{0,0,0.05}}],
 Line[{t4-{0,0,0.05},(t0+t5)/2}],
 Polygon[{t4-{0.02,0,0},t6,t0}],
 Polygon[{t4-{0,-0.02,0},t0,t5}],
        SurfaceColor[RGBColor[1,1,1]],
 Polygon[{t0,t5+{0,0,-0.05},t4-{0,-0.02,0}}],
 Polygon[{t0,t4-{0.02,0,0},t6+{0,0,-0.05}}],
        SurfaceColor[RGBColor[1,1,1]],
 Polygon[{t0,t5+{0,0,-0.05},t4+{0,0,-0.05},t6+{0,0,-0.05}}]};
NewLines=Graphics3D[b1,(*Opt,*)Boxed->False,         
       PlotRange -> All];

Show[NewLines];

Bird Base

BirdBaseStages={};Do[
lu=Polygon[{p1lu,p2lu,p3lu,p4lu}];
ru=Polygon[{p1ru,p2ru,p3ru,p4ru}];
ld=Polygon[{p1ld,p2ld,p3ld,p4ld}];
rd=Polygon[{p1rd,p2rd,p3rd,p4rd}];
LU=basicBird[lu,N[-i]];
RU=basicBird[ru,N[i]];
LD=basicBird[ld,N[i]];
RD=basicBird[rd,N[-i]];
BirdBaseStages=Append[BirdBaseStages,
Graphics3D[Join[{EdgeForm[{RGBColor[0.1,0.,0.9],
        Thickness[0.005]}]},LU,RU,LD,RD,c],
        (*Delete[Opt,0],*)Boxed->False,      
        PlotRange -> All,ViewPoint->{0,-1,1}]],
        {i,0.01,Pi-0.01,Pi/8-0.01}];

Bird base is a folded configuration, used as a base in many different model, such as, for example, Water Lily, Four-Point Star, Sitting Crane, Charcoal Brazier etc. To start with the Bird Base, we inscribe an isosceles triangle in the square outer frame of the preliminary fold, such that the base of the triangle is the segment, connecting the middle points of the two adjascent sides of the square. Then the configuration is folded over the edges of the triangle as shown.

Map[Show,BirdBaseStages];

Pseudoreverse Fold for opening the surfaces

ReverseStages={};
Do[boo=Chop[reverseFoldAuxOne[m0,m1,m2,m3,m4,
   N[fee],False]];
   t= boo[[2,1,3]];
   t1=reflection3[t,Polygon[{m0,m2,m3}]];
   joo=Join[NS,{Polygon[{cur,t1,m3}],
                Polygon[{cdr,t,m3}],
                RGBColor[0.2, 0., 0.8], 
                Thickness[0.005],
                Line[{t1,(c6+cu)/2+{0,0,0.0001}}],
                Line[{t,(c6+cu)/2-{0,0,0.1}}]},
                boo,Map[reflection3[#,
                Polygon[{m0,m2,m3}]]&,
                boo]];
   
   ReverseStages=Append[ReverseStages,
               Graphics3D[Prepend[joo,EdgeForm[
                RGBColor[0.1,0.,0.9]]],(*Opt,*)
       Boxed->False,(*Axes->True,*)         
       PlotRange -> All,ViewPoint->{1,0,1}]],
   {fee,0.001,Pi/2-0.001,Pi/12-0.01}];

Now  two side petals of the bird base must be opened up as shown.

Map[Show,ReverseStages];

Double Reverse Fold

cur=RU[[2]][[1]][[3]];
cdr=RD[[2]][[1]][[3]];
nu=boo[[1]][[1]][[1]];
BeakStages={};
Do[boo=Chop[reverseFold[m0,m1,m2,m3,m4,N[fee]]];
   t= boo[[2,1,3]];
   t1=reflection3[t,Polygon[{m0,m2,m3}]];
   s=boo[[1]][[1]][[2]];
   s1=reflection3[t,Polygon[{m0,m2,m3}]];
   FFboo=First[First[boo]];
   k0=0.35 FFboo[[1]]+0.65 FFboo[[3]];
   k1star=0.35 FFboo[[2]]+0.65 FFboo[[3]];
   aoo=reverseFoldAuxTwo[boo[[1]],m4,k0,k1star];
   hoo=Append[aoo,boo[[2]]];
   (* Last five lines generate the small beak *)
   PO1={Polygon[{cur,t1,s1,nu}],Polygon[{cdr,t,s,nu}]};
   joo=Join[NS,PO1,hoo,
            Map[reflection3[#,Polygon[{m0,m2,m3}]]&,hoo]];
   BeakStages=Append[BeakStages,Graphics3D[Prepend[joo,EdgeForm[
                   RGBColor[0.1,0.,0.9]]],
                   (*Delete[Opt,0],*)Boxed->False,         
                   PlotRange -> All,
                   ViewPoint->{1,0,1}]],
   {fee,Pi/2-0.001,0.001,-(Pi/24-0.0001)}];

Now it is easy to form the "neck" and the "beak" of the would be bird by applying two reverse foldings simultaneously. The reverseFold[] and reverseFoldAuxTwo[] functions of the proposed package were used.

Map[Show,BeakStages];

Opening Tail

ReverseStages={};
Do[boo=Chop[reverseFoldAuxOne[m0,m1,m2,m3,m4,
   N[fee],False]];
   t= boo[[2,1,3]];
   t1=reflection3[t,Polygon[{m0,m2,m3}]];
   joo=Join[SNref,{Polygon[{cur,t1,m3}],
                Polygon[{cdr,t,m3}],
                RGBColor[0.1, 0., 0.9], 
                Thickness[0.005],
                Line[{t1,(c6+cu)/2+{0,0,0.0001}}],
                Line[{t,(c6+cu)/2-{0,0,0.1}}]},
                boo,Map[reflection3[#,
                Polygon[{m0,m2,m3}]]&,
                boo]];
   
   ReverseStages=Append[ReverseStages,
               Graphics3D[Prepend[joo,EdgeForm[
                RGBColor[0.1,0.,0.9]]](*,Opt*),
       Boxed->False,(*Axes->True,*)         
       PlotRange -> All,ViewPoint->{1,0,1}]],
   {fee,0.001,Pi/2-0.001,Pi/12-0.01}];

It is now necessary to up the "tail" of the figurine. This is done using exactly the same pattern as in the recent above subsection called "Pseudoreverse fold". We therefore show less intermediate stages here.

Map[Show,ReverseStages];

Reverse the Tail

ReverseTail={};
Do[
   boo=Chop[reverseFold[m0,m1,m2,m3,m4,N[fee]]];
   t= boo[[2,1,3]];
   t1=reflection3[t,Polygon[{m0,m2,m3}]];
   s=boo[[1]][[1]][[2]];
   s1=reflection3[t,Polygon[{m0,m2,m3}]];
   PO1={Polygon[{cdr,t1,s1,nu}], 
        Polygon[{cur,t,s,nu}]};
   joo=Join[SN,PO1,boo,Map[reflection3[#,Polygon[{m0,m2,m3}]]&,
                 boo]];
   ReverseTail=Append[ReverseTail,
                Graphics3D[Prepend[joo,EdgeForm[
                RGBColor[0.1,0.,0.9]]],
        (*Opt1,*)Boxed->False,PlotRange -> All
        (*,ViewPoint->{1,0,1}*)]],
   {fee,Pi/2-0.001,0.001,-(Pi/24-0.0001)}];

Now the tail of the model must be reversed using the reverseFold[ ] function.

Map[Show,ReverseTail];

Stationary part of the wings

tmp=qoo1;
WingBase={};
Do[tmp=WingStep[tmp,N[Pi/20],mir];
WingBase=Append[WingBase,Graphics3D[Prepend[tmp[[1]],
EdgeForm[RGBColor[0.1,0.,0.71]]],
PlotRange->All,(*ViewPoint->{1.3, -2.4, -5.},*)
Boxed->False]],{3}];

Since we are now going to flex the wings of this model, we make a small crease, showing the initial pivot line.

Map[Show,WingBase];

The flapping of flexible wings

FlexibleWings={};
Do[tmp=WingStep[tmp,N[Pi/36],mir];
FlexibleWings=Append[FlexibleWings,
Graphics3D[Prepend[tmp[[1]],
EdgeForm[RGBColor[0.1,0.,0.71]]],
PlotRange->All,(*ViewPoint->{1,-1,0},*)
Boxed->False]],{20}];

This is done usnig the special  WingStep[ ] function, described in the previous section.
The animation part in the actual notebook consists of 16 frames, of which we have picked out only five.

Map[Show,FlexibleWings];

Conclusion

It is shown in the paper that the basic Origami operations common to most  of the models are formalized (after the appropriate systematization) as Mathematica rules and functions that may serve as standard building blocks for Origami synthesis and animation on computer.

But many of more sophisticated models contain unique elements and charts that constitute the specific charm of the Origami and make room to geometric creativity. Therefore a computer Origami courseware if ever created will necessarily contain quite a few excercises in computer graphics and Mathematica programming challenging the readers resourceffulness and geometric skills.

Appendix

Here the Mathematica sources for selected Origami functions are given.
The Author attempted to select the most instructive pieces of code for this presentation. The current Origami1.m containing all the relevant functions will be  available as a part of electronic supplement to the paper.

The preliminaryFold function

preliminaryFold[Polygon[{p1_List,p2_List,p3_List}],p4_List,
          Fi_]:=
  Module[{p5,p6,p7,p8,p9,p10},
       p5=reflection[p3,Line[{p1,p2}]];
       p6=rotate3D[Point[p2],Line[{p1,p3}],N[Fi]];
       p6=Part[p6,1];
       p7=rotate3D[Point[p2],Line[{p1,p5}],N[-Fi]];
       p7=Part[p7,1];
       p8=reflection3[p3,Polygon[{p1,p6,p7}]];
       p9=reflection3[p4,Polygon[{p1,p6,p7}]];
       p10=reflection3[p5,Polygon[{p1,p6,p7}]];
    {Polygon[{p1,p3,p6}],
     Polygon[{p1,p5,p7}],
     Polygon[{p1,p6,p8}],
     Polygon[{p1,p7,p10}],
     Polygon[{p1,p8,p9,p10}]}
         ]

This function tracks the movement of a simple "folding in box" consisting of  five polygons and controlled by the folding angle Fi. As was already said, a straightforward sequence of rotations and reflections is used to place the polygons.

The basicBird function

basicBird[Polygon[{p1_List,p2_List,p3_List,
                   p4_List}],Fi_]:=
   Module[{p5,p6,p7},
     p5=rotate3D[Point[p4],Line[{p2,p3}],Fi];
     p6=Part[p5,1];    
     p7=reflection3[p3,Polygon[{p4,p2,p6}]];     
    {Polygon[{p4,p7,p2}],
     Polygon[{p7,p2,p6}],
     Polygon[{p6,p2,p3}]}
          ]

This seemingly simple function generates a "quarter" of the moving polygon structure participating in folding the Bird base. The other three components are retrieved by simple reflections (using the symmetry of the model).

Folding the "Space Shuttle" tail.

As it had been already said, this task turns out to be unexpectedly sophisticated. It would be a pain to describe all the geometric constructions involved in plain English. But the code below is a fairly faithful line-by-line description of what is done in Mathematica language. (So understanding the underlying geometry shouldn't be a problem for a native Mathematica speaker.)

foldTail[q1_List,q2_List,q3_List,Fi_]:=
Module[{t,nq2,qc,Psi,sol,lp,k,l,r,nqc,sq2,Psi0},
       qc=perpendicular[q2,Line[{q1,q3}]][[1,2]];
       nq2=perpendicular[qc,Line[{q1,q2}]][[1,2]];
       nqc=perpendicular[nq2,Line[{q1,q3}]][[1,2]];
       sq2=perpendicular[nq2,Line[{q2,qc}]][[1,2]];
       l=segLength[q2,sq2];
       (* r=segLength[sq2,qc]; *)
       k=segLength[qc,nqc];
       t=N[Sqrt[k^2+l^2]];
       Psi0=ArcSin[l/t];
       Psi=N[Psi0+ArcCos[k*Cos[Fi]/t]]
      ] (*foldTail*)

This function computes the relation between two basic supporting angles of the folding tail.

buildTail[q1_List,q2_List,q3_List,qc_List, 
        nq2_List,sq2_List,nq4_List,f_(*angle*)]:=
   Module[{pangle,pss,q2turned,qcturned,vp,
           turnedMore,plength,qlength,qp2turned,
           polyturned,polyrefl,smallgon,smallrefl,
           hgt,mlen,nlen,ksi,tailDir,ltD,tailPoint,
           tailgon,tailrefl},
          pangle=ArcCos[Dot[q1-qc,nq2-qc]/
          segLength[qc,q1]/segLength[qc,nq2]];
          (* angle nq2,qc,qp2             *)
          pss=helpfoldTail[q1,q2,q3,f];
          (* turn {nq2,nq4,qc}            *)
          q2turned=
            rotate3D[Point[q2],
            Line[{sq2,nq2}],f][[1]];
          (* rotate the smallest triangle *)
          qcturned=
             rotate3D[Point[qc],
             Line[{nq4,nq2}],pss][[1]];
          vp=VectorProduct[q2turned-nq2,
                           qcturned-nq2];
          turnedMore=rotate3D[Point[nq2],
            Line[{qcturned,qcturned+vp}],
            pangle][[1]];
          plength=segLength[qc,qp2];
          qlength=segLength[qcturned,turnedMore];
          qp2turned=qcturned+
          (plength/qlength*(turnedMore-qcturned));
          polyturned=
          Polygon[{nq2,qcturned,
                   qp2turned,q2turned}];
          polyrefl=reflection3[polyturned,
                   Polygon[{q1,qc,qcturned}]];
          smallgon=Polygon[{nq2,sq2,q2turned}];
          smallrefl=reflection3[smallgon,
                   Polygon[{q1,qc,qcturned}]];
          hgt=perpendicular3D[qp2turned,
                   Polygon[{q1,qc,qcturned}]];
          mlen=segLength[qp2turned,qcturned];
          nlen=segLength[qcturned,hgt[[1,2]]];
          ksi=ArcCos[mlen*
                     Cos[N[Pi-2pangle]]/nlen];
          tailDir=rotate3D[Line[{qcturned,
                                hgt[[1,2]]}],
                     Line[{qcturned,
                     qcturned+
                     (hgt[[1,2]]-hgt[[1,1]])}],
                     -ksi];
          ltD=segLength@@tailDir[[1]];
          tailPoint=qcturned+
                    ((tailDir[[1,2]]-qcturned)*
                    segLength[qc,q3]/ltD);
          tailgon=Polygon[{qcturned,qp2turned,
                           tailPoint}];
          tailrefl=reflection3[tailgon,
            Polygon[{q1,qc,qcturned}]];
          {polyturned,polyrefl,smallgon,
           smallrefl,tailgon,tailrefl,
           Polygon[{nq2,nq4,qcturned}]}
         ]

This function implements a straightforward sequense of geometric constructions for any value of the control angle  f, placing the seven constituent polygons into appropriate 3-D locations.

Acknowledgments

I am grateful to Alexei Bocharov for his substantial help and  guidance in writting this paper and doing this work. I wish to thank my unknown reviewer,   whose comments and suggestions were  of extraordinary benefit for the eventual shape and content of this paper.

References.

1. S. Wolfram:  Mathematica: a System for Doing Mathematics by Computer./ Addson-Wesley, 1991.

2. K.Kasahara: Origami Omnibus./ Japan Publications Inc., 1988

3. Kasahara K., T.Takahama: Origami for the Connsseur./ Japan     Publications Inc., 1987

4. H.Sakata: Origami./ GRAPH-SHA Ltd., 1991

5. J.M.Sakoda. Modern Origami. Simon&Shuster, N.Y.,1969

6. E.Kenneway. Complete Origami. St. Martin's, N.Y., 1987

7. Y.Momotani. Flying Bird Origami. Seibundo Shinkosha, Tokyo, 1993

8. S.Randlett. The Best of Origami. Dutton&Co., N.Y., 1963

9. S.Randlett. The Art of Origami. Dutton&Co., N.Y., 1961

10.T. Sundara Row's. Geometric Exercises in Paper Folding. LA Salle, Illinois    ::: London The Open Court Publishing Company,Fourth Edition, 1941.

11.Friedrich Froebel. The Education of Mansclifton, N.Y., 1974.