Struct OpaqueColor

#[repr(transparent)]pub struct OpaqueColor<CS> {
    pub components: [f32; 3],
    pub cs: PhantomData<CS>,
}

Expand description

An opaque color.

A color in a color space known at compile time, without transparency. Note that “opaque” refers to the color, not the representation; the components are publicly accessible.

Arithmetic traits are defined on this type, and operate component-wise. A major motivation for including these is to enable weighted sums, including for spline interpolation. For cylindrical color spaces, hue fixup should be applied before interpolation.

Fields§

§components: [f32; 3]

The components, which may be manipulated directly.

The interpretation of the components depends on the color space.

§cs: PhantomData<CS>

The color space.

Implementations§

§

impl<CS> OpaqueColor<CS>
where CS: ColorSpace,

pub const BLACK: OpaqueColor<CS>

A black color.

More comprehensive pre-defined colors are available in the color::palette module.

pub const WHITE: OpaqueColor<CS>

A white color.

This value is specific to the color space.

More comprehensive pre-defined colors are available in the color::palette module.

pub const fn new(components: [f32; 3]) -> OpaqueColor<CS>

Create a new color from the given components.

pub fn convert<TargetCS>(self) -> OpaqueColor<TargetCS>
where TargetCS: ColorSpace,

Convert a color into a different color space.

pub const fn with_alpha(self, alpha: f32) -> AlphaColor<CS>

Add an alpha channel.

This function is the inverse of AlphaColor::split.

pub fn difference(self, other: OpaqueColor<CS>) -> f32

Difference between two colors by Euclidean metric.

pub fn lerp_rect(self, other: OpaqueColor<CS>, t: f32) -> OpaqueColor<CS>

Linearly interpolate colors, without hue fixup.

This method produces meaningful results in rectangular color spaces, or if hue fixup has been applied.

pub fn fixup_hues(self, other: &mut OpaqueColor<CS>, direction: HueDirection)

Apply hue fixup for interpolation.

Adjust the hue angle of other so that linear interpolation results in the expected hue direction.

pub fn lerp( self, other: OpaqueColor<CS>, t: f32, direction: HueDirection, ) -> OpaqueColor<CS>

Linearly interpolate colors, with hue fixup if needed.

pub fn scale_chroma(self, scale: f32) -> OpaqueColor<CS>

Scale the chroma by the given amount.

See ColorSpace::scale_chroma for more details.

pub fn relative_luminance(self) -> f32

Compute the relative luminance of the color.

This can be useful for choosing contrasting colors, and follows the WCAG 2.1 spec.

pub fn map(self, f: impl Fn(f32, f32, f32) -> [f32; 3]) -> OpaqueColor<CS>

Map components.

pub fn map_in<TargetCS>( self, f: impl Fn(f32, f32, f32) -> [f32; 3], ) -> OpaqueColor<CS>
where TargetCS: ColorSpace,

Map components in a given color space.

pub fn map_lightness(self, f: impl Fn(f32) -> f32) -> OpaqueColor<CS>

Map the lightness of the color.

In a color space that naturally has a lightness component, map that value. Otherwise, do the mapping in Oklab. The lightness range is normalized so that 1.0 is white. That is the normal range for Oklab but differs from the range in Lab, Lch, and Hsl.

§Examples

use color::{Lab, OpaqueColor};

let color = OpaqueColor::<Lab>::new([40., 4., -17.]);
let lighter = color.map_lightness(|l| l + 0.2);
let expected = OpaqueColor::<Lab>::new([60., 4., -17.]);

assert!(lighter.difference(expected) < 1e-4);

pub fn map_hue(self, f: impl Fn(f32) -> f32) -> OpaqueColor<CS>

Map the hue of the color.

In a color space that naturally has a hue component, map that value. Otherwise, do the mapping in Oklch. The hue is in degrees.

§Examples

use color::{Oklab, OpaqueColor};

let color = OpaqueColor::<Oklab>::new([0.5, 0.2, -0.1]);
let complementary = color.map_hue(|h| (h + 180.) % 360.);
let expected = OpaqueColor::<Oklab>::new([0.5, -0.2, 0.1]);

assert!(complementary.difference(expected) < 1e-4);

pub fn to_rgba8(self) -> Rgba8

Convert the color to sRGB if not already in sRGB, and pack into 8 bit per component integer encoding.

The RGB components are mapped from the floating point range of 0.0-1.0 to the integer range of 0-255. Component values outside of this range are saturated to 0 or 255. The alpha component is set to 255.