pub trait GenericImage: GenericImageView {
    // Required methods
    fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut Self::Pixel;
    fn put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel);
    fn blend_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel);

    // Provided methods
    unsafe fn unsafe_put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel) { ... }
    fn copy_from<O>(
        &mut self,
        other: &O,
        x: u32,
        y: u32,
    ) -> Result<(), ImageError>
       where O: GenericImageView<Pixel = Self::Pixel> { ... }
    fn copy_within(&mut self, source: Rect, x: u32, y: u32) -> bool { ... }
    fn sub_image(
        &mut self,
        x: u32,
        y: u32,
        width: u32,
        height: u32,
    ) -> SubImage<&mut Self>
       where Self: Sized { ... }
}
Expand description

A trait for manipulating images.

Required Methods§

source

fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut Self::Pixel

👎Deprecated since 0.24.0: Use get_pixel and put_pixel instead.

Gets a reference to the mutable pixel at location (x, y). Indexed from top left.

§Panics

Panics if (x, y) is out of bounds.

Panics for dynamic images (this method is deprecated and will be removed).

§Known issues

This requires the buffer to contain a unique set of continuous channels in the exact order and byte representation that the pixel type requires. This is somewhat restrictive.

TODO: Maybe use some kind of entry API? this would allow pixel type conversion on the fly while still doing only one array lookup:

let px = image.pixel_entry_at(x,y);
px.set_from_rgba(rgba)
source

fn put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)

Put a pixel at location (x, y). Indexed from top left.

§Panics

Panics if (x, y) is out of bounds.

source

fn blend_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)

👎Deprecated since 0.24.0: Use iterator pixels_mut to blend the pixels directly

Put a pixel at location (x, y), taking into account alpha channels

Provided Methods§

source

unsafe fn unsafe_put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)

Puts a pixel at location (x, y). Indexed from top left.

This function can be implemented in a way that ignores bounds checking.

§Safety

The coordinates must be in_bounds of the image.

source

fn copy_from<O>(&mut self, other: &O, x: u32, y: u32) -> Result<(), ImageError>
where O: GenericImageView<Pixel = Self::Pixel>,

Copies all of the pixels from another image into this image.

The other image is copied with the top-left corner of the other image placed at (x, y).

In order to copy only a piece of the other image, use GenericImageView::view.

You can use FlatSamples to source pixels from an arbitrary regular raster of channel values, for example from a foreign interface or a fixed image.

§Returns

Returns an error if the image is too large to be copied at the given position

source

fn copy_within(&mut self, source: Rect, x: u32, y: u32) -> bool

Copies all of the pixels from one part of this image to another part of this image.

The destination rectangle of the copy is specified with the top-left corner placed at (x, y).

§Returns

true if the copy was successful, false if the image could not be copied due to size constraints.

source

fn sub_image( &mut self, x: u32, y: u32, width: u32, height: u32, ) -> SubImage<&mut Self>
where Self: Sized,

Returns a mutable subimage that is a view into this image. If you want an immutable subimage instead, use GenericImageView::view The coordinates set the position of the top left corner of the SubImage.

Object Safety§

This trait is not object safe.

Implementors§

source§

impl GenericImage for DynamicImage

source§

impl<Buffer, P> GenericImage for ViewMut<Buffer, P>
where P: Pixel, Buffer: AsMut<[<P as Pixel>::Subpixel]> + AsRef<[<P as Pixel>::Subpixel]>,

source§

impl<P, Container> GenericImage for ImageBuffer<P, Container>
where P: Pixel, Container: Deref<Target = [<P as Pixel>::Subpixel]> + DerefMut,