re_types/datatypes/
annotation_info.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/annotation_info.fbs".
3
4#![allow(unused_braces)]
5#![allow(unused_imports)]
6#![allow(unused_parens)]
7#![allow(clippy::clone_on_copy)]
8#![allow(clippy::cloned_instead_of_copied)]
9#![allow(clippy::map_flatten)]
10#![allow(clippy::needless_question_mark)]
11#![allow(clippy::new_without_default)]
12#![allow(clippy::redundant_closure)]
13#![allow(clippy::too_many_arguments)]
14#![allow(clippy::too_many_lines)]
15
16use ::re_types_core::try_serialize_field;
17use ::re_types_core::SerializationResult;
18use ::re_types_core::{ComponentBatch as _, SerializedComponentBatch};
19use ::re_types_core::{ComponentDescriptor, ComponentType};
20use ::re_types_core::{DeserializationError, DeserializationResult};
21
22/// **Datatype**: Annotation info annotating a class id or key-point id.
23///
24/// Color and label will be used to annotate entities/keypoints which reference the id.
25/// The id refers either to a class or key-point id
26#[derive(Clone, Debug, Default, Eq, PartialEq)]
27pub struct AnnotationInfo {
28    /// [`datatypes::ClassId`][crate::datatypes::ClassId] or [`datatypes::KeypointId`][crate::datatypes::KeypointId] to which this annotation info belongs.
29    pub id: u16,
30
31    /// The label that will be shown in the UI.
32    pub label: Option<crate::datatypes::Utf8>,
33
34    /// The color that will be applied to the annotated entity.
35    pub color: Option<crate::datatypes::Rgba32>,
36}
37
38::re_types_core::macros::impl_into_cow!(AnnotationInfo);
39
40impl ::re_types_core::Loggable for AnnotationInfo {
41    #[inline]
42    fn arrow_datatype() -> arrow::datatypes::DataType {
43        #![allow(clippy::wildcard_imports)]
44        use arrow::datatypes::*;
45        DataType::Struct(Fields::from(vec![
46            Field::new("id", DataType::UInt16, false),
47            Field::new("label", <crate::datatypes::Utf8>::arrow_datatype(), true),
48            Field::new("color", <crate::datatypes::Rgba32>::arrow_datatype(), true),
49        ]))
50    }
51
52    fn to_arrow_opt<'a>(
53        data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
54    ) -> SerializationResult<arrow::array::ArrayRef>
55    where
56        Self: Clone + 'a,
57    {
58        #![allow(clippy::wildcard_imports)]
59        #![allow(clippy::manual_is_variant_and)]
60        use ::re_types_core::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
61        use arrow::{array::*, buffer::*, datatypes::*};
62        Ok({
63            let fields = Fields::from(vec![
64                Field::new("id", DataType::UInt16, false),
65                Field::new("label", <crate::datatypes::Utf8>::arrow_datatype(), true),
66                Field::new("color", <crate::datatypes::Rgba32>::arrow_datatype(), true),
67            ]);
68            let (somes, data): (Vec<_>, Vec<_>) = data
69                .into_iter()
70                .map(|datum| {
71                    let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
72                    (datum.is_some(), datum)
73                })
74                .unzip();
75            let validity: Option<arrow::buffer::NullBuffer> = {
76                let any_nones = somes.iter().any(|some| !*some);
77                any_nones.then(|| somes.into())
78            };
79            as_array_ref(StructArray::new(
80                fields,
81                vec![
82                    {
83                        let (somes, id): (Vec<_>, Vec<_>) = data
84                            .iter()
85                            .map(|datum| {
86                                let datum = datum.as_ref().map(|datum| datum.id.clone());
87                                (datum.is_some(), datum)
88                            })
89                            .unzip();
90                        let id_validity: Option<arrow::buffer::NullBuffer> = {
91                            let any_nones = somes.iter().any(|some| !*some);
92                            any_nones.then(|| somes.into())
93                        };
94                        as_array_ref(PrimitiveArray::<UInt16Type>::new(
95                            ScalarBuffer::from(
96                                id.into_iter()
97                                    .map(|v| v.unwrap_or_default())
98                                    .collect::<Vec<_>>(),
99                            ),
100                            id_validity,
101                        ))
102                    },
103                    {
104                        let (somes, label): (Vec<_>, Vec<_>) = data
105                            .iter()
106                            .map(|datum| {
107                                let datum =
108                                    datum.as_ref().map(|datum| datum.label.clone()).flatten();
109                                (datum.is_some(), datum)
110                            })
111                            .unzip();
112                        let label_validity: Option<arrow::buffer::NullBuffer> = {
113                            let any_nones = somes.iter().any(|some| !*some);
114                            any_nones.then(|| somes.into())
115                        };
116                        {
117                            let offsets = arrow::buffer::OffsetBuffer::<i32>::from_lengths(
118                                label.iter().map(|opt| {
119                                    opt.as_ref().map(|datum| datum.0.len()).unwrap_or_default()
120                                }),
121                            );
122                            #[allow(clippy::unwrap_used)]
123                            let capacity = offsets.last().copied().unwrap() as usize;
124                            let mut buffer_builder =
125                                arrow::array::builder::BufferBuilder::<u8>::new(capacity);
126                            for data in label.iter().flatten() {
127                                buffer_builder.append_slice(data.0.as_bytes());
128                            }
129                            let inner_data: arrow::buffer::Buffer = buffer_builder.finish();
130
131                            #[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
132                            as_array_ref(unsafe {
133                                StringArray::new_unchecked(offsets, inner_data, label_validity)
134                            })
135                        }
136                    },
137                    {
138                        let (somes, color): (Vec<_>, Vec<_>) = data
139                            .iter()
140                            .map(|datum| {
141                                let datum =
142                                    datum.as_ref().map(|datum| datum.color.clone()).flatten();
143                                (datum.is_some(), datum)
144                            })
145                            .unzip();
146                        let color_validity: Option<arrow::buffer::NullBuffer> = {
147                            let any_nones = somes.iter().any(|some| !*some);
148                            any_nones.then(|| somes.into())
149                        };
150                        as_array_ref(PrimitiveArray::<UInt32Type>::new(
151                            ScalarBuffer::from(
152                                color
153                                    .into_iter()
154                                    .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
155                                    .collect::<Vec<_>>(),
156                            ),
157                            color_validity,
158                        ))
159                    },
160                ],
161                validity,
162            ))
163        })
164    }
165
166    fn from_arrow_opt(
167        arrow_data: &dyn arrow::array::Array,
168    ) -> DeserializationResult<Vec<Option<Self>>>
169    where
170        Self: Sized,
171    {
172        #![allow(clippy::wildcard_imports)]
173        use ::re_types_core::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
174        use arrow::{array::*, buffer::*, datatypes::*};
175        Ok({
176            let arrow_data = arrow_data
177                .as_any()
178                .downcast_ref::<arrow::array::StructArray>()
179                .ok_or_else(|| {
180                    let expected = Self::arrow_datatype();
181                    let actual = arrow_data.data_type().clone();
182                    DeserializationError::datatype_mismatch(expected, actual)
183                })
184                .with_context("rerun.datatypes.AnnotationInfo")?;
185            if arrow_data.is_empty() {
186                Vec::new()
187            } else {
188                let (arrow_data_fields, arrow_data_arrays) =
189                    (arrow_data.fields(), arrow_data.columns());
190                let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
191                    .iter()
192                    .map(|field| field.name().as_str())
193                    .zip(arrow_data_arrays)
194                    .collect();
195                let id = {
196                    if !arrays_by_name.contains_key("id") {
197                        return Err(DeserializationError::missing_struct_field(
198                            Self::arrow_datatype(),
199                            "id",
200                        ))
201                        .with_context("rerun.datatypes.AnnotationInfo");
202                    }
203                    let arrow_data = &**arrays_by_name["id"];
204                    arrow_data
205                        .as_any()
206                        .downcast_ref::<UInt16Array>()
207                        .ok_or_else(|| {
208                            let expected = DataType::UInt16;
209                            let actual = arrow_data.data_type().clone();
210                            DeserializationError::datatype_mismatch(expected, actual)
211                        })
212                        .with_context("rerun.datatypes.AnnotationInfo#id")?
213                        .into_iter()
214                };
215                let label = {
216                    if !arrays_by_name.contains_key("label") {
217                        return Err(DeserializationError::missing_struct_field(
218                            Self::arrow_datatype(),
219                            "label",
220                        ))
221                        .with_context("rerun.datatypes.AnnotationInfo");
222                    }
223                    let arrow_data = &**arrays_by_name["label"];
224                    {
225                        let arrow_data = arrow_data
226                            .as_any()
227                            .downcast_ref::<StringArray>()
228                            .ok_or_else(|| {
229                                let expected = DataType::Utf8;
230                                let actual = arrow_data.data_type().clone();
231                                DeserializationError::datatype_mismatch(expected, actual)
232                            })
233                            .with_context("rerun.datatypes.AnnotationInfo#label")?;
234                        let arrow_data_buf = arrow_data.values();
235                        let offsets = arrow_data.offsets();
236                        ZipValidity::new_with_validity(offsets.windows(2), arrow_data.nulls())
237                            .map(|elem| {
238                                elem.map(|window| {
239                                    let start = window[0] as usize;
240                                    let end = window[1] as usize;
241                                    let len = end - start;
242                                    if arrow_data_buf.len() < end {
243                                        return Err(DeserializationError::offset_slice_oob(
244                                            (start, end),
245                                            arrow_data_buf.len(),
246                                        ));
247                                    }
248
249                                    #[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
250                                    let data = arrow_data_buf.slice_with_length(start, len);
251                                    Ok(data)
252                                })
253                                .transpose()
254                            })
255                            .map(|res_or_opt| {
256                                res_or_opt.map(|res_or_opt| {
257                                    res_or_opt.map(|v| {
258                                        crate::datatypes::Utf8(::re_types_core::ArrowString::from(
259                                            v,
260                                        ))
261                                    })
262                                })
263                            })
264                            .collect::<DeserializationResult<Vec<Option<_>>>>()
265                            .with_context("rerun.datatypes.AnnotationInfo#label")?
266                            .into_iter()
267                    }
268                };
269                let color = {
270                    if !arrays_by_name.contains_key("color") {
271                        return Err(DeserializationError::missing_struct_field(
272                            Self::arrow_datatype(),
273                            "color",
274                        ))
275                        .with_context("rerun.datatypes.AnnotationInfo");
276                    }
277                    let arrow_data = &**arrays_by_name["color"];
278                    arrow_data
279                        .as_any()
280                        .downcast_ref::<UInt32Array>()
281                        .ok_or_else(|| {
282                            let expected = DataType::UInt32;
283                            let actual = arrow_data.data_type().clone();
284                            DeserializationError::datatype_mismatch(expected, actual)
285                        })
286                        .with_context("rerun.datatypes.AnnotationInfo#color")?
287                        .into_iter()
288                        .map(|res_or_opt| res_or_opt.map(crate::datatypes::Rgba32))
289                };
290                ZipValidity::new_with_validity(
291                    ::itertools::izip!(id, label, color),
292                    arrow_data.nulls(),
293                )
294                .map(|opt| {
295                    opt.map(|(id, label, color)| {
296                        Ok(Self {
297                            id: id
298                                .ok_or_else(DeserializationError::missing_data)
299                                .with_context("rerun.datatypes.AnnotationInfo#id")?,
300                            label,
301                            color,
302                        })
303                    })
304                    .transpose()
305                })
306                .collect::<DeserializationResult<Vec<_>>>()
307                .with_context("rerun.datatypes.AnnotationInfo")?
308            }
309        })
310    }
311}
312
313impl ::re_byte_size::SizeBytes for AnnotationInfo {
314    #[inline]
315    fn heap_size_bytes(&self) -> u64 {
316        self.id.heap_size_bytes() + self.label.heap_size_bytes() + self.color.heap_size_bytes()
317    }
318
319    #[inline]
320    fn is_pod() -> bool {
321        <u16>::is_pod()
322            && <Option<crate::datatypes::Utf8>>::is_pod()
323            && <Option<crate::datatypes::Rgba32>>::is_pod()
324    }
325}
re_types/datatypes/annotation_info.rs

re_types/datatypes/
annotation_info.rs
