Struct ravif::Img

source · [−]

pub struct Img<Container> {
    pub buf: Container,
    pub stride: usize,
    pub width: u32,
    pub height: u32,
}

Expand description

Basic struct used for both owned (alias ImgVec) and borrowed (alias ImgRef) image fragments.

Note: the fields are pub only because of borrow checker limitations. Please consider them as read-only.

Fields

buf: Container

👎Deprecated:

Don’t access struct fields directly. Use buf(), buf_mut() or into_buf()

Storage for the pixels. Usually Vec<Pixel> or &[Pixel]. See ImgVec and ImgRef.

Note that future version will make this field private. Use .rows() and .pixels() iterators where possible, or buf()/buf_mut()/into_buf().

stride: usize

👎Deprecated:

Don’t access struct fields directly. Use stride()

Number of pixels to skip in the container to advance to the next row.

Note: pixels between width and stride may not be usable, and may not even exist in the last row.

width: u32

👎Deprecated:

Don’t access struct fields directly. Use width()

Width of the image in pixels.

Note that this isn’t same as the width of the row in the buf, see stride

height: u32

👎Deprecated:

Don’t access struct fields directly. Use height()

Height of the image in pixels.

Implementations

source

impl<Container> Img<Container>

source

pub fn width(&self) -> usize

Width of the image in pixels.

Note that this isn’t same as the width of the row in image data, see stride()

source

pub fn height(&self) -> usize

Height of the image in pixels.

source

pub fn stride(&self) -> usize

Number of pixels to skip in the container to advance to the next row.

Note the last row may have fewer pixels than the stride. Some APIs use number of bytes for a stride. You may need to multiply this one by number of pixels.

source

pub fn buf(&self) -> &Container

Immutable reference to the pixel storage. Warning: exposes stride. Use pixels() or rows() insetad.

pub fn buf_mut(&mut self) -> &mut Container

Mutable reference to the pixel storage. Warning: exposes stride. Use pixels_mut() or rows_mut() insetad.

pub fn into_buf(self) -> Container

Get the pixel storage by consuming the image. Be careful about stride — see into_contiguous_buf() for a safe version.

source

pub fn rows_buf<'a, T>(&self, buf: &'a [T]) -> RowsIter<'a, T>where
T: 'a,

👎Deprecated:

this was meant to be private, use new_buf() and/or rows()

source

impl<'a, T> Img<&'a [T]>

source

pub fn sub_image(
 &self,
 left: usize,
 top: usize,
 width: usize,
 height: usize
) -> Img<&'a [T]>

Make a reference for a part of the image, without copying any pixels.

Panics

It will panic if sub_image is outside of the image area (left + width must be <= container width, etc.)

source

pub fn rows(&self) -> RowsIter<'_, T>

Iterate over whole rows of pixels as slices

Panics

If stride is 0

pub fn iter(&self) -> Iter<'_, T>

👎Deprecated:

Size of this buffer is unpredictable. Use .rows() instead

Deprecated

Note: it iterates all pixels in the underlying buffer, not just limited by width/height.

source

impl<'a, T> Img<&'a [T]>where
T: Clone,

source

pub fn to_contiguous_buf(&self) -> (Cow<'a, [T]>, usize, usize)

Returns a reference to the buffer, width, height. Guarantees that the buffer is contiguous, i.e. it’s width*height elements long, and [x + y*width] addresses each pixel.

It will create a copy if the buffer isn’t contiguous (width != stride). For a more efficient version, see into_contiguous_buf()

source

impl<'a, T> Img<&'a mut [T]>

source

pub fn sub_image(
 &'a mut self,
 left: usize,
 top: usize,
 width: usize,
 height: usize
) -> Img<&'a [T]>

Turn this into immutable reference, and slice a subregion of it

source

pub fn sub_image_mut(
 &mut self,
 left: usize,
 top: usize,
 width: usize,
 height: usize
) -> Img<&mut [T]>

Trim this image without copying. Note that mutable borrows are exclusive, so it’s not possible to have more than one mutable subimage at a time.

source

pub fn as_ref(&self) -> Img<&[T]>

Make mutable reference immutable

source

impl<'a, T> Img<&'a [T]>where
T: Copy,

source

pub fn pixels(&self) -> PixelsIter<'_, T>

Iterate width*height pixels in the Img, ignoring padding area

If you want to iterate in parallel, parallelize rows() instead.

Panics

if width is 0

source

impl<'a, T> Img<&'a [T]>

source

pub fn pixels_ref(&self) -> PixelsRefIter<'_, T>

Iterate width*height pixels in the Img, by reference, ignoring padding area

If you want to iterate in parallel, parallelize rows() instead.

Panics

if width is 0

source

impl<'a, T> Img<&'a mut [T]>where
T: Copy,

source

pub fn pixels(&self) -> PixelsIter<'_, T>

Panics

If you want to iterate in parallel, parallelize rows() instead.

if width is 0

source

pub fn pixels_mut(&mut self) -> PixelsIterMut<'_, T>

If you want to iterate in parallel, parallelize rows() instead.

Panics

if width is 0

source

impl<'a, T> Img<Vec<T, Global>>where
T: Copy,

source

pub fn pixels(&self) -> PixelsIter<'_, T>

If you want to iterate in parallel, parallelize rows() instead.

Panics

if width is 0

source

pub fn pixels_mut(&mut self) -> PixelsIterMut<'_, T>

If you want to iterate in parallel, parallelize rows() instead.

Panics

if width is 0

source

impl<'a, T> Img<&'a mut [T]>

source

pub fn rows(&self) -> RowsIter<'_, T>

Iterate over whole rows as slices

Panics

if stride is 0

source

pub fn rows_mut(&mut self) -> RowsIterMut<'_, T>

Iterate over whole rows as slices

Panics

if stride is 0

source

impl<T> Img<Vec<T, Global>>

source

pub fn sub_image_mut(
 &mut self,
 left: usize,
 top: usize,
 width: usize,
 height: usize
) -> Img<&mut [T]>

Create a mutable view into a region within the image. See sub_image() for read-only views.

source

pub fn sub_image(
 &self,
 left: usize,
 top: usize,
 width: usize,
 height: usize
) -> Img<&[T]>

Make a reference for a part of the image, without copying any pixels.

source

pub fn as_ref(&self) -> Img<&[T]>

Make a reference to this image to pass it to functions without giving up ownership

The reference should be passed by value (ImgRef, not &ImgRef).

If you need a mutable reference, see as_mut() and sub_image_mut()

source

pub fn as_mut(&mut self) -> Img<&mut [T]>

Make a mutable reference to the entire image

The reference should be passed by value (ImgRefMut, not &mut ImgRefMut).

See also sub_image_mut() and rows_mut()

source

pub fn iter(&self) -> Iter<'_, T>

👎Deprecated:

Size of this buffer may be unpredictable. Use .rows() instead

source

pub fn rows(&self) -> RowsIter<'_, T>

Iterate over rows of the image as slices

Each slice is guaranteed to be exactly width pixels wide.

This iterator is a good candidate for parallelization (e.g. rayon’s par_bridge())

source

pub fn rows_mut(&mut self) -> RowsIterMut<'_, T>

Iterate over rows of the image as mutable slices

Each slice is guaranteed to be exactly width pixels wide.

This iterator is a good candidate for parallelization (e.g. rayon’s par_bridge())

source

impl<Container> Img<Container>

source

pub fn new_stride(
 buf: Container,
 width: usize,
 height: usize,
 stride: usize
) -> Img<Container>

Same as new(), except each row is located stride number of pixels after the previous one.

Stride can be equal to width or larger. If it’s larger, then pixels between end of previous row and start of the next are considered a padding, and may be ignored.

The Container is usually a Vec or a slice.

source

pub fn new(buf: Container, width: usize, height: usize) -> Img<Container>

Create new image with Container (which can be Vec, &[] or something else) with given width and height in pixels.

Assumes the pixels in container are contiguous, layed out row by row with width pixels per row and at least height rows.

If the container is larger than width×height pixels, the extra rows are a considered a padding and may be ignored.

source

impl<T> Img<Vec<T, Global>>where
T: Copy,

source

pub fn into_contiguous_buf(self) -> (Vec<T, Global>, usize, usize)

Returns the buffer, width, height. Guarantees that the buffer is contiguous, i.e. it’s width*height elements long, and [x + y*width] addresses each pixel.

Efficiently performs operation in-place. For other containers use pixels().collect().

source

pub fn as_contiguous_buf(&mut self) -> (&[T], usize, usize)

Returns a reference to the buffer, width, height. Guarantees that the buffer is contiguous, i.e. it’s width*height elements long, and [x + y*width] addresses each pixel.

Efficiently performs operation in-place. For other containers use pixels().collect().

source

impl<OldContainer> Img<OldContainer>

source

pub fn map_buf<NewContainer, OldPixel, NewPixel, F>(
 self,
 callback: F
) -> Img<NewContainer>where
 NewContainer: AsRef<[NewPixel]>,
 OldContainer: AsRef<[OldPixel]>,
 F: FnOnce(OldContainer) -> NewContainer,

A convenience method for creating an image of the same size and stride, but with a new buffer.

source

pub fn new_buf<NewContainer, OldPixel, NewPixel>(
 &self,
 new_buf: NewContainer
) -> Img<NewContainer>where
 NewContainer: AsRef<[NewPixel]>,
 OldContainer: AsRef<[OldPixel]>,

A convenience method for creating an image of the same size and stride, but with a new buffer.

source

impl<T> Img<Cow<'_, [T]>>where
T: Clone,

source

pub fn into_owned(self) -> Img<Vec<T, Global>>

Convert underlying buffer to owned (e.g. slice to vec)

See also to_contiguous_buf().0.into_owned()

source

impl<T> Img<T>where
T: ToOwned,

source

pub fn to_owned(&self) -> Img<<T as ToOwned>::Owned>

Convert underlying buffer to owned (e.g. slice to vec)

See also to_contiguous_buf().0.into_owned()

Trait Implementations

source

impl<Container> Clone for Img<Container>where
Container: Clone,

source

fn clone(&self) -> Img<Container>

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl<Container> Debug for Img<Container>where
Container: Debug,

source

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

Formats the value using the given formatter. Read more

source

impl<'a, T> From<Img<&'a [T]>> for Img<Cow<'a, [T]>>where
T: Clone,

source

fn from(img: Img<&'a [T]>) -> Img<Cow<'a, [T]>>

Converts to this type from the input type.

source

impl<T> From<Img<Cow<'_, [T]>>> for Img<Vec<T, Global>>where
T: Clone,

source

fn from(img: Img<Cow<'_, [T]>>) -> Img<Vec<T, Global>>

Converts to this type from the input type.

source

impl<T> From<Img<Vec<T, Global>>> for Img<Cow<'static, [T]>>where
T: Clone,

source

fn from(img: Img<Vec<T, Global>>) -> Img<Cow<'static, [T]>>

Converts to this type from the input type.

source

impl<'a, T> Hash for Img<&'a [T]>where
T: Hash,

source

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

Feeds this value into the given Hasher. Read more

1.3.0 · source

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

Feeds a slice of this type into the given Hasher. Read more

source

impl<'a, T> Hash for Img<&'a mut [T]>where
T: Hash,

source

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

Feeds this value into the given Hasher. Read more

1.3.0 · source

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

Feeds a slice of this type into the given Hasher. Read more

source

impl<T> Hash for Img<Vec<T, Global>>where
T: Hash,

source

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

Feeds this value into the given Hasher. Read more

1.3.0 · source

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

Feeds a slice of this type into the given Hasher. Read more

source

impl<Pixel, Container> ImgExt<Pixel> for Img<Container>where
Container: AsRef<[Pixel]>,

source

fn rows_padded(&self) -> Chunks<'_, Pixel>

Iterate over the entire buffer as rows, including all padding

Rows will have up to stride width, but the last row may be shorter.

source

fn width_padded(&self) -> usize

Maximum possible width of the data, including the stride. Read more

source

fn height_padded(&self) -> usize

Height in number of full strides. If the underlying buffer is not an even multiple of strides, the last row is ignored. Read more

source

fn as_ref(&self) -> Img<&[Pixel]>

Borrow the container

source

impl<Pixel, Container> ImgExtMut<Pixel> for Img<Container>where
Container: AsMut<[Pixel]>,

source

fn rows_padded_mut(&mut self) -> ChunksMut<'_, Pixel>

Iterate over the entire buffer as rows, including all padding

Rows will have up to stride width, but the last row may be shorter.

Panics

If stride is 0

source

fn as_mut(&mut self) -> Img<&mut [Pixel]>

Borrow the container mutably

source

impl<'a, Pixel> Index<(u32, u32)> for Img<&'a [Pixel]>where
Pixel: Copy,

source

fn index(
&self,
index: (u32, u32)
) -> &<Img<&'a [Pixel]> as Index<(u32, u32)>>::Output

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

source

impl<'a, Pixel> Index<(u32, u32)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

source

fn index(
&self,
index: (u32, u32)
) -> &<Img<&'a mut [Pixel]> as Index<(u32, u32)>>::Output

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

source

impl<'a, Pixel> Index<(u32, u32)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

source

fn index(
&self,
index: (u32, u32)
) -> &<Img<Vec<Pixel, Global>> as Index<(u32, u32)>>::Output

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

source

impl<'a, Pixel> Index<(usize, usize)> for Img<&'a [Pixel]>where
Pixel: Copy,

source

fn index(
&self,
index: (usize, usize)
) -> &<Img<&'a [Pixel]> as Index<(usize, usize)>>::Output

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

source

impl<'a, Pixel> Index<(usize, usize)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

source

fn index(
&self,
index: (usize, usize)
) -> &<Img<&'a mut [Pixel]> as Index<(usize, usize)>>::Output

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

source

impl<'a, Pixel> Index<(usize, usize)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

source

fn index(
&self,
index: (usize, usize)
) -> &<Img<Vec<Pixel, Global>> as Index<(usize, usize)>>::Output

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

source

impl<'a, Pixel> Index<usize> for Img<&'a [Pixel]>where
Pixel: Copy,

source

fn index(&self, row: usize) -> &<Img<&'a [Pixel]> as Index<usize>>::Output

Take n-th row as a slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

type Output = [Pixel]

The returned type after indexing.

source

impl<'a, Pixel> Index<usize> for Img<&'a mut [Pixel]>where
Pixel: Copy,

source

fn index(&self, row: usize) -> &<Img<&'a mut [Pixel]> as Index<usize>>::Output

Take n-th row as a slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

type Output = [Pixel]

The returned type after indexing.

source

impl<'a, Pixel> Index<usize> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

source

fn index(&self, row: usize) -> &<Img<Vec<Pixel, Global>> as Index<usize>>::Output

Take n-th row as a slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

type Output = [Pixel]

The returned type after indexing.

source

impl<'a, Pixel> IndexMut<(u32, u32)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

source

fn index_mut(
&mut self,
index: (u32, u32)
) -> &mut <Img<&'a mut [Pixel]> as Index<(u32, u32)>>::Output

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

source

impl<'a, Pixel> IndexMut<(u32, u32)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

source

fn index_mut(
&mut self,
index: (u32, u32)
) -> &mut <Img<Vec<Pixel, Global>> as Index<(u32, u32)>>::Output

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

source

impl<'a, Pixel> IndexMut<(usize, usize)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

source

fn index_mut(
&mut self,
index: (usize, usize)
) -> &mut <Img<&'a mut [Pixel]> as Index<(usize, usize)>>::Output

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

source

impl<'a, Pixel> IndexMut<(usize, usize)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

source

fn index_mut(
&mut self,
index: (usize, usize)
) -> &mut <Img<Vec<Pixel, Global>> as Index<(usize, usize)>>::Output

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

source

impl<'a, Pixel> IndexMut<usize> for Img<&'a mut [Pixel]>where
Pixel: Copy,

source

fn index_mut(
&mut self,
row: usize
) -> &mut <Img<&'a mut [Pixel]> as Index<usize>>::Output

Take n-th row as a mutable slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

source

impl<'a, Pixel> IndexMut<usize> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

source

fn index_mut(
&mut self,
row: usize
) -> &mut <Img<Vec<Pixel, Global>> as Index<usize>>::Output

Take n-th row as a mutable slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

source

impl<Container> IntoIterator for Img<Container>where
Container: IntoIterator,

Deprecated. Use .rows() or .pixels() iterators which are more predictable

source

fn into_iter(self) -> <Container as IntoIterator>::IntoIter

Deprecated. Use .rows() or .pixels() iterators which are more predictable

type Item = <Container as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <Container as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

source

impl<'a, T, U> PartialEq<Img<&'a [U]>> for Img<Vec<T, Global>>where
T: PartialEq,

source

fn eq(&self, other: &Img<&'a [U]>) -> bool

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

1.0.0 · source

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. Read more

source

impl<'a, 'b, T, U> PartialEq<Img<&'b [U]>> for Img<&'a [T]>where
T: PartialEq,

source

fn eq(&self, other: &Img<&'b [U]>) -> bool

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

1.0.0 · source

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. Read more

source

impl<'a, 'b, T, U> PartialEq<Img<&'b [U]>> for Img<&'a mut [T]>where
T: PartialEq,

source

fn eq(&self, other: &Img<&'b [U]>) -> bool

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

1.0.0 · source

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. Read more

source

impl<'a, 'b, T, U> PartialEq<Img<&'b mut [U]>> for Img<&'a [T]>where
T: PartialEq,

source

fn eq(&self, other: &Img<&'b mut [U]>) -> bool

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

1.0.0 · source

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. Read more

source

impl<'a, 'b, T, U> PartialEq<Img<&'b mut [U]>> for Img<&'a mut [T]>where
T: PartialEq,

source

fn eq(&self, other: &Img<&'b mut [U]>) -> bool

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

1.0.0 · source

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. Read more

source

impl<'a, T, U> PartialEq<Img<Vec<U, Global>>> for Img<&'a [T]>where
T: PartialEq,

source

fn eq(&self, other: &Img<Vec<U, Global>>) -> bool

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

1.0.0 · source

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. Read more

source

impl<T, U> PartialEq<Img<Vec<U, Global>>> for Img<Vec<T, Global>>where
T: PartialEq,

source

fn eq(&self, other: &Img<Vec<U, Global>>) -> bool

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

1.0.0 · source

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. Read more

source

impl<T> Eq for Img<Vec<T, Global>>where
T: Eq,

Auto Trait Implementations

impl<Container> RefUnwindSafe for Img<Container>where
Container: RefUnwindSafe,

impl<Container> Send for Img<Container>where
Container: Send,

impl<Container> Sync for Img<Container>where
Container: Sync,

impl<Container> Unpin for Img<Container>where
Container: Unpin,

impl<Container> UnwindSafe for Img<Container>where
Container: UnwindSafe,

Blanket Implementations

source

impl<T> Any for Twhere
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

source

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct ravif::Img

Fields

Implementations

impl<Container> Img<Container>

pub fn width(&self) -> usize

pub fn height(&self) -> usize

pub fn stride(&self) -> usize

pub fn buf(&self) -> &Container

pub fn buf_mut(&mut self) -> &mut Container

pub fn into_buf(self) -> Container

pub fn rows_buf<'a, T>(&self, buf: &'a [T]) -> RowsIter<'a, T>where T: 'a,

impl<'a, T> Img<&'a [T]>

pub fn sub_image( &self, left: usize, top: usize, width: usize, height: usize) -> Img<&'a [T]>

pub fn rows(&self) -> RowsIter<'_, T>

pub fn iter(&self) -> Iter<'_, T>

impl<'a, T> Img<&'a [T]>where T: Clone,

pub fn to_contiguous_buf(&self) -> (Cow<'a, [T]>, usize, usize)

impl<'a, T> Img<&'a mut [T]>

pub fn sub_image( &'a mut self, left: usize, top: usize, width: usize, height: usize) -> Img<&'a [T]>

pub fn sub_image_mut( &mut self, left: usize, top: usize, width: usize, height: usize) -> Img<&mut [T]>

pub fn as_ref(&self) -> Img<&[T]>

impl<'a, T> Img<&'a [T]>where T: Copy,

pub fn pixels(&self) -> PixelsIter<'_, T>

impl<'a, T> Img<&'a [T]>

pub fn pixels_ref(&self) -> PixelsRefIter<'_, T>

impl<'a, T> Img<&'a mut [T]>where T: Copy,

pub fn pixels(&self) -> PixelsIter<'_, T>

pub fn pixels_mut(&mut self) -> PixelsIterMut<'_, T>

impl<'a, T> Img<Vec<T, Global>>where T: Copy,

pub fn pixels(&self) -> PixelsIter<'_, T>

pub fn pixels_mut(&mut self) -> PixelsIterMut<'_, T>

impl<'a, T> Img<&'a mut [T]>

pub fn rows(&self) -> RowsIter<'_, T>

pub fn rows_mut(&mut self) -> RowsIterMut<'_, T>

impl<T> Img<Vec<T, Global>>

pub fn sub_image_mut( &mut self, left: usize, top: usize, width: usize, height: usize) -> Img<&mut [T]>

pub fn sub_image( &self, left: usize, top: usize, width: usize, height: usize) -> Img<&[T]>

pub fn as_ref(&self) -> Img<&[T]>

pub fn as_mut(&mut self) -> Img<&mut [T]>

pub fn iter(&self) -> Iter<'_, T>

pub fn rows(&self) -> RowsIter<'_, T>

pub fn rows_mut(&mut self) -> RowsIterMut<'_, T>

impl<Container> Img<Container>

pub fn new_stride( buf: Container, width: usize, height: usize, stride: usize) -> Img<Container>

pub fn new(buf: Container, width: usize, height: usize) -> Img<Container>

impl<T> Img<Vec<T, Global>>where T: Copy,

pub fn into_contiguous_buf(self) -> (Vec<T, Global>, usize, usize)

pub fn as_contiguous_buf(&mut self) -> (&[T], usize, usize)

impl<OldContainer> Img<OldContainer>

pub fn map_buf<NewContainer, OldPixel, NewPixel, F>( self, callback: F) -> Img<NewContainer>where NewContainer: AsRef<[NewPixel]>, OldContainer: AsRef<[OldPixel]>, F: FnOnce(OldContainer) -> NewContainer,

pub fn new_buf<NewContainer, OldPixel, NewPixel>( &self, new_buf: NewContainer) -> Img<NewContainer>where NewContainer: AsRef<[NewPixel]>, OldContainer: AsRef<[OldPixel]>,

impl<T> Img<Cow<'_, [T]>>where T: Clone,

pub fn into_owned(self) -> Img<Vec<T, Global>>

impl<T> Img<T>where T: ToOwned,

pub fn to_owned(&self) -> Img<<T as ToOwned>::Owned>

Trait Implementations

impl<Container> Clone for Img<Container>where Container: Clone,

fn clone(&self) -> Img<Container>

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

impl<Container> Debug for Img<Container>where Container: Debug,

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

impl<'a, T> From<Img<&'a [T]>> for Img<Cow<'a, [T]>>where T: Clone,

fn from(img: Img<&'a [T]>) -> Img<Cow<'a, [T]>>

impl<T> From<Img<Cow<'_, [T]>>> for Img<Vec<T, Global>>where T: Clone,

fn from(img: Img<Cow<'_, [T]>>) -> Img<Vec<T, Global>>

impl<T> From<Img<Vec<T, Global>>> for Img<Cow<'static, [T]>>where T: Clone,

fn from(img: Img<Vec<T, Global>>) -> Img<Cow<'static, [T]>>

impl<'a, T> Hash for Img<&'a [T]>where T: Hash,

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

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

impl<'a, T> Hash for Img<&'a mut [T]>where T: Hash,

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

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

impl<T> Hash for Img<Vec<T, Global>>where T: Hash,

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

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

impl<Pixel, Container> ImgExt<Pixel> for Img<Container>where Container: AsRef<[Pixel]>,

fn rows_padded(&self) -> Chunks<'_, Pixel>

fn width_padded(&self) -> usize

fn height_padded(&self) -> usize

pub fn rows_buf<'a, T>(&self, buf: &'a [T]) -> RowsIter<'a, T>where
T: 'a,

pub fn sub_image(
&self,
left: usize,
top: usize,
width: usize,
height: usize
) -> Img<&'a [T]>

impl<'a, T> Img<&'a [T]>where
T: Clone,

pub fn sub_image(
&'a mut self,
left: usize,
top: usize,
width: usize,
height: usize
) -> Img<&'a [T]>

pub fn sub_image_mut(
&mut self,
left: usize,
top: usize,
width: usize,
height: usize
) -> Img<&mut [T]>

impl<'a, T> Img<&'a [T]>where
T: Copy,

impl<'a, T> Img<&'a mut [T]>where
T: Copy,

impl<'a, T> Img<Vec<T, Global>>where
T: Copy,

pub fn sub_image_mut(
&mut self,
left: usize,
top: usize,
width: usize,
height: usize
) -> Img<&mut [T]>

pub fn sub_image(
&self,
left: usize,
top: usize,
width: usize,
height: usize
) -> Img<&[T]>

pub fn new_stride(
buf: Container,
width: usize,
height: usize,
stride: usize
) -> Img<Container>

impl<T> Img<Vec<T, Global>>where
T: Copy,

pub fn map_buf<NewContainer, OldPixel, NewPixel, F>(
self,
callback: F
) -> Img<NewContainer>where
NewContainer: AsRef<[NewPixel]>,
OldContainer: AsRef<[OldPixel]>,
F: FnOnce(OldContainer) -> NewContainer,

pub fn new_buf<NewContainer, OldPixel, NewPixel>(
&self,
new_buf: NewContainer
) -> Img<NewContainer>where
NewContainer: AsRef<[NewPixel]>,
OldContainer: AsRef<[OldPixel]>,

impl<T> Img<Cow<'_, [T]>>where
T: Clone,

impl<T> Img<T>where
T: ToOwned,

impl<Container> Clone for Img<Container>where
Container: Clone,

impl<Container> Debug for Img<Container>where
Container: Debug,

impl<'a, T> From<Img<&'a [T]>> for Img<Cow<'a, [T]>>where
T: Clone,

impl<T> From<Img<Cow<'_, [T]>>> for Img<Vec<T, Global>>where
T: Clone,

impl<T> From<Img<Vec<T, Global>>> for Img<Cow<'static, [T]>>where
T: Clone,

impl<'a, T> Hash for Img<&'a [T]>where
T: Hash,

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

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

impl<'a, T> Hash for Img<&'a mut [T]>where
T: Hash,

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

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

impl<T> Hash for Img<Vec<T, Global>>where
T: Hash,

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

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

impl<Pixel, Container> ImgExt<Pixel> for Img<Container>where
Container: AsRef<[Pixel]>,

impl<Pixel, Container> ImgExtMut<Pixel> for Img<Container>where
Container: AsMut<[Pixel]>,

impl<'a, Pixel> Index<(u32, u32)> for Img<&'a [Pixel]>where
Pixel: Copy,

fn index(
&self,
index: (u32, u32)
) -> &<Img<&'a [Pixel]> as Index<(u32, u32)>>::Output

impl<'a, Pixel> Index<(u32, u32)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

fn index(
&self,
index: (u32, u32)
) -> &<Img<&'a mut [Pixel]> as Index<(u32, u32)>>::Output

impl<'a, Pixel> Index<(u32, u32)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

fn index(
&self,
index: (u32, u32)
) -> &<Img<Vec<Pixel, Global>> as Index<(u32, u32)>>::Output

impl<'a, Pixel> Index<(usize, usize)> for Img<&'a [Pixel]>where
Pixel: Copy,

fn index(
&self,
index: (usize, usize)
) -> &<Img<&'a [Pixel]> as Index<(usize, usize)>>::Output

impl<'a, Pixel> Index<(usize, usize)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

fn index(
&self,
index: (usize, usize)
) -> &<Img<&'a mut [Pixel]> as Index<(usize, usize)>>::Output

impl<'a, Pixel> Index<(usize, usize)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

fn index(
&self,
index: (usize, usize)
) -> &<Img<Vec<Pixel, Global>> as Index<(usize, usize)>>::Output

impl<'a, Pixel> Index<usize> for Img<&'a [Pixel]>where
Pixel: Copy,

impl<'a, Pixel> Index<usize> for Img<&'a mut [Pixel]>where
Pixel: Copy,

impl<'a, Pixel> Index<usize> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

impl<'a, Pixel> IndexMut<(u32, u32)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

fn index_mut(
&mut self,
index: (u32, u32)
) -> &mut <Img<&'a mut [Pixel]> as Index<(u32, u32)>>::Output

impl<'a, Pixel> IndexMut<(u32, u32)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

fn index_mut(
&mut self,
index: (u32, u32)
) -> &mut <Img<Vec<Pixel, Global>> as Index<(u32, u32)>>::Output

impl<'a, Pixel> IndexMut<(usize, usize)> for Img<&'a mut [Pixel]>where
Pixel: Copy,

fn index_mut(
&mut self,
index: (usize, usize)
) -> &mut <Img<&'a mut [Pixel]> as Index<(usize, usize)>>::Output

impl<'a, Pixel> IndexMut<(usize, usize)> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

fn index_mut(
&mut self,
index: (usize, usize)
) -> &mut <Img<Vec<Pixel, Global>> as Index<(usize, usize)>>::Output

impl<'a, Pixel> IndexMut<usize> for Img<&'a mut [Pixel]>where
Pixel: Copy,

fn index_mut(
&mut self,
row: usize
) -> &mut <Img<&'a mut [Pixel]> as Index<usize>>::Output

impl<'a, Pixel> IndexMut<usize> for Img<Vec<Pixel, Global>>where
Pixel: Copy,

fn index_mut(
&mut self,
row: usize
) -> &mut <Img<Vec<Pixel, Global>> as Index<usize>>::Output

impl<Container> IntoIterator for Img<Container>where
Container: IntoIterator,

impl<'a, T, U> PartialEq<Img<&'a [U]>> for Img<Vec<T, Global>>where
T: PartialEq<U>,

impl<'a, 'b, T, U> PartialEq<Img<&'b [U]>> for Img<&'a [T]>where
T: PartialEq<U>,