[−][src]Struct image::ImageBuffer
Generic image buffer
This is an image parameterised by its Pixel types, represented by a width and height and a
container of channel data. It provides direct access to its pixels and implements the
GenericImageView
and GenericImage
traits. In many ways, this is the standard buffer
implementing those traits. Using this concrete type instead of a generic type parameter has
been shown to improve performance.
The crate defines a few type aliases with regularly used pixel types for your convenience, such
as RgbImage
, GrayImage
etc.
Examples
Create a simple canvas and paint a small cross.
use image::{RgbImage, Rgb}; let mut img = RgbImage::new(32, 32); for x in 15..=17 { for y in 8..24 { img.put_pixel(x, y, Rgb([255, 0, 0])); img.put_pixel(y, x, Rgb([255, 0, 0])); } }
Overlays an image on top of a larger background raster.
use image::{GenericImage, GenericImageView, ImageBuffer, open}; let on_top = open("path/to/some.png").unwrap().into_rgb(); let mut img = ImageBuffer::from_fn(512, 512, |x, y| { if (x + y) % 2 == 0 { image::Rgb([0, 0, 0]) } else { image::Rgb([255, 255, 255]) } }); image::imageops::overlay(&mut img, &on_top, 128, 128);
Methods
impl<P, Container> ImageBuffer<P, Container> where
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]>,
[src]
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>>
[src]
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
[src]
Returns the underlying raw buffer
pub fn dimensions(&self) -> (u32, u32)
[src]
The width and height of this image.
pub fn width(&self) -> u32
[src]
The width of this image.
pub fn height(&self) -> u32
[src]
The height of this image.
pub fn pixels(&self) -> Pixels<P>
[src]
Returns an iterator over the pixels of this image.
pub fn rows(&self) -> Rows<P>
[src]
Returns an iterator over the rows of this image.
pub fn enumerate_pixels(&self) -> EnumeratePixels<P>
[src]
Enumerates over the pixels of the image. The iterator yields the coordinates of each pixel along with a reference to them.
pub fn enumerate_rows(&self) -> EnumerateRows<P>
[src]
Enumerates over the rows of the image. The iterator yields the y-coordinate of each row along with a reference to them.
pub fn get_pixel(&self, x: u32, y: u32) -> &P
[src]
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
[src]
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]>,
[src]
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]>,
[src]
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,
[src]
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]> + DerefMut,
pub fn pixels_mut(&mut self) -> PixelsMut<P>
[src]
Returns an iterator over the mutable pixels of this image.
pub fn rows_mut(&mut self) -> RowsMut<P>
[src]
Returns an iterator over the mutable rows of this image.
pub fn enumerate_pixels_mut(&mut self) -> EnumeratePixelsMut<P>
[src]
Enumerates over the pixels of the image. The iterator yields the coordinates of each pixel along with a mutable reference to them.
pub fn enumerate_rows_mut(&mut self) -> EnumerateRowsMut<P>
[src]
Enumerates over the rows of the image. The iterator yields the y-coordinate of each row along with a mutable reference to them.
pub fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut P
[src]
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)
[src]
impl<P, Container> ImageBuffer<P, Container> where
P: Pixel + 'static,
[P::Subpixel]: EncodableLayout,
Container: Deref<Target = [P::Subpixel]>,
[src]
P: Pixel + 'static,
[P::Subpixel]: EncodableLayout,
Container: Deref<Target = [P::Subpixel]>,
pub fn save<Q>(&self, path: Q) -> ImageResult<()> where
Q: AsRef<Path>,
[src]
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, Container> ImageBuffer<P, Container> where
P: Pixel + 'static,
[P::Subpixel]: EncodableLayout,
Container: Deref<Target = [P::Subpixel]>,
[src]
P: Pixel + 'static,
[P::Subpixel]: EncodableLayout,
Container: Deref<Target = [P::Subpixel]>,
pub fn save_with_format<Q>(
&self,
path: Q,
format: ImageFormat
) -> ImageResult<()> where
Q: AsRef<Path>,
[src]
&self,
path: Q,
format: ImageFormat
) -> ImageResult<()> where
Q: AsRef<Path>,
Saves the buffer to a file at the specified path in the specified format.
See save_buffer_with_format
for
supported types.
impl<P: Pixel + 'static> ImageBuffer<P, Vec<P::Subpixel>> where
P::Subpixel: 'static,
[src]
P::Subpixel: 'static,
pub fn new(width: u32, height: u32) -> ImageBuffer<P, Vec<P::Subpixel>>
[src]
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>>
[src]
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,
[src]
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>>>
[src]
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>
[src]
Consumes the image buffer and returns the underlying data as an owned buffer
impl ImageBuffer<Luma<u8>, Vec<u8>>
[src]
pub fn expand_palette(
self,
palette: &[(u8, u8, u8)],
transparent_idx: Option<u8>
) -> RgbaImage
[src]
self,
palette: &[(u8, u8, u8)],
transparent_idx: Option<u8>
) -> RgbaImage
Expands a color palette by re-using the existing buffer. Assumes 8 bit per pixel. Uses an optionally transparent index to adjust it's alpha value accordingly.
Trait Implementations
impl<P, Container> Clone for ImageBuffer<P, Container> where
P: Pixel,
Container: Deref<Target = [P::Subpixel]> + Clone,
[src]
P: Pixel,
Container: Deref<Target = [P::Subpixel]> + Clone,
fn clone(&self) -> ImageBuffer<P, Container>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
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,
[src]
Container: Deref<Target = [FromType::Subpixel]>,
ToType: FromColor<FromType>,
FromType::Subpixel: 'static,
ToType::Subpixel: 'static,
fn convert(&self) -> ImageBuffer<ToType, Vec<ToType::Subpixel>>
[src]
impl<P: Debug + Pixel, Container: Debug> Debug for ImageBuffer<P, Container>
[src]
impl<P, Container> Deref for ImageBuffer<P, Container> where
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]>,
[src]
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
[src]
impl<P, Container> DerefMut for ImageBuffer<P, Container> where
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]> + DerefMut,
[src]
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]> + DerefMut,
impl<P, Container> GenericImage for ImageBuffer<P, Container> where
P: Pixel + 'static,
Container: Deref<Target = [P::Subpixel]> + DerefMut,
P::Subpixel: 'static,
[src]
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. Read more
fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut P
[src]
fn put_pixel(&mut self, x: u32, y: u32, pixel: P)
[src]
unsafe fn unsafe_put_pixel(&mut self, x: u32, y: u32, pixel: P)
[src]
Puts a pixel at location (x, y), ignoring bounds checking.
fn blend_pixel(&mut self, x: u32, y: u32, p: P)
[src]
Put a pixel at location (x, y), taking into account alpha channels
DEPRECATED: This method will be removed. Blend the pixel directly instead.
fn copy_within(&mut self, source: Rect, x: u32, y: u32) -> bool
[src]
fn inner_mut(&mut self) -> &mut Self::InnerImage
[src]
fn copy_from<O>(&mut self, other: &O, x: u32, y: u32) -> ImageResult<()> where
O: GenericImageView<Pixel = Self::Pixel>,
[src]
O: GenericImageView<Pixel = Self::Pixel>,
fn sub_image(
&mut self,
x: u32,
y: u32,
width: u32,
height: u32
) -> SubImage<&mut Self::InnerImage>
[src]
&mut self,
x: u32,
y: u32,
width: u32,
height: u32
) -> SubImage<&mut Self::InnerImage>
impl<P, Container> GenericImageView for ImageBuffer<P, Container> where
P: Pixel + 'static,
Container: Deref<Target = [P::Subpixel]> + Deref,
P::Subpixel: 'static,
[src]
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. Read more
fn dimensions(&self) -> (u32, u32)
[src]
fn bounds(&self) -> (u32, u32, u32, u32)
[src]
fn get_pixel(&self, x: u32, y: u32) -> P
[src]
unsafe fn unsafe_get_pixel(&self, x: u32, y: u32) -> P
[src]
Returns the pixel located at (x, y), ignoring bounds checking.
fn inner(&self) -> &Self::InnerImageView
[src]
fn width(&self) -> u32
[src]
fn height(&self) -> u32
[src]
fn in_bounds(&self, x: u32, y: u32) -> bool
[src]
fn pixels(&self) -> Pixels<Self>
[src]
fn view(
&self,
x: u32,
y: u32,
width: u32,
height: u32
) -> SubImage<&Self::InnerImageView>
[src]
&self,
x: u32,
y: u32,
width: u32,
height: u32
) -> SubImage<&Self::InnerImageView>
impl<P, Container> Index<(u32, u32)> for ImageBuffer<P, Container> where
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]>,
[src]
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]>,
impl<P, Container> IndexMut<(u32, u32)> for ImageBuffer<P, Container> where
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]> + DerefMut,
[src]
P: Pixel + 'static,
P::Subpixel: 'static,
Container: Deref<Target = [P::Subpixel]> + DerefMut,
Auto Trait Implementations
impl<P, Container> RefUnwindSafe for ImageBuffer<P, Container> where
Container: RefUnwindSafe,
P: RefUnwindSafe,
Container: RefUnwindSafe,
P: RefUnwindSafe,
impl<P, Container> Send for ImageBuffer<P, Container> where
Container: Send,
P: Send,
Container: Send,
P: Send,
impl<P, Container> Sync for ImageBuffer<P, Container> where
Container: Sync,
P: Sync,
Container: Sync,
P: Sync,
impl<P, Container> Unpin for ImageBuffer<P, Container> where
Container: Unpin,
P: Unpin,
Container: Unpin,
P: Unpin,
impl<P, Container> UnwindSafe for ImageBuffer<P, Container> where
Container: UnwindSafe,
P: UnwindSafe,
Container: UnwindSafe,
P: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> SetParameter for T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,