# [−][src]Struct image::flat::ViewMut

    pub struct ViewMut<Buffer, P: Pixel> where
        Buffer: AsMut<[P::Subpixel]>,  { /* fields omitted */ }

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`

## Methods

### `impl<Buffer, P: Pixel> ViewMut<Buffer, P> where
Buffer: AsMut<[P::Subpixel]>,` [src]

#### `pub fn into_inner(self) -> FlatSamples<Buffer>`[src]

Take out the sample buffer.

Gives up the normalization invariants on the buffer format.

#### `pub fn flat(&self) -> &FlatSamples<Buffer>`[src]

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.

#### `pub fn samples(&self) -> &Buffer`[src]

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`.

#### `pub fn min_length(&self) -> usize`[src]

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.

#### `pub fn get_sample(&self, channel: u8, x: u32, y: u32) -> Option<&P::Subpixel> where
Buffer: AsRef<[P::Subpixel]>,` [src]

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`.

#### `pub fn get_mut_sample(
&mut self,
channel: u8,
x: u32,
y: u32
) -> Option<&mut P::Subpixel>`[src]

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`.

#### `pub fn image_slice(&self) -> &[P::Subpixel] where
Buffer: AsRef<[P::Subpixel]>,` [src]

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.

#### `pub fn image_mut_slice(&mut self) -> &mut [P::Subpixel]`[src]

Return the mutable buffer that holds sample values.

#### `pub fn shrink_to(&mut self, width: u32, height: u32)`[src]

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`.

## Trait Implementations

### `impl<Buffer, P: Pixel> GenericImageView for ViewMut<Buffer, P> where
Buffer: AsMut<[P::Subpixel]> + AsRef<[P::Subpixel]>,` [src]

#### `type Pixel = P`

The type of pixel.

#### `type InnerImageView = Self`

Underlying image type. This is mainly used by SubImages in order to always have a reference to the original image. This allows for less indirections and it eases the use of nested SubImages. Read more

#### `fn dimensions(&self) -> (u32, u32)`[src]

The width and height of this image.

#### `fn bounds(&self) -> (u32, u32, u32, u32)`[src]

The bounding rectangle of this image.

#### `fn in_bounds(&self, x: u32, y: u32) -> bool`[src]

Returns true if this x, y coordinate is contained inside the image.

#### `fn get_pixel(&self, x: u32, y: u32) -> Self::Pixel`[src]

Returns the pixel located at (x, y) Read more

#### `fn inner(&self) -> &Self`[src]

Returns a reference to the underlying image.

#### `fn width(&self) -> u32`[src]

The width of this image.

#### `fn height(&self) -> u32`[src]

The height of this image.

#### `unsafe fn unsafe_get_pixel(&self, x: u32, y: u32) -> Self::Pixel`[src]

Returns the pixel located at (x, y) Read more

####
ⓘImportant traits for Pixels<'a, I>

### Important traits for Pixels<'a, I>

`impl<'a, I: GenericImageView> Iterator for Pixels<'a, I> type Item = (u32, u32, I::Pixel);`
`fn pixels(&self) -> Pixels<Self>`[src]

Returns an Iterator over the pixels of this image. The iterator yields the coordinates of each pixel along with their value Read more

#### `fn view(
&self,
x: u32,
y: u32,
width: u32,
height: u32
) -> SubImage<&Self::InnerImageView>`[src]

Returns an subimage that is an immutable view into this image.

### `impl<Buffer, P: Pixel> GenericImage for ViewMut<Buffer, P> where
Buffer: AsMut<[P::Subpixel]> + AsRef<[P::Subpixel]>,` [src]

#### `type InnerImage = Self`

Underlying image type. This is mainly used by SubImages in order to always have a reference to the original image. This allows for less indirections and it eases the use of nested SubImages. Read more

#### `fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut Self::Pixel`[src]

Gets a reference to the mutable pixel at location `(x, y)` Read more

#### `fn put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)`[src]

Put a pixel at location (x, y) Read more

#### `fn blend_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)`[src]

Put a pixel at location (x, y), taking into account alpha channels Read more

#### `fn inner_mut(&mut self) -> &mut Self`[src]

Returns a mutable reference to the underlying image.

#### `unsafe fn unsafe_put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)`[src]

Puts a pixel at location (x, y) Read more

####
ⓘImportant traits for MutPixels<'a, I>

### Important traits for MutPixels<'a, I>

`impl<'a, I: GenericImage + 'a> Iterator for MutPixels<'a, I> where
I::Pixel: 'a,
<I::Pixel as Pixel>::Subpixel: 'a, type Item = (u32, u32, &'a mut I::Pixel);`
`fn pixels_mut(&mut self) -> MutPixels<Self>`[src]

Deprecated:

This cannot be implemented safely in Rust. Please use the image buffer directly.

Returns an Iterator over mutable pixels of this image. The iterator yields the coordinates of each pixel along with a mutable reference to them. Read more

#### `fn copy_from<O>(&mut self, other: &O, x: u32, y: u32) -> bool where
O: GenericImageView<Pixel = Self::Pixel>,` [src]

Copies all of the pixels from another image into this image. Read more

#### `fn sub_image(
&mut self,
x: u32,
y: u32,
width: u32,
height: u32
) -> SubImage<&mut Self::InnerImage>`[src]

Returns a subimage that is a view into this image.

### `impl<Buffer: Clone, P: Clone + Pixel> Clone for ViewMut<Buffer, P> where
Buffer: AsMut<[P::Subpixel]>,` [src]

#### `fn clone(&self) -> ViewMut<Buffer, P>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl<Buffer: Debug, P: Debug + Pixel> Debug for ViewMut<Buffer, P> where
Buffer: AsMut<[P::Subpixel]>,` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl<Buffer, P> Send for ViewMut<Buffer, P> where
Buffer: Send,
P: Send,`

### `impl<Buffer, P> Unpin for ViewMut<Buffer, P> where
Buffer: Unpin,
P: Unpin,`

### `impl<Buffer, P> Sync for ViewMut<Buffer, P> where
Buffer: Sync,
P: Sync,`

### `impl<Buffer, P> UnwindSafe for ViewMut<Buffer, P> where
Buffer: UnwindSafe,
P: UnwindSafe,`

### `impl<Buffer, P> RefUnwindSafe for ViewMut<Buffer, P> where
Buffer: RefUnwindSafe,
P: RefUnwindSafe,`

## Blanket Implementations

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> SetParameter for T`[src]

#### `fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
T: Parameter<Self>,` [src]

Sets `value` as a parameter of `self`.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)