Improved automatic view creation heuristic, major speedup for scenes with many entities

crates/re_data_store/src/store_write.rs

@@ -237,7 +237,7 @@ impl DataStore {
         } else {
             // Cache miss! Craft a new instance keys from the ground up.
 
-            // ...so we create it manually instead.
+            // …so we create it manually instead.
             let values =
                 arrow2::array::UInt64Array::from_vec((0..num_instances as u64).collect_vec())
                     .boxed();

crates/re_entity_db/src/entity_tree.rs

@@ -563,9 +563,9 @@ impl EntityTree {
         subtree_recursive(self, path.as_slice())
     }
 
-    // Invokes visitor for `self` all children recursively.
-    pub fn visit_children_recursively(&self, visitor: &mut impl FnMut(&EntityPath)) {
-        visitor(&self.path);
+    // Invokes visitor for `self` and all children recursively.
+    pub fn visit_children_recursively(&self, visitor: &mut impl FnMut(&EntityPath, &EntityInfo)) {
+        visitor(&self.path, &self.entity);
         for child in self.children.values() {
             child.visit_children_recursively(visitor);
         }

crates/re_log_types/src/path/entity_path_filter.rs

@@ -110,6 +110,20 @@ impl EntityPathFilter {
         filter
     }
 
+    /// Creates a new entity path filter that includes only a single entity.
+    pub fn single_entity_filter(entity_path: &EntityPath) -> Self {
+        let mut filter = Self::default();
+        filter.add_exact(entity_path.clone());
+        filter
+    }
+
+    /// Creates a new entity path filter that includes a single subtree.
+    pub fn subtree_entity_filter(entity_path: &EntityPath) -> Self {
+        let mut filter = Self::default();
+        filter.add_subtree(entity_path.clone());
+        filter
+    }
+
     pub fn add_rule(&mut self, effect: RuleEffect, rule: EntityPathRule) {
         self.rules.insert(rule, effect);
     }

crates/re_sdk/src/recording_stream.rs

@@ -1158,7 +1158,7 @@ impl RecordingStream {
             // Get the current time on all timelines, for the current recording, on the current
             // thread…
             let mut now = self.now();
-            // ...and then also inject the current recording tick into it.
+            // …and then also inject the current recording tick into it.
             now.insert(Timeline::log_tick(), tick.into());
 
             // Inject all these times into the row, overriding conflicting times, if any.

crates/re_space_view/src/data_query_blueprint.rs

@@ -274,9 +274,7 @@ impl<'a> QueryExpressionEvaluator<'a> {
                         if self
                             .indicator_matching_entities_per_visualizer
                             .get(visualizer)
-                            .map_or(false, |matching_list| {
-                                matching_list.contains(&entity_path.hash())
-                            })
+                            .map_or(false, |matching_list| matching_list.contains(entity_path))
                         {
                             Some(*visualizer)
                         } else {
@@ -404,7 +402,7 @@ impl DataQueryPropertyResolver<'_> {
         let mut prop_map = self.auto_properties.clone();
 
         if let Some(tree) = blueprint.tree().subtree(override_root) {
-            tree.visit_children_recursively(&mut |path: &EntityPath| {
+            tree.visit_children_recursively(&mut |path: &EntityPath, _| {
                 if let Some(props) = blueprint
                     .store()
                     .query_latest_component_quiet::<EntityPropertiesComponent>(path, query)
@@ -667,9 +665,7 @@ mod tests {
                         .map(|(id, entities)| {
                             (
                                 *id,
-                                IndicatorMatchingEntities(
-                                    entities.0.iter().map(|path| path.hash()).collect(),
-                                ),
+                                IndicatorMatchingEntities(entities.0.iter().cloned().collect()),
                             )
                         })
                         .collect(),

crates/re_space_view/src/heuristics.rs

@@ -0,0 +1,55 @@
+use re_log_types::EntityPathFilter;
+use re_viewer_context::{
+    ApplicableEntities, IdentifiedViewSystem, RecommendedSpaceView, SpaceViewClass,
+    SpaceViewSpawnHeuristics, ViewerContext, VisualizerSystem,
+};
+
+/// Spawns a space view for each single entity which is visualizable & indicator-matching for a given visualizer.
+pub fn recommend_space_views_for_all_default_visualized_entities_for<TVisualizer>(
+    ctx: &ViewerContext<'_>,
+    space_view: &impl SpaceViewClass,
+) -> SpaceViewSpawnHeuristics
+where
+    TVisualizer: VisualizerSystem + IdentifiedViewSystem + Default,
+{
+    re_tracing::profile_function!();
+
+    let Some(indicator_matching_entities) = ctx
+        .indicator_matching_entities_per_visualizer
+        .get(&TVisualizer::identifier())
+    else {
+        return Default::default();
+    };
+    let Some(applicable_entities) = ctx
+        .applicable_entities_per_visualizer
+        .get(&TVisualizer::identifier())
+    else {
+        return Default::default();
+    };
+
+    let visualizer = TVisualizer::default();
+    let recommended_space_views = applicable_entities
+        .intersection(indicator_matching_entities)
+        .filter_map(|entity| {
+            let context = space_view.visualizable_filter_context(entity, ctx.entity_db);
+            if visualizer
+                .filter_visualizable_entities(
+                    ApplicableEntities(std::iter::once(entity.clone()).collect()),
+                    context.as_ref(),
+                )
+                .is_empty()
+            {
+                None
+            } else {
+                Some(RecommendedSpaceView {
+                    root: entity.clone(),
+                    query_filter: EntityPathFilter::single_entity_filter(entity),
+                })
+            }
+        })
+        .collect();
+
+    re_viewer_context::SpaceViewSpawnHeuristics {
+        recommended_space_views,
+    }
+}

crates/re_space_view/src/lib.rs

@@ -6,11 +6,13 @@ pub mod blueprint;
 pub mod controls;
 mod data_query;
 mod data_query_blueprint;
+mod heuristics;
 mod screenshot;
 mod unreachable_transform_reason;
 
 pub use data_query::{DataQuery, EntityOverrideContext, PropertyResolver};
 pub use data_query_blueprint::DataQueryBlueprint;
+pub use heuristics::recommend_space_views_for_all_default_visualized_entities_for;
 pub use screenshot::ScreenshotMode;
 pub use unreachable_transform_reason::UnreachableTransformReason;
 

crates/re_space_view_bar_chart/src/space_view_class.rs

@@ -1,7 +1,7 @@
 use egui::util::hash;
 use re_entity_db::{EditableAutoValue, EntityProperties, LegendCorner};
 use re_log_types::EntityPath;
-use re_space_view::controls;
+use re_space_view::{controls, recommend_space_views_for_all_default_visualized_entities_for};
 use re_types::datatypes::TensorBuffer;
 use re_viewer_context::{
     auto_color, SpaceViewClass, SpaceViewClassRegistryError, SpaceViewId,
@@ -59,6 +59,16 @@ impl SpaceViewClass for BarChartSpaceView {
         None
     }
 
+    fn spawn_heuristics(
+        &self,
+        ctx: &ViewerContext<'_>,
+    ) -> re_viewer_context::SpaceViewSpawnHeuristics {
+        re_tracing::profile_function!();
+        recommend_space_views_for_all_default_visualized_entities_for::<BarChartVisualizerSystem>(
+            ctx, self,
+        )
+    }
+
     fn layout_priority(&self) -> re_viewer_context::SpaceViewClassLayoutPriority {
         re_viewer_context::SpaceViewClassLayoutPriority::Low
     }

crates/re_space_view_bar_chart/src/visualizer_system.rs

@@ -4,10 +4,7 @@ use re_data_store::LatestAtQuery;
 use re_entity_db::EntityPath;
 use re_space_view::diff_component_filter;
 use re_types::{
-    archetypes::{BarChart, Tensor},
-    components::Color,
-    datatypes::TensorData,
-    Archetype, ComponentNameSet,
+    archetypes::BarChart, components::Color, datatypes::TensorData, Archetype, ComponentNameSet,
 };
 use re_viewer_context::{
     IdentifiedViewSystem, SpaceViewSystemExecutionError, ViewContextCollection, ViewQuery,
@@ -45,12 +42,7 @@ impl VisualizerSystem for BarChartVisualizerSystem {
     }
 
     fn indicator_components(&self) -> ComponentNameSet {
-        // TODO(#3342): For now, we relax the indicator component heuristics on bar charts so that
-        // logging a 1D tensor also results in a bar chart view, rather than a broken viewer (see #3709).
-        // Ideally though, this should be implemented using an heuristic fallback mechanism.
-        [BarChart::indicator().name(), Tensor::indicator().name()]
-            .into_iter()
-            .collect()
+        std::iter::once(BarChart::indicator().name()).collect()
     }
 
     fn applicability_filter(&self) -> Option<Box<dyn VisualizerAdditionalApplicabilityFilter>> {

crates/re_space_view_dataframe/src/space_view_class.rs

@@ -8,9 +8,8 @@ use re_entity_db::{EntityProperties, InstancePath};
 use re_log_types::{EntityPath, Timeline};
 use re_query::get_component_with_instances;
 use re_viewer_context::{
-    AutoSpawnHeuristic, PerSystemEntities, SpaceViewClass, SpaceViewClassRegistryError,
-    SpaceViewId, SpaceViewSystemExecutionError, SystemExecutionOutput, UiVerbosity, ViewQuery,
-    ViewerContext,
+    SpaceViewClass, SpaceViewClassRegistryError, SpaceViewId, SpaceViewSystemExecutionError,
+    SystemExecutionOutput, UiVerbosity, ViewQuery, ViewerContext,
 };
 
 use crate::visualizer_system::EmptySystem;
@@ -53,13 +52,12 @@ impl SpaceViewClass for DataframeSpaceView {
         re_viewer_context::SpaceViewClassLayoutPriority::Low
     }
 
-    fn auto_spawn_heuristic(
+    fn spawn_heuristics(
         &self,
         _ctx: &ViewerContext<'_>,
-        _space_origin: &EntityPath,
-        _ent_paths: &PerSystemEntities,
-    ) -> re_viewer_context::AutoSpawnHeuristic {
-        AutoSpawnHeuristic::NeverSpawn
+    ) -> re_viewer_context::SpaceViewSpawnHeuristics {
+        // Doesn't spawn anything by default.
+        Default::default()
     }
 
     fn selection_ui(