Struct OpaqueColor

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

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: ColorSpace> OpaqueColor<CS>

pub const BLACK: Self

A black color.

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

pub const WHITE: Self

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]) -> Self

Create a new color from the given components.

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

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: Self) -> f32

Difference between two colors by Euclidean metric.

pub fn lerp_rect(self, other: Self, t: f32) -> Self

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 Self, 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: Self, t: f32, direction: HueDirection) -> Self

Linearly interpolate colors, with hue fixup if needed.

pub fn scale_chroma(self, scale: f32) -> Self

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]) -> Self

Map components.

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

Map components in a given color space.

pub fn map_lightness(self, f: impl Fn(f32) -> f32) -> Self

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) -> Self

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.

Implementation note

This performs almost-correct rounding, see the note on AlphaColor::to_rgba8.

impl OpaqueColor<Srgb>

pub const fn from_rgb8(r: u8, g: u8, b: u8) -> Self

Create a color from 8-bit rgb values.

Trait Implementations

impl<CS: ColorSpace> Add for OpaqueColor<CS>

Component-wise addition of components.

type Output = OpaqueColor<CS>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<CS> BitEq for OpaqueColor<CS>

fn bit_eq(&self, other: &Self) -> bool

Returns true if self is equal to other.

impl<CS> BitHash for OpaqueColor<CS>

fn bit_hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl<CS: Clone> Clone for OpaqueColor<CS>

fn clone(&self) -> OpaqueColor<CS>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<CS: Debug> Debug for OpaqueColor<CS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<CS: ColorSpace> Div<f32> for OpaqueColor<CS>

Divide components by a scalar.

type Output = OpaqueColor<CS>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self

Performs the / operation.

impl<CS: ColorSpace> From<OpaqueColor<CS>> for AlphaColor<CS>

fn from(value: OpaqueColor<CS>) -> Self

Converts to this type from the input type.

impl<CS: ColorSpace> From<OpaqueColor<CS>> for PremulColor<CS>

fn from(value: OpaqueColor<CS>) -> Self

Converts to this type from the input type.

impl<CS: ColorSpace> FromStr for OpaqueColor<CS>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<CS: ColorSpace> Mul<OpaqueColor<CS>> for f32

Multiply components by a scalar.

type Output = OpaqueColor<CS>

The resulting type after applying the * operator.

fn mul(self, rhs: OpaqueColor<CS>) -> Self::Output

Performs the * operation.

impl<CS: ColorSpace> Mul<f32> for OpaqueColor<CS>

Multiply components by a scalar.

type Output = OpaqueColor<CS>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self

Performs the * operation.

impl<CS: ColorSpace> PartialEq for OpaqueColor<CS>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<CS: ColorSpace> Sub for OpaqueColor<CS>

Component-wise subtraction of components.

type Output = OpaqueColor<CS>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<CS: ColorSpace> TransparentWrapper<[f32; 3]> for OpaqueColor<CS>

fn wrap(s: Inner) -> Self

where Self: Sized,

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<CS: ColorSpace> Zeroable for OpaqueColor<CS>

fn zeroed() -> Self

Calls zeroed.

impl<CS: Copy> Copy for OpaqueColor<CS>

impl<CS: ColorSpace> Pod for OpaqueColor<CS>