Struct image2::Image

pub struct Image<T: Type, C: Color> {
    pub meta: Meta<T, C>,
    pub data: Box<[T]>,
}

Image type

Fields

meta: Meta<T, C>

Metadata

data: Box<[T]>

Pixel data

Implementations

impl<T: Type, C: Color> Image<T, C>

pub fn hash(&self) -> Hash

Get image hash

impl<T: Type, C: Color> Image<T, C>

pub unsafe fn new_with_data(
    size: impl Into<Size>,
    data: impl Into<Box<[T]>>
) -> Image<T, C>

Create a new image with the given size and data

Safety

This is marked as unsafe because it does not check to ensure the data passed in matches the dimensions

pub fn new(size: impl Into<Size>) -> Image<T, C>

Create a new image

pub fn new_like(&self) -> Image<T, C>

Create a new image with the same size, type and color

pub fn new_like_with_type<U: Type>(&self) -> Image<U, C>

Create a new image with the same size and color as an existing image with the given type

pub fn new_like_with_color<D: Color>(&self) -> Image<T, D>

Create a new image with the same size and type as an existing image with the given color

pub fn new_like_with_type_and_color<U: Type, D: Color>(&self) -> Image<U, D>

Create a new image with the same size as an existing image with the given type and color

pub fn channels(&self) -> Channel

Returns the number of channels

pub fn meta(&self) -> Meta<T, C>

Get image meta

pub fn width(&self) -> usize

Image width

pub fn height(&self) -> usize

Image height

pub fn shape(&self) -> (usize, usize, Channel)

Returns (width, height, channels)

pub fn size(&self) -> Size

Get image size

pub fn into_buffer(self) -> Vec<u8>

Convert image data into byte vec

pub fn to_buffer(&self) -> Vec<u8>

Copy image data into new byte vec

pub fn buffer(&self) -> &[u8]

Get image data as bytes

pub fn buffer_mut(&mut self) -> &mut [u8]

Get image data as mutable bytes

pub fn get(&self, pt: impl Into<Point>) -> Data<'_, T, C>

Get data at specified index

pub fn get_mut(&mut self, pt: impl Into<Point>) -> DataMut<'_, T, C>

Get mutable data at specified index

pub fn set(&mut self, pt: impl Into<Point>, data: impl AsRef<[T]>)

Set data to specified location

pub fn in_bounds(&self, pt: impl Into<Point>) -> bool

Returns true when (x, y) is in bounds for the given image

pub fn at(&self, pt: impl Into<Point>, px: impl AsMut<[T]>) -> bool

Get image data from an image, reusing an existing data buffer big enough for a single pixel

pub fn pixel_at(&self, pt: impl Into<Point>, px: &mut Pixel<C>) -> bool

Load data from and Image into an existing Pixel structure

pub fn new_pixel(&self) -> Pixel<C>

Get an empty pixel for the image color type

pub fn get_pixel(&self, pt: impl Into<Point>) -> Pixel<C>

Get a normalized pixel from an image

pub fn set_pixel(&mut self, pt: impl Into<Point>, px: &Pixel<C>)

Set a normalized pixel to the specified location

pub fn get_f(&self, pt: impl Into<Point>, c: Channel) -> f64

Get a normalized float value

pub fn set_f(&mut self, pt: impl Into<Point>, c: Channel, f: f64)

Set normalized float value

pub fn row(&self, y: usize) -> Data<'_, T, C>

Get row

pub fn row_mut(&mut self, y: usize) -> DataMut<'_, T, C>

Get mutable row

pub fn rows(&self) -> impl ParallelIterator<Item = (usize, &[T])>

Iterate over image rows

pub fn rows_mut(&mut self) -> impl ParallelIterator<Item = (usize, &mut [T])>

Iterate over mutable image rows

pub fn row_range(
    &self,
    y: usize,
    height: usize
) -> impl ParallelIterator<Item = (usize, &[T])>

Iterate over image rows

pub fn row_range_mut(
    &mut self,
    y: usize,
    height: usize
) -> impl ParallelIterator<Item = (usize, &mut [T])>

Iterate over mutable image rows

pub fn open(path: impl AsRef<Path>) -> Result<Image<T, C>, Error>

Read an image from disk

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

Write an image to disk

pub fn iter_region_mut<'a>(
    &'a mut self,
    roi: Region
) -> impl 'a + ParallelIterator<Item = (Point, DataMut<'_, T, C>)>

Iterate over part of an image with mutable data access

pub fn iter_region<'a>(
    &'a self,
    roi: Region
) -> impl 'a + ParallelIterator<Item = (Point, Data<'_, T, C>)>

Iterate over part of an image

pub fn iter<'a>(
    &'a self
) -> impl 'a + ParallelIterator<Item = (Point, Data<'_, T, C>)>

Get pixel iterator

pub fn iter_mut<'a>(
    &'a mut self
) -> impl 'a + ParallelIterator<Item = (Point, DataMut<'_, T, C>)>

Get mutable pixel iterator

pub fn for_each<F: Sync + Send + Fn(Point, DataMut<'_, T, C>)>(&mut self, f: F)

Iterate over each pixel applying f to every pixel

pub fn for_each_region<F: Sync + Send + Fn(Point, DataMut<'_, T, C>)>(
    &mut self,
    roi: Region,
    f: F
)

Iterate over a region of pixels qpplying f to every pixel

pub fn for_each2<F: Sync + Send + Fn(Point, DataMut<'_, T, C>, Data<'_, T, C>)>(
    &mut self,
    other: &Image<T, C>,
    f: F
)

Iterate over each pixel of two images at once

pub fn each_pixel<F: Sync + Send + FnMut(Point, &Pixel<C>)>(&self, f: F)

Iterate over pixels, with a mutable closure

pub fn each_pixel_region<F: Sync + Send + FnMut(Point, &Pixel<C>)>(
    &self,
    region: Region,
    f: F
)

Iterate over pixels in region, with a mutable closure

pub fn each_pixel_mut<F: Sync + Send + FnMut(Point, &mut Pixel<C>)>(
    &mut self,
    f: F
)

Iterate over mutable pixels, with a mutable closure

pub fn each_pixel_region_mut<F: Sync + Send + FnMut(Point, &mut Pixel<C>)>(
    &mut self,
    region: Region,
    f: F
)

Iterate over mutable pixels in region, with a mutable closure

pub fn crop(&self, roi: Region) -> Image<T, C>

Copy a region of an image to a new image

pub fn copy_from_region(
    &mut self,
    offs: impl Into<Point>,
    other: &Image<T, C>,
    roi: Region
)

Copy into a region from another image starting at the given offset

pub fn apply<U: Type, D: Color>(
    &mut self,
    filter: impl Filter<U, D, T, C>,
    input: &[&Image<U, D>]
) -> &mut Self

Apply a filter using an Image as output

pub async fn apply_async<'a, U: Type, D: Color>(
    &mut self,
    mode: AsyncMode,
    filter: impl Filter<U, D, T, C> + Unpin,
    input: &[&Image<U, D>]
) -> &mut Self

Apply an async filter using an Image as output

pub fn run_in_place(&mut self, filter: impl Filter<T, C>) -> &mut Self

Run a filter using the same Image as input and output

pub fn run<U: Type, D: Color>(
    &self,
    filter: impl Filter<T, C, U, D>,
    output: Option<Meta<U, D>>
) -> Image<U, D>

Run a filter using an Image as input

pub async fn run_async<'a, U: 'a + Type, D: 'a + Color>(
    &self,
    mode: AsyncMode,
    filter: impl Filter<T, C, U, D> + Unpin,
    output: Option<Meta<U, D>>
) -> Image<U, D>

Run an async filter using an Image as input

pub fn convert<U: Type, D: Color>(&self) -> Image<U, D>

Convert image type/color

pub fn convert_to<U: Type, D: Color>(&self, dest: &mut Image<U, D>)

Convert image type/color

pub fn histogram(&self, bins: usize) -> Vec<Histogram>

Get image histogram

pub fn set_gamma_log(&mut self)

Convert to log RGB

pub fn set_gamma_lin(&mut self)

Convert to linear RGB

pub fn resize(&self, size: impl Into<Size>) -> Image<T, C>

Resize an image

pub fn scale(&self, width: f64, height: f64) -> Image<T, C>

Scale an image

impl<T: Type, C: Color> Image<T, C>

pub fn to_mut_halide_buffer(&mut self) -> Result<Buffer<'_>, Error>

Use the image as a mutable halide_buffer_t

pub fn to_halide_buffer(&self) -> Result<Buffer<'_>, Error>

Use the image as a mutable halide_buffer_t

Trait Implementations

impl<T: Clone + Type, C: Clone + Color> Clone for Image<T, C>

fn clone(&self) -> Image<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Type, C: Debug + Color> Debug for Image<T, C>

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

Formats the value using the given formatter.

impl<'de, T: Type, C: Color> Deserialize<'de> for Image<T, C> where
    T: Deserialize<'de>,
    C: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<X: Into<Point>, T: Type, C: Color> Index<X> for Image<T, C>

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<X: Into<Point>, T: Type, C: Color> IndexMut<X> for Image<T, C>

fn index_mut(&mut self, pt: X) -> &mut Self::Output

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

impl<T: PartialEq + Type, C: PartialEq + Color> PartialEq<Image<T, C>> for Image<T, C>

fn eq(&self, other: &Image<T, C>) -> bool

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

fn ne(&self, other: &Image<T, C>) -> bool

This method tests for !=.

impl<T: Type, C: Color> Serialize for Image<T, C> where
    T: Serialize,
    C: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl ToTexture<f32, Rgb> for Image<f32, Rgb>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<f32, Rgb>

Get metadata

fn get_data(&self) -> &[f32]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<f32, Rgba> for Image<f32, Rgba>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<f32, Rgba>

Get metadata

fn get_data(&self) -> &[f32]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<i16, Rgb> for Image<i16, Rgb>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<i16, Rgb>

Get metadata

fn get_data(&self) -> &[i16]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<i16, Rgba> for Image<i16, Rgba>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<i16, Rgba>

Get metadata

fn get_data(&self) -> &[i16]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<u16, Rgb> for Image<u16, Rgb>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<u16, Rgb>

Get metadata

fn get_data(&self) -> &[u16]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<u16, Rgba> for Image<u16, Rgba>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<u16, Rgba>

Get metadata

fn get_data(&self) -> &[u16]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<u8, Rgb> for Image<u8, Rgb>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<u8, Rgb>

Get metadata

fn get_data(&self) -> &[u8]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl ToTexture<u8, Rgba> for Image<u8, Rgba>

const COLOR: GLuint

OpenGL color

const KIND: GLuint

OpenGL type

fn get_meta(&self) -> &Meta<u8, Rgba>

Get metadata

fn get_data(&self) -> &[u8]

Get data buffer

fn to_texture(&self) -> Result<Texture, Error>

Convert to texture

impl<T: Eq + Type, C: Eq + Color> Eq for Image<T, C>

impl<T: Type, C: Color> StructuralEq for Image<T, C>

impl<T: Type, C: Color> StructuralPartialEq for Image<T, C>