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

use crate::quaternion::Quaternion;
use crate::vectors::Vector3;
use std::ops;

#[derive(Debug, PartialEq, Copy, Clone)]
pub struct Rotation3 {
    pub q: Quaternion,
}

impl ops::Neg for Rotation3 {
    type Output = Rotation3;
    fn neg(self) -> Self::Output {
        Rotation3 {
            q: self.q.inverse(),
        }
    }
}

impl ops::Add<Rotation3> for Rotation3 {
    type Output = Rotation3;
    fn add(self, other: Rotation3) -> Self::Output {
        Rotation3 {
            q: other.q * self.q,
        }
    }
}

impl ops::Sub<Rotation3> for Rotation3 {
    type Output = Rotation3;
    fn sub(self, other: Rotation3) -> Self::Output {
        Rotation3 {
            q: other.q.inverse() * self.q,
        }
    }
}

impl ops::Mul<f64> for Rotation3 {
    type Output = Rotation3;
    fn mul(self, other: f64) -> Self::Output {
        if self.q.w >= 0.0 {
            Rotation3::from_axis_angle(
                self.q
                    .get_vector()
                    .with_magnitude(2.0 * other * self.q.w.acos()),
            )
        } else {
            Rotation3::from_axis_angle(
                -self
                    .q
                    .get_vector()
                    .with_magnitude(2.0 * other * (-self.q.w).acos()),
            )
        }
    }
}
impl ops::Div<f64> for Rotation3 {
    type Output = Rotation3;
    fn div(self, other: f64) -> Self::Output {
        self * (1.0 / other)
    }
}

impl Rotation3 {
    pub fn identity() -> Rotation3 {
        Rotation3 {
            q: Quaternion::default(),
        }
    }
    pub fn new(q: Quaternion) -> Rotation3 {
        Rotation3 { q }
    }
    pub fn rotate_vector(&self, vector: Vector3) -> Vector3 {
        // https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Using_quaternions_as_rotations
        // Accessed 2025/5/9
        let other_as_quaternion = Quaternion::from_scalar_vector(0.0, vector);
        (other_as_quaternion.clone() * self.q * (other_as_quaternion.inverse())).get_vector()
    }
    pub fn from_axis_angle(v: Vector3) -> Rotation3 {
        Rotation3 {
            q: Quaternion::from_rotation_vector(v),
        }
    }
}