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

autd3_core/geometry/
mod.rs
