feim 0.25.1

Modular crate for working with images in Rust
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

pub use oklab::Oklab;

use super::convert::ConvertFrom;
#[cfg(feature = "col-nrgba64")]
use super::Endianness;
#[cfg(feature = "col-nrgba")]
use super::Nrgba;
#[cfg(feature = "col-rgb")]
use super::Rgb;
use super::{Color, Zero};
#[cfg(feature = "col-nrgba64")]
use super::{Nrgba64, Nrgba64Channels};
#[allow(unused_imports)]
use crate::specialized;

impl Zero for Oklab {
    const ZERO: Self = Oklab {
        l: 0.0,
        a: 0.0,
        b: 0.0,
    };
}

impl Color for Oklab {
    fn as_rgba(&self) -> (u32, u32, u32, u32) {
        let oklab::Rgb { r, g, b } = oklab::oklab_to_srgb(*self);

        let r = r as u32;
        let g = g as u32;
        let b = b as u32;

        let r = r | (r << 8);
        let g = g | (g << 8);
        let b = b | (b << 8);
        let a = 0xffff;

        (r, g, b, a)
    }
}

impl<C: Color> ConvertFrom<C> for Oklab {
    fn convert_from(c: C) -> Oklab {
        let (r, g, b, _) = c.as_rgba();
        oklab::srgb_to_oklab(oklab::Rgb {
            r: ((r >> 8) & 0xff) as u8,
            g: ((g >> 8) & 0xff) as u8,
            b: ((b >> 8) & 0xff) as u8,
        })
    }
}

#[cfg(feature = "col-rgb")]
impl ConvertFrom<Rgb, specialized::For<Oklab>> for Oklab {
    #[inline]
    fn convert_from(Rgb { r, g, b }: Rgb) -> Oklab {
        oklab::srgb_to_oklab(oklab::Rgb { r, g, b })
    }
}

#[cfg(feature = "col-nrgba")]
impl ConvertFrom<Nrgba, specialized::For<Oklab>> for Oklab {
    #[inline]
    fn convert_from(Nrgba { r, g, b, .. }: Nrgba) -> Oklab {
        oklab::srgb_to_oklab(oklab::Rgb { r, g, b })
    }
}

#[cfg(feature = "col-nrgba64")]
impl<E> ConvertFrom<Nrgba64<E>, specialized::For<Oklab>> for Oklab
where
    Nrgba64<E>: Copy + Color + Nrgba64Channels,
    E: Endianness,
{
    #[inline]
    fn convert_from(c: Nrgba64<E>) -> Oklab {
        oklab::linear_srgb_to_oklab(oklab::Rgb {
            r: c.r() as f32 / 65535.0,
            g: c.g() as f32 / 65535.0,
            b: c.b() as f32 / 65535.0,
        })
    }
}

#[cfg(feature = "col-nrgba64")]
impl<E> ConvertFrom<Oklab, specialized::For<Nrgba64<E>>> for Nrgba64<E>
where
    Nrgba64<E>: Copy + Color + Zero + Nrgba64Channels,
{
    #[inline]
    fn convert_from(c: Oklab) -> Nrgba64<E> {
        let oklab::Rgb { r, g, b } = oklab::oklab_to_linear_srgb(c);

        let mut result = Nrgba64::ZERO;
        result = result.set_r((r * 65535.0).round() as u16);
        result = result.set_g((g * 65535.0).round() as u16);
        result = result.set_b((b * 65535.0).round() as u16);
        result = result.set_a(0xffff);

        result
    }
}