rustyphoenixpng 1.1.2

This project eases manipulation of ong image inside Phoenix ecosystem
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

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

///Color related to a value
#[derive(Debug)]
struct PColorValue{
	///Value of the color
	value: f32,
	///Red channel
	r: u8,
	///Green channel
	g: u8,
	///Blue channel
	b: u8,
	///Alpha channel
	a: u8,
}

impl PColorValue{
	///Constructor of a PColorValue
	/// # Parameters
	/// - `value` : 1d value
	/// - `r` : associated red component
	/// - `g` : associated green component
	/// - `b` : associated blue component
	/// - `a` : associated a component
	/// # Returns
	/// Initialised PColorValue
	pub fn new(value: f32, r: u8, g: u8, b: u8, a: u8) -> Self{
		PColorValue {
			value: value,
			r: r,
			g: g,
			b: b,
			a: a
		}
	}
	///Get a color tuple
	/// # Return
	/// Color tuple
	pub fn get_color(&self) -> (u8, u8, u8, u8){
		return (self.r, self.g, self.b, self.a);
	}
}

///Map which interpolates between colors
#[derive(Debug)]
pub struct PColorMap{
	///Vector of reference color for given values
	vec_value: Vec<PColorValue>,
}

impl PColorMap{
	///Constructor of the PColorMap
	pub fn new() -> Self{
		PColorMap {
			vec_value: vec![]
		}
	}
	///Create the Gray Scott PColorMap
	/// # Returns
	/// Gray Scott PColorMap
	pub fn gray_scott() -> Self{
		let mut colormap: PColorMap = PColorMap::new();
		colormap.add_color(0.0, 0, 0, 0, 255);
		colormap.add_color(0.2, 0, 255, 0, 255);
		colormap.add_color(0.21, 255, 255, 0, 255);
		colormap.add_color(0.4, 255, 0, 0, 255);
		colormap.add_color(0.6, 255, 255, 255, 255);
		return colormap;
	}
	///Add a color in the map
	/// # Parameters
	/// - `value` : 1d value
	/// - `r` : associated red component
	/// - `g` : associated green component
	/// - `b` : associated blue component
	/// - `a` : associated a component
	pub fn add_color(&mut self, value: f32, r: u8, g: u8, b: u8, a: u8){
		self.vec_value.push(PColorValue::new(value, r, g, b, a));
	}
	///Interpolate value in color
	/// # Parameters
	/// - `value` : value to be interpolated
	/// # Returns
	/// Interpolated (r,g,b,a) tuple
	pub fn interpolate(&self, value: f32) -> (u8, u8, u8, u8){
		if self.vec_value.len() == 0 {	//The vector is empty
			return (0,0,0,0);
		}else{
			//If the value is less than min
			let mincolor = self.vec_value.first().unwrap();
			if value <= mincolor.value {
				return mincolor.get_color();
			}
			//If the value is greater than the max
			let maxcolor = self.vec_value.last().unwrap();
			if value >= maxcolor.value {
				return maxcolor.get_color();
			}
			for (min, max) in self.vec_value.iter().zip(self.vec_value.iter().skip(1)) {
				if value >= min.value && value < max.value {
					let interp: PColorValue = self.interpolate_color(value, min, max);
					return interp.get_color();
				}
			}
			return (0,0,0,0);
		}
	}
	///Interpolate color
	/// # Parameters
	/// - `value` : value to be interpolated
	/// - `min_color` : color where value is smaller than the given value
	/// - `max_color` : color where value is greater than the given value
	/// # Returns
	/// Interpolated PColorValue
	fn interpolate_color(&self, value: f32, min_color: &PColorValue, max_color: &PColorValue) -> PColorValue{
		let ratio: f32 = (value - min_color.value)/(max_color.value - min_color.value);
		let color: PColorValue = PColorValue::new(value,
			((max_color.r as f32)*ratio + (min_color.r as f32)*(1.0 - ratio)) as u8,
			((max_color.g as f32)*ratio + (min_color.g as f32)*(1.0 - ratio)) as u8,
			((max_color.b as f32)*ratio + (min_color.b as f32)*(1.0 - ratio)) as u8,
			((max_color.a as f32)*ratio + (min_color.a as f32)*(1.0 - ratio)) as u8
		);
		return color;
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	///Test the PColorMap
	#[test]
	fn test_pcolormap() {
		let colormap: PColorMap = PColorMap::gray_scott();
		println!("test_pcolormap : colormap = {:?}", colormap);
		assert_eq!(colormap.vec_value.get(0).unwrap().get_color(), (0, 0, 0, 255));
		assert_eq!(colormap.vec_value.first().unwrap().get_color(), (0, 0, 0, 255));
		assert_eq!(colormap.vec_value.get(1).unwrap().get_color(), (0, 255, 0, 255));
		assert_eq!(colormap.vec_value.get(2).unwrap().get_color(), (255, 255, 0, 255));
		assert_eq!(colormap.vec_value.get(3).unwrap().get_color(), (255, 0, 0, 255));
		assert_eq!(colormap.vec_value.get(4).unwrap().get_color(), (255, 255, 255, 255));
		assert_eq!(colormap.vec_value.last().unwrap().get_color(), (255, 255, 255, 255));
		
		assert_eq!(colormap.interpolate(-1.0), (0, 0, 0, 255));
		assert_eq!(colormap.interpolate(1.0), (255, 255, 255, 255));
		assert_eq!(colormap.interpolate(0.5), (255, 127, 127, 255));
	}
}