auto-palette 0.8.1

🎨 A Rust library that extracts prominent color palettes from images automatically.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

#[cfg(feature = "image")]
use image::ImageError;
use thiserror::Error;

use crate::math::sampling::SamplingError;

/// Represents specific errors encountered during the palette extraction process.
#[derive(Debug, Error)]
pub enum Error {
    /// Error when provided image data is empty and contains no pixel information.
    #[error("Image data is empty: no pixels to process")]
    EmptyImageData,

    /// Error when the provided image data contains invalid pixel information.
    #[error("Image data is invalid: contains invalid pixel data")]
    InvalidImageData,

    /// Error when the palette extraction process fails, providing the underlying details.
    #[error("Palette extraction process failed with error: {details}")]
    PaletteExtractionError {
        /// The underlying cause of the palette extraction failure.
        details: String,
    },

    /// Error when the swatch selection process fails, providing the underlying details.
    #[error("Swatch selection process failed with error: {cause}")]
    SwatchSelectionError {
        #[from]
        cause: SamplingError,
    },

    /// Error when an unsupported algorithm is specified.
    #[error("Unsupported algorithm specified: '{name}'")]
    UnsupportedAlgorithm {
        /// The name of the unsupported algorithm.
        name: String,
    },

    /// Error when an unsupported theme is specified.
    #[error("Unsupported theme specified: '{name}'")]
    UnsupportedTheme {
        /// The name of the unsupported theme.
        name: String,
    },

    /// Error when the image fails to load, providing the underlying cause.
    #[cfg(feature = "image")]
    #[error("Image loading process failed with error: {cause}")]
    ImageLoadError {
        /// The underlying cause of the image loading failure.
        #[from]
        cause: ImageError,
    },

    /// Error when the image format or color type is not supported.
    #[cfg(feature = "image")]
    #[error("Image format or color type is not supported")]
    UnsupportedImageFormat,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty_image_data() {
        // Act
        let actual = Error::EmptyImageData;

        // Assert
        assert_eq!(
            actual.to_string(),
            "Image data is empty: no pixels to process"
        );
    }

    #[test]
    fn test_invalid_image_data() {
        // Act
        let actual = Error::InvalidImageData;

        // Assert
        assert_eq!(
            actual.to_string(),
            "Image data is invalid: contains invalid pixel data"
        );
    }

    #[test]
    fn test_palette_extraction_error() {
        // Act
        let actual = Error::PaletteExtractionError {
            details: "Details about the failure.".to_string(),
        };

        // Assert
        assert_eq!(
            actual.to_string(),
            "Palette extraction process failed with error: Details about the failure."
        );
    }

    #[test]
    fn test_swatches_selection_error() {
        // Act
        let cause = SamplingError::InvalidDiversity;
        let actual = Error::SwatchSelectionError { cause };

        // Assert
        assert_eq!(
            actual.to_string(),
            "Swatch selection process failed with error: Invalid diversity: Diversity score must be between 0.0 and 1.0."
        );
    }

    #[test]
    fn test_unsupported_algorithm() {
        // Act
        let actual = Error::UnsupportedAlgorithm {
            name: "xmeans".to_string(),
        };

        // Assert
        assert_eq!(
            actual.to_string(),
            "Unsupported algorithm specified: 'xmeans'"
        );
    }

    #[test]
    fn test_unsupported_theme() {
        // Act
        let actual = Error::UnsupportedTheme {
            name: "pastel".to_string(),
        };

        // Assert
        assert_eq!(actual.to_string(), "Unsupported theme specified: 'pastel'");
    }

    #[test]
    #[cfg(feature = "image")]
    fn test_image_load_error() {
        // Arrange
        let cause = ImageError::IoError(std::io::Error::from(std::io::ErrorKind::NotFound));
        let error = Error::ImageLoadError { cause };

        // Act
        let actual = error.to_string();

        // Assert
        assert_eq!(
            actual,
            "Image loading process failed with error: entity not found"
        );
    }

    #[test]
    #[cfg(feature = "image")]
    fn test_unsupported_image() {
        // Act
        let actual = Error::UnsupportedImageFormat;

        // Assert
        assert_eq!(
            actual.to_string(),
            "Image format or color type is not supported"
        );
    }
}