Struct image::ImageBuffer

pub struct ImageBuffer<P: Pixel, Container> { /* fields omitted */ }

Generic image buffer

Methods

impl<P, Container> ImageBuffer<P, Container> where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]>, 

pub fn from_raw(
    width: u32,
    height: u32,
    buf: Container
) -> Option<ImageBuffer<P, Container>>

Contructs a buffer from a generic container (for example a Vec or a slice)

Returns None if the container is not big enough (including when the image dimensions necessitate an allocation of more bytes than supported by the container).

pub fn into_raw(self) -> Container

Returns the underlying raw buffer

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

The width and height of this image.

pub fn width(&self) -> u32

The width of this image.

pub fn height(&self) -> u32

The height of this image.

pub fn pixels(&self) -> Pixels<P>

Returns an iterator over the pixels of this image.

pub fn enumerate_pixels(&self) -> EnumeratePixels<P>

Enumerates over the pixels of the image. The iterator yields the coordinates of each pixel along with a reference to them.

pub fn get_pixel(&self, x: u32, y: u32) -> &P

Gets a reference to the pixel at location (x, y)

Panics

Panics if (x, y) is out of the bounds (width, height).

pub fn sample_layout(&self) -> SampleLayout

Get the format of the buffer when viewed as a matrix of samples.

pub fn into_flat_samples(self) -> FlatSamples<Container> where
    Container: AsRef<[P::Subpixel]>, 

Return the raw sample buffer with its stride an dimension information.

The returned buffer is guaranteed to be well formed in all cases. It is layed out by colors, width then height, meaning channel_stride <= width_stride <= height_stride. All strides are in numbers of elements but those are mostly u8 in which case the strides are also byte strides.

pub fn as_flat_samples(&self) -> FlatSamples<&[P::Subpixel]> where
    Container: AsRef<[P::Subpixel]>, 

Return a view on the raw sample buffer.

See flattened for more details.

impl<P, Container> ImageBuffer<P, Container> where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]> + DerefMut, 

pub fn pixels_mut(&mut self) -> PixelsMut<P>

Returns an iterator over the mutable pixels of this image.

pub fn enumerate_pixels_mut(&mut self) -> EnumeratePixelsMut<P>

Enumerates over the pixels of the image. The iterator yields the coordinates of each pixel along with a mutable reference to them.

pub fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut P

Gets a reference to the mutable pixel at location (x, y)

Panics

Panics if (x, y) is out of the bounds (width, height).

pub fn put_pixel(&mut self, x: u32, y: u32, pixel: P)

Puts a pixel at location (x, y)

Panics

Panics if (x, y) is out of the bounds (width, height).

impl<P, Container> ImageBuffer<P, Container> where
    P: Pixel<Subpixel = u8> + 'static,
    Container: Deref<Target = [u8]>, 

pub fn save<Q>(&self, path: Q) -> Result<()> where
    Q: AsRef<Path>, 

Saves the buffer to a file at the path specified.

The image format is derived from the file extension. Currently only jpeg and png files are supported.

impl<P: Pixel + 'static> ImageBuffer<P, Vec<P::Subpixel>> where
    P::Subpixel: 'static, 

pub fn new(width: u32, height: u32) -> ImageBuffer<P, Vec<P::Subpixel>>

Creates a new image buffer based on a Vec<P::Subpixel>.

Panics

Panics when the resulting image is larger the the maximum size of a vector.

pub fn from_pixel(
    width: u32,
    height: u32,
    pixel: P
) -> ImageBuffer<P, Vec<P::Subpixel>>

Constructs a new ImageBuffer by copying a pixel

Panics

Panics when the resulting image is larger the the maximum size of a vector.

pub fn from_fn<F>(
    width: u32,
    height: u32,
    f: F
) -> ImageBuffer<P, Vec<P::Subpixel>> where
    F: FnMut(u32, u32) -> P, 

Constructs a new ImageBuffer by repeated application of the supplied function.

The arguments to the function are the pixel's x and y coordinates.

Panics

Panics when the resulting image is larger the the maximum size of a vector.

pub fn from_vec(
    width: u32,
    height: u32,
    buf: Vec<P::Subpixel>
) -> Option<ImageBuffer<P, Vec<P::Subpixel>>>

Creates an image buffer out of an existing buffer. Returns None if the buffer is not big enough.

pub fn into_vec(self) -> Vec<P::Subpixel>

Consumes the image buffer and returns the underlying data as an owned buffer

Trait Implementations

impl<'a, 'b, Container, FromType: Pixel + 'static, ToType: Pixel + 'static> ConvertBuffer<ImageBuffer<ToType, Vec<<ToType as Pixel>::Subpixel>>> for ImageBuffer<FromType, Container> where
    Container: Deref<Target = [FromType::Subpixel]>,
    ToType: FromColor<FromType>,
    FromType::Subpixel: 'static,
    ToType::Subpixel: 'static, 

fn convert(&self) -> ImageBuffer<ToType, Vec<ToType::Subpixel>>

Converts self to a buffer of type T

impl<P, Container> GenericImageView for ImageBuffer<P, Container> where
    P: Pixel + 'static,
    Container: Deref<Target = [P::Subpixel]> + Deref,
    P::Subpixel: 'static, 

type Pixel = P

The type of pixel.

type InnerImageView = Self

Underlying image type. This is mainly used by SubImages in order to always have a reference to the original image. This allows for less indirections and it eases the use of nested SubImages.

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

The width and height of this image.

fn bounds(&self) -> (u32, u32, u32, u32)

The bounding rectangle of this image.

fn get_pixel(&self, x: u32, y: u32) -> P

Returns the pixel located at (x, y)

unsafe fn unsafe_get_pixel(&self, x: u32, y: u32) -> P

Returns the pixel located at (x, y), ignoring bounds checking.

fn inner(&self) -> &Self::InnerImageView

Returns a reference to the underlying image.

fn width(&self) -> u32

The width of this image.

fn height(&self) -> u32

The height of this image.

fn in_bounds(&self, x: u32, y: u32) -> bool

Returns true if this x, y coordinate is contained inside the image.

Important traits for Pixels<'a, I>

impl<'a, I: GenericImageView> Iterator for Pixels<'a, I> type Item = (u32, u32, I::Pixel);

fn pixels(&self) -> Pixels<Self>

Returns an Iterator over the pixels of this image. The iterator yields the coordinates of each pixel along with their value

fn view(
    &self,
    x: u32,
    y: u32,
    width: u32,
    height: u32
) -> SubImage<&Self::InnerImageView>

Returns an subimage that is an immutable view into this image.

impl<P, Container> GenericImage for ImageBuffer<P, Container> where
    P: Pixel + 'static,
    Container: Deref<Target = [P::Subpixel]> + DerefMut,
    P::Subpixel: 'static, 

type InnerImage = Self

Underlying image type. This is mainly used by SubImages in order to always have a reference to the original image. This allows for less indirections and it eases the use of nested SubImages.

fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut P

Gets a reference to the mutable pixel at location (x, y)

fn put_pixel(&mut self, x: u32, y: u32, pixel: P)

Put a pixel at location (x, y)

unsafe fn unsafe_put_pixel(&mut self, x: u32, y: u32, pixel: P)

Puts a pixel at location (x, y), ignoring bounds checking.

fn blend_pixel(&mut self, x: u32, y: u32, p: P)

Put a pixel at location (x, y), taking into account alpha channels

DEPRECATED: This method will be removed. Blend the pixel directly instead.

fn inner_mut(&mut self) -> &mut Self::InnerImage

Returns a mutable reference to the underlying image.

Important traits for MutPixels<'a, I>

impl<'a, I: GenericImage + 'a> Iterator for MutPixels<'a, I> where
    I::Pixel: 'a,
    <I::Pixel as Pixel>::Subpixel: 'a,  type Item = (u32, u32, &'a mut I::Pixel);

fn pixels_mut(&mut self) -> MutPixels<Self>

Deprecated:

This cannot be implemented safely in Rust. Please use the image buffer directly.

Returns an Iterator over mutable pixels of this image. The iterator yields the coordinates of each pixel along with a mutable reference to them.

fn copy_from<O>(&mut self, other: &O, x: u32, y: u32) -> bool where
    O: GenericImageView<Pixel = Self::Pixel>, 

Copies all of the pixels from another image into this image.

fn sub_image(
    &mut self,
    x: u32,
    y: u32,
    width: u32,
    height: u32
) -> SubImage<&mut Self::InnerImage>

Returns a subimage that is a view into this image.

impl<P, Container> Clone for ImageBuffer<P, Container> where
    P: Pixel,
    Container: Deref<Target = [P::Subpixel]> + Clone, 

fn clone(&self) -> ImageBuffer<P, Container>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, Container> Deref for ImageBuffer<P, Container> where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]>, 

type Target = [P::Subpixel]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<P, Container> DerefMut for ImageBuffer<P, Container> where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]> + DerefMut, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<P: Debug + Pixel, Container: Debug> Debug for ImageBuffer<P, Container>

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

Formats the value using the given formatter.

impl<P, Container> Index<(u32, u32)> for ImageBuffer<P, Container> where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]>, 

type Output = P

The returned type after indexing.

fn index(&self, (x, y): (u32, u32)) -> &P

Performs the indexing (container[index]) operation.

impl<P, Container> IndexMut<(u32, u32)> for ImageBuffer<P, Container> where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]> + DerefMut, 

fn index_mut(&mut self, (x, y): (u32, u32)) -> &mut P

Performs the mutable indexing (container[index]) operation.