Struct aurum_image::VecImage2

pub struct VecImage2<T> { /* fields omitted */ }

2D raster image with pixels stored as a Vec.

Methods

impl<T> VecImage2<T>

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

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

fn from_vec(buf: Vec<T>, size: Vec2<usize>) -> Option<VecImage2<T>>

fn height(&self) -> usize

fn into_vec(self) -> Vec<T>

fn row(&self, index: usize) -> &[T]

fn row_mut(&mut self, index: usize) -> &mut [T]

fn size(&self) -> Vec2<usize>

fn try_row(&self, index: usize) -> Option<&[T]>

fn try_row_mut(&mut self, index: usize) -> Option<&mut [T]>

fn width(&self) -> usize

Trait Implementations

impl<T: Clone> Clone for VecImage2<T>

fn clone(&self) -> VecImage2<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Eq> Eq for VecImage2<T>

impl<T: Hash> Hash for VecImage2<T>

fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<T: PartialEq> PartialEq for VecImage2<T>

fn eq(&self, __arg_0: &VecImage2<T>) -> bool

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

fn ne(&self, __arg_0: &VecImage2<T>) -> bool

This method tests for !=.

impl<T, U> FromImage<U> for VecImage2<T> where
    U: Image<Bounds = Size2<usize>, Pixel = T>, 

fn from_image(src: &U) -> VecImage2<T>

impl<T: Copy> Image for VecImage2<T>

type Bounds = Size2<usize>

type Pixel = T

fn bounds(&self) -> &Size2<usize>

fn pixel(&self, index: Vec2<usize>) -> T

fn try_pixel(&self, index: Vec2<usize>) -> Option<T>

unsafe fn unsafe_pixel(&self, index: Vec2<usize>) -> T

fn bounded<B, I>(self, bounds: B) -> Bounded<Self, B> where
    Self: Sized,
    Self::Bounds: Bounds<Index = I> + IsUnbounded,
    B: Bounds<Index = I>,
    I: Copy, 

fn in_bounds(&self, index: <Self::Bounds as Bounds>::Index) -> bool

fn map<F, Q>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: Fn(Self::Pixel) -> Q, 

fn render<T>(&self) -> T where
    Self: Sized,
    T: FromImage<Self>, 

fn transform<F, I>(self, f: F) -> Transform<Self, F, I> where
    Self: Sized,
    F: Fn(I) -> <Self::Bounds as Bounds>::Index,
    I: Copy, 

fn with_size1<T>(self, len: T) -> Bounded<Self, Size1<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = T> + IsUnbounded,
    T: Copy, 

fn with_size2<T>(self, size: Vec2<T>) -> Bounded<Self, Size2<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec2<T>> + IsUnbounded,
    T: Copy, 

fn with_size2_parts<T>(self, width: T, height: T) -> Bounded<Self, Size2<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec2<T>> + IsUnbounded,
    T: Copy, 

fn with_size3<T>(self, size: Vec3<T>) -> Bounded<Self, Size3<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec3<T>> + IsUnbounded,
    T: Copy, 

fn with_size3_parts<T>(
    self,
    width: T,
    height: T,
    depth: T
) -> Bounded<Self, Size3<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec3<T>> + IsUnbounded,
    T: Copy, 

impl<'a, T> Image for &'a VecImage2<T>

type Bounds = Size2<usize>

type Pixel = &'a T

fn bounds(&self) -> &Size2<usize>

fn pixel(&self, index: Vec2<usize>) -> &'a T

fn try_pixel(&self, index: Vec2<usize>) -> Option<&'a T>

unsafe fn unsafe_pixel(&self, index: Vec2<usize>) -> &'a T

fn bounded<B, I>(self, bounds: B) -> Bounded<Self, B> where
    Self: Sized,
    Self::Bounds: Bounds<Index = I> + IsUnbounded,
    B: Bounds<Index = I>,
    I: Copy, 

fn in_bounds(&self, index: <Self::Bounds as Bounds>::Index) -> bool

fn map<F, Q>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: Fn(Self::Pixel) -> Q, 

fn render<T>(&self) -> T where
    Self: Sized,
    T: FromImage<Self>, 

fn transform<F, I>(self, f: F) -> Transform<Self, F, I> where
    Self: Sized,
    F: Fn(I) -> <Self::Bounds as Bounds>::Index,
    I: Copy, 

fn with_size1<T>(self, len: T) -> Bounded<Self, Size1<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = T> + IsUnbounded,
    T: Copy, 

fn with_size2<T>(self, size: Vec2<T>) -> Bounded<Self, Size2<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec2<T>> + IsUnbounded,
    T: Copy, 

fn with_size2_parts<T>(self, width: T, height: T) -> Bounded<Self, Size2<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec2<T>> + IsUnbounded,
    T: Copy, 

fn with_size3<T>(self, size: Vec3<T>) -> Bounded<Self, Size3<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec3<T>> + IsUnbounded,
    T: Copy, 

fn with_size3_parts<T>(
    self,
    width: T,
    height: T,
    depth: T
) -> Bounded<Self, Size3<T>> where
    Self: Sized,
    Self::Bounds: Bounds<Index = Vec3<T>> + IsUnbounded,
    T: Copy, 

impl<T> Index<Vec2<usize>> for VecImage2<T>

type Output = T

The returned type after indexing

fn index(&self, index: Vec2<usize>) -> &T

The method for the indexing (container[index]) operation

impl<T> IndexMut<Vec2<usize>> for VecImage2<T>

fn index_mut(&mut self, index: Vec2<usize>) -> &mut T

The method for the mutable indexing (container[index]) operation