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 enabled devices.
66    #[must_use]
67    pub fn num_devices(&self) -> usize {
68        self.devices().count()
69    }
70
71    /// Gets the number of enabled transducers.
72    #[must_use]
73    pub fn num_transducers(&self) -> usize {
74        self.devices().map(|dev| dev.num_transducers()).sum()
75    }
76
77    /// Gets the center of the enabled transducers.
78    #[must_use]
79    pub fn center(&self) -> Point3 {
80        Point3::from(
81            self.devices().map(|d| d.center().coords).sum::<Vector3>() / self.devices.len() as f32,
82        )
83    }
84
85    /// Gets the iterator of enabled devices.
86    pub fn devices(&self) -> impl Iterator<Item = &Device> {
87        self.iter().filter(|dev| dev.enable)
88    }
89
90    /// Gets the mutable iterator of enabled devices.
91    pub fn devices_mut(&mut self) -> impl Iterator<Item = &mut Device> {
92        self.iter_mut().filter(|dev| dev.enable)
93    }
94
95    /// Sets the sound speed of enabled devices.
96    pub fn set_sound_speed(&mut self, c: f32) {
97        self.devices_mut().for_each(|dev| dev.sound_speed = c);
98    }
99
100    /// Sets the sound speed of enabled devices from the temperature `t`.
101    ///
102    /// This is equivalent to `Self::set_sound_speed_from_temp_with(t, 1.4, 8.314_463, 28.9647e-3)`.
103    pub fn set_sound_speed_from_temp(&mut self, t: f32) {
104        self.set_sound_speed_from_temp_with(t, 1.4, 8.314_463, 28.9647e-3);
105    }
106
107    /// Sets the sound speed of enabled devices from the temperature `t`, heat capacity ratio `k`, gas constant `r`, and molar mass `m` [kg/mol].
108    pub fn set_sound_speed_from_temp_with(&mut self, t: f32, k: f32, r: f32, m: f32) {
109        self.devices_mut()
110            .for_each(|dev| dev.set_sound_speed_from_temp_with(t, k, r, m));
111    }
112
113    /// Axis Aligned Bounding Box of enabled devices.
114    #[must_use]
115    pub fn aabb(&self) -> Aabb<f32, 3> {
116        self.devices()
117            .fold(Aabb::empty(), |aabb, dev| aabb.join(dev.aabb()))
118    }
119
120    /// Reconfigure the geometry.
121    pub fn reconfigure<D: Into<Device>, F: Fn(&Device) -> D>(&mut self, f: F) {
122        self.devices = self.devices.iter().map(f).map(|dev| dev.into()).collect();
123        self.assign_idx();
124        self.version += 1;
125    }
126}
127
128impl<'a> IntoIterator for &'a mut Geometry {
129    type Item = &'a mut Device;
130    type IntoIter = std::slice::IterMut<'a, Device>;
131
132    fn into_iter(self) -> Self::IntoIter {
133        self.version += 1;
134        self.devices.iter_mut()
135    }
136}
137
138impl std::ops::DerefMut for Geometry {
139    fn deref_mut(&mut self) -> &mut Self::Target {
140        self.version += 1;
141        &mut self.devices
142    }
143}
144
145#[cfg(test)]
146pub(crate) mod tests {
147    use rand::Rng;
148
149    use crate::defined::{deg, mm};
150
151    use super::*;
152
153    macro_rules! assert_approx_eq_vec3 {
154        ($a:expr, $b:expr) => {
155            approx::assert_abs_diff_eq!($a.x, $b.x, epsilon = 1e-3);
156            approx::assert_abs_diff_eq!($a.y, $b.y, epsilon = 1e-3);
157            approx::assert_abs_diff_eq!($a.z, $b.z, epsilon = 1e-3);
158        };
159    }
160
161    pub struct TestDevice {
162        pub rotation: UnitQuaternion,
163        pub transducers: Vec<Transducer>,
164    }
165
166    impl TestDevice {
167        pub fn new_autd3(pos: Point3) -> Self {
168            Self::new_autd3_with_rot(pos, UnitQuaternion::identity())
169        }
170
171        pub fn new_autd3_with_rot(pos: Point3, rot: impl Into<UnitQuaternion>) -> Self {
172            let rotation = rot.into();
173            let isometry = Isometry {
174                rotation,
175                translation: Translation::from(pos),
176            };
177            Self {
178                rotation,
179                transducers: itertools::iproduct!(0..14, 0..18)
180                    .map(|(y, x)| {
181                        Transducer::new(
182                            (isometry * (10.16 * mm * Point3::new(x as f32, y as f32, 0.))).xyz(),
183                        )
184                    })
185                    .collect(),
186            }
187        }
188    }
189
190    impl From<TestDevice> for Device {
191        fn from(dev: TestDevice) -> Self {
192            Self::new(dev.rotation, dev.transducers)
193        }
194    }
195
196    pub fn create_device(n: u8) -> Device {
197        Device::new(
198            UnitQuaternion::identity(),
199            (0..n).map(|_| Transducer::new(Point3::origin())).collect(),
200        )
201    }
202
203    pub fn create_geometry(n: u16, num_trans_in_unit: u8) -> Geometry {
204        Geometry::new((0..n).map(|_| create_device(num_trans_in_unit)).collect())
205    }
206
207    #[rstest::rstest]
208    #[test]
209    #[case(1, vec![create_device(249)])]
210    #[case(2, vec![create_device(249), create_device(249)])]
211    fn test_num_devices(#[case] expected: usize, #[case] devices: Vec<Device>) {
212        let geometry = Geometry::new(devices);
213        assert_eq!(0, geometry.version());
214        assert_eq!(expected, geometry.num_devices());
215        assert_eq!(0, geometry.version());
216    }
217
218    #[rstest::rstest]
219    #[test]
220    #[case(249, vec![create_device(249)])]
221    #[case(498, vec![create_device(249), create_device(249)])]
222    fn test_num_transducers(#[case] expected: usize, #[case] devices: Vec<Device>) {
223        let geometry = Geometry::new(devices);
224        assert_eq!(0, geometry.version());
225        assert_eq!(expected, geometry.num_transducers());
226        assert_eq!(0, geometry.version());
227    }
228
229    #[test]
230    fn test_center() {
231        let geometry = Geometry::new(vec![
232            TestDevice::new_autd3(Point3::origin()).into(),
233            TestDevice::new_autd3(Point3::new(10., 20., 30.)).into(),
234        ]);
235        let expect = geometry
236            .iter()
237            .map(|dev| dev.center().coords)
238            .sum::<Vector3>()
239            / geometry.num_devices() as f32;
240        assert_eq!(0, geometry.version());
241        assert_approx_eq_vec3!(expect, geometry.center());
242        assert_eq!(0, geometry.version());
243    }
244
245    #[rstest::rstest]
246    #[test]
247    #[case(340.29525e3, 15.)]
248    #[case(343.23497e3, 20.)]
249    #[case(349.04013e3, 30.)]
250    fn test_set_sound_speed_from_temp(#[case] expected: f32, #[case] temp: f32) {
251        let mut geometry = create_geometry(2, 1);
252        assert_eq!(0, geometry.version());
253        geometry.set_sound_speed_from_temp(temp);
254        assert_eq!(1, geometry.version());
255        geometry.iter().for_each(|dev| {
256            approx::assert_abs_diff_eq!(expected * mm, dev.sound_speed, epsilon = 1e-3);
257        });
258    }
259
260    #[rstest::rstest]
261    #[test]
262    #[case(3.402_952_8e5)]
263    #[case(3.432_35e5)]
264    #[case(3.490_401_6e5)]
265    fn test_set_sound_speed(#[case] temp: f32) {
266        let mut geometry = create_geometry(2, 1);
267        assert_eq!(0, geometry.version());
268        geometry.set_sound_speed(temp * mm);
269        assert_eq!(1, geometry.version());
270        geometry.iter().for_each(|dev| {
271            assert_eq!(dev.sound_speed, temp * mm);
272        });
273    }
274
275    #[test]
276    fn into_iter() {
277        let mut geometry = create_geometry(1, 1);
278        assert_eq!(0, geometry.version());
279        for dev in &mut geometry {
280            dev.enable = true;
281        }
282        assert_eq!(1, geometry.version());
283    }
284
285    #[rstest::rstest]
286    #[test]
287    #[case(Aabb{min: Point3::origin(), max: Point3::new(172.72 * mm, 132.08 * mm, 0.)}, vec![TestDevice::new_autd3(Point3::origin())])]
288    #[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))])]
289    #[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))])]
290    #[case(Aabb{min: Point3::new(-132.08 * mm, -10. * mm, 0.), max: Point3::new(172.72 * mm, 162.72 * mm, 10. * mm)}, vec![
291        TestDevice::new_autd3(Point3::origin()),
292        TestDevice::new_autd3_with_rot(Point3::new(0., -10. * mm, 10. * mm), EulerAngle::ZYZ(90. * deg, 0. * deg, 0. * deg))
293    ])]
294    fn aabb(#[case] expect: Aabb<f32, 3>, #[case] dev: Vec<TestDevice>) {
295        let geometry = Geometry::new(dev.into_iter().map(|d| d.into()).collect());
296        assert_approx_eq_vec3!(expect.min, geometry.aabb().min);
297        assert_approx_eq_vec3!(expect.max, geometry.aabb().max);
298    }
299
300    #[test]
301    fn idx() {
302        let geometry = Geometry::new(vec![
303            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
304            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
305        ]);
306        (0..2).for_each(|dev_idx| {
307            assert_eq!(dev_idx, geometry[dev_idx].idx());
308            (0..14 * 18).for_each(|tr_idx| {
309                assert_eq!(tr_idx, geometry[dev_idx][tr_idx].idx());
310                assert_eq!(dev_idx, geometry[dev_idx][tr_idx].dev_idx());
311            });
312        });
313    }
314
315    #[test]
316    fn reconfigure() {
317        let mut geometry = Geometry::new(vec![
318            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
319            TestDevice::new_autd3_with_rot(Point3::origin(), UnitQuaternion::identity()).into(),
320        ]);
321
322        let mut rng = rand::rng();
323        let t = Point3::new(rng.random(), rng.random(), rng.random());
324        let rot = UnitQuaternion::new_normalize(Quaternion::new(
325            rng.random(),
326            rng.random(),
327            rng.random(),
328            rng.random(),
329        ));
330
331        geometry.reconfigure(|dev| match dev.idx() {
332            0 => TestDevice::new_autd3_with_rot(t, rot),
333            _ => TestDevice::new_autd3_with_rot(*dev[0].position(), *dev.rotation()),
334        });
335
336        assert_eq!(1, geometry.version());
337        assert_eq!(t, *geometry[0][0].position());
338        assert_eq!(rot, *geometry[0].rotation());
339        assert_eq!(Point3::origin(), *geometry[1][0].position());
340        assert_eq!(UnitQuaternion::identity(), *geometry[1].rotation());
341    }
342}
autd3_core/geometry/mod.rs

autd3_core/geometry/
mod.rs
