Simulation Examples

With these languages one can reliably program a wide variety of complex predetermined shapes and patterns, using only local
communication and local computation. Several examples are presented - origami shapes, geometric patterns and biological caricatures

Each of the examples were generated by compiling a global description in Origami Shape Language and simulating the execution of the local cell program on thousands of cells, with average local neighborhoods of 15 to 20 cells. The cells are randomly but
smoothly distributed, where smooth implies that cells are prevented from overlapping arbitrarily. The cells are randomly placed, have identical programs and the initial conditions consist of the four corners and edges (c1 c2 c3 c4, e12 e23 e34 e14, clockwise from top left).

Origami Shapes:

The animations were generated from the simulator output and show the various stages as the cells cooperate to fold themselves into a prespecified origami shape. The crease pattern after unfolding the final shape is also shown. The global programs on the left were compiled into individual cell programs.
Origami Cup:
(seepthru #t)
(define d1 (fold-onto e23 e12 "green"))
(execute-fold 'd1)

(define d2 (fold-onto e12 d1 "cyan"))
(define p1 (intersect d2 e14))
(define d3 (fold-onto c2 p1 "magenta"))
(execute-fold 'd3)

(define p2 (intersect d3 e12))
(define d4 (fold-onto c4 p2 "magenta"))
(execute-fold 'd4)

(seepthru #f)
(define l1 (fold-line p1 p2 "yellow"))
(execute-fold 'l1)

Origami Airplane:
(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)
(define r2 (fold-onto c2 tmp-m "green"))
(execute-fold r2)
(define l2 (fold-onto c1 tmp-m "green"))
(execute-fold l2)

(define r3 (fold-lontol r2 cntr "cyan"))
(execute-fold r3)
(define l3 (fold-lontol l2 cntr "lightblue"))
(execute-fold l3)

(define r4 (fold-lontol r3 cntr "magenta"))
(execute-fold r4)
(define l4 (fold-lontol l3 cntr "purple"))
(execute-fold l4)

(execute-fold cntr)

(non animated cup sequence)

(non animated airplane  sequence)


Geometric Patterns:

The global language is particularly good at producing geometric patterns.  The figures on the left show patterns generated by applying axioms 2 and 3. We can see that even when the  processors are placed completely randomly (left top row), the creases formed are surprisingly straight.



(define v1 (fold-onto e14 e23 "green"))
(define v2 (fold-onto e14 v1 "green"))
(define v3 (fold-onto e23 v1 "green"))
(define h1 (fold-onto e12 e34 "cyan"))
(define h2 (fold-onto e12 h1 "cyan"))
(define h3 (fold-onto e34 h1 "cyan"))
(if (and (or v1 v2 v3) (or h1 h2 h3))
    (color-me "magenta"))

FIGURE: In the top row, processors are placed randomly and independently. In the bottom row, processors are assumed to have some size and the attempt is made not overlap, thus smoothing the distribution.

The robustness with which these patterns form, results from the properties of gradients. Gradients are an extremely robust mechanism - not only do they provide on average a good estimate of euclidean distance (when average local neighborhood size > 15) but they are also robust to communication failures do not depend on synchronicity of processors. The errors in the distance estimates are on average radially symmetric and not correlated with distance from the source.

The geometric properties of the pattern, however, are a result of the way the gradients are combined. When gradients from two points are combined there is an interference pattern that results in regions of high and low error.  In particular the error is the least along the bisector. Axioms 2 and 3 take advantage of this structure and minimize error by operating along that bisector, thus producing creases that are visually straight (but not necessarily continuous because processors may be missing along the actual bisector). Thus the global language produces straight folds with high accuracy (see Robustness). AI Memo 1666 provides a an extensive analysis of gradients, both theoretical as well as via simulation.

Tessellations and Moth Wing patterns

The primitive seepthru allows multiple layers in a folded sheet to act as if they were a single layer. Any action taken seeps through all the layers. As the images (a,b) show, this allows one to easily create symmetric images. In these images a single cells emits a chemical that seeps through the folded sheet. When the sheet is unfolded, one gets perfectly symmetric pattern on both sides. The image in (b) reminds me of butterfly wings. This might be how the perfectly symmetric wings are produced - the winges are folded together in the caccoon when the pattern forms and it seeps through both wings. When the wings are opened then you get perfect mirror images (as opposed to some complex reaction diffusion boundery idea). Image (d) is a caricatures of a typical butterfly-like pattern and is produced by further folding each wing (c), making a dot/line on the folded wings and then unfolding (still have to generate these images)

(a)  (b)  (c) INSERT MOTH WING PIX (d) ????

This idea can be used to compactly program large scale geometric patterns - tesselations, triangulations, grids, etc. The sheet is first folded into a base tile shape (square, parallelogram, triangle) and then the pattern is folded onto the tile. When the sheet is unfolded the pattern appears in each tile as a result of seepthru. This is a very compact way of reprsenting large scale texture. The triangulation in (e) is produced by folding the sheet into a small triangle and then unfolding; (f) is a result of creating a pattern on that small traingle; (g) is the result of folding a sheet into a square of one fourth size and then making a cup - resulting in a tesselation pattern of cups.

(e)  (f)  (g) 

NOTE: some interesting results in origami by Maekawa that show that many of the origami shapes when unfolded are tesselations of the same basic units. In fact he uses this understanding of tiling and tesselations to create new origami shapes. This might be a compact way of first generating the tiled crease pattern and then folding the shape along the precreases, maybe...