Ask which side of the confidence threshold a delete of every listed track reaches (#1944)

* Ask which side of the confidence threshold a delete of every listed track reaches

The track list only shows what passes the confidence thresholds, so its
delete button asks: above (the listed tracks), below (hidden ones), or all.

* Delete whole tracks in every threshold scope

* Widen the delete scope dialog to keep each option on one line

* Make all tracks the first default delete scope and tighten the dialog

* Shorten delete scope dialog prompt

* fix below threshold delete removing non visible tracks

---------

Co-authored-by: Bryon Lewis <Bryon.Lewis@kitware.com>

Author: mattdawkins

client/dive-common/components/Viewer.vue

@@ -743,7 +743,7 @@ export default defineComponent({
       sorted: cameraStore.sortedTracks,
       remove: removeTracks,
       markChangesPending: (markChangesPending as MarkChangesPendingFilter),
-      lookupGroups: cameraStore.lookupGroups,
+      lookupGroups: cameraStore.lookupGroups.bind(cameraStore),
       getTracks: (track: AnnotationId) => cameraStore.getTrackAll(track),
       renameTrackPair: (id, currentType, newType) => (
         cameraStore.renameTrackPair(id, currentType, newType)

client/src/BaseFilterControls.ts

@@ -1,6 +1,7 @@
 import {
   ref, computed, Ref, watch,
 } from 'vue';
+import { resolveConfidenceThreshold } from 'dive-common/typeHierarchy';
 import type { AnnotationId, ConfidencePair } from './BaseAnnotation';
 import { SortedAnnotation } from './BaseAnnotationStore';
 import type Group from './Group';
@@ -15,6 +16,9 @@ interface MarkChangesPendingData {
 export type MarkChangesPendingFilter = (data?: MarkChangesPendingData) => void;
 
 export const DefaultConfidence = 0.1;
+
+/** Which annotations a delete-all reaches, relative to each type's threshold. */
+export type ThresholdScope = 'above' | 'below' | 'all';
 /**
  * AnnotationWithContext wraps an annotation with additional information
  * such as why the annotation was included or returned by a system
@@ -235,6 +239,21 @@ export default abstract class BaseFilterControls<T extends Track | Group> {
     });
   }
 
+  /**
+   * Tracks with enabled classes, none of which reach their confidence threshold.
+   * TrackFilterControls overrides this to also apply time, group, and attribute filters.
+   */
+  annotationIdsBelowThreshold(types: string[]): AnnotationId[] {
+    const wanted = new Set(types);
+    const filters = this.confidenceFilters.value;
+    return this.sorted.value.filter((annotation) => {
+      const matching = annotation.confidencePairs.filter(([type]) => wanted.has(type));
+      return matching.length > 0 && matching.every(([type, confidence]) => (
+        confidence < resolveConfidenceThreshold(filters, type)
+      ));
+    }).map(({ id }) => id);
+  }
+
   updateCheckedTypes(types: string[]) {
     this.checkedTypes.value = types;
   }

client/src/TrackFilterControls.spec.ts

@@ -101,7 +101,7 @@ function makeTrackFilterControls(markPending: MarkChangesPendingFilter = markCha
     remove,
     markChangesPending: markPending,
     groupFilterControls,
-    lookupGroups: cameraStore.lookupGroups,
+    lookupGroups: cameraStore.lookupGroups.bind(cameraStore),
     getTracks: (track: AnnotationId) => cameraStore.getTrackAll(track),
     renameTrackPair: (id, currentType, newType) => (
       cameraStore.renameTrackPair(id, currentType, newType)
@@ -126,7 +126,7 @@ function makePairFixture(
     remove: (id) => cameraStore.removeTracks(id),
     markChangesPending: markPending,
     groupFilterControls,
-    lookupGroups: cameraStore.lookupGroups,
+    lookupGroups: cameraStore.lookupGroups.bind(cameraStore),
     getTracks: (id) => cameraStore.getTrackAll(id),
     renameTrackPair: (id, currentType, newType) => (
       cameraStore.renameTrackPair(id, currentType, newType)
@@ -449,6 +449,132 @@ describe('useAnnotationFilters', () => {
     expect(cameraStore.getTrack(1).confidencePairs).toEqual([['baz', 0.7]]);
   });
 
+  it('selects whole hidden tracks without stripping their other class scores', () => {
+    const { cameraStore, filters } = makePairFixture([
+      [['fish', 0.9], ['shark', 0.1]],
+      [['fish', 0.2], ['shark', 0.1]],
+      [['shark', 0.1]],
+      [['fish', 0.5]],
+    ]);
+    filters.setConfidenceFilters({ default: 0.5 });
+    filters.updateCheckedTypes(['fish']);
+    const ids = filters.annotationIdsBelowThreshold(['fish']);
+    expect(ids).toEqual([1]);
+    expect(cameraStore.getTrack(1).confidencePairs).toEqual([['fish', 0.2], ['shark', 0.1]]);
+    ids.forEach((id) => cameraStore.removeTracks(id));
+    expect(cameraStore.getPossibleTrack(1)).toBeUndefined();
+    expect(cameraStore.getTrack(0).confidencePairs).toEqual([['fish', 0.9], ['shark', 0.1]]);
+    expect(cameraStore.getPossibleTrack(2)).toBeDefined();
+    expect(cameraStore.getPossibleTrack(3)).toBeDefined();
+  });
+
+  it('does not classify a visible track by its low-scoring secondary class', () => {
+    const { filters } = makePairFixture([
+      [['fish', 0.9], ['shark', 0.1]],
+      [['fish', 0.2], ['shark', 0.7]],
+      [['fish', 0.2], ['shark', 0.1]],
+    ]);
+    filters.setConfidenceFilters({ default: 0.5 });
+    expect(filters.annotationIdsBelowThreshold(['fish', 'shark'])).toEqual([2]);
+    expect(filters.annotationIdsBelowThreshold([])).toEqual([]);
+  });
+
+  it('limits below-threshold delete to the active time filter', () => {
+    const cameraStore = new CameraStore({ markChangesPending });
+    const trackStore = cameraStore.camMap.value.get('singleCam')?.trackStore;
+    const lateFeatures: Feature[] = [];
+    lateFeatures[10] = { frame: 10, bounds: [0, 0, 1, 1], keyframe: true };
+    trackStore?.insert(new Track(0, {
+      begin: 0,
+      end: 0,
+      confidencePairs: [['fish', 0.2]],
+      features,
+    }));
+    trackStore?.insert(new Track(1, {
+      begin: 10,
+      end: 10,
+      confidencePairs: [['fish', 0.2]],
+      features: lateFeatures,
+    }));
+    trackStore?.setEnableSorting();
+    const groupFilterControls = makeGroupFilterControls(cameraStore);
+    const filters = new TrackFilterControls({
+      sorted: cameraStore.sortedTracks,
+      remove: (id) => cameraStore.removeTracks(id),
+      markChangesPending,
+      groupFilterControls,
+      lookupGroups: cameraStore.lookupGroups.bind(cameraStore),
+      getTracks: (id) => cameraStore.getTrackAll(id),
+      renameTrackPair: (id, currentType, newType) => (
+        cameraStore.renameTrackPair(id, currentType, newType)
+      ),
+      removeTypes: (id, types) => cameraStore.removeTypes(id, types),
+    });
+    filters.setConfidenceFilters({ default: 0.5 });
+    filters.setTimeFilters([0, 5]);
+    expect(filters.annotationIdsBelowThreshold(['fish'])).toEqual([0]);
+    filters.setTimeFilters(null);
+    expect(filters.annotationIdsBelowThreshold(['fish'])).toEqual([0, 1]);
+  });
+
+  it('limits below-threshold delete to enabled groups', () => {
+    const cameraStore = new CameraStore({ markChangesPending });
+    const cam = cameraStore.camMap.value.get('singleCam');
+    cam?.trackStore.insert(new Track(0, {
+      confidencePairs: [['fish', 0.2]],
+      features,
+    }));
+    cam?.trackStore.insert(new Track(1, {
+      confidencePairs: [['fish', 0.2]],
+      features,
+    }));
+    cam?.trackStore.setEnableSorting();
+    cam?.groupStore.insert(new Group(10, {
+      confidencePairs: [['school', 1]],
+      members: { 0: { ranges: [[0, 0]] } },
+    }), { imported: true });
+    cam?.groupStore.insert(new Group(11, {
+      confidencePairs: [['pod', 1]],
+      members: { 1: { ranges: [[0, 0]] } },
+    }), { imported: true });
+    cam?.groupStore.setEnableSorting();
+    const groupFilterControls = makeGroupFilterControls(cameraStore);
+    groupFilterControls.checkedTypes.value = ['school'];
+    const filters = new TrackFilterControls({
+      sorted: cameraStore.sortedTracks,
+      remove: (id) => cameraStore.removeTracks(id),
+      markChangesPending,
+      groupFilterControls,
+      lookupGroups: cameraStore.lookupGroups.bind(cameraStore),
+      getTracks: (id) => cameraStore.getTrackAll(id),
+      renameTrackPair: (id, currentType, newType) => (
+        cameraStore.renameTrackPair(id, currentType, newType)
+      ),
+      removeTypes: (id, types) => cameraStore.removeTypes(id, types),
+    });
+    filters.setConfidenceFilters({ default: 0.5 });
+    expect(filters.annotationIdsBelowThreshold(['fish'])).toEqual([0]);
+  });
+
+  it('limits below-threshold delete with attribute filters', () => {
+    const { cameraStore, filters } = makePairFixture([
+      [['fish', 0.2]],
+      [['fish', 0.2]],
+    ]);
+    cameraStore.getTrack(0).attributes.quality = 'good';
+    cameraStore.getTrack(1).attributes.quality = 'bad';
+    filters.setConfidenceFilters({ default: 0.5 });
+    filters.loadTrackAttributesFilter([{
+      name: 'fish quality',
+      type: 'track',
+      typeFilter: ['fish'],
+      attribute: 'quality',
+      filter: { op: '=', val: 'good' },
+      enabled: true,
+    }]);
+    expect(filters.annotationIdsBelowThreshold(['fish'])).toEqual([0]);
+  });
+
   it('returns the caller fallback without recomputing flat pair selection', () => {
     const { cameraStore, filters } = makePairFixture([
       [['root', 0.1], ['leaf', 0.9]],
@@ -655,7 +781,7 @@ describe('useAnnotationFilters', () => {
       remove: (id) => cameraStore.removeTracks(id),
       markChangesPending,
       groupFilterControls: groupFilters,
-      lookupGroups: cameraStore.lookupGroups,
+      lookupGroups: cameraStore.lookupGroups.bind(cameraStore),
       getTracks: (id) => cameraStore.getTrackAll(id),
       renameTrackPair: (id, currentType, newType) => (
         cameraStore.renameTrackPair(id, currentType, newType)

client/src/TrackFilterControls.ts

@@ -96,11 +96,17 @@ export default class TrackFilterControls extends BaseFilterControls<Track> {
 
   private renameTrackPair: TrackFilterControlsParams['renameTrackPair'];
 
+  private lookupGroups: TrackFilterControlsParams['lookupGroups'];
+
+  private groupFilterControls: TrackFilterControlsParams['groupFilterControls'];
+
   constructor(params: TrackFilterControlsParams) {
     super(params);
 
     this.getTracks = params.getTracks;
     this.renameTrackPair = params.renameTrackPair;
+    this.lookupGroups = params.lookupGroups;
+    this.groupFilterControls = params.groupFilterControls;
 
     const flatAllTypes = this.allTypes;
     this.typeHierarchy = ref(undefined);
@@ -125,26 +131,13 @@ export default class TrackFilterControls extends BaseFilterControls<Track> {
      */
     this.filteredAnnotations = computed(() => {
       const checkedSet = this.checkedTypesSet.value;
-      const filteredGroupsSet = new Set(params.groupFilterControls.enabledAnnotations.value
-        .map((v) => v.annotation.id));
+      const enabledGroupIds = this.enabledGroupIds();
       const confidenceFiltersVal = cloneDeep(this.confidenceFilters.value);
       const resultsArr: AnnotationWithContext<Track>[] = [];
       const resultsIds: Set<AnnotationId> = new Set();
-      params.sorted.value.forEach((annotation) => {
-        if (this.timeFilters.value !== null && !this.disableAnnotationFilters.value) {
-          const [startTime, endTime] = this.timeFilters.value;
-          if (annotation.begin > endTime || annotation.end < startTime) {
-            return;
-          }
-        }
-        let enabledInGroupFilters = true;
-        const groups = params.lookupGroups(annotation.id);
-        if (groups.length) {
-          /**
-           * This track is a member of a group,
-           * so check that at least one of its groups is enabled
-           */
-          enabledInGroupFilters = groups.some((group) => filteredGroupsSet.has(group.id));
+      this.sorted.value.forEach((annotation) => {
+        if (!this.passesTimeAndGroupFilters(annotation, enabledGroupIds)) {
+          return;
         }
         let confidencePairIndex: number;
         if (this.hierarchyActive.value) {
@@ -165,40 +158,95 @@ export default class TrackFilterControls extends BaseFilterControls<Track> {
         if (
           (confidencePairIndex >= 0
             || (!this.hierarchyActive.value && annotation.confidencePairs.length === 0))
-          && enabledInGroupFilters && !resultsIds.has(annotation.id)
+          && !resultsIds.has(annotation.id)
+          && this.passesAttributeFilters(
+            annotation.id,
+            annotation.confidencePairs[confidencePairIndex]?.[0],
+          )
         ) {
-          let addValue = true;
-          if (!this.disableAnnotationFilters.value && this.attributeFilters.value.length > 0
-            && this.enabledFilters.value.length > 0) {
-            const [canonicalTrack] = params.getTracks(annotation.id);
-            if (canonicalTrack === undefined) {
-              addValue = false;
-            } else {
-              addValue = trackIdPassesFilter(
-                annotation.id,
-                () => canonicalTrack,
-                this.attributeFilters.value,
-                this.userDefinedValues.value,
-                this.enabledFilters.value,
-                annotation.confidencePairs[confidencePairIndex]?.[0],
-              );
-            }
-          }
-          if (addValue) {
-            resultsIds.add(annotation.id);
-            resultsArr.push({
-              annotation,
-              context: {
-                confidencePairIndex,
-              },
-            });
-          }
+          resultsIds.add(annotation.id);
+          resultsArr.push({
+            annotation,
+            context: {
+              confidencePairIndex,
+            },
+          });
         }
       });
       return resultsArr;
     });
   }
 
+  private enabledGroupIds(): Set<AnnotationId> {
+    return new Set(this.groupFilterControls.enabledAnnotations.value
+      .map((v) => v.annotation.id));
+  }
+
+  /** Time range and group-membership checks shared by the list and below-threshold delete. */
+  private passesTimeAndGroupFilters(
+    annotation: { id: AnnotationId; begin: number; end: number },
+    enabledGroupIds: Set<AnnotationId>,
+  ): boolean {
+    if (this.timeFilters.value !== null && !this.disableAnnotationFilters.value) {
+      const [startTime, endTime] = this.timeFilters.value;
+      if (annotation.begin > endTime || annotation.end < startTime) {
+        return false;
+      }
+    }
+    const groups = this.lookupGroups(annotation.id);
+    if (groups.length) {
+      return groups.some((group) => enabledGroupIds.has(group.id));
+    }
+    return true;
+  }
+
+  private passesAttributeFilters(
+    annotationId: AnnotationId,
+    displayType: string | undefined,
+  ): boolean {
+    if (this.disableAnnotationFilters.value || this.attributeFilters.value.length === 0
+      || this.enabledFilters.value.length === 0) {
+      return true;
+    }
+    const [canonicalTrack] = this.getTracks(annotationId);
+    if (canonicalTrack === undefined) {
+      return false;
+    }
+    return trackIdPassesFilter(
+      annotationId,
+      () => canonicalTrack,
+      this.attributeFilters.value,
+      this.userDefinedValues.value,
+      this.enabledFilters.value,
+      displayType,
+    );
+  }
+
+  /**
+   * Tracks with enabled classes that fail their confidence thresholds, after the
+   * same time / group / attribute filters the track list applies.
+   */
+  annotationIdsBelowThreshold(types: string[]): AnnotationId[] {
+    const wanted = new Set(types);
+    const filters = this.confidenceFilters.value;
+    const enabledGroupIds = this.enabledGroupIds();
+    return this.sorted.value.filter((annotation) => {
+      if (!this.passesTimeAndGroupFilters(annotation, enabledGroupIds)) {
+        return false;
+      }
+      const matching = annotation.confidencePairs.filter(([type]) => wanted.has(type));
+      if (matching.length === 0 || matching.some(([type, confidence]) => (
+        confidence >= resolveConfidenceThreshold(filters, type)
+      ))) {
+        return false;
+      }
+      const displayType = matching.reduce((best, pair) => (
+        pair[1] > best[1] ? pair : best
+      ))[0];
+      return this.passesAttributeFilters(annotation.id, displayType);
+    }).map(({ id }) => id);
+  }
+
   displayPairIndex(track: Readonly<Track>, flatFallbackIndex: number): number {
     const index = this.hierarchyIndex.value;
     if (index === undefined) {