color_gradient/interpolation/
mod.rs

1use std::{collections::BTreeMap, ops::Range};
2
3type Resolution = u16;
4
5/// A interpolator that interpolates values in range.
6#[derive(Clone, Debug)]
7#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8pub struct Interpolator {
9    keys: BTreeMap<Resolution, f32>,
10    lhs: f32,
11    rhs: f32,
12}
13
14impl Default for Interpolator {
15    fn default() -> Self {
16        Self { keys: Default::default(), lhs: 0.0, rhs: 1.0 }
17    }
18}
19
20impl Interpolator {
21    /// Create a new interpolator with the given lower and upper bounds.
22    ///
23    /// # Examples
24    ///
25    /// ```
26    /// # use color_gradient::Interpolator;
27    /// let interpolator = Interpolator::new(0.0, 1.0);
28    /// assert_eq!(interpolator.head(), 0.0);
29    /// assert_eq!(interpolator.tail(), 1.0);
30    /// ```
31    pub fn new(lower: f32, upper: f32) -> Self {
32        Self { keys: Default::default(), lhs: lower, rhs: upper }
33    }
34    /// Get the left most value of the interpolator, if not set, the lower bound is returned.
35    ///
36    /// # Examples
37    ///
38    /// ```
39    /// # use color_gradient::Interpolator;
40    /// let mut interpolator = Interpolator::default();
41    /// assert_eq!(interpolator.head(), 0.0);
42    /// interpolator.insert(0, 0.5);
43    /// assert_eq!(interpolator.head(), 0.5);
44    /// ```
45    pub fn head(&self) -> f32 {
46        self.keys.get(&Resolution::MIN).copied().unwrap_or(self.lhs)
47    }
48    /// Get the right most value of the interpolator, if not set, the upper bound is returned.
49    ///
50    /// # Examples
51    ///
52    /// ```
53    /// # use color_gradient::Interpolator;
54    /// let mut interpolator = Interpolator::default();
55    /// assert_eq!(interpolator.tail(), 1.0);
56    /// interpolator.insert(65535, 0.5);
57    /// assert_eq!(interpolator.tail(), 0.5);
58    /// ```
59    pub fn tail(&self) -> f32 {
60        self.keys.get(&Resolution::MAX).copied().unwrap_or(self.rhs)
61    }
62    /// Insert a new key value pair into the interpolator, overwriting any existing value.
63    ///
64    /// # Examples
65    ///
66    /// ```
67    /// # use color_gradient::{Interpolator};
68    /// let mut gradient = Interpolator::default();
69    /// gradient.insert(0, 0.5);
70    /// gradient.insert(65535, 0.5);
71    /// assert_eq!(gradient.head(), 0.5);
72    /// assert_eq!(gradient.tail(), 0.5);
73    /// ```
74    pub fn insert(&mut self, key: Resolution, value: f32) {
75        self.keys.insert(key, value);
76    }
77    /// Remove a key value pair from the interpolator.
78    ///
79    /// # Examples
80    ///
81    /// ```
82    /// # use color_gradient::{Interpolator};
83    /// let mut gradient = Interpolator::default();
84    /// gradient.insert(0, 0.5);
85    /// assert_eq!(gradient.head(), 0.5);
86    /// gradient.remove(0);
87    /// assert_eq!(gradient.head(), 0.0);
88    /// ```
89    pub fn remove(&mut self, key: Resolution) {
90        self.keys.remove(&key);
91    }
92    /// Clear all key value pairs from the interpolator.
93    ///
94    /// # Examples
95    ///
96    /// ```
97    /// # use color_gradient::{Interpolator};
98    /// ```
99    pub fn clear(&mut self) {
100        self.keys.clear();
101    }
102}
103
104impl Interpolator {
105    pub(crate) fn get_ratio(range: &Range<f32>, value: f32) -> u16 {
106        if value <= range.start {
107            0
108        }
109        else if value >= range.end {
110            65535
111        }
112        else {
113            let ratio = (value - range.start) / (range.end - range.start);
114            (ratio * 65535.0) as u16
115        }
116    }
117
118    /// Get zero-order interpolation, that is, the first number greater than ratio
119    pub fn get_step(&self, key: Resolution) -> f32 {
120        if key == Resolution::MIN {
121            self.head()
122        }
123        else if key == Resolution::MAX {
124            self.tail()
125        }
126        else {
127            self.keys.range(..=key).next_back().map(|(_, v)| *v).unwrap_or(self.lhs)
128        }
129    }
130    /// Get first-order linear interpolation
131    pub fn get_linear(&self, key: Resolution) -> f32 {
132        if key == Resolution::MIN {
133            self.head()
134        }
135        else if key == Resolution::MAX {
136            self.tail()
137        }
138        else {
139            let s1 = (&Resolution::MIN, &self.head());
140            let s2 = (&Resolution::MAX, &self.tail());
141            let (k1, v1) = self.keys.range(..=key).next_back().unwrap_or(s1);
142            let (k2, v2) = self.keys.range(key..).next().unwrap_or(s2);
143            if k1 == k2 { *v1 } else { v1 + (v2 - v1) * (key - k1) as f32 / (k2 - k1) as f32 }
144        }
145    }
146    /// Get bezier interpolation
147    pub fn get_bezier(&self, key: Resolution) -> f32 {
148        if key == Resolution::MIN {
149            self.head()
150        }
151        else if key == Resolution::MAX {
152            self.tail()
153        }
154        else {
155            // bezier 1D
156            let s1 = (&Resolution::MIN, &self.head());
157            let s2 = (&Resolution::MAX, &self.tail());
158            let (k1, v1) = self.keys.range(..=key).next_back().unwrap_or(s1);
159            let (k2, v2) = self.keys.range(key..).next().unwrap_or(s2);
160            let t = (key - k1) as f32 / (k2 - k1) as f32;
161            let v = (1.0 - t) * v1 + t * v2;
162            v
163        }
164    }
165}
color_gradient/interpolation/mod.rs

color_gradient/interpolation/
mod.rs
