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_imports)]
5#![allow(unused_parens)]
6#![allow(clippy::clone_on_copy)]
7#![allow(clippy::cloned_instead_of_copied)]
8#![allow(clippy::map_flatten)]
9#![allow(clippy::needless_question_mark)]
10#![allow(clippy::new_without_default)]
11#![allow(clippy::redundant_closure)]
12#![allow(clippy::too_many_arguments)]
13#![allow(clippy::too_many_lines)]
14
15use ::re_types_core::try_serialize_field;
16use ::re_types_core::SerializationResult;
17use ::re_types_core::{ComponentBatch as _, SerializedComponentBatch};
18use ::re_types_core::{ComponentDescriptor, ComponentName};
19use ::re_types_core::{DeserializationError, DeserializationResult};
20
21/// **Datatype**: 3D rotation represented by a rotation around a given axis.
22#[derive(Clone, Debug, Copy, PartialEq)]
23pub struct RotationAxisAngle {
24    /// Axis to rotate around.
25    ///
26    /// This is not required to be normalized.
27    /// However, if normalization of the rotation axis fails (typically due to a zero vector)
28    /// the rotation is treated as an invalid transform, unless the angle is zero in which case
29    /// it is treated as an identity.
30    pub axis: crate::datatypes::Vec3D,
31
32    /// How much to rotate around the axis.
33    pub angle: crate::datatypes::Angle,
34}
35
36::re_types_core::macros::impl_into_cow!(RotationAxisAngle);
37
38impl ::re_types_core::Loggable for RotationAxisAngle {
39    #[inline]
40    fn arrow_datatype() -> arrow::datatypes::DataType {
41        #![allow(clippy::wildcard_imports)]
42        use arrow::datatypes::*;
43        DataType::Struct(Fields::from(vec![
44            Field::new("axis", <crate::datatypes::Vec3D>::arrow_datatype(), false),
45            Field::new("angle", <crate::datatypes::Angle>::arrow_datatype(), false),
46        ]))
47    }
48
49    fn to_arrow_opt<'a>(
50        data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
51    ) -> SerializationResult<arrow::array::ArrayRef>
52    where
53        Self: Clone + 'a,
54    {
55        #![allow(clippy::wildcard_imports)]
56        #![allow(clippy::manual_is_variant_and)]
57        use ::re_types_core::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
58        use arrow::{array::*, buffer::*, datatypes::*};
59        Ok({
60            let fields = Fields::from(vec![
61                Field::new("axis", <crate::datatypes::Vec3D>::arrow_datatype(), false),
62                Field::new("angle", <crate::datatypes::Angle>::arrow_datatype(), false),
63            ]);
64            let (somes, data): (Vec<_>, Vec<_>) = data
65                .into_iter()
66                .map(|datum| {
67                    let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
68                    (datum.is_some(), datum)
69                })
70                .unzip();
71            let validity: Option<arrow::buffer::NullBuffer> = {
72                let any_nones = somes.iter().any(|some| !*some);
73                any_nones.then(|| somes.into())
74            };
75            as_array_ref(StructArray::new(
76                fields,
77                vec![
78                    {
79                        let (somes, axis): (Vec<_>, Vec<_>) = data
80                            .iter()
81                            .map(|datum| {
82                                let datum = datum.as_ref().map(|datum| datum.axis.clone());
83                                (datum.is_some(), datum)
84                            })
85                            .unzip();
86                        let axis_validity: Option<arrow::buffer::NullBuffer> = {
87                            let any_nones = somes.iter().any(|some| !*some);
88                            any_nones.then(|| somes.into())
89                        };
90                        {
91                            let axis_inner_data: Vec<_> = axis
92                                .into_iter()
93                                .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
94                                .flatten()
95                                .collect();
96                            let axis_inner_validity: Option<arrow::buffer::NullBuffer> =
97                                axis_validity.as_ref().map(|validity| {
98                                    validity
99                                        .iter()
100                                        .map(|b| std::iter::repeat(b).take(3usize))
101                                        .flatten()
102                                        .collect::<Vec<_>>()
103                                        .into()
104                                });
105                            as_array_ref(FixedSizeListArray::new(
106                                std::sync::Arc::new(Field::new("item", DataType::Float32, false)),
107                                3,
108                                as_array_ref(PrimitiveArray::<Float32Type>::new(
109                                    ScalarBuffer::from(
110                                        axis_inner_data.into_iter().collect::<Vec<_>>(),
111                                    ),
112                                    axis_inner_validity,
113                                )),
114                                axis_validity,
115                            ))
116                        }
117                    },
118                    {
119                        let (somes, angle): (Vec<_>, Vec<_>) = data
120                            .iter()
121                            .map(|datum| {
122                                let datum = datum.as_ref().map(|datum| datum.angle.clone());
123                                (datum.is_some(), datum)
124                            })
125                            .unzip();
126                        let angle_validity: Option<arrow::buffer::NullBuffer> = {
127                            let any_nones = somes.iter().any(|some| !*some);
128                            any_nones.then(|| somes.into())
129                        };
130                        as_array_ref(PrimitiveArray::<Float32Type>::new(
131                            ScalarBuffer::from(
132                                angle
133                                    .into_iter()
134                                    .map(|datum| {
135                                        datum.map(|datum| datum.radians).unwrap_or_default()
136                                    })
137                                    .collect::<Vec<_>>(),
138                            ),
139                            angle_validity,
140                        ))
141                    },
142                ],
143                validity,
144            ))
145        })
146    }
147
148    fn from_arrow_opt(
149        arrow_data: &dyn arrow::array::Array,
150    ) -> DeserializationResult<Vec<Option<Self>>>
151    where
152        Self: Sized,
153    {
154        #![allow(clippy::wildcard_imports)]
155        use ::re_types_core::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
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                                        #[allow(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                                        #[allow(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
