Struct Rect 

pub struct Rect<T: Copy> { /* private fields */ }

矩形结构体

Note

若启用perffeature，所有方法都将不会进行标准化检查，以提高性能， 该情况下，如有必要，需手动进行标准化检查，以保证方法计算结果的正确性

Implementations

impl<T: Copy + Ord> Rect<T>

pub fn new(left: T, top: T, right: T, bottom: T) -> Self

创建一个新的矩形

Example

use ponsic_types::Rect;
let rect = Rect::new(1, 2, 3, 4);

impl<T: Copy> Rect<T>

pub fn left(&self) -> T

返回矩形的左边界坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的左边界坐标， 若要标准化矩形，请使用 [normalize()]

pub fn top(&self) -> T

返回矩形的上边界坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的上边界坐标， 若要标准化矩形，请使用 [normalize()]

pub fn right(&self) -> T

返回矩形的右边界坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的右边界坐标， 若要标准化矩形，请使用 [normalize()]

pub fn bottom(&self) -> T

返回矩形的下边界坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的下边界坐标， 若要标准化矩形，请使用 [normalize()]

pub fn left_top(&self) -> Point<T>

返回矩形的左上角坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的左上角坐标， 若要标准化矩形，请使用 [normalize()]

pub fn right_top(&self) -> Point<T>

返回矩形的右上角坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的右上角坐标， 若要标准化矩形，请使用 [normalize()]

pub fn left_bottom(&self) -> Point<T>

返回矩形的左下角坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的左下角坐标， 若要标准化矩形，请使用 [normalize()]

pub fn right_bottom(&self) -> Point<T>

返回矩形的右下角坐标

Note

若矩形不是标准化的，该函数可能不会返回实际的右下角坐标， 若要标准化矩形，请使用 [normalize()]

impl<T: Copy + Ord> Rect<T>

若启用perffeature，以下方法将不会进行标准化检查，以提高性能

pub fn set_left(&mut self, left: T)

设置矩形的左边界坐标

pub fn set_top(&mut self, top: T)

设置矩形的上边界坐标

pub fn set_right(&mut self, right: T)

设置矩形的右边界坐标

pub fn set_bottom(&mut self, bottom: T)

设置矩形的下边界坐标

pub fn set_left_top(&mut self, left: T, top: T)

设置矩形的左上角坐标

pub fn set_right_top(&mut self, right: T, top: T)

设置矩形的右上角坐标

pub fn set_left_bottom(&mut self, left: T, bottom: T)

设置矩形的左下角坐标

pub fn set_right_bottom(&mut self, right: T, bottom: T)

设置矩形的右下角坐标

impl<T: Copy + Sub<Output = T>> Rect<T>

pub fn width(&self) -> T

返回矩形的宽度

Note

若矩形不是标准化的，该函数可能会返回负值， 若要标准化矩形，请使用 [normalize()]

pub fn height(&self) -> T

返回矩形的高度

Note

若矩形不是标准化的，该函数可能会返回负值， 若要标准化矩形，请使用 [normalize()]

pub fn size(&self) -> Size<T>

返回矩形的尺寸

Note

若矩形不是标准化的，该函数返回值可能包含负值， 若要标准化矩形，请使用 [normalize()]

impl<T: Copy + Ord> Rect<T>

pub fn contains(&self, point: Point<T>) -> bool

判断点是否在矩形区域内

Note

如果点在矩形的边界上，此函数也会返回 false； 如果需要包含点在矩形边界上的情况，请使用 [contains_with_bound()]

pub fn contains_with_bound(&self, point: Point<T>) -> bool

判断点是否在矩形区域内

Note

如果点在矩形的边界上，此函数也会返回 true； 如果需要排除点在矩形边界上的情况，请使用 [contains_with_bound()]

pub fn intersects(&self, other: &Rect<T>) -> bool

判断此矩形与另一个矩形是否存在交集

如果另一个矩形与此矩形存在公共区域，则返回 true

pub fn intersected(&self, other: &Self) -> Option<Self>

计算两个矩形的交集

此函数会计算两个矩形的重叠部分，并返回一个包含该信息的新矩形

Note

若两个矩形没有交集，则返回 None

pub fn united(&self, other: &Rect<T>) -> Rect<T>

计算两个矩形的并集

此函数会计算两个矩形所在位置的最小轮廓矩形，并返回一个包含该信息的新矩形

impl<T: Copy + AddAssign + Ord> Rect<T>

pub fn adjust(&mut self, left: T, top: T, right: T, bottom: T)

调整矩形的位置

impl<T: Copy + Add<Output = T> + Div<i32, Output = T>> Rect<T>

pub fn center(&self) -> Point<T>

返回矩形的中心点坐标

Trait Implementations

impl<T: Copy + Ord> BitAnd for Rect<T>

type Output = Option<Rect<T>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T: Copy + Ord> BitOr for Rect<T>

type Output = Rect<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T: Clone + Copy> Clone for Rect<T>

fn clone(&self) -> Rect<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy> Debug for Rect<T>

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

Formats the value using the given formatter.

impl<T: Default + Copy> Default for Rect<T>

fn default() -> Rect<T>

Returns the “default value” for a type.

impl<T: Copy + Add<Output = T>> From<(Point<T>, Size<T>)> for Rect<T>

fn from((pos, size): (Point<T>, Size<T>)) -> Self

Converts to this type from the input type.

impl<T: Hash + Copy> Hash for Rect<T>

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<T: PartialEq + Copy> PartialEq for Rect<T>

fn eq(&self, other: &Rect<T>) -> 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<T: Copy + Copy> Copy for Rect<T>

impl<T: Eq + Copy> Eq for Rect<T>

impl<T: Copy> StructuralPartialEq for Rect<T>