@rgsoft/turtle

Turtle

Turtle and L-Systems library

L-Systems

The LSystem class is an implementation of the Lindenmayer systems based on an alphabet of symbols and production rules.

const lsystem = new LSystem(axiom, rules);

The axiom is the base sentence from which future sentences will be generated or inferred, and must be composed only by symbols of a defined alphabet. This alphabet is based on the Turtle Graphics movements.

F, G, H, L, M, D, U, +, -, [, ]

The rules is an array of strings or instances of the Rule class, where each one of them defines a production rule for spawning the next generation sentence.

Generation

The generate method in the LSystem class spawns new generations of the current sentence.

const axiom = 'F';
const rules = [
    'F=>F[+F][-G]'
];
const lsystem = new LSystem(axiom, rules);
console.log(lsystem.sentence); // F
lsystem.generate();
console.log(lsystem.sentence); // F[+F][-G]

This method also admits a number argument that indicates the number of generations to generate.

const axiom = 'F';
const rules = [
    'F=>FG'
];
const lsystem = new LSystem(axiom, rules);
console.log(lsystem.sentence); // F
lsystem.generate(4);
console.log(lsystem.sentence); // FGGGG

Rules

The Rule class represents a production rule that allows the generation from a symbol to a string of one or more symbols from the alphabet.

const str = 'F => F[+F][-F]';
const rules = [ new Rule(str) ];
console.log(rule.base); // F
console.log(rule.next); // ['F', '[', '+', 'F', ']', '[', '-', 'F', ']']

The LSystem class uses this class to maintain and generate the sentences.

Turtle Graphics

The Turtle class is a clumsy attempt to use a "sentence" driven drawing engine based on the turtle graphics. The sentences use the same symbols in the LSystem and Rule alphabet, with each symbol having a specific usage.

Symbol	Action
F, G, H	Advances forward a certain amount of steps drawing a line
M	Advances forward a certain amount of steps without drawing a line
L	Draws a tree leaf
U	Upscale drawing (divides current scale by scale ratio, with initial scale is 1)
D	Downscale drawing (multiplies current scale by scale ratio, with initial scale is 1)
+	Turn right a certain angle
-	Turn left a certain angle
[	Saves current context
]	Restores current context

The render method reads each symbol in the string, and performs an action according to the previous table.

const turtle = new Turtle(config);
turtle.render(sentence);

Turtle Config

The config argument for the Turtle class constructor has these properties:

Property	Type	Description
context	CanvasRenderingContext2D	Canvas rendering context used for drawing
strokeSize	number	Lenght of each step used stroke or move (may be affected by scaling)
strokeWeight	number	Width of the stroke (may be affected by scaling)
angle	number	Angle used for each turn (+ and -)
scale	ScaleConfig	Scale config

The ScaleConfig has this properties:

Property	Type	Description
ratio	number	Scale ratio (between 0 and 1) to be applied when upscaling or downscaling
scaleStrokeSize	boolean	Optional (default false), specifies if the stroke length must be scaled
scaleStrokeWeight	boolean	Optional (default false), specifies if the stroke weight must be scaled
scaleAngle	boolean	Optional (default false), specifies if the angle must be scaled