Introduce a new StrokeWidth component and use it for SeriesLine

crates/re_data_ui/src/editors.rs

@@ -5,7 +5,7 @@ use re_data_store::{DataStore, LatestAtQuery};
 use re_log_types::EntityPath;
 use re_query::ComponentWithInstances;
 use re_types::{
-    components::{Color, MarkerShape, Radius, ScalarScattering, Text},
+    components::{Color, MarkerShape, Radius, ScalarScattering, StrokeWidth, Text},
     Component, Loggable,
 };
 use re_viewer_context::{UiVerbosity, ViewerContext};
@@ -243,6 +243,53 @@ fn default_marker_shape(
 
 // ----
 
+#[allow(clippy::too_many_arguments)]
+fn edit_stroke_width_ui(
+    ctx: &ViewerContext<'_>,
+    ui: &mut egui::Ui,
+    _verbosity: UiVerbosity,
+    query: &LatestAtQuery,
+    store: &DataStore,
+    entity_path: &EntityPath,
+    override_path: &EntityPath,
+    component: &ComponentWithInstances,
+    instance_key: &re_types::components::InstanceKey,
+) {
+    let current_stroke_width = component
+        .lookup::<StrokeWidth>(instance_key)
+        .ok()
+        .unwrap_or_else(|| default_stroke_width(ctx, query, store, entity_path));
+
+    let current_stroke_width = current_stroke_width.0;
+    let mut edit_stroke_width = current_stroke_width;
+
+    let speed = (current_stroke_width * 0.01).at_least(0.001);
+
+    ui.add(
+        egui::DragValue::new(&mut edit_stroke_width)
+            .clamp_range(0.0..=f64::INFINITY)
+            .speed(speed),
+    );
+
+    if edit_stroke_width != current_stroke_width {
+        let new_stroke_width = StrokeWidth::from(edit_stroke_width);
+
+        ctx.save_blueprint_component(override_path, new_stroke_width);
+    }
+}
+
+#[inline]
+fn default_stroke_width(
+    _ctx: &ViewerContext<'_>,
+    _query: &LatestAtQuery,
+    _store: &DataStore,
+    _entity_path: &EntityPath,
+) -> StrokeWidth {
+    StrokeWidth::from(1.0)
+}
+
+// ----
+
 fn register_editor<'a, C: Component + Loggable + 'static>(
     registry: &mut re_viewer_context::ComponentUiRegistry,
     default: fn(&ViewerContext<'_>, &LatestAtQuery, &DataStore, &EntityPath) -> C,
@@ -272,8 +319,9 @@ fn register_editor<'a, C: Component + Loggable + 'static>(
 
 pub fn register_editors(registry: &mut re_viewer_context::ComponentUiRegistry) {
     register_editor::<Color>(registry, default_color, edit_color_ui);
-    register_editor::<Text>(registry, default_text, edit_text_ui);
-    register_editor::<ScalarScattering>(registry, default_scatter, edit_scatter_ui);
-    register_editor::<Radius>(registry, default_radius, edit_radius_ui);
     register_editor::<MarkerShape>(registry, default_marker_shape, edit_marker_shape_ui);
+    register_editor::<Radius>(registry, default_radius, edit_radius_ui);
+    register_editor::<ScalarScattering>(registry, default_scatter, edit_scatter_ui);
+    register_editor::<StrokeWidth>(registry, default_stroke_width, edit_stroke_width_ui);
+    register_editor::<Text>(registry, default_text, edit_text_ui);
 }

crates/re_space_view_time_series/src/aggregation.rs

@@ -33,7 +33,7 @@ impl AverageAggregator {
                 let point = &points[i + j];
 
                 acc.value += point.value;
-                acc.attrs.radius += point.attrs.radius;
+                acc.attrs.stroke_width += point.attrs.stroke_width;
 
                 ratio += 1.0;
                 j += 1;
@@ -48,14 +48,14 @@ impl AverageAggregator {
 
                 let w = aggregation_factor_fract;
                 acc.value += point.value * w;
-                acc.attrs.radius += (point.attrs.radius as f64 * w) as f32;
+                acc.attrs.stroke_width += (point.attrs.stroke_width as f64 * w) as f32;
 
                 ratio += aggregation_factor_fract;
                 j += 1;
             }
 
             acc.value /= ratio;
-            acc.attrs.radius = (acc.attrs.radius as f64 / ratio) as _;
+            acc.attrs.stroke_width = (acc.attrs.stroke_width as f64 / ratio) as _;
 
             aggregated.push(acc);
 
@@ -124,17 +124,21 @@ impl MinMaxAggregator {
                 match self {
                     MinMaxAggregator::MinMax | MinMaxAggregator::MinMaxAverage => {
                         acc_min.value = f64::min(acc_min.value, point.value);
-                        acc_min.attrs.radius = f32::min(acc_min.attrs.radius, point.attrs.radius);
+                        acc_min.attrs.stroke_width =
+                            f32::min(acc_min.attrs.stroke_width, point.attrs.stroke_width);
                         acc_max.value = f64::max(acc_max.value, point.value);
-                        acc_max.attrs.radius = f32::max(acc_max.attrs.radius, point.attrs.radius);
+                        acc_max.attrs.stroke_width =
+                            f32::max(acc_max.attrs.stroke_width, point.attrs.stroke_width);
                     }
                     MinMaxAggregator::Min => {
                         acc_min.value = f64::min(acc_min.value, point.value);
-                        acc_min.attrs.radius = f32::min(acc_min.attrs.radius, point.attrs.radius);
+                        acc_min.attrs.stroke_width =
+                            f32::min(acc_min.attrs.stroke_width, point.attrs.stroke_width);
                     }
                     MinMaxAggregator::Max => {
                         acc_max.value = f64::max(acc_max.value, point.value);
-                        acc_max.attrs.radius = f32::max(acc_max.attrs.radius, point.attrs.radius);
+                        acc_max.attrs.stroke_width =
+                            f32::max(acc_max.attrs.stroke_width, point.attrs.stroke_width);
                     }
                 }
 
@@ -153,7 +157,8 @@ impl MinMaxAggregator {
                     // Don't average a single point with itself.
                     if j > 1 {
                         acc_min.value = (acc_min.value + acc_max.value) * 0.5;
-                        acc_min.attrs.radius = (acc_min.attrs.radius + acc_max.attrs.radius) * 0.5;
+                        acc_min.attrs.stroke_width =
+                            (acc_min.attrs.stroke_width + acc_max.attrs.stroke_width) * 0.5;
                     }
                     aggregated.push(acc_min);
                 }
@@ -190,7 +195,7 @@ fn are_aggregatable(point1: &PlotPoint, point2: &PlotPoint, window_size: usize)
     let PlotPointAttrs {
         label,
         color,
-        radius: _,
+        stroke_width: _,
         kind,
     } = attrs;
 

crates/re_space_view_time_series/src/lib.rs

@@ -33,7 +33,7 @@ pub(crate) fn plot_id(space_view_id: re_viewer_context::SpaceViewId) -> egui::Id
 pub struct PlotPointAttrs {
     pub label: Option<String>,
     pub color: egui::Color32,
-    pub radius: f32,
+    pub stroke_width: f32,
     pub kind: PlotSeriesKind,
 }
 
@@ -47,12 +47,12 @@ impl PartialEq for PlotPointAttrs {
         let Self {
             label,
             color,
-            radius,
+            stroke_width: radius,
             kind,
         } = self;
         label.eq(&rhs.label)
             && color.eq(&rhs.color)
-            && radius.total_cmp(&rhs.radius).is_eq()
+            && radius.total_cmp(&rhs.stroke_width).is_eq()
             && kind.eq(&rhs.kind)
     }
 }

crates/re_space_view_time_series/src/line_visualizer_system.rs

@@ -1,8 +1,9 @@
 use re_query_cache::{MaybeCachedComponentData, QueryError};
 use re_types::archetypes;
+use re_types::components::StrokeWidth;
 use re_types::{
     archetypes::SeriesLine,
-    components::{Color, Radius, Scalar, Text},
+    components::{Color, Scalar, Text},
     Archetype as _, ComponentNameSet, Loggable,
 };
 use re_viewer_context::{
@@ -29,6 +30,8 @@ impl IdentifiedViewSystem for SeriesLineSystem {
     }
 }
 
+const DEFAULT_STROKE_WIDTH: f32 = 0.75;
+
 impl VisualizerSystem for SeriesLineSystem {
     fn visualizer_query_info(&self) -> VisualizerQueryInfo {
         let mut query_info = VisualizerQueryInfo::from_archetype::<archetypes::Scalar>();
@@ -76,6 +79,8 @@ impl VisualizerSystem for SeriesLineSystem {
     ) -> Option<re_log_types::DataCell> {
         if *component == Color::name() {
             Some([initial_override_color(entity_path)].into())
+        } else if *component == StrokeWidth::name() {
+            Some([StrokeWidth(DEFAULT_STROKE_WIDTH)].into())
         } else {
             None
         }
@@ -123,18 +128,19 @@ impl SeriesLineSystem {
                 let override_label =
                     lookup_override::<Text>(data_result, ctx).map(|t| t.to_string());
 
-                let override_radius = lookup_override::<Radius>(data_result, ctx).map(|r| r.0);
+                let override_stroke_width =
+                    lookup_override::<StrokeWidth>(data_result, ctx).map(|r| r.0);
 
                 let query = re_data_store::RangeQuery::new(query.timeline, time_range);
 
                 // TODO(jleibs): need to do a "joined" archetype query
                 query_caches
-                    .query_archetype_pov1_comp2::<archetypes::Scalar, Scalar, Color, Text, _>(
+                    .query_archetype_pov1_comp3::<archetypes::Scalar, Scalar, Color, StrokeWidth, Text, _>(
                         ctx.app_options.experimental_primary_caching_range,
                         store,
                         &query.clone().into(),
                         &data_result.entity_path,
-                        |((time, _row_id), _, scalars, colors, labels)| {
+                        |((time, _row_id), _, scalars, colors, stroke_width, labels)| {
                             let Some(time) = time else {
                                 return;
                             }; // scalars cannot be timeless
@@ -147,46 +153,46 @@ impl SeriesLineSystem {
                                     attrs: PlotPointAttrs {
                                         label: None,
                                         color: egui::Color32::BLACK,
-                                        radius: 0.0,
+                                        stroke_width: 0.0,
                                         kind: PlotSeriesKind::Clear,
                                     },
                                 });
                                 return;
                             }
 
-                            for (scalar, color, label) in itertools::izip!(
+                            for (scalar, color, stoke_width, label) in itertools::izip!(
                                 scalars.iter(),
                                 MaybeCachedComponentData::iter_or_repeat_opt(
                                     &colors,
                                     scalars.len()
                                 ),
+                                MaybeCachedComponentData::iter_or_repeat_opt(
+                                    &stroke_width,
+                                    scalars.len()
+                                ),
                                 //MaybeCachedComponentData::iter_or_repeat_opt(&radii, scalars.len()),
                                 MaybeCachedComponentData::iter_or_repeat_opt(
                                     &labels,
                                     scalars.len()
                                 ),
                             ) {
-                                // TODO(jleibs): Replace with StrokeWidth
-                                let radius: Option<Radius> = None;
                                 let color = override_color.unwrap_or_else(|| {
                                     annotation_info
                                         .color(color.map(|c| c.to_array()), default_color)
                                 });
                                 let label = override_label.clone().or_else(|| {
                                     annotation_info.label(label.as_ref().map(|l| l.as_str()))
                                 });
-                                let radius = override_radius
-                                    .unwrap_or_else(|| radius.map_or(DEFAULT_RADIUS, |r| r.0));
-
-                                const DEFAULT_RADIUS: f32 = 0.75;
+                                let stroke_width = override_stroke_width
+                                    .unwrap_or_else(|| stoke_width.map_or(DEFAULT_STROKE_WIDTH, |r| r.0));
 
                                 points.push(PlotPoint {
                                     time: time.as_i64(),
                                     value: scalar.0,
                                     attrs: PlotPointAttrs {
                                         label,
                                         color,
-                                        radius,
+                                        stroke_width,
                                         kind: PlotSeriesKind::Continuous,
                                     },
                                 });

crates/re_space_view_time_series/src/point_visualizer_system.rs

@@ -159,7 +159,7 @@ impl SeriesPointSystem {
                                     attrs: PlotPointAttrs {
                                         label: None,
                                         color: egui::Color32::BLACK,
-                                        radius: 0.0,
+                                        stroke_width: 0.0,
                                         kind: PlotSeriesKind::Clear,
                                     },
                                 });
@@ -204,7 +204,7 @@ impl SeriesPointSystem {
                                     attrs: PlotPointAttrs {
                                         label,
                                         color,
-                                        radius,
+                                        stroke_width: radius,
                                         kind: PlotSeriesKind::Scatter(ScatterAttrs{marker}),
                                     },
                                 });

crates/re_space_view_time_series/src/util.rs

@@ -107,7 +107,7 @@ pub fn points_to_series(
         all_series.push(PlotSeries {
             label: series_label,
             color: points[0].attrs.color,
-            width: 2.0 * points[0].attrs.radius,
+            width: 2.0 * points[0].attrs.stroke_width,
             kind,
             points: vec![(points[0].time, points[0].value)],
             entity_path: data_result.entity_path.clone(),
@@ -204,7 +204,7 @@ fn add_series_runs(
     let mut series: PlotSeries = PlotSeries {
         label: series_label.to_owned(),
         color: attrs.color,
-        width: 2.0 * attrs.radius,
+        width: 2.0 * attrs.stroke_width,
         points: Vec::with_capacity(num_points),
         kind: attrs.kind,
         entity_path: entity_path.clone(),
@@ -228,7 +228,7 @@ fn add_series_runs(
                 PlotSeries {
                     label: series_label.to_owned(),
                     color: attrs.color,
-                    width: 2.0 * attrs.radius,
+                    width: 2.0 * attrs.stroke_width,
                     kind: attrs.kind,
                     points: Vec::with_capacity(num_points - i),
                     entity_path: entity_path.clone(),

crates/re_space_view_time_series/src/visualizer_system.rs

@@ -149,7 +149,7 @@ impl LegacyTimeSeriesSystem {
                                 attrs: PlotPointAttrs {
                                     label: None,
                                     color: egui::Color32::BLACK,
-                                    radius: 0.0,
+                                    stroke_width: 0.0,
                                     kind: PlotSeriesKind::Clear,
                                 },
                             });
@@ -188,7 +188,7 @@ impl LegacyTimeSeriesSystem {
                                 attrs: PlotPointAttrs {
                                     label,
                                     color,
-                                    radius,
+                                    stroke_width: radius,
                                     kind,
                                 },
                             });

crates/re_types/definitions/rerun/archetypes/series_line.fbs

@@ -18,4 +18,8 @@ table SeriesLine (
     /// Color for the corresponding series.
     // TODO(jleibs): This should be batch if we make a batch Scalars loggable.
     color: rerun.components.Color ("attr.rerun.component_optional", nullable, order: 1000);
+
+    /// Stroke width for the corresponding series.
+    // TODO(jleibs): This should be batch if we make a batch Scalars loggable.
+    width: rerun.components.StrokeWidth ("attr.rerun.component_optional", nullable, order: 2000);
 }

crates/re_types/definitions/rerun/components.fbs

@@ -25,6 +25,7 @@ include "./components/resolution.fbs";
 include "./components/rotation3d.fbs";
 include "./components/scalar_scattering.fbs";
 include "./components/scalar.fbs";
+include "./components/stroke_width.fbs";
 include "./components/tensor_data.fbs";
 include "./components/texcoord2d.fbs";
 include "./components/text_log_level.fbs";

crates/re_types/definitions/rerun/components/stroke_width.fbs

@@ -0,0 +1,21 @@
+include "arrow/attributes.fbs";
+include "python/attributes.fbs";
+include "rust/attributes.fbs";
+
+include "rerun/datatypes.fbs";
+include "rerun/attributes.fbs";
+
+namespace rerun.components;
+
+// ---
+
+/// The width of a stroke specified in UI points.
+struct StrokeWidth (
+  "attr.docs.unreleased",
+  "attr.python.aliases": "float",
+  "attr.python.array_aliases": "float, npt.ArrayLike",
+  "attr.rust.derive": "Copy, PartialEq, PartialOrd, bytemuck::Pod, bytemuck::Zeroable",
+  "attr.rust.repr": "transparent"
+) {
+  width: float (order: 100);
+}