image 0.2.0-alpha

a pure rust imaging library
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Functions for altering and converting the color of pixelbufs
use std::num:: {
    cast,
    Float,
};

use std::default::Default;

use color:: {
    Pixel,
    Luma,
    Primitive,
};

use image:: {
    GenericImage,
    ImageBuf,
};

fn clamp <N: PartialOrd> (a: N, min: N, max: N) -> N {
    if a > max { max }
    else if a < min { min }
    else { a }
}

/// Convert the supplied image to grayscale
pub fn grayscale<P: Primitive + Default, T: Pixel<P>, I: GenericImage<T>> (
    image: &I) -> ImageBuf<Luma<P>> {

    let (width, height) = image.dimensions();
    let mut out = ImageBuf::new(width, height);

    for y in range(0, height) {
        for x in range(0, width) {
            let p = image.get_pixel(x, y).to_luma();
            out.put_pixel(x, y, p);
        }
    }

    out
}

/// Invert each pixel within the supplied image
/// This function operates in place.
pub fn invert<P: Primitive, T: Pixel<P>, I: GenericImage<T>>(image: &mut I) {
    let (width, height) = image.dimensions();

    for y in range(0, height) {
        for x in range(0, width) {
            let mut p = image.get_pixel(x, y);
            p.invert();

            image.put_pixel(x, y, p);
        }
    }
}

/// Adjust the contrast of the supplied image
/// ```contrast``` is the amount to adjust the contrast by.
/// Negative values decrease the contrast and positive values increase the contrast.
pub fn contrast<P: Primitive, T: Pixel<P>, I: GenericImage<T>>(
    image:    &I,
    contrast: f32) -> ImageBuf<T> {

    let (width, height) = image.dimensions();
    let mut out = ImageBuf::new(width, height);

    let max:P = Primitive::max_value();
    let max = cast::<P, f32>(max).unwrap();

    let percent = ((100.0 + contrast) / 100.0).powi(2);

    for y in range(0, height) {
        for x in range(0, width) {
            let f = image.get_pixel(x, y).map(|b| {
                let c = cast::<P, f32>(b).unwrap();

                let d = ((c / max - 0.5) * percent  + 0.5) * max;
                let e = clamp(d, 0.0, max);

                cast::<f32, P>(e).unwrap()
            });

            out.put_pixel(x, y, f);
        }
    }

    out
}

/// Brighten the supplied image
/// ```value``` is the amount to brighten each pixel by.
/// Negative values decrease the brightness and positive values increase it.
pub fn brighten<P: Primitive, T: Pixel<P>, I: GenericImage<T>>(
    image: &I,
    value: i32) -> ImageBuf<T> {

    let (width, height) = image.dimensions();
    let mut out = ImageBuf::new(width, height);

    let max: P = Primitive::max_value();
    let max = cast::<P, i32>(max).unwrap();

    for y in range(0, height) {
        for x in range(0, width) {
            let e = image.get_pixel(x, y).map_with_alpha(|b| {
                let c = cast::<P, i32>(b).unwrap();
                let d = clamp(c + value, 0, max);

                cast::<i32, P>(d).unwrap()
            }, |alpha| alpha);

            out.put_pixel(x, y, e);
        }
    }

    out
}