Set timeline with most events as default timeline (#11217)

### Related

* Closes
https://linear.app/rerun/issue/RR-2282/better-default-timeline-when-loading-mcap.
* Related: #10739

### What

This PR changes the `default_timeline` logic (when no timeline was
selected by the user) to always switch to the timeline with the most
events on it.

It also adds the number of events to the timeline selector in the time
panel.

> [!IMPORTANT]
> It would be very nice if we could right-align the subdued text. That
way it would be much easier to see, at a glance, which of the timelines
has the most events (because the text would be the longest). **If
someone knows how to do this quickly, please point out in the review.**

| dark | light |
|--------|--------|
| <img width="233" height="199" alt="image"
src="https://github.com/user-attachments/assets/2c3eacf0-2a5e-4ffb-b334-a8ba3af28159"
/> | <img width="233" height="201" alt="image"
src="https://github.com/user-attachments/assets/96d094cc-596d-4a2e-ae95-4a55201fe0b1"
/> |

---------

Co-authored-by: Andreas Reich <[email protected]>

Author: grtlr

crates/store/re_entity_db/src/lib.rs

@@ -20,7 +20,7 @@ pub use self::{
     instance_path::{InstancePath, InstancePathHash},
     store_bundle::{StoreBundle, StoreLoadError},
     time_histogram_per_timeline::{TimeHistogram, TimeHistogramPerTimeline},
-    times_per_timeline::{TimeCounts, TimesPerTimeline},
+    times_per_timeline::{TimeCounts, TimelineStats, TimesPerTimeline},
     versioned_instance_path::{VersionedInstancePath, VersionedInstancePathHash},
 };
 

crates/store/re_entity_db/src/times_per_timeline.rs

@@ -8,19 +8,30 @@ use re_log_types::{TimeInt, Timeline};
 
 pub type TimeCounts = BTreeMap<TimeInt, u64>;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct TimelineStats {
     pub timeline: Timeline,
     pub per_time: TimeCounts,
+    pub total_count: u64,
 }
 
 impl TimelineStats {
     pub fn new(timeline: Timeline) -> Self {
         Self {
             timeline,
             per_time: Default::default(),
+            total_count: 0,
         }
     }
+
+    pub fn num_events(&self) -> u64 {
+        debug_assert_eq!(
+            self.per_time.values().sum::<u64>(),
+            self.total_count,
+            "[DEBUG ASSERT] book keeping drifted"
+        );
+        self.total_count
+    }
 }
 
 /// A [`ChunkStoreSubscriber`] that keeps track of all unique timestamps on each [`Timeline`].
@@ -43,6 +54,11 @@ impl TimesPerTimeline {
     pub fn timelines(&self) -> impl ExactSizeIterator<Item = &Timeline> + '_ {
         self.0.values().map(|stats| &stats.timeline)
     }
+
+    #[inline]
+    pub fn timelines_with_stats(&self) -> impl ExactSizeIterator<Item = &TimelineStats> + '_ {
+        self.0.values()
+    }
 }
 
 // Always ensure we have a default "log_time" timeline.
@@ -85,6 +101,7 @@ impl ChunkStoreSubscriber for TimesPerTimeline {
 
                 for time in time_column.times() {
                     let count = stats.per_time.entry(time).or_default();
+                    let total_count = &mut stats.total_count;
 
                     let delta = event.delta();
 
@@ -95,21 +112,45 @@ impl ChunkStoreSubscriber for TimesPerTimeline {
                                 entity_path = %event.chunk.entity_path(),
                                 current = count,
                                 removed = delta.unsigned_abs(),
-                                "book keeping underflowed"
+                                "per `TimeInt` book keeping underflowed"
                             );
                             u64::MIN
                         });
+                        *total_count = total_count
+                            .checked_sub(delta.unsigned_abs())
+                            .unwrap_or_else(|| {
+                                re_log::debug!(
+                                    store_id = ?event.store_id,
+                                    entity_path = %event.chunk.entity_path(),
+                                    current = total_count,
+                                    removed = delta.unsigned_abs(),
+                                    "total book keeping underflowed"
+                                );
+                                u64::MIN
+                            });
                     } else {
                         *count = count.checked_add(delta.unsigned_abs()).unwrap_or_else(|| {
                             re_log::debug!(
                                 store_id = ?event.store_id,
                                 entity_path = %event.chunk.entity_path(),
                                 current = count,
                                 removed = delta.unsigned_abs(),
-                                "book keeping overflowed"
+                                "per `TimeInt` book keeping overflowed"
                             );
                             u64::MAX
                         });
+                        *total_count = total_count
+                            .checked_add(delta.unsigned_abs())
+                            .unwrap_or_else(|| {
+                                re_log::debug!(
+                                    store_id = ?event.store_id,
+                                    entity_path = %event.chunk.entity_path(),
+                                    current = total_count,
+                                    removed = delta.unsigned_abs(),
+                                    "total book keeping underflowed"
+                                );
+                                u64::MAX
+                            });
                     }
 
                     if *count == 0 {

crates/viewer/re_time_panel/src/time_control_ui.rs

@@ -28,11 +28,21 @@ impl TimeControlUi {
             egui::ComboBox::from_id_salt("timeline")
                 .selected_text(time_control.timeline().name().as_str())
                 .show_ui(ui, |ui| {
-                    for timeline in times_per_timeline.timelines() {
+                    for timeline_stats in times_per_timeline.timelines_with_stats() {
+                        let timeline = &timeline_stats.timeline;
                         if ui
                             .selectable_label(
                                 timeline == time_control.timeline(),
-                                timeline.name().as_str(),
+                                (
+                                    timeline.name().as_str(),
+                                    egui::Atom::grow(),
+                                    egui::RichText::new(format!(
+                                        "{} events",
+                                        re_format::format_uint(timeline_stats.num_events())
+                                    ))
+                                    .size(10.0)
+                                    .color(ui.tokens().text_subdued),
+                                ),
                             )
                             .clicked()
                         {

crates/viewer/re_viewer_context/src/time_control.rs

@@ -1,7 +1,7 @@
 use std::collections::BTreeMap;
 
 use re_chunk::TimelineName;
-use re_entity_db::{TimeCounts, TimesPerTimeline};
+use re_entity_db::{TimeCounts, TimelineStats, TimesPerTimeline};
 use re_log_types::{
     AbsoluteTimeRange, AbsoluteTimeRangeF, Duration, TimeCell, TimeInt, TimeReal, TimeType,
     Timeline,
@@ -564,7 +564,8 @@ impl TimeControl {
         if matches!(self.timeline, ActiveTimeline::Auto(_))
             || !is_timeline_valid(self.timeline(), times_per_timeline)
         {
-            self.timeline = ActiveTimeline::Auto(default_timeline(times_per_timeline.timelines()));
+            self.timeline =
+                ActiveTimeline::Auto(default_timeline(times_per_timeline.timelines_with_stats()));
         }
     }
 
@@ -740,23 +741,26 @@ fn range(values: &TimeCounts) -> AbsoluteTimeRange {
     AbsoluteTimeRange::new(min(values), max(values))
 }
 
-/// Pick the timeline that should be the default, prioritizing user-defined ones.
-fn default_timeline<'a>(timelines: impl IntoIterator<Item = &'a Timeline>) -> Timeline {
-    let mut found_log_tick = false;
-    let mut found_log_time = false;
+/// Pick the timeline that should be the default, by number of elements and prioritizing user-defined ones.
+fn default_timeline<'a>(timelines: impl IntoIterator<Item = &'a TimelineStats>) -> Timeline {
+    re_tracing::profile_function!();
 
-    for timeline in timelines {
-        if timeline == &Timeline::log_tick() {
-            found_log_tick = true;
-        } else if timeline == &Timeline::log_time() {
-            found_log_time = true;
-        } else {
-            return *timeline;
+    // Helper function that acts as a tie-breaker.
+    fn timeline_priority(timeline: &Timeline) -> u8 {
+        match timeline {
+            t if *t == Timeline::log_tick() => 0, // lowest priority
+            t if *t == Timeline::log_time() => 1, // medium priority
+            _ => 2,                               // user-defined, highest priority
         }
     }
+    let most_events = timelines.into_iter().max_by(|a, b| {
+        a.num_events()
+            .cmp(&b.num_events())
+            .then_with(|| timeline_priority(&a.timeline).cmp(&timeline_priority(&b.timeline)))
+    });
 
-    if found_log_tick && !found_log_time {
-        Timeline::log_tick()
+    if let Some(most_events) = most_events {
+        most_events.timeline
     } else {
         Timeline::log_time()
     }
@@ -823,50 +827,62 @@ fn step_back_time_looped(
 mod tests {
     use super::*;
 
+    fn with_events(timeline: Timeline, num: u64) -> TimelineStats {
+        TimelineStats {
+            timeline,
+            // Dummy `TimeInt` because were only interested in the counts.
+            per_time: std::iter::once((TimeInt::ZERO, num)).collect(),
+            total_count: num,
+        }
+    }
+
     #[test]
     fn test_default_timeline() {
-        let log_time = Timeline::log_time();
-        let log_tick = Timeline::log_tick();
-        let custom_timeline0 = Timeline::new("my_timeline0", TimeType::DurationNs);
-        let custom_timeline1 = Timeline::new("my_timeline1", TimeType::DurationNs);
-
-        assert_eq!(default_timeline([]), log_time);
-        assert_eq!(default_timeline([&log_tick]), log_tick);
-        assert_eq!(default_timeline([&log_time]), log_time);
-        assert_eq!(default_timeline([&log_time, &log_tick]), log_time);
+        let log_time = with_events(Timeline::log_time(), 42);
+        let log_tick = with_events(Timeline::log_tick(), 42);
+        let custom_timeline0 = with_events(Timeline::new("my_timeline0", TimeType::DurationNs), 42);
+        let custom_timeline1 = with_events(Timeline::new("my_timeline1", TimeType::DurationNs), 43);
+
+        assert_eq!(default_timeline([]), log_time.timeline);
+        assert_eq!(default_timeline([&log_tick]), log_tick.timeline);
+        assert_eq!(default_timeline([&log_time]), log_time.timeline);
+        assert_eq!(default_timeline([&log_time, &log_tick]), log_time.timeline);
         assert_eq!(
             default_timeline([&log_time, &log_tick, &custom_timeline0]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
         assert_eq!(
             default_timeline([&custom_timeline0, &log_time, &log_tick]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
         assert_eq!(
             default_timeline([&log_time, &custom_timeline0, &log_tick]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
         assert_eq!(
             default_timeline([&custom_timeline0, &log_time]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
         assert_eq!(
             default_timeline([&custom_timeline0, &log_tick]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
         assert_eq!(
             default_timeline([&log_time, &custom_timeline0]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
         assert_eq!(
             default_timeline([&log_tick, &custom_timeline0]),
-            custom_timeline0
+            custom_timeline0.timeline
         );
 
         assert_eq!(
             default_timeline([&custom_timeline0, &custom_timeline1]),
-            custom_timeline0
+            custom_timeline1.timeline
+        );
+        assert_eq!(
+            default_timeline([&custom_timeline0]),
+            custom_timeline0.timeline
         );
-        assert_eq!(default_timeline([&custom_timeline0]), custom_timeline0);
     }
 }