procedural_modelling 0.4.2

A framework-agnostic Procedural Modelling crate.
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

use super::{ScalarPlus, VecN};
use crate::math::{Rotator, Scalar};
use nalgebra::SMatrix;

/// Rotation in D-dimensional space.
#[derive(Clone, Debug, Copy)]
pub struct NdRotate<S: Scalar, const D: usize> {
    // TODO: this is clumsy. But nd-rotation is extremely hard to implement. We should probably update the traits to not include the hard to implement rotation methods!
    /// rotation in 2D space
    rot2: Option<nalgebra::Rotation2<S>>,

    /// rotation in 3D space
    rot3: Option<nalgebra::Rotation3<S>>,

    /// rotation in D-dimensional space
    rot: Option<SMatrix<S, D, D>>,
}

impl<S: Scalar, const D: usize> NdRotate<S, D> {
    /// Creates a new rotation from a matrix.
    pub fn new(matrix: SMatrix<S, D, D>) -> Self {
        if D == 2 {
            Self {
                rot2: Some(nalgebra::Rotation2::from_matrix_unchecked(
                    matrix.fixed_view::<2, 2>(0, 0).into_owned(),
                )),
                rot3: None,
                rot: None,
            }
        } else if D == 3 {
            Self {
                rot2: None,
                rot3: Some(nalgebra::Rotation3::from_matrix_unchecked(
                    matrix.fixed_view::<3, 3>(0, 0).into_owned(),
                )),
                rot: None,
            }
        } else {
            Self {
                rot2: None,
                rot3: None,
                rot: Some(matrix),
            }
        }
    }

    /// Returns the matrix representation of the rotation.
    pub fn to_matrix(&self) -> SMatrix<S, D, D> {
        if let Some(rot) = &self.rot {
            rot.clone()
        } else if let Some(rot2) = &self.rot2 {
            rot2.matrix().fixed_resize::<D, D>(S::zero())
        } else if let Some(rot3) = &self.rot3 {
            rot3.matrix().fixed_resize::<D, D>(S::zero())
        } else {
            panic!("No rotation matrix found");
        }
    }

    /// Creates a new rotation from an angle. Works only for 2D.
    pub fn from_angle(angle: S) -> Self
    where
        S: ScalarPlus,
    {
        assert!(D == 2);
        Self {
            rot2: Some(nalgebra::Rotation2::new(angle)),
            rot3: None,
            rot: None,
        }
    }

    /// Creates a new rotation from an axis and an angle. Works only for 3D.
    pub fn from_axis_angle(axis: nalgebra::Unit<VecN<S, 3>>, angle: S) -> Self
    where
        S: ScalarPlus,
    {
        assert!(D == 3);
        Self {
            rot2: None,
            rot3: Some(nalgebra::Rotation3::from_axis_angle(&axis, angle)),
            rot: None,
        }
    }

    /// Creates a new rotation from a rotation arc.
    pub fn from_rotation_arc(from: VecN<S, D>, to: VecN<S, D>) -> Self
    where
        S: ScalarPlus,
    {
        if D == 2 {
            Self {
                rot2: Some(nalgebra::Rotation2::rotation_between(
                    &from.fixed_rows::<2>(0).into_owned(),
                    &to.fixed_rows::<2>(0).into_owned(),
                )),
                rot3: None,
                rot: None,
            }
        } else if D == 3 {
            Self {
                rot2: None,
                rot3: Some(
                    nalgebra::Rotation3::rotation_between(
                        &from.fixed_rows::<3>(0).into_owned(),
                        &to.fixed_rows::<3>(0).into_owned(),
                    )
                    .expect("Failed to create rotation"),
                ),
                rot: None,
            }
        } else {
            todo!();
        }
    }
}

impl<S: Scalar, const D: usize> Rotator<VecN<S, D>> for NdRotate<S, D> {}

#[cfg(test)]
mod tests {
    use crate::extensions::nalgebra::*;
    use nalgebra::SMatrix;

    #[test]
    fn test_nd_rotate() {
        let rot = NdRotate::<f64, 2>::from_angle(std::f64::consts::PI / 2.0);
        let expected = SMatrix::<f64, 2, 2>::new(0.0, -1.0, 1.0, 0.0);
        assert!((rot.to_matrix() - expected).abs().max() < 1e-10);

        let rot = NdRotate::<f64, 2>::from_rotation_arc(
            VecN::<f64, 2>::new(1.0, 0.0),
            VecN::<f64, 2>::new(0.0, 1.0),
        );
        let expected = SMatrix::<f64, 2, 2>::new(0.0, -1.0, 1.0, 0.0);
        assert!((rot.to_matrix() - expected).abs().max() < 1e-10);

        let rot = NdRotate::<f64, 3>::from_axis_angle(
            nalgebra::Unit::new_normalize(VecN::<f64, 3>::new(1.0, 0.0, 0.0)),
            std::f64::consts::PI / 2.0,
        );
        let expected = SMatrix::<f64, 3, 3>::new(1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0);
        assert!((rot.to_matrix() - expected).abs().max() < 1e-10);

        // The same operation can be done with a rotation arc
        let rot = NdRotate::<f64, 3>::from_rotation_arc(
            VecN::<f64, 3>::new(0.0, 1.0, 0.0),
            VecN::<f64, 3>::new(0.0, 0.0, 1.0),
        );
        let expected = SMatrix::<f64, 3, 3>::new(1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0);
        assert!((rot.to_matrix() - expected).abs().max() < 1e-10);
    }
}