YetAnotherGeometryLibrary 0.1.2

A geometry library. Includes computational geometry.
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::simple_tri::SimpleTriangle;
use crate::vectors::Vector3;

#[derive(Debug, PartialEq, Copy, Clone)]
pub struct Tetrahedron {
    pub origin: Vector3,
    pub a: Vector3,
    pub b: Vector3,
    pub c: Vector3,
}

impl Tetrahedron {
    pub fn new(origin: Vector3, a: Vector3, b: Vector3, c: Vector3) -> Self {
        Tetrahedron { origin, a, b, c }
    }
    pub fn from_points(a: Vector3, b: Vector3, c: Vector3, d: Vector3) -> Self {
        Tetrahedron::new(a, b - a, c - a, d - a)
    }
    pub fn volume(&self) -> f64 {
        // This is the scalar triple product, or the determinant of the matrix with a,b,and c as its rows. It is the volume of the parallelepiped with sides a,b,c.
        self.a.dot(&self.b.cross(&self.c)) / 6.0
    }
    pub fn pt_1(&self) -> Vector3 {
        self.origin
    }
    pub fn pt_2(&self) -> Vector3 {
        self.origin + self.a
    }
    pub fn pt_3(&self) -> Vector3 {
        self.origin + self.b
    }
    pub fn pt_4(&self) -> Vector3 {
        self.origin + self.c
    }
    pub fn point_in(&self, other: Vector3) -> bool {
        let other_adj = other - self.origin;
        let point_in_threespace = Vector3::new(
            other_adj.dot(&self.a) / self.a.dot(&self.a),
            other_adj.dot(&self.b) / self.b.dot(&self.b),
            other_adj.dot(&self.c) / self.c.dot(&self.c),
        );
        (point_in_threespace.x >= 0.0)
            && (point_in_threespace.y >= 0.0)
            && (point_in_threespace.z >= 0.0)
            && (point_in_threespace.dot(&Vector3::new(1.0, 1.0, 1.0)) <= 1.0)
    }
    /// Returns the surface triangles. If the volume is positive, the normals of the triangles will point outward, and if it is negative, they will point inward
    ///
    /// returns: [SimpleTriangle;4]
    ///
    /// # Examples
    ///
    /// ```
    ///
    /// ```
    pub fn surface(&self) -> [SimpleTriangle; 4] {
        [
            SimpleTriangle::new(self.pt_1(), self.pt_3(), self.pt_2()),
            SimpleTriangle::new(self.pt_1(), self.pt_4(), self.pt_3()),
            SimpleTriangle::new(self.pt_1(), self.pt_2(), self.pt_4()),
            SimpleTriangle::new(self.pt_2(), self.pt_3(), self.pt_4()),
        ]
    }
    pub fn surface_area(&self) -> f64 {
        let sf = self.surface();
        sf[0].area() + sf[1].area() + sf[2].area() + sf[3].area()
    }
}
#[derive(Debug, PartialEq, Clone)]
pub struct Polyhedron {
    points: Vec<Vector3>,
    faces: Vec<(usize, usize, usize)>,
}

impl Polyhedron {
    //TODO:Impl
    fn check_homeomorphism(points: &Vec<Vector3>, faces: &Vec<(usize, usize, usize)>) -> bool {
        true
    }
    //TODO:Impl
    fn check_normals(points: &Vec<Vector3>, faces: &Vec<(usize, usize, usize)>) -> bool {
        true
    }
    //TODO:Impl
    pub fn new(points: Vec<Vector3>, faces: Vec<(usize, usize, usize)>) -> Result<Self, String> {
        Err("NOIMPL".to_string())
    }
    //TODO:Impl
    pub fn new_autofix(
        points: Vec<Vector3>,
        faces: Vec<(usize, usize, usize)>,
    ) -> Result<Self, String> {
        Err("NOIMPL".to_string())
    }
    pub fn new_unchecked(points: Vec<Vector3>, faces: Vec<(usize, usize, usize)>) -> Self {
        Self { points, faces }
    }
    pub fn cube() -> Self {
        Self::new_unchecked(
            vec![
                Vector3::zero(),
                Vector3::ihat(),
                Vector3::jhat(),
                Vector3::khat(),
                Vector3::new(0.0, 1.0, 1.0),
                Vector3::new(1.0, 0.0, 1.0),
                Vector3::new(1.0, 1.0, 0.0),
                Vector3::new(1.0, 1.0, 1.0),
            ],
            vec![
                (0, 2, 1),
                (0, 1, 3),
                (0, 3, 2),
                (6, 1, 2),
                (5, 3, 1),
                (4, 2, 3),
                (4, 5, 7),
                (4, 7, 6),
                (5, 6, 7),
                (4, 3, 5),
                (4, 6, 2),
                (5, 1, 6),
            ],
        )
    }
    pub fn get_faces(&self) -> Vec<SimpleTriangle> {
        self.faces
            .iter()
            .map(|x| SimpleTriangle::new(self.points[x.0], self.points[x.1], self.points[x.2]))
            .collect()
    }
    pub fn get_volume(&self) -> f64 {
        self.faces
            .iter()
            .map(|x| {
                Tetrahedron::from_points(
                    self.points[0],
                    self.points[x.0],
                    self.points[x.1],
                    self.points[x.2],
                )
                .volume()
            })
            .sum()
    }
    pub fn get_obj(&self) -> String {
        let mut ret = "# Automatically generated from polyhederon by YAGL\n".to_string();
        for pt in &self.points {
            ret += format!("v {} {} {}\n", pt.x, pt.y, pt.z).as_str();
        }
        for f in &self.faces {
            ret += format!("f {} {} {}\n", f.0 + 1, f.1 + 1, f.2 + 1).as_str();
        }
        ret
    }
}