feat: Group findings table values with custom components/grouping functions (#4712)

platform/core/src/hooks/useActiveViewportDisplaySets.ts

@@ -9,9 +9,7 @@ import { DisplaySet } from '../types';
  * @returns Array of display sets for the active viewport
  */
 const useActiveViewportDisplaySets = ({ servicesManager }): DisplaySet[] => {
-  const [displaySets, setDisplaySets] = useState<DisplaySet[]>([]);
   const { displaySetService, viewportGridService } = servicesManager.services;
-
   // Move this function outside useEffect and memoize it
   const getDisplaySetsForViewport = useCallback(
     (viewportId: string) => {
@@ -21,19 +19,22 @@ const useActiveViewportDisplaySets = ({ servicesManager }): DisplaySet[] => {
     [displaySetService, viewportGridService]
   );
 
-  useEffect(() => {
-    // Get initial state
-    const viewportId = viewportGridService.getActiveViewportId();
-    setDisplaySets(getDisplaySetsForViewport(viewportId));
+  // Get initial state
+  const viewportId = viewportGridService.getActiveViewportId();
+  const displaySetsNew = getDisplaySetsForViewport(viewportId) || [];
+  const [displaySets, setDisplaySets] = useState<DisplaySet[]>(displaySetsNew);
 
+  useEffect(() => {
     const handleViewportChange = ({ viewportId }) => {
-      setDisplaySets(getDisplaySetsForViewport(viewportId));
+      const displaySetsNew = getDisplaySetsForViewport(viewportId);
+      setDisplaySets(displaySetsNew);
     };
 
     const handleGridStateChange = ({ state }) => {
       const activeViewportId = state.activeViewportId;
       if (activeViewportId) {
-        setDisplaySets(getDisplaySetsForViewport(activeViewportId));
+        const displaySetsNew = getDisplaySetsForViewport(activeViewportId);
+        setDisplaySets(displaySetsNew);
       }
     };
 

platform/core/src/services/MeasurementService/MeasurementService.ts

@@ -405,11 +405,14 @@ class MeasurementService extends PubSubService {
     let measurement = {};
     try {
       measurement = toMeasurementSchema(data);
+      if (!measurement) {
+        return;
+      }
       measurement.source = source;
     } catch (error) {
       log.warn(
         `Failed to map '${sourceInfo}' measurement for annotationType ${annotationType}:`,
-        error.message
+        error
       );
       return;
     }
@@ -589,6 +592,30 @@ class MeasurementService extends PubSubService {
     });
   }
 
+  /**
+   * Remove multiple measurements at once.
+   */
+  removeMany(measurementUIDs: string[]): void {
+    const measurements = [];
+    for (const measurementUID of measurementUIDs) {
+      const measurement =
+        this.measurements.get(measurementUID) || this.unmappedMeasurements.get(measurementUID);
+
+      if (!measurementUID || !measurement) {
+        console.debug(`No uid provided, or unable to find measurement by uid.`);
+        continue;
+      }
+
+      this.unmappedMeasurements.delete(measurementUID);
+      this.measurements.delete(measurementUID);
+      measurements.push(measurement);
+    }
+    if (!measurements.length) {
+      return;
+    }
+    this._broadcastEvent(this.EVENTS.MEASUREMENTS_CLEARED, { measurements });
+  }
+
   /**
    * Clears measurements that match the filter, defaulting to all of them.
    * That allows, for example, clearing all of a single studies measurements
@@ -769,7 +796,7 @@ class MeasurementService extends PubSubService {
     });
   }
 
-  public toggleVisibilityMeasurement(measurementUID: string): void {
+  public toggleVisibilityMeasurement(measurementUID: string, visibility?: boolean): void {
     const measurement = this.measurements.get(measurementUID);
 
     if (!measurement) {
@@ -777,7 +804,10 @@ class MeasurementService extends PubSubService {
       return;
     }
 
-    measurement.isVisible = !measurement.isVisible;
+    if (measurement.isVisible === visibility && visibility !== undefined) {
+      return;
+    }
+    measurement.isVisible = visibility !== undefined ? visibility : !measurement.isVisible;
 
     this._broadcastEvent(this.EVENTS.MEASUREMENT_UPDATED, {
       source: measurement.source,
@@ -786,6 +816,10 @@ class MeasurementService extends PubSubService {
     });
   }
 
+  public toggleVisibilityMeasurementMany(measurementUIDs: string[], visibility?: boolean): void {
+    return measurementUIDs.forEach(uid => this.toggleVisibilityMeasurement(uid, visibility));
+  }
+
   public updateColorMeasurement(measurementUID: string, color: number[]): void {
     const measurement = this.measurements.get(measurementUID);
 

platform/core/src/services/ViewportGridService/ViewportGridService.ts

@@ -130,6 +130,9 @@ class ViewportGridService extends PubSubService {
   }
 
   public setActiveViewportId(id: string) {
+    if (id === this.getActiveViewportId()) {
+      return;
+    }
     this.serviceImplementation._setActiveViewport(id);
 
     // Use queueMicrotask to delay the event broadcast

platform/core/src/types/DisplaySet.ts

@@ -3,6 +3,7 @@ import { InstanceMetadata } from './StudyMetadata';
 export type DisplaySet = {
   displaySetInstanceUID: string;
   instances: InstanceMetadata[];
+  isReconstructable?: boolean;
   StudyInstanceUID: string;
   SeriesInstanceUID?: string;
   SeriesNumber?: number;

platform/core/src/utils/measurementFilters.ts

@@ -1,11 +1,19 @@
+import MeasurementService from '../services/MeasurementService';
 /**
  * Returns a filter function which filters for measurements belonging to both
  * the study and series.
  */
 export function filterMeasurementsBySeriesUID(selectedSeries: string[]) {
+  if (!selectedSeries) {
+    return;
+  }
   return measurement => selectedSeries.includes(measurement.referenceSeriesUID);
 }
 
+export function filterMeasurementsByStudyUID(studyUID) {
+  return measurement => measurement.referenceStudyUID == studyUID;
+}
+
 /**
  * @returns true for measurements include referencedImageId (coplanar with an image)
  */
@@ -13,6 +21,10 @@ export function filterPlanarMeasurement(measurement) {
   return measurement?.referencedImageId;
 }
 
+export function filterTool(toolName: string) {
+  return annotation => annotation.metadata?.toolName === toolName;
+}
+
 /** A filter that always returns true */
 export function filterAny(_measurement) {
   return true;
@@ -30,6 +42,10 @@ export function filterNone(_measurement) {
 export function filterOr(...filters) {
   return function (item) {
     for (let filter of filters) {
+      if (!filter) {
+        // Un undefined filter means all, so return true for the or
+        return true;
+      }
       if (typeof filter === 'string') {
         filter = this[filter];
       }
@@ -44,13 +60,14 @@ export function filterOr(...filters) {
   };
 }
 
+const { POINT } = MeasurementService.VALUE_TYPES;
+
 /**
  * Filters for additional findings, that is, measurements with
  * a value of type point, and having a referenced image
  */
-export function filterAdditionalFindings(measurementService) {
-  const { POINT } = measurementService.VALUE_TYPES;
-  return dm => dm.type === POINT && dm.referencedImageId;
+export function filterAdditionalFindings(dm) {
+  return dm.type === POINT && dm.referencedImageId;
 }
 
 /**
@@ -70,8 +87,15 @@ const isString = s => typeof s === 'string' || s instanceof String;
  * called on the final filter call.
  */
 export function filterAnd(...filters) {
+  const nonNullFilters = filters.filter(filter => !!filter);
+  if (!nonNullFilters.length) {
+    return;
+  }
+  if (nonNullFilters.length === 1 && typeof nonNullFilters[0] === 'function') {
+    return nonNullFilters[0];
+  }
   return function (item) {
-    for (const filter of filters) {
+    for (const filter of nonNullFilters) {
       if (isString(filter)) {
         if (!this[filter](item)) {
           return false;
@@ -98,7 +122,7 @@ export function filterAnd(...filters) {
  */
 export function filterNot(...filters) {
   if (filters.length !== 1) {
-    return filterAnd.apply(null, filters.map(filterNot));
+    return filterAnd(...filters.map(filter => filterNot(filter)));
   }
   const [filter] = filters;
   if (isString(filter)) {