Struct LSystem 

pub struct LSystem { /* private fields */ }

An L-system.

Basic Usage

The suggested method for constructing an LSystem is to use a LSystemBuilder, as shown in our implementation of Lindenmayer’s system below.

use dcc_lsystem::LSystemBuilder;

let mut builder = LSystemBuilder::new();

// Set up our two tokens
let a = builder.token("A");
let b = builder.token("B");

// Set the axiom
builder.axiom(vec![a]);

// Set the transformation rules
builder.transformation_rule(a, vec![a, b]);
builder.transformation_rule(b, vec![a]);

// Build our L-system
let mut system = builder.finish();

Once the LSystem has been built, you can use the step() and step_by() methods to iterate the system.

use dcc_lsystem::LSystemBuilder;

let mut builder = LSystemBuilder::new();

/* <---- snip ----> */

let mut system = builder.finish();

// The initial state of our system
assert_eq!(system.render(), "A");

system.step();

assert_eq!(system.render(), "AB");

system.step();

assert_eq!(system.render(), "ABA");

system.step_by(5);

// The state after 7 iterations
assert_eq!(system.render(), "ABAABABAABAABABAABABAABAABABAABAAB");

Implementations

impl LSystem

pub fn new( arena: Arena<Token>, axiom: Vec<ArenaId>, rules_map: HashMap<ArenaId, Vec<ArenaId>>, ) -> Self

Create a new instance of LSystem. In general you should avoid using this and use an LSystemBuilder instead.

pub fn reset(&mut self)

Reset the system to its initial state.

Example

use dcc_lsystem::LSystemBuilder;

let mut builder = LSystemBuilder::new();

//  Create a simple L-System with one variable `A` and production rule `A -> AA`
let a = builder.token("A");
builder.axiom(vec![a]);
builder.transformation_rule(a, vec![a, a]);
let mut system = builder.finish();

// Do some work with the system
system.step_by(3);
assert_eq!(system.render(), "AAAAAAAA");

// Reset the system back to its axiom
system.reset();
assert_eq!(system.render(), "A");

pub fn step(&mut self)

Iterate the system a single step.

Examples found in repository

examples/cantor_set.rs (line 45)

fn main() {
    let mut builder = LSystemBuilder::new();

    let a = builder.token("A");
    let b = builder.token("B");

    builder.axiom(vec![a]);
    builder.transformation_rule(a, vec![a, b, a]);
    builder.transformation_rule(b, vec![b, b, b]);

    let mut system = builder.finish();

    // the total number of states (including the initial state!) to render
    let step_limit = 6;

    // At state number `step_limit`, our diagram has 3^(step_limit - 1) bars,
    // so we make the width of our image an integer multiple of this number.
    let width = 3_u32.pow(step_limit - 1) * 2;

    // the vertical spacing between each bar in the render
    let vertical_spacing = 5;

    let mut lines = Vec::new();

    for index in 0..step_limit {
        let state = system.get_state();
        let bar_width: u32 = width / state.len() as u32;

        let mut x: u32 = 0;
        let y = vertical_spacing * index;

        for token in state {
            if *token == a {
                // draw a line
                lines.push((x, y, x + bar_width, y));
            }
            x += bar_width;
        }

        system.step();
    }

    let padding: u32 = 5;
    let render_width = 2 * padding + width as u32;
    let render_height = 2 * padding + vertical_spacing * (step_limit - 1);

    let mut buffer = ImageBuffer::new(render_width, render_height);

    // Make the buffer entirely white
    fill_mut(&mut buffer, Rgb([255u8, 255u8, 255u8]));

    // Draw the lines
    for (x1, y1, x2, y2) in lines.into_iter() {
        for x in x1..=x2 {
            for y in y1..=y2 {
                let pixel = buffer.get_pixel_mut(x + padding, y + padding);
                *pixel = Rgb([0u8, 0u8, 0u8]);
            }
        }
    }

    buffer
        .save("cantor_set.png")
        .expect("Failed to save to cantor_set.png");
}

pub fn step_by(&mut self, n: usize)

Iterate the system by n steps.

Examples found in repository

examples/dragon_curve_data.rs (line 19)

fn main() {
    let mut builder = TurtleLSystemBuilder::new();

    builder
        .token("X", TurtleAction::Nothing)
        .token("Y", TurtleAction::Nothing)
        .token("F", TurtleAction::Forward(30))
        .token("+", TurtleAction::Rotate(-90))
        .token("-", TurtleAction::Rotate(90))
        .axiom("F X")
        .rule("X => X + Y F +")
        .rule("Y => - F X - Y");

    let (mut system, renderer) = builder.finish();
    system.step_by(15);

    let rv = renderer.render(&system, &DataRendererOptions::default());
    println!("Dragon curve builder generated {} lines", rv.len());
}

examples/koch_curve.rs (line 17)

fn main() {
    let mut builder = TurtleLSystemBuilder::new();

    builder
        .token("F", TurtleAction::Forward(30))
        .token("+", TurtleAction::Rotate(90))
        .token("-", TurtleAction::Rotate(-90))
        .axiom("F")
        .rule("F => F + F - F - F + F");

    let (mut system, renderer) = builder.finish();
    system.step_by(7);

    let options = ImageRendererOptionsBuilder::new()
        .padding(10)
        .thickness(4.0)
        .fill_color(Rgb([255u8, 255u8, 255u8]))
        .line_color(Rgb([0u8, 0u8, 100u8]))
        .build();

    renderer
        .render(&system, &options)
        .save("koch_curve.png")
        .expect("Failed to save koch_curve.png");
}

examples/koch_curve_video.rs (line 17)

fn main() {
    let mut builder = TurtleLSystemBuilder::new();

    builder
        .token("F", TurtleAction::Forward(30))
        .token("+", TurtleAction::Rotate(90))
        .token("-", TurtleAction::Rotate(-90))
        .axiom("F")
        .rule("F => F + F - F - F + F");

    let (mut system, renderer) = builder.finish();
    system.step_by(4);

    let options = VideoRendererOptionsBuilder::new()
        .filename("koch_curve.gif")
        .fps(20)
        .skip_by(5)
        .padding(10)
        .thickness(4.0)
        .fill_color(Rgb([255u8, 255u8, 255u8]))
        .line_color(Rgb([0u8, 0u8, 100u8]))
        .progress_bar(true)
        .build();

    renderer.render(&system, &options);
}

examples/sierpinski_arrowhead.rs (line 19)

fn main() {
    let mut builder = TurtleLSystemBuilder::new();

    builder
        .token("A", TurtleAction::Forward(200))
        .token("B", TurtleAction::Forward(200))
        .token("+", TurtleAction::Rotate(60))
        .token("-", TurtleAction::Rotate(-60))
        .axiom("A")
        .rule("A => B - A - B")
        .rule("B => A + B + A");

    let (mut system, renderer) = builder.finish();
    system.step_by(7);

    let options = ImageRendererOptionsBuilder::new()
        .padding(20)
        .thickness(15.0)
        .fill_color(Rgb([255u8, 255u8, 255u8]))
        .line_color(Rgb([0u8, 100u8, 0u8]))
        .build();

    renderer
        .render(&system, &options)
        .save("sierpinski_arrowhead.png")
        .expect("Failed to save to sierpinski_arrowhead.png");
}

examples/sierpinski_triangle.rs (line 19)

fn main() {
    let mut builder = TurtleLSystemBuilder::new();

    builder
        .token("F", TurtleAction::Forward(200))
        .token("G", TurtleAction::Forward(200))
        .token("+", TurtleAction::Rotate(120))
        .token("-", TurtleAction::Rotate(-120))
        .axiom("F - G - G")
        .rule("F => F - G + F + G - F")
        .rule("G => G G");

    let (mut system, renderer) = builder.finish();
    system.step_by(7);

    let options = ImageRendererOptionsBuilder::new()
        .padding(20)
        .thickness(8.0)
        .fill_color(Rgb([255u8, 255u8, 255u8]))
        .line_color(Rgb([0u8, 100u8, 0u8]))
        .build();

    renderer
        .render(&system, &options)
        .save("sierpinski_triangle.png")
        .expect("Failed to save to sierpinski_triangle.png");
}

examples/dragon_curve.rs (line 21)

fn main() {
    let mut builder = TurtleLSystemBuilder::new();

    builder
        .token("X", TurtleAction::Nothing)
        .token("Y", TurtleAction::Nothing)
        .token("F", TurtleAction::Forward(30))
        .token("+", TurtleAction::Rotate(-90))
        .token("-", TurtleAction::Rotate(90))
        .axiom("F X")
        .rule("X => X + Y F +")
        .rule("Y => - F X - Y");

    let (mut system, renderer) = builder.finish();
    system.step_by(15);

    let options = ImageRendererOptionsBuilder::new()
        .padding(10)
        .thickness(8.0)
        .fill_color(Rgb([255u8, 255u8, 255u8]))
        .line_color(Rgb([100u8, 0u8, 0u8]))
        .build();

    renderer
        .render(&system, &options)
        .save("dragon_curve.png")
        .expect("Failed to save to dragon_curve.png");
}

Additional examples can be found in:

• examples/fractal_binary_tree.rs
• examples/fractal_plant.rs
• examples/random_fractal_generator.rs

pub fn steps(&self) -> usize

Returns the number of iterations the system has undergone so far

pub fn render(&self) -> String

Returns the current state of the system as a String.

pub fn get_state(&self) -> &[ArenaId]

Returns the current state of the system.

Examples found in repository

examples/cantor_set.rs (line 31)

fn main() {
    let mut builder = LSystemBuilder::new();

    let a = builder.token("A");
    let b = builder.token("B");

    builder.axiom(vec![a]);
    builder.transformation_rule(a, vec![a, b, a]);
    builder.transformation_rule(b, vec![b, b, b]);

    let mut system = builder.finish();

    // the total number of states (including the initial state!) to render
    let step_limit = 6;

    // At state number `step_limit`, our diagram has 3^(step_limit - 1) bars,
    // so we make the width of our image an integer multiple of this number.
    let width = 3_u32.pow(step_limit - 1) * 2;

    // the vertical spacing between each bar in the render
    let vertical_spacing = 5;

    let mut lines = Vec::new();

    for index in 0..step_limit {
        let state = system.get_state();
        let bar_width: u32 = width / state.len() as u32;

        let mut x: u32 = 0;
        let y = vertical_spacing * index;

        for token in state {
            if *token == a {
                // draw a line
                lines.push((x, y, x + bar_width, y));
            }
            x += bar_width;
        }

        system.step();
    }

    let padding: u32 = 5;
    let render_width = 2 * padding + width as u32;
    let render_height = 2 * padding + vertical_spacing * (step_limit - 1);

    let mut buffer = ImageBuffer::new(render_width, render_height);

    // Make the buffer entirely white
    fill_mut(&mut buffer, Rgb([255u8, 255u8, 255u8]));

    // Draw the lines
    for (x1, y1, x2, y2) in lines.into_iter() {
        for x in x1..=x2 {
            for y in y1..=y2 {
                let pixel = buffer.get_pixel_mut(x + padding, y + padding);
                *pixel = Rgb([0u8, 0u8, 0u8]);
            }
        }
    }

    buffer
        .save("cantor_set.png")
        .expect("Failed to save to cantor_set.png");
}

Trait Implementations

impl Clone for LSystem

fn clone(&self) -> LSystem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LSystem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.