ezquadtree 0.0.1

Simple and easy to use QuadTree
Documentation 
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

use super::*;


#[test]
fn test_rectangle() {
    let r = Rectangle::new(10, 10, 50, 50);
    assert_eq!(r, Rectangle::new(10, 10, 50, 50));
}

// #[test]
// fn test_circle() {
//     let r = Circle::new(10, 10, 50);
//     assert_eq!(r, Circle::new(10, 10, 50));
// }

#[test]
fn test_quadtree_insert_query() {

    let foos = create_foo(0..9);
    let mut result: Vec<Foo> = Vec::new();

    let (w, h) = (40, 40);
    let bb = Rectangle::new(0, 0, w, h);
    let mut qt = QuadTree::new(bb, 4);

    let bb = Rectangle::new(0, 0, w+10, h+10);

    insert_foo(&mut qt, &foos);

    qt.query(Some(&bb), &mut |e| result.push(e.clone()));

    assert_eq!(result, foos);
}

#[test]
fn test_len() {
    let foos = create_foo(0..9);

    let (w, h) = (40, 40);
    let bb = Rectangle::new(0, 0, w, h);

    let mut qt = QuadTree::new(bb.clone(), 4);

    insert_foo(&mut qt, &foos);

    assert_eq!(qt.len(), 9);
}

#[test]
fn test_insert_same_location() {
    let old = Foo::new(5, 5, "old");
    let new = Foo::new(5, 5, "new");

    let (w, h) = (40, 40);
    let bb = Rectangle::new(0, 0, w, h);

    let mut qt = QuadTree::new(bb, 4);

    qt.insert(&old);
    qt.insert(&new);

    let mut result = Vec::new();

    qt.query(None, &mut |e| result.push(e.clone()));

    assert_eq!(result, vec![old]);
    assert_eq!(qt.len(), 1);
}

#[test]
fn test_replace_same_location() {
    let old = Foo::new(5, 5, "old");
    let new = Foo::new(5, 5, "new");

    let (w, h) = (40, 40);
    let bb = Rectangle::new(0, 0, w, h);

    let mut qt = QuadTree::new(bb, 4);

    qt.insert(&old);
    let return_of_replace = qt.replace(&new);

    let mut result = Vec::new();

    qt.query(None, &mut |e| result.push(e.clone()));

    assert_eq!(Some(old), return_of_replace);
    assert_eq!(result, vec![new]);
    assert_eq!(qt.len(), 1);
}

#[derive(Debug, Clone)]
struct Foo {
    item: String,
    x: u32,
    y: u32,
}

impl Foo {
    fn new(x: u32, y: u32, item: &str) -> Self {
        Self { item: item.to_string(), x, y }
    }
}

impl Vector for Foo {
    fn as_point(&self) -> (u32, u32) {
        (self.x, self.y)
    }
}

impl PartialEq for Foo {
    fn eq(&self, other: &Foo) -> bool {
        self.x == other.x && self.y == other.y
    }
}

fn create_foo(range: std::ops::Range<u32>) -> Vec<Foo> {
    let mut foos = Vec::new();
    for i in range {
        foos.push(Foo::new(i, 0, "FOOOOOOO"));
    }
    foos
}

fn insert_foo(qt: &mut QuadTree<Foo>, foos: &Vec<Foo>) {
    for f in foos.iter() {
        qt.insert(f);
    }
}