Struct quantette::PalettePipeline

pub struct PalettePipeline<'a> { /* private fields */ }

A builder struct to specify options to create a color palette for an image or slice of colors.

Examples

To start, create a PalettePipeline from an RgbImage (note that the image feature is needed):

let img = image::open("some image")?.into_rgb8();
let pipeline = PalettePipeline::try_from(&img)?;

A slice of colors can be used instead:

let srgb = vec![Srgb::new(0, 0, 0)];
let pipeline = PalettePipeline::new(srgb.as_slice().try_into()?);

Then, you can change different options like the number of colors in the palette:

let pipeline = pipeline.palette_size(192.into());

Or, use a more accurate color space (needs the colorspaces feature):

let pipeline = pipeline
    .palette_size(192.into())
    .colorspace(ColorSpace::Oklab);

Or, change to a more accurate quantization method (needs the kmeans feature):

let pipeline = pipeline
    .palette_size(192.into())
    .colorspace(ColorSpace::Oklab)
    .quantize_method(QuantizeMethod::Kmeans(KmeansOptions::new()));

Finally, run the pipeline:

let palette = pipeline.palette();

Or, in parallel across multiple threads (needs the threads feature):

let palette = pipeline.palette_par();

Implementations

impl<'a> PalettePipeline<'a>

pub fn new(colors: ColorSlice<'a, Srgb<u8>>) -> Self

Creates a new PalettePipeline with default options.

pub fn palette_size(self, size: PaletteSize) -> Self

Sets the palette size which determines the (maximum) number of colors to have in the palette.

The default palette size is PaletteSize::MAX.

pub fn colorspace(self, colorspace: ColorSpace) -> Self

Sets the color space to perform color quantization in.

See ColorSpace for more details.

The default color space is ColorSpace::Srgb.

pub fn quantize_method(self, quantize_method: QuantizeMethod<Srgb<u8>>) -> Self

Sets the color quantization method to use.

See QuantizeMethod for more details.

The default quantization method is QuantizeMethod::Wu.

pub fn dedup_pixels(self, dedup_pixels: bool) -> Self

Sets whether or not to deduplicate pixels in the image.

It is recommended to keep this option as default, unless the image is very small or you have reason to believe that the image contains very little redundancy (i.e., most pixels are their own unique color). quantette will only deduplicate pixels if it is worth doing so (i.e., the k-means quantization method is chosen or a color space converision is needed).

The default value is true.

impl<'a> PalettePipeline<'a>

pub fn palette(self) -> Vec<Srgb<u8>>

Runs the pipeline and returns the computed color palette.

impl<'a> PalettePipeline<'a>

pub fn palette_par(self) -> Vec<Srgb<u8>>

Runs the pipeline in parallel and returns the computed color palette.

Trait Implementations

impl<'a> Clone for PalettePipeline<'a>

fn clone(&self) -> PalettePipeline<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for PalettePipeline<'a>

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

Formats the value using the given formatter.

impl<'a> From<ImagePipeline<'a>> for PalettePipeline<'a>

fn from(value: ImagePipeline<'a>) -> Self

Converts to this type from the input type.

impl<'a> TryFrom<&'a ImageBuffer<Rgb<u8>, Vec<u8>>> for PalettePipeline<'a>

type Error = AboveMaxLen<u32>

The type returned in the event of a conversion error.

fn try_from(image: &'a RgbImage) -> Result<Self, Self::Error>

Performs the conversion.