Struct LSystemBuilder 

pub struct LSystemBuilder { /* private fields */ }

Implementations

impl LSystemBuilder

pub fn new() -> Self

Examples found in repository

examples/cantor_set.rs (line 7)

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 token<S: Into<String>>(&mut self, name: S) -> ArenaId

Register a new token.

Returns a TokenId which can be used (in this LSystem) to refer to the registered token.

Examples found in repository

examples/cantor_set.rs (line 9)

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 transformation_rule( &mut self, predecessor: ArenaId, successor: Vec<ArenaId>, )

Register a new transformation rule in this LSystem.

If any of the provided TokenId are invalid, this function will panic.

Examples found in repository

examples/cantor_set.rs (line 13)

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 axiom(&mut self, axiom: Vec<ArenaId>)

Set the axiom for this LSystem.

Examples found in repository

examples/cantor_set.rs (line 12)

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 finish(self) -> LSystem

Consumes the builder, returning an LSystem instance.

This function will panic if you have not set an axiom before proceeding.

Examples found in repository

examples/cantor_set.rs (line 16)

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 LSystemBuilder

fn clone(&self) -> LSystemBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LSystemBuilder

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

Formats the value using the given formatter.

impl Default for LSystemBuilder

fn default() -> LSystemBuilder

Returns the “default value” for a type.