Extracts from several messages pertaining to O.I.L.




In response to Kevin's request of May 24 1988 for info on a "code"
for origami (and Anne LaVin's response of June 3): in 1975 the
British Origami Society published a booklet by John S. Smith
entitled "O.I.L.:  An Origami Instruction Language".  I had pretty
much ignored it, finding the effort of learning yet another set
of symbols not worth the trouble.  But realizing the difficulties
of mailing folding instructions via email makes me wonder if it
is worth investigating.  I quote from the first page:

   The language has two parts which occur in each step:

  (I) Definition matrix--a formal statement in rows and columns
     uniquely identifying the points on the boundary or elsewhere
     of the model so far and defining any new locations needed for
     the next fold(s).  To a certain extent the matrix can be used
     to check the accuracy of what has been folded so far.

  (II) Fold Instructions-- Usually these consis of identifying the
     two points which are to be brought into coincidence by a fold
     (or folds).  On occasions two lines may be specified or a
     mixture of points and lines.

He gives numerous simple examples, but as I haven't mastered the
notation yet, and as it would take me quite a while to enter the
specifics, I will wait to find out if anyone is interested.  The
point is, this does not use "drawings", but a more schematic nota-
tion that could probably be adapted to email with a minimum of
trouble.  The trouble would be in learning the code (if it's
even worth the bother).  I can't imagine how this would work for
3-dimensional folds--I suspect it doesn't.  Still--any interest
out there?




Well, I was interested, and Bob sent me a copy of the paper.  It's
about 27 pages long, but I'll see if I can put in a short example.

This is the preliminary fold (DM == Definition Matrix which defines
the corners, FI == Fold Instruction):

Step 0:
DM                                  1


                             2             3


                                    4

Comment:  Each number represents a corner, numbered from top to bottom
and left to right.  The fact that the numbers are unadorned indicates
right angles.

FI:                       1
                   1 ------------> 4

Comment:  This means bring corner 1 to corner 4.  The 1 over the line
tells us that the top layer only is involved in the fold, i.e. it's a
valley fold.  If the 1 were underneath the line, it would be a mountain
fold.

Step 1:
DM:
                    _               _
                    1               2


                           3

Comment:  The lines over the 1 and 2 indicate that those corners have
angles that are less than 90 degrees.  Lines under the numbers
indicate angles of greater than 90 degrees.

FI:
                           2
                 1 -----------------> 3
                           1


                           2
                 2 -----------------> 3
                           1

Comment: Since the corner numbers are unique, we omit the modifier
lines.  The first fold says move point 1 to point 3 over the 2nd layer
and under the 1st layer -- i.e. an inside reverse fold.  Similarly for
moving point 2 to point 3.

That's a *very* simple example.  In addition to the corners, you can
designate other parts of the paper by saying something like A =
1/2(1-3) (A is the point halfway along a line between point 1 and 3 --
this is not necessarily a point on an edge).

Now this is all a big pain in the neck to type in by hand, and
probably too baroque to decode by eye, particularly since the summary
of the symbols is 4 pages long, and includes ways of designating
diagonals (that may cross at angles other than 90 degrees), enclosed
areas, approximate point locations, number of layers in the definition
matrix, etc., etc.

On the other hand, it would be relatively simple to write a program to
translate O.I.L into diagrams.  These diagrams combined with the usual
step-by-step commentary would probably be sufficient.  Getting folds
into O.I.L. would be a little tougher, but I could see how it might be
done with a specialized origami diagram drawing tool (it would be a
fun three-week lispm hack... too bad I'm working on a degree at the
moment).

This is probably more than anyone wants to know about O.I.L., but
there you go.  If anyone is really interested, send me some mail, and
we'll discuss how to get it to you (I'm a broke grad student, or I'd
offer to xerox it up and send it out to everyone who wanted it).


The only reference I have to code that allows one to specify an
origami model is in Peter Engel's "Folding the Universe."

Here is a paragraph about it from the book and
the reference: (w/o permission, of course)

"    It happens that a system has already been devised for
     converting folding diagrams to a numerical notational
     system, John Smith's Origami Instruction Language (OIL).
     Smith, a British statistician and computer programmer,
     uses a Cartesian coordinate system to locate points on
     the square and identifies a crease by the two endpoints
     it connects. The success of Smith's system ensures that
     establishing a purely numerical representation for each
     model is possible....       "

The reference is

Alice Gray, "OIL: John Smith's Origami Instruction language,"
The Origamian 13, no.2, (n.d.), p. 1.
I think it is a good idea to have software that can communicate
folds on a sheet of paper graphically, but it could become
extremely cumbersome or nonfunctional for complex models and
when thickness becomes an issue.