Enum LumaCoefficients 

#[non_exhaustive]
pub enum LumaCoefficients {
    Bt709,
    Bt601,
    Bt2020,
    DisplayP3,
}

Luma coefficients for RGB→Gray conversion.

Use coefficients() to get the concrete [f32; 3] weights for each variant.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Bt709

BT.709: 0.2126R + 0.7152G + 0.0722B (HDTV, sRGB).

Bt601

BT.601: 0.299R + 0.587G + 0.114B (SDTV, JPEG).

Bt2020

BT.2020 / BT.2100: 0.2627R + 0.6780G + 0.0593B (UHDTV, wide gamut).

BT.2100 (HDR) uses the same primaries as BT.2020, so this is the variant to use for both SDR BT.2020 and HDR BT.2100 content.

DisplayP3

Display P3 (DCI-P3 primaries + D65): 0.2289746R + 0.6917385G + 0.0792869B (Apple wide-gamut consumer displays).

Unlike BT.709 and BT.2020, no ITU recommendation prescribes these weights — they are derived as the middle (Y) row of the DisplayP3→XYZ matrix from the P3 primaries and D65 white point, and match what libultrahdr and other HDR tooling use in practice for RGB→luma on DisplayP3 content.

Implementations

impl LumaCoefficients

pub const fn coefficients(self) -> [f32; 3]

Return the [R, G, B] weights for this luma recipe.

• Bt709: [0.2126, 0.7152, 0.0722]
• Bt601: [0.299, 0.587, 0.114]
• Bt2020: [0.2627, 0.6780, 0.0593] (same as BT.2100)
• DisplayP3: [0.2289746, 0.6917385, 0.0792869]

The three weights always sum to exactly 1.0 in IEEE 754 double precision, but may sum to 1.0 ± 1 ULP in f32. Callers that need the weights to sum to exactly 1.0 in f32 should use double-precision accumulation in their inner loop.

Trait Implementations

impl Clone for LumaCoefficients

fn clone(&self) -> LumaCoefficients

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LumaCoefficients

impl Debug for LumaCoefficients

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

Formats the value using the given formatter.

impl Eq for LumaCoefficients

impl Hash for LumaCoefficients

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LumaCoefficients

fn eq(&self, other: &LumaCoefficients) -> 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 StructuralPartialEq for LumaCoefficients