L-systems (Lindenmayer-systems, named after Aristid Lindenmayer, 1925-1989), allow definition of complex shapes through the use of iteration. They use a mathematical language in which an initial string of characters is matched against rules which are evaluated repeatedly, and the results are used to generate geometry. The result of each evaluation becomes the basis for the next iteration of geometry, giving the illusion of growth.

The L-system SOP lets you simulate complex organic structures such as trees, lightning, snowflakes, flowers, and other branching phenomena.

There are several factors which combine to organize plant structures and contribute to their beauty. These include:

• symmetry

• self-similarity

• developmental algorithms

With L-systems, we are mostly concerned with the latter two. Self-similarity implies an underlying fractal structure which is provided through strings of L-systems. Benoit Mandelbrot describes self-similarity as follows:

“When each piece of a shape is geometrically similar to the whole, both the shape and the cascade that generate it are called self-similar.”

L-systems provide a grammar for describing the growth of self-similar structures in time. L-system rules determine the underlying structures of growth in a way that is analogous to the way that DNA is thought to determine biological growth. This growth relies on the principle of self-similarity to provide extremely compact descriptions of complex surfaces.

The central concept of L-systems is rewriting. This works by recursively replacing an initial state (the initiator) with rewritten geometry (the generator), reduced and displaced to have the same end points as those of the interval being replaced.

In 1968, Astrid Lindenmayer introduced a string rewriting mechanism termed “L-systems”. The grammar of L-systems is unique in that the method of applying productions is applied in parallel and simultaneously replaces all letters in a given “word”.

The simplest example of a rewriting grammar is where two “words” or strings are used, built from the two letters: a and b, which may occur many times in a string. Each letter is associated with a rewriting rule. The rule a = ab means that the letter a is to be replaced by the string ab, and the rule b = a means that the letter b is to be replaced by a.

If we start the process with the letter b (the premise), and follow it through in time, we see a certain pattern emerges by following the rewriting rules:

The general form of an L-system rule is:

[left_context<] symbol [>right_context] [:condition]=replacement [:probability]

Where…

We can combine this string-manipulation system with a graphics routine that interprets the strings as commands for a drawing “turtle” with a position (XYZ) and heading (angle). By following the commands, the turtle traces out a shape as it moves.

Examples of simple turtle commands:

(In the actual L-system node, the angle of the + and - commands is configurable.)

With these simple rules, we can easily come up with a string that causes the turtle to draw a shape such as the letter “L”. For example, assuming the turtle is initially facing upwards, we would use the following string to create the letter “L”:

By iteratively running a turtle command string through rewrite rules, you can generate surprisingly complex geometry. The power of self-reference in rewrite rules can create extremely intricate figures.

As a very simple example of self-reference, consider an L-system with the initial string A and the rule A=F+A. The rule means “Wherever you see 'A', replace it with 'F+A'”. Because the replacement will contain within it the trigger for the rule, each generation will cause the string to grow in a cascade effect:

This generates a growing list of repeated “move forward, then turn” commands. With a turn angle less than 90 and a sufficient number of generations, this L-system will approximate an arc or circle. You could use this behavior as the basis for curling a sheet of paper or curling a scorpion’s tail. Or, you could randomize the turn angle and create a squiggly line, which you could use as the basis for a bolt of lightning.

(Be sure not to confuse the turtle command string F+A with the mathematical statement F plus A. In the context of L-systems, the + symbol means “turn”, not “add”.)

Another example: the following figure is called a quadratic Koch island. Beginning with these values:

…the turtle generates the following for three generations:

The systems described so far generate a single continuous line. To describe things like trees, we need a way to create branches.

In L-systems, you create branches with the square brackets ([ and ]). Any turtle commands you put inside square brackets are executed separately from the main string by a new turtle.

For example, the turtle commands F [+F] F [+F] [-F] is interpreted as:

1. Go forward.

2. Branch off a new turtle and have it turn right and then go forward.

3. Go forward.

4. Branch off a new turtle and have it turn right and then go forward.

5. Branch off a new turtle and have it turn left and then go forward.

This creates the following figure:

Another example: the command string F [+F] [-F] F [+F] -FF creates the following figure:

The systems described so far generate flat geometry.

To move the turtle in 3D, you use the , ^ (pitch up), & (pitch down), \ (roll clockwise), and / (roll counter-clockwise) commands.

For example, the initial premise FFFA and the rule:

A= " [&FFFA] //// [&FFFA] //// [&FFFA]

Does the following:

This creates the following 3D figure:

The rule creates three branches at every generation. The pitch down commands (&) split the branches off from the vertical. The roll commands (/) make the branches go out in different directions. (Note the A at the end of each branch that ensures new copies of the rule will grow from the ends of the branches.)

The " command makes the F commands half length in each generation, which makes the branches shrink further out.

In the previous section we used the rule A= " [&FFFA] //// [&FFFA] //// [&FFFA].

Obviously this rule has redundancy. Since L-systems are about replacing symbols with strings, we can simply replace the repeated strings with a new symbol, and then create a new rule for that symbol:

Because the branches are now defined in one place, if you want to change the branch instructions you only need to edit one string.

Note that the two-rule system will take twice as many generations to produce the same result. This is because each generation performs one rule substitution.

So, whereas the single rule A= " [&FFFA] //// [&FFFA] //// [&FFFA] grows by expanding A at each generation, the dual rules of A= " [B] //// [B] //// [B] and B= &FFFA work by alternating between replacing A with " [B] //// [B] //// [B] and replacing B with &FFFA.

Normally turtle symbols use the current length/angle/thickness etc. to determine their effect. You can provide explicit arguments in brackets to override the normal values used by the turtle command.

The following list shows the bracketed arguments. Remember that you can simply use the single-character command without the arguments and Houdini will simply use the normal values.

See local functions and variables below for what functions and variables you can use in argument expressions inside the brackets.

These functions and variables are available in arguments to turtle commands such as F(). These are separate from parameter expression functions and node local variables.

Houdini lets you create a copy of some geometry at the turtle’s location using certain commands. You can use this to create leaves and flowers on an L-system shrub, for example.

1. Connect the output of the geometry you want to stamp to one of the L-system node’s inputs.

2. Use the corresponding command (J, K, or M) in a turtle command string to insert the geometry.

If you connect a leaf surface to the L-systems input 1 and a flower to input 2, you can use the following to create a bush with leaves and flowers:

Rule 1 prefaces the K and J commands with f (move forward without drawing) to offset the geometry a little bit. Otherwise, the leaf would be attached at its center, rather than the edge.

Each symbol can have up to five user-defined variables associated with it. You can reference or assign these variables in expressions. Variables in the matched symbol are instanced while variables in the replacement are assigned.

For example, the rule A(i, j)=A(i+1, j-1) will replace each A with a new A in which the first parameter (i) has been incremented and the second parameter (j) decremented.

Parameters assigned to geometric symbols (for example, F, +, and !) are interpreted geometrically. For example, the rule: F(i, j) = F(0.5*i, 2*j) will again replace each F with a new F containing modified parameters. In addition to this, the new F will now be drawn at half the length and twice the width.

To create an L-system which goes forward ‹x› percent less on each iteration, you need to start your Premise with a value, and then in a rule multiply that value by the percentage you want to remain.

This way ‹i› is scaled before ‹A› is re-evaluated. The important part is the premise: you need to start with a value to be able to scale it.

The third argument to the J/K/M commands is passed to the connected geometry.

1. Create a Circle node and set the number of divisions to stamp("/path/to/lsystem", "lsys", 3).

   Because the default number of divisions is 3 (the second argument in the expression), this creates a triangle.

2. Connect the output of the circle node to the J input of an L-system node.

3. In the L-system rules, you can use J(L,0,‹number›) to pass ‹number› to the J geometry. For example, J(L,0,4) produces a square, J(L,0,5) produces a pentagram.

The g command puts all geometry currently being built into a group.

The group name is composed of a prefix set on the Funcs tab and a number. Default prefix is lsys, producing group names like “lsys1”. You can specify the number as an argument to the g command.

For example, g[F] puts geometry from the F into a group (named using ). Otherwise, the default index is incremented appropriately.

The current group is associated with the branch, so you can do things like gF [ gFF ] F to put the first and last F into group 0, and the middle (branched) FF into group 1.

To exclude a branch from its parent’s group, use g(-1).

In The Algorithmic Beauty of Plants, many examples use a technique called edge rewriting which involve left and right subscripts. A typical example is:

However, Houdini doesn’t support the F(l) and F(r) syntax. You can modify the rules to use symbol variables instead.

For the F turtle symbol, the first four parameters are ‹length›, ‹width›, ‹tubesides›, and ‹tubesegs›. The last parameter is user-definable. We can define this last parameter so 0 is left, and 1 is right:

After two generations this produces: Fl+Fr+-Fl-Fr There should not be any difference between this final string and: F+F+-F-F

Another approach is to use two new variables, and use a conditional statement on the final step to convert them to F:

The produces the following output:

The L-system node’s meta-test input lets you generate rules that will cause the system to stop when it reaches the edges of a defined shape, like a topiary hedge.

• This L-system checks to see if the next iteration of growth will be within the Meta-test bounds, and if not it prunes the current branch.

• Rule 1 executes 80% of the time when the branch is within the meta-test boundary.

• Rule 2 executes when the branch is not within the meta-test boundary (the ! negates the in(x,y,z) condition). The % command ends the branch.

L-systems can be a powerful tool for arranging modeled geometry. By using an L-system as the template input to a Copy SOP, you can place a copy of a model at every point of the L-system.

For example, you could use the “arc approximation” L-system from the L-system basics (premise=A, rule=A=F+A) to arrange a series of spheres in an arc or circle. This gives you parametric control of the bending and spacing of the arc of spheres.

If you have any serious interests in creating L-systems, you should obtain the book:

The Algorithmic Beauty of Plants by Przemyslaw Prusinkiewicz and Aristid Lindenmayer (1996, Springer-Verlag, New York. Phone 212.460.1500. ISBN: 0-387-94676-4)

It is the definitive work on the subject. It contains many L-systems examples along with ideas and theories about modeling realistic plant growth.

Modeling something like a whole tree as single large L-System may cause collision resolution calculations to be single threaded. The wire solver will look for pieces of wire objects that can be solved independently and divide the work among the available cores. One large connected L-System means the work cannot be divided into smaller work units.

Try using a Wire Glue Constraint DOP to constrain a point on the L-System where the branches join together near the root of the tree (constrain the point to its world space position). This will cause the wire solver to see the separate branches as distinct pieces that can be solved independently. Since the constrained point will not move, any motion on one of the branches will not affect the other branches. If possible, reducing the number of points in the wire object should also speed up the calculations.