1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
//! Implements a 2d region
use crate::{Number, Float};
use super::vector2::Vector2;
use crate::core;
/// Implements a region between min and max
#[derive(Clone)]
pub struct Bound2<T: Number> {
pub min: Vector2<T>,
pub max: Vector2<T>
}
pub type Bound2i = Bound2<i32>;
pub type Bound2f = Bound2<Float>;
fn min<T: Number> (a: T, b: T) -> T {
if b < a {
return b;
}
a
}
fn max<T: Number> (a: T, b: T) -> T {
if b > a {
return b;
}
a
}
impl<T: Number> Bound2<T> {
/// Creates a new bound from two points
///
/// p0 does not have to be smaller than p1
pub fn new(p0: &Vector2<T>, p1: &Vector2<T>) -> Self {
let min = Vector2::new_xy(min(p0.x, p1.x), min(p0.y, p1.y));
let max = Vector2::new_xy(max(p0.x, p1.x), max(p0.y, p1.y));
Self { min, max }
}
pub fn new_xyxy(x1: T, y1: T, x2: T, y2: T) -> Self {
Self::new(
&Vector2::new_xy(x1, y1),
&Vector2::new_xy(x2, y2),
)
}
/// Calculates the diagonal vector
///
/// Can be used to calculate the size of the bound
///
/// # Examples
///
/// ```
/// use rendering::core::Bound2i;
/// let b = Bound2i::new_xyxy(2, 2, 6, 7);
/// let diag = b.diagonal();
///
/// assert!(diag.x == 4 && diag.y == 5);
/// ```
pub fn diagonal(&self) -> Vector2<T> {
self.max - self.min
}
/// Calculates the area of of the bounded region
///
/// # Examples
///
/// ```
/// use rendering::core::Bound2i;
/// let b = Bound2i::new_xyxy(10, 10, 20, 20);
///
/// assert!(b.area() == 100);
/// ```
pub fn area(&self) -> T {
let diag = self.diagonal();
return diag.x * diag.y;
}
}
impl From<&Bound2i> for Bound2f {
fn from(b: &Bound2i) -> Self {
Self {
min: core::Vector2f::from(b.min),
max: core::Vector2f::from(b.max),
}
}
}
impl From<&Bound2f> for Bound2i {
fn from(b: &Bound2f) -> Self {
Self {
min: core::Vector2i::from(b.min),
max: core::Vector2i::from(b.max),
}
}
}
/// Finds the intersected area between two bounds
pub fn intersect<T: Number>(a: &Bound2<T>, b: &Bound2<T>) -> Bound2<T> {
Bound2::new(
&Vector2::new_xy(max(a.min.x, b.min.x), max(a.min.y, b.min.y)),
&Vector2::new_xy(min(a.max.x, b.max.x), min(a.max.y, b.max.y)),
)
}
#[cfg(test)]
mod tests {
use super::*;
fn create_test() -> Bound2<i32> {
Bound2::new(
&Vector2::new_xy(1, 2),
&Vector2::new_xy(10, 3)
)
}
#[test]
fn area() {
let b = create_test();
assert!(b.area() == 9);
}
#[test]
fn intersect_test() {
let b1 = Bound2i::new_xyxy(10, 10, 20, 20);
let b2 = Bound2i::new_xyxy(2, 11, 22, 17);
let b = intersect(&b1, &b2);
assert!(
b.min.x == 10 &&
b.min.y == 11 &&
b.max.x == 20 &&
b.max.y == 17
)
}
}
|
