Struct Bounds 

pub struct Bounds { /* private fields */ }

Rectangle bounds for defining sub-regions of images.

Implementations

impl Bounds

pub fn width(&self) -> Pt

pub fn height(&self) -> Pt

impl Bounds

pub fn new(x: Pt, y: Pt, width: Pt, height: Pt) -> Self

Creates new bounds with the specified dimensions.

Examples found in repository

examples/subimage_example.rs (line 22)

        fn initialize(_context: &mut Context) -> Self {
            const TREE_PNG: &[u8] = include_bytes!("../assets/happy-tree.png");
            let decoded = image::load_from_memory(TREE_PNG).expect("failed to decode happy-tree.png");
            let rgba = decoded.to_rgba8();
            let (w, h) = (rgba.width(), rgba.height());
            let tree = Image::new_from_rgba8(Pt::from(w), Pt::from(h), rgba.as_raw())
                .expect("failed to create happy-tree image");

            let crop_w = (w / 2).max(1);
            let crop_h = (h / 2).max(1);
            let tree_sub = Image::sub_image(
                tree,
                Bounds::new(Pt::from(0.0), Pt::from(0.0), Pt::from(crop_w), Pt::from(crop_h)),
            )
                .expect("failed to create sub image");

            Self { tree, tree_sub }
        }

examples/demo.rs (line 33)

        fn initialize(_context: &mut Context) -> Self {
            const TREE_PNG: &[u8] = include_bytes!("../assets/happy-tree.png");
            let decoded = image::load_from_memory(TREE_PNG).expect("failed to decode happy-tree.png");
            let rgba = decoded.to_rgba8();
            let (w, h) = (rgba.width(), rgba.height());
            let tree = Image::new_from_rgba8(Pt::from(w), Pt::from(h), rgba.as_raw())
                .expect("failed to create happy-tree image");

            let mut rgba = vec![0u8; 20 * 20 * 4];
            for y in 0..20u32 {
                for x in 0..20u32 {
                    let i = ((y * 20 + x) * 4) as usize;
                    let on = ((x / 5 + y / 5) % 2) == 0;
                    rgba[i] = if on { 255 } else { 30 };
                    rgba[i + 1] = if on { 80 } else { 200 };
                    rgba[i + 2] = if on { 80 } else { 255 };
                    rgba[i + 3] = 255;
                }
            }
            let image =
                Image::new_from_rgba8(Pt::from(20.0), Pt::from(20.0), &rgba).expect("failed to create test image");
            let image_sub = Image::sub_image(image, Bounds::new(Pt::from(5.0), Pt::from(5.0), Pt::from(10.0), Pt::from(10.0)))
                .expect("failed to create sub image");
            let image_clone = Image::new_from_image(image).expect("failed to create image from image");

            Self {
                tree,
                image,
                image_sub,
                image_clone,
            }
        }

Trait Implementations

impl Clone for Bounds

fn clone(&self) -> Bounds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bounds

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

Formats the value using the given formatter.

impl Hash for Bounds

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Bounds

fn eq(&self, other: &Bounds) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Bounds

impl Eq for Bounds

impl StructuralPartialEq for Bounds