Auto merge of #22 - Ogeon:alpha, r=Ogeon

Extract the alpha component as a wrapper type

This closes #11 by adding a wrapper type that bolts the alpha component to any color. This works well because of how passive the alpha is in most of the calculations and conversions, and results in a relatively low amount of code duplication.

Each color space (and `Color`) has a sibling type alias with an `a` added to the name, such as `Rgba`. Those are alias for `Alpha<C<T>, T>`, where `C` is the color space type, and can be used more or less in the same way as their non-alpha variants. Conversion between alpha types and non-alpha types is as easy as always.

This is a breaking change, since the alpha component is removed from every color and constructors are moved and/or renamed. The new constructors follows the same convention as the constructors in `Srgb` and `GammaRgb`, which is `new` for float values and `new_u8` for `u8` values. The constructors on `Color` are roughly the same as before, with the exception of changing things like `rgb8` to `rgb_u8`.

Author: homu

README.md

@@ -110,13 +110,13 @@ extern crate palette;
 use palette::{Rgb, Hsv, Gradient};
 
 let grad1 = Gradient::new(vec![
-    Rgb::rgb(1.0, 0.1, 0.1),
-    Rgb::rgb(0.1, 1.0, 1.0)
+    Rgb::new(1.0, 0.1, 0.1),
+    Rgb::new(0.1, 1.0, 1.0)
 ]);
 
 let grad2 = Gradient::new(vec![
-    Hsv::from(Rgb::rgb(1.0, 0.1, 0.1)),
-    Hsv::from(Rgb::rgb(0.1, 1.0, 1.0))
+    Hsv::from(Rgb::new(1.0, 0.1, 0.1)),
+    Hsv::from(Rgb::new(0.1, 1.0, 1.0))
 ]);
 ```
 

examples/gradient.rs

@@ -9,30 +9,30 @@ use image::{RgbImage, GenericImage};
 fn main() {
     //A gradient of evenly spaced colors
     let grad1 = Gradient::new(vec![
-        Rgb::rgb(1.0, 0.1, 0.1),
-        Rgb::rgb(0.1, 0.1, 1.0),
-        Rgb::rgb(0.1, 1.0, 0.1)
+        Rgb::new(1.0, 0.1, 0.1),
+        Rgb::new(0.1, 0.1, 1.0),
+        Rgb::new(0.1, 1.0, 0.1)
     ]);
 
     //The same colors as in grad1, but with the blue point shifted down
     let grad2 = Gradient::with_domain(vec![
-        (0.0, Rgb::rgb(1.0, 0.1, 0.1)),
-        (0.25, Rgb::rgb(0.1, 0.1, 1.0)),
-        (1.0, Rgb::rgb(0.1, 1.0, 0.1))
+        (0.0, Rgb::new(1.0, 0.1, 0.1)),
+        (0.25, Rgb::new(0.1, 0.1, 1.0)),
+        (1.0, Rgb::new(0.1, 1.0, 0.1))
     ]);
 
     //The same colors and offsets as in grad1, but in a color space where the hue is a component
     let grad3 = Gradient::new(vec![
-        Lch::from(Rgb::rgb(1.0, 0.1, 0.1)),
-        Lch::from(Rgb::rgb(0.1, 0.1, 1.0)),
-        Lch::from(Rgb::rgb(0.1, 1.0, 0.1))
+        Lch::from(Rgb::new(1.0, 0.1, 0.1)),
+        Lch::from(Rgb::new(0.1, 0.1, 1.0)),
+        Lch::from(Rgb::new(0.1, 1.0, 0.1))
     ]);
 
     //The same colors and and color space as in grad3, but with the blue point shifted down
     let grad4 = Gradient::with_domain(vec![
-        (0.0, Lch::from(Rgb::rgb(1.0, 0.1, 0.1))),
-        (0.25, Lch::from(Rgb::rgb(0.1, 0.1, 1.0))),
-        (1.0, Lch::from(Rgb::rgb(0.1, 1.0, 0.1)))
+        (0.0, Lch::from(Rgb::new(1.0, 0.1, 0.1))),
+        (0.25, Lch::from(Rgb::new(0.1, 0.1, 1.0))),
+        (1.0, Lch::from(Rgb::new(0.1, 1.0, 0.1)))
     ]);
 
     let mut image = RgbImage::new(256, 128);

examples/readme_examples.rs

@@ -5,7 +5,7 @@ extern crate num;
 use image::{RgbImage, GenericImage};
 use num::traits::Float;
 
-use palette::{Rgb, Gradient, Mix};
+use palette::{Rgba, Gradient, Mix};
 use palette::pixel::Srgb;
 
 mod color_spaces {
@@ -48,13 +48,13 @@ mod gradients {
 
     pub fn run() {
         let grad1 = Gradient::new(vec![
-            Rgb::rgb(1.0, 0.1, 0.1),
-            Rgb::rgb(0.1, 1.0, 1.0)
+            Rgb::new(1.0, 0.1, 0.1),
+            Rgb::new(0.1, 1.0, 1.0)
         ]);
 
         let grad2 = Gradient::new(vec![
-            Hsv::from(Rgb::rgb(1.0, 0.1, 0.1)),
-            Hsv::from(Rgb::rgb(0.1, 1.0, 1.0))
+            Hsv::from(Rgb::new(1.0, 0.1, 0.1)),
+            Hsv::from(Rgb::new(0.1, 1.0, 1.0))
         ]);
 
         display_gradients("examples/readme_gradients.png", grad1, grad2);
@@ -76,8 +76,8 @@ fn display_colors(filename: &str, colors: &[[u8; 3]]) {
 }
 
 fn display_gradients<T: Float, A: Mix<Scalar=T> + Clone, B: Mix<Scalar=T> + Clone>(filename: &str, grad1: Gradient<A>, grad2: Gradient<B>) where
-    Rgb<T>: From<A>,
-    Rgb<T>: From<B>,
+    Rgba<T>: From<A>,
+    Rgba<T>: From<B>,
 {
     let mut image = RgbImage::new(256, 64);
 

examples/shade.rs

@@ -8,7 +8,7 @@ use image::{RgbImage, GenericImage};
 
 fn main() {
     //The same color in linear RGB, CIE L*a*b*, and HSV
-    let rgb = Rgb::rgb(0.5, 0.0, 0.0);
+    let rgb = Rgb::new(0.5, 0.0, 0.0);
     let lab = Lab::from(rgb);
     let hsv = Hsv::from(rgb);
 

src/alpha.rs

@@ -0,0 +1,193 @@
+use std::ops::{Deref, DerefMut, Add, Sub, Mul, Div};
+
+use num::Float;
+
+use {Mix, Shade, GetHue, Hue, Saturate};
+
+///An alpha component wrapper for colors.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Alpha<C, T: Float> {
+    ///The color.
+    pub color: C,
+
+    ///The transparency component. 0.0 is fully transparent and 1.0 is fully
+    ///opaque.
+    pub alpha: T,
+}
+
+impl<C, T: Float> Deref for Alpha<C, T> {
+    type Target = C;
+
+    fn deref(&self) -> &C {
+        &self.color
+    }
+}
+
+impl<C, T: Float> DerefMut for Alpha<C, T> {
+    fn deref_mut(&mut self) -> &mut C {
+        &mut self.color
+    }
+}
+
+impl<C: Mix> Mix for Alpha<C, C::Scalar> {
+    type Scalar = C::Scalar;
+    
+    fn mix(&self, other: &Alpha<C, C::Scalar>, factor: C::Scalar) -> Alpha<C, C::Scalar> {
+        Alpha {
+            color: self.color.mix(&other.color, factor),
+            alpha: self.alpha + factor * (other.alpha - self.alpha),
+        }
+    }
+}
+
+impl<C: Shade> Shade for Alpha<C, C::Scalar> {
+    type Scalar = C::Scalar;
+
+    fn lighten(&self, amount: C::Scalar) -> Alpha<C, C::Scalar> {
+        Alpha {
+            color: self.color.lighten(amount),
+            alpha: self.alpha,
+        }
+    }
+}
+
+impl<C: GetHue, T: Float> GetHue for Alpha<C, T> {
+    type Hue = C::Hue;
+
+    fn get_hue(&self) -> Option<C::Hue> {
+        self.color.get_hue()
+    }
+}
+
+impl<C: Hue, T: Float> Hue for Alpha<C, T> {
+    fn with_hue(&self, hue: C::Hue) -> Alpha<C, T> {
+        Alpha {
+            color: self.color.with_hue(hue),
+            alpha: self.alpha,
+        }
+    }
+
+    fn shift_hue(&self, amount: C::Hue) -> Alpha<C, T> {
+        Alpha {
+            color: self.color.shift_hue(amount),
+            alpha: self.alpha,
+        }
+    }
+}
+
+impl<C: Saturate> Saturate for Alpha<C, C::Scalar> {
+    type Scalar = C::Scalar;
+
+    fn saturate(&self, factor: C::Scalar) -> Alpha<C, C::Scalar> {
+        Alpha {
+            color: self.color.saturate(factor),
+            alpha: self.alpha,
+        }
+    }
+}
+
+impl<C: Default, T: Float> Default for Alpha<C, T> {
+    fn default() -> Alpha<C, T> {
+        Alpha {
+            color: C::default(),
+            alpha: T::one(),
+        }
+    }
+}
+
+impl<C: Add, T: Float> Add for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn add(self, other: Alpha<C, T>) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color + other.color,
+            alpha: self.alpha + other.alpha,
+        }
+    }
+}
+
+impl<T: Float + Clone, C: Add<T>> Add<T> for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn add(self, c: T) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color + c.clone(),
+            alpha: self.alpha + c,
+        }
+    }
+}
+
+impl<C: Sub, T: Float> Sub for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn sub(self, other: Alpha<C, T>) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color - other.color,
+            alpha: self.alpha - other.alpha,
+        }
+    }
+}
+
+impl<T: Float + Clone, C: Sub<T>> Sub<T> for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn sub(self, c: T) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color - c.clone(),
+            alpha: self.alpha - c,
+        }
+    }
+}
+
+impl<C: Mul, T: Float> Mul for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn mul(self, other: Alpha<C, T>) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color * other.color,
+            alpha: self.alpha * other.alpha,
+        }
+    }
+}
+
+impl<T: Float + Clone, C: Mul<T>> Mul<T> for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn mul(self, c: T) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color * c.clone(),
+            alpha: self.alpha * c,
+        }
+    }
+}
+
+impl<C: Div, T: Float> Div for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn div(self, other: Alpha<C, T>) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color / other.color,
+            alpha: self.alpha / other.alpha,
+        }
+    }
+}
+
+impl<T: Float + Clone, C: Div<T>> Div<T> for Alpha<C, T> {
+    type Output = Alpha<C::Output, T>;
+
+    fn div(self, c: T) -> Alpha<C::Output, T> {
+        Alpha {
+            color: self.color / c.clone(),
+            alpha: self.alpha / c,
+        }
+    }
+}
+
+impl<C, T: Float> From<C> for Alpha<C, T> {
+    fn from(color: C) -> Alpha<C, T> {
+        Alpha {
+            color: color,
+            alpha: T::one(),
+        }
+    }
+}

src/gradient.rs

@@ -314,7 +314,7 @@ mod test {
 
     #[test]
     fn simple_slice() {
-        let g1 = Gradient::new(vec![Rgb::rgb(1.0, 0.0, 0.0), Rgb::rgb(0.0, 0.0, 1.0)]);
+        let g1 = Gradient::new(vec![Rgb::new(1.0, 0.0, 0.0), Rgb::new(0.0, 0.0, 1.0)]);
         let g2 = g1.slice(..0.5);
 
         let v1: Vec<_> = g1.take(10).take(5).collect();