prisma 0.1.1

A color library for both simple and complex color manipulation, intending to be the go to rust color library for most tasks. It can handle conversion between a large number of color models, and can convert into the CIE device independent color spaces. Prisma tries to be easy to use while encouraging correct transformations, making mathematically correct conversions easy without knowing the whole field of color science.
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
103
104
105
106
107
108
109

//! Implementing `From` conversions between colors
//!
//! All of these methods delegate to `from_color` internally.

use crate::convert::*;
use crate::channel::{PosNormalChannelScalar, AngularChannelScalar, NormalChannelScalar};
use angle::{Angle, FromAngle, Turns, Rad};
use num_traits::{Float, NumCast};

use crate::{Rgb, Hsv, Hsl, Hwb, Hsi, eHsi};
use crate::ycbcr::{YCbCr, YCbCrModel, UnitModel};

//region From<Rgb> {{{
macro_rules! impl_angular_from_rgb {
    ($color1:ty, $color2:ty) => {
        impl<T, A> From<$color1> for $color2
        where
            T: PosNormalChannelScalar + Float,
            A: AngularChannelScalar + FromAngle<Turns<T>>,
        {
            fn from(from: Rgb<T>) -> Self {
                Self::from_color(&from)
            }
        }
    }
}

impl_angular_from_rgb!(Rgb<T>, Hsv<T, A>);
impl_angular_from_rgb!(Rgb<T>, Hsl<T, A>);
impl_angular_from_rgb!(Rgb<T>, Hwb<T, A>);

impl<T, A> From<Rgb<T>> for Hsi<T, A>
where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar=T> + FromAngle<Rad<T>>,
{
    fn from(from: Rgb<T>) -> Self {
        Self::from_color(&from)
    }
}

impl<T, A> From<Rgb<T>> for eHsi<T, A>
    where
        T: PosNormalChannelScalar + Float,
        A: AngularChannelScalar + Angle<Scalar=T> + FromAngle<Rad<T>>,
{
    fn from(from: Rgb<T>) -> Self {
        Self::from_color(&from)
    }
}

impl<T, M> From<Rgb<T>> for YCbCr<T, M>
    where
        T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
        M: YCbCrModel<T> + UnitModel<T>,
{
    fn from(from: Rgb<T>) -> YCbCr<T, M> {
        Self::from_rgb(&from)
    }
}
//endregion }}}

//region From<Hsv> {{{
impl<T, A> From<Hsv<T, A>> for Rgb<T>
    where
        T: PosNormalChannelScalar + Float,
        A: AngularChannelScalar,
{
    fn from(from: Hsv<T, A>) -> Self {
        Self::from_color(&from)
    }
}
/*
impl<T, A, A2> From<Hsv<T, A>> for Hwb<T, A2>
    where
        T: PosNormalChannelScalar + Float,
        A: AngularChannelScalar + Angle,
        A2: AngularChannelScalar + FromAngle<A>,
{
    fn from(from: Hsv<T, A>) -> Self {
        Self::from_color(&from)
    }
}
*/
//endregion }}}

//region From<Hsl> {{{
impl<T, A> From<Hsl<T, A>> for Rgb<T>
    where
        T: PosNormalChannelScalar + Float,
        A: AngularChannelScalar,
{
    fn from(from: Hsl<T, A>) -> Self {
        Self::from_color(&from)
    }
}
//endregion }}}

//region From<Hwb> {{{
impl<T, A> From<Hwb<T, A>> for Rgb<T>
    where
        T: PosNormalChannelScalar + Float,
        A: AngularChannelScalar,
{
    fn from(from: Hwb<T, A>) -> Self {
        Self::from_color(&from)
    }
}
//endregion }}}