auto-palette 0.9.0

🎨 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

use thiserror::Error;

use crate::FloatNumber;

/// Error type for Gaussian function.
#[derive(Debug, Error)]
pub enum GaussianError<T>
where
    T: FloatNumber,
{
    /// Error when either the center or sigma is invalid.
    #[error("Invalid Parameters: center = {center}, sigma = {sigma}")]
    InvalidParameters { center: T, sigma: T },
}

/// Calculates the value of the Gaussian function at a given point.
///
/// The formula used is:
/// exp(-((x - center)^2) / (2 * sigma^2))
///
/// # Arguments
/// * `x` - The point at which to evaluate the Gaussian function.
/// * `center` - The center of the Gaussian function.
/// * `sigma` - The standard deviation of the Gaussian function.
///
/// # Returns
/// The value of the Gaussian function at the given point.
#[inline(always)]
pub fn gaussian<T>(x: T, center: T, sigma: T) -> Result<T, GaussianError<T>>
where
    T: FloatNumber,
{
    if center.is_nan() {
        return Err(GaussianError::InvalidParameters { center, sigma });
    }
    if sigma.is_zero() {
        return Err(GaussianError::InvalidParameters { center, sigma });
    }
    Ok((-(x - center).powi(2) / (T::from_u16(2) * sigma.powi(2))).exp())
}

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

    use super::*;
    use crate::assert_approx_eq;

    #[rstest]
    #[case(0.0, 0.0, 1.0, 1.0)]
    #[case(0.0, 1.0, 1.0, 0.606530)]
    #[case(1.0, 0.0, 1.0, 0.606530)]
    #[case(1.0, 1.0, 1.0, 1.0)]
    #[case(0.0, 0.5, 1.0, 0.882496)]
    #[case(0.5, 0.0, 1.0, 0.882496)]
    #[case(16.0, 60.0, 15.0, 0.013538)]
    #[case(64.0, 60.0, 15.0, 0.965069)]
    #[case(104.0, 60.0, 15.0, 0.013538)]
    fn test_gaussian_score(
        #[case] x: f64,
        #[case] center: f64,
        #[case] sigma: f64,
        #[case] expected: f64,
    ) {
        // Act
        let actual = gaussian(x, center, sigma).unwrap();

        // Assert
        assert_approx_eq!(actual, expected);
    }

    #[rstest]
    #[case::invalid_sigma(0.0, 0.0, "Invalid Parameters: center = 0, sigma = 0")]
    #[case::invalid_center(f32::NAN, 1.0, "Invalid Parameters: center = NaN, sigma = 1")]
    fn test_gaussian_invalid(#[case] center: f32, #[case] sigma: f32, #[case] expected: &str) {
        // Act
        let actual = gaussian(1.0, center, sigma);

        // Assert
        assert!(actual.is_err());
        assert_eq!(actual.unwrap_err().to_string(), expected);
    }
}