imageproc 0.23.1

Image processing operations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! An example of finding gradients in a greyscale image.
//! If running from the root directory of this crate you can test on the
//! building image in /examples by running the following command line.
//!
//! `cargo run --example gradients ./examples/empire-state-building.jpg ./tmp`

use image::{open, GrayImage, Luma};
use imageproc::{
    definitions::Image,
    gradients::{
        horizontal_prewitt, horizontal_scharr, horizontal_sobel, vertical_prewitt, vertical_scharr,
        vertical_sobel,
    },
    map::map_pixels,
};
use std::{env, fs, path::Path};

fn compute_gradients<F>(
    input: &GrayImage,
    gradient_func: F,
    output_dir: &Path,
    file_name: &str,
    scale: i16,
) where
    F: Fn(&GrayImage) -> Image<Luma<i16>>,
{
    let gradient = gradient_func(&input);
    let gradient = map_pixels(&gradient, |_, _, p| Luma([(p[0].abs() / scale) as u8]));
    gradient.save(&output_dir.join(file_name)).unwrap();
}

fn main() {
    if env::args().len() != 3 {
        panic!("Please enter an input file and a target directory")
    }

    let input_path = env::args().nth(1).unwrap();
    let output_dir = env::args().nth(2).unwrap();

    let input_path = Path::new(&input_path);
    let output_dir = Path::new(&output_dir);

    if !output_dir.is_dir() {
        fs::create_dir(output_dir).expect("Failed to create output directory")
    }

    if !input_path.is_file() {
        panic!("Input file does not exist");
    }

    // Load image and convert to grayscale
    let input_image = open(input_path)
        .expect(&format!("Could not load image at {:?}", input_path))
        .to_luma8();

    // Save grayscale image in output directory
    let gray_path = output_dir.join("grey.png");
    input_image.save(&gray_path).unwrap();

    compute_gradients(
        &input_image,
        horizontal_scharr,
        &output_dir,
        "horizontal_scharr.png",
        32,
    );
    compute_gradients(
        &input_image,
        vertical_scharr,
        &output_dir,
        "vertical_scharr.png",
        32,
    );
    compute_gradients(
        &input_image,
        horizontal_sobel,
        &output_dir,
        "horizontal_sobel.png",
        8,
    );
    compute_gradients(
        &input_image,
        vertical_sobel,
        &output_dir,
        "vertical_sobel.png",
        8,
    );
    compute_gradients(
        &input_image,
        horizontal_prewitt,
        &output_dir,
        "horizontal_prewitt.png",
        6,
    );
    compute_gradients(
        &input_image,
        vertical_prewitt,
        &output_dir,
        "vertical_prewitt.png",
        6,
    );
}