Struct FromLinearLut 

pub struct FromLinearLut<L, E, F, T>
where
    T: LutType<<E as GammaLutOutput>::TableValue>,
    <T as LutType<<E as GammaLutOutput>::TableValue>>::Table: Sized,
    E: GammaLutOutput,
{ /* private fields */ }

Lookup table from linear to gamma encoded values.

L and E are the linear and encoded types, F is the transfer function, and T determines the storage type for the table.

use palette::{LinSrgb, SrgbLuma, LinLuma, encoding, math::lut::VecTable};

// Accessing a pre-generated lookup table:
let lut = encoding::Srgb::get_f32_to_u8_lut();
let encoded = lut.lookup_rgb(LinSrgb::new(0.3, 0.8, 0.1));

// Generating a new lookup table, allocated as a Vec:
let lut = encoding::FromLinearLut::<f32, _, _, VecTable>::new_u8();
let encoded = lut.lookup_rgb(LinSrgb::new(0.3, 0.8, 0.1));

// Looking up a Luma value:
let lut = encoding::Srgb::get_f32_to_u8_lut();
let encoded: SrgbLuma<_> = lut.lookup_luma(LinLuma::new(0.3));

Implementations

impl<L, F, T> FromLinearLut<L, u8, F, T>

where T: LutType<u32>, <T as LutType<u32>>::Table: Sized,

pub fn new_u8() -> FromLinearLut<L, u8, F, T>

where F: GetLutBuilder, <T as LutType<u32>>::Table: FromIterator<u32>,

Generate a new lookup table that encodes into u8 values.

impl<L, F, T> FromLinearLut<L, u16, F, T>

where T: LutType<u64>, <T as LutType<u64>>::Table: Sized,

pub fn new_u16() -> FromLinearLut<L, u16, F, T>

where F: GetLutBuilder, <T as LutType<u64>>::Table: FromIterator<u64>,

Generate a new lookup table that encodes into u16 values.

impl<L, E, F, T> FromLinearLut<L, E, F, T>

where T: LutType<<E as GammaLutOutput>::TableValue>, <T as LutType<<E as GammaLutOutput>::TableValue>>::Table: Sized, E: GammaLutOutput,

pub const fn from_table(table: GammaLut<L, E, T>) -> FromLinearLut<L, E, F, T>

Create a lookup table from a component lookup table.

The input table will not be verified for correctness and may result in unintended values if it’s not for the intended transfer function. This function is primarily useful for code generation.

pub fn lookup_rgb<S>(&self, encoded: Rgb<Linear<S>, L>) -> Rgb<S, E>

where L: GammaLutInput, S: RgbStandard<TransferFn = F>,

Get an RGB value from the table.

pub fn lookup_luma<S>(&self, encoded: Luma<Linear<S>, L>) -> Luma<S, E>

where L: GammaLutInput, S: LumaStandard<TransferFn = F>,

Get a luma from in the table.

Trait Implementations

impl<L, E, S, T> Convert<Luma<Linear<S>, L>, Luma<S, E>> for FromLinearLut<L, E, <S as LumaStandard>::TransferFn, T>

where L: GammaLutInput, E: GammaLutOutput, T: LutType<<E as GammaLutOutput>::TableValue>, <T as LutType<<E as GammaLutOutput>::TableValue>>::Table: Sized, S: LumaStandard,

fn convert(&self, input: Luma<Linear<S>, L>) -> Luma<S, E>

Convert an input value of type I to a value of type O.

impl<L, E, S, T> Convert<Rgb<Linear<S>, L>, Rgb<S, E>> for FromLinearLut<L, E, <S as RgbStandard>::TransferFn, T>

where L: GammaLutInput, E: GammaLutOutput, T: LutType<<E as GammaLutOutput>::TableValue>, <T as LutType<<E as GammaLutOutput>::TableValue>>::Table: Sized, S: RgbStandard,

fn convert(&self, input: Rgb<Linear<S>, L>) -> Rgb<S, E>

Convert an input value of type I to a value of type O.

impl<L, E, S, T> ConvertOnce<Luma<Linear<S>, L>, Luma<S, E>> for FromLinearLut<L, E, <S as LumaStandard>::TransferFn, T>

where L: GammaLutInput, E: GammaLutOutput, T: LutType<<E as GammaLutOutput>::TableValue>, <T as LutType<<E as GammaLutOutput>::TableValue>>::Table: Sized, S: LumaStandard,

fn convert_once(self, input: Luma<Linear<S>, L>) -> Luma<S, E>

Convert an input value of type I to a value of type O, while consuming itself.

impl<L, E, S, T> ConvertOnce<Rgb<Linear<S>, L>, Rgb<S, E>> for FromLinearLut<L, E, <S as RgbStandard>::TransferFn, T>

where L: GammaLutInput, E: GammaLutOutput, T: LutType<<E as GammaLutOutput>::TableValue>, <T as LutType<<E as GammaLutOutput>::TableValue>>::Table: Sized, S: RgbStandard,

fn convert_once(self, input: Rgb<Linear<S>, L>) -> Rgb<S, E>

Convert an input value of type I to a value of type O, while consuming itself.