end-to-end arrow-based scalars / time-series (#666)

* add scalar component

* add scalarplotprops component

* re_query: visit4 & visit5

* building the scene

* dispatching to plot view

* complete rust example

* python bindings

* doesnt look like it's used but still

crates/re_data_store/src/log_db.rs

@@ -1,8 +1,8 @@
 use itertools::Itertools as _;
-use nohash_hasher::IntMap;
+use nohash_hasher::{IntMap, IntSet};
 
 use re_log_types::{
-    field_types::{Instance, TextEntry},
+    field_types::{Instance, Scalar, TextEntry},
     msg_bundle::{Component as _, MsgBundle},
     objects, ArrowMsg, BatchIndex, BeginRecordingMsg, DataMsg, DataPath, DataVec, LogMsg,
     LoggedData, MsgId, ObjPath, ObjPathHash, ObjTypePath, ObjectType, PathOp, PathOpMsg,
@@ -134,8 +134,16 @@ impl ObjDb {
         // TODO(cmc): That's an extension of the hack below, and will disappear at the same time
         // and for the same reasons.
         {
-            let obj_type = if msg_bundle.find_component(&TextEntry::name()).is_some() {
+            let components = msg_bundle
+                .components
+                .iter()
+                .map(|bundle| bundle.name)
+                .collect::<IntSet<_>>();
+
+            let obj_type = if components.contains(&TextEntry::name()) {
                 ObjectType::TextEntry
+            } else if components.contains(&Scalar::name()) {
+                ObjectType::Scalar
             } else {
                 // TODO(jleibs): Hack in a type so the UI treats these objects as visible
                 // This can go away once we determine object categories directly from the arrow

crates/re_log_types/src/field_types/color.rs

@@ -15,7 +15,7 @@ use crate::msg_bundle::Component;
 ///
 /// assert_eq!(ColorRGBA::data_type(), DataType::UInt32);
 /// ```
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, derive_more::From, derive_more::Into)]
 pub struct ColorRGBA(pub u32);
 
 impl ColorRGBA {

crates/re_log_types/src/field_types/label.rs

@@ -15,7 +15,7 @@ use crate::msg_bundle::Component;
 ///
 /// assert_eq!(Label::data_type(), DataType::Utf8);
 /// ```
-#[derive(Debug)]
+#[derive(Debug, Clone, derive_more::From, derive_more::Into)]
 pub struct Label(pub String);
 
 arrow_enable_vec_for_type!(Label);

crates/re_log_types/src/field_types/mod.rs

@@ -18,6 +18,7 @@ mod point;
 mod quaternion;
 mod radius;
 mod rect;
+mod scalar;
 mod size;
 mod text_entry;
 
@@ -31,12 +32,13 @@ pub use point::{Point2D, Point3D};
 pub use quaternion::Quaternion;
 pub use radius::Radius;
 pub use rect::Rect2D;
+pub use scalar::{Scalar, ScalarPlotProps};
 pub use size::Size3D;
 pub use text_entry::TextEntry;
 
 lazy_static! {
     //TODO(john) actully use a run-time type registry
-    static ref FIELDS: [Field; 12] = [
+    static ref FIELDS: [Field; 14] = [
         <ColorRGBA as Component>::field(),
         <Instance as Component>::field(),
         <KeypointId as Component>::field(),
@@ -47,6 +49,8 @@ lazy_static! {
         <Quaternion as Component>::field(),
         <Radius as Component>::field(),
         <Rect2D as Component>::field(),
+        <Scalar as Component>::field(),
+        <ScalarPlotProps as Component>::field(),
         <Size3D as Component>::field(),
         <TextEntry as Component>::field(),
     ];

crates/re_log_types/src/field_types/radius.rs

@@ -14,7 +14,7 @@ use crate::msg_bundle::Component;
 ///
 /// assert_eq!(Radius::data_type(), DataType::Float32);
 /// ```
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy, derive_more::From, derive_more::Into)]
 pub struct Radius(pub f32);
 
 arrow_enable_vec_for_type!(Radius);

crates/re_log_types/src/field_types/scalar.rs

@@ -0,0 +1,87 @@
+use arrow2_convert::{
+    arrow_enable_vec_for_type, deserialize::ArrowDeserialize, field::ArrowField,
+    serialize::ArrowSerialize,
+};
+
+use crate::msg_bundle::Component;
+
+// ---
+
+/// A double-precision scalar.
+///
+/// ```
+/// use re_log_types::field_types::Scalar;
+/// use arrow2_convert::field::ArrowField;
+/// use arrow2::datatypes::{DataType, Field};
+///
+/// assert_eq!(Scalar::data_type(), DataType::Float64);
+/// ```
+#[derive(Debug, Clone, Copy, derive_more::From, derive_more::Into)]
+pub struct Scalar(pub f64);
+
+arrow_enable_vec_for_type!(Scalar);
+
+impl ArrowField for Scalar {
+    type Type = Self;
+    fn data_type() -> arrow2::datatypes::DataType {
+        <f64 as ArrowField>::data_type()
+    }
+}
+
+impl ArrowSerialize for Scalar {
+    type MutableArrayType = <f64 as ArrowSerialize>::MutableArrayType;
+
+    #[inline]
+    fn new_array() -> Self::MutableArrayType {
+        <f64 as ArrowSerialize>::new_array()
+    }
+
+    #[inline]
+    fn arrow_serialize(v: &Self, array: &mut Self::MutableArrayType) -> arrow2::error::Result<()> {
+        <f64 as ArrowSerialize>::arrow_serialize(&v.0, array)
+    }
+}
+
+impl ArrowDeserialize for Scalar {
+    type ArrayType = <f64 as ArrowDeserialize>::ArrayType;
+
+    #[inline]
+    fn arrow_deserialize(
+        v: <&Self::ArrayType as IntoIterator>::Item,
+    ) -> Option<<Self as ArrowField>::Type> {
+        <f64 as ArrowDeserialize>::arrow_deserialize(v).map(Scalar)
+    }
+}
+
+impl Component for Scalar {
+    fn name() -> crate::ComponentName {
+        "rerun.scalar".into()
+    }
+}
+
+// ---
+
+/// Additional properties of a scalar when rendered as a plot.
+///
+/// ```
+/// use re_log_types::field_types::ScalarPlotProps;
+/// use arrow2_convert::field::ArrowField;
+/// use arrow2::datatypes::{DataType, Field};
+///
+/// assert_eq!(
+///     ScalarPlotProps::data_type(),
+///     DataType::Struct(vec![
+///         Field::new("scattered", DataType::Boolean, false),
+///     ])
+/// );
+/// ```
+#[derive(Debug, Clone, Copy, arrow2_convert::ArrowField)]
+pub struct ScalarPlotProps {
+    pub scattered: bool,
+}
+
+impl Component for ScalarPlotProps {
+    fn name() -> crate::ComponentName {
+        "rerun.scalar_plot_props".into()
+    }
+}

crates/re_query/src/visit.rs

@@ -127,4 +127,76 @@ where
 
         Ok(())
     }
+
+    /// Visit the primary and joined components of an [`EntityView`]
+    /// See [`Self::visit2`]
+    pub fn visit4<C1: Component, C2: Component, C3: Component>(
+        &self,
+        mut visit: impl FnMut(Instance, Primary, Option<C1>, Option<C2>, Option<C3>),
+    ) -> crate::Result<()>
+    where
+        C1: ArrowDeserialize + ArrowField<Type = C1> + 'static,
+        C1::ArrayType: ArrowArray,
+        for<'a> &'a C1::ArrayType: IntoIterator,
+        C2: ArrowDeserialize + ArrowField<Type = C2> + 'static,
+        C2::ArrayType: ArrowArray,
+        for<'a> &'a C2::ArrayType: IntoIterator,
+        C3: ArrowDeserialize + ArrowField<Type = C3> + 'static,
+        C3::ArrayType: ArrowArray,
+        for<'a> &'a C3::ArrayType: IntoIterator,
+    {
+        let instance_iter = self.primary.iter_instance_keys()?;
+        let prim_iter = self.primary.iter_values::<Primary>()?;
+        let c1_iter = self.iter_component::<C1>()?;
+        let c2_iter = self.iter_component::<C2>()?;
+        let c3_iter = self.iter_component::<C3>()?;
+
+        itertools::izip!(instance_iter, prim_iter, c1_iter, c2_iter, c3_iter).for_each(
+            |(instance, primary, c1_data, c2_data, c3_iter)| {
+                if let Some(primary) = primary {
+                    visit(instance, primary, c1_data, c2_data, c3_iter);
+                }
+            },
+        );
+
+        Ok(())
+    }
+
+    /// Visit the primary and joined components of an [`EntityView`]
+    /// See [`Self::visit2`]
+    pub fn visit5<C1: Component, C2: Component, C3: Component, C4: Component>(
+        &self,
+        mut visit: impl FnMut(Instance, Primary, Option<C1>, Option<C2>, Option<C3>, Option<C4>),
+    ) -> crate::Result<()>
+    where
+        C1: ArrowDeserialize + ArrowField<Type = C1> + 'static,
+        C1::ArrayType: ArrowArray,
+        for<'a> &'a C1::ArrayType: IntoIterator,
+        C2: ArrowDeserialize + ArrowField<Type = C2> + 'static,
+        C2::ArrayType: ArrowArray,
+        for<'a> &'a C2::ArrayType: IntoIterator,
+        C3: ArrowDeserialize + ArrowField<Type = C3> + 'static,
+        C3::ArrayType: ArrowArray,
+        for<'a> &'a C3::ArrayType: IntoIterator,
+        C4: ArrowDeserialize + ArrowField<Type = C4> + 'static,
+        C4::ArrayType: ArrowArray,
+        for<'a> &'a C4::ArrayType: IntoIterator,
+    {
+        let instance_iter = self.primary.iter_instance_keys()?;
+        let prim_iter = self.primary.iter_values::<Primary>()?;
+        let c1_iter = self.iter_component::<C1>()?;
+        let c2_iter = self.iter_component::<C2>()?;
+        let c3_iter = self.iter_component::<C3>()?;
+        let c4_iter = self.iter_component::<C4>()?;
+
+        itertools::izip!(instance_iter, prim_iter, c1_iter, c2_iter, c3_iter, c4_iter).for_each(
+            |(instance, primary, c1_data, c2_data, c3_iter, c4_iter)| {
+                if let Some(primary) = primary {
+                    visit(instance, primary, c1_data, c2_data, c3_iter, c4_iter);
+                }
+            },
+        );
+
+        Ok(())
+    }
 }

crates/re_viewer/src/ui/view_time_series/scene.rs

@@ -2,8 +2,14 @@ use crate::{
     ui::{annotations::AnnotationMap, DefaultColor, SceneQuery},
     ViewerContext,
 };
+use re_arrow_store::TimeRange;
 use re_data_store::{query::visit_type_data_4, FieldName, TimeQuery};
-use re_log_types::{IndexHash, MsgId, ObjectType};
+use re_log_types::{
+    field_types::{self, Instance},
+    msg_bundle::Component,
+    IndexHash, MsgId, ObjectType,
+};
+use re_query::{range_entity_with_primary, QueryError};
 
 // ---
 
@@ -67,6 +73,8 @@ impl SceneTimeSeries {
         self.annotation_map.load(ctx, query);
 
         self.load_scalars(ctx, query);
+
+        self.load_scalars_arrow(ctx, query);
     }
 
     fn load_scalars(&mut self, ctx: &mut ViewerContext<'_>, query: &SceneQuery<'_>) {
@@ -129,6 +137,88 @@ impl SceneTimeSeries {
         }
     }
 
+    fn load_scalars_arrow(&mut self, ctx: &mut ViewerContext<'_>, query: &SceneQuery<'_>) {
+        crate::profile_function!();
+
+        let store = &ctx.log_db.obj_db.arrow_store;
+
+        for obj_path in query.obj_paths {
+            let ent_path = obj_path;
+
+            let mut points = Vec::new();
+            let annotations = self.annotation_map.find(ent_path);
+            let default_color = DefaultColor::ObjPath(ent_path);
+
+            let query = re_arrow_store::RangeQuery::new(
+                query.timeline,
+                TimeRange::new(i64::MIN.into(), i64::MAX.into()),
+            );
+
+            let components = [
+                Instance::name(),
+                field_types::Scalar::name(),
+                field_types::ScalarPlotProps::name(),
+                field_types::ColorRGBA::name(),
+                field_types::Radius::name(),
+                field_types::Label::name(),
+            ];
+            let ent_views = range_entity_with_primary::<field_types::Scalar, 6>(
+                store, &query, ent_path, components,
+            );
+
+            for (time, ent_view) in ent_views {
+                match ent_view.visit5(
+                    |_instance,
+                     scalar: field_types::Scalar,
+                     props: Option<field_types::ScalarPlotProps>,
+                     color: Option<field_types::ColorRGBA>,
+                     radius: Option<field_types::Radius>,
+                     label: Option<field_types::Label>| {
+                        // TODO(andreas): Support object path
+                        let annotation_info = annotations.class_description(None).annotation_info();
+                        let color = annotation_info
+                            .color(color.map(|c| c.to_array()).as_ref(), default_color);
+                        let label = annotation_info.label(label.map(|l| l.into()).as_ref());
+
+                        points.push(PlotPoint {
+                            time: time.as_i64(),
+                            value: scalar.into(),
+                            attrs: PlotPointAttrs {
+                                label,
+                                color,
+                                radius: radius.map_or(1.0, |r| r.into()),
+                                scattered: props.map_or(false, |props| props.scattered),
+                            },
+                        });
+                    },
+                ) {
+                    Ok(_) | Err(QueryError::PrimaryNotFound) => {}
+                    Err(err) => {
+                        re_log::error_once!("Unexpected error querying '{ent_path:?}': {err:?}");
+                    }
+                }
+            }
+
+            points.sort_by_key(|s| s.time);
+
+            if points.is_empty() {
+                continue;
+            }
+
+            // If all points within a line share the label (and it isn't `None`), then we use it
+            // as the whole line label for the plot legend.
+            // Otherwise, we just use the object path as-is.
+            let same_label = |points: &[PlotPoint]| {
+                let label = points[0].attrs.label.as_ref();
+                (label.is_some() && points.iter().all(|p| p.attrs.label.as_ref() == label))
+                    .then(|| label.cloned().unwrap())
+            };
+            let line_label = same_label(&points).unwrap_or_else(|| obj_path.to_string());
+
+            self.add_line_segments(&line_label, points);
+        }
+    }
+
     // We have a bunch of raw points, and now we need to group them into actual line
     // segments.
     // A line segment is a continuous run of points with identical attributes: each time

crates/rerun_sdk/Cargo.toml

@@ -49,6 +49,7 @@ tokio = { version = "1.16", features = ["macros", "rt-multi-thread"] }
 
 [dev-dependencies]
 arrow2_convert.workspace = true
+rand = "0.8"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 clap = { version = "4.0", features = ["derive"] }