re_types/datatypes/
rotation_axis_angle.rs

1// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/rust/api.rs
2// Based on "crates/store/re_types/definitions/rerun/datatypes/rotation_axis_angle.fbs".
3
4#![allow(unused_braces)]
5#![allow(unused_imports)]
6#![allow(unused_parens)]
7#![allow(clippy::allow_attributes)]
8#![allow(clippy::clone_on_copy)]
9#![allow(clippy::cloned_instead_of_copied)]
10#![allow(clippy::map_flatten)]
11#![allow(clippy::needless_question_mark)]
12#![allow(clippy::new_without_default)]
13#![allow(clippy::redundant_closure)]
14#![allow(clippy::too_many_arguments)]
15#![allow(clippy::too_many_lines)]
16#![allow(clippy::wildcard_imports)]
17
18use ::re_types_core::SerializationResult;
19use ::re_types_core::try_serialize_field;
20use ::re_types_core::{ComponentBatch as _, SerializedComponentBatch};
21use ::re_types_core::{ComponentDescriptor, ComponentType};
22use ::re_types_core::{DeserializationError, DeserializationResult};
23
24/// **Datatype**: 3D rotation represented by a rotation around a given axis.
25#[derive(Clone, Debug, Copy, PartialEq)]
26pub struct RotationAxisAngle {
27    /// Axis to rotate around.
28    ///
29    /// This is not required to be normalized.
30    /// However, if normalization of the rotation axis fails (typically due to a zero vector)
31    /// the rotation is treated as an invalid transform, unless the angle is zero in which case
32    /// it is treated as an identity.
33    pub axis: crate::datatypes::Vec3D,
34
35    /// How much to rotate around the axis.
36    pub angle: crate::datatypes::Angle,
37}
38
39::re_types_core::macros::impl_into_cow!(RotationAxisAngle);
40
41impl ::re_types_core::Loggable for RotationAxisAngle {
42    #[inline]
43    fn arrow_datatype() -> arrow::datatypes::DataType {
44        use arrow::datatypes::*;
45        DataType::Struct(Fields::from(vec![
46            Field::new("axis", <crate::datatypes::Vec3D>::arrow_datatype(), false),
47            Field::new("angle", <crate::datatypes::Angle>::arrow_datatype(), false),
48        ]))
49    }
50
51    fn to_arrow_opt<'a>(
52        data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
53    ) -> SerializationResult<arrow::array::ArrayRef>
54    where
55        Self: Clone + 'a,
56    {
57        #![allow(clippy::manual_is_variant_and)]
58        use ::re_types_core::{Loggable as _, ResultExt as _, arrow_helpers::as_array_ref};
59        use arrow::{array::*, buffer::*, datatypes::*};
60        Ok({
61            let fields = Fields::from(vec![
62                Field::new("axis", <crate::datatypes::Vec3D>::arrow_datatype(), false),
63                Field::new("angle", <crate::datatypes::Angle>::arrow_datatype(), false),
64            ]);
65            let (somes, data): (Vec<_>, Vec<_>) = data
66                .into_iter()
67                .map(|datum| {
68                    let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
69                    (datum.is_some(), datum)
70                })
71                .unzip();
72            let validity: Option<arrow::buffer::NullBuffer> = {
73                let any_nones = somes.iter().any(|some| !*some);
74                any_nones.then(|| somes.into())
75            };
76            as_array_ref(StructArray::new(
77                fields,
78                vec![
79                    {
80                        let (somes, axis): (Vec<_>, Vec<_>) = data
81                            .iter()
82                            .map(|datum| {
83                                let datum = datum.as_ref().map(|datum| datum.axis.clone());
84                                (datum.is_some(), datum)
85                            })
86                            .unzip();
87                        let axis_validity: Option<arrow::buffer::NullBuffer> = {
88                            let any_nones = somes.iter().any(|some| !*some);
89                            any_nones.then(|| somes.into())
90                        };
91                        {
92                            let axis_inner_data: Vec<_> = axis
93                                .into_iter()
94                                .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
95                                .flatten()
96                                .collect();
97                            let axis_inner_validity: Option<arrow::buffer::NullBuffer> =
98                                axis_validity.as_ref().map(|validity| {
99                                    validity
100                                        .iter()
101                                        .map(|b| std::iter::repeat_n(b, 3usize))
102                                        .flatten()
103                                        .collect::<Vec<_>>()
104                                        .into()
105                                });
106                            as_array_ref(FixedSizeListArray::new(
107                                std::sync::Arc::new(Field::new("item", DataType::Float32, false)),
108                                3,
109                                as_array_ref(PrimitiveArray::<Float32Type>::new(
110                                    ScalarBuffer::from(
111                                        axis_inner_data.into_iter().collect::<Vec<_>>(),
112                                    ),
113                                    axis_inner_validity,
114                                )),
115                                axis_validity,
116                            ))
117                        }
118                    },
119                    {
120                        let (somes, angle): (Vec<_>, Vec<_>) = data
121                            .iter()
122                            .map(|datum| {
123                                let datum = datum.as_ref().map(|datum| datum.angle.clone());
124                                (datum.is_some(), datum)
125                            })
126                            .unzip();
127                        let angle_validity: Option<arrow::buffer::NullBuffer> = {
128                            let any_nones = somes.iter().any(|some| !*some);
129                            any_nones.then(|| somes.into())
130                        };
131                        as_array_ref(PrimitiveArray::<Float32Type>::new(
132                            ScalarBuffer::from(
133                                angle
134                                    .into_iter()
135                                    .map(|datum| {
136                                        datum.map(|datum| datum.radians).unwrap_or_default()
137                                    })
138                                    .collect::<Vec<_>>(),
139                            ),
140                            angle_validity,
141                        ))
142                    },
143                ],
144                validity,
145            ))
146        })
147    }
148
149    fn from_arrow_opt(
150        arrow_data: &dyn arrow::array::Array,
151    ) -> DeserializationResult<Vec<Option<Self>>>
152    where
153        Self: Sized,
154    {
155        use ::re_types_core::{Loggable as _, ResultExt as _, arrow_zip_validity::ZipValidity};
156        use arrow::{array::*, buffer::*, datatypes::*};
157        Ok({
158            let arrow_data = arrow_data
159                .as_any()
160                .downcast_ref::<arrow::array::StructArray>()
161                .ok_or_else(|| {
162                    let expected = Self::arrow_datatype();
163                    let actual = arrow_data.data_type().clone();
164                    DeserializationError::datatype_mismatch(expected, actual)
165                })
166                .with_context("rerun.datatypes.RotationAxisAngle")?;
167            if arrow_data.is_empty() {
168                Vec::new()
169            } else {
170                let (arrow_data_fields, arrow_data_arrays) =
171                    (arrow_data.fields(), arrow_data.columns());
172                let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
173                    .iter()
174                    .map(|field| field.name().as_str())
175                    .zip(arrow_data_arrays)
176                    .collect();
177                let axis = {
178                    if !arrays_by_name.contains_key("axis") {
179                        return Err(DeserializationError::missing_struct_field(
180                            Self::arrow_datatype(),
181                            "axis",
182                        ))
183                        .with_context("rerun.datatypes.RotationAxisAngle");
184                    }
185                    let arrow_data = &**arrays_by_name["axis"];
186                    {
187                        let arrow_data = arrow_data
188                            .as_any()
189                            .downcast_ref::<arrow::array::FixedSizeListArray>()
190                            .ok_or_else(|| {
191                                let expected = DataType::FixedSizeList(
192                                    std::sync::Arc::new(Field::new(
193                                        "item",
194                                        DataType::Float32,
195                                        false,
196                                    )),
197                                    3,
198                                );
199                                let actual = arrow_data.data_type().clone();
200                                DeserializationError::datatype_mismatch(expected, actual)
201                            })
202                            .with_context("rerun.datatypes.RotationAxisAngle#axis")?;
203                        if arrow_data.is_empty() {
204                            Vec::new()
205                        } else {
206                            let offsets = (0..)
207                                .step_by(3usize)
208                                .zip((3usize..).step_by(3usize).take(arrow_data.len()));
209                            let arrow_data_inner = {
210                                let arrow_data_inner = &**arrow_data.values();
211                                arrow_data_inner
212                                    .as_any()
213                                    .downcast_ref::<Float32Array>()
214                                    .ok_or_else(|| {
215                                        let expected = DataType::Float32;
216                                        let actual = arrow_data_inner.data_type().clone();
217                                        DeserializationError::datatype_mismatch(expected, actual)
218                                    })
219                                    .with_context("rerun.datatypes.RotationAxisAngle#axis")?
220                                    .into_iter()
221                                    .collect::<Vec<_>>()
222                            };
223                            ZipValidity::new_with_validity(offsets, arrow_data.nulls())
224                                .map(|elem| {
225                                    elem.map(|(start, end): (usize, usize)| {
226                                        debug_assert!(end - start == 3usize);
227                                        if arrow_data_inner.len() < end {
228                                            return Err(DeserializationError::offset_slice_oob(
229                                                (start, end),
230                                                arrow_data_inner.len(),
231                                            ));
232                                        }
233
234                                        #[expect(unsafe_code, clippy::undocumented_unsafe_blocks)]
235                                        let data =
236                                            unsafe { arrow_data_inner.get_unchecked(start..end) };
237                                        let data =
238                                            data.iter().cloned().map(Option::unwrap_or_default);
239
240                                        // NOTE: Unwrapping cannot fail: the length must be correct.
241                                        #[expect(clippy::unwrap_used)]
242                                        Ok(array_init::from_iter(data).unwrap())
243                                    })
244                                    .transpose()
245                                })
246                                .map(|res_or_opt| {
247                                    res_or_opt
248                                        .map(|res_or_opt| res_or_opt.map(crate::datatypes::Vec3D))
249                                })
250                                .collect::<DeserializationResult<Vec<Option<_>>>>()?
251                        }
252                        .into_iter()
253                    }
254                };
255                let angle = {
256                    if !arrays_by_name.contains_key("angle") {
257                        return Err(DeserializationError::missing_struct_field(
258                            Self::arrow_datatype(),
259                            "angle",
260                        ))
261                        .with_context("rerun.datatypes.RotationAxisAngle");
262                    }
263                    let arrow_data = &**arrays_by_name["angle"];
264                    arrow_data
265                        .as_any()
266                        .downcast_ref::<Float32Array>()
267                        .ok_or_else(|| {
268                            let expected = DataType::Float32;
269                            let actual = arrow_data.data_type().clone();
270                            DeserializationError::datatype_mismatch(expected, actual)
271                        })
272                        .with_context("rerun.datatypes.RotationAxisAngle#angle")?
273                        .into_iter()
274                        .map(|res_or_opt| {
275                            res_or_opt.map(|radians| crate::datatypes::Angle { radians })
276                        })
277                };
278                ZipValidity::new_with_validity(::itertools::izip!(axis, angle), arrow_data.nulls())
279                    .map(|opt| {
280                        opt.map(|(axis, angle)| {
281                            Ok(Self {
282                                axis: axis
283                                    .ok_or_else(DeserializationError::missing_data)
284                                    .with_context("rerun.datatypes.RotationAxisAngle#axis")?,
285                                angle: angle
286                                    .ok_or_else(DeserializationError::missing_data)
287                                    .with_context("rerun.datatypes.RotationAxisAngle#angle")?,
288                            })
289                        })
290                        .transpose()
291                    })
292                    .collect::<DeserializationResult<Vec<_>>>()
293                    .with_context("rerun.datatypes.RotationAxisAngle")?
294            }
295        })
296    }
297}
298
299impl ::re_byte_size::SizeBytes for RotationAxisAngle {
300    #[inline]
301    fn heap_size_bytes(&self) -> u64 {
302        self.axis.heap_size_bytes() + self.angle.heap_size_bytes()
303    }
304
305    #[inline]
306    fn is_pod() -> bool {
307        <crate::datatypes::Vec3D>::is_pod() && <crate::datatypes::Angle>::is_pod()
308    }
309}
re_types/datatypes/rotation_axis_angle.rs

re_types/datatypes/
rotation_axis_angle.rs
