Improved 3D transform ingestion & affine transform support

crates/re_arrow_store/src/arrow_util.rs

@@ -233,109 +233,64 @@ fn test_clean_for_polars_nomodify() {
     assert_eq!(cell.as_arrow_ref(), &*cleaned);
 }
 
-#[test]
-fn test_clean_for_polars_modify() {
-    use re_log_types::{DataCell, Pinhole, Transform};
-    // transforms are a nice pathological type with both Unions and FixedSizeLists
-    let transforms = vec![Transform::Pinhole(Pinhole {
-        image_from_cam: [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]].into(),
-        resolution: None,
-    })];
+#[cfg(test)]
+mod tests {
+    use arrow2::datatypes::{DataType, Field, UnionMode};
+    use arrow2_convert::{ArrowDeserialize, ArrowField, ArrowSerialize};
+    use re_log_types::{component_types::Vec3D, Component, DataCell};
 
-    let cell: DataCell = transforms.try_into().unwrap();
-    assert_eq!(
-        *cell.datatype(),
-        DataType::Union(
-            vec![
-                Field::new("Unknown", DataType::Boolean, false),
-                Field::new(
-                    "Rigid3",
-                    DataType::Struct(vec![
-                        Field::new(
-                            "rotation",
-                            DataType::FixedSizeList(
-                                Box::new(Field::new("item", DataType::Float32, false)),
-                                4
-                            ),
-                            false
-                        ),
-                        Field::new(
-                            "translation",
-                            DataType::FixedSizeList(
-                                Box::new(Field::new("item", DataType::Float32, false)),
-                                3
-                            ),
-                            false
-                        )
-                    ]),
-                    false
-                ),
-                Field::new(
-                    "Pinhole",
-                    DataType::Struct(vec![
-                        Field::new(
-                            "image_from_cam",
-                            DataType::FixedSizeList(
-                                Box::new(Field::new("item", DataType::Float32, false)),
-                                9
-                            ),
-                            false,
-                        ),
-                        Field::new(
-                            "resolution",
-                            DataType::FixedSizeList(
-                                Box::new(Field::new("item", DataType::Float32, false)),
-                                2
-                            ),
-                            true,
-                        ),
-                    ]),
-                    false
-                )
-            ],
-            None,
-            UnionMode::Dense
-        ),
-    );
+    use crate::ArrayExt;
 
-    let cleaned = cell.as_arrow_ref().clean_for_polars();
+    #[derive(Clone, Copy, Debug, PartialEq, ArrowField, ArrowSerialize, ArrowDeserialize)]
+    #[arrow_field(type = "dense")]
+    enum TestComponentWithUnionAndFixedSizeList {
+        Bool(bool),
+        Vec3D(Vec3D),
+    }
 
-    assert_eq!(
-        *cleaned.data_type(),
-        DataType::Struct(vec![
-            Field::new("Unknown", DataType::Boolean, false),
-            Field::new(
-                "Rigid3",
-                DataType::Struct(vec![
-                    Field::new(
-                        "rotation",
-                        DataType::List(Box::new(Field::new("item", DataType::Float32, false)),),
-                        false
-                    ),
+    impl Component for TestComponentWithUnionAndFixedSizeList {
+        fn name() -> re_log_types::ComponentName {
+            "test_component_with_union_and_fixed_size_list".into()
+        }
+    }
+
+    #[test]
+    fn test_clean_for_polars_modify() {
+        // Pick a type with both Unions and FixedSizeLists
+        let elements = vec![TestComponentWithUnionAndFixedSizeList::Bool(false)];
+
+        let cell: DataCell = elements.try_into().unwrap();
+        assert_eq!(
+            *cell.datatype(),
+            DataType::Union(
+                vec![
+                    Field::new("Bool", DataType::Boolean, false),
                     Field::new(
-                        "translation",
-                        DataType::List(Box::new(Field::new("item", DataType::Float32, false)),),
+                        "Vec3D",
+                        DataType::FixedSizeList(
+                            Box::new(Field::new("item", DataType::Float32, false)),
+                            3
+                        ),
                         false
                     )
-                ]),
-                false
-            ),
-            Field::new(
-                "Pinhole",
-                DataType::Struct(vec![
-                    Field::new(
-                        "image_from_cam",
-                        DataType::List(Box::new(Field::new("item", DataType::Float32, false))),
-                        false,
-                    ),
-                    Field::new(
-                        "resolution",
-                        DataType::List(Box::new(Field::new("item", DataType::Float32, false))),
-                        true,
-                    ),
-                ]),
-                false
+                ],
+                None,
+                UnionMode::Dense
             )
-        ],),
-    );
+        );
+
+        let cleaned = cell.as_arrow_ref().clean_for_polars();
+
+        assert_eq!(
+            *cleaned.data_type(),
+            DataType::Struct(vec![
+                Field::new("Bool", DataType::Boolean, false),
+                Field::new(
+                    "Vec3D",
+                    DataType::List(Box::new(Field::new("item", DataType::Float32, false))),
+                    false
+                )
+            ],)
+        );
+    }
 }

crates/re_data_ui/src/component_ui_registry.rs

@@ -51,6 +51,7 @@ pub fn create_component_ui_registry() -> ComponentUiRegistry {
     add::<re_log_types::component_types::Mesh3D>(&mut registry);
     // add::<re_log_types::component_types::Point2D>(&mut registry);
     // add::<re_log_types::component_types::Point3D>(&mut registry);
+    add::<re_log_types::component_types::Pinhole>(&mut registry);
     // add::<re_log_types::component_types::Quaternion>(&mut registry);
     // add::<re_log_types::component_types::Radius>(&mut registry);
     add::<re_log_types::component_types::Rect2D>(&mut registry);
@@ -59,7 +60,7 @@ pub fn create_component_ui_registry() -> ComponentUiRegistry {
     // add::<re_log_types::component_types::Size3D>(&mut registry);
     add::<re_log_types::component_types::Tensor>(&mut registry);
     add::<re_log_types::component_types::TextEntry>(&mut registry);
-    add::<re_log_types::component_types::Transform>(&mut registry);
+    add::<re_log_types::component_types::Transform3D>(&mut registry);
     add::<re_log_types::component_types::Vec2D>(&mut registry);
     add::<re_log_types::component_types::Vec3D>(&mut registry);
     add::<re_log_types::ViewCoordinates>(&mut registry);

crates/re_data_ui/src/data.rs

@@ -1,10 +1,8 @@
 use egui::Vec2;
 
 use re_format::format_f32;
-use re_log_types::{
-    component_types::ColorRGBA,
-    component_types::{LineStrip2D, LineStrip3D, Mat3x3, Rect2D, Vec2D, Vec3D, Vec4D},
-    Pinhole, Rigid3, Transform, ViewCoordinates,
+use re_log_types::component_types::{
+    ColorRGBA, LineStrip2D, LineStrip3D, Mat3x3, Rect2D, Vec2D, Vec3D, Vec4D, ViewCoordinates,
 };
 use re_viewer_context::{UiVerbosity, ViewerContext};
 
@@ -53,24 +51,6 @@ impl DataUi for ColorRGBA {
     }
 }
 
-impl DataUi for Transform {
-    fn data_ui(
-        &self,
-        ctx: &mut ViewerContext<'_>,
-        ui: &mut egui::Ui,
-        verbosity: UiVerbosity,
-        query: &re_arrow_store::LatestAtQuery,
-    ) {
-        match self {
-            Transform::Unknown => {
-                ui.label("Unknown transform");
-            }
-            Transform::Rigid3(rigid3) => rigid3.data_ui(ctx, ui, verbosity, query),
-            Transform::Pinhole(pinhole) => pinhole.data_ui(ctx, ui, verbosity, query),
-        }
-    }
-}
-
 impl DataUi for ViewCoordinates {
     fn data_ui(
         &self,
@@ -90,90 +70,6 @@ impl DataUi for ViewCoordinates {
     }
 }
 
-impl DataUi for Rigid3 {
-    #[allow(clippy::only_used_in_recursion)]
-    fn data_ui(
-        &self,
-        ctx: &mut ViewerContext<'_>,
-        ui: &mut egui::Ui,
-        verbosity: UiVerbosity,
-        query: &re_arrow_store::LatestAtQuery,
-    ) {
-        match verbosity {
-            UiVerbosity::Small => {
-                ui.label("Rigid 3D transform").on_hover_ui(|ui| {
-                    self.data_ui(ctx, ui, UiVerbosity::All, query);
-                });
-            }
-
-            UiVerbosity::All | UiVerbosity::Reduced => {
-                let pose = self.parent_from_child(); // TODO(emilk): which one to show?
-                let rotation = pose.rotation();
-                let translation = pose.translation();
-
-                ui.vertical(|ui| {
-                    ui.label("Rigid 3D transform:");
-                    ui.indent("rigid3", |ui| {
-                        egui::Grid::new("rigid3").num_columns(2).show(ui, |ui| {
-                            ui.label("rotation");
-                            ui.monospace(format!("{rotation:?}"));
-                            ui.end_row();
-
-                            ui.label("translation");
-                            ui.monospace(format!("{translation:?}"));
-                            ui.end_row();
-                        });
-                    });
-                });
-            }
-        }
-    }
-}
-
-impl DataUi for Pinhole {
-    fn data_ui(
-        &self,
-        ctx: &mut ViewerContext<'_>,
-        ui: &mut egui::Ui,
-        verbosity: UiVerbosity,
-        query: &re_arrow_store::LatestAtQuery,
-    ) {
-        match verbosity {
-            UiVerbosity::Small => {
-                ui.label("Pinhole transform").on_hover_ui(|ui| {
-                    self.data_ui(ctx, ui, UiVerbosity::All, query);
-                });
-            }
-
-            UiVerbosity::All | UiVerbosity::Reduced => {
-                let Pinhole {
-                    image_from_cam: image_from_view,
-                    resolution,
-                } = self;
-
-                ui.vertical(|ui| {
-                    ui.label("Pinhole transform:");
-                    ui.indent("pinole", |ui| {
-                        ui.horizontal(|ui| {
-                            ui.label("resolution:");
-                            if let Some(re_log_types::component_types::Vec2D([x, y])) = resolution {
-                                ui.monospace(format!("{x}x{y}"));
-                            } else {
-                                ui.weak("(none)");
-                            }
-                        });
-
-                        ui.label("image from view:");
-                        ui.indent("image_from_view", |ui| {
-                            image_from_view.data_ui(ctx, ui, verbosity, query);
-                        });
-                    });
-                });
-            }
-        }
-    }
-}
-
 impl DataUi for Mat3x3 {
     fn data_ui(
         &self,

crates/re_data_ui/src/lib.rs

@@ -17,6 +17,8 @@ mod instance_path;
 mod item;
 pub mod item_ui;
 mod log_msg;
+mod pinhole;
+mod transform3d;
 
 pub use crate::image::{
     show_zoomed_image_region, show_zoomed_image_region_area_outline,

crates/re_data_ui/src/pinhole.rs

@@ -0,0 +1,48 @@
+use re_log_types::component_types::Pinhole;
+use re_viewer_context::{UiVerbosity, ViewerContext};
+
+use crate::DataUi;
+
+impl DataUi for Pinhole {
+    fn data_ui(
+        &self,
+        ctx: &mut ViewerContext<'_>,
+        ui: &mut egui::Ui,
+        verbosity: UiVerbosity,
+        query: &re_arrow_store::LatestAtQuery,
+    ) {
+        match verbosity {
+            UiVerbosity::Small => {
+                ui.label("Pinhole transform").on_hover_ui(|ui| {
+                    self.data_ui(ctx, ui, UiVerbosity::All, query);
+                });
+            }
+
+            UiVerbosity::All | UiVerbosity::Reduced => {
+                let Pinhole {
+                    image_from_cam: image_from_view,
+                    resolution,
+                } = self;
+
+                ui.vertical(|ui| {
+                    ui.label("Pinhole transform:");
+                    ui.indent("pinole", |ui| {
+                        ui.horizontal(|ui| {
+                            ui.label("resolution:");
+                            if let Some(re_log_types::component_types::Vec2D([x, y])) = resolution {
+                                ui.monospace(format!("{x}x{y}"));
+                            } else {
+                                ui.weak("(none)");
+                            }
+                        });
+
+                        ui.label("image from view:");
+                        ui.indent("image_from_view", |ui| {
+                            image_from_view.data_ui(ctx, ui, verbosity, query);
+                        });
+                    });
+                });
+            }
+        }
+    }
+}