Lindenmayer L-System Library

Lindenmayer.js supports several production formats to handle different L-System complexities:

1. String-Based

Simple replacement using a string. myLsystem.setProduction('F', 'FF');

2. Array-Based (Parametric)

Used for parametric L-Systems where symbols carry custom parameters. Each object in the array must have a symbol property.

myLsystem.setProduction('F', [
	{symbol: 'F', params: [5,6,1]},
	{symbol: 'F', params: [1,0,0]}
]);

3. Object-Based (Context-Sensitive, Conditional, Stochastic)

Wrap a successor in an object to add advanced logic:

• Context-Sensitive: Use leftCtx and rightCtx to define required neighbors.
• Conditional: Use a condition function that returns a boolean.
• Stochastic: Use the successors array with weight properties to define probabilities.

// Context-sensitive
myLsystem.setProduction('F', { successor: 'FF', leftCtx: 'FB' });

// Conditional
myLsystem.setProduction('F', { successor: 'FF', condition: () => true });

// Stochastic
myLsystem.setProduction('B', {
  successors: [
    {weight: 50, successor: 'X'},
    {weight: 50, successor: 'Y'}
  ]
});

4. Function-Based

Provides maximum flexibility. The function receives an info object and returns a successor (String or Array).

The info object contains:

• index: Current index in the axiom.
• part: The current symbol part (the full object if using Array-based axioms).
• params: Shorthand for part.params.
• currentAxiom: Reference to the current axiom.

myLsystem.setProduction('F', ({index, part}) => {
    // Access custom parameters from 'part'
    return [{symbol: 'F', size: part.size / 2}];
});

You can create highly flexible L-Systems by using an Array of Objects for the axiom instead of simple strings. This allows you to inject custom parameters (e.g., food, size, angle) into your symbols.

When defining productions, the function receives an object representing the current part. This object contains the symbol and any custom parameters you defined in the axiom. You can then use these parameters to drive conditional logic within your production rules, such as simulating organic growth or resource consumption.

Note: When using objects in the axiom, you must explicitly define the symbol key so the engine can match it to the correct production rule.

let parametricLsystem = new lsys.LSystem({
  axiom: [
    {symbol: 'A', food:0.5},
    {symbol: 'B'},
    {symbol: 'A', food:0.1},
    {symbol: 'C'}
  ],
  productions: {
    'A': ({part, index}) => {
      // split A into one A and a new B if it ate enough:
      if(part.food >= 1.0) {
        return [{symbol: 'A', food:0}, {symbol: 'B', food:0}]
      } else {
        // otherwise eat a random amount of food
        part.food += Math.random() * 0.1;
        return part;
      }
    }
  }
});

// parametricLsystem.iterate(60);

When initializing new LSystem(options), you can provide the following configuration keys:

• axiom: The initial word/string (the initiator). Can be a String (e.g., 'ABC') or an Array of Objects (e.g., [{symbol: 'A'}, {symbol: 'B'}]).
• productions: A key-value Object mapping symbols to their replacement rules. Rules can be Strings, Arrays, Objects, or Functions.
• finals: An optional key-value Object of functions executed for each symbol in order. Useful for visualization. Each function follows the signature (info, arg) => {} where info is {index, part}.
• allowClassicSyntax: Boolean (default: true). Enables classic context-sensitive syntax (e.g., A<B>C).
• branchSymbols: A String tuple of symbols treated as branches (default: '[]').
• ignoredSymbols: A String of symbols to ignore during context-sensitive checks (default: '+-&^/|\').
• forceObjects: Boolean (default: false). If true, automatically converts Strings like 'AB' into arrays of objects [{symbol: 'A'}, {symbol: 'B'}].