Global Language: Origami Shape Language (OSL)

Origami can be considered as a language for constructively describing global shape. A shape is described as a sequence of straight folds performed on a square sheet of paper, with no cuts or glue. There are two types of folds - mountain and valley. The folds are always flat and 3D structures are created by opening the flat structure in the end. Huzita, the Italian-Japanese mathematician, has created a set of six axioms for constructing origami folds.The Origami Shape Language (OSL) is based on Huzita's axioms.

Primitive Operations (pop):

Let p* denote a point and l*  a crease line or edge
(fold-line   p1 p2 c) 
(fold-onto  p1 p2 c)
(fold-lontol  l1  l2 c)
(fold-onto-self p1  l1 c)
Huzita's axioms 1 through 4. Return value is a crease line.
c is a optional and specifies a color for the crease line
(intersect  l1  l2 c) Generates (returns)  a new point by intersecting two crease lines
(execute-fold l1 type landmark) Actually fold the sheet along the crease line (unspecified return value). Sheet maintains an apical and basal surface.
type = apical/basal, landmark = point indicating which region changes its apical/basal meaning (induction)
(seepthru #t/#f) If true, then the folded sheet is treated as one sheet of a new shape, and creases go through multiple layers of the sheet.
If false, then the crease line is generated wrt to the unfolded sheet (single layer) . Returns previous seepthru value.
(unresolved issues: should points generated by intersect seep thru? can old points or lines be made to seep thru? is that useful)
(define-region r1 (p1 l1))
(within-region r1
      op1 op2 ...)
A region is defined by a crease line l1 that divides the sheet into two halves and the point p1 indicates which half forms the region r1.,
One can restrict any of the above operations (including seepthru) to occur within only the defined region. 

Means of Combination:

(define cntr (fold-onto e41 e23 "green"))
(define tmp-line (fold-onto e12 e34))
(define cntr-pt (intersect cntr tmp-line))
(execute-fold cntr apical c3)
(seepthru #t)

Not all crease lines are folded, execute-fold actually implies that the sheet should be folded along the crease Not all folds go through all layers of the paper. If seepthru is true then any future creases formed will go through all layers, otherwise the fold goes through a single layer. Many creases are intermediate steps that do not need to be used beyond some small scope and can be nested. The arguments are evaluated before the operation is applied and the order in which the arguments are evaluated is not specified.  It is important to make sure that there are no order dependencies between the arguments.

(execute-fold (fold-onto l1 l2) apical landmark)
(define d1 (fold-onto-self (intersect l1 l2) (fold-onto l3 l4)))

Origami has an implicit notion of a top surface. The type of fold - mountain or valley - is relative to the top surface. After a fold, one side is chosen as the new top surface and future folds are relative to this new top. This is essential, since even a simple structure like a cup will fail if the fold direction is chosen arbitrarily. In the global language we make this more explicit by having the cellsheet maintain an apical surface and a basal surface. A origami valley fold is an apical surface fold and a origami mountain fold is a basal surface fold. After a fold is executed, the apical and basal surfaces are redetermined. Execute-fold specifies  a landmark ( a point or crease) that determines which side of the fold will induce its surface polarity on the other.  This is inspired by the idea of tissue induction where one region of cells induces its type or function or polarity on new cells that it comes into contact with.

All folds are flat folds, which implies that the structure always folds flat. Future extensions to the language will include non-flat folds and folds through multiple layers. Also, the initial sheet need not be a square, but can be any shape with initial boundery conditions, and in fact this already happens as the shape of sheet changes with each fold. The key is that the initial conditions required are simple, few, and likely to remain the same for a given initial shape.

Means of Abstraction:

In origami it is not uncommon to perform identical sets of folds on different flaps or repeat a sequence of flaps multiple times. In addition there are fold sequences that appear often in different origami (traditional bases, rabbit ear folds, etc). Allowing procedures introduces modularity in the high level description as well as in the low level rules. The procedure returns the value of the last statement (hence it can return a new crease or point). Example: Airplane sequence of folds. The folds on the left wing and the right wing are identical, but mirror images. A single procedure works for both wings.

(defun (fold-wing corner cntr-pt cntr-line landmark color)
  (let (t2 t3 t4)
    (set! t2 (fold-onto corner cntr-pt color))
    (execute-fold t2 apical landmark)
    (set! t3 (fold-lontol t2 cntr-line color))
    (execute-fold t3 apical landmark)
    (set! t4 (fold-lontol t3 cntr-line color))
    (execute-fold t4 apical landmark)

(define cntr (fold-lontol e14 e23 "green"))
(define tmp-l (fold-lontol e12 e34 "yellow"))
(define tmp-m (intersect cntr tmp-l "red"))
(seepthru #t)
(fold-wing c1 tmp-m cntr c4 "green")    ;left wing
(fold-wing c2 tmp-m cntr c3 "magenta")  ;right wing
(execute-fold cntr basal landmark=c4)

Define-region and within-region allow one to restrict the execution of a sequence of folds to occur only within some region. A region is defined by a crease line which cuts the sheet into two disjoint regions and a landmark point that distinguishes one side from the other. Even seepthru is restricted within that region. The global language allows one to create more complicated regions by using OR and AND on existing regions.

(define-region rside (create-region cntr c2))
(within-region R1 (fold-wing c2 tmp-m cntr c3 "magenta"))

Regions have many uses. Regions compliment the modularity introduced by procedures. If the regions are disjoint then the same set of code could be executed in both regions without interference. Regions also allow one to use segments of lines (by using only the part of the line that lies within the region) .

Regions also allow one to create and execute folds that do not go through all the layers. In origami this tends to be implicit and expressed through diagrams. Most such folds involve flaps - flaps are regions of the origami that are like appendages off the main origami body and one can define folds that only affect the flap, not the main body, no matter where the flap is. The notion of flaps and operations on flaps is captured by define-region and within-region.

Current Status:

There is a working compiler that translates from the above language to local rules. Implements procedures but not nesting.
Most examples have been generated by writing in the global language and using the compiler to derive the local rules.

Why Origami:

The most attractive feature of origami is that one can construct a
wide variety of complex shapes using a few axioms, simple fixed
initial conditions and one mechanical operation (a fold). The
constructive nature of the shape description plays an important role
in the compilation to local rules. At the same time origami has
considerable descriptive power. Huzita \shortcite{huzita} has proven
that the axioms can not only construct all plane euclidean
constructions, but also solve polynomials of degree three, such as
cube doubling and angle trisection. Demaine {\em et al}
\shortcite{flat-origami} provide a method for constructing scaled
polygonal shapes. Several people are working on automatic generation
of folding sequences from end shape diagrams \cite{Lang}. Huzita's
axioms do not describe all possible origami folds and its limits in
describing 3D shapes are not known. But in general origamists
recognize few if any limitations on the power of origami