Struct UninitImage 

pub struct UninitImage<T: ImageData>(/* private fields */);

Represents an allocated Image whose image data has not yet been initialized.

Implementations

impl<T: ImageData> UninitImage<T>

pub fn new_2d( width: usize, height: usize, channels: usize, space: ColorSpace, interleaving: bool, ) -> UninitImage<T>

Construct a new uninitialized Image with the specified properties.

Panics

This function will panic if UninitImage::try_new_2d() returns an error.

Examples found in repository

examples/tests/test_images.rs (lines 33-39)

fn test_create_bitmap_image() -> Image<bool> {
    let width = 2;
    let height = 2;
    let channels = 1;

    let mut image = UninitImage::<bool>::new_2d(
        width,
        height,
        channels,
        ColorSpace::Automatic,
        false,
    );

    image.set(Pixel::D2([1, 1]), 1, false);
    image.set(Pixel::D2([1, 2]), 1, true);
    image.set(Pixel::D2([2, 1]), 1, true);
    image.set(Pixel::D2([2, 2]), 1, false);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_u8_image() -> Image<u8> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<u8> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, u8::MAX);
    image.set(Pixel::D2([1, 2]), G, u8::MAX);
    image.set(Pixel::D2([2, 1]), B, u8::MAX);

    // Make this pixel white, by setting R, G, and B channels to ~80%.
    image.set(Pixel::D2([2, 2]), R, 200);
    image.set(Pixel::D2([2, 2]), G, 200);
    image.set(Pixel::D2([2, 2]), B, 200);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_f32_image() -> Image<f32> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<f32> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, 1.0);
    image.set(Pixel::D2([1, 2]), G, 1.0);
    image.set(Pixel::D2([2, 1]), B, 1.0);

    // Make this pixel white, by setting R, G, and B channels to 80%.
    image.set(Pixel::D2([2, 2]), R, 0.8);
    image.set(Pixel::D2([2, 2]), G, 0.8);
    image.set(Pixel::D2([2, 2]), B, 0.8);

    unsafe { image.assume_init() }
}

pub fn try_new_2d( width: usize, height: usize, channels: usize, space: ColorSpace, interleaving: bool, ) -> Result<UninitImage<T>, i64>

Construct a new uninitialized 2D image.

pub fn zero(&mut self)

Efficiently set every pixel value in this image to zero.

This fully initializes this image, albeit to a black image.

Examples found in repository

examples/tests/test_images.rs (line 68)

fn test_create_color_rgb_u8_image() -> Image<u8> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<u8> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, u8::MAX);
    image.set(Pixel::D2([1, 2]), G, u8::MAX);
    image.set(Pixel::D2([2, 1]), B, u8::MAX);

    // Make this pixel white, by setting R, G, and B channels to ~80%.
    image.set(Pixel::D2([2, 2]), R, 200);
    image.set(Pixel::D2([2, 2]), G, 200);
    image.set(Pixel::D2([2, 2]), B, 200);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_f32_image() -> Image<f32> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<f32> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, 1.0);
    image.set(Pixel::D2([1, 2]), G, 1.0);
    image.set(Pixel::D2([2, 1]), B, 1.0);

    // Make this pixel white, by setting R, G, and B channels to 80%.
    image.set(Pixel::D2([2, 2]), R, 0.8);
    image.set(Pixel::D2([2, 2]), G, 0.8);
    image.set(Pixel::D2([2, 2]), B, 0.8);

    unsafe { image.assume_init() }
}

pub fn set(&mut self, pixel: Pixel, channel: usize, value: T)

Set the value of the specified pixel and channel.

Panics

This function will panic if the underlying call to ImageData::setter() fails. This can happen if the specified pixel or channel does not exist.

Examples found in repository

examples/tests/test_images.rs (line 41)

fn test_create_bitmap_image() -> Image<bool> {
    let width = 2;
    let height = 2;
    let channels = 1;

    let mut image = UninitImage::<bool>::new_2d(
        width,
        height,
        channels,
        ColorSpace::Automatic,
        false,
    );

    image.set(Pixel::D2([1, 1]), 1, false);
    image.set(Pixel::D2([1, 2]), 1, true);
    image.set(Pixel::D2([2, 1]), 1, true);
    image.set(Pixel::D2([2, 2]), 1, false);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_u8_image() -> Image<u8> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<u8> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, u8::MAX);
    image.set(Pixel::D2([1, 2]), G, u8::MAX);
    image.set(Pixel::D2([2, 1]), B, u8::MAX);

    // Make this pixel white, by setting R, G, and B channels to ~80%.
    image.set(Pixel::D2([2, 2]), R, 200);
    image.set(Pixel::D2([2, 2]), G, 200);
    image.set(Pixel::D2([2, 2]), B, 200);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_f32_image() -> Image<f32> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<f32> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, 1.0);
    image.set(Pixel::D2([1, 2]), G, 1.0);
    image.set(Pixel::D2([2, 1]), B, 1.0);

    // Make this pixel white, by setting R, G, and B channels to 80%.
    image.set(Pixel::D2([2, 2]), R, 0.8);
    image.set(Pixel::D2([2, 2]), G, 0.8);
    image.set(Pixel::D2([2, 2]), B, 0.8);

    unsafe { image.assume_init() }
}

pub unsafe fn assume_init(self) -> Image<T>

Assume that the data in this image has been initialized.

Use UninitImage::zero() to quickly ensure that every pixel value has been initialized.

Use UninitImage::set() to set individual pixel/channel values.

Safety

This function must only be called once all elements of this image have been initialized. It is undefined behavior to construct an Image without first initializing the data array. In practice, uninitialized values will be essentially random, causing the resulting image to appear different each time it is created.

Examples found in repository

examples/tests/test_images.rs (line 46)

fn test_create_bitmap_image() -> Image<bool> {
    let width = 2;
    let height = 2;
    let channels = 1;

    let mut image = UninitImage::<bool>::new_2d(
        width,
        height,
        channels,
        ColorSpace::Automatic,
        false,
    );

    image.set(Pixel::D2([1, 1]), 1, false);
    image.set(Pixel::D2([1, 2]), 1, true);
    image.set(Pixel::D2([2, 1]), 1, true);
    image.set(Pixel::D2([2, 2]), 1, false);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_u8_image() -> Image<u8> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<u8> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, u8::MAX);
    image.set(Pixel::D2([1, 2]), G, u8::MAX);
    image.set(Pixel::D2([2, 1]), B, u8::MAX);

    // Make this pixel white, by setting R, G, and B channels to ~80%.
    image.set(Pixel::D2([2, 2]), R, 200);
    image.set(Pixel::D2([2, 2]), G, 200);
    image.set(Pixel::D2([2, 2]), B, 200);

    unsafe { image.assume_init() }
}

/// Create an image with four pixels, where the top left image is red, the top right
/// pixel is green, the bottom left pixel is blue, and the bottom right pixel is light
/// gray.
#[wll::export]
fn test_create_color_rgb_f32_image() -> Image<f32> {
    let width = 2;
    let height = 2;
    let channels = 3; // Red, green, and blue.

    let mut image: UninitImage<f32> =
        UninitImage::new_2d(width, height, channels, ColorSpace::RGB, false);

    // Red, green, and blue channels indices.
    const R: usize = 1;
    const G: usize = 2;
    const B: usize = 3;

    // Set every pixel value to black. The image data is otherwise completely
    // uninitialized memory, and can contain arbitrary values.
    image.zero();

    // Set the top left, top right, and bottom left pixels on only one color channel.
    image.set(Pixel::D2([1, 1]), R, 1.0);
    image.set(Pixel::D2([1, 2]), G, 1.0);
    image.set(Pixel::D2([2, 1]), B, 1.0);

    // Make this pixel white, by setting R, G, and B channels to 80%.
    image.set(Pixel::D2([2, 2]), R, 0.8);
    image.set(Pixel::D2([2, 2]), G, 0.8);
    image.set(Pixel::D2([2, 2]), B, 0.8);

    unsafe { image.assume_init() }
}