Struct Lut 

pub struct Lut {
    pub title: Option<String>,
    pub size: usize,
    pub domain_min: [f32; 3],
    pub domain_max: [f32; 3],
    pub data: Vec<[f32; 3]>,
    pub path: Option<PathBuf>,
}

A 3D LUT: size^3 RGB entries, red varying fastest (.cube order).

Fields

title: Option<String>

size: usize

domain_min: [f32; 3]

domain_max: [f32; 3]

data: Vec<[f32; 3]>

size^3 entries, index r + g * size + b * size * size.

path: Option<PathBuf>

Where it was loaded from, if anywhere.

Implementations

impl Lut

pub fn from_cube_file(path: impl AsRef<Path>) -> Result<Lut, Error>

Reads an Adobe/Resolve .cube 3D LUT.

pub fn mixed(self, strength: f32) -> Lut

This LUT mixed with identity by strength (0..1, lut_strength): each lattice entry moved from its identity value (in the LUT’s domain) towards its own by strength.

pub fn identity(size: usize) -> Lut

The identity LUT of the given size.

pub fn at(&self, r: usize, g: usize, b: usize) -> [f32; 3]

Nearest-entry lookup at lattice coordinates (for tests and debugging; the GPU interpolates).

pub fn sample(&self, rgb: [f32; 3]) -> [f32; 3]

Trilinear lookup of rgb (in the LUT’s domain, clamped to it): how libplacebo samples a pl_custom_lut (a linearly filtered 3D texture), so baked LUTs agree with the GPU.

pub fn with_input_gain(&self, gain: [f32; 3]) -> Lut

This LUT after a per-channel gain on its input, clamped to 0..1 (ffmpeg’s colorchannelmixer rr:gg:bb ahead of lut3d), resampled on the same lattice.

pub fn to_cube(&self) -> String

The LUT as .cube text (TITLE, LUT_3D_SIZE, the domain if not 0..1, then entries).

pub fn write_cube(&self, path: &Path) -> Result<(), Error>

Writes the LUT as a .cube file.

Trait Implementations

impl Clone for Lut

fn clone(&self) -> Lut

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Lut

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

Formats the value using the given formatter.

impl PartialEq for Lut

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Lut