Struct QuantizationResult

pub struct QuantizationResult { /* private fields */ }

Remapping step, computed from Attributes::quantize()

Implementations

impl QuantizationResult

pub fn set_dithering_level(&mut self, value: f32) -> Result<(), Error>

Set to 1.0 to get nice smooth image

pub fn set_output_gamma(&mut self, value: f64) -> Result<(), Error>

The default is sRGB gamma (~1/2.2)

pub fn output_gamma(&self) -> f64

Approximate gamma correction value used for the output

Colors are converted from input gamma to this gamma

pub fn quantization_quality(&self) -> Option<u8>

Number 0-100 guessing how nice the input image will look if remapped to this palette

pub fn quantization_error(&self) -> Option<f64>

Approximate mean square error of the palette

pub fn remapping_error(&self) -> Option<f64>

Approximate mean square error of the palette used for the most recent remapping

pub fn remapping_quality(&self) -> Option<u8>

Palette remapping error mapped back to 0-100 scale, same as the scale in Attributes::set_quality()

pub fn palette(&mut self) -> &[RGBA]

The final palette

It’s slighly better if you get palette from the remapped() call instead

pub fn set_progress_callback<F: Fn(f32) -> ControlFlow + Sync + Send + 'static>( &mut self, callback: F, )

Callback called at various point of processing, which gets percentage of progress done, and can return ControlFlow::Break to abort further processing

pub fn remapped( &mut self, image: &mut Image<'_>, ) -> Result<(Vec<RGBA>, Vec<u8>), Error>

Remap image into a palette + indices.

Returns the palette and a 1-byte-per-pixel uncompressed bitmap

pub fn remap_into_vec( &mut self, image: &mut Image<'_>, buf: &mut Vec<u8>, ) -> Result<Vec<RGBA>, Error>

Remap image into an existing buffer. Use remapped() if you don’t have a pre-allocated buffer to reuse.

Writes 1-byte-per-pixel uncompressed bitmap into the Vec.

Returns the palette.

pub fn remap_into( &mut self, image: &mut Image<'_>, output_buf: &mut [MaybeUninit<u8>], ) -> Result<(), Error>

Remap image into an existing buffer.

This is a low-level call for use when existing memory has to be reused. Use remapped() or remap_into_vec() if possible.

Writes 1-byte-per-pixel uncompressed bitmap into the pre-allocated buffer.

You should call palette() after this call, but not before it, because remapping refines the palette.

pub fn palette_vec(&mut self) -> Vec<RGBA>

The final palette, copied.

It’s slighly better if you get palette from the remapped() call instead

pub fn palette_len(&mut self) -> usize

Expected length of the palette

Reads the length without finalizing the colors

pub fn from_palette( attr: &Attributes, palette: &[RGBA], gamma: f64, ) -> Result<Self, Error>

Shortcut for making Histogram with add_fixed_color

Set gamma to 0. for sRGB colors.

pub fn dithering_level(&self) -> f32

Getter for the value set in [set_dithering_level]

Trait Implementations

impl Clone for QuantizationResult

fn clone(&self) -> Self

It will be without a progress callback

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

Performs copy-assignment from source.

impl Debug for QuantizationResult

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

Formats the value using the given formatter.