Enum NonSeperableBlendMode 

pub enum NonSeperableBlendMode {
    Hue,
    Saturation,
    Color,
    Luminosity,
}

Since the nonseparable blend modes consider all color components in combination, their computation depends on the blending color space in which the components are interpreted. They may be applied to all multiple-component color spaces that are allowed as blending color spaces (see Section 7.2.3, “Blending Color Space”).

All of these blend modes conceptually entail the following steps:

1. Convert the backdrop and source colors from the blending color space to an intermediate HSL (hue-saturation-luminosity) representation.
2. Create a new color from some combination of hue, saturation, and luminosity components selected from the backdrop and source colors.
3. Convert the result back to the original (blending) color space.

However, the formulas given below do not actually perform these conversions. Instead, they start with whichever color (backdrop or source) is providing the hue for the result; then they adjust this color to have the proper saturation and luminosity.

For RGB color spaces

The nonseparable blend mode formulas make use of several auxiliary functions. These functions operate on colors that are assumed to have red, green, and blue components.

fn luminosity(input: Rgb) -> f32 {
    0.3 * input.r + 0.59 * input.g + 0.11 * input.b
}

fn set_luminosity(input: Rgb, target_luminosity: f32) -> Rgb {
    let d = target_luminosity - luminosity(input);
    Rgb {
        r: input.r + d,
        g: input.g + d,
        b: input.b + d,
        icc_profile: input.icc_profile,
    }
}

fn clip_color(mut input: Rgb) -> Rgb {

    let lum = luminosity(input);

    let mut cur_r = (input.r * 1000.0) as i64;
    let mut cur_g = (input.g * 1000.0) as i64;
    let mut cur_b = (input.b * 1000.0) as i64;

    /// min! and max! is defined in printpdf/src/glob_macros.rs
    let mut min = min!(cur_r, cur_g, cur_b);
    let mut max = max!(cur_r, cur_g, cur_b);

    let new_min = (min as f32) / 1000.0;
    let new_max = (max as f32) / 1000.0;

    if new_min < 0.0 {
        input.r = lum + (((input.r - lum) * lum) / (lum - new_min));
        input.g = lum + (((input.g - lum) * lum) / (lum - new_min));
        input.b = lum + (((input.b - lum) * lum) / (lum - new_min));
    } else if new_max > 1.0 {
        input.r = lum + ((input.r - lum) * (1.0 - lum) / (new_max - lum));
        input.g = lum + ((input.g - lum) * (1.0 - lum) / (new_max - lum));
        input.b = lum + ((input.b - lum) * (1.0 - lum) / (new_max - lum));
    }

    return input;
}

fn saturation(input: Rgb) -> f32 {
    let mut cur_r = (input.r * 1000.0) as i64;
    let mut cur_g = (input.g * 1000.0) as i64;
    let mut cur_b = (input.b * 1000.0) as i64;

    /// min! and max! is defined in printpdf/src/glob_macros.rs
    let mut min = min!(cur_r, cur_g, cur_b);
    let mut max = max!(cur_r, cur_g, cur_b);

    let new_min = (min as f32) / 1000.0;
    let new_max = (max as f32) / 1000.0;
    new_max - new_min
}

For CMYK color spaces

The C, M, and Y components are converted to their complementary R, G, and B components in the usual way. The formulas above are applied to the RGB color values. The results are converted back to C, M, and Y.

For the K component, the result is the K component of Cb for the Hue, Saturation, and Color blend modes; it is the K component of Cs for the Luminosity blend mode.

Variants

Hue

Saturation

Color

Luminosity

Trait Implementations

impl Clone for NonSeperableBlendMode

fn clone(&self) -> NonSeperableBlendMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NonSeperableBlendMode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NonSeperableBlendMode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NonSeperableBlendMode

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for NonSeperableBlendMode

impl StructuralPartialEq for NonSeperableBlendMode