Struct Image 

pub struct Image<Color, Container> { /* private fields */ }

The base image type parameterized by the type of the container.

Typically you want to use one of the other image types with a defined container:

• ImageBuf: an owned image backed by a Vec.
• ImageRef: a borrowed image backed by an immutable slice reference.
• ImageMut: a mutable, borrowed image backed by a mutable slice reference.

Implementations

impl<Color, Container> Image<Color, Container>

pub fn dimensions(&self) -> (u32, u32)

Returns the width and height of the Image.

pub fn width(&self) -> u32

Returns the width of the Image.

pub fn height(&self) -> u32

Returns the height of the Image.

pub fn is_empty(&self) -> bool

Returns whether the Image has zero pixels.

pub fn as_inner(&self) -> &Container

Returns a reference to the underlying pixel container.

pub fn into_inner(self) -> Container

Returns the underlying pixel container.

impl<Color, Container: AsRef<[Color]>> Image<Color, Container>

pub fn new( width: u32, height: u32, pixels: Container, ) -> Result<Self, CreateImageBufError<Container>>

Create a new Image from a width, a height, and a Container of pixels.

Errors

The provided pixels is returned as an Err if any of the following are true:

• The length of pixels and width * height do not match.
• width * height overflows a u32.

pub fn num_pixels(&self) -> u32

Returns the number of pixels in the Image specified by width * height.

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

Returns a reference to the underlying pixels as a slice.

pub fn as_ref(&self) -> ImageRef<'_, Color>

Convert an Image to an ImageRef.

pub fn to_owned(&self) -> Image<Color, Container::Owned>

where Container: ToOwned, Container::Owned: AsRef<[Color]>,

Convert an Image to an owned ImageBuf.

pub fn map<NewColor, NewContainer>( self, mapping: impl FnOnce(Container) -> NewContainer, ) -> Image<NewColor, NewContainer>

where NewContainer: AsRef<[NewColor]>,

Map the pixel buffer of an Image to new buffer type and/or color type.

Rather than being a function from Color -> NewColor, mapping takes the whole pixel buffer and returns a new buffer. 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_image = ImageBuf::<Srgb<u8>>::default();
let oklab_image = srgb_image.map(|pixels| srgb8_to_oklab(&pixels));

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

let srgb_image = ImageBuf::<Srgb<u8>>::default();
let lin_srgb_image: ImageBuf<LinSrgb> =
    srgb_image.map(|pixels| pixels.into_iter().map(|srgb| srgb.into_linear()).collect());

Panics

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

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

where NewContainer: AsRef<[NewColor]>,

Map the pixel buffer of an Image to new buffer type and/or color type.

Rather than being a function from Color -> NewColor, mapping takes the whole pixel slice and returns a new buffer. 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_image = ImageBuf::<Srgb<u8>>::default();
let oklab_image = srgb_image.map_ref(srgb8_to_oklab);

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

let srgb_image = ImageBuf::<Srgb<u8>>::default();
let lin_srgb_image: ImageBuf<LinSrgb> =
    srgb_image.map_ref(|palette| palette.iter().map(|srgb| srgb.into_linear()).collect());

Panics

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

pub fn map_to_image<ColorMap: IndexedColorMap<Color>>( &self, color_map: ColorMap, ) -> ImageBuf<ColorMap::Output>

Map the pixel buffer of an Image using the provided IndexedColorMap.

Panics

Panics if color_map is not a valid implementor of IndexedColorMap. That is, it returns a Vec with a different length than the input slice.

pub fn map_to_indexed<ColorMap: IndexedColorMap<Color>>( &self, color_map: ColorMap, ) -> IndexedImage<ColorMap::Output>

Convert an Image to an IndexedImage using the provided IndexedColorMap.

Panics

Panics if color_map is not a valid implementor of IndexedColorMap. That is, it returns a Vec with a different length than the input slice.

impl<Color, Container: AsMut<[Color]>> Image<Color, Container>

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

Returns a mutable reference to the underlying pixels as a mutable slice.

pub fn as_mut(&mut self) -> ImageMut<'_, Color>

Convert an Image to an ImageMut.

impl<Color: Zeroable> Image<Color, Vec<Color>>

pub fn zeroed(width: u32, height: u32) -> Option<Self>

Create a new ImageBuf from zeroed memory.

Returns None if width * height overflows a u32.

impl<Color: Clone> Image<Color, Vec<Color>>

pub fn from_pixel(width: u32, height: u32, pixel: Color) -> Option<Self>

Create a new ImageBuf by cloning a specific color.

Returns None if width * height overflows a u32.

Trait Implementations

impl<Color: Clone, Container: Clone> Clone for Image<Color, Container>

fn clone(&self) -> Image<Color, Container>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Color: Debug, Container: Debug> Debug for Image<Color, Container>

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

Formats the value using the given formatter.

impl<Component> From<Image<Rgb<Srgb, Component>, Vec<Rgb<Srgb, Component>>>> for ImageBuffer<Rgb<Component>, Vec<Component>>

where Srgb<Component>: ArrayCast, <Srgb<Component> as ArrayCast>::Array: ArrayExt<Item = Component>, Rgb<Component>: Pixel<Subpixel = Component>, Vec<Component>: Deref<Target = [<Rgb<Component> as Pixel>::Subpixel]>,

fn from(image: ImageBuf<Srgb<Component>>) -> Self

Converts to this type from the input type.

impl<Color, Container> Hash for Image<Color, Container>

where Color: Hash, Container: AsRef<[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<ColorA, ColorB, ContainerA, ContainerB> PartialEq<Image<ColorB, ContainerB>> for Image<ColorA, ContainerA>

where ColorA: PartialEq<ColorB>, ContainerA: AsRef<[ColorA]>, ContainerB: AsRef<[ColorB]>,

fn eq(&self, other: &Image<ColorB, ContainerB>) -> 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: Copy, Container: Copy> Copy for Image<Color, Container>

impl<Color, Container> Eq for Image<Color, Container>

where Color: PartialEq<Color>, Container: AsRef<[Color]>,