dipc 1.1.0

Convert your favorite images and wallpapers with your favorite color palettes/themes
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

use deltae::LabValue;

#[derive(Debug, Clone, Copy)]
pub struct Lab {
    l: f32,
    a: f32,
    b: f32,
}

impl From<[u8; 3]> for Lab {
    fn from(value: [u8; 3]) -> Self {
        let lab::Lab { l, a, b } = lab::Lab::from_rgb(&value);
        Lab { l, a, b }
    }
}

impl From<[u8; 4]> for Lab {
    fn from(value: [u8; 4]) -> Self {
        let lab::Lab { l, a, b } = lab::Lab::from_rgba(&value);
        Lab { l, a, b }
    }
}

impl From<Lab> for LabValue {
    fn from(lab: Lab) -> Self {
        LabValue {
            l: lab.l,
            a: lab.a,
            b: lab.b,
        }
    }
}

impl Lab {
    pub fn to_nearest_palette(self, palette: &[Lab], method: deltae::DEMethod) -> Self {
        let mut min_distance = f32::MAX;
        let mut new_color = self;

        for &color in palette {
            // let delta = *deltae::DeltaE::new(self, color, deltae::DEMethod::DE2000).value();
            let delta = *deltae::DeltaE::new(self, color, method).value();

            if delta < min_distance {
                min_distance = delta;
                new_color = color;
            }
        }

        new_color
    }

    pub fn to_rgb(self) -> [u8; 3] {
        let lab = lab::Lab {
            l: self.l,
            a: self.a,
            b: self.b,
        };
        lab.to_rgb()
    }
}

// Implement DeltaEq for Lab
impl<D: deltae::Delta + Copy> deltae::DeltaEq<D> for Lab {}

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
pub enum CLIDEMethod {
    /// The default DeltaE method
    DE2000,
    // /// An implementation of DeltaE with separate tolerances for Lightness and Chroma
    // DECMC(
    //     /// Lightness tolerance
    //     f32,
    //     /// Chroma tolerance
    //     f32,
    // ),
    /// CIE94 DeltaE implementation, weighted with a tolerance for graphics
    DE1994G,
    /// CIE94 DeltaE implementation, weighted with a tolerance for textiles
    DE1994T,
    /// The original DeltaE implementation, a basic euclidian distance formula
    DE1976,
}

impl Default for CLIDEMethod {
    fn default() -> Self {
        Self::DE2000
    }
}

impl std::fmt::Display for CLIDEMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CLIDEMethod::DE2000 => write!(f, "de2000"),
            // CLIDEMethod::DECMC(l, c) => write!(f, "decmc({}, {})", l, c),
            CLIDEMethod::DE1994G => write!(f, "de1994g"),
            CLIDEMethod::DE1994T => write!(f, "de1994t"),
            CLIDEMethod::DE1976 => write!(f, "de1976"),
        }
    }
}

impl From<CLIDEMethod> for deltae::DEMethod {
    fn from(method: CLIDEMethod) -> Self {
        match method {
            CLIDEMethod::DE2000 => Self::DE2000,
            // CLIDEMethod::DECMC(l, c) => Self::DECMC(l, c),
            CLIDEMethod::DE1994G => Self::DE1994G,
            CLIDEMethod::DE1994T => Self::DE1994T,
            CLIDEMethod::DE1976 => Self::DE1976,
        }
    }
}