Struct Rectangle

Source

pub struct Rectangle<P> { /* private fields */ }

Expand description

An n-dimensional rectangle defined by its two corners.

This rectangle can be directly inserted into an r-tree.

Note: Despite being called rectangle, this struct can be used with more than two dimensions by using an appropriate point type.

§Type parameters

P: The rectangle’s Point type.

Implementations§

Source §

impl Rectangle

Source

pub fn from_corners(corner_1: P, corner_2: P) -> Self
where P: Point,

Creates a new rectangle defined by two corners.

Examples found in repository ?

examples/hashmap.rs (line 18)

10fn main() {
11    // A hashmap of 2D rectangles will be the underlying collection.
12    let rect_hashmap: HashMap<i32, Rectangle<(i32, i32)>> = HashMap::new();
13
14    // Wrap `RTreed` around the hashmap.
15    let mut rtreed = RTreed::new(rect_hashmap);
16
17    // Insert two rectangles, recording them in the R-tree.
18    rtreed.insert(1, Rectangle::from_corners((0, 0), (1, 1)));
19    rtreed.insert(2, Rectangle::from_corners((1, 1), (2, 2)));
20
21    // Locate the two rectangles in the R-tree.
22    assert_eq!(
23        rtreed
24            .rtree()
25            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
26            .count(),
27        2
28    );
29
30    // Now remove one of the rectangles, recording this in the R-tree.
31    rtreed.remove(&1);
32
33    // Make the same query to the R-tree as before.
34    // Only one rectangle is now present.
35    assert_eq!(
36        rtreed
37            .rtree()
38            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
39            .count(),
40        1
41    );
42}

More examples

Hide additional examples

examples/vec.rs (line 16)

8fn main() {
9    // A vec of 2D rectangles will be the underlying collection.
10    let rect_vec: Vec<Rectangle<(i32, i32)>> = Vec::new();
11
12    // Wrap `RTreed` around the vec.
13    let mut rtreed = RTreed::new(rect_vec);
14
15    // Push two rectangles, recording them in the R-tree.
16    rtreed.push(Rectangle::from_corners((0, 0), (1, 1)));
17    rtreed.push(Rectangle::from_corners((1, 1), (2, 2)));
18
19    // Locate the two rectangles in the R-tree.
20    assert_eq!(
21        rtreed
22            .rtree()
23            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
24            .count(),
25        2
26    );
27
28    // Access a rectangle by its index in the vec.
29    assert_eq!(
30        rtreed.get(&0),
31        Some(&Rectangle::from_corners((0, 0), (1, 1)))
32    );
33
34    // Push one more rectangle.
35    rtreed.push(Rectangle::from_corners((2, 2), (3, 3)));
36
37    // Swap-remove the first rectangle.
38    assert_eq!(
39        rtreed.swap_remove(&0),
40        Rectangle::from_corners((0, 0), (1, 1))
41    );
42
43    // Now the latest-pushed rectangle occupies the place of the first
44    // rectangle. The second rectangle is as it was previously.
45    assert_eq!(
46        rtreed.get(&0),
47        Some(&Rectangle::from_corners((2, 2), (3, 3)))
48    );
49    assert_eq!(
50        rtreed.get(&1),
51        Some(&Rectangle::from_corners((1, 1), (2, 2)))
52    );
53    assert_eq!(
54        rtreed
55            .rtree()
56            .locate_in_envelope(AABB::from_corners((0, 0), (3, 3)))
57            .count(),
58        2
59    );
60}

examples/undoredo.rs (line 22)

11fn main() {
12    // A hashmap of 2D rectangles will be the underlying container.
13    let rect_hashmap: HashMap<i32, Rectangle<(i32, i32)>> = HashMap::new();
14    // Wrap `RTreed` around the hashmap and then `Recorder` around it.
15    let mut recorder = Recorder::<
16        RTreed<HashMap<i32, Rectangle<(i32, i32)>>>,
17        RTreedHalfDelta<i32, Rectangle<(i32, i32)>>,
18    >::new(RTreed::new(rect_hashmap));
19    let mut undoredo: UndoRedo<RTreedDelta<i32, Rectangle<(i32, i32)>>> = UndoRedo::new();
20
21    // Insert two rectangles, recording them in the R-tree.
22    recorder.insert(1, Rectangle::from_corners((0, 0), (1, 1)));
23    undoredo.commit(&mut recorder);
24
25    recorder.insert(2, Rectangle::from_corners((1, 1), (2, 2)));
26    undoredo.commit(&mut recorder);
27
28    // Locate the two rectangles in the R-tree.
29    assert_eq!(
30        recorder
31            .container()
32            .rtree()
33            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
34            .count(),
35        2
36    );
37
38    undoredo.undo(&mut recorder);
39
40    // After undo, there is now only one rectangle.
41    assert_eq!(
42        recorder
43            .container()
44            .rtree()
45            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
46            .count(),
47        1
48    );
49
50    undoredo.undo(&mut recorder);
51
52    // After another undo, there is no rectangles anymore.
53    assert_eq!(
54        recorder
55            .container()
56            .rtree()
57            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
58            .count(),
59        0
60    );
61
62    undoredo.redo(&mut recorder);
63
64    // After redo, we are back to one rectangle.
65    assert_eq!(
66        recorder
67            .container()
68            .rtree()
69            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
70            .count(),
71        1
72    );
73
74    undoredo.redo(&mut recorder);
75
76    // After another redo, we are back to two rectangles.
77    assert_eq!(
78        recorder
79            .container()
80            .rtree()
81            .locate_in_envelope(AABB::from_corners((0, 0), (2, 2)))
82            .count(),
83        2
84    );
85}