farg 0.4.5

A Rust library for colorimetry, color space conversions, and color manipulation.
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

use super::Table;

/// Shorthand alias for [`SpectralPowerDistribution`].
pub type Spd = SpectralPowerDistribution;

/// Spectral power distribution — the power of a light source at each wavelength.
#[derive(Clone, Copy, Debug)]
pub struct SpectralPowerDistribution(&'static [(u32, f64)]);

impl SpectralPowerDistribution {
  /// Creates a new SPD from static wavelength-power pairs.
  pub const fn new(table: &'static [(u32, f64)]) -> Self {
    Self(table)
  }

  /// Returns the maximum power value across all wavelengths.
  pub fn peak_power(&self) -> f64 {
    self.values().cloned().fold(f64::NEG_INFINITY, f64::max)
  }

  /// Returns the wavelength with the highest power, or `None` if empty.
  pub fn peak_wavelength(&self) -> Option<u32> {
    self
      .table()
      .iter()
      .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
      .map(|(w, _)| *w)
  }

  /// Returns the sum of power values across all wavelengths.
  pub fn total_power(&self) -> f64 {
    self.values().sum()
  }
}

impl Table for SpectralPowerDistribution {
  type Value = f64;

  fn table(&self) -> &[(u32, Self::Value)] {
    self.0
  }
}

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

  static TEST_SPD: &[(u32, f64)] = &[(380, 0.1), (400, 0.5), (420, 0.3), (440, 0.2)];
  static EMPTY_SPD: &[(u32, f64)] = &[];

  mod peak_power {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn it_returns_maximum_power_value() {
      let spd = Spd::new(TEST_SPD);

      assert_eq!(spd.peak_power(), 0.5);
    }

    #[test]
    fn it_returns_negative_infinity_for_empty_table() {
      let spd = Spd::new(EMPTY_SPD);

      assert_eq!(spd.peak_power(), f64::NEG_INFINITY);
    }
  }

  mod peak_wavelength {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn it_returns_wavelength_with_maximum_power() {
      let spd = Spd::new(TEST_SPD);

      assert_eq!(spd.peak_wavelength(), Some(400));
    }

    #[test]
    fn it_returns_none_for_empty_table() {
      let spd = Spd::new(EMPTY_SPD);

      assert_eq!(spd.peak_wavelength(), None);
    }
  }

  mod total_power {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn it_sums_all_power_values() {
      let spd = Spd::new(TEST_SPD);
      let expected = 0.1 + 0.5 + 0.3 + 0.2;

      assert_eq!(spd.total_power(), expected);
    }

    #[test]
    fn it_returns_zero_for_empty_table() {
      let spd = Spd::new(EMPTY_SPD);

      assert_eq!(spd.total_power(), 0.0);
    }
  }
}