Some other features

(back to contents)

Polygons

"The Algorithmic Beauty of Plants" book describes a way to represent procedural surface models by making turtle draw polygons. 

(with-graphics
  (iteration-count 18)
  (set-axiom (turn(-80) A))
  (add-rule (A -> forward(100) turn(20) A)))

This example draws the familiar outline of a regular polygon. 

(with-graphics
  (iteration-count 18)
  (set-axiom ({ turn(-80) A }))
  (add-rule (A -> edge(100) turn(20) A)))

This example draws the polygon itself. Here are command explanations:

{ - start polygon shape
} - end polygon shape
dot - draw polygon point
edge - draw polygon edge
Each polygon must start with { and must end with }, { and } can be nested. In between { and } there must be at least three dot or edge commands. (edge(x)) is essentially the same as (jump(x) dot). The reason why dot is separated is that normal vector for a polygon vertex is assumed to be turtle's current local Y axis. Perhaps it is convenient to change turtle orientation before issuing dot, for example (jump(100) turn(10) dot turn(10) jump(100) ...).

Ripping branches

There are times when it is necessary to destroy whole branches — erase lots of different symbols at once. For that there is a rip command which erases everything up until matching closing square bracket. Consider example: 

(with-debug
  (iteration-count 2)
  (set-axiom (B C C [ C X C B [ B B C ] C B ] C C B))
  (add-rule (B -> B))
  (add-rule (C -> C))
  (add-rule (X -> Y))
  (add-rule (Y -> rip)))
which rewrites in the following manner:
axiom: (B C C [ C X C B [ B B C ] C B ] C C B)
p1: (B C C [ C Y C B [ B B C ] C B ] C C B)
p2: (B C C [ C ] C C B)
In L-systems similar to the one in chapter four where weights of branches are propagated, rip command could be used to snap branches that get too heavy.

Meta rules

LISP makes it possible to pass down rules as arguments: 

(with-graphics
  (iteration-count 19)
  (set-axiom (turn(-80) A))
  (add-rule (A -> meta-rule(#'F 100) meta-rule(#'turn 20) A))
  (add-rule (meta-rule(rule parameter) -> funcall(rule parameter))))
This code produces same circle outline that is shown above.
Try out another LISPy example: 
(add-rule ((delay(rule args time) ? (> time 0) -> delay(rule args (1- time)))
	   (delay(rule args time) ? (= time 0) -> apply(rule args))))

(back to contents)