Struct View

struct View<Buffer, P: Pixel> { ... }
where
    Buffer: AsRef<[<P as >::Subpixel]>

A flat buffer that can be used as an image view.

This is a nearly trivial wrapper around a buffer but at least sanitizes by checking the buffer length first and constraining the pixel type.

Note that this does not eliminate panics as the AsRef<[T]> implementation of Buffer may be unreliable, i.e. return different buffers at different times. This of course is a non-issue for all common collections where the bounds check once must be enough.

Inner invariants

Implementations

impl<Buffer, P: Pixel> View<Buffer, P>

fn into_inner(self: Self) -> FlatSamples<Buffer>

Take out the sample buffer.

Gives up the normalization invariants on the buffer format.

fn flat(self: &Self) -> &FlatSamples<Buffer>

Get a reference on the inner sample descriptor.

There is no mutable counterpart as modifying the buffer format, including strides and lengths, could invalidate the accessibility invariants of the View. It is not specified if the inner buffer is the same as the buffer of the image from which this view was created. It might have been truncated as an optimization.

fn samples(self: &Self) -> &Buffer

Get a reference on the inner buffer.

There is no mutable counter part since it is not intended to allow you to reassign the buffer or otherwise change its size or properties.

fn get_sample(self: &Self, channel: u8, x: u32, y: u32) -> Option<&<P as >::Subpixel>

Get a reference to a selected subpixel if it is in-bounds.

This method will return None when the sample is out-of-bounds. All errors that could occur due to overflow have been eliminated while construction the View.

fn get_mut_sample(self: &mut Self, channel: u8, x: u32, y: u32) -> Option<&mut <P as >::Subpixel>
where
    Buffer: AsMut<[<P as >::Subpixel]>

Get a mutable reference to a selected subpixel if it is in-bounds.

This is relevant only when constructed with FlatSamples::as_view_with_mut_samples. This method will return None when the sample is out-of-bounds. All errors that could occur due to overflow have been eliminated while construction the View.

WARNING: Note that of course samples may alias, so that the mutable reference returned here can in fact modify more than the coordinate in the argument.

fn min_length(self: &Self) -> usize

Get the minimum length of a buffer such that all in-bounds samples have valid indices.

See FlatSamples::min_length. This method will always succeed.

fn image_slice(self: &Self) -> &[<P as >::Subpixel]

Return the portion of the buffer that holds sample values.

While this can not fail–the validity of all coordinates has been validated during the conversion from FlatSamples–the resulting slice may still contain holes.

fn image_mut_slice(self: &mut Self) -> &mut [<P as >::Subpixel]
where
    Buffer: AsMut<[<P as >::Subpixel]>

Return the mutable portion of the buffer that holds sample values.

This is relevant only when constructed with FlatSamples::as_view_with_mut_samples. While this can not fail–the validity of all coordinates has been validated during the conversion from FlatSamples–the resulting slice may still contain holes.

fn shrink_to(self: &mut Self, width: u32, height: u32)

Shrink the inner image.

The new dimensions will be the minimum of the previous dimensions. Since the set of in-bounds pixels afterwards is a subset of the current ones, this is allowed on a View. Note that you can not change the number of channels as an intrinsic property of P.

fn try_upgrade(self: Self) -> Result<ViewMut<Buffer, P>, (Error, Self)>
where
    Buffer: AsMut<[<P as >::Subpixel]>

Try to convert this into an image with mutable pixels.

The resulting image implements GenericImage in addition to GenericImageView. While this has mutable samples, it does not enforce that pixel can not alias and that samples are packed enough for a mutable pixel reference. This is slightly cheaper than the chain self.into_inner().as_view_mut() and keeps the View alive on failure.

# use image::RgbImage;
# use image::Rgb;
let mut buffer = RgbImage::new(480, 640).into_flat_samples();
let view = buffer.as_view_with_mut_samples::<Rgb<u8>>().unwrap();

// Inspect some pixels, …

// Doesn't fail because it was originally an `RgbImage`.
let view_mut = view.try_upgrade().unwrap();

impl<Buffer, P> Freeze for View<Buffer, P>

impl<Buffer, P> RefUnwindSafe for View<Buffer, P>

impl<Buffer, P> Send for View<Buffer, P>

impl<Buffer, P> Sync for View<Buffer, P>

impl<Buffer, P> Unpin for View<Buffer, P>

impl<Buffer, P> UnwindSafe for View<Buffer, P>

impl<Buffer, P: $crate::clone::Clone + Pixel> Clone for View<Buffer, P>

fn clone(self: &Self) -> View<Buffer, P>

impl<Buffer, P: $crate::fmt::Debug + Pixel> Debug for View<Buffer, P>

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

impl<Buffer, P: Pixel> GenericImageView for View<Buffer, P>

fn dimensions(self: &Self) -> (u32, u32)
fn get_pixel(self: &Self, x: u32, y: u32) -> <Self as >::Pixel

impl<T> Any for View<Buffer, P>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for View<Buffer, P>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for View<Buffer, P>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for View<Buffer, P>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for View<Buffer, P>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Pointable for View<Buffer, P>

unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

impl<T> ToOwned for View<Buffer, P>

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for View<Buffer, P>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for View<Buffer, P>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for View<Buffer, P>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>