Struct AlphaColor 

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

A color with an alpha channel.

A color in a color space known at compile time, with an alpha channel.

The color channels are straight, i.e., they are not premultiplied by the alpha channel. See PremulColor for a color type with color channels premultiplied by the alpha channel.

See OpaqueColor for a discussion of arithmetic traits and interpolation.

Fields

components: [f32; 4]

The components, which may be manipulated directly.

The interpretation of the first three components depends on the color space. The fourth component is separate alpha.

cs: PhantomData<CS>

The color space.

Implementations

impl<CS> AlphaColor<CS>

where CS: ColorSpace,

pub const BLACK: AlphaColor<CS>

A black color.

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

pub const TRANSPARENT: AlphaColor<CS>

A transparent color.

This is a black color with full alpha.

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

pub const WHITE: AlphaColor<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; 4]) -> AlphaColor<CS>

Create a new color from the given components.

pub const fn split(self) -> (OpaqueColor<CS>, f32)

Split into opaque and alpha components.

This function is the inverse of OpaqueColor::with_alpha.

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

Set the alpha channel.

This replaces the existing alpha channel. To scale or or otherwise modify the existing alpha channel, use AlphaColor::multiply_alpha or AlphaColor::map.

let c = color::palette::css::GOLDENROD.with_alpha(0.5);
assert_eq!(0.5, c.split().1);

pub const fn discard_alpha(self) -> OpaqueColor<CS>

Split out the opaque components, discarding the alpha.

This is a shorthand for calling split.

pub fn convert<TargetCs>(self) -> AlphaColor<TargetCs>

where TargetCs: ColorSpace,

Convert a color into a different color space.

pub const fn premultiply(self) -> PremulColor<CS>

Convert a color to the corresponding premultiplied form.

pub fn lerp_rect(self, other: AlphaColor<CS>, t: f32) -> AlphaColor<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 lerp( self, other: AlphaColor<CS>, t: f32, direction: HueDirection, ) -> AlphaColor<CS>

Linearly interpolate colors, with hue fixup if needed.

pub const fn multiply_alpha(self, rhs: f32) -> AlphaColor<CS>

Multiply alpha by the given factor.

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

Scale the chroma by the given amount.

See ColorSpace::scale_chroma for more details.

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

Map components.

pub fn map_in<TargetCS>( self, f: impl Fn(f32, f32, f32, f32) -> [f32; 4], ) -> AlphaColor<CS>

where TargetCS: ColorSpace,

Map components in a given color space.

pub fn map_lightness(self, f: impl Fn(f32) -> f32) -> AlphaColor<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::{AlphaColor, Lab};

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

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

pub fn map_hue(self, f: impl Fn(f32) -> f32) -> AlphaColor<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::{AlphaColor, Oklab};

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

assert!(complementary.premultiply().difference(expected.premultiply()) < 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 RGBA 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.

Implementation note

This performs almost-correct rounding to be fast on both x86 and AArch64 hardware. Within the saturated output range of this method, 0-255, there is a single color component value where results differ: 0.0019607842. This method maps that component to integer value 1; it would more precisely be mapped to 0.

impl AlphaColor<Srgb>

pub const fn from_rgba8(r: u8, g: u8, b: u8, a: u8) -> AlphaColor<Srgb>

Create a color from 8-bit rgba values.

Note: for conversion from the Rgba8 type, just use the From trait.

pub const fn from_rgb8(r: u8, g: u8, b: u8) -> AlphaColor<Srgb>

Create a color from 8-bit rgb values with an opaque alpha.

Note: for conversion from the Rgba8 type, just use the From trait.

Trait Implementations

impl<CS> Add for AlphaColor<CS>

where CS: ColorSpace,

Component-wise addition of components.

type Output = AlphaColor<CS>

The resulting type after applying the + operator.

fn add(self, rhs: AlphaColor<CS>) -> AlphaColor<CS>

Performs the + operation.

impl<CS> BitEq for AlphaColor<CS>

fn bit_eq(&self, other: &AlphaColor<CS>) -> bool

Returns true if self is equal to other.

impl<CS> BitHash for AlphaColor<CS>

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

where H: Hasher,

Feeds this value into the given Hasher.

impl<CS> Clone for AlphaColor<CS>

where CS: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<CS> Debug for AlphaColor<CS>

where CS: Debug,

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

Formats the value using the given formatter.

impl<CS> Div<f32> for AlphaColor<CS>

where CS: ColorSpace,

Divide components by a scalar.

type Output = AlphaColor<CS>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> AlphaColor<CS>

Performs the / operation.

impl<CS> From<AlphaColor<CS>> for DynamicColor

where CS: ColorSpace, ColorSpaceTag: From<CS>,

Note that the conversion is only lossless for color spaces that have a corresponding tag. This is why we have this additional trait bound. See also https://github.com/linebender/color/pull/155 for more discussion.

fn from(value: AlphaColor<CS>) -> DynamicColor

Converts to this type from the input type.

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

where CS: ColorSpace,

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

Converts to this type from the input type.

impl From<Rgba> for AlphaColor<Srgb>

fn from(value: Rgba) -> AlphaColor<Srgb>

Converts to this type from the input type.

impl From<Rgba8> for AlphaColor<Srgb>

fn from(value: Rgba8) -> AlphaColor<Srgb>

Converts to this type from the input type.

impl<CS> FromStr for AlphaColor<CS>

where CS: ColorSpace,

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<AlphaColor<CS>, <AlphaColor<CS> as FromStr>::Err>

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

impl<CS> Interpolatable for AlphaColor<CS>

where CS: ColorSpace,

fn lerp(&self, target: &AlphaColor<CS>, t: f64) -> AlphaColor<CS>

Lerping between values

impl<CS> Mul<f32> for AlphaColor<CS>

where CS: ColorSpace,

Multiply components by a scalar.

type Output = AlphaColor<CS>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> AlphaColor<CS>

Performs the * operation.

impl<CS> PartialEq for AlphaColor<CS>

where CS: ColorSpace,

fn eq(&self, other: &AlphaColor<CS>) -> 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> Sub for AlphaColor<CS>

where CS: ColorSpace,

Component-wise subtraction of components.

type Output = AlphaColor<CS>

The resulting type after applying the - operator.

fn sub(self, rhs: AlphaColor<CS>) -> AlphaColor<CS>

Performs the - operation.

impl<CS> Copy for AlphaColor<CS>

where CS: Copy,