From bc30648f09fc562708a345336f116111d30484d2 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 25 Sep 2026 11:48:38 -0400
Subject: [PATCH 1/3] Add Review statistics and aggregate sequence timelines

---
 .../components/Review/ReviewDatasetsPanel.vue |   2 +-
 .../components/Review/ReviewPage.spec.ts      |  43 +++++-
 .../components/Review/ReviewPage.vue          |  18 ++-
 .../Review/ReviewStatisticsPanel.vue          | 125 ++++++++++++++++++
 client/dive-common/review/reviewSession.ts    |   2 +-
 client/dive-common/review/statistics.spec.ts  | 104 +++++++++++++++
 client/dive-common/review/statistics.ts       | 121 +++++++++++++++++
 client/dive-common/use/useReview.ts           |  10 ++
 docs/Review.md                                |  28 ++++
 9 files changed, 446 insertions(+), 7 deletions(-)
 create mode 100644 client/dive-common/components/Review/ReviewStatisticsPanel.vue
 create mode 100644 client/dive-common/review/statistics.spec.ts
 create mode 100644 client/dive-common/review/statistics.ts

diff --git a/client/dive-common/components/Review/ReviewDatasetsPanel.vue b/client/dive-common/components/Review/ReviewDatasetsPanel.vue
index 54ad9ce05..70ae7767d 100644
--- a/client/dive-common/components/Review/ReviewDatasetsPanel.vue
+++ b/client/dive-common/components/Review/ReviewDatasetsPanel.vue
@@ -54,7 +54,7 @@ export default defineComponent({
 
     function statusText(status: string) {
       if (status === 'ready') return 'Ready';
-      if (status === 'queued') return 'Loads when Results opens';
+      if (status === 'queued') return 'Loads when Results or Statistics opens';
       return 'Loading…';
     }
 
diff --git a/client/dive-common/components/Review/ReviewPage.spec.ts b/client/dive-common/components/Review/ReviewPage.spec.ts
index 4c66d5ea2..3980d5a51 100644
--- a/client/dive-common/components/Review/ReviewPage.spec.ts
+++ b/client/dive-common/components/Review/ReviewPage.spec.ts
@@ -3,7 +3,7 @@ import Vue, { ComponentOptions, CreateElement, nextTick } from 'vue';
 import type { NavigationGuard } from 'vue-router';
 import type { DatasetConfig } from 'dive-common/apispec';
 import type { ReviewService } from 'dive-common/use/useReview';
-import { takeReviewSession } from 'dive-common/review/reviewSession';
+import { holdReviewSession, takeReviewSession } from 'dive-common/review/reviewSession';
 import ReviewPage from './ReviewPage.vue';
 
 const mocks = vi.hoisted(() => ({
@@ -46,7 +46,8 @@ interface PageState {
   review: ReviewService;
   grid: { page: { value: number }; goToPage(page: number): void };
   deleteEntry(entry: ReviewService['entries']['value'][number]): void;
-  view: 'results' | 'datasets';
+  view: 'results' | 'datasets' | 'statistics';
+  setView(view: 'statistics'): void;
   resolveLeave(choice: 'save' | 'discard' | 'cancel'): void;
   leaveDialog: boolean;
 }
@@ -259,3 +260,41 @@ it('repopulates a cleared list when returning from the same sequence that starte
   expect(page.view).toBe('results');
   second.destroy();
 });
+
+it('loads queued datasets on Statistics and updates counts after edits, deletion, and removal', async () => {
+  const wrapper = mountPage({ retainSession: false });
+  const page = wrapper.vm as unknown as PageState;
+  await page.review.addDataset('stats', undefined, { defer: true });
+  expect(page.review.statistics.value.trackCount).toBe(0);
+  page.setView('statistics');
+  await page.review.ensureLoaded('stats');
+  expect(page.view).toBe('statistics');
+  expect(page.review.statistics.value.categories[0]).toMatchObject({ name: 'fish', count: 1 });
+  const item = page.review.items.value[0];
+  page.review.assignType(item, 'shark');
+  expect(page.review.statistics.value.categories[0]).toMatchObject({ name: 'shark', count: 1 });
+  page.review.query.threshold = 1;
+  page.review.query.type = 'absent';
+  page.review.runQuery();
+  expect(page.review.statistics.value.trackCount).toBe(1);
+  page.review.deleteTrack(item);
+  expect(page.review.statistics.value.trackCount).toBe(0);
+  page.review.removeDataset('stats');
+  expect(page.review.statistics.value.timelines).toHaveLength(0);
+  wrapper.destroy();
+});
+
+it('returns to Statistics after visiting a sequence viewer', async () => {
+  const first = mountPage();
+  const page = first.vm as unknown as PageState;
+  await page.review.addDataset('stats');
+  page.setView('statistics');
+  holdReviewSession({
+    review: page.review, view: 'statistics', page: 0, datasetKey: '',
+  });
+  first.destroy();
+  const second = mountPage({ retainSession: false });
+  expect((second.vm as unknown as PageState).view).toBe('statistics');
+  await nextTick();
+  second.destroy();
+});
diff --git a/client/dive-common/components/Review/ReviewPage.vue b/client/dive-common/components/Review/ReviewPage.vue
index fecc106c7..cdc482c31 100644
--- a/client/dive-common/components/Review/ReviewPage.vue
+++ b/client/dive-common/components/Review/ReviewPage.vue
@@ -17,6 +17,7 @@ import {
 import { ReviewEntry, ReviewSortOrder } from 'dive-common/review/types';
 import type { ViewerFocus } from 'dive-common/review/viewerNavigation';
 import UserSettingsDialog from 'dive-common/components/UserSettingsDialog.vue';
+import ReviewStatisticsPanel from './ReviewStatisticsPanel.vue';
 import ReviewDatasetsPanel from './ReviewDatasetsPanel.vue';
 import ReviewGrid from './ReviewGrid.vue';
 import ReviewGridControls from './ReviewGridControls.vue';
@@ -27,7 +28,7 @@ const TYPE_LIST_ID = 'reviewTypeOptions';
 /** Base footer height of a cell at scale 1 (type field plus caption). */
 const CELL_FOOTER_BASE_PX = 48;
 
-type ReviewView = 'results' | 'datasets';
+type ReviewView = 'results' | 'datasets' | 'statistics';
 
 const SORT_OPTIONS: { value: ReviewSortOrder; text: string }[] = [
   { value: 'confidence-desc', text: 'Confidence, high first' },
@@ -51,7 +52,7 @@ const SCOPE_OPTIONS = [
 export default defineComponent({
   name: 'ReviewPage',
   components: {
-    ReviewDatasetsPanel, ReviewGrid, ReviewGridControls, ReviewCell, UserSettingsDialog,
+    ReviewStatisticsPanel, ReviewDatasetsPanel, ReviewGrid, ReviewGridControls, ReviewCell, UserSettingsDialog,
   },
   props: {
     sessionOwner: { type: String, default: '' },
@@ -85,6 +86,7 @@ export default defineComponent({
     // loaded data opens Results.
     const hasReady = review.datasets.value.some((d) => d.status === 'ready');
     const view = ref<ReviewView>(hasReady || initialIds.length > 0 ? 'results' : 'datasets');
+    if (resumed?.view === 'statistics') view.value = 'statistics';
     const resuming = ref(!!resumed);
     // Covers the gap before the initial selection starts loading.
     const opening = ref(!hasReady && initialIds.length > 0);
@@ -181,7 +183,7 @@ export default defineComponent({
     function setView(next: ReviewView) {
       view.value = next;
       // Datasets picked on the Datasets view load only now, when results are wanted.
-      if (next === 'results') review.loadQueued();
+      if (next !== 'datasets') review.loadQueued();
     }
 
     /** Open the viewer on the frame the chip is showing (its first frame otherwise). */
@@ -483,6 +485,12 @@ export default defineComponent({
           Datasets
           <span class="ml-1 grey--text">({{ review.datasets.value.length }})</span>
         </v-btn>
+        <v-btn small value="statistics">
+          <v-icon small left>
+            mdi-chart-timeline-variant
+          </v-icon>
+          Statistics
+        </v-btn>
       </v-btn-toggle>
 
       <template v-if="view === 'results' && readyDatasets > 0">
@@ -736,6 +744,10 @@ export default defineComponent({
         v-if="view === 'datasets'"
         @open-dataset="openDataset"
       />
+      <ReviewStatisticsPanel
+        v-else-if="view === 'statistics'"
+        @open-dataset="openDataset"
+      />
       <template v-else>
         <div
           v-if="readyDatasets === 0"
diff --git a/client/dive-common/components/Review/ReviewStatisticsPanel.vue b/client/dive-common/components/Review/ReviewStatisticsPanel.vue
new file mode 100644
index 000000000..fe307febf
--- /dev/null
+++ b/client/dive-common/components/Review/ReviewStatisticsPanel.vue
@@ -0,0 +1,125 @@
+<script lang="ts">
+import { computed, defineComponent, ref } from 'vue';
+import { useReview } from 'dive-common/use/useReview';
+import type { TimelineRow } from 'dive-common/review/statistics';
+
+export default defineComponent({
+  name: 'ReviewStatisticsPanel',
+  setup() {
+    const review = useReview();
+    const search = ref('');
+    const table = ref('categories');
+    const { statistics } = review;
+    const incomplete = computed(() => review.datasets.value.filter((dataset) => dataset.status !== 'ready').length);
+    // A common vertical scale makes counts comparable across sequences.
+    const peak = computed(() => statistics.value.timelines.reduce((max, row) => Math.max(max, ...row.bins), 1));
+    function points(row: TimelineRow) {
+      return `0,60 ${row.bins.map((count, index) => `${(index / (row.bins.length - 1)) * 1000},${60 - (count / peak.value) * 56}`).join(' ')} 1000,60`;
+    }
+    function endLabel(row: TimelineRow) {
+      const end = row.frameCount - 1;
+      return Number.isFinite(row.fps) && row.fps > 0 ? `${(end / row.fps).toFixed(1)} s` : `frame ${end}`;
+    }
+    const headers = computed(() => (table.value === 'categories'
+      ? [{ text: 'Category', value: 'name' }, { text: 'Tracks', value: 'count' }]
+      : [{ text: 'Attribute', value: 'name' }, { text: 'Value', value: 'value' },
+        { text: 'Scope', value: 'scope' }, { text: 'Occurrences', value: 'count' }]));
+    return {
+      review,
+      statistics,
+      incomplete,
+      peak,
+      points,
+      endLabel,
+      search,
+      table,
+      headers,
+      dateLabel: (row: TimelineRow) => (row.timestamp === undefined
+        ? 'Capture time unavailable' : new Date(row.timestamp * 1000).toLocaleString()),
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="review-statistics">
+    <v-progress-linear v-if="review.loading.value" indeterminate aria-label="Loading statistics" />
+    <v-alert v-if="incomplete" dense text type="info">
+      Statistics include loaded sequences only. {{ incomplete }} selected sequences are loading,
+      queued, or failed. See Datasets for details and retry failed loads there.
+    </v-alert>
+    <p v-if="!review.datasets.value.length">
+      Select sequences on the Datasets page to see their statistics.
+    </p>
+    <template v-else>
+      <h3>{{ statistics.trackCount }} tracks across {{ statistics.timelines.length }} camera sequences</h3>
+      <p class="text-caption">
+        Uses each sequence's saved category thresholds, independently of the Results filters.
+        A track counts once for each qualifying category. Attributes count occurrences on qualifying
+        tracks or detections; false and zero are included. Stereo cameras are counted separately.
+      </p>
+      <div class="d-flex align-center flex-wrap">
+        <v-btn-toggle v-model="table" mandatory dense>
+          <v-btn small value="categories">
+            Categories
+          </v-btn>
+          <v-btn small value="attributes">
+            Attributes
+          </v-btn>
+        </v-btn-toggle>
+        <v-text-field v-model="search" label="Filter counts" clearable dense hide-details class="ml-4" />
+      </div>
+      <v-data-table
+        :headers="headers"
+        :items="table === 'categories' ? statistics.categories : statistics.attributes"
+        :search="search || ''"
+        item-key="key"
+        :items-per-page="10"
+        :footer-props="{ 'items-per-page-options': [10, 25, 50] }"
+        sort-by="count"
+        :sort-desc="true"
+        dense
+        no-data-text="No annotations meet the saved thresholds."
+      />
+      <h3 class="mt-4">
+        Sequence timelines
+      </h3>
+      <p class="text-caption">
+        Newest capture time first; undated sequences follow by name. Each row shows elapsed time
+        (or frames without FPS), with a shared vertical scale of 0–{{ peak }} tracks per bin.
+        Tracks span their first through last frame. Video rows use the annotated extent when the
+        full media length is unavailable. Scroll within the timelines to see more sequences.
+      </p>
+      <v-virtual-scroll :items="statistics.timelines" :item-height="140" height="460" class="timeline-list">
+        <template #default="{ item }">
+          <div class="timeline-row">
+            <div class="d-flex align-center">
+              <v-btn text small class="timeline-name" :title="item.name" @click="$emit('open-dataset', review.parentOf(item.id))">
+                {{ item.name }}
+              </v-btn>
+              <span class="text-caption ml-2">{{ item.count }} tracks · {{ dateLabel(item) }}</span>
+            </div>
+            <svg viewBox="0 0 1000 64" preserveAspectRatio="none" role="img" :aria-label="`${item.name}: ${item.count} qualifying tracks`">
+              <title>{{ item.name }}: {{ item.count }} qualifying tracks; peak scale {{ peak }}</title>
+              <line x1="0" y1="60" x2="1000" y2="60" stroke="currentColor" />
+              <polygon :points="points(item)" fill="#64b5f6" fill-opacity="0.7" />
+            </svg>
+            <div class="d-flex justify-space-between text-caption">
+              <span>0</span>
+              <span v-if="item.annotatedExtent">Annotated extent</span>
+              <span>{{ endLabel(item) }}</span>
+            </div>
+          </div>
+        </template>
+      </v-virtual-scroll>
+    </template>
+  </div>
+</template>
+
+<style scoped>
+.review-statistics { height: 100%; min-height: 0; overflow: auto; padding: 8px; }
+.timeline-list { border: 1px solid #777; }
+.timeline-row { height: 140px; padding: 8px 16px; border-bottom: 1px solid #777; }
+.timeline-row svg { display: block; width: 100%; height: 64px; }
+.timeline-name { max-width: 45%; overflow: hidden; text-overflow: ellipsis; }
+</style>
diff --git a/client/dive-common/review/reviewSession.ts b/client/dive-common/review/reviewSession.ts
index 5444282df..986d82a56 100644
--- a/client/dive-common/review/reviewSession.ts
+++ b/client/dive-common/review/reviewSession.ts
@@ -13,7 +13,7 @@ export interface ReviewSession {
   review: ReviewService;
   /** Platform account that owns this in-memory session. */
   owner?: string;
-  view: 'results' | 'datasets';
+  view: 'results' | 'datasets' | 'statistics';
   page: number;
   /** Key of the datasets the session was started with, see `sessionKey`. */
   datasetKey: string;
diff --git a/client/dive-common/review/statistics.spec.ts b/client/dive-common/review/statistics.spec.ts
new file mode 100644
index 000000000..0c071b7d0
--- /dev/null
+++ b/client/dive-common/review/statistics.spec.ts
@@ -0,0 +1,104 @@
+import type { DatasetConfig } from 'dive-common/apispec';
+import type { TrackData } from 'vue-media-annotator/track';
+import { buildReviewStatistics, TIMELINE_BINS } from './statistics';
+
+const config = (id: string, extra: Partial<DatasetConfig> = {}): DatasetConfig => ({
+  id,
+  name: id,
+  imageData: [],
+  videoUrl: undefined,
+  type: 'video',
+  fps: 10,
+  createdAt: '',
+  subType: null,
+  multiCamMedia: null,
+  ...extra,
+});
+const track = (extra: Partial<TrackData> = {}): TrackData => ({
+  id: 1, begin: 0, end: 9, confidencePairs: [['fish', 0.8]], attributes: {}, features: [], ...extra,
+});
+
+it('counts every qualifying category once per track using each dataset threshold', () => {
+  const result = buildReviewStatistics([
+    { config: config('a', { confidenceFilters: { default: 0.9, fish: 0 } }), tracks: [track({ confidencePairs: [['fish', 0], ['fish', 0.5], ['animal', 1], ['shark', 0.8]] })] },
+    { config: config('b', { confidenceFilters: { default: 0.9 } }), tracks: [track()] },
+  ]);
+  expect(result.trackCount).toBe(1);
+  expect(Object.fromEntries(result.categories.map((row) => [row.name, row.count]))).toEqual({ fish: 1, animal: 1 });
+  expect(result.timelines.find((row) => row.id === 'b')?.count).toBe(0);
+});
+
+it('separates attribute scope and values, includes false/zero, and excludes filtered tracks', () => {
+  const result = buildReviewStatistics([{
+    config: config('a'),
+    tracks: [
+      track({
+        attributes: {
+          checked: false, size: 0, absent: null, userAttributes: {},
+        },
+        features: [
+          { frame: 0, attributes: { checked: true } }, { frame: 2, attributes: { checked: true } },
+        ],
+      }),
+      track({ id: 2, confidencePairs: [['fish', 0.01]], attributes: { hidden: true } }),
+    ],
+  }]);
+  expect(result.attributes.map(({
+    name, value, scope, count,
+  }) => ({
+    name, value, scope, count,
+  }))).toEqual([
+    {
+      name: 'checked', value: 'true', scope: 'Detection', count: 2,
+    },
+    {
+      name: 'checked', value: 'false', scope: 'Track', count: 1,
+    },
+    {
+      name: 'size', value: '0', scope: 'Track', count: 1,
+    },
+  ]);
+});
+
+it('sorts by capture time newest first, ignores import date, and places undated rows last', () => {
+  const result = buildReviewStatistics([
+    { config: config('undated', { createdAt: '2099-01-01' }), tracks: [] },
+    { config: config('older', { imageData: [{ filename: 'image.jpg', url: '', timestamp: 1700000000 }] }), tracks: [] },
+    { config: config('newer_20250101_120000.mp4'), tracks: [] },
+  ]);
+  expect(result.timelines.map((row) => row.id)).toEqual(['newer_20250101_120000.mp4', 'older', 'undated']);
+});
+
+it('bins inclusive track spans, preserves empty media and below-threshold frame extent', () => {
+  const result = buildReviewStatistics([{
+    config: config('a'),
+    tracks: [
+      track({ begin: 0, end: 199 }), track({ id: 2, begin: 100, end: 199 }),
+      track({ id: 3, end: 399, confidencePairs: [['fish', 0.01]] }),
+    ],
+  }, { config: config('empty', { imageData: Array.from({ length: 10 }, () => ({ filename: '', url: '' })) }), tracks: [] }]);
+  const [row, empty] = result.timelines;
+  expect(row.frameCount).toBe(400);
+  expect(row.bins.slice(0, 50)).toEqual(Array(50).fill(1));
+  expect(row.bins.slice(50, 100)).toEqual(Array(50).fill(2));
+  expect(row.bins.slice(100)).toEqual(Array(100).fill(0));
+  expect(empty.frameCount).toBe(10);
+  expect(empty.bins.every((count) => count === 0)).toBe(true);
+  expect(empty.annotatedExtent).toBe(false);
+});
+
+it('keeps unclassified annotations and counts camera annotations independently', () => {
+  const result = buildReviewStatistics(['rig/left', 'rig/right'].map((id) => ({
+    config: config(id), tracks: [track({ confidencePairs: [] })],
+  })));
+  expect(result.categories[0]).toMatchObject({ name: '(unclassified)', count: 2 });
+  expect(result.timelines).toHaveLength(2);
+});
+
+it('bounds timeline size for large selections', () => {
+  const result = buildReviewStatistics(Array.from({ length: 1000 }, (_, i) => ({
+    config: config(String(i)), tracks: [track({ end: 1e9 })],
+  })));
+  expect(result.trackCount).toBe(1000);
+  expect(result.timelines.every((row) => row.bins.length === TIMELINE_BINS)).toBe(true);
+});
diff --git a/client/dive-common/review/statistics.ts b/client/dive-common/review/statistics.ts
new file mode 100644
index 000000000..7b5daad57
--- /dev/null
+++ b/client/dive-common/review/statistics.ts
@@ -0,0 +1,121 @@
+import type { DatasetConfig } from 'dive-common/apispec';
+import { parseFrameTimestamp } from 'dive-common/frameTimestamp';
+import { resolveConfidenceThreshold } from 'dive-common/typeHierarchy';
+import { DefaultConfidence } from 'vue-media-annotator/BaseFilterControls';
+import type { TrackData } from 'vue-media-annotator/track';
+
+export interface StatisticsDataset {
+  config: DatasetConfig;
+  tracks: Iterable<TrackData>;
+}
+export interface CountRow {
+  key: string;
+  name: string;
+  value: string;
+  scope: string;
+  count: number;
+}
+export interface TimelineRow {
+  id: string;
+  name: string;
+  timestamp?: number;
+  fps: number;
+  frameCount: number;
+  annotatedExtent: boolean;
+  count: number;
+  bins: number[];
+}
+export interface ReviewStatistics {
+  categories: CountRow[];
+  attributes: CountRow[];
+  timelines: TimelineRow[];
+  trackCount: number;
+}
+
+/** Fixed-size timelines avoid rendering one SVG element per annotation. */
+export const TIMELINE_BINS = 200;
+
+export function buildReviewStatistics(datasets: Iterable<StatisticsDataset>): ReviewStatistics {
+  const categories = new Map<string, CountRow>();
+  const attributes = new Map<string, CountRow>();
+  const timelines: TimelineRow[] = [];
+  let trackCount = 0;
+  function increment(map: Map<string, CountRow>, name: string, value = '', scope = '') {
+    const key = JSON.stringify([name, value, scope]);
+    const row = map.get(key) ?? {
+      key, name, value, scope, count: 0,
+    };
+    row.count += 1;
+    map.set(key, row);
+  }
+  function countAttributes(values: Record<string, unknown> | undefined, scope: string) {
+    Object.entries(values ?? {}).forEach(([name, value]) => {
+      // userAttributes contains schema metadata, not annotation values.
+      if (name !== 'userAttributes' && value !== null && value !== undefined) {
+        increment(attributes, name, typeof value === 'object' ? JSON.stringify(value) : String(value), scope);
+      }
+    });
+  }
+  Array.from(datasets).forEach(({ config, tracks }) => {
+    const filters = config.confidenceFilters ?? { default: DefaultConfidence };
+    const intervals: [number, number][] = [];
+    let lastFrame = Math.max(0, config.imageData.length - 1);
+    let count = 0;
+    Array.from(tracks).forEach((track) => {
+      const begin = Math.max(0, Number.isFinite(track.begin) ? track.begin : 0);
+      const end = Math.max(begin, Number.isFinite(track.end) ? track.end : begin);
+      lastFrame = Math.max(lastFrame, end);
+      const types = new Set(track.confidencePairs
+        .filter(([name, confidence]) => Number.isFinite(confidence)
+          && confidence >= resolveConfidenceThreshold(filters, name))
+        .map(([name]) => name));
+      if (!types.size && track.confidencePairs.length) return;
+      types.forEach((name) => increment(categories, name));
+      if (!types.size) increment(categories, '(unclassified)');
+      countAttributes(track.attributes, 'Track');
+      track.features.forEach((feature) => countAttributes(feature.attributes, 'Detection'));
+      intervals.push([begin, end]);
+      count += 1;
+    });
+    const frameCount = lastFrame + 1;
+    const delta = new Array<number>(TIMELINE_BINS + 1).fill(0);
+    intervals.forEach(([begin, end]) => {
+      const first = Math.min(TIMELINE_BINS - 1, Math.floor((begin / frameCount) * TIMELINE_BINS));
+      const last = Math.min(TIMELINE_BINS - 1, Math.floor((end / frameCount) * TIMELINE_BINS));
+      delta[first] += 1;
+      delta[last + 1] -= 1;
+    });
+    let active = 0;
+    const bins = delta.slice(0, TIMELINE_BINS).map((change) => { active += change; return active; });
+    let timestamp: number | undefined;
+    config.imageData.forEach((image) => {
+      const time = image.timestamp ?? parseFrameTimestamp(image.filename);
+      if (time !== undefined && Number.isFinite(time)) timestamp = Math.min(timestamp ?? time, time);
+    });
+    timestamp ??= parseFrameTimestamp(config.name);
+    timelines.push({
+      id: config.id,
+      name: config.name,
+      timestamp,
+      fps: config.fps,
+      frameCount,
+      annotatedExtent: !config.imageData.length,
+      count,
+      bins,
+    });
+    trackCount += count;
+  });
+  const sorted = (rows: Map<string, CountRow>) => [...rows.values()]
+    .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+  timelines.sort((a, b) => {
+    if (a.timestamp !== undefined && b.timestamp !== undefined) {
+      return b.timestamp - a.timestamp || a.name.localeCompare(b.name) || a.id.localeCompare(b.id);
+    }
+    if (a.timestamp !== undefined) return -1;
+    if (b.timestamp !== undefined) return 1;
+    return a.name.localeCompare(b.name) || a.id.localeCompare(b.id);
+  });
+  return {
+    categories: sorted(categories), attributes: sorted(attributes), timelines, trackCount,
+  };
+}
diff --git a/client/dive-common/use/useReview.ts b/client/dive-common/use/useReview.ts
index 15d268fe4..5e4d59aec 100644
--- a/client/dive-common/use/useReview.ts
+++ b/client/dive-common/use/useReview.ts
@@ -1,3 +1,4 @@
+import { buildReviewStatistics, ReviewStatistics } from 'dive-common/review/statistics';
 import { orderedHeadTail } from 'vue-media-annotator/headTail';
 /**
  * State behind the Review page: the datasets under review (with their
@@ -68,6 +69,7 @@ export interface ReviewDataset {
 }
 
 export interface ReviewService {
+  statistics: Readonly<Ref<ReviewStatistics>>;
   datasets: Readonly<Ref<ReviewDataset[]>>;
   available: Readonly<Ref<ScoringDatasetSummary[]>>;
   query: ReviewQuery;
@@ -493,6 +495,13 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     return dataRevision.value;
   }
 
+  const statistics = computed(() => {
+    dependOnData();
+    return buildReviewStatistics([...loaded.entries()]
+      .filter(([id]) => entry(id)?.status === 'ready')
+      .map(([, dataset]) => ({ config: dataset.config, tracks: dataset.tracks.values() })));
+  });
+
   /** Types the query can ask for: present on the selected datasets at the current threshold. */
   const types = computed(() => {
     dependOnData();
@@ -858,6 +867,7 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     sort,
     items,
     entries,
+    statistics,
     dataRevision,
     stale,
     queryGeneration,
diff --git a/docs/Review.md b/docs/Review.md
index 375dd3661..3a30ad2d0 100644
--- a/docs/Review.md
+++ b/docs/Review.md
@@ -114,3 +114,31 @@ On DIVE Desktop, the Query page shows ranked similarity results across indexed d
 Every result is also an annotation in waiting. Typing a type under a chip, or editing its box (the edit action or a right click), gives the result a track of its own in its dataset, built from the result's frames and boxes; the dataset's existing annotations are never edited in place. Such entries show their track id and can be deleted.
 
 **Save** on the results toolbar writes the results that count as annotations: every accepted result (with its type, or `unknown` when none was given), every result given a type, rejected results only when they were given a type, and unmarked results that were typed or box-edited. When any of them overlaps an annotation the dataset already has on the same frame, a dialog asks how to proceed: **Keep originals** saves the other results and leaves the overlapping ones out, **Replace overlapping** deletes just the overlapped annotations before saving, **Replace all annotations** deletes every annotation in those sequences and saves only the results, and **Discard results** saves nothing. **Discard** drops the unsaved results, and leaving the page with unsaved changes asks first. Opening a saved entry selects its track in the viewer. Grid shape, zoom and context settings are shared with Review.
+
+## Statistics
+
+Choose **Review → Statistics** to summarize every selected sequence. Queued
+sequences load when this tab opens; partial results are labelled while loading
+or if a sequence fails. Retry failed loads on Datasets.
+
+**Categories** counts each track once per category whose confidence meets that
+sequence's saved type-specific threshold (or its default threshold). Without
+saved filters, the viewer default of 0.1 applies. Unclassified tracks have their
+own row. A track with multiple qualifying labels can appear in multiple category
+counts. **Attributes** separates track and detection occurrences by name and
+value, including false and zero. Only attributes on qualifying tracks are counted.
+Stereo cameras contribute independently. Search, sorting, and pagination keep
+large category and attribute lists manageable.
+
+Statistics use the current loaded annotations, including unsaved edits, and do
+not inherit the Results tab's type, attribute, or confidence query. Changing the
+selected sequences, editing, deleting, or reloading annotations updates totals.
+
+Timeline rows show qualifying track spans in 200 bins on a common count scale.
+Each row uses its own elapsed seconds axis (frames when FPS is unknown). Image
+sequences include their full frame range; video rows use the annotated extent
+because review metadata does not provide the full video duration. No media is
+decoded to construct these plots. Capture timestamps on images or parsed from
+sequence names order rows newest first; undated sequences follow alphabetically.
+Import dates are not treated as capture dates. Scroll inside the timeline list
+to browse more rows, or click a sequence name to open its viewer.

From cc6d1b0e45aa22bc8bc8774ff3be5ff634d78577 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 25 Sep 2026 12:23:21 -0400
Subject: [PATCH 2/3] Combine camera statistics timelines with per-type step
 plots

---
 .../components/Review/ReviewPage.vue          |  24 +--
 .../Review/ReviewStatisticsPanel.vue          |  49 ++++--
 client/dive-common/review/statistics.spec.ts  |  56 ++++++-
 client/dive-common/review/statistics.ts       | 149 ++++++++++++------
 client/dive-common/use/useReview.spec.ts      |   2 +
 client/dive-common/use/useReview.ts           |   7 +-
 docs/Review.md                                |   7 +-
 7 files changed, 215 insertions(+), 79 deletions(-)

diff --git a/client/dive-common/components/Review/ReviewPage.vue b/client/dive-common/components/Review/ReviewPage.vue
index cdc482c31..df9dcbff3 100644
--- a/client/dive-common/components/Review/ReviewPage.vue
+++ b/client/dive-common/components/Review/ReviewPage.vue
@@ -460,18 +460,6 @@ export default defineComponent({
         class="mr-3"
         @change="setView"
       >
-        <v-btn
-          small
-          value="results"
-        >
-          <v-icon
-            small
-            left
-          >
-            mdi-view-grid
-          </v-icon>
-          Results
-        </v-btn>
         <v-btn
           small
           value="datasets"
@@ -491,6 +479,18 @@ export default defineComponent({
           </v-icon>
           Statistics
         </v-btn>
+        <v-btn
+          small
+          value="results"
+        >
+          <v-icon
+            small
+            left
+          >
+            mdi-view-grid
+          </v-icon>
+          Results
+        </v-btn>
       </v-btn-toggle>
 
       <template v-if="view === 'results' && readyDatasets > 0">
diff --git a/client/dive-common/components/Review/ReviewStatisticsPanel.vue b/client/dive-common/components/Review/ReviewStatisticsPanel.vue
index fe307febf..f54797aa5 100644
--- a/client/dive-common/components/Review/ReviewStatisticsPanel.vue
+++ b/client/dive-common/components/Review/ReviewStatisticsPanel.vue
@@ -1,7 +1,7 @@
 <script lang="ts">
 import { computed, defineComponent, ref } from 'vue';
 import { useReview } from 'dive-common/use/useReview';
-import type { TimelineRow } from 'dive-common/review/statistics';
+import { timelineStepPath, TimelineRow } from 'dive-common/review/statistics';
 
 export default defineComponent({
   name: 'ReviewStatisticsPanel',
@@ -13,12 +13,8 @@ export default defineComponent({
     const incomplete = computed(() => review.datasets.value.filter((dataset) => dataset.status !== 'ready').length);
     // A common vertical scale makes counts comparable across sequences.
     const peak = computed(() => statistics.value.timelines.reduce((max, row) => Math.max(max, ...row.bins), 1));
-    function points(row: TimelineRow) {
-      return `0,60 ${row.bins.map((count, index) => `${(index / (row.bins.length - 1)) * 1000},${60 - (count / peak.value) * 56}`).join(' ')} 1000,60`;
-    }
     function endLabel(row: TimelineRow) {
-      const end = row.frameCount - 1;
-      return Number.isFinite(row.fps) && row.fps > 0 ? `${(end / row.fps).toFixed(1)} s` : `frame ${end}`;
+      return `${row.duration.toFixed(row.unit === 's' ? 1 : 0)} ${row.unit}`;
     }
     const headers = computed(() => (table.value === 'categories'
       ? [{ text: 'Category', value: 'name' }, { text: 'Tracks', value: 'count' }]
@@ -29,7 +25,7 @@ export default defineComponent({
       statistics,
       incomplete,
       peak,
-      points,
+      timelineStepPath,
       endLabel,
       search,
       table,
@@ -52,7 +48,7 @@ export default defineComponent({
       Select sequences on the Datasets page to see their statistics.
     </p>
     <template v-else>
-      <h3>{{ statistics.trackCount }} tracks across {{ statistics.timelines.length }} camera sequences</h3>
+      <h3>{{ statistics.trackCount }} camera tracks across {{ statistics.timelines.length }} sequences</h3>
       <p class="text-caption">
         Uses each sequence's saved category thresholds, independently of the Results filters.
         A track counts once for each qualifying category. Attributes count occurrences on qualifying
@@ -86,23 +82,41 @@ export default defineComponent({
       </h3>
       <p class="text-caption">
         Newest capture time first; undated sequences follow by name. Each row shows elapsed time
-        (or frames without FPS), with a shared vertical scale of 0–{{ peak }} tracks per bin.
+        (or frames if any camera lacks FPS), with a shared vertical scale of 0–{{ peak }} tracks.
+        Colored steps show each type. All cameras share one sequence plot; matching track IDs
+        are counted once on each timeline.
         Tracks span their first through last frame. Video rows use the annotated extent when the
         full media length is unavailable. Scroll within the timelines to see more sequences.
       </p>
-      <v-virtual-scroll :items="statistics.timelines" :item-height="140" height="460" class="timeline-list">
+      <v-virtual-scroll :items="statistics.timelines" :item-height="180" height="460" class="timeline-list">
         <template #default="{ item }">
           <div class="timeline-row">
             <div class="d-flex align-center">
               <v-btn text small class="timeline-name" :title="item.name" @click="$emit('open-dataset', review.parentOf(item.id))">
                 {{ item.name }}
               </v-btn>
-              <span class="text-caption ml-2">{{ item.count }} tracks · {{ dateLabel(item) }}</span>
+              <span class="text-caption ml-2">{{ item.count }} tracks · {{ item.cameraCount }} cameras · {{ dateLabel(item) }}</span>
+            </div>
+            <div class="timeline-legend text-caption">
+              <span v-for="series in item.series" :key="series.name" :style="{ color: review.colorFor(series.name) }">
+                {{ series.name }}
+              </span>
             </div>
-            <svg viewBox="0 0 1000 64" preserveAspectRatio="none" role="img" :aria-label="`${item.name}: ${item.count} qualifying tracks`">
-              <title>{{ item.name }}: {{ item.count }} qualifying tracks; peak scale {{ peak }}</title>
-              <line x1="0" y1="60" x2="1000" y2="60" stroke="currentColor" />
-              <polygon :points="points(item)" fill="#64b5f6" fill-opacity="0.7" />
+            <svg viewBox="0 0 1000 84" preserveAspectRatio="none" role="img" :aria-label="`${item.name}: timelines by type across all cameras`">
+              <title>{{ item.name }}: {{ item.count }} tracks across {{ item.cameraCount }} cameras; peak scale {{ peak }}</title>
+              <line x1="0" y1="80" x2="1000" y2="80" stroke="currentColor" />
+              <path
+                v-for="series in item.series"
+                :key="series.name"
+                :d="timelineStepPath(series.bins, peak)"
+                :fill="review.colorFor(series.name)"
+                :stroke="review.colorFor(series.name)"
+                fill-opacity="0.12"
+                stroke-width="1.5"
+                vector-effect="non-scaling-stroke"
+              >
+                <title>{{ series.name }}: peak {{ Math.max(...series.bins) }} tracks</title>
+              </path>
             </svg>
             <div class="d-flex justify-space-between text-caption">
               <span>0</span>
@@ -119,7 +133,8 @@ export default defineComponent({
 <style scoped>
 .review-statistics { height: 100%; min-height: 0; overflow: auto; padding: 8px; }
 .timeline-list { border: 1px solid #777; }
-.timeline-row { height: 140px; padding: 8px 16px; border-bottom: 1px solid #777; }
-.timeline-row svg { display: block; width: 100%; height: 64px; }
+.timeline-row { height: 180px; padding: 8px 16px; border-bottom: 1px solid #777; }
+.timeline-row svg { display: block; width: 100%; height: 84px; }
+.timeline-legend { display: flex; gap: 12px; height: 24px; overflow-x: auto; white-space: nowrap; }
 .timeline-name { max-width: 45%; overflow: hidden; text-overflow: ellipsis; }
 </style>
diff --git a/client/dive-common/review/statistics.spec.ts b/client/dive-common/review/statistics.spec.ts
index 0c071b7d0..283c968f9 100644
--- a/client/dive-common/review/statistics.spec.ts
+++ b/client/dive-common/review/statistics.spec.ts
@@ -1,6 +1,6 @@
 import type { DatasetConfig } from 'dive-common/apispec';
 import type { TrackData } from 'vue-media-annotator/track';
-import { buildReviewStatistics, TIMELINE_BINS } from './statistics';
+import { buildReviewStatistics, timelineStepPath, TIMELINE_BINS } from './statistics';
 
 const config = (id: string, extra: Partial<DatasetConfig> = {}): DatasetConfig => ({
   id,
@@ -78,11 +78,12 @@ it('bins inclusive track spans, preserves empty media and below-threshold frame
     ],
   }, { config: config('empty', { imageData: Array.from({ length: 10 }, () => ({ filename: '', url: '' })) }), tracks: [] }]);
   const [row, empty] = result.timelines;
-  expect(row.frameCount).toBe(400);
+  expect(row.duration).toBe(40);
+  expect(row.unit).toBe('s');
   expect(row.bins.slice(0, 50)).toEqual(Array(50).fill(1));
   expect(row.bins.slice(50, 100)).toEqual(Array(50).fill(2));
   expect(row.bins.slice(100)).toEqual(Array(100).fill(0));
-  expect(empty.frameCount).toBe(10);
+  expect(empty.duration).toBe(1);
   expect(empty.bins.every((count) => count === 0)).toBe(true);
   expect(empty.annotatedExtent).toBe(false);
 });
@@ -102,3 +103,52 @@ it('bounds timeline size for large selections', () => {
   expect(result.trackCount).toBe(1000);
   expect(result.timelines.every((row) => row.bins.length === TIMELINE_BINS)).toBe(true);
 });
+
+it('combines camera timelines by parent, unions matching IDs, and keeps per-type steps', () => {
+  const result = buildReviewStatistics([
+    {
+      config: config('rig/left', { fps: 10 }),
+      sequenceId: 'rig',
+      sequenceName: 'Stereo',
+      tracks: [
+        track({ begin: 0, end: 9 }),
+      ],
+    },
+    {
+      config: config('rig/right', { fps: 20 }),
+      sequenceId: 'rig',
+      sequenceName: 'Stereo',
+      tracks: [
+        track({ begin: 10, end: 39 }),
+        track({
+          id: 2, begin: 20, end: 39, confidencePairs: [['shark', 1]],
+        }),
+      ],
+    },
+  ]);
+  expect(result.timelines).toHaveLength(1);
+  const [row] = result.timelines;
+  expect(row).toMatchObject({
+    id: 'rig', name: 'Stereo', cameraCount: 2, count: 2, duration: 2, unit: 's',
+  });
+  expect(row.series.map((series) => series.name)).toEqual(['fish', 'shark']);
+  expect(row.series[0].bins).toEqual(Array(TIMELINE_BINS).fill(1));
+  expect(row.series[1].bins.slice(0, 100)).toEqual(Array(100).fill(0));
+  expect(row.bins.slice(100)).toEqual(Array(100).fill(2));
+});
+
+it('keeps gaps between cameras and falls back to frames if any camera lacks FPS', () => {
+  const result = buildReviewStatistics([
+    { config: config('rig/a', { fps: 0 }), sequenceId: 'rig', tracks: [track({ end: 9 })] },
+    { config: config('rig/b'), sequenceId: 'rig', tracks: [track({ begin: 30, end: 39 })] },
+  ]);
+  expect(result.timelines[0].unit).toBe('frames');
+  expect(result.timelines[0].count).toBe(1);
+  expect(result.timelines[0].bins.slice(50, 150)).toEqual(Array(100).fill(0));
+});
+
+it('draws horizontal step plateaus instead of diagonal spikes', () => {
+  expect(timelineStepPath([0, 2, 2, 0], 2, 100, 24)).toBe(
+    'M0,24 H25 V4 H75 V24 H100 V24 Z',
+  );
+});
diff --git a/client/dive-common/review/statistics.ts b/client/dive-common/review/statistics.ts
index 7b5daad57..f8d6434ef 100644
--- a/client/dive-common/review/statistics.ts
+++ b/client/dive-common/review/statistics.ts
@@ -7,6 +7,8 @@ import type { TrackData } from 'vue-media-annotator/track';
 export interface StatisticsDataset {
   config: DatasetConfig;
   tracks: Iterable<TrackData>;
+  sequenceId?: string;
+  sequenceName?: string;
 }
 export interface CountRow {
   key: string;
@@ -19,8 +21,10 @@ export interface TimelineRow {
   id: string;
   name: string;
   timestamp?: number;
-  fps: number;
-  frameCount: number;
+  duration: number;
+  unit: 's' | 'frames';
+  cameraCount: number;
+  series: { name: string; bins: number[] }[];
   annotatedExtent: boolean;
   count: number;
   bins: number[];
@@ -56,54 +60,96 @@ export function buildReviewStatistics(datasets: Iterable<StatisticsDataset>): Re
       }
     });
   }
-  Array.from(datasets).forEach(({ config, tracks }) => {
-    const filters = config.confidenceFilters ?? { default: DefaultConfidence };
-    const intervals: [number, number][] = [];
-    let lastFrame = Math.max(0, config.imageData.length - 1);
-    let count = 0;
-    Array.from(tracks).forEach((track) => {
-      const begin = Math.max(0, Number.isFinite(track.begin) ? track.begin : 0);
-      const end = Math.max(begin, Number.isFinite(track.end) ? track.end : begin);
-      lastFrame = Math.max(lastFrame, end);
-      const types = new Set(track.confidencePairs
-        .filter(([name, confidence]) => Number.isFinite(confidence)
+  const groups = new Map<string, StatisticsDataset[]>();
+  Array.from(datasets).forEach((dataset) => {
+    const id = dataset.sequenceId ?? dataset.config.id;
+    groups.set(id, [...(groups.get(id) ?? []), dataset]);
+  });
+  groups.forEach((cameras, id) => {
+    const seconds = cameras.every(({ config }) => Number.isFinite(config.fps) && config.fps > 0);
+    const intervals = new Map<string, Map<string, [number, number][]>>();
+    let duration = 0;
+    let timestamp: number | undefined;
+    cameras.forEach(({ config, tracks }) => {
+      const filters = config.confidenceFilters ?? { default: DefaultConfidence };
+      let lastFrame = Math.max(0, config.imageData.length - 1);
+      let count = 0;
+      Array.from(tracks).forEach((track) => {
+        const begin = Math.max(0, Number.isFinite(track.begin) ? track.begin : 0);
+        const end = Math.max(begin, Number.isFinite(track.end) ? track.end : begin);
+        lastFrame = Math.max(lastFrame, end);
+        const types = new Set(track.confidencePairs
+          .filter(([name, confidence]) => Number.isFinite(confidence)
           && confidence >= resolveConfidenceThreshold(filters, name))
-        .map(([name]) => name));
-      if (!types.size && track.confidencePairs.length) return;
-      types.forEach((name) => increment(categories, name));
-      if (!types.size) increment(categories, '(unclassified)');
-      countAttributes(track.attributes, 'Track');
-      track.features.forEach((feature) => countAttributes(feature.attributes, 'Detection'));
-      intervals.push([begin, end]);
-      count += 1;
-    });
-    const frameCount = lastFrame + 1;
-    const delta = new Array<number>(TIMELINE_BINS + 1).fill(0);
-    intervals.forEach(([begin, end]) => {
-      const first = Math.min(TIMELINE_BINS - 1, Math.floor((begin / frameCount) * TIMELINE_BINS));
-      const last = Math.min(TIMELINE_BINS - 1, Math.floor((end / frameCount) * TIMELINE_BINS));
-      delta[first] += 1;
-      delta[last + 1] -= 1;
+          .map(([name]) => name));
+        if (!types.size && track.confidencePairs.length) return;
+        types.forEach((name) => increment(categories, name));
+        if (!types.size) increment(categories, '(unclassified)');
+        countAttributes(track.attributes, 'Track');
+        track.features.forEach((feature) => countAttributes(feature.attributes, 'Detection'));
+        const key = JSON.stringify(track.id);
+        const byType = intervals.get(key) ?? new Map<string, [number, number][]>();
+        const divisor = seconds ? config.fps : 1;
+        const range: [number, number] = [begin / divisor, (end + 1) / divisor];
+        const qualifyingTypes = types.size ? [...types] : ['(unclassified)'];
+        qualifyingTypes.forEach((type) => byType.set(type, [...(byType.get(type) ?? []), range]));
+        intervals.set(key, byType);
+        count += 1;
+      });
+      duration = Math.max(duration, (lastFrame + 1) / (seconds ? config.fps : 1));
+      config.imageData.forEach((image) => {
+        const time = image.timestamp ?? parseFrameTimestamp(image.filename);
+        if (time !== undefined && Number.isFinite(time)) timestamp = Math.min(timestamp ?? time, time);
+      });
+      timestamp ??= parseFrameTimestamp(config.name);
+      trackCount += count;
     });
-    let active = 0;
-    const bins = delta.slice(0, TIMELINE_BINS).map((change) => { active += change; return active; });
-    let timestamp: number | undefined;
-    config.imageData.forEach((image) => {
-      const time = image.timestamp ?? parseFrameTimestamp(image.filename);
-      if (time !== undefined && Number.isFinite(time)) timestamp = Math.min(timestamp ?? time, time);
+    const totalDelta = new Array<number>(TIMELINE_BINS + 1).fill(0);
+    const typeDeltas = new Map<string, number[]>();
+    // Union ranges of the same track across cameras before accumulating them,
+    // so a stereo track is represented once even where camera views overlap.
+    function addRanges(target: number[], ranges: [number, number][]) {
+      const delta = target;
+      const bins = ranges.map(([begin, end]) => [
+        Math.min(TIMELINE_BINS - 1, Math.floor((begin / duration) * TIMELINE_BINS)),
+        Math.min(TIMELINE_BINS, Math.max(1, Math.ceil((end / duration) * TIMELINE_BINS))),
+      ]).sort((a, b) => a[0] - b[0]);
+      let first = -1;
+      let last = -1;
+      bins.forEach(([begin, end]) => {
+        if (begin > last) {
+          if (first >= 0) { delta[first] += 1; delta[last] -= 1; }
+          first = begin;
+          last = end;
+        } else last = Math.max(last, end);
+      });
+      if (first >= 0) { delta[first] += 1; delta[last] -= 1; }
+    }
+    intervals.forEach((byType) => {
+      addRanges(totalDelta, [...byType.values()].flat());
+      byType.forEach((ranges, type) => {
+        const delta = typeDeltas.get(type) ?? new Array<number>(TIMELINE_BINS + 1).fill(0);
+        addRanges(delta, ranges);
+        typeDeltas.set(type, delta);
+      });
     });
-    timestamp ??= parseFrameTimestamp(config.name);
+    function accumulate(delta: number[]) {
+      let active = 0;
+      return delta.slice(0, TIMELINE_BINS).map((change) => { active += change; return active; });
+    }
     timelines.push({
-      id: config.id,
-      name: config.name,
+      id,
+      name: cameras[0].sequenceName ?? cameras[0].config.name,
       timestamp,
-      fps: config.fps,
-      frameCount,
-      annotatedExtent: !config.imageData.length,
-      count,
-      bins,
+      duration,
+      unit: seconds ? 's' : 'frames',
+      cameraCount: cameras.length,
+      annotatedExtent: cameras.some(({ config }) => !config.imageData.length),
+      count: intervals.size,
+      bins: accumulate(totalDelta),
+      series: [...typeDeltas].sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, delta]) => ({ name, bins: accumulate(delta) })),
     });
-    trackCount += count;
   });
   const sorted = (rows: Map<string, CountRow>) => [...rows.values()]
     .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
@@ -119,3 +165,18 @@ export function buildReviewStatistics(datasets: Iterable<StatisticsDataset>): Re
     categories: sorted(categories), attributes: sorted(attributes), timelines, trackCount,
   };
 }
+
+/** Step-after area: horizontal plateaus with vertical transitions, never diagonal spikes. */
+export function timelineStepPath(bins: number[], peak: number, width = 1000, height = 80): string {
+  if (!bins.length) return '';
+  const scale = Math.max(1, peak);
+  let path = `M0,${height}`;
+  let previous = 0;
+  bins.forEach((count, index) => {
+    if (count !== previous) {
+      path += ` H${(index / bins.length) * width} V${height - (count / scale) * (height - 4)}`;
+      previous = count;
+    }
+  });
+  return `${path} H${width} V${height} Z`;
+}
diff --git a/client/dive-common/use/useReview.spec.ts b/client/dive-common/use/useReview.spec.ts
index dc2f973e1..fd39822f3 100644
--- a/client/dive-common/use/useReview.spec.ts
+++ b/client/dive-common/use/useReview.spec.ts
@@ -230,6 +230,8 @@ describe('createReviewService', () => {
     expect(service.entries.value).toHaveLength(1);
     const [entry] = service.entries.value;
     expect(entry.labels).toEqual(['left', 'right']);
+    expect(service.statistics.value.timelines).toHaveLength(1);
+    expect(service.statistics.value.timelines[0]).toMatchObject({ id: 'm', cameraCount: 2, count: 1 });
     expect(service.parentOf('m/right')).toBe('m');
     const right = entry.items[1];
     expect(right.frames.map((f) => f.missing ?? false)).toEqual([true, false]);
diff --git a/client/dive-common/use/useReview.ts b/client/dive-common/use/useReview.ts
index 5e4d59aec..26d85976e 100644
--- a/client/dive-common/use/useReview.ts
+++ b/client/dive-common/use/useReview.ts
@@ -499,7 +499,12 @@ function createScopedReviewService(deps: ReviewServiceDeps): ReviewService {
     dependOnData();
     return buildReviewStatistics([...loaded.entries()]
       .filter(([id]) => entry(id)?.status === 'ready')
-      .map(([, dataset]) => ({ config: dataset.config, tracks: dataset.tracks.values() })));
+      .map(([id, dataset]) => ({
+        config: dataset.config,
+        tracks: dataset.tracks.values(),
+        sequenceId: parentOf(id),
+        sequenceName: datasetName(parentOf(id)),
+      })));
   });
 
   /** Types the query can ask for: present on the selected datasets at the current threshold. */
diff --git a/docs/Review.md b/docs/Review.md
index 3a30ad2d0..674e5efe7 100644
--- a/docs/Review.md
+++ b/docs/Review.md
@@ -134,8 +134,11 @@ Statistics use the current loaded annotations, including unsaved edits, and do
 not inherit the Results tab's type, attribute, or confidence query. Changing the
 selected sequences, editing, deleting, or reloading annotations updates totals.
 
-Timeline rows show qualifying track spans in 200 bins on a common count scale.
-Each row uses its own elapsed seconds axis (frames when FPS is unknown). Image
+Timeline rows show qualifying track spans as colored, per-type steps in 200 bins
+on a common count scale. All cameras of a sequence share one plot; overlapping
+spans for the same track ID are counted once in each type series.
+Each row uses elapsed seconds, converting each camera by its own FPS (frames
+when any camera lacks FPS). Image
 sequences include their full frame range; video rows use the annotated extent
 because review metadata does not provide the full video duration. No media is
 decoded to construct these plots. Capture timestamps on images or parsed from

From 8bf19f6a777103d0ed9eec215ea254dd38a215ec Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 25 Sep 2026 12:31:16 -0400
Subject: [PATCH 3/3] Use parent capture names and preserve statistics table
 contrast

---
 .../components/Review/ReviewStatisticsPanel.vue     |  4 +++-
 client/dive-common/review/statistics.spec.ts        | 13 +++++++++++++
 client/dive-common/review/statistics.ts             |  1 +
 3 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/client/dive-common/components/Review/ReviewStatisticsPanel.vue b/client/dive-common/components/Review/ReviewStatisticsPanel.vue
index f54797aa5..823278fd4 100644
--- a/client/dive-common/components/Review/ReviewStatisticsPanel.vue
+++ b/client/dive-common/components/Review/ReviewStatisticsPanel.vue
@@ -66,6 +66,7 @@ export default defineComponent({
         <v-text-field v-model="search" label="Filter counts" clearable dense hide-details class="ml-4" />
       </div>
       <v-data-table
+        class="statistics-counts"
         :headers="headers"
         :items="table === 'categories' ? statistics.categories : statistics.attributes"
         :search="search || ''"
@@ -95,7 +96,7 @@ export default defineComponent({
               <v-btn text small class="timeline-name" :title="item.name" @click="$emit('open-dataset', review.parentOf(item.id))">
                 {{ item.name }}
               </v-btn>
-              <span class="text-caption ml-2">{{ item.count }} tracks · {{ item.cameraCount }} cameras · {{ dateLabel(item) }}</span>
+              <span class="text-caption ml-2">{{ item.count }} tracks · {{ item.cameraCount }} camera{{ item.cameraCount === 1 ? '' : 's' }} · {{ dateLabel(item) }}</span>
             </div>
             <div class="timeline-legend text-caption">
               <span v-for="series in item.series" :key="series.name" :style="{ color: review.colorFor(series.name) }">
@@ -132,6 +133,7 @@ export default defineComponent({
 
 <style scoped>
 .review-statistics { height: 100%; min-height: 0; overflow: auto; padding: 8px; }
+.statistics-counts ::v-deep table { color: inherit; }
 .timeline-list { border: 1px solid #777; }
 .timeline-row { height: 180px; padding: 8px 16px; border-bottom: 1px solid #777; }
 .timeline-row svg { display: block; width: 100%; height: 84px; }
diff --git a/client/dive-common/review/statistics.spec.ts b/client/dive-common/review/statistics.spec.ts
index 283c968f9..82068b0a6 100644
--- a/client/dive-common/review/statistics.spec.ts
+++ b/client/dive-common/review/statistics.spec.ts
@@ -152,3 +152,16 @@ it('draws horizontal step plateaus instead of diagonal spikes', () => {
     'M0,24 H25 V4 H75 V24 H100 V24 Z',
   );
 });
+
+it('uses the sequence name for capture order when camera names carry no date', () => {
+  const result = buildReviewStatistics([
+    { config: config('older_20241201_120000.mp4'), tracks: [] },
+    {
+      config: config('rig/left'), sequenceId: 'rig', sequenceName: 'newer_20250101_120000.mp4', tracks: [],
+    },
+    {
+      config: config('rig/right'), sequenceId: 'rig', sequenceName: 'newer_20250101_120000.mp4', tracks: [],
+    },
+  ]);
+  expect(result.timelines.map(({ id }) => id)).toEqual(['rig', 'older_20241201_120000.mp4']);
+});
diff --git a/client/dive-common/review/statistics.ts b/client/dive-common/review/statistics.ts
index f8d6434ef..018d013c4 100644
--- a/client/dive-common/review/statistics.ts
+++ b/client/dive-common/review/statistics.ts
@@ -137,6 +137,7 @@ export function buildReviewStatistics(datasets: Iterable<StatisticsDataset>): Re
       let active = 0;
       return delta.slice(0, TIMELINE_BINS).map((change) => { active += change; return active; });
     }
+    timestamp ??= parseFrameTimestamp(cameras[0].sequenceName ?? '');
     timelines.push({
       id,
       name: cameras[0].sequenceName ?? cameras[0].config.name,