Struct imagequant::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(
    &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() 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

Trait Implementations

impl Debug for QuantizationResult

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

Formats the value using the given formatter.