Struct picto::View

pub struct View<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel,  { /* fields omitted */ }

A view into a Buffer.

The View is a readable and writable borrowed region within a Buffer and it’s parametrized over two types, the Pixel and Channel.

The same details on those types from Buffer hold true for View, except it doesn’t own any Data.

There is no functional difference between a Buffer and a View that encompasses the whole Buffer region.

Implementations

impl<'a, P, C> View<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

pub fn from_raw(
    width: u32,
    height: u32,
    data: &mut [C]
) -> Result<View<'_, P, C>, ()>

pub fn with_stride(
    width: u32,
    height: u32,
    stride: usize,
    data: &mut [C]
) -> Result<View<'_, P, C>, ()>

pub fn stride(&self) -> usize

Get the stride.

pub fn region(&self) -> Region

Get the region.

pub fn width(&self) -> u32

Get the width.

pub fn height(&self) -> u32

Get the height.

pub fn get(&self, x: u32, y: u32) -> P

Get the Pixel at the given coordinates.

Panics

Requires that x < self.width() and y < self.height(), otherwise it will panic.

pub fn set(&mut self, x: u32, y: u32, pixel: &P)

Set the Pixel at the given coordinates.

Panics

Requires that x < self.width() and y < self.height(), otherwise it will panic.

pub fn readable(&self, region: Builder) -> Read<'_, P, C>

Get a read-only view of the given region.

Panics

Requires that x + width <= self.width() and y + height <= self.height(), otherwise it will panic.

pub fn writable(&mut self, region: Builder) -> Write<'_, P, C>

Get a write-only view of the given region.

Panics

Requires that x + width <= self.width() and y + height <= self.height(), otherwise it will panic.

pub fn view(&mut self, region: Builder) -> View<'_, P, C>

Get a mutable view of the given region.

Panics

Requires that x + width <= self.width() and y + height <= self.height(), otherwise it will panic.

pub fn fill(&mut self, pixel: &P)

Fill the view with the given pixel.

Example

use picto::read;
use picto::Region;
use picto::color::Rgb;

let mut image = read::from_path::<Rgb, u8, _>("tests/boat.xyz").unwrap();
let mut view  = image.view(Region::new().x(10).y(10).width(20).height(30));

// Make a 20x20 pixel region black at offset 10,10.
view.fill(&Rgb::new(0.0, 0.0, 0.0));

pub fn pixels(&self) -> Pixels<'_, P, C>

Get a mutable Iterator over the pixels.

pub fn pixels_mut(&mut self) -> PixelsMut<'_, P, C>

Get a mutable Iterator over the pixels.

Example

use picto::read;
use picto::Region;
use picto::color::{Mix, Rgb};

let mut image = read::from_path::<Rgb, u8, _>("tests/boat.xyz").unwrap();
let mut view  = image.view(Region::new().x(50).y(20));

for (_, _, mut px) in view.pixels_mut() {
    // Get the pixel value.
    let p = px.get();

    // Mix the color with red.
    let p = p.mix(&Rgb::new(1.0, 0.0, 0.0), 0.5);

    // Set the pixel value.
    px.set(&p);
}

pub fn into_owned(&self) -> Buffer<P, C, Vec<C>>

Create a Buffer from the View.

pub fn convert<PO, CO>(&self) -> Buffer<PO, CO, Vec<CO>> where
    P: Into<PO>,
    PO: Write<CO>,
    CO: Channel, 

Convert the View to a Buffer with different channel and pixel type.

Example

use picto::read;
use picto::Region;
use picto::color::{Rgb, Rgba};

let mut image = read::from_path::<Rgba, u8, _>("tests/rainbow.png").unwrap();
let     view  = image.view(Region::new().x(10).y(10).width(20).height(20));

// Convert the 20x20 region from Rgba to Rgb.
view.convert::<Rgb, u8>();

pub fn convert_with<PO, CO, F>(&self, func: F) -> Buffer<PO, CO, Vec<CO>> where
    F: FnMut(P) -> PO,
    PO: Write<CO>,
    CO: Channel, 

Convert the View to a Buffer with a closure handling the conversion.

Example

use picto::read;
use picto::Region;
use picto::color::{Rgb, Rgba, Srgb};

let mut image = read::from_path::<Rgba, u8, _>("tests/rainbow.png").unwrap();
let     view  = image.view(Region::new().x(10).y(10).width(20).height(20));

// Convert the 20x20 region from Rgba to sRGB.
view.convert_with::<Rgb, f32, _>(|p| Srgb::new(p.red, p.green, p.blue).into());

Trait Implementations

impl<'a, P: Debug, C: Debug> Debug for View<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

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

Formats the value using the given formatter.

impl<'a, P, C> From<&'a View<'a, P, C>> for Read<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

fn from(value: &'a View<'a, P, C>) -> Read<'a, P, C>

Performs the conversion.

impl<'a, P, C, D> From<&'a mut Buffer<P, C, D>> for View<'a, P, C> where
    P: Write<C> + Read<C>,
    C: Channel,
    D: DerefMut<Target = [C]>, 

fn from(value: &'a mut Buffer<P, C, D>) -> View<'a, P, C>

Performs the conversion.

impl<'a, P, C> From<&'a mut View<'a, P, C>> for View<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

fn from(value: &'a mut View<'a, P, C>) -> View<'a, P, C>

Performs the conversion.

impl<'a, P, C> From<&'a mut View<'a, P, C>> for Write<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

fn from(value: &'a mut View<'a, P, C>) -> Write<'a, P, C>

Performs the conversion.

impl<'a, P, C> From<View<'a, P, C>> for Read<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

fn from(value: View<'a, P, C>) -> Read<'a, P, C>

Performs the conversion.

impl<'a, P, C> From<View<'a, P, C>> for Write<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

fn from(value: View<'a, P, C>) -> Write<'a, P, C>

Performs the conversion.

impl<'a, P: PartialEq, C: PartialEq> PartialEq<View<'a, P, C>> for View<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel, 

fn eq(&self, other: &View<'a, P, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &View<'a, P, C>) -> bool

This method tests for !=.

impl<'a, P, C> StructuralPartialEq for View<'a, P, C> where
    P: Read<C> + Write<C>,
    C: Channel,