Struct eimg::Img

pub struct Img<P> { /* fields omitted */ }

Image as a flat buffer of pixels; accessible by (x, y) Index

Methods

impl<P> Img<P>

pub fn new(buf: impl IntoIterator<Item = P>, width: u32) -> Option<Self>

create an Img

from a buf and width. fails if buf.len() % buf.width() != 0

pub const unsafe fn from_raw_buf(buf: Vec<P>, width: u32) -> Self

create an Img

from a buf and length directly, skipping the bounds check.

assert_eq!(
    unsafe{Img::from_raw_buf(vec![2, 4, 6, 8], 2)},
    Img::new(vec![2, 4, 6, 8], 2).unwrap()
);

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

pull the buffer out of the image as a vec.

assert_eq!(Img::new(1..=4, 2).unwrap().into_vec(), vec![1, 2, 3, 4]);

pub fn width(&self) -> u32

get the width of the image.

assert_eq!(Img::new(0..12, 3).unwrap().width(), 3);

pub fn iter(&self) -> <&Self as IntoIterator>::IntoIter

returns an iterator over the pixels in the buffer

pub fn iter_mut(&mut self) -> <&mut Self as IntoIterator>::IntoIter

returns an iterator that allows modifying each pixel

pub fn height(&self) -> u32

the height of the image; i.e, buf.len() / width

assert_eq!(Img::new(0..12, 3).unwrap().height(), 4);

pub fn convert_with<Q>(self, convert: impl Fn(P) -> Q) -> Img<Q>

map a function on P across the image buffer, converting an Img<P> to an Img<Q>

let img: Img<u8> = Img::new(1..=4, 2).unwrap();
let doubled: Img<u16> = Img::new(vec![2, 4, 6, 8], 2).unwrap();
assert_eq!(img.convert_with(|x| u16::from(x*2)), doubled);

pub fn len(&self) -> usize

the length of the image, in pixels. equal to Img::width()*Img::height()

pub fn is_empty(&self) -> bool

pub fn get(&self, (x, y): (u32, u32)) -> Option<&P>

Returns a reference to an element.

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

Returns a pair (width, height).

impl<N: From<u8>> Img<RGB<N>>

pub fn load(path: impl AsRef<Path>) -> Result<Self>

load an image as an RGB after converting it. See image::open and image::DynamicImage::to_rgb

use eimg::*;
let img: Img<RGB<u8>> = Img::load("bunny.png").unwrap();
assert_eq!(img.size(), (480, 320));

impl Img<RGB<u8>>

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

save an image as a .png or .jpg to the path. the path extension determines the image type. See image::ImageBuffer::save

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

the raw_buf flattens out each RGB triplet;

use eimg::*;
let img: Img<RGB<u8>> = Img::new(vec![RGB(0, 1, 2), RGB(1, 1, 1)], 1).unwrap();
assert_eq!(img.raw_buf(), vec![0, 1, 2, 1, 1, 1]);

Trait Implementations

impl<P: PartialEq> PartialEq<Img<P>> for Img<P>

fn eq(&self, other: &Img<P>) -> bool

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

fn ne(&self, other: &Img<P>) -> bool

This method tests for !=.

impl<P: Clone> Clone for Img<P>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> IntoIterator for Img<P>

type Item = P

The type of the elements being iterated over.

type IntoIter = IntoIter<P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, P> IntoIterator for &'a Img<P>

type Item = &'a P

The type of the elements being iterated over.

type IntoIter = Iter<'a, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, P> IntoIterator for &'a mut Img<P>

type Item = &'a mut P

The type of the elements being iterated over.

type IntoIter = IterMut<'a, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<P: Debug> Debug for Img<P>

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

Formats the value using the given formatter.

impl<P> Index<(u32, u32)> for Img<P>

type Output = P

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<P> IndexMut<(u32, u32)> for Img<P>

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

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