Struct PlaneBytes 

pub struct PlaneBytes<const N: usize> { /* private fields */ }

An array of byte matrices.

This type is optimized for the concrete layout type.

use image_texel::texels::{U8, F32};
use image_texel::layout::{Layout, PlaneBytes, MatrixBytes};

let m0 = MatrixBytes::from_width_height(U8.into(), 4, 4).unwrap();
let m1 = MatrixBytes::from_width_height(F32.into(), 16, 16).unwrap();

let planar = PlaneBytes::new([m0, m1]);
let ref_to_m0 = planar.plane_ref(0).unwrap();
let ref_to_m1 = planar.plane_ref(1).unwrap();

assert!(ref_to_m0.byte_len() <= ref_to_m1.offset.get());
assert!(ref_to_m1.byte_len() == planar.byte_len());

Implementations

impl<const N: usize> PlaneBytes<N>

pub fn new(inner: [MatrixBytes; N]) -> Self

Construct from separate matrices.

Relocates each consecutive matrix such that they do not overlap.

Panics

This method panics if the overall layout length would exceed isize::MAX.

pub fn from_repeated(matrix: MatrixBytes) -> Self

pub fn plane_ref(&self, idx: usize) -> Option<&Relocated<MatrixBytes>>

Return a reference to one relocated matrix layout.

pub fn retain_coefficients_like(&self, texel: TexelLayout) -> Self

Return a layout where only planes with a matching texel layout are preserved.

All other planes are rewritten to be empty matrices of that layout. All offsets are preserved.

use image_texel::texels::{U8, F32};
use image_texel::layout::{Layout, PlaneBytes, MatrixBytes};

let m0 = MatrixBytes::from_width_height(U8.into(), 4, 4).unwrap();
let m1 = MatrixBytes::from_width_height(F32.into(), 16, 16).unwrap();

let planar = PlaneBytes::new([m0, m1]);
let only_u8 = planar.retain_coefficients_like(U8.into());

assert_eq!(planar.plane_ref(0), only_u8.plane_ref(0));
assert_ne!(planar.plane_ref(1), only_u8.plane_ref(1));

use image_texel::layout::Relocate;
// That second plane is still offset, but empty
assert!(only_u8.plane_ref(1).unwrap().byte_len() > 0);
assert_eq!(only_u8.plane_ref(1).unwrap().byte_range().len(), 0);

Trait Implementations

impl<const N: usize> Clone for PlaneBytes<N>

fn clone(&self) -> PlaneBytes<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> Decay<PlaneMatrices<T, N>> for PlaneBytes<N>

fn decay(from: PlaneMatrices<T, N>) -> PlaneBytes<N>

impl<const N: usize> Layout for PlaneBytes<N>

fn byte_len(&self) -> usize

impl<const N: usize> PlaneOf<PlaneBytes<N>> for usize

type Plane = Relocated<MatrixBytes>

fn get_plane(self, layout: &PlaneBytes<N>) -> Option<Self::Plane>

Get the layout describing the plane.

impl<const N: usize> Relocate for PlaneBytes<N>

fn byte_offset(&self) -> usize

The offset of the first relevant byte of this layout.

fn relocate(&mut self, offset: AlignedOffset)

Move the layout to another aligned offset.

fn relocate_to_byte(&mut self, offset: usize) -> bool

Attempt to relocate the offset to another start offset, in bytes.

fn byte_range(&self) -> Range<usize>

Retrieve the contiguous byte range occupied by this layout.

impl<T, const N: usize> TryMend<PlaneBytes<N>> for Texel<T>

Upgrade to a collection of planes of the same texel.

type Into = PlaneMatrices<T, N>

type Err = MismatchedPixelError

fn try_mend(self, from: &PlaneBytes<N>) -> Result<Self::Into, Self::Err>