use-polyhedron 0.0.6

Polyhedron primitives for the RustUse geometry workspace
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
130
131
132
133
134
135
136

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

use use_vector::Vector3;

/// A polyhedron vertex.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Vertex {
    position: Vector3,
}

impl Vertex {
    /// Creates a vertex.
    #[must_use]
    pub const fn new(position: Vector3) -> Self {
        Self { position }
    }

    /// Returns the vertex position.
    #[must_use]
    pub const fn position(self) -> Vector3 {
        self.position
    }
}

/// A polyhedron edge represented by vertex indices.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Edge {
    start: usize,
    end: usize,
}

impl Edge {
    /// Creates an edge between two vertex indices.
    #[must_use]
    pub const fn new(start: usize, end: usize) -> Self {
        Self { start, end }
    }

    /// Returns the edge endpoints.
    #[must_use]
    pub const fn endpoints(self) -> (usize, usize) {
        (self.start, self.end)
    }
}

/// A polyhedron face record represented by vertex indices.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PolyhedronFace {
    vertices: Vec<usize>,
}

impl PolyhedronFace {
    /// Creates a face record.
    #[must_use]
    pub const fn new(vertices: Vec<usize>) -> Self {
        Self { vertices }
    }

    /// Returns the face vertex indices.
    #[must_use]
    pub fn vertices(&self) -> &[usize] {
        &self.vertices
    }
}

/// A polyhedron count summary.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Polyhedron {
    vertex_count: usize,
    edge_count: usize,
    face_count: usize,
}

impl Polyhedron {
    /// Creates a polyhedron from positive vertex, edge, and face counts.
    #[must_use]
    pub const fn from_counts(
        vertex_count: usize,
        edge_count: usize,
        face_count: usize,
    ) -> Option<Self> {
        if vertex_count > 0 && edge_count > 0 && face_count > 0 {
            Some(Self {
                vertex_count,
                edge_count,
                face_count,
            })
        } else {
            None
        }
    }

    /// Returns the vertex count.
    #[must_use]
    pub const fn vertex_count(self) -> usize {
        self.vertex_count
    }

    /// Returns the edge count.
    #[must_use]
    pub const fn edge_count(self) -> usize {
        self.edge_count
    }

    /// Returns the face count.
    #[must_use]
    pub const fn face_count(self) -> usize {
        self.face_count
    }

    /// Returns `V - E + F`.
    #[must_use]
    pub const fn euler_characteristic(self) -> isize {
        self.vertex_count as isize - self.edge_count as isize + self.face_count as isize
    }
}

#[cfg(test)]
mod tests {
    use super::{Edge, Polyhedron, PolyhedronFace, Vertex};
    use use_vector::Vector3;

    #[test]
    fn stores_polyhedron_records() {
        let vertex = Vertex::new(Vector3::new(1.0, 2.0, 3.0));
        let edge = Edge::new(0, 1);
        let face = PolyhedronFace::new(vec![0, 1, 2]);
        let polyhedron = Polyhedron::from_counts(8, 12, 6).expect("valid counts");

        assert_eq!(vertex.position(), Vector3::new(1.0, 2.0, 3.0));
        assert_eq!(edge.endpoints(), (0, 1));
        assert_eq!(face.vertices(), &[0, 1, 2]);
        assert_eq!(polyhedron.euler_characteristic(), 2);
    }
}