Struct image2::ImageBuf

pub struct ImageBuf<T: Type, C: Color> { /* private fields */ }

Image implementation using Vec<T> to store data

Implementations

impl<T: Type, C: Color> ImageBuf<T, C>

pub fn new(width: usize, height: usize) -> Self

Create a new ImageBuf with the given size

pub fn inner(self) -> Vec<T>

Convert the ImageBuf back to the underlying data buffer

pub fn new_like(&self) -> Self

Create a new image with the same type, shape and color as an existing image

pub fn new_like_with_type<U: Type>(&self) -> ImageBuf<U, C>

Create a new image with the given type and the same shape and color

pub fn new_like_with_color<D: Color>(&self) -> ImageBuf<T, D>

Create a new image with the given color and the same shape and type

pub fn new_from(width: usize, height: usize, data: Vec<T>) -> Self

Create a new image from existing data

Note: This function does not do bounds checking, so you need to ensure that data is the correct length to handle the specified width and height

Trait Implementations

impl<T: Clone + Type, C: Clone + Color> Clone for ImageBuf<T, C>

fn clone(&self) -> ImageBuf<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Type, C: Debug + Color> Debug for ImageBuf<T, C>

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

Formats the value using the given formatter.

impl<'de, T, C: Color> Deserialize<'de> for ImageBuf<T, C>where
    T: Deserialize<'de> + Type,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Type, C: Color> Image<T, C> for ImageBuf<T, C>

fn shape(&self) -> (usize, usize, usize)

Returns the width, height and channels of an image

fn data(&self) -> &[T]

An immutable reference to the underlying image data

fn data_mut(&mut self) -> &mut [T]

A mutable reference to the underlying image data

fn width(&self) -> usize

fn height(&self) -> usize

fn channels(&self) -> usize

fn len(&self) -> usize

Get the number of total elements in an image

fn total_bytes(&self) -> usize

Get the total number of bytes needed to store the image data

fn index(&self, x: usize, y: usize, c: usize) -> usize

Get the offset of the component at (x, y, c)

fn empty_pixel(&self) -> Vec<T>

Create a new, empty pixel with each component set to 0

fn at_mut(&mut self, x: usize, y: usize) -> &mut [T]

Get a vector of mutable references to each component at (x, y)

fn at(&self, x: usize, y: usize) -> &[T]

Get a vector of immutable references to each component at (x, y)

fn get_pixel<'a, P: PixelMut<'a, T, C>>(&self, x: usize, y: usize, px: &mut P)

Load data from the pixel at (x, y) into px

fn get_pixel_f<'a, P: PixelMut<'a, f64, C>>(&self, x: usize, y: usize, px: &mut P)

Load data from the pixel at (x, y) into px and convert to normalized f64

fn set_pixel<'a, P: Pixel<'a, T, C>>(&mut self, x: usize, y: usize, px: &P)

Set data at (x, y) to px

fn set_pixel_f<'a, P: Pixel<'a, f64, C>>(&mut self, x: usize, y: usize, px: &P)

Set data at (x, y) to px after denormalizing

fn get_f(&self, x: usize, y: usize, c: usize) -> f64

Get a single component at (x, y, c) as a noramlized f64 value

fn set_f(&mut self, x: usize, y: usize, c: usize, f: f64)

Set the component at (x, y, c) using a normalized f64 value

fn get(&self, x: usize, y: usize, c: usize) -> T

Get a single component at (x, y, c)

fn set(&mut self, x: usize, y: usize, c: usize, t: T)

Set a single component at (x, y, c)

fn convert_type<U: Type, I: Image<U, C>>(&self, dest: &mut I)

Convert from type T to type U

fn as_image_ref(&mut self) -> ImageRef<'_, T, C>

Convert Image to ImageRef

fn to_image_ptr<'a>(self) -> ImagePtr<'a, T, C>

Consume and convert Image to ImagePtr

fn for_each<F: Sync + Send + Fn((usize, usize), &mut [T])>(&mut self, f: F)

Iterate over each pixel

fn for_each2<F: Sync + Send + Fn((usize, usize), &mut [T], &[T]), I: Image<T, C>>(
    &mut self,
    other: &I,
    f: F
)

Iterate over each pixel

fn crop(&self, x: usize, y: usize, width: usize, height: usize) -> ImageBuf<T, C>

Create a new image from the region specified by (x, y, width, height)

fn clone(&self) -> ImageBuf<T, C>

fn hash(&self) -> Hash

fn diff<I: Image<T, C>>(&self, other: &I) -> Diff

impl<T: PartialEq + Type, C: PartialEq + Color> PartialEq<ImageBuf<T, C>> for ImageBuf<T, C>

fn eq(&self, other: &ImageBuf<T, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T, C: Color> Serialize for ImageBuf<T, C>where
    T: Serialize + Type,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Type, C: Color> StructuralPartialEq for ImageBuf<T, C>