#interop #frame #width-height #plane #vec2d #stride

imgref

A basic 2-dimensional slice for safe and convenient handling of pixel buffers with width, height & stride

11 stable releases

1.10.1 Jan 21, 2024
1.10.0 Oct 17, 2023
1.9.4 Sep 18, 2022
1.9.2 Jun 12, 2022
1.2.0 Jul 28, 2017

#4 in Images

Download history 69292/week @ 2024-03-29 65472/week @ 2024-04-05 68612/week @ 2024-04-12 67830/week @ 2024-04-19 69674/week @ 2024-04-26 73782/week @ 2024-05-03 71301/week @ 2024-05-10 71941/week @ 2024-05-17 55195/week @ 2024-05-24 111837/week @ 2024-05-31 137566/week @ 2024-06-07 129106/week @ 2024-06-14 175580/week @ 2024-06-21 167632/week @ 2024-06-28 138719/week @ 2024-07-05 112191/week @ 2024-07-12

616,853 downloads per month
Used in 130 crates (38 directly)

CC0-1.0 OR Apache-2.0

62KB
1K SLoC

2D slice of a an image

This is a minimal struct that represents a 2-dimensional vector and rectangular slices of it. It's intended for describing image data, and regions of images (AKA bitmap descriptors, frames with a pitch or stride, planes). It's useful when working with image data, and can be used as the common struct for exchanging image pixels between crates.

In graphics code it's very common to pass width and height along with a Vec or a slice of pixels — all as separate arguments. This gets very repetitive, and can lead to errors.

Additionally, some graphics code requires use of stride, which allows defining sub-regions of images without copying. This is useful for slicing and tiling, and to support bitmaps that require padding (e.g. in video formats that round frame sizes to a multiple of a block size).

This crate is a simple struct that adds dimensions to the underlying pixel buffer. This makes it easier to correctly keep track of the image size and allows passing images with just one function argument instead three or four. For convenience, it also implements efficient iterators for pixels/rows and indexing with img[(x,y)].

use imgref::*;

fn main() {
    let img = Img::new(vec![0; 1000], 50, 20); // 1000 pixels of a 50×20 image

    let new_image = some_image_processing_function(img.as_ref()); // Use imgvec.as_ref() instead of &imgvec for better efficiency

    println!("New size is {}×{}", new_image.width(), new_image.height());
    println!("And the top left pixel is {:?}", new_image[(0u32,0u32)]);

    let first_row_slice = &new_image[0];

    for row in new_image.rows() {}
    for px in new_image.pixels() {}

    // slice (x, y, width, height) by reference - no copy!
    let fragment = img.sub_image(5, 5, 15, 15);

    // create a vec of pixels without stride, for compatibility with software
    // that expects pixels without any "gaps"
    let (vec, width, height) = fragment.to_contiguous_buf();
}

Type aliases

Illustration: stride is width of the whole buffer.

These are described in more detail in the reference.

ImgVec

It owns its pixels (held in a Vec). It's analogous to a 2-dimensional Vec. Use this type to create and return new images from functions.

Don't use &ImgVec. Instead call ImgVec.as_ref() to get a reference (ImgRef) from it (explicit .as_ref() call is required, because Rust doesn't support custom conversions yet.)

ImgRef

ImgRef is a reference to pixels owned by some other ImgVec or a slice. It's analogous to a 2-dimensional &[].

Use this type to accept read-only images as arguments in functions. Note that ImgRef is a Copy type. Pass ImgRef, and not &ImgRef.

Requirements

  • Latest stable Rust (1.42+)

No runtime deps

Features