Struct fimg::Image

pub struct Image<T, const CHANNELS: usize> { /* private fields */ }

A image with a variable number of channels, and a nonzero size.

Implementations

impl<const CHANNELS: usize, T: AsMut<[u8]> + AsRef<[u8]>> Image<T, CHANNELS>

pub fn flip_v(&mut self)

Flip an image vertically.

pub fn flip_h(&mut self)

Flip an image horizontally.

impl<const CHANNELS: usize, T: AsMut<[u8]> + AsRef<[u8]>> Image<T, CHANNELS>

pub fn rot_180(&mut self)

Rotate an image 180 degrees clockwise.

pub unsafe fn rot_90(&mut self)

Rotate an image 90 degrees clockwise.

Safety

UB if the image is not square

pub unsafe fn rot_270(&mut self)

Rotate an image 270 degrees clockwise, or 90 degrees anti clockwise.

Safety

UB if the image is not square

impl<B: Buffer, const C: usize> Image<B, C>

pub const fn build(w: u32, h: u32) -> Builder<B, C>

creates a builder

impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub fn box( &mut self, (x1, y1): (u32, u32), width: u32, height: u32, c: [u8; CHANNELS] )

Draw a bordered box

let mut b = Image::alloc(10, 9);
b.as_mut().r#box((1, 1), 7, 6, [255]);

pub fn filled_box( &mut self, (x1, y1): (u32, u32), width: u32, height: u32, c: [u8; CHANNELS] )

Draw a filled box.

let mut b = Image::alloc(10, 9);
b.as_mut().filled_box((1, 1), 7, 6, [255]);

pub fn stroked_box( &mut self, (x1, y1): (u32, u32), width: u32, height: u32, stroke: u32, c: [u8; CHANNELS] )

Draw a stroked box

let mut b = Image::alloc(11, 11);
b.as_mut().stroked_box((2, 2), 6, 6, 2, [255]);

impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub fn border_circle( &mut self, (xc, yc): (i32, i32), radius: i32, c: [u8; CHANNELS] )

Draws a circle, using the Bresenham’s circle algorithm.

let mut i = Image::alloc(50, 50);
i.border_circle((25, 25), 20, [255]);

pub fn circle(&mut self, (xc, yc): (i32, i32), radius: i32, c: [u8; CHANNELS])

Draw a filled circle.

let mut i = Image::alloc(50, 50);
i.circle((25, 25), 20, [255]);

impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub fn line(&mut self, a: (i32, i32), b: (i32, i32), color: [u8; CHANNELS])

Draw a line from point a to point b.

Points not in bounds will not be included.

Uses bresenshams line algorithm.

pub fn thick_line( &mut self, a: impl Into<Vec2>, b: impl Into<Vec2>, stroke: f32, color: [u8; CHANNELS] )

Draw a thick line from point a to point b. Prefer Image::line when possible.

Points not in bounds will not be included.

Uses Image::quad.

let mut i = Image::alloc(10, 10);
i.thick_line((2.0, 2.0), (8.0, 8.0), 2.0, [255]);

impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub fn points(&mut self, poly: &[(i32, i32)], c: [u8; CHANNELS])

Draws a filled polygon from a slice of points. Please close your poly. (first == last)

Borrowed from imageproc, modified for less allocations.

let mut i = Image::alloc(10, 10);
i.points(&[(1, 8), (3, 1), (8, 1), (6, 6), (8, 8), (1, 8)], [255]);

pub fn quad( &mut self, a: (i32, i32), b: (i32, i32), c: (i32, i32), d: (i32, i32), col: [u8; CHANNELS] )

Draws a filled quadrilateral. This currently just uses Image::points, but in the future this may change.

pub fn poly( &mut self, pos: impl Into<Vec2>, sides: usize, radius: f32, rotation: f32, c: [u8; CHANNELS] )

Draws a regular convex polygon with a specified number of sides, a radius, and a rotation (radians). Prefer Image::circle over poly(.., 600, ..). Calls into Image::tri and Image::quad.

let mut i = Image::alloc(300, 300);
//          draw a enneagon
// at  x150, y150    │  unrotated   white
// with a radius of ─┼──╮      │      │
i.poly((150., 150.), 9, 100.0, 0.0, [255]);

pub fn border_poly( &mut self, pos: impl Into<Vec2>, sides: usize, radius: f32, rotation: f32, stroke: f32, c: [u8; CHANNELS] )

Draw a bordered polygon. Prefer Image::border_circle to draw circles. See also Image::poly.

let mut i = fimg::Image::alloc(100, 100);
i.border_poly((50., 50.), 5, 25., 0., 7., [255]);

impl<const N: usize, T: AsMut<[u8]> + AsRef<[u8]>> Image<T, N>

pub fn text( &mut self, x: u32, y: u32, size: f32, font: &Font, text: &str, color: [u8; N] )

Available on crate feature text only.

Draw text.

let font = fontdue::Font::from_bytes(
    &include_bytes!("../../tdata/CascadiaCode.ttf")[..],
    fontdue::FontSettings {
        scale: 200.0,
        ..Default::default()
    },
).unwrap();
let mut i: Image<_, 4> = Image::alloc(750, 250).boxed();
i.text(50, 10, 200.0, &font, "hello", [0, 0, 0, 255]);

impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub fn tri( &mut self, b: impl Into<Vec2>, a: impl Into<Vec2>, c: impl Into<Vec2>, col: [u8; CHANNELS] )

Draw a (filled) triangle

let mut a = Image::alloc(10, 10);
// draw a triangle
a.as_mut().tri(
  (3.0, 2.0), // point a
  (8.0, 7.0), // point b
  (1.0, 8.0), // point c
  [255] // white
);

impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, 1>

pub fn scale<A: ScalingAlgorithm>( &self, width: u32, height: u32 ) -> Image<Box<[u8]>, 1>

Available on crate feature scale only.

Scale a Y image with a given scaling algorithm.

impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, 2>

pub fn scale<A: ScalingAlgorithm>( &mut self, width: u32, height: u32 ) -> Image<Box<[u8]>, 2>

Available on crate feature scale only.

Scale a YA image with a given scaling algorithm.

impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, 3>

pub fn scale<A: ScalingAlgorithm>( &self, width: u32, height: u32 ) -> Image<Box<[u8]>, 3>

Available on crate feature scale only.

Scale a RGB image with a given scaling algorithm.

impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, 4>

pub fn scale<A: ScalingAlgorithm>( &mut self, width: u32, height: u32 ) -> Image<Box<[u8]>, 4>

Available on crate feature scale only.

Scale a RGBA image with a given scaling algorithm.

impl Image<&[u8], 3>

pub unsafe fn repeated( &self, out_width: u32, out_height: u32 ) -> Image<Vec<u8>, 3>

Tile self till it fills a new image of size x, y

Safety

UB if self’s width is not a multiple of x, or self’s height is not a multiple of y

let x: Image<&[u8], 3> = Image::build(8, 8).buf(include_bytes!("../benches/3_8x8.imgbuf"));
let tiled = unsafe { x.repeated(48, 48) }; // repeat 6 times

impl<T, const CHANNELS: usize> Image<T, CHANNELS>

pub fn height(&self) -> u32

get the height as a u32

pub fn width(&self) -> u32

get the width as a u32

pub const unsafe fn new( width: NonZeroU32, height: NonZeroU32, buffer: T ) -> Self

create a new image

Safety

does not check that buffer.len() == w * h * C

using this with invalid values may result in future UB

pub fn take_buffer(self) -> T

consumes the image, returning the image buffer

pub const fn buffer(&self) -> &T

returns a immutable reference to the backing buffer

pub unsafe fn buffer_mut(&mut self) -> &mut T

returns a mutable(!) reference to the backing buffer

Safety

please do not change buffer size.

impl<const CHANNELS: usize, T: Clone> Image<&[T], CHANNELS>

pub fn to_owned(&self) -> Image<Vec<T>, CHANNELS>

Allocate a new Image<Vec<T>> from this imageref.

impl<const CHANNELS: usize, T: Clone> Image<&mut [T], CHANNELS>

pub fn to_owned(&self) -> Image<Vec<T>, CHANNELS>

Allocate a new Image<Vec<T>> from this mutable imageref.

impl<const CHANNELS: usize> Image<&[u8], CHANNELS>

pub const fn copy(&self) -> Self

Copy this ref image

pub const fn make<'a, const WIDTH: u32, const HEIGHT: u32>( ) -> Image<&'a [u8], CHANNELS>

Create a new immutable image of width x, y.

Panics

if width || height == 0

let img = Image::make::<5, 5>();

impl<const CHANNELS: usize, const N: usize> Image<[u8; N], CHANNELS>

pub fn boxed(self) -> Image<Box<[u8]>, CHANNELS>

Box this array image.

impl<const CHANNELS: usize> Image<&[u8], CHANNELS>

pub fn boxed(self) -> Image<Box<[u8]>, CHANNELS>

Box this image.

impl<const CHANNELS: usize> Image<Vec<u8>, CHANNELS>

pub fn boxed(self) -> Image<Box<[u8]>, CHANNELS>

Box this owned image.

impl<T: AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub fn len(&self) -> usize

The size of the underlying buffer.

pub fn cloner(&self) -> ImageCloner<'_, CHANNELS>

Procure a ImageCloner.

pub fn as_ref(&self) -> Image<&[u8], CHANNELS>

Reference this image.

pub fn chunked(&self) -> impl DoubleEndedIterator<Item = &[u8; CHANNELS]>

Returns a iterator over every pixel

pub fn flatten(&self) -> &[[u8; CHANNELS]]

Flatten the chunks of this image into a slice of slices.

pub unsafe fn pixel(&self, x: u32, y: u32) -> [u8; CHANNELS]

Return a pixel at (x, y).

Safety

• UB if x, y is out of bounds
• UB if buffer is too small

impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS>

pub unsafe fn pixel_mut(&mut self, x: u32, y: u32) -> &mut [u8]

Return a mutable reference to a pixel at (x, y).

Safety

• UB if x, y is out of bounds
• UB if buffer is too small

pub fn chunked_mut(&mut self) -> impl Iterator<Item = &mut [u8; CHANNELS]>

Returns a iterator over every pixel, mutably

pub fn as_mut(&mut self) -> Image<&mut [u8], CHANNELS>

Create a mutref to this image

pub fn flatten_mut(&mut self) -> &mut [[u8; CHANNELS]]

Flatten the chunks of this image into a mutable slice of slices.

pub unsafe fn set_pixel(&mut self, x: u32, y: u32, px: [u8; CHANNELS])

Set the pixel at x, y

Safety

UB if x, y is out of bounds.

impl<const CHANNELS: usize> Image<&mut [u8], CHANNELS>

pub fn copy(&mut self) -> Image<&mut [u8], CHANNELS>

Copy this ref image

impl<const CHANNELS: usize> Image<Vec<u8>, CHANNELS>

pub fn alloc(width: u32, height: u32) -> Self

Allocates a new image. If width and height are constant, try using make.

Panics

if width || height == 0

pub fn leak(self) -> Image<&'static mut [u8], CHANNELS>

Consumes and leaks this image, returning a reference to the image.

impl<const CHANNELS: usize, T: ?Sized> Image<Box<T>, CHANNELS>

pub fn leak(self) -> Image<&'static mut T, CHANNELS>

Consumes and leaks this image, returning a reference to the image.

impl<const CHANNELS: usize> Image<Vec<u8>, CHANNELS>

pub fn open(f: impl AsRef<Path>) -> Self

Available on crate feature save only.

Open a PNG image

impl<T: AsRef<[u8]>> Image<T, 3>

pub fn save(&self, f: impl AsRef<Path>)

Available on crate feature save only.

Save this RGB image.

impl<T: AsRef<[u8]>> Image<T, 4>

pub fn save(&self, f: impl AsRef<Path>)

Available on crate feature save only.

Save this RGBA image.

impl<T: AsRef<[u8]>> Image<T, 2>

pub fn save(&self, f: impl AsRef<Path>)

Available on crate feature save only.

Save this YA image.

impl<T: AsRef<[u8]>> Image<T, 1>

pub fn save(&self, f: impl AsRef<Path>)

Available on crate feature save only.

Save this Y image.

Trait Implementations

impl BlendingOverlay<Image<&[u8], 4>> for Image<&mut [u8], 4>

unsafe fn overlay_blended(&mut self, with: &Image<&[u8], 4>) -> &mut Self

Overlay with => self, blending. You probably do not need this, unless your images make much usage of alpha. If you only have 2 alpha states, 0 | 255 (transparent | opaque), please use Overlay, as it is much faster.

impl<T: AsMut<[u8]> + AsRef<[u8]>, U: AsRef<[u8]>> BlendingOverlay<Image<U, 4>> for Image<T, 3>

unsafe fn overlay_blended(&mut self, with: &Image<U, 4>) -> &mut Self

Overlay with => self, blending. You probably do not need this, unless your images make much usage of alpha. If you only have 2 alpha states, 0 | 255 (transparent | opaque), please use Overlay, as it is much faster.

impl<T: Clone, const CHANNELS: usize> Clone for Image<T, CHANNELS>

fn clone(&self) -> Self

Returns a duplicate of this image.

let new_i = i.clone();

If you find yourself in the pattern of

let mut i = i.clone();
unsafe { i.rot_90() };

STOP!

Instead use

let i = unsafe { i.cloner().rot_90() };

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

Performs copy-assignment from source.

impl<T: Debug, const CHANNELS: usize> Debug for Image<T, CHANNELS>

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

Formats the value using the given formatter.

impl<T: AsMut<[u8]> + AsRef<[u8]>, U: AsRef<[u8]>> Overlay<Image<U, 4>> for Image<T, 3>

unsafe fn overlay(&mut self, with: &Image<U, 4>) -> &mut Self

Overlay with => self (does not blend)

impl<T: AsMut<[u8]> + AsRef<[u8]>, U: AsRef<[u8]>> Overlay<Image<U, 4>> for Image<T, 4>

unsafe fn overlay(&mut self, with: &Image<U, 4>) -> &mut Self

Overlay with => self (does not blend)

impl<T: AsMut<[u8]> + AsRef<[u8]>, U: AsRef<[u8]>> OverlayAt<Image<U, 3>> for Image<T, 3>

unsafe fn overlay_at(&mut self, with: &Image<U, 3>, x: u32, y: u32) -> &mut Self

Overlay a RGB image(with) => self at coordinates x, y. As this is a RGBxRGB operation, blending is unnecessary, and this is simply a copy.

Safety

UB if x, y is out of bounds

impl<T: AsMut<[u8]> + AsRef<[u8]>, U: AsRef<[u8]>> OverlayAt<Image<U, 4>> for Image<T, 3>

unsafe fn overlay_at(&mut self, with: &Image<U, 4>, x: u32, y: u32) -> &mut Self

Overlay with => self at coordinates x, y, without blending

impl<T: AsMut<[u8]> + AsRef<[u8]>, U: AsRef<[u8]>> OverlayAt<Image<U, 4>> for Image<T, 4>

unsafe fn overlay_at(&mut self, with: &Image<U, 4>, x: u32, y: u32) -> &mut Self

Overlay with => self at coordinates x, y, without blending

impl<T: PartialEq, const CHANNELS: usize> PartialEq for Image<T, CHANNELS>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const CHANNELS: usize> Copy for Image<&[u8], CHANNELS>

impl<T: Eq, const CHANNELS: usize> Eq for Image<T, CHANNELS>

impl<T, const CHANNELS: usize> StructuralEq for Image<T, CHANNELS>

impl<T, const CHANNELS: usize> StructuralPartialEq for Image<T, CHANNELS>