terrustrial 0.1.1

A Rust library for geospatial statistics, variograms, and kriging.
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

use ultraviolet::{DIsometry3, DVec3};

#[derive(Clone, Copy, Debug)]
pub struct Aabb {
    pub center: DVec3,
    pub half_extents: DVec3,
}

impl Aabb {
    #[inline(always)]
    pub fn new(center: DVec3, half_extents: DVec3) -> Self {
        Self {
            center,
            half_extents,
        }
    }

    #[inline(always)]
    pub fn from_min_max(min: DVec3, max: DVec3) -> Self {
        let center = (min + max) / 2.0;
        let half_extents = (max - min) / 2.0;
        Self {
            center,
            half_extents,
        }
    }

    #[inline(always)]
    pub fn mins(&self) -> DVec3 {
        self.center - self.half_extents
    }

    #[inline(always)]
    pub fn maxs(&self) -> DVec3 {
        self.center + self.half_extents
    }

    #[inline(always)]
    pub fn contains_point(&self, point: DVec3) -> bool {
        let mins = self.mins();
        let maxs = self.maxs();

        mins.x <= point.x
            && mins.y <= point.y
            && mins.z <= point.z
            && maxs.x >= point.x
            && maxs.y >= point.y
            && maxs.z >= point.z
    }

    #[inline(always)]
    pub fn distance_to_point_squared(&self, point: DVec3) -> f64 {
        let inside = self.contains_point(point);
        let clamped = point.clamped(self.mins(), self.maxs());

        let mult = -(inside as u8 as f64);

        let delta = point - clamped;
        delta.dot(delta) * mult
    }

    #[inline(always)]
    pub fn transformed_by(&self, transform: DIsometry3) -> Self {
        let m = transform.rotation.into_matrix();

        let mut out_c = transform.translation;
        let mut out_r = DVec3::zero();

        out_c += m * self.center;
        out_r += (m * self.half_extents).abs();

        Self {
            center: out_c,
            half_extents: out_r,
        }
    }

    #[inline(always)]
    pub fn discretize_in(&self, disc: DVec3, out: &mut Vec<DVec3>) {
        let dx = disc.x;
        let dy = disc.y;
        let dz = disc.z;
        //ceil gaurantees that the resulting discretization will have dimensions upperbounded by dx, dy, dz
        let nx = ((self.maxs().x - self.mins().x) / dx).ceil() as usize;
        let ny = ((self.maxs().y - self.mins().y) / dy).ceil() as usize;
        let nz = ((self.maxs().z - self.mins().z) / dz).ceil() as usize;

        //step size in each direction
        let step_x = (self.maxs().x - self.mins().x) / (nx as f64);
        let step_y = (self.maxs().y - self.mins().y) / (ny as f64);
        let step_z = (self.maxs().z - self.mins().z) / (nz as f64);

        let mut x = self.mins().x + step_x / 2.0;
        while x <= self.maxs().x {
            let mut y = self.mins().y + step_y / 2.0;
            while y <= self.maxs().y {
                let mut z = self.mins().z + step_z / 2.0;
                while z <= self.maxs().z {
                    out.push(DVec3::new(x, y, z));
                    z += step_z;
                }
                y += step_y;
            }
            x += step_x;
        }
    }

    #[inline(always)]
    pub fn merged(&self, other: &Self) -> Self {
        Self::from_min_max(
            self.mins().min_by_component(other.mins()),
            self.maxs().max_by_component(other.maxs()),
        )
    }
}