plozone 0.1.0

3D spatial zone engine: geofencing, octree hole-scanning, realtime sync (WebSocket + QUIC + io_uring), voxel pathfinding, and AV sensor fusion.
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

//! `no_std` zone store fallback (feature `embedded`).
//!
//! A linear-scan zone store for embedded / bare-metal targets where `rstar`
//! (which requires `std`) is unavailable. Suitable for < ~500 zones.

extern crate alloc;

use alloc::boxed::Box;
use alloc::vec;
use alloc::vec::Vec;

use crate::zone::ZoneShape;

/// `no_std` zone store — linear scan, no R-tree.
pub struct ZoneStoreEmbed {
    zones: Vec<(u32, Box<dyn ZoneShape>)>,
}

impl ZoneStoreEmbed {
    pub fn new() -> Self {
        Self { zones: vec![] }
    }

    pub fn add(&mut self, id: u32, shape: Box<dyn ZoneShape>) {
        self.zones.retain(|(i, _)| *i != id);
        self.zones.push((id, shape));
    }

    pub fn remove(&mut self, id: u32) {
        self.zones.retain(|(i, _)| *i != id);
    }

    pub fn query_enu(&self, p: [f64; 3]) -> Vec<u32> {
        self.zones
            .iter()
            .filter(|(_, s)| s.contains_enu(p))
            .map(|(id, _)| *id)
            .collect()
    }

    pub fn len(&self) -> usize {
        self.zones.len()
    }

    pub fn is_empty(&self) -> bool {
        self.zones.is_empty()
    }
}

impl Default for ZoneStoreEmbed {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::zone::Zone;
    use crate::coord::EnuConverter;
    use crate::zone::zone_to_shape;

    #[test]
    fn embed_add_query_remove() {
        let conv = EnuConverter::new(0.0, 0.0, 0.0);
        let mut store = ZoneStoreEmbed::new();

        let shape = zone_to_shape(
            &Zone::Cylinder {
                center: [0.0, 0.0],
                radius_m: 10.0,
                z_min: 0.0,
                z_max: 5.0,
            },
            &conv,
        );
        store.add(1, shape);
        assert_eq!(store.query_enu([0.0, 0.0, 2.5]), vec![1]);
        assert!(store.query_enu([20.0, 0.0, 2.5]).is_empty());

        store.remove(1);
        assert!(store.is_empty());
    }
}