autd3_core/geometry/
mod.rs

1pub(crate) mod device;
2mod rotation;
3mod transducer;
4
5/// a complex number
6pub type Complex = nalgebra::Complex<f32>;
7/// 3-dimensional column vector.
8pub type Vector3 = nalgebra::Vector3<f32>;
9/// 3-dimensional unit vector.
10pub type UnitVector3 = nalgebra::UnitVector3<f32>;
11/// 3-dimensional point.
12pub type Point3 = nalgebra::Point3<f32>;
13/// A quaternion.
14pub type Quaternion = nalgebra::Quaternion<f32>;
15/// A unit quaternion.
16pub type UnitQuaternion = nalgebra::UnitQuaternion<f32>;
17/// A 3-dimensional translation.
18pub type Translation = nalgebra::Translation3<f32>;
19/// A 3-dimensional isometry.
20pub type Isometry = nalgebra::Isometry3<f32>;
21
22pub use bvh::aabb::Aabb;
23pub use device::*;
24use getset::CopyGetters;
25pub use rotation::*;
26pub use transducer::*;
27
28use derive_more::{Deref, IntoIterator};
29
30/// Geometry of the devices.
31#[derive(Deref, CopyGetters, IntoIterator)]
32pub struct Geometry {
33    #[deref]
34    #[into_iterator(ref)]
35    pub(crate) devices: Vec<Device>,
36    #[doc(hidden)]
37    #[getset(get_copy = "pub")]
38    version: usize,
39}
40
41impl Geometry {
42    /// Creates a new [`Geometry`].
43    #[must_use]
44    pub fn new(devices: Vec<Device>) -> Self {
45        let mut geometry = Self {
46            devices,
47            version: 0,
48        };
49        geometry.assign_idx();
50        geometry
51    }
52
53    fn assign_idx(&mut self) {
54        self.devices
55            .iter_mut()
56            .enumerate()
57            .for_each(|(dev_idx, dev)| {
58                dev.idx = dev_idx as _;
59                dev.transducers.iter_mut().for_each(|tr| {
60                    tr.dev_idx = dev_idx as _;
61                });
62            });
63    }
64
65    /// Gets the number of devices.
66    #[must_use]
67    pub fn num_devices(&self) -> usize {
68        self.devices.len()
69    }
70
71    /// Gets the number of transducers.
72    #[must_use]
73    pub fn num_transducers(&self) -> usize {
74        self.iter().map(|dev| dev.num_transducers()).sum()
75    }
76
77    /// Gets the center of the transducers.
78    #[must_use]
79    pub fn center(&self) -> Point3 {
80        Point3::from(
81            self.iter().map(|d| d.center().coords).sum::<Vector3>() / self.devices.len() as f32,
82        )
83    }
84
85    /// Axis Aligned Bounding Box of devices.
86    #[must_use]
87    pub fn aabb(&self) -> Aabb<f32, 3> {
88        self.iter()
89            .fold(Aabb::empty(), |aabb, dev| aabb.join(dev.aabb()))
90    }
91
92    /// Reconfigure the geometry.
93    pub fn reconfigure<D: Into<Device>, F: Fn(&Device) -> D>(&mut self, f: F) {
94        self.devices.iter_mut().for_each(|dev| {
95            *dev = f(dev).into();
96        });
97        self.assign_idx();
98        self.version += 1;
99    }
100}
101
102impl<'a> IntoIterator for &'a mut Geometry {
103    type Item = &'a mut Device;
104    type IntoIter = std::slice::IterMut<'a, Device>;
105
106    fn into_iter(self) -> Self::IntoIter {
107        self.version += 1;
108        self.devices.iter_mut()
109    }
110}
111
112impl std::ops::DerefMut for Geometry {
113    fn deref_mut(&mut self) -> &mut Self::Target {
114        self.version += 1;
115        &mut self.devices
116    }
117}
118
119#[cfg(test)]
120pub(crate) mod tests {
121    use rand::Rng;
122
123    use crate::common::{deg, mm};
124
125    use super::*;
126
127    macro_rules! assert_approx_eq_vec3 {
128        ($a:expr, $b:expr) => {
129            approx::assert_abs_diff_eq!($a.x, $b.x, epsilon = 1e-3);
130            approx::assert_abs_diff_eq!($a.y, $b.y, epsilon = 1e-3);
131            approx::assert_abs_diff_eq!($a.z, $b.z, epsilon = 1e-3);
132        };
133    }
134
135    pub struct TestDevice {
136        pub rotation: UnitQuaternion,
137        pub transducers: Vec<Transducer>,
138    }
139
140    impl TestDevice {
141        pub fn new_autd3(pos: Point3) -> Self {
142            Self::new_autd3_with_rot(pos, UnitQuaternion::identity())
143        }
144
145        pub fn new_autd3_with_rot(pos: Point3, rot: impl Into<UnitQuaternion>) -> Self {
146            let rotation = rot.into();
147            let isometry = Isometry {
148                rotation,
149                translation: Translation::from(pos),
150            };
151            Self {
152                rotation,
153                transducers: itertools::iproduct!(0..14, 0..18)
154                    .map(|(y, x)| {
155                        Transducer::new(
156                            (isometry * (10.16 * mm * Point3::new(x as f32, y as f32, 0.))).xyz(),
157                        )
158                    })
159                    .collect(),
160            }
161        }
162    }
163
164    impl From<TestDevice> for Device {
165        fn from(dev: TestDevice) -> Self {
166            Self::new(dev.rotation, dev.transducers)
167        }
168    }
169
170    pub fn create_device(n: u8) -> Device {
171        Device::new(
172            UnitQuaternion::identity(),
173            (0..n).map(|_| Transducer::new(Point3::origin())).collect(),
174        )
175    }
176
177    pub fn create_geometry(n: u16, num_trans_in_unit: u8) -> Geometry {
178        Geometry::new((0..n).map(|_| create_device(num_trans_in_unit)).collect())
179    }
180
181    #[rstest::rstest]
182    #[test]
183    #[case(1, vec![create_device(249)])]
184    #[case(2, vec![create_device(249), create_device(249)])]
185    fn test_num_devices(#[case] expected: usize, #[case] devices: Vec<Device>) {
186        let geometry = Geometry::new(devices);
187        assert_eq!(0, geometry.version());
188        assert_eq!(expected, geometry.num_devices());
189        assert_eq!(0, geometry.version());
190    }
191
192    #[rstest::rstest]
193    #[test]
194    #[case(249, vec![create_device(249)])]
195    #[case(498, vec![create_device(249), create_device(249)])]
196    fn test_num_transducers(#[case] expected: usize, #[case] devices: Vec<Device>) {
197        let geometry = Geometry::new(devices);
198        assert_eq!(0, geometry.version());
199        assert_eq!(expected, geometry.num_transducers());
200        assert_eq!(0, geometry.version());
201    }
202
203    #[test]
204    fn test_center() {
205        let geometry = Geometry::new(vec![
206            TestDevice::new_autd3(Point3::origin()).into(),
207            TestDevice::new_autd3(Point3::new(10., 20., 30.)).into(),
208        ]);
209        let expect = geometry
210            .iter()
211            .map(|dev| dev.center().coords)
212            .sum::<Vector3>()
213            / geometry.num_devices() as f32;
214        assert_eq!(0, geometry.version());
215        assert_approx_eq_vec3!(expect, geometry.center());
216        assert_eq!(0, geometry.version());
217    }
218
219    #[test]
220    fn into_iter() {
221        let mut geometry = create_geometry(1, 1);
222        assert_eq!(0, geometry.version());
223        for dev in &mut geometry {
224            _ = dev;
225        }
226        assert_eq!(1, geometry.version());
227    }
228
229    #[rstest::rstest]
230    #[test]
231    #[case(Aabb{min: Point3::origin(), max: Point3::new(172.72 * mm, 132.08 * mm, 0.)}, vec![TestDevice::new_autd3(Point3::origin())])]
232    #[case(Aabb{min: Point3::new(10. * mm, 20. * mm, 30. * mm), max: Point3::new(182.72 * mm, 152.08 * mm, 30. * mm)}, vec![TestDevice::new_autd3(Point3::new(10. * mm, 20. * mm, 30. * mm))])]
233    #[case(Aabb{min: Point3::new(-132.08 * mm, 0., 0.), max: Point3::new(0., 172.72 * mm, 0.)}, vec![TestDevice::new_autd3_with_rot(Point3::origin(), EulerAngle::ZYZ(90. * deg, 0. * deg, 0. * deg))])]
234    #[case(Aabb{min: Point3::new(-132.08 * mm, -10. * mm, 0.), max: Point3::new(172.72 * mm, 162.72 * mm, 10. * mm)}, vec![
235        TestDevice::new_autd3(Point3::origin()),
236        TestDevice::new_autd3_with_rot(Point3::new(0., -10. * mm, 10. * mm), EulerAngle::ZYZ(90. * deg, 0. * deg, 0. * deg))
237    ])]
238    fn aabb(#[case] expect: Aabb<f32, 3>, #[case] dev: Vec<TestDevice>) {
239        let geometry = Geometry::new(dev.into_iter().map(|d| d.into()).collect());
240        assert_approx_eq_vec3!(expect.min, geometry.aabb().min);
241        assert_approx_eq_vec3!(expect.max, geometry.aabb().max);
242    }
243
244    #[test]
245    fn idx() {
246        let geometry = Geometry::new(vec![
247            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
248            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
249        ]);
250        (0..2).for_each(|dev_idx| {
251            assert_eq!(dev_idx, geometry[dev_idx].idx());
252            (0..14 * 18).for_each(|tr_idx| {
253                assert_eq!(tr_idx, geometry[dev_idx][tr_idx].idx());
254                assert_eq!(dev_idx, geometry[dev_idx][tr_idx].dev_idx());
255            });
256        });
257    }
258
259    #[test]
260    fn reconfigure() {
261        let mut geometry = Geometry::new(vec![
262            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
263            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
264        ]);
265
266        let mut rng = rand::rng();
267        let t = Point3::new(rng.random(), rng.random(), rng.random());
268        let rot = UnitQuaternion::new_normalize(Quaternion::new(
269            rng.random(),
270            rng.random(),
271            rng.random(),
272            rng.random(),
273        ));
274
275        geometry.reconfigure(|dev| match dev.idx() {
276            0 => TestDevice::new_autd3_with_rot(t, rot),
277            _ => TestDevice::new_autd3_with_rot(*dev[0].position(), *dev.rotation()),
278        });
279
280        assert_eq!(1, geometry.version());
281        assert_eq!(t, *geometry[0][0].position());
282        assert_eq!(rot, *geometry[0].rotation());
283        assert_eq!(Point3::origin(), *geometry[1][0].position());
284        assert_eq!(UnitQuaternion::identity(), *geometry[1].rotation());
285    }
286}
autd3_core/geometry/mod.rs

autd3_core/geometry/
mod.rs
