The defining characteristic of flat origami is that it essentially has no three dimensional structure and can be flattened without forming any new creases. This subset of general origami is useful for generating mathematical figures such as the golden section, regular polygons, or any number of others.
My explorations into this area began in the spring of 1999. You can examine snapshots of my pages (1st, 2nd) over the years via the wayback machine to get specific dates for when I published content on this subject matter. My web presence has changed quite dramatically over the years, so be kind about what you find.
|
The Axioms |
top |
The first formal axiom list for origami was published by Humiaki Huzita and Benedetto Scimemi and has come to be known as the Huzita axioms. These axioms describe the ways in which a crease (or line) can be generated by the alignment of points and lines. A version of the six axioms including the possible outcomes, but not including the conditions for those outcomes, is as follows.
(O1): Given two points pA and pB, we can fold a unique line through them.
(O2): Given two points pA and pB, we can fold a unique line by folding pA onto pB.
(O3): Given two lines lA and lB, we can fold one or two lines by folding lA onto lB.
(O4): Given a point pA and a line lB, we can fold a unique line perpendicular to lB through pA.
(O5): Given a point pA, a line lB, and another point pC, we can fold zero, one, or two lines through pC by placing pA onto lB.
(O6): Given two points pA and pC and two lines lB and lD, we can fold zero, one, two, or three lines by placing pA onto lB and pC onto lD.
In 2002, Koshiro Hatori described a single-fold alignment which produces a crease not possible using the Huzita axioms. This seventh axiom is referred to by O7. This set of seven axioms has come to be known as the Huzita-Hatori axioms. Robert Lang points out in [5] Jacques Justin had published a paper in 1989 which he described the Huzita axioms and the seventh axiom later discovered by Hatori. Mathematics is a science of exploration, wherein the same concepts can easily be discovered by completely independent researchers. There is a tradition of naming things after the person who first discovered them, so as Lang properly suggests, the origami axiom list should be referred to as the Huzita-Justin axioms and the seventh axiom should be referred to as Justin's axiom.
(O7): Given a point pA and two lines lB and lC, we can fold zero or one line by placing pA onto lB such that the resultant crease is perpendicular to lC.
These axioms are the basic folds of origami, producing new fold lines from existing points and lines. Robert Lang has illustrated a proof of the completeness of this set in [5] with regards to simple point and line alignments.
The intersection of two lines forms a point. This is sometimes stated and most assuredly, always assumed. For an unambiguous method of writing fold sequences, it is important to specify this. The origami axiom list describes the basic steps available for folding origami. For my purposes it should have an axiom for this concept. Because it is required for the generation of point references used in every other axiom and is so rarely stated, I will refer to it as the 0th origami axiom (O0).
(O0): Given two lines lA and lB, we can form zero or one point by intersecting lA and lB.
When a fold is made, any points or lines from one side of the crease are placed into contact with the other side of the crease. These points or lines can then be used in further folds which do not actually involve them, but instead their image on the opposite side of a crease. The image is that of a reflection of the points or lines across the crease. For my purposes, it makes sense to state a reflection axiom for points and one for lines.
(O8): Given a point pA and a line lB, we can form one point by reflecting pA across lB.
(O9): Given two lines lA and lB, we can form one line by reflecting lA across lB.
|
The Story |
top |
When I first took an interest in geometric constructions with origami I decided to try and fold some basic regular polygons. After some false starts I figured out how to fold the equilateral triangle and regular hexagon. I found I had to save the resultant forms if I wanted to make them again without difficulty, ending up with a collection of folded sheets in a pile on my desk. I wanted a more permanent way to store the method for folding the shapes, but I didn't want to have to go to the effort of diagramming them as I had for some of my animal models. After some thought I decided to just try writing the folding sequence out instead of drawing them. This didn't work as easily as I thought it might because the way I thought of folds was meaningless without the visual references provided by a sheet of paper or my imagination. I realized to be able to write down the folding sequence, I'd have to explicitly define every reference point and crease I'd need to fold a model. With every reference defined, the fold then could be written without having to draw any images. Each step would result in one or more new references being added to the set of those already in use.
As I worked out how to write down the folds, I had to think about what the basic fold processes actually were. I worked out a set of what I thought were all the basic folds for flat origami. I then thought up some symbols to clearly represent those basic folds. I soon had what I considered a complete method for generating typewritten unambiguous fold descriptions.
I then decided to do a web search to see if anyone else had approached the problem in this way. Any research project should begin with a literature search, but I didn't see this project as research. I saw it as a puzzle to amuse myself with.
My search led me to Tom Hull's Origami Mathematics page [1], where I learned about Humiaki Huzita and the axioms he had published for flat origami in 1992. I also found a seventh axiom of flat origami was discovered by Koshiro Hatori [2] in 2002.
I had recognized the first five of the six basic folds identified by Huzita. Huzita's sixth axiom and Hatori's (Justin's) axiom were surprises to me, but were easily included within the written framework I had developed.
All the work I found regarding the axiomatic nature of origami was very interesting and helped me to organize my thoughts on the subject, but they were not works on written forms for origami and as such were not alternate solutions to my own work so far.
An early example of work towards a written form for origami instructions I did find was John Smith's Origami Instruction Language (O.I.L). I don't have access to the original publication, but there is information regarding his method available online. Joseph Wu is hosting the first section of John Smith's booklet, An Origami Instruction Language [3]. The topic of O.I.L. has also come up in discussions on the Origami-L, excerpts [4] are hosted at the Origami Interest Group (maintained by Maarten van Gelder).
Doodle is a diagramming aid with many features that I would like to eventually include in the work I am doing. It allows for the automated production of diagrams from a text definition of a fold sequence. It does have a few drawbacks. The code which defines a fold is not very readable. Reading through the documentation reveals the origami axioms are not used. You have to include in your script the new lines and where you want them, rather than having their placement generated from actions on existing features. Doodle appears to allow for a full range of three dimensional fold representations, but the given examples do not test this limit. Work on the Doodle project seems to have stalled in about 2001.
Oridraw, created by Maarten van Gelder, is another diagramming aid that reads in a text description and outputs a graphical image. It can be used for diagramming origami or anything else you might feel like. Maarten began working on this program in 1985 and the last update is indicated in 2002.
Foldinator is another diagramming aid for origami. This project has a graphical interface which simulates the folding process of origami. This project also does not rely on axioms of origami, instead allowing the user to draw fold lines across the model. The documentation indicates a snap-to feature is present, so that you can generate folds to pre-existing points and line intersections. There are limited examples. Work on the Foldinator project seems to have stalled in early 2004.
The work most similar to mine that I've come across is found in a thesis by David Fisher [5]. David's system is comparable to mine in general concept, but uses language more similar to english for describing fold operations. He has included most of the possible fold operations, excluding Justin's axiom (O7). His system is able to describe the orientation of the paper at each stage of the fold, which my system ignores. The drawback of David's system is the need to use his program for ease of use in the creation and interpretation of the text description of a fold.
I have written some code which allows me to play with simulated folds. That the code uses the axioms of origami to generate new references from those existing, seems to make it somewhat unique among those projects published on the web. However, I am certain others have written programs for their own purposes which do the same.
My code is an ongoing work and not yet ready for a public release. I have translated my codebase into PHP, the code now outputs crease diagrams in PDF format, and I have mostly completed the code's internal documentation. I am currently writing a parser for the origami script language. The first versions should handle the basic language syntax, but I'm certain they will fail on the more complex language elements.
|
The Language |
top |
|
This written form is a combination of references, sets of references, and operations on those references. References can be points, lines, or line segments. Each operation will generate new references or sets of references which can be used to further construct the model. |
|
|
Definitions : |
|
|
|
A single or series of letters is a reference. A reference is the label for a specific feature and needs to be unambiguous. The features include points, segments, and lines. Segments and lines correspond to fold lines and creases. References for points start with a "p", segments with an "s", and lines with a "l". |
|
|
A shape name can define a set of points to start a fold, A shape name can also be defined by a set of points at the end of of a fold. The points are ordered clockwise around the shape. |
|
Operators : |
|
|
|
This operator indicates the first term and the second term are equivalent. |
|
|
This operator indicates the first term is folded to the second term. |
|
|
This operator indicates a fold is made between the first term and second term. |
|
|
This operator indicates the first term requires the second term as a reference to make the statment unambiguous or that the scope of the first term is limited by the second term. |
|
|
This operator indicates the intersection of the first term and the second term. |
|
|
This operator indicates a fold is made by acting the first term against second term. This is not a symmetric operator and its only use is in writing O8 and O9. |
|
Folds : Any fold not otherwise specified should be thought of as a crease. |
|
|
|
If this fold type is applied to a line, it indicates the line is to be folded and then unfolded. If this fold type is applied to a point, it indicates a small crease perpindicular to the paper edge or line the point is on. If an operation generates a line without the type of fold being specified, a crease is assumed. |
|
|
Indicates the line or lines are to be valley or mountain folded. If used on a point, it means an arbitrary fold passing through that point. |
|
|
Indicates the line or lines are to be unfolded. The statement used without references indicates the entire model is to be unfolded. |
|
example: "crease(lA):[lB to lC]" would indicate creasing lA between lB and lC only. |
|
|
Operations : |
|
|
|
The sort operation acts on a set of references and returns a copy of the set of references ordered by distance from reference "D". This operation is required to remove the ambiguity generated when an operation can generate multiple valid references which may be required for further constructions. Typically the operation which results in the set to be sorted would be written within the sort operation. (example: sort((lA <=> lB),pC) = [lD,lE]) |
|
|
The intersection of two lines or line segments generates a new point. The lines can be on separate layers of a fold when folded. [0,1] solution. (O0) |
|
|
Indicates the creation of a line by folding one point to another point. [1] solution. (Huzita's axiom, O2) |
|
|
Indicates the creation of a line by folding one line to another line. There can be one or two solutions for this operation depending on initial conditions. [1,2] solution. (Huzita's axiom, 03) |
|
|
Indicates the creation of a line by folding one point to a line such that the resulting line passes through another point. There can be between zero and two solutions for this operation depending on initial conditions. [0,1,2] solutions. (Huzita's axiom, O5) |
|
|
Indicates the creation of a line by folding one point to a line such that the resulting line passes through another line. The only unambiguous position for the resulting line is perpendicular through the second line. There can be zero or one solution for this operation depending on initial conditions. [0,1] solution. (Justin's axiom, O7) |
|
|
Indicates the creation of a line by folding one point to a line while a second point is folded to a second line. There can be between zero and three solutions for this operation depending on initial conditions. [0,1,2,3] solutions. (Huzita's axiom, O6) |
|
|
Indicates the creation of a line by folding from one point to another. [1] solution. (Huzita's axiom, O1) |
|
|
Indicates the action of folding a line from a point to a line. The only unambiguous way to do this is to make the fold perpendicular to the line through the point. [1] solution. (Huzita's axiom, O4) |
|
(lB -> lA) != lC |
Indicates the action of reflecting a line across another line. This is not a symmetric operation. [1] solution. (O9) |
|
|
Indicates the action of reflecting a point across a line. [1] solution. (O8) |
|
Combination statments : |
|
|
|
For writing a series of identical statments using different references, you can replace each term of the operation with a set of references. Operators and operations act in a distributive manner across the sets. Thus: (([pA,pB,pC] <-> [pD,pE,pF]) = [lG,lH,lI]) = [(pA <-> pD) = lG, (pB <-> pE) = lH, (pC <-> pF) = lI] |
|
Composite statments : |
|
|
(lD @ lE) = pF (pC <-> pF) = lG ((lA @ lB) <-> (lD @ lE)) = lG |
If a reference is only to be used once in the formation of another reference, you can combine the statments into one in this way. This makes sense so long as the type of reference produced by one operation is apropriate for the input of the next operation. Presumably you could write in one line a series of twenty or more operations combined into one statement if none but the final references were to be used in any other context. I do not advise this, however. |
|
The Problem |
top |
|
At present, I don't have a method of describing multiple layers and other more complicated fold operations. I have some ideas working, but no schedule for breakthroughs. For now this method is limited, but is sufficient for writing the geometrical constructions which inspired me in the beginning. |
|
|
Examples |
top |
|
Equilateral Triangle (maximum) : [diagram]
square = [pA,pB,pC,pD] (pA <-> pB) = lA (pB <-> pC) = lB (pC <-> pD) = lC (pD <-> pA) = lD (lA <=> lC) = lE (lD <=> lB) = lF (pA <=> lE):pB = lG (pC <=> lF):pB = lH (lG @ lD) = pE (lH @ lC) = pF (pF <-> pE) = lI equilateral triangle = [pB,pE,pF] Combining multiple identical folds into one statement would shorten the instructions, thus: square = [pA,pB,pC,pD] ([pA,pB,pC,pD] <-> [pB,pC,pD,pA]) = [lA,lB,lC,lD] ([lA,lD] <=> [lC,lB]) = [lE,lF] ([pA,pC] <=> [lE,lF]):pB = [lG,lH] ([lG,lH] @ [lD,lC]) = [pE,pF] (pF <-> pE) = lI equilateral triangle = [pB,pF,pE] |
|
|
Square : [diagram]
paper[pA] fold( pA ) = lA (lA <=> lA):pA = lB (lB <=> lA) = lC (lB <=> lB):(not(pA)) = lD (lB @ lD) = pB (lD @ lC) = pC (pC <= lA) => lE (lE @ lA) = pD square = [pA,pB,pC,pD] |
|
|
Pentagon : [diagram]
square = [pA,pB,pC,pD] (pA,pC,pB,pD <-> pB,pD,pC,pA) = lA,lB,lC,lD (lC <=> lD) = lE crease(lA <=> lB):lC = lF (pD <-> (lF @ lC)) = lG (lG <=> lB) = lH (lG <=> lC) = lI vfold( ((lH @ lI) <-> lB) ) = lJ mfold( lE ) mfold( (lC <=> lD) ) = lK unfold( ) ([lJ,lK] @ [lB,lB]) = [pE,pF] (pF <=> lC):pE = lM crease([lC,lD] @ [lK,lE]) = [pG,pH] (pH <-> lM) = lN (lN @ lE) = pI ([pH,pE,pG] <-> [pF,pG,pI]) = [lO,lP,lQ] pentagon = [pI,pH,pF,pE,pG] |
|
|
Hexagon (maximum): [diagram]
square = [pA,pB,pC,pD] ([pA,pB,pC,pD] <-> [pB,pC,pD,pA]) = [lA,lB,lC,lD] ([lA,lB] <=> [lC,lD]) = [lE,lF] crease(lF <=> lB):[lA,lE] = lG crease(lE <=> lA):[lB,lF] = lH (pB <=> pD) = lI ([lE,lE,lF] @ [lF,lB,lA]) = [pE,pF,pG] (pF <=> lH):pE = lJ (pG <=> lG):pE = lK ([lJ,lJ,lK,lK] @ [lB,lD,lA,lC]) = [pH,pI,pJ,pK] mfold(pI <-> pK) = lL mfold(pJ <-> pH) = lM vfold(lJ) ([lI,lI] @ [lA,lC]) = [pL,pM] mfold([pH,pI] <-> [pL,pM]) = [lN,lP] unfold() ([pK,pJ] <-> [pL,pM]) = [lO,lQ] hexagon = [pJ,pH,pL,pK,pI,pM] |
|
|
Octogon (maximum): [diagram]
square = [pA,pB,pC,pD] ([pA,pD,pA,pB] <-> [pB,pC,pD,pC]) = [lA,lB,lC,lD] ([lA,lC] <=> [lB,lD]) = [lE,lF] ([pA,pB] <=> [pC,pD]) = [lG,lH] (lG <=> lF) = [lI,lJ] (lI @ [lD,lC]) = [pE,pF] (lJ @ [lA,lB]) = [pG,pH] ([pH,pE,pG,pF] <-> [lG,lH,lG,lH]) = [lK,lL,lM,lN] ([lK,lL,lM,lN] @ [lC,lB,lD,lA]) = [pI,pJ,pK,pL] octagon = [pG,pK,pE,pJ,pH,pI,pF,pL] |
|
|
References |
top |
[1] Hull, T. (1997,2003). Origami and Geometric Constructions. http://www.merrimack.edu/~thull/omfiles/geoconst.html
[2] Hatori, K. Origami Construction. (n.d.). http://origami.ousaan.com/library/conste.html.
[3] Smith, J. (1975). An Origami Instruction Language. http://www.origami.as/Info/Oil/oil.php
[4] Extracts from several messages pertaining to O.I.L. (1988). http://origami.kvi.nl/lists/oil.htm
[5] Fisher, D. (n.d.). Origami on Computer. http://origami.kvi.nl/articles/thesis.ps
[6] Lang, R. (1996-2003). Origami and Geometric Constructions. http://www.langorigami.com/science/hha/hha.php4