feat: add support to scoord3d (#5016)

Co-authored-by: Bill Wallace <wayfarer3130@gmail.com>

platform/app/src/components/ViewportGrid.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useCallback, useRef } from 'react';
-import { Types, MeasurementService } from '@ohif/core';
+import { Types } from '@ohif/core';
 import { ViewportGrid, ViewportPane } from '@ohif/ui-next';
 import { useViewportGrid } from '@ohif/ui-next';
 import EmptyViewport from './EmptyViewport';
@@ -14,13 +14,8 @@ function ViewerViewportGrid(props: withAppTypes) {
   const { numCols, numRows } = layout;
   const layoutHash = useRef(null);
 
-  const {
-    displaySetService,
-    measurementService,
-    hangingProtocolService,
-    uiNotificationService,
-    customizationService,
-  } = servicesManager.services;
+  const { displaySetService, hangingProtocolService, uiNotificationService, customizationService } =
+    servicesManager.services;
 
   const generateLayoutHash = () => `${numCols}-${numRows}`;
 
@@ -32,9 +27,9 @@ function ViewerViewportGrid(props: withAppTypes) {
 
    */
   const updateDisplaySetsFromProtocol = (
-    protocol: Types.HangingProtocol.Protocol,
+    _protocol: Types.HangingProtocol.Protocol,
     stage,
-    activeStudyUID,
+    _activeStudyUID,
     viewportMatchDetails
   ) => {
     const availableDisplaySets = displaySetService.getActiveDisplaySets();
@@ -154,100 +149,6 @@ function ViewerViewportGrid(props: withAppTypes) {
     }
   }, [viewportGridService, generateLayoutHash]);
 
-  useEffect(() => {
-    const { unsubscribe } = measurementService.subscribe(
-      MeasurementService.EVENTS.JUMP_TO_MEASUREMENT_LAYOUT,
-      event => {
-        const { viewportId, measurement, isConsumed } = event;
-        if (isConsumed) {
-          return;
-        }
-
-        const { displaySetInstanceUID: referencedDisplaySetInstanceUID } = measurement;
-        const { viewports } = viewportGridService.getState();
-
-        // Check if any viewport can display this measurement
-        let canAnyViewportDisplayMeasurement = false;
-
-        viewports.forEach((viewport, id) => {
-          const displaySetInstanceUIDs = viewport.displaySetInstanceUIDs || [];
-          const viewportHasDisplaySet = displaySetInstanceUIDs.includes(
-            referencedDisplaySetInstanceUID
-          );
-
-          // Extract metadata and prepare reference
-          const { FrameOfReferenceUID, ...metadataRest } = measurement.metadata;
-          const reference = {
-            ...(viewportHasDisplaySet ? measurement.metadata : metadataRest),
-            displaySetInstanceUID: referencedDisplaySetInstanceUID,
-          };
-
-          // Check if viewport can display the reference
-          if (
-            viewport.isReferenceViewable?.({
-              viewportId: id,
-              reference,
-            })
-          ) {
-            canAnyViewportDisplayMeasurement = true;
-          }
-        });
-
-        if (canAnyViewportDisplayMeasurement) {
-          // Let the viewports handle the jump
-          return;
-        }
-
-        // Need to change layouts since no viewport consumed the event
-        const updatedViewports = _getUpdatedViewports(viewportId, referencedDisplaySetInstanceUID);
-
-        if (!updatedViewports?.[0]) {
-          console.warn(
-            'ViewportGrid::Unable to navigate to viewport containing',
-            referencedDisplaySetInstanceUID
-          );
-          return;
-        }
-
-        // Find the viewport that can display the measurement
-        const viewport = updatedViewports.find(viewport => {
-          const gridViewport = viewportGridService.getViewportState(viewport.viewportId);
-          return gridViewport.isReferenceViewable?.({
-            viewportId: viewport.viewportId,
-            reference: {
-              ...measurement.metadata,
-              displaySetInstanceUID: referencedDisplaySetInstanceUID,
-            },
-            viewportOptions: gridViewport.viewportOptions || {},
-          });
-        });
-
-        if (!viewport) {
-          console.warn('No suitable viewport found for displaying measurement');
-          return;
-        }
-
-        // Update stored position presentation
-        commandsManager.run('updateStoredPositionPresentation', {
-          viewportId: viewport.viewportId,
-          displaySetInstanceUIDs: [referencedDisplaySetInstanceUID],
-          referencedImageId: measurement.referencedImageId,
-          options: {
-            ...measurement.metadata,
-          },
-        });
-
-        event.consume();
-
-        commandsManager.run('setDisplaySetsForViewports', { viewportsToUpdate: updatedViewports });
-      }
-    );
-
-    return () => {
-      unsubscribe();
-    };
-  }, [viewports, _getUpdatedViewports]);
-
   const onDropHandler = (viewportId, { displaySetInstanceUID }) => {
     const { viewportGridService } = servicesManager.services;
     const customOnDropHandler = customizationService.getCustomization('customOnDropHandler');
@@ -267,23 +168,6 @@ function ViewerViewportGrid(props: withAppTypes) {
     viewportGridService.publishViewportOnDropHandled({ displaySetInstanceUID });
   };
 
-  // Store previous isReferenceViewable values to avoid infinite loops
-  const prevReferenceViewableMap = useRef(new Map());
-  // Track viewports that need isReferenceViewable updates
-  const viewportsToUpdate = useRef(new Map());
-
-  // Apply isReferenceViewable updates in an effect, not during render
-  useEffect(() => {
-    const updates = viewportsToUpdate.current;
-    if (updates.size > 0) {
-      updates.forEach((isReferenceViewable, viewportId) => {
-        viewportGridService.setIsReferenceViewable(viewportId, isReferenceViewable);
-        prevReferenceViewableMap.current.set(viewportId, isReferenceViewable);
-      });
-      viewportsToUpdate.current.clear();
-    }
-  });
-
   const getViewportPanes = useCallback(() => {
     const viewportPanes = [];
 
@@ -315,27 +199,12 @@ function ViewerViewportGrid(props: withAppTypes) {
           return !displaySet?.unsupported;
         });
 
-      const { component: ViewportComponent, isReferenceViewable } = _getViewportComponent(
+      const { component: ViewportComponent } = _getViewportComponent(
         displaySets,
         viewportComponents,
         uiNotificationService
       );
 
-      // Only queue isReferenceViewable updates if it's changed to avoid render loops
-      // We need to handle both function and non-function values
-      if (viewportId) {
-        const prevValue = prevReferenceViewableMap.current.get(viewportId);
-        const isFunction = typeof isReferenceViewable === 'function';
-        const isSameFunction = isFunction && typeof prevValue === 'function';
-
-        // For non-functions, compare directly. For functions, we treat them as always different
-        // (this is conservative but safe)
-        if (!isSameFunction && prevValue !== isReferenceViewable) {
-          // Queue the update instead of doing it during render
-          viewportsToUpdate.current.set(viewportId, isReferenceViewable);
-        }
-      }
-
       // look inside displaySets to see if they need reRendering
       const displaySetsNeedsRerendering = displaySets.some(displaySet => {
         return displaySet.needsRerendering;
@@ -462,8 +331,8 @@ function _getViewportComponent(displaySets, viewportComponents, uiNotificationSe
       throw new Error('displaySetsToDisplay is null');
     }
     if (viewportComponents[i].displaySetsToDisplay.includes(SOPClassHandlerId)) {
-      const { component, isReferenceViewable } = viewportComponents[i];
-      return { component, isReferenceViewable };
+      const { component } = viewportComponents[i];
+      return { component };
     }
   }
 
@@ -474,7 +343,7 @@ function _getViewportComponent(displaySets, viewportComponents, uiNotificationSe
     type: 'error',
   });
 
-  return { component: EmptyViewport, isReferenceViewable: () => false };
+  return { component: EmptyViewport };
 }
 
 export default ViewerViewportGrid;