Struct Canvas 

pub struct Canvas { /* private fields */ }

Implementations

impl Canvas

pub fn new(width: u32, height: u32) -> Canvas

Creates a new Canvas of size width and height

Examples

use pixtra::canvas::Canvas;

let canvas = Canvas::new(20, 20);

For more examples look at examples (examples/create-image.rs)

Examples found in repository

examples/vertical-and-horizontal-chunks.rs (line 13)

fn main() {
    let canvas = Canvas::new(100, 100);

    // Let's color it.
    let canvas = canvas.filter(draw_filter);
    let counts = count_colors(&canvas);
    assert_eq!(counts.len(), 10);
    assert_eq!(counts.get(&Pixel::new(30, 0, 0, 255)), Some(&1000));
    assert_eq!(counts.get(&Pixel::new(0, 0, 0, 0)), None);

    let chunks = canvas.vertical_chunks(10);
    for (i, chunk) in chunks.iter().enumerate() {
        let counts = count_colors(&chunk);
        assert_eq!(counts.len(), 1, "We are testing chunk {}", i);
        assert_eq!(
            counts.contains_key(&Pixel::new(((i + 1) * 15) as u8, 0, 0, 255)),
            true,
            "We are testing chunk {}",
            i
        );
    }
}

examples/rotations.rs (line 12)

fn main() {
    let canvas = Canvas::new(100, 200);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-1.png")).unwrap();
    let canvas_old = canvas.clone();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-1.png")).unwrap();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let rotate_error = error(&canvas_old, &canvas);
    println!("ERROR: {}", rotate_error);

    let canvas = Canvas::new(200, 100);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-2.png")).unwrap();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-2.png")).unwrap();
}

examples/draw-on-flamingo.rs (line 24)

fn main() {
    println!("Starting");
    let foreground = Canvas::load(Path::new("assets/flamingos.png")).unwrap();
    let background = Canvas::load(Path::new("assets/flamingobg.jpg")).unwrap();

    let result = background.draw_subimage(0, 0, &foreground);

    let compare_image = Canvas::load(Path::new("assets/draw-on-example-result.png")).unwrap();
    let diff = diff_debug(&result, &compare_image);
    diff.save(Path::new("diff_debug_flamingo.out.png")).unwrap();

    result.save(Path::new("flamingo.out.png")).unwrap();

    let non_zero = diff.find_with_predicate(find_non_zero);
    let mut diff_two = Canvas::new(400, 400);
    for e in non_zero.iter() {
        println!("{:?}", e);
        diff_two.set_pixel_mut(e.coordinate.x, e.coordinate.y, &Colors::BLACK);
    }
    diff_two.save(Path::new("diff_two.png")).unwrap();
    println!("Count: {}", non_zero.len());
}

examples/create-image.rs (line 13)

fn main() {
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let mut canvas = Canvas::new(10, 10);

    canvas.set_pixel_mut(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);

    // We can do the same without the _mut modifier
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let canvas = Canvas::new(10, 10);

    // Here is the difference.
    // We discard the old canvas and use the new one which contains the new pixel
    let canvas = canvas.set_pixel(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);
}

pub fn new_with_data(width: u32, height: u32, data: Vec<Pixel>) -> Canvas

Creates a new Canvas of size width and height with initial data of data

pub fn dimensions(&self) -> Size

Retrieves width and height of canvas in a Size struct.

Examples found in repository

examples/advanced-filters.rs (line 22)

fn gaussian_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    // NOTE: The kernel needs to sum to 1.0. Below 1.0 your image will appear darker
    // and above 1.0 it will appear lighter.
    let kernel = vec![0.06, 0.13, 0.06, 0.13, 0.24, 0.13, 0.06, 0.13, 0.06];
    let coords = vec![
        (-1, -1),
        (0, -1),
        (1, -1),
        (-1, 0),
        (0, 0),
        (1, 0),
        (-1, 1),
        (0, 1),
        (1, 1),
    ];
    // For simplicity, we will leave out the edges of the picture.
    let canvas_size = canvas.dimensions();
    if x > 0 && y > 0 && x < canvas_size.width - 1 && y < canvas_size.height - 1 {
        let pixel = apply_filter(canvas, (x, y), &kernel, &coords);
        return pixel;
    }
    canvas.get_pixel(x, y)
}

fn lap_of_gaussian_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    // NOTE: The kernel needs to sum to 1.0. Below 1.0 your image will appear darker
    // and above 1.0 it will appear lighter.
    let kernel = vec![
        0, 1, 1, 2, 2, 2, 1, 1, 0,
        1, 2, 4, 5, 5, 5, 4, 2, 1,
        1, 4, 5, 3, 0, 3, 5, 4, 1,
        2, 5, 3, -12, -24, -12, 3, 5, 2,
        2, 5, 0, -24, -40, -24, 0, 5, 2,
        2, 5, 3, -12, -24, -12, 3, 5, 2,
        1, 4, 5, 3, 0, 3, 5, 4, 1,
        1, 2, 4, 5, 5, 5, 4, 2, 1,
        0, 1, 1, 2, 2, 2, 1, 1, 0];
    let kernel = kernel.iter().map(|&x| x as f32).collect();
    let mut coords = vec![];
    for y in -4..5 {
        for x in -4..5 {
            coords.push((x, y));
        }
    }
    // For simplicity, we will leave out the edges of the picture.
    let canvas_size = canvas.dimensions();
    if x > 3 && y > 3 && x < canvas_size.width - 4 && y < canvas_size.height - 4 {
        let pixel = apply_filter(canvas, (x, y), &kernel, &coords);
        return pixel;
    }
    canvas.get_pixel(x, y)
}

fn grey_scale_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    to_grey_lumiosity(&canvas.get_pixel(x, y))
}

fn black_or_white_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    let pixel = canvas.get_pixel(x, y);
    if pixel.r < 128 {
        Pixel::new(0, 0, 0, 255)
    } else {
        Pixel::new(255, 255, 255, 255)
    }
}



fn apply_filter(
    canvas: &Canvas,
    center: (u32, u32),
    kernel: &Vec<f32>,
    coords: &Vec<(i32, i32)>,
) -> Pixel {
    let scales = kernel
        .iter()
        .zip(coords.iter())
        .fold(Pixel::builder(), |acc, (scale, (x, y))| {
            let pixel =
                canvas.get_pixel((center.0 as i32 + *x) as u32, (center.1 as i32 + *y) as u32);
            acc + PixelBuilder::from(
                pixel.r as f32 * scale,
                pixel.g as f32 * scale,
                pixel.b as f32 * scale,
                pixel.a as f32,
            )
        });
    scales.build()
}

fn lap_edge_detection_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    // NOTE: The kernel (this vector) needs to sum to 1.0. Below 1.0 your image will appear darker
    // and above 1.0 it will appear lighter.
    let kernel = vec![0.5, 1.0, 0.5, 1.0, -6.0, 1.0, 0.5, 1.0, 0.5];
    let coords = vec![
        (-1, -1),
        (0, -1),
        (1, -1),
        (-1, 0),
        (0, 0),
        (1, 0),
        (-1, 1),
        (0, 1),
        (1, 1),
    ];
    // For simplicity, we will leave out the edges of the picture.
    let canvas_size = canvas.dimensions();
    if x > 0 && y > 0 && x < canvas_size.width - 1 && y < canvas_size.height - 1 {
        let pixel = apply_filter(canvas, (x, y), &kernel, &coords);
        return pixel;
    }
    canvas.get_pixel(x, y)
}

fn prewitt_edge_detection_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    let kernel_one: Vec<f32> = vec![1f32, 0f32, -1f32, 1f32, 0f32, -1f32, 1f32, 0f32, -1f32];
    let kernel_two: Vec<f32> = vec![1f32, 1f32, 1f32, 0f32, 0f32, 0f32, -1f32, -1f32, -1f32];
    let coords = vec![
        (-1, -1),
        (0, -1),
        (1, -1),
        (-1, 0),
        (0, 0),
        (1, 0),
        (-1, 1),
        (0, 1),
        (1, 1),
    ];

    let canvas_size = canvas.dimensions();
    if x > 0 && y > 0 && x < canvas_size.width - 1 && y < canvas_size.height - 1 {
        let pixel_one = apply_filter(canvas, (x, y), &kernel_one, &coords);
        let pixel_two = apply_filter(canvas, (x, y), &kernel_two, &coords);

        let pixel = PixelBuilder::from(
            ((pixel_one.r as u32 * pixel_one.r as u32 + pixel_two.r as u32 * pixel_two.r as u32)
                as f64)
                .sqrt() as f32,
            ((pixel_one.g as u32 * pixel_one.g as u32 + pixel_two.g as u32 * pixel_two.g as u32)
                as f64)
                .sqrt() as f32,
            ((pixel_one.b as u32 * pixel_one.b as u32 + pixel_two.b as u32 * pixel_two.b as u32)
                as f64)
                .sqrt() as f32,
            255f32,
        );
        return pixel.build();
    }
    canvas.get_pixel(x, y)
}

examples/filling.rs (line 23)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

examples/count-and-replace.rs (line 14)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn pixels(&self) -> Iter<'_, Pixel>

Returns an iterator for all the pixels in the Canvas.

pub fn new_with_background(width: u32, height: u32, color: Pixel) -> Canvas

Creates a new Canvas of size width and height with all pixels initially set to color.

Examples found in repository

examples/filling.rs (line 16)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

pub fn save(&self, filename: &Path) -> Result<(), ImageError>

Saves the canvas as an image at the path given by filename

Examples found in repository

examples/flipping-and-flopping.rs (line 10)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();

    let flipped = canvas.flip();
    let double_flipped = flipped.flip();

    let _ = flipped.save(Path::new("flipped.png")).unwrap();
    let _ = double_flipped
        .save(Path::new("double_flipped.png"))
        .unwrap();

    let flopped = canvas.flop();
    let double_flopped = flopped.flop();

    let _ = flopped.save(Path::new("flopped.png")).unwrap();
    let _ = double_flopped
        .save(Path::new("double_flopped.png"))
        .unwrap();
}

examples/rotations.rs (line 14)

fn main() {
    let canvas = Canvas::new(100, 200);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-1.png")).unwrap();
    let canvas_old = canvas.clone();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-1.png")).unwrap();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let rotate_error = error(&canvas_old, &canvas);
    println!("ERROR: {}", rotate_error);

    let canvas = Canvas::new(200, 100);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-2.png")).unwrap();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-2.png")).unwrap();
}

examples/simple-filters.rs (line 40)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();
    let filtered_canvas = canvas.filter(unit_filter);
    let inverse_canvas = canvas.filter(inverse_filter);
    let inverse_inverse_canvas = inverse_canvas.filter(inverse_filter);

    assert_eq!(canvas, inverse_inverse_canvas);
    assert_ne!(canvas, inverse_canvas);
    println!(
        "Normal and double inversed canvas are equal: {}",
        canvas == inverse_inverse_canvas
    );
    println!(
        "Normal and single inversed canvas are equal: {}",
        canvas == inverse_canvas
    );

    let _ = filtered_canvas
        .save(Path::new("filtered_canvas.png"))
        .unwrap();
    let _ = inverse_canvas
        .save(Path::new("inverse_canvas.png"))
        .unwrap();
}

examples/draw-on-flamingo.rs (line 19)

fn main() {
    println!("Starting");
    let foreground = Canvas::load(Path::new("assets/flamingos.png")).unwrap();
    let background = Canvas::load(Path::new("assets/flamingobg.jpg")).unwrap();

    let result = background.draw_subimage(0, 0, &foreground);

    let compare_image = Canvas::load(Path::new("assets/draw-on-example-result.png")).unwrap();
    let diff = diff_debug(&result, &compare_image);
    diff.save(Path::new("diff_debug_flamingo.out.png")).unwrap();

    result.save(Path::new("flamingo.out.png")).unwrap();

    let non_zero = diff.find_with_predicate(find_non_zero);
    let mut diff_two = Canvas::new(400, 400);
    for e in non_zero.iter() {
        println!("{:?}", e);
        diff_two.set_pixel_mut(e.coordinate.x, e.coordinate.y, &Colors::BLACK);
    }
    diff_two.save(Path::new("diff_two.png")).unwrap();
    println!("Count: {}", non_zero.len());
}

examples/filling.rs (line 20)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

examples/count-and-replace.rs (line 20)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

Additional examples can be found in:

• examples/advanced-filters.rs

pub fn load(filename: &Path) -> Result<Canvas, ImageError>

Loads the image at the path given by filename and returns it as a canvas

Examples found in repository

examples/flipping-and-flopping.rs (line 5)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();

    let flipped = canvas.flip();
    let double_flipped = flipped.flip();

    let _ = flipped.save(Path::new("flipped.png")).unwrap();
    let _ = double_flipped
        .save(Path::new("double_flipped.png"))
        .unwrap();

    let flopped = canvas.flop();
    let double_flopped = flopped.flop();

    let _ = flopped.save(Path::new("flopped.png")).unwrap();
    let _ = double_flopped
        .save(Path::new("double_flopped.png"))
        .unwrap();
}

examples/simple-filters.rs (line 23)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();
    let filtered_canvas = canvas.filter(unit_filter);
    let inverse_canvas = canvas.filter(inverse_filter);
    let inverse_inverse_canvas = inverse_canvas.filter(inverse_filter);

    assert_eq!(canvas, inverse_inverse_canvas);
    assert_ne!(canvas, inverse_canvas);
    println!(
        "Normal and double inversed canvas are equal: {}",
        canvas == inverse_inverse_canvas
    );
    println!(
        "Normal and single inversed canvas are equal: {}",
        canvas == inverse_canvas
    );

    let _ = filtered_canvas
        .save(Path::new("filtered_canvas.png"))
        .unwrap();
    let _ = inverse_canvas
        .save(Path::new("inverse_canvas.png"))
        .unwrap();
}

examples/draw-on-flamingo.rs (line 12)

fn main() {
    println!("Starting");
    let foreground = Canvas::load(Path::new("assets/flamingos.png")).unwrap();
    let background = Canvas::load(Path::new("assets/flamingobg.jpg")).unwrap();

    let result = background.draw_subimage(0, 0, &foreground);

    let compare_image = Canvas::load(Path::new("assets/draw-on-example-result.png")).unwrap();
    let diff = diff_debug(&result, &compare_image);
    diff.save(Path::new("diff_debug_flamingo.out.png")).unwrap();

    result.save(Path::new("flamingo.out.png")).unwrap();

    let non_zero = diff.find_with_predicate(find_non_zero);
    let mut diff_two = Canvas::new(400, 400);
    for e in non_zero.iter() {
        println!("{:?}", e);
        diff_two.set_pixel_mut(e.coordinate.x, e.coordinate.y, &Colors::BLACK);
    }
    diff_two.save(Path::new("diff_two.png")).unwrap();
    println!("Count: {}", non_zero.len());
}

examples/find-islands.rs (line 8)

fn main() {
    let canvas = Canvas::load(Path::new("assets/small_green_islands.png")).unwrap();
    let count = count_colors(&canvas);
    for (key, value) in count.iter() {
        println!("{}: {}", key, value);
    }
    let islands = canvas.find_islands(&Colors::GREEN);
    println!("Size of islands: {}", islands.len());
    for (i, island) in islands.iter().enumerate() {
        println!("Island {} has {} points", i + 1, island.points.len());
    }
    let count = count_colors(&canvas);
    for (key, value) in count.iter() {
        println!("{}: {}", key, value);
    }
    let color_one = canvas.get_pixel(islands[0].points[0].x, islands[0].points[0].y);
    let color_two = canvas.get_pixel(islands[1].points[0].x, islands[1].points[0].y);
    println!("Color from island one: {}", color_one);
    println!("Color from island one: {}", color_two);
    let mut hashmap = HashMap::new();
    for c in islands[0].points.iter() {
        hashmap.insert(c, "");
    }
    println!("Island 1 hashmap: {}", hashmap.len());
    let mut hashmap = HashMap::new();
    for c in islands[1].points.iter() {
        hashmap.insert(c, "");
    }
    println!("Island 2 hashmap: {}", hashmap.len());


}

examples/filling.rs (line 22)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

examples/count-and-replace.rs (line 13)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

Additional examples can be found in:

• examples/advanced-filters.rs

pub fn count_pixels(&self, pixel: &Pixel) -> u32

Counts the amount of pixels in the canvas equal to pixel

Examples found in repository

examples/count-and-replace.rs (line 16)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn count_pixels_with_distance(&self, pixel: &Pixel, distance: f32) -> u32

Counts the amount of pixels in the canvas that are within the distance of distance of pixel

Examples found in repository

examples/count-and-replace.rs (line 25)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn replace_pixel_with_distance( self, find_pixel: &Pixel, distance: f32, replace_pixel: &Pixel, ) -> Canvas

Replaces all pixels in the canvas that are within the distance of distance of pixel

Examples found in repository

examples/count-and-replace.rs (line 32)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn replace_pixel_with_distance_mut( &mut self, find_pixel: &Pixel, distance: f32, replace_pixel: &Pixel, )

Replaces all pixels in the canvas that are within the distance of distance of pixel

pub fn replace_pixel_with( self, find_pixel: &Pixel, replace_pixel: &Pixel, ) -> Canvas

Replaces all pixels in the canvas that are equal to pixel

Examples found in repository

examples/count-and-replace.rs (line 19)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn replace_pixel_with_mut( &mut self, find_pixel: &Pixel, replace_pixel: &Pixel, )

Replaces all pixels in the canvas that are equal to pixel

pub fn get_subimage(&self, x: u32, y: u32, width: u32, height: u32) -> Canvas

Returns a canvas that is subimage starting at (x, y) with size width x height.

Examples found in repository

examples/count-and-replace.rs (line 46)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn resize(self, x: u32, y: u32) -> Canvas

pub fn resize_mut(&mut self, x: u32, y: u32)

pub fn rotate90_mut(&mut self)

pub fn rotate180_mut(&mut self)

pub fn rotate270_mut(&mut self)

pub fn rotate90(self) -> Canvas

Examples found in repository

examples/rotations.rs (line 16)

fn main() {
    let canvas = Canvas::new(100, 200);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-1.png")).unwrap();
    let canvas_old = canvas.clone();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-1.png")).unwrap();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let rotate_error = error(&canvas_old, &canvas);
    println!("ERROR: {}", rotate_error);

    let canvas = Canvas::new(200, 100);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-2.png")).unwrap();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-2.png")).unwrap();
}

examples/filling.rs (line 22)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

pub fn rotate180(self) -> Canvas

pub fn rotate270(self) -> Canvas

pub fn vertical_chunks(&self, size_of_chunk: u32) -> Vec<Canvas>

Examples found in repository

examples/vertical-and-horizontal-chunks.rs (line 22)

fn main() {
    let canvas = Canvas::new(100, 100);

    // Let's color it.
    let canvas = canvas.filter(draw_filter);
    let counts = count_colors(&canvas);
    assert_eq!(counts.len(), 10);
    assert_eq!(counts.get(&Pixel::new(30, 0, 0, 255)), Some(&1000));
    assert_eq!(counts.get(&Pixel::new(0, 0, 0, 0)), None);

    let chunks = canvas.vertical_chunks(10);
    for (i, chunk) in chunks.iter().enumerate() {
        let counts = count_colors(&chunk);
        assert_eq!(counts.len(), 1, "We are testing chunk {}", i);
        assert_eq!(
            counts.contains_key(&Pixel::new(((i + 1) * 15) as u8, 0, 0, 255)),
            true,
            "We are testing chunk {}",
            i
        );
    }
}

pub fn horizontal_chunks(&self, size_of_chunk: u32) -> Vec<Canvas>

pub fn iter(&self) -> impl Iterator<Item = Pixel> + '_

pub fn iter_with_coordinates( &self, ) -> impl Iterator<Item = PixelWithCoordinate> + '_

pub fn draw_subimage_mut(&mut self, x: u32, y: u32, canvas: &Canvas)

Draws canvas canvas as a subimage at (x, y)

pub fn set_subimage_mut(&mut self, x: u32, y: u32, canvas: &Canvas)

Inserts canvas canvas as a subimage at (x, y)

pub fn trace( self, island: &Island, left: u32, right: u32, up: u32, down: u32, ) -> Canvas

pub fn trace_mut( &mut self, island: &Island, left: u32, right: u32, up: u32, down: u32, )

pub fn draw_island(self, island: &Island, color: &Pixel) -> Canvas

pub fn draw_island_mut(&mut self, island: &Island, color: &Pixel)

pub fn draw_subimage(self, x: u32, y: u32, canvas: &Canvas) -> Canvas

Draws canvas canvas as a subimage at (x, y)

Examples found in repository

examples/draw-on-flamingo.rs (line 15)

fn main() {
    println!("Starting");
    let foreground = Canvas::load(Path::new("assets/flamingos.png")).unwrap();
    let background = Canvas::load(Path::new("assets/flamingobg.jpg")).unwrap();

    let result = background.draw_subimage(0, 0, &foreground);

    let compare_image = Canvas::load(Path::new("assets/draw-on-example-result.png")).unwrap();
    let diff = diff_debug(&result, &compare_image);
    diff.save(Path::new("diff_debug_flamingo.out.png")).unwrap();

    result.save(Path::new("flamingo.out.png")).unwrap();

    let non_zero = diff.find_with_predicate(find_non_zero);
    let mut diff_two = Canvas::new(400, 400);
    for e in non_zero.iter() {
        println!("{:?}", e);
        diff_two.set_pixel_mut(e.coordinate.x, e.coordinate.y, &Colors::BLACK);
    }
    diff_two.save(Path::new("diff_two.png")).unwrap();
    println!("Count: {}", non_zero.len());
}

pub fn set_subimage(self, x: u32, y: u32, canvas: &Canvas) -> Canvas

Inserts canvas canvas as a subimage at (x, y)

Examples found in repository

examples/count-and-replace.rs (line 48)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn get_pixel(&self, x: u32, y: u32) -> Pixel

Returns pixel at position (x, y) from the canvas

Examples found in repository

examples/simple-filters.rs (line 15)

fn unit_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    canvas.get_pixel(x, y)
}

fn inverse_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    inverse(canvas.get_pixel(x, y))
}

examples/advanced-filters.rs (line 27)

fn gaussian_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    // NOTE: The kernel needs to sum to 1.0. Below 1.0 your image will appear darker
    // and above 1.0 it will appear lighter.
    let kernel = vec![0.06, 0.13, 0.06, 0.13, 0.24, 0.13, 0.06, 0.13, 0.06];
    let coords = vec![
        (-1, -1),
        (0, -1),
        (1, -1),
        (-1, 0),
        (0, 0),
        (1, 0),
        (-1, 1),
        (0, 1),
        (1, 1),
    ];
    // For simplicity, we will leave out the edges of the picture.
    let canvas_size = canvas.dimensions();
    if x > 0 && y > 0 && x < canvas_size.width - 1 && y < canvas_size.height - 1 {
        let pixel = apply_filter(canvas, (x, y), &kernel, &coords);
        return pixel;
    }
    canvas.get_pixel(x, y)
}

fn lap_of_gaussian_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    // NOTE: The kernel needs to sum to 1.0. Below 1.0 your image will appear darker
    // and above 1.0 it will appear lighter.
    let kernel = vec![
        0, 1, 1, 2, 2, 2, 1, 1, 0,
        1, 2, 4, 5, 5, 5, 4, 2, 1,
        1, 4, 5, 3, 0, 3, 5, 4, 1,
        2, 5, 3, -12, -24, -12, 3, 5, 2,
        2, 5, 0, -24, -40, -24, 0, 5, 2,
        2, 5, 3, -12, -24, -12, 3, 5, 2,
        1, 4, 5, 3, 0, 3, 5, 4, 1,
        1, 2, 4, 5, 5, 5, 4, 2, 1,
        0, 1, 1, 2, 2, 2, 1, 1, 0];
    let kernel = kernel.iter().map(|&x| x as f32).collect();
    let mut coords = vec![];
    for y in -4..5 {
        for x in -4..5 {
            coords.push((x, y));
        }
    }
    // For simplicity, we will leave out the edges of the picture.
    let canvas_size = canvas.dimensions();
    if x > 3 && y > 3 && x < canvas_size.width - 4 && y < canvas_size.height - 4 {
        let pixel = apply_filter(canvas, (x, y), &kernel, &coords);
        return pixel;
    }
    canvas.get_pixel(x, y)
}

fn grey_scale_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    to_grey_lumiosity(&canvas.get_pixel(x, y))
}

fn black_or_white_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    let pixel = canvas.get_pixel(x, y);
    if pixel.r < 128 {
        Pixel::new(0, 0, 0, 255)
    } else {
        Pixel::new(255, 255, 255, 255)
    }
}



fn apply_filter(
    canvas: &Canvas,
    center: (u32, u32),
    kernel: &Vec<f32>,
    coords: &Vec<(i32, i32)>,
) -> Pixel {
    let scales = kernel
        .iter()
        .zip(coords.iter())
        .fold(Pixel::builder(), |acc, (scale, (x, y))| {
            let pixel =
                canvas.get_pixel((center.0 as i32 + *x) as u32, (center.1 as i32 + *y) as u32);
            acc + PixelBuilder::from(
                pixel.r as f32 * scale,
                pixel.g as f32 * scale,
                pixel.b as f32 * scale,
                pixel.a as f32,
            )
        });
    scales.build()
}

fn lap_edge_detection_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    // NOTE: The kernel (this vector) needs to sum to 1.0. Below 1.0 your image will appear darker
    // and above 1.0 it will appear lighter.
    let kernel = vec![0.5, 1.0, 0.5, 1.0, -6.0, 1.0, 0.5, 1.0, 0.5];
    let coords = vec![
        (-1, -1),
        (0, -1),
        (1, -1),
        (-1, 0),
        (0, 0),
        (1, 0),
        (-1, 1),
        (0, 1),
        (1, 1),
    ];
    // For simplicity, we will leave out the edges of the picture.
    let canvas_size = canvas.dimensions();
    if x > 0 && y > 0 && x < canvas_size.width - 1 && y < canvas_size.height - 1 {
        let pixel = apply_filter(canvas, (x, y), &kernel, &coords);
        return pixel;
    }
    canvas.get_pixel(x, y)
}

fn prewitt_edge_detection_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    let kernel_one: Vec<f32> = vec![1f32, 0f32, -1f32, 1f32, 0f32, -1f32, 1f32, 0f32, -1f32];
    let kernel_two: Vec<f32> = vec![1f32, 1f32, 1f32, 0f32, 0f32, 0f32, -1f32, -1f32, -1f32];
    let coords = vec![
        (-1, -1),
        (0, -1),
        (1, -1),
        (-1, 0),
        (0, 0),
        (1, 0),
        (-1, 1),
        (0, 1),
        (1, 1),
    ];

    let canvas_size = canvas.dimensions();
    if x > 0 && y > 0 && x < canvas_size.width - 1 && y < canvas_size.height - 1 {
        let pixel_one = apply_filter(canvas, (x, y), &kernel_one, &coords);
        let pixel_two = apply_filter(canvas, (x, y), &kernel_two, &coords);

        let pixel = PixelBuilder::from(
            ((pixel_one.r as u32 * pixel_one.r as u32 + pixel_two.r as u32 * pixel_two.r as u32)
                as f64)
                .sqrt() as f32,
            ((pixel_one.g as u32 * pixel_one.g as u32 + pixel_two.g as u32 * pixel_two.g as u32)
                as f64)
                .sqrt() as f32,
            ((pixel_one.b as u32 * pixel_one.b as u32 + pixel_two.b as u32 * pixel_two.b as u32)
                as f64)
                .sqrt() as f32,
            255f32,
        );
        return pixel.build();
    }
    canvas.get_pixel(x, y)
}

fn inverse(pixel: Pixel) -> Pixel {
    Pixel {
        r: u8::max_value() - pixel.r,
        g: u8::max_value() - pixel.g,
        b: u8::max_value() - pixel.b,
        a: pixel.a,
    }
}

fn inverse_filter(canvas: &Canvas, x: u32, y: u32) -> Pixel {
    inverse(canvas.get_pixel(x, y))
}

examples/create-image.rs (line 17)

fn main() {
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let mut canvas = Canvas::new(10, 10);

    canvas.set_pixel_mut(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);

    // We can do the same without the _mut modifier
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let canvas = Canvas::new(10, 10);

    // Here is the difference.
    // We discard the old canvas and use the new one which contains the new pixel
    let canvas = canvas.set_pixel(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);
}

examples/find-islands.rs (line 22)

fn main() {
    let canvas = Canvas::load(Path::new("assets/small_green_islands.png")).unwrap();
    let count = count_colors(&canvas);
    for (key, value) in count.iter() {
        println!("{}: {}", key, value);
    }
    let islands = canvas.find_islands(&Colors::GREEN);
    println!("Size of islands: {}", islands.len());
    for (i, island) in islands.iter().enumerate() {
        println!("Island {} has {} points", i + 1, island.points.len());
    }
    let count = count_colors(&canvas);
    for (key, value) in count.iter() {
        println!("{}: {}", key, value);
    }
    let color_one = canvas.get_pixel(islands[0].points[0].x, islands[0].points[0].y);
    let color_two = canvas.get_pixel(islands[1].points[0].x, islands[1].points[0].y);
    println!("Color from island one: {}", color_one);
    println!("Color from island one: {}", color_two);
    let mut hashmap = HashMap::new();
    for c in islands[0].points.iter() {
        hashmap.insert(c, "");
    }
    println!("Island 1 hashmap: {}", hashmap.len());
    let mut hashmap = HashMap::new();
    for c in islands[1].points.iter() {
        hashmap.insert(c, "");
    }
    println!("Island 2 hashmap: {}", hashmap.len());


}

examples/count-and-replace.rs (line 15)

fn main() {
    let color = Pixel {
        r: 192,
        g: 192,
        b: 192,
        a: 255,
    };

    let canvas = Canvas::load(Path::new("assets/mario-yellow.png")).unwrap();
    let canvas_size = canvas.dimensions();
    let find_pixel = canvas.get_pixel(canvas_size.width / 2, canvas_size.height / 2);
    let pixel_count = canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let gray_canvas = canvas.clone().replace_pixel_with(&find_pixel, &color);
    gray_canvas.save(Path::new("mario-gray.png")).unwrap();
    let pixel_count = gray_canvas.count_pixels(&find_pixel);
    println!("We found {} pixels with color {}", pixel_count, find_pixel);

    let distance = 10.0;
    let pixel_count = canvas.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );
    let gray_canvas_two = canvas
        .clone()
        .replace_pixel_with_distance(&find_pixel, distance, &color);

    let pixel_count = gray_canvas_two.count_pixels_with_distance(&find_pixel, distance);
    println!(
        "We found {} pixels within {} distance of color {}",
        pixel_count, distance, find_pixel
    );

    gray_canvas_two
        .save(Path::new("mario-gray-two.png"))
        .unwrap();

    let canvas_size = canvas.dimensions();
    let position = (canvas_size.width / 2 - 100, canvas_size.height / 2 - 100);
    let sub_image = canvas.get_subimage(position.0, position.1, 200, 200);
    let sub_image = sub_image.replace_pixel_with(&find_pixel, &color);
    let canvas = canvas.set_subimage(position.0, position.1, &sub_image);
    canvas.save(Path::new("mario-gray-subimage.png")).unwrap();
}

pub fn set_pixel(self, x: u32, y: u32, pixel: &Pixel) -> Canvas

Sets pixel at position (x, y) to pixel

Examples found in repository

examples/create-image.rs (line 35)

fn main() {
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let mut canvas = Canvas::new(10, 10);

    canvas.set_pixel_mut(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);

    // We can do the same without the _mut modifier
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let canvas = Canvas::new(10, 10);

    // Here is the difference.
    // We discard the old canvas and use the new one which contains the new pixel
    let canvas = canvas.set_pixel(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);
}

pub fn set_pixel_mut(&mut self, x: u32, y: u32, pixel: &Pixel)

Mutable sets pixel at position (x, y) to pixel

Examples found in repository

examples/draw-on-flamingo.rs (line 27)

fn main() {
    println!("Starting");
    let foreground = Canvas::load(Path::new("assets/flamingos.png")).unwrap();
    let background = Canvas::load(Path::new("assets/flamingobg.jpg")).unwrap();

    let result = background.draw_subimage(0, 0, &foreground);

    let compare_image = Canvas::load(Path::new("assets/draw-on-example-result.png")).unwrap();
    let diff = diff_debug(&result, &compare_image);
    diff.save(Path::new("diff_debug_flamingo.out.png")).unwrap();

    result.save(Path::new("flamingo.out.png")).unwrap();

    let non_zero = diff.find_with_predicate(find_non_zero);
    let mut diff_two = Canvas::new(400, 400);
    for e in non_zero.iter() {
        println!("{:?}", e);
        diff_two.set_pixel_mut(e.coordinate.x, e.coordinate.y, &Colors::BLACK);
    }
    diff_two.save(Path::new("diff_two.png")).unwrap();
    println!("Count: {}", non_zero.len());
}

examples/create-image.rs (line 15)

fn main() {
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let mut canvas = Canvas::new(10, 10);

    canvas.set_pixel_mut(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);

    // We can do the same without the _mut modifier
    let color = Pixel {
        r: 255,
        g: 255,
        b: 0,
        a: 255,
    };

    // Creates new blank canvas. Blank is white.
    let canvas = Canvas::new(10, 10);

    // Here is the difference.
    // We discard the old canvas and use the new one which contains the new pixel
    let canvas = canvas.set_pixel(5, 5, &color);

    let pixel = canvas.get_pixel(5, 5);

    assert_eq!(color, pixel);
    println!("We found color {} and we expected color {}", pixel, color);
}

pub fn set_pixel_mut_signed(&mut self, x: i64, y: i64, pixel: &Pixel)

Mutable sets pixel at position (x, y) to pixel if x: i64 and y: i64 is within image bounds

pub fn to_grey(&self) -> Canvas

Turns the entire canvas grayscale.

pub fn to_grey_mut(&mut self)

Turns the entire canvas grayscale.

pub fn draw_square_mut(&mut self, x: u32, y: u32, w: u32, h: u32, color: &Pixel)

Draws a square on the canvas. Draws at position (x, y) with size width x height. Color is color.

pub fn draw_square( self, x: u32, y: u32, w: u32, h: u32, color: &Pixel, ) -> Canvas

Draws a square on the canvas. Draws at position (x, y) with size width x height. Color is color.

Examples found in repository

examples/filling.rs (line 17)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

pub fn find_islands(&self, island_color: &Pixel) -> Vec<Island>

Examples found in repository

examples/find-islands.rs (line 13)

fn main() {
    let canvas = Canvas::load(Path::new("assets/small_green_islands.png")).unwrap();
    let count = count_colors(&canvas);
    for (key, value) in count.iter() {
        println!("{}: {}", key, value);
    }
    let islands = canvas.find_islands(&Colors::GREEN);
    println!("Size of islands: {}", islands.len());
    for (i, island) in islands.iter().enumerate() {
        println!("Island {} has {} points", i + 1, island.points.len());
    }
    let count = count_colors(&canvas);
    for (key, value) in count.iter() {
        println!("{}: {}", key, value);
    }
    let color_one = canvas.get_pixel(islands[0].points[0].x, islands[0].points[0].y);
    let color_two = canvas.get_pixel(islands[1].points[0].x, islands[1].points[0].y);
    println!("Color from island one: {}", color_one);
    println!("Color from island one: {}", color_two);
    let mut hashmap = HashMap::new();
    for c in islands[0].points.iter() {
        hashmap.insert(c, "");
    }
    println!("Island 1 hashmap: {}", hashmap.len());
    let mut hashmap = HashMap::new();
    for c in islands[1].points.iter() {
        hashmap.insert(c, "");
    }
    println!("Island 2 hashmap: {}", hashmap.len());


}

examples/advanced-filters.rs (line 213)

fn main() {
    // Gaussian blur
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();
    let test_image = Canvas::load(Path::new("assets/IMG_0771.JPG")).unwrap();
    let gaussian_canvas = canvas.filter(gaussian_filter);
    let _ = gaussian_canvas
        .save(Path::new("gaussian_canvas.png"))
        .unwrap();
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let _ = gaussian_canvas
        .save(Path::new("very_gaussian_canvas.png"))
        .unwrap();

    // Chaining filters
    let inverse_gaussian_canvas = canvas.filter(inverse_filter).filter(gaussian_filter);
    let _ = inverse_gaussian_canvas
        .save(Path::new("inverse_gaussian_canvas.png"))
        .unwrap();

    let lap_edge_detection_canvas = canvas.filter(lap_edge_detection_filter);
    let _ = lap_edge_detection_canvas
        .save(Path::new("lap_edge_detection_filter.png"))
        .unwrap();

    let prewitt_edge_detection_canvas = canvas.filter(prewitt_edge_detection_filter);
    let _ = prewitt_edge_detection_canvas
        .save(Path::new("prewitt_edge_detection_filter.png"))
        .unwrap();

    let lap_of_gaussian_filter_canvas = test_image.filter(grey_scale_filter).filter(lap_of_gaussian_filter);
    //let counted_colors = count_colors(&lap_of_gaussian_filter_canvas);
    //println!("{}", counted_colors_to_html(&counted_colors));
    let _ = lap_of_gaussian_filter_canvas
        .save(Path::new("lap_of_gaussian_edge_detection_filter.png"))
        .unwrap();
    let filtered_canvas = lap_of_gaussian_filter_canvas.filter(black_or_white_filter);
    let _ = filtered_canvas
        .save(Path::new("filtered_canvas.png"))
        .unwrap();

    let islands = filtered_canvas.find_islands(&Pixel::new(255, 255, 255, 255));
    let islands_with_size: Vec<Island> = islands.iter().filter(|x| x.points.len() > 40000).map(|x| x.clone()).collect();
    // TODO: Now we have the outline of the islands. 
    // Copy the islands a blank canvas.
    // Fill from the outside
    // Now you have the entire form of all the islands
    // Transfer the pixels that were not filled from the outside
    //
    //
    // TODO: NEW IDEA AS WELL: Create a 'fattener'. Paints a 2x2, 3x3, 4x4, ... etc around each
    // pixel. This way you can expand outwards





}

pub fn fill_by_distance( self, x: u32, y: u32, fill_color: &Pixel, distance: f32, ) -> Canvas

pub fn fill_by_color_and_distance( self, x: u32, y: u32, fill_color: &Pixel, color: &Pixel, distance: f32, ) -> Canvas

pub fn fill(self, x: u32, y: u32, fill_color: &Pixel) -> Canvas

Examples found in repository

examples/filling.rs (line 19)

fn main() {
    let color = Pixel {
        r: 0,
        g: 0,
        b: 255,
        a: 255,
    };

    let new_color = Pixel::new(255, 0, 0, 255);

    let canvas = Canvas::new_with_background(100, 100, color.clone())
        .draw_square(10, 10, 80, 80, &new_color)
        .draw_square(20, 20, 60, 60, &color)
        .fill(1, 1, &Pixel::new(172, 172, 172, 255));
    canvas.save(Path::new("testing.png")).unwrap();

    let canvas = Canvas::load(Path::new("assets/20230709_111142.jpg")).unwrap().rotate90();
    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    /*let subcanvas = canvas.get_subimage(1600, 50, 1400, 400);
    let (center, distance) = utility::find_center_and_size(&subcanvas);
    println!("center and distance = {center} and {distance}");
    let canvas = canvas.fill_by_color_and_distance(1600, 50, &Pixel::new(0,0,0,0), &center, 100.0);

    println!("Size of canvas: {} x {}", canvas.dimensions().width, canvas.dimensions().height);
    canvas.save(Path::new("testing-fill-by-center-and-distance.png")).unwrap();*/

    /*for i in (30..90).step_by(1) {
        let current_canvas = canvas.clone();
        let name = format!("output_liv/distance_{i}.png");
        let current = current_canvas.fill_by_distance(1500, 20, &Pixel::new(0,0,0,0), i as f32);
        current.save(Path::new(&name)).unwrap();
        println!("Number {i} done");
    }*/
}

pub fn filter(&self, filter: fn(&Canvas, u32, u32) -> Pixel) -> Canvas

Applies filter to entire canvas. filter is a function that takes a reference to the canvas and position (x, y) and returns the color which should be set at that position.

Examples found in repository

examples/vertical-and-horizontal-chunks.rs (line 16)

fn main() {
    let canvas = Canvas::new(100, 100);

    // Let's color it.
    let canvas = canvas.filter(draw_filter);
    let counts = count_colors(&canvas);
    assert_eq!(counts.len(), 10);
    assert_eq!(counts.get(&Pixel::new(30, 0, 0, 255)), Some(&1000));
    assert_eq!(counts.get(&Pixel::new(0, 0, 0, 0)), None);

    let chunks = canvas.vertical_chunks(10);
    for (i, chunk) in chunks.iter().enumerate() {
        let counts = count_colors(&chunk);
        assert_eq!(counts.len(), 1, "We are testing chunk {}", i);
        assert_eq!(
            counts.contains_key(&Pixel::new(((i + 1) * 15) as u8, 0, 0, 255)),
            true,
            "We are testing chunk {}",
            i
        );
    }
}

examples/rotations.rs (line 13)

fn main() {
    let canvas = Canvas::new(100, 200);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-1.png")).unwrap();
    let canvas_old = canvas.clone();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-1.png")).unwrap();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let canvas = canvas.rotate90();
    let rotate_error = error(&canvas_old, &canvas);
    println!("ERROR: {}", rotate_error);

    let canvas = Canvas::new(200, 100);
    let canvas = canvas.filter(draw_filter);
    canvas.save(Path::new("rotation-before-2.png")).unwrap();
    let canvas = canvas.rotate90();
    canvas.save(Path::new("rotation-after-2.png")).unwrap();
}

examples/simple-filters.rs (line 24)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();
    let filtered_canvas = canvas.filter(unit_filter);
    let inverse_canvas = canvas.filter(inverse_filter);
    let inverse_inverse_canvas = inverse_canvas.filter(inverse_filter);

    assert_eq!(canvas, inverse_inverse_canvas);
    assert_ne!(canvas, inverse_canvas);
    println!(
        "Normal and double inversed canvas are equal: {}",
        canvas == inverse_inverse_canvas
    );
    println!(
        "Normal and single inversed canvas are equal: {}",
        canvas == inverse_canvas
    );

    let _ = filtered_canvas
        .save(Path::new("filtered_canvas.png"))
        .unwrap();
    let _ = inverse_canvas
        .save(Path::new("inverse_canvas.png"))
        .unwrap();
}

examples/advanced-filters.rs (line 174)

fn main() {
    // Gaussian blur
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();
    let test_image = Canvas::load(Path::new("assets/IMG_0771.JPG")).unwrap();
    let gaussian_canvas = canvas.filter(gaussian_filter);
    let _ = gaussian_canvas
        .save(Path::new("gaussian_canvas.png"))
        .unwrap();
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let gaussian_canvas = gaussian_canvas.filter(gaussian_filter);
    let _ = gaussian_canvas
        .save(Path::new("very_gaussian_canvas.png"))
        .unwrap();

    // Chaining filters
    let inverse_gaussian_canvas = canvas.filter(inverse_filter).filter(gaussian_filter);
    let _ = inverse_gaussian_canvas
        .save(Path::new("inverse_gaussian_canvas.png"))
        .unwrap();

    let lap_edge_detection_canvas = canvas.filter(lap_edge_detection_filter);
    let _ = lap_edge_detection_canvas
        .save(Path::new("lap_edge_detection_filter.png"))
        .unwrap();

    let prewitt_edge_detection_canvas = canvas.filter(prewitt_edge_detection_filter);
    let _ = prewitt_edge_detection_canvas
        .save(Path::new("prewitt_edge_detection_filter.png"))
        .unwrap();

    let lap_of_gaussian_filter_canvas = test_image.filter(grey_scale_filter).filter(lap_of_gaussian_filter);
    //let counted_colors = count_colors(&lap_of_gaussian_filter_canvas);
    //println!("{}", counted_colors_to_html(&counted_colors));
    let _ = lap_of_gaussian_filter_canvas
        .save(Path::new("lap_of_gaussian_edge_detection_filter.png"))
        .unwrap();
    let filtered_canvas = lap_of_gaussian_filter_canvas.filter(black_or_white_filter);
    let _ = filtered_canvas
        .save(Path::new("filtered_canvas.png"))
        .unwrap();

    let islands = filtered_canvas.find_islands(&Pixel::new(255, 255, 255, 255));
    let islands_with_size: Vec<Island> = islands.iter().filter(|x| x.points.len() > 40000).map(|x| x.clone()).collect();
    // TODO: Now we have the outline of the islands. 
    // Copy the islands a blank canvas.
    // Fill from the outside
    // Now you have the entire form of all the islands
    // Transfer the pixels that were not filled from the outside
    //
    //
    // TODO: NEW IDEA AS WELL: Create a 'fattener'. Paints a 2x2, 3x3, 4x4, ... etc around each
    // pixel. This way you can expand outwards





}

pub fn find_with_predicate( &self, predicate: fn(&Pixel, u32, u32) -> bool, ) -> Vec<PixelWithCoordinate>

Finds all pixels where predicate predicate holds

Examples found in repository

examples/draw-on-flamingo.rs (line 23)

fn main() {
    println!("Starting");
    let foreground = Canvas::load(Path::new("assets/flamingos.png")).unwrap();
    let background = Canvas::load(Path::new("assets/flamingobg.jpg")).unwrap();

    let result = background.draw_subimage(0, 0, &foreground);

    let compare_image = Canvas::load(Path::new("assets/draw-on-example-result.png")).unwrap();
    let diff = diff_debug(&result, &compare_image);
    diff.save(Path::new("diff_debug_flamingo.out.png")).unwrap();

    result.save(Path::new("flamingo.out.png")).unwrap();

    let non_zero = diff.find_with_predicate(find_non_zero);
    let mut diff_two = Canvas::new(400, 400);
    for e in non_zero.iter() {
        println!("{:?}", e);
        diff_two.set_pixel_mut(e.coordinate.x, e.coordinate.y, &Colors::BLACK);
    }
    diff_two.save(Path::new("diff_two.png")).unwrap();
    println!("Count: {}", non_zero.len());
}

pub fn flip(&self) -> Canvas

Flips the image on the vertical axis

Examples found in repository

examples/flipping-and-flopping.rs (line 7)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();

    let flipped = canvas.flip();
    let double_flipped = flipped.flip();

    let _ = flipped.save(Path::new("flipped.png")).unwrap();
    let _ = double_flipped
        .save(Path::new("double_flipped.png"))
        .unwrap();

    let flopped = canvas.flop();
    let double_flopped = flopped.flop();

    let _ = flopped.save(Path::new("flopped.png")).unwrap();
    let _ = double_flopped
        .save(Path::new("double_flopped.png"))
        .unwrap();
}

pub fn flop(&self) -> Canvas

Flips the image on the horizontal axis

Examples found in repository

examples/flipping-and-flopping.rs (line 15)

fn main() {
    let canvas = Canvas::load(Path::new("assets/lena.png")).unwrap();

    let flipped = canvas.flip();
    let double_flipped = flipped.flip();

    let _ = flipped.save(Path::new("flipped.png")).unwrap();
    let _ = double_flipped
        .save(Path::new("double_flipped.png"))
        .unwrap();

    let flopped = canvas.flop();
    let double_flopped = flopped.flop();

    let _ = flopped.save(Path::new("flopped.png")).unwrap();
    let _ = double_flopped
        .save(Path::new("double_flopped.png"))
        .unwrap();
}

Trait Implementations

impl Clone for Canvas

fn clone(&self) -> Canvas

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Canvas

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

Formats the value using the given formatter.

impl Display for Canvas

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

Formats the value using the given formatter.

impl PartialEq for Canvas

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Canvas