Struct imgref::Img

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

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

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

stride: usize

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

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

Height of the image in pixels.

Methods

impl<Container> Img<Container>

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()

fn height(&self) -> usize

Height of the image in pixels.

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.

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

fn sub_image(
    &self,
    left: usize,
    top: usize,
    width: usize,
    height: usize
) -> Self

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

fn iter(&self) -> Iter<T>

Deprecated

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

impl<Container> Img<Container>

fn new_stride(
    buf: Container,
    width: usize,
    height: usize,
    stride: usize
) -> Self

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.

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

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.

impl<OldContainer> Img<OldContainer>

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.

Trait Implementations

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

type Output = Pixel

The returned type after indexing

fn index(&self, index: (usize, usize)) -> &Self::Output

Read a pixel at (x,y) location.

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

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

type Output = Pixel

The returned type after indexing

fn index(&self, index: (u32, u32)) -> &Self::Output

Read a pixel at (x,y) location.

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

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

type Output = Pixel

The returned type after indexing

fn index(&self, index: (usize, usize)) -> &Self::Output

Read a pixel at (x,y) location.

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

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

type Output = Pixel

The returned type after indexing

fn index(&self, index: (u32, u32)) -> &Self::Output

Read a pixel at (x,y) location.

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

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

fn index_mut(&mut self, index: (usize, usize)) -> &mut Self::Output

Write a pixel at (x,y) location.

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

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

fn index_mut(&mut self, index: (u32, u32)) -> &mut Self::Output

Write a pixel at (x,y) location.

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

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

type Output = Pixel

The returned type after indexing

fn index(&self, index: (usize, usize)) -> &Self::Output

Read a pixel at (x,y) location.

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

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

type Output = Pixel

The returned type after indexing

fn index(&self, index: (u32, u32)) -> &Self::Output

Read a pixel at (x,y) location.

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

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

fn index_mut(&mut self, index: (usize, usize)) -> &mut Self::Output

Write a pixel at (x,y) location.

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

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

fn index_mut(&mut self, index: (u32, u32)) -> &mut Self::Output

Write a pixel at (x,y) location.

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn width_padded(&self) -> usize

Maximum possible width of the data, including the stride.

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.

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

References (ImgRef) should be passed "by value" to avoid a double indirection of &Img<&[]>.

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

type Item = Container::Item

The type of the elements being iterated over.

type IntoIter = Container::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Container::IntoIter

Creates an iterator from a value.