TimeSeriesAggregation can now be set per SeriesLine (and as blueprint default per View) (#6558)

### What

Adds `TimeSeriesAggreation` component to `SeriesLine`, allowing to set
it both per line and as a component default.

example:
```python
rr.log("trig/sin", rr.SeriesLine(color=[255, 0, 0], name="sin(0.01t)", aggregator="minmax"), static=True)
```

This is good step forward overall but there's problems with this PR
* ui is a bit worse #6556
* one would expect this setting still on the view since most of the time
one wants to change the aggregation for all lines (i.e. the default):
#6557

--
* Part of #4442
* If not already fixed, fixes
#6460

### Checklist
* [x] I have read and agree to [Contributor
Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and
the [Code of
Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md)
* [x] I've included a screenshot or gif (if applicable)
* [x] I have tested the web demo (if applicable):
* Using examples from latest `main` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/6558?manifest_url=https://app.rerun.io/version/main/examples_manifest.json)
* Using full set of examples from `nightly` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/6558?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json)
* [x] The PR title and labels are set such as to maximize their
usefulness for the next release's CHANGELOG
* [x] If applicable, add a new check to the [release
checklist](https://github.com/rerun-io/rerun/blob/main/tests/python/release_checklist)!

- [PR Build Summary](https://build.rerun.io/pr/6558)
- [Recent benchmark results](https://build.rerun.io/graphs/crates.html)
- [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)

To run all checks from `main`, comment on the PR with `@rerun-bot
full-check`.

Author: Wumpf

crates/re_edit_ui/src/lib.rs

@@ -13,8 +13,8 @@ use datatype_editors::edit_enum;
 use re_types::{
     blueprint::components::{BackgroundKind, Corner2D, LockRangeDuringZoom, Visible},
     components::{
-        AxisLength, Color, Colormap, ImagePlaneDistance, MarkerSize, Name, Radius, StrokeWidth,
-        Text,
+        AggregationPolicy, AxisLength, Color, Colormap, ImagePlaneDistance, MarkerSize, Name,
+        Radius, StrokeWidth, Text,
     },
 };
 use re_viewer_context::ViewerContext;
@@ -67,6 +67,9 @@ pub fn register_editors(registry: &mut re_viewer_context::ComponentUiRegistry) {
     registry.add_singleline_editor_ui(|_ctx, ui, value| {
         edit_enum(ui, "corner2d", value, &Corner2D::ALL)
     });
+    registry.add_singleline_editor_ui(|_ctx, ui, value| {
+        edit_enum(ui, "tseriesaggregator", value, &AggregationPolicy::ALL)
+    });
 
     registry.add_multiline_editor_ui(visual_bounds2d::multiline_edit_visual_bounds2d);
     registry.add_singleline_editor_ui(visual_bounds2d::singleline_edit_visual_bounds2d);

crates/re_entity_db/src/entity_properties.rs

@@ -1,5 +1,3 @@
-use std::fmt::Formatter;
-
 #[cfg(feature = "serde")]
 use re_log_types::EntityPath;
 
@@ -99,9 +97,6 @@ pub struct EntityProperties {
 
     /// Used to scale the radii of the points in the resulting point cloud.
     pub backproject_radius_scale: EditableAutoValue<f32>, // TODO(andreas): should be a component on the DepthImage archetype.
-
-    /// What kind of data aggregation to perform (for plot space views).
-    pub time_series_aggregator: EditableAutoValue<TimeSeriesAggregator>, // TODO(andreas): Should be a component probably on SeriesLine, but today it would become a view property.
 }
 
 #[cfg(feature = "serde")]
@@ -110,7 +105,6 @@ impl Default for EntityProperties {
         Self {
             test_property: true,
             backproject_radius_scale: EditableAutoValue::Auto(1.0),
-            time_series_aggregator: EditableAutoValue::Auto(TimeSeriesAggregator::default()),
         }
     }
 }
@@ -126,11 +120,6 @@ impl EntityProperties {
                 .backproject_radius_scale
                 .or(&child.backproject_radius_scale)
                 .clone(),
-
-            time_series_aggregator: self
-                .time_series_aggregator
-                .or(&child.time_series_aggregator)
-                .clone(),
         }
     }
 
@@ -149,11 +138,6 @@ impl EntityProperties {
                 .backproject_radius_scale
                 .or(&self.backproject_radius_scale)
                 .clone(),
-
-            time_series_aggregator: other
-                .time_series_aggregator
-                .or(&self.time_series_aggregator)
-                .clone(),
         }
     }
 
@@ -162,91 +146,9 @@ impl EntityProperties {
         let Self {
             test_property,
             backproject_radius_scale,
-            time_series_aggregator,
         } = self;
 
         test_property != &other.test_property
             || backproject_radius_scale.has_edits(&other.backproject_radius_scale)
-            || time_series_aggregator.has_edits(&other.time_series_aggregator)
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-/// What kind of aggregation should be performed when the zoom-level on the X axis goes below 1.0?
-///
-/// Aggregation affects the points' values and radii.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub enum TimeSeriesAggregator {
-    /// No aggregation.
-    Off,
-
-    /// Average all points in the range together.
-    Average,
-
-    /// Keep only the maximum values in the range.
-    Max,
-
-    /// Keep only the minimum values in the range.
-    Min,
-
-    /// Keep both the minimum and maximum values in the range.
-    ///
-    /// This will yield two aggregated points instead of one, effectively creating a vertical line.
-    #[default]
-    MinMax,
-
-    /// Find both the minimum and maximum values in the range, then use the average of those.
-    MinMaxAverage,
-}
-
-impl std::fmt::Display for TimeSeriesAggregator {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Off => write!(f, "Off"),
-            Self::Average => write!(f, "Average"),
-            Self::Max => write!(f, "Max"),
-            Self::Min => write!(f, "Min"),
-            Self::MinMax => write!(f, "MinMax"),
-            Self::MinMaxAverage => write!(f, "MinMaxAverage"),
-        }
-    }
-}
-
-impl TimeSeriesAggregator {
-    #[inline]
-    pub fn variants() -> [Self; 6] {
-        // Just making sure this method won't compile if the enum gets modified.
-        #[allow(clippy::match_same_arms)]
-        match Self::default() {
-            Self::Off => {}
-            Self::Average => {}
-            Self::Max => {}
-            Self::Min => {}
-            Self::MinMax => {}
-            Self::MinMaxAverage => {}
-        }
-
-        [
-            Self::Off,
-            Self::Average,
-            Self::Max,
-            Self::Min,
-            Self::MinMax,
-            Self::MinMaxAverage,
-        ]
-    }
-
-    #[inline]
-    pub fn description(&self) -> &'static str {
-        match self {
-            Self::Off => "No aggregation.",
-            Self::Average => "Average all points in the range together.",
-            Self::Max => "Keep only the maximum values in the range.",
-            Self::Min => "Keep only the minimum values in the range.",
-            Self::MinMax => "Keep both the minimum and maximum values in the range.\nThis will yield two aggregated points instead of one, effectively creating a vertical line.",
-            Self::MinMaxAverage => "Find both the minimum and maximum values in the range, then use the average of those",
-        }
     }
 }

crates/re_entity_db/src/lib.rs

@@ -4,6 +4,8 @@
 #![doc = document_features::document_features!()]
 //!
 
+#![allow(unused_imports)] // TODO(andreas): temporary until entity_properties is removed.
+
 pub mod entity_db;
 pub mod entity_properties;
 pub mod entity_tree;

crates/re_space_view_time_series/src/aggregation.rs

@@ -1,6 +1,6 @@
 use crate::{PlotPoint, PlotPointAttrs};
 
-/// Implements aggregation behaviors corresponding to [`TimeSeriesAggregator`][re_viewer_context::external::re_entity_db::TimeSeriesAggregator]:
+/// Implements aggregation behaviors corresponding to [`AggregationPolicy`][re_viewer_context::external::re_entity_db::AggregationPolicy]:
 /// `Average`
 pub struct AverageAggregator;
 
@@ -76,7 +76,7 @@ impl AverageAggregator {
     }
 }
 
-/// Implements aggregation behaviors corresponding to [`TimeSeriesAggregator`][re_viewer_context::external::re_entity_db::TimeSeriesAggregator]:
+/// Implements aggregation behaviors corresponding to [`AggregationPolicy`][re_viewer_context::external::re_entity_db::AggregationPolicy]:
 /// `Min`, `Max`, `MinMax`, and `MinMaxAverage`.
 pub enum MinMaxAggregator {
     /// Keep only the maximum values in the range.

crates/re_space_view_time_series/src/lib.rs

@@ -13,8 +13,10 @@ mod space_view_class;
 mod util;
 
 use re_log_types::EntityPath;
-use re_types::{components::MarkerShape, datatypes::Utf8};
-use re_viewer_context::external::re_entity_db::TimeSeriesAggregator;
+use re_types::{
+    components::{AggregationPolicy, MarkerShape},
+    datatypes::Utf8,
+};
 pub use space_view_class::TimeSeriesSpaceView;
 
 /// Computes a deterministic, globally unique ID for the plot based on the ID of the space view
@@ -88,7 +90,7 @@ pub struct PlotSeries {
     pub min_time: i64,
 
     /// What kind of aggregation was used to compute the graph?
-    pub aggregator: TimeSeriesAggregator,
+    pub aggregator: AggregationPolicy,
 
     /// `1.0` for raw data.
     ///

crates/re_space_view_time_series/src/line_visualizer_system.rs

@@ -2,6 +2,7 @@ use itertools::Itertools as _;
 use re_query::{PromiseResult, QueryError};
 use re_space_view::range_with_blueprint_resolved_data;
 use re_types::archetypes;
+use re_types::components::AggregationPolicy;
 use re_types::{
     archetypes::SeriesLine,
     components::{Color, Name, Scalar, StrokeWidth},
@@ -152,15 +153,8 @@ impl SeriesLineSystem {
         let current_query = ctx.current_query();
         let query_ctx = ctx.query_context(data_result, &current_query);
 
-        let fallback_color =
-            re_viewer_context::TypedComponentFallbackProvider::<Color>::fallback_for(
-                self, &query_ctx,
-            );
-
-        let fallback_stroke =
-            re_viewer_context::TypedComponentFallbackProvider::<StrokeWidth>::fallback_for(
-                self, &query_ctx,
-            );
+        let fallback_color: Color = self.fallback_for(&query_ctx);
+        let fallback_stroke: StrokeWidth = self.fallback_for(&query_ctx);
 
         // All the default values for a `PlotPoint`, accounting for both overrides and default
         // values.
@@ -202,6 +196,7 @@ impl SeriesLineSystem {
                     Color::name(),
                     StrokeWidth::name(),
                     Name::name(),
+                    AggregationPolicy::name(),
                 ],
             );
 
@@ -337,13 +332,26 @@ impl SeriesLineSystem {
             }
 
             // Now convert the `PlotPoints` into `Vec<PlotSeries>`
+            let aggregator = results
+                .get_or_empty_dense::<AggregationPolicy>(resolver)
+                .ok()
+                .and_then(|result| {
+                    result
+                        .range_data(all_scalars_entry_range.clone())
+                        .next()
+                        .and_then(|aggregator| aggregator.first().copied())
+                })
+                // TODO(andreas): Relying on the default==placeholder here instead of going through a fallback provider.
+                //                This is fine, because we know there's no `TypedFallbackProvider`, but wrong if one were to be added.
+                .unwrap_or_default();
             points_to_series(
-                data_result,
+                &data_result.entity_path,
                 time_per_pixel,
                 points,
                 ctx.recording_store(),
                 view_query,
                 series_name,
+                aggregator,
                 all_series,
             );
         }

crates/re_space_view_time_series/src/point_visualizer_system.rs

@@ -327,12 +327,14 @@ impl SeriesPointSystem {
 
                 // Now convert the `PlotPoints` into `Vec<PlotSeries>`
                 points_to_series(
-                    data_result,
+                    &data_result.entity_path,
                     time_per_pixel,
                     points,
                     ctx.recording_store(),
                     view_query,
                     series_name,
+                    // Aggregation for points is not supported.
+                    re_types::components::AggregationPolicy::Off,
                     &mut self.all_series,
                 );
             }

crates/re_space_view_time_series/src/space_view_class.rs

@@ -8,11 +8,10 @@ use re_log_types::{EntityPath, TimeInt, TimeZone};
 use re_space_view::{controls, view_property_ui};
 use re_types::blueprint::archetypes::{PlotLegend, ScalarAxis};
 use re_types::blueprint::components::{Corner2D, LockRangeDuringZoom, Visible};
+use re_types::components::AggregationPolicy;
 use re_types::{components::Range1D, datatypes::TimeRange, SpaceViewClassIdentifier, View};
 use re_ui::{list_item, UiExt as _};
-use re_viewer_context::external::re_entity_db::{
-    EditableAutoValue, EntityProperties, TimeSeriesAggregator,
-};
+use re_viewer_context::external::re_entity_db::EntityProperties;
 use re_viewer_context::{
     ApplicableEntities, IdentifiedViewSystem, IndicatedEntities, PerVisualizer, QueryRange,
     RecommendedSpaceView, SmallVisualizerSet, SpaceViewClass, SpaceViewClassRegistryError,
@@ -144,42 +143,11 @@ impl SpaceViewClass for TimeSeriesSpaceView {
         state: &mut dyn SpaceViewState,
         _space_origin: &EntityPath,
         space_view_id: SpaceViewId,
-        root_entity_properties: &mut EntityProperties,
+        _root_entity_properties: &mut EntityProperties,
     ) -> Result<(), SpaceViewSystemExecutionError> {
         let state = state.downcast_mut::<TimeSeriesSpaceViewState>()?;
 
         list_item::list_item_scope(ui, "time_series_selection_ui", |ui| {
-            ui.list_item()
-                .interactive(false)
-                .show_hierarchical(
-                    ui,
-                    list_item::PropertyContent::new("Zoom aggregation").value_fn(|ui, _| {
-                        let mut agg_mode = *root_entity_properties.time_series_aggregator.get();
-
-                        egui::ComboBox::from_id_source("aggregation_mode")
-                            .selected_text(agg_mode.to_string())
-                            .show_ui(ui, |ui| {
-                                for variant in TimeSeriesAggregator::variants() {
-                                    ui.selectable_value(
-                                        &mut agg_mode,
-                                        variant,
-                                        variant.to_string(),
-                                    )
-                                    .on_hover_text(variant.description());
-                                }
-                            });
-
-                        root_entity_properties.time_series_aggregator =
-                            EditableAutoValue::UserEdited(agg_mode);
-                    }),
-                )
-                .on_hover_text(
-                    "Configures the zoom-dependent scalar aggregation.\n\
-                     This is done only if steps on the X axis go below 1.0, i.e. a single pixel \
-                     covers more than one tick worth of data. It can greatly improve performance \
-                     (and readability) in such situations as it prevents overdraw.",
-                );
-
             view_property_ui::<PlotLegend>(ctx, ui, space_view_id, self, state);
             view_property_ui::<ScalarAxis>(ctx, ui, space_view_id, self, state);
         });
@@ -398,7 +366,7 @@ impl SpaceViewClass for TimeSeriesSpaceView {
 
                 let y_value = re_format::format_f64(value.y);
 
-                if aggregator == TimeSeriesAggregator::Off || aggregation_factor <= 1.0 {
+                if aggregator == AggregationPolicy::Off || aggregation_factor <= 1.0 {
                     format!("{timeline_name}: {label}\n{name}: {y_value}")
                 } else {
                     format!(