It has now been nearly three weeks since version 0.1.0 of Palette, a linear color calculation and conversion library for Rust, was released, but it has already gone through some big and important changes, so I thought it would be a good idea to describe them in a bit more detail. Let’s take a look at what’s new.
Slicing Gradients
Palette provides a Gradient type for linear color interpolation. The basic
idea is that you can define a series of control points (colors mapped to
numbers), and the Gradient will mix them to give you any color between them.
The colors beyond the endpoints of the series will be the same as at the
nearest endpoint.
The new slicing feature lets you create an other gradient, which is based on the original one, but with a different domain (or range). Everything outside this new domain will have the same color as at the nearest of its endpoints, so it’s the same behavior as before, but with new endpoints. Let’s take a look at an example:
//Create a gradient from red to blue. The default domain is 0.0 to 1.0.
let g1 = Gradient::new(vec![Rgb::new(1.0, 0.0, 0.0), Rgb::new(0.0, 0.0, 1.0)]);
//Slice it to only include the first half.
let g2 = g1.slice(..0.5);
assert_eq!(g1.get(0.0), g2.get(0.0)); //Ok
assert_eq!(g1.get(0.3), g2.get(0.3)); //Ok
assert_eq!(g1.get(0.5), g2.get(0.5)); //Ok
assert_eq!(g1.get(0.7), g2.get(0.7)); //Error!
The reason for the error is that 0.7 is outside the domain of g2, so it
gives RGB(0.5, 0.0, 0.5) (the color at 0.5) instead of RGB(0.3, 0.0, 0.7).
See the documentation for more info about Gradient.
Color Arithmetics
One of the two main purposes of Palette is doing maths with colors and that
has now been made a lot simpler. The basic arithmetic operations (+, -,
* and /) has been implemented for each color space, and allows both
another color and a plain number as the right hand side.
let a = Rgb::new(1.0, 0.5, 0.3);
let b = Rgb::new(0.1, 0.5, 0.2);
//It's now possible to do this:
let c = a * b;
//...instead of this:
let c = Rgb::new(a.red * b.red, a.green * b.green, a.blue * b.blue);
//...and this:
let c = a * 0.5;
//...instead of this:
let c = Rgb::new(a.red * 0.5, a.green * 0.5, a.blue * 0.5);
The only exceptions are the hue based colors (HSV, HSL, etc.), since multiplication and division of the hue isn’t well defined. They do still implement addition and subtraction, so they are not completely left outside.
Working With Any Float
The colors were initially represented by f32 components, which may be too
limited for some high precision applications, so every single color type was
rewritten to be based on any T: num::Float. The difference isn’t directly
apparent, since the default is still f32, but it’s now possible to use
Rgb<f64> or even Rgb<MyIncreatibelFloatType>.
The operation traits, like Mix and Shade, has been given an associated
type, called Scalar. This corresponds to the type parameter T in the color
spaces and allows some simplification when they are used together, like in
Gradient<C: Mix + Clone>.
Separating Transparency From Color
The second big change was the separation of the transparency (alpha) component
from the colors. The alpha was initially a mandatory part of each color, but
this came with increased memory usage if many colors are to be stored, so some
kind of decoupling was necessary.
One idea was to make duplicates of each color type, where one has the alpha
component and the other doesn’t. This is simple and can easily be automated.
The other idea was to make more use of the type system and create a
transparent wrapper type which would carry the alpha component. This ended
up being the final solution and comes with some interesting possibilities.
The new system introduces an Alpha<C, T: Float> type, which is defined as
pub struct Alpha<C, T: Float> {
color: C,
alpha: T,
}
This type implements all of the operation traits, as well as Deref and
DerefMut to also expose the content of color. This allows operations on
color + alpha as a whole, as well as isolated operations on just color
without any conversion. Take a look at this example from the documentation:
use palette::{Rgb, Rgba};
let mut c1 = Rgba::new(1.0, 0.5, 0.5, 0.8);
let c2 = Rgb::new(0.5, 1.0, 1.0);
c1.color = c1.color * c2; //Leave the alpha as it is
c1.blue += 0.2; //The color components can easily be accessed
c1 = c1 * 0.5; //Scale both the color and the alpha
The Rgba type is an alias for Alpha<Rgb<T>, T> and it implements the
necessary functions for it to behave in the same way as Rgb. There are also
aliases for the other color spaces.
You can read a bit more about Alpha in the documentation.
Separation of Pixel Encodings
An other important change is the separation of sRGB and gamma correction
related things from the Rgb type. The distinction between linear and non-
linear colors is now encoded into the type system as the Srgb and GammaRgb
types. They are meant as transition types when converting from a linear color
to some kind of pixel representation, and back. This change has also resulted
in a pixel module, where all the pixel format related types can be found.
See the documentation for more.
New Constructor Names
Last, but not least, is a short PSA regarding the new constructor names. The
separation of transparency, and the new RGB types made the old constructor
naming convention (like Rgb::rgb(...)) unnecessary. Each type (Rgb,
Rgba, Srgb, etc.) can now be constructed with a new function, and
sometimes with an additional new_u8 function. The Color type is mostly as
before, though, with the exception of the transparency variants.
What’s Next?
The next phase will focus on adding some new features. There are already some to-do issues that has been scheduled for version 0.2.1, including named colors, blending and the addition of xyY support. A further goal is to implement variable white points and chromatic adaption.
Palette can be found on GitHub, where contributions are most welcome, and on crates.io.
Thank you for reading this, and have fun making colorful creations!
