Struct ffimage::packed::generic::ImageBuffer

pub struct ImageBuffer<T: Pixel> { /* fields omitted */ }

Implementations

impl<T: Pixel> ImageBuffer<T>

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

Returns an image buffer with pixel accessors

The backing memory is allocated by this struct. There is no padding added so only the minimum amount of memory is consumed. In contrast to flat image buffers, fat buffer structs own their data and can safely be moved between threads.

Arguments

• width - Width in pixels
• height - Height in pixels

Example

use ffimage::color::rgb::*;
use ffimage::core::GenericImage;
use ffimage::packed::generic::ImageBuffer;

let mut buf = ImageBuffer::<Rgb<u8>>::new(3, 3);
let pix = Rgb::<u8>::new([255, 255, 255]);
buf.set_pixel(0, 0, &pix).unwrap();

pub fn from_raw(width: u32, height: u32, raw: Vec<T::T>) -> Option<Self>

Returns an image buffer with pixel accessors

The pixel memory is copied into an allocated buffer owned by this struct.

Arguments

• width - Width in pixels
• height - Height in pixels
• raw - Pixel memory storage owned by the instance

Example

use ffimage::color::rgb::*;
use ffimage::core::GenericImage;
use ffimage::packed::generic::ImageBuffer;

let mut mem = vec![0; 3];
let mut buf = ImageBuffer::<Rgb<u8>>::from_raw(1, 1, mem)
    .expect("Memory region too small");
let pix = Rgb::<u8>::new([255, 255, 255]);
buf.set_pixel(0, 0, &pix).unwrap();

pub fn raw(&self) -> &[T::T]

pub fn raw_mut(&mut self) -> &mut [T::T]

pub fn stride(&self) -> usize

Returns the length of one pixel row in bytes

Trait Implementations

impl<'a, T: Pixel, '_> From<&'_ ImageView<'a, T>> for ImageBuffer<T>

fn from(view: &ImageView<'a, T>) -> Self

Performs the conversion.

impl<'a, T: Pixel, '_> From<&'_ ImageViewMut<'a, T>> for ImageBuffer<T>

fn from(view: &ImageViewMut<'a, T>) -> Self

Performs the conversion.

impl<'a, T: Pixel + 'a> GenericImage<'a> for ImageBuffer<T>

fn set_pixel(&mut self, x: u32, y: u32, pix: &Self::T) -> Result<(), ()>

Sets the pixel values at the specified coordinates

impl<'a, T: Pixel + 'a> GenericImageView<'a> for ImageBuffer<T>

type T = T

Pixel type

fn width(&self) -> u32

Width in pixels

fn height(&self) -> u32

Height in pixels

fn pixel(&self, x: u32, y: u32) -> Option<Self::T>

Returns the pixel at the specified coordinates

type SubImage = SubImageView<'a, Self>

Type of sub images

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

Returns a sub image view backed by the same data

impl<T: Pixel> Index<usize> for ImageBuffer<T>

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Pixel> IndexMut<usize> for ImageBuffer<T>

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

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

impl<T: Pixel> Into<Vec<<T as Pixel>::T>> for ImageBuffer<T>

fn into(self) -> Vec<T::T>

Performs the conversion.

impl<'a, T: Pixel> IntoIterator for &'a ImageBuffer<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = PixelIter<'a, ImageBuffer<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: Pixel> IntoIterator for &'a mut ImageBuffer<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = PixelIterMut<'a, ImageBuffer<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, SP, DP> TryConvert<ImageBuffer<DP>> for ImageView<'a, SP> where
    SP: Pixel,
    DP: Pixel,
    SP: TryConvertSlice<DP>, 

type Error = ()

fn try_convert(&self, output: &mut ImageBuffer<DP>) -> Result<(), Self::Error>

Converts the buffer into another, possibly with a different format

impl<'a, SP, DP> TryConvert<ImageBuffer<DP>> for ImageViewMut<'a, SP> where
    SP: Pixel,
    DP: Pixel,
    SP: TryConvertSlice<DP>, 

type Error = ()

fn try_convert(&self, output: &mut ImageBuffer<DP>) -> Result<(), Self::Error>

Converts the buffer into another, possibly with a different format

impl<SP, DP> TryConvert<ImageBuffer<DP>> for ImageBuffer<SP> where
    SP: Pixel,
    DP: Pixel,
    SP: TryConvertSlice<DP>, 

type Error = ()

fn try_convert(&self, output: &mut ImageBuffer<DP>) -> Result<(), Self::Error>

Converts the buffer into another, possibly with a different format

impl<'b, SP, DP> TryConvert<ImageViewMut<'b, DP>> for ImageBuffer<SP> where
    SP: Pixel,
    DP: Pixel,
    SP: TryConvertSlice<DP>, 

type Error = ()

fn try_convert(
    &self,
    output: &mut ImageViewMut<'b, DP>
) -> Result<(), Self::Error>

Converts the buffer into another, possibly with a different format