Struct `ViewMut`

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

A mutable owning version of a flat buffer.

While this wraps a buffer similar to ImageBuffer, this is mostly intended as a utility. The library endorsed normalized representation is still ImageBuffer. Also, the implementation of AsMut<[P::Subpixel]> must always yield the same buffer. Therefore there is no public way to construct this with an owning buffer.

Inner invariants

For all indices inside bounds, the corresponding index is valid in the buffer
There is no aliasing of samples
The samples are packed, i.e. self.inner.layout.sample_stride == 1
P::channel_count() agrees with self.inner.layout.channels

Implementations

`impl<Buffer, P: Pixel> ViewMut<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 sample buffer 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. However, its contents can be accessed mutable through a slice with image_mut_slice.

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 get_sample(self: &Self, channel: u8, x: u32, y: u32) -> Option<&::Subpixel> where Buffer: AsRef<[::Subpixel]>

Get a reference to a selected subpixel.

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 ::Subpixel>

Get a mutable reference to a selected sample.

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 image_slice(self: &Self) -> &[::Subpixel] where Buffer: AsRef<[::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 [::Subpixel]

Return the mutable buffer that holds sample values.

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.

`impl<Buffer, P> Freeze for ViewMut<Buffer, P>`

`impl<Buffer, P> RefUnwindSafe for ViewMut<Buffer, P>`

`impl<Buffer, P> Send for ViewMut<Buffer, P>`

`impl<Buffer, P> Sync for ViewMut<Buffer, P>`

`impl<Buffer, P> Unpin for ViewMut<Buffer, P>`

`impl<Buffer, P> UnwindSafe for ViewMut<Buffer, P>`

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

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

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

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

`impl<Buffer, P: Pixel> GenericImage for ViewMut<Buffer, P>`

fn get_pixel_mut(self: &mut Self, x: u32, y: u32) -> &mut <Self as >::Pixel
fn put_pixel(self: &mut Self, x: u32, y: u32, pixel: <Self as >::Pixel)
fn blend_pixel(self: &mut Self, x: u32, y: u32, pixel: <Self as >::Pixel)

`impl<Buffer, P: Pixel> GenericImageView for ViewMut<Buffer, P>`

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

`impl<T> Any for ViewMut<Buffer, P>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for ViewMut<Buffer, P>`

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

`impl<T> BorrowMut for ViewMut<Buffer, P>`

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

`impl<T> CloneToUninit for ViewMut<Buffer, P>`

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

`impl<T> From for ViewMut<Buffer, P>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Pointable for ViewMut<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 ViewMut<Buffer, P>`

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

`impl<T, U> Into for ViewMut<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 ViewMut<Buffer, P>`

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

`impl<T, U> TryInto for ViewMut<Buffer, P>`

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