Struct PaletteCounts 

pub struct PaletteCounts<Color> { /* private fields */ }

A palette of colors and their corresponding counts.

Certain algorithms are faster when operating on deduplicated data, in which case PaletteCounts will be a supported input. To create a PaletteCounts, see the dedup module or PaletteCounts::new.

Implementations

impl<Color> PaletteCounts<Color>

pub fn new( palette: Vec<Color>, counts: Vec<u32>, ) -> Result<Self, CreatePaletteCountsError<Color>>

Create a new PaletteCounts from a Vec of palette colors and a Vec of corresponding counts.

Errors

The provided palette and counts are returned as an Err if any of the following are true:

• The length of palette and counts do not match.
• The sum of counts is greater than MAX_PIXELS (overflows a u32).

pub fn into_parts(self) -> (Vec<Color>, Vec<u32>)

Consume a PaletteCounts and return the inner Vec of palette colors and Vec of counts.

pub fn palette(&self) -> &[Color]

Returns a slice of the inner palette colors.

To get a mutable slice, see palette_mut. To get an owned Vec, see into_parts.

pub fn palette_mut(&mut self) -> &mut [Color]

Returns a mutable slice of the inner palette colors.

To get an immutable slice, see palette. To get an owned Vec, see into_parts.

pub fn counts(&self) -> &[u32]

Returns a slice of the inner counts.

To get an owned Vec, see into_parts.

pub fn total_count(&self) -> u32

Returns the sum of the counts for all palette colors.

This operation is O(1). The total count is calculated on creation and never changes.

pub fn replace_palette<NewColor>( self, palette: Vec<NewColor>, ) -> Result<(PaletteCounts<NewColor>, Vec<Color>), (Self, Vec<NewColor>)>

Replace the palette of a PaletteCounts to a different color type (or to new colors of the same type).

Errors

If the length of the provided palette does not match the length of the current palette in the PaletteCounts, then self and palette are returned as an Err. Otherwise, the new PaletteCounts is returned alongside the old palette.

pub fn map<NewColor>( self, mapping: impl FnOnce(Vec<Color>) -> Vec<NewColor>, ) -> PaletteCounts<NewColor>

Map the palette of a PaletteCounts, reusing the existing counts.

See map_ref to instead clone the existing counts and retain the original PaletteCounts.

Rather than being a function from Color -> NewColor, mapping takes the whole palette as input and returns a new palette. This is to allow batch or parallel mappings.

Examples

It is recommended to do batch mappings for efficiency where it makes sense. E.g., using the color space conversion functions from the color_space module.

use quantette::color_space::srgb8_to_oklab;
let srgb_counts = PaletteCounts::<Srgb<u8>>::default();
let oklab_counts = srgb_counts.map(|palette| srgb8_to_oklab(&palette));

To instead map each color one at a time, use into_iter, map, and collect like normal:

let srgb_counts = PaletteCounts::<Srgb<u8>>::default();
let lin_srgb_counts: PaletteCounts<LinSrgb> =
    srgb_counts.map(|palette| palette.into_iter().map(|srgb| srgb.into_linear()).collect());

Panics

Panics if mapping returns a palette with a different length than the original palette.

pub fn map_ref<NewColor>( &self, mapping: impl FnOnce(&[Color]) -> Vec<NewColor>, ) -> PaletteCounts<NewColor>

Map the palette colors of a PaletteCounts to a new PaletteCounts, cloning the counts in the process.

See map to instead consume the original PaletteCounts and avoid a clone of the counts.

Rather than being a function from Color -> NewColor, mapping takes the whole palette as input and returns a new palette. This is to allow batch or parallel mappings.

Examples

It is recommended to do batch mappings for efficiency where it makes sense. E.g., using the color space conversion functions from the color_space module.

use quantette::color_space::srgb8_to_oklab;
let srgb_counts = PaletteCounts::<Srgb<u8>>::default();
let oklab_counts = srgb_counts.map_ref(srgb8_to_oklab);

To instead map each color one at a time, use iter, map, and collect like normal:

let srgb_counts = PaletteCounts::<Srgb<u8>>::default();
let lin_srgb_counts: PaletteCounts<LinSrgb> =
    srgb_counts.map_ref(|palette| palette.iter().map(|srgb| srgb.into_linear()).collect());

Panics

Panics if mapping returns a palette with a different length than the original palette.

Trait Implementations

impl<Color: Clone> Clone for PaletteCounts<Color>

fn clone(&self) -> PaletteCounts<Color>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Color: Debug> Debug for PaletteCounts<Color>

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

Formats the value using the given formatter.

impl<Color> Default for PaletteCounts<Color>

fn default() -> Self

Returns the “default value” for a type.

impl<Color: Hash> Hash for PaletteCounts<Color>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Color: PartialEq> PartialEq for PaletteCounts<Color>

fn eq(&self, other: &PaletteCounts<Color>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Color: Eq> Eq for PaletteCounts<Color>

impl<Color> StructuralPartialEq for PaletteCounts<Color>