Doodle

Contents

Purpose
Instructions
Configuration
Development
Reference
Lexicon

Purpose

Doodle is a language for description of Origami diagram (paper folding). It is also a translator (a program in fact or compiler) making it possible to transform a doodle text into a diagram (PS, GIF, pdf, HTML...).

Example:
Text in Doodle 
\diagram_header {
  \designer("Anonymous");
  \title("Traditional crane");
  \diagramer("Jerome Gout");
  \diagram_date(2000);
  \color_front(white);
  \color_back(100, 8, 58);
}
\step {
  \diamond(a, b, c, d);
  [mid_ab, mid_dc] = \line_to_line([b,c], [a,d], [a, b], [d,c]);
  [mid_da, mid_bc] = \line_to_line([a, b], [d,c], [a,d], [b,c]);
  \valley_fold(mid_ab, mid_dc);
  \simple_arrow(mid_da, mid_bc, unfold, valley, right);
  \valley_fold(mid_da, mid_bc);
  \simple_arrow(mid_ab, mid_dc, unfold, valley, left);
  \turn_over_vertical;
  \caption("Fold unfold medians and return"); 
}
Result : (click on image to zoom)
Example

The language

A Doodle text is composed of a general description, followed by one or more step (like a traditional diagram). Each step is a succession of operators making it possible to calculate points of control or to describe the movements to carry out the step using these points. For example, a geometrical operator as \point_to_point calculates the points necessary to bring a point on another by a fold. An operator as \valley_fold draws a valley fold between two points (like those calculated before).

Doodle allows a purely geometrical description of folding : each point is located in relation to the others in a precise and geometrical way. But the compiler (current version) does not control feasibility, nor the coherence of folding. All is possible if one can describe it geometrically.

The language uses only ASCII characters and any other symbol. A simple text editor is enough, and the Doodle diagram can be sent by mail easily.

The operators are rather explicit, it is thus possible to fold while following the text. But it is easier to transform it into diagram using the compiler.

The compiler

The compiler takes in input a Doodle file, then analyzes it and generates a graphic file. At this time, only the PS is generated, other formats are aimed.
If you are under Unix, this format is directly displayable using a PostScript interpretor (gv, http://www.cs.wisc.edu/~ghost/gv/index.htm) or it can be sent to a PS printer (by the "lpr" command ).
Under Windows, either send it directly to a postscript printer (copy), or you use an PS interpreter like Ghostscript one (gsview, http://www.cs.wisc.edu/~ghost/gsview/index.htm) to display it and print it. You can also convert it into pdf with Ghostscript or uses Internet sites (http://www.ps2pdf.com/convert/convert.htm).

Example

Here is the most known folding : the pajarita :
The source file parjarita.doo
PS file generated from doo file pajarita.ps
PDF file converted from  PS file pajarita.pdf

Instructions

The textual doodle file is a simple ASCII file and can be edited with your favorite program (notepad under Windows for example).

Then, on command line, launch the program in the following way: 

Usage: doodle [-h] [-v] [-f format] [-o file] file
   -h        : this short usage help
   -v        : verbose mode
   -f format : specifies output format (default ps)
               known formats are : ps, text, graph
   -o file   : uses `file' as the output file
               by default produces extension .ps
   file      : input diagram file (.d)

Example  : if your file is called crane.d, type the following command "doodle crane.d". In the current version, you will obtain by default a file derived from the input file name with ps extension.
Some information is given at the end of the conversion:

  • name of the output file
  • number of steps for the model
  • numbers of pages

Minimal Configuration

Windows

Any basic PC is suitable. The memory required  is negligible. No graphic configuration is necessary to write or compile a doodle file. On the other hand, you need an external tool to see the result (see specification of Ghostscript).

Unix

The current version was compiled under Solaris and   Linux. Other Unix should be able to be used.

Development

This project is hosted by SourceForge SourceForge Logo.

You can see the project state at project page on SourceForge.

The source code is managed with CVS. You can brownse anonymously on tree source.
You can do some enhancements, but first let's talk together about these modifications on the devel-list. It could save you lot of time if someone lese is doing it, or we could help you if needed. Thenb, download the latest sources versions with CVS with these parameters :

  • :pserver:anonymous@cvs.doodle.sourceforge.net:/cvsroot/doodle

When you have finished, generate an unified diff file and send it on the devel-list (compress it if too big).

Three mailling lists could be used :

  • announce-list : list for new version announcements. (low traffic)
  • users-list : list for Doodle users, questions, faq... (medium traffic)
  • devel-list : list for development purpose. You could talk about problem resolutions, enhancement, conception... (technical traffic)

References

Origami
If you do not know Origami, start with these pages, in particular the 'solfege' and the bases.
(http://osele.free.fr/origami)

O.I.L.
OIL is a description language of folding data-processing making it possible to transmit a folding by mail or to evaluate the difficulty of a folding well. It was written by John Smith. There is no OIL compiler at the present time. The language utilizes arrows in the place of operator.
(http://www.users.waitrose.com/~pureland/oil.htm)

Origami One Computer
The thesis of David Fisher (in 1994) described a language of folding. The various types of folds are studied there. (more precise description to provide)
(http://origami.kvi.nl/articles/thesis.ps)

OriDraw de Marteen Van Gelder
Like Doodle on the principle but older.
(http://origami.kvi.nl/programs/oridraw/index.htm)

Lexicon

Origami
Art to fold paper
Diagram
Drawing showing the steps to carry out a origami model
Doodle
Doodle : Origami Oriented Diagramming LanguagE

Updated page on May 29 01
© Osele 2001