pasture-core 0.5.0

A framework for working with point cloud data
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

use std::cmp;

use nalgebra::{Scalar, Vector3};

/// Helper trait for computing minimum and maximum values for types. This is used in conjunction
/// with `PrimitiveType` to enable min/max computations even for vector types
pub trait MinMax {
    /// Computes the infimum of this value and `other`. For scalar types, the infimum is simply the
    /// minimum of the two types (as defined by `PartialOrd`), for vector types, this is the component-wise
    /// minimum
    ///
    /// # Example
    /// ```
    /// use pasture_core::math::MinMax;
    /// # use pasture_core::nalgebra::Vector3;
    ///
    /// assert_eq!(5i32.infimum(&3i32), 3i32);
    /// assert_eq!(Vector3::new(1.0, 2.0, 3.0).infimum(&Vector3::new(2.0, 1.0, 0.0)), Vector3::new(1.0, 1.0, 0.0));
    /// ```
    fn infimum(&self, other: &Self) -> Self;
    /// Computes the supremum of this value and `other`. For scalar types, the infimum is simply the
    /// maximum of the two types (as defined by `PartialOrd`), for vector types, this is the component-wise
    /// maximum
    ///
    /// # Example
    /// ```
    /// use pasture_core::math::MinMax;
    /// # use pasture_core::nalgebra::Vector3;
    ///
    /// assert_eq!(5i32.supremum(&3i32), 5i32);
    /// assert_eq!(Vector3::new(1.0, 2.0, 3.0).supremum(&Vector3::new(2.0, 1.0, 4.0)), Vector3::new(2.0, 2.0, 4.0));
    /// ```
    fn supremum(&self, other: &Self) -> Self;
}

macro_rules! impl_minmax_for_primitive_type {
    ($type:tt) => {
        impl MinMax for $type {
            fn infimum(&self, other: &Self) -> Self {
                cmp::min(*self, *other)
            }

            fn supremum(&self, other: &Self) -> Self {
                cmp::max(*self, *other)
            }
        }
    };
}

impl_minmax_for_primitive_type! {u8}
impl_minmax_for_primitive_type! {u16}
impl_minmax_for_primitive_type! {u32}
impl_minmax_for_primitive_type! {u64}
impl_minmax_for_primitive_type! {i8}
impl_minmax_for_primitive_type! {i16}
impl_minmax_for_primitive_type! {i32}
impl_minmax_for_primitive_type! {i64}
impl_minmax_for_primitive_type! {bool}

impl MinMax for f32 {
    fn infimum(&self, other: &Self) -> Self {
        if *self < *other {
            *self
        } else {
            *other
        }
    }

    fn supremum(&self, other: &Self) -> Self {
        if *self > *other {
            *self
        } else {
            *other
        }
    }
}

impl MinMax for f64 {
    fn infimum(&self, other: &Self) -> Self {
        if *self < *other {
            *self
        } else {
            *other
        }
    }

    fn supremum(&self, other: &Self) -> Self {
        if *self > *other {
            *self
        } else {
            *other
        }
    }
}

impl<T: MinMax + Scalar> MinMax for Vector3<T> {
    fn infimum(&self, other: &Self) -> Self {
        Vector3::new(
            self.x.infimum(&other.x),
            self.y.infimum(&other.y),
            self.z.infimum(&other.z),
        )
    }

    fn supremum(&self, other: &Self) -> Self {
        Vector3::new(
            self.x.supremum(&other.x),
            self.y.supremum(&other.y),
            self.z.supremum(&other.z),
        )
    }
}