@cornerstonejs/tools 1.78.3 → 1.80.1

package/src/utilities/cine/playClip.ts

@@ -3,6 +3,7 @@ import {
   utilities as csUtils,
   getEnabledElement,
   StackViewport,
+  VideoViewport,
   VolumeViewport,
   cache,
   BaseVolumeViewport,
@@ -152,7 +153,14 @@ function playClip(
     const delta = newStepIndex - currentStepIndex;
 
     if (delta) {
-      playClipContext.scroll(delta);
+      try {
+        playClipContext.scroll(delta);
+      } catch (e) {
+        console.warn('Play clip not scrolling', e);
+        _stopClipWithData(playClipData);
+        triggerEvent(element, CINE_EVENTS.CLIP_STOPPED, eventDetail);
+        return;
+      }
     }
   };
 
@@ -160,9 +168,14 @@ function playClip(
     dynamicVolumesPlayingMap.set(volume.volumeId, element);
   }
 
-  // If playClipTimeouts array is available, not empty and its elements are NOT uniform ...
-  // ... (at least one timeout is different from the others), use alternate setTimeout implementation
-  if (
+  if (playClipContext.play) {
+    playClipData.framesPerSecond = playClipContext.play(
+      playClipOptions.framesPerSecond
+    );
+
+    // If playClipTimeouts array is available, not empty and its elements are NOT uniform ...
+    // ... (at least one timeout is different from the others), use alternate setTimeout implementation
+  } else if (
     playClipTimeouts &&
     playClipTimeouts.length > 0 &&
     playClipIsTimeVarying
@@ -213,6 +226,7 @@ function _stopClip(
   const enabledElement = getEnabledElement(element);
 
   let toolState;
+  const viewport = enabledElement?.viewport;
   if (!enabledElement) {
     if (viewportId) {
       toolState = getToolStateByViewportId(viewportId);
@@ -228,10 +242,9 @@ function _stopClip(
     _stopClipWithData(toolState);
   }
 
-  if (
-    stopDynamicCine &&
-    enabledElement?.viewport instanceof BaseVolumeViewport
-  ) {
+  if (viewport instanceof VideoViewport) {
+    viewport.pause();
+  } else if (stopDynamicCine && viewport instanceof BaseVolumeViewport) {
     _stopDynamicVolumeCine(element);
   }
 }
@@ -374,6 +387,45 @@ function _createStackViewportCinePlayContext(
   };
 }
 
+function _createVideoViewportCinePlayContext(
+  viewport: VideoViewport,
+  waitForRendered: number
+): CINETypes.CinePlayContext {
+  return {
+    get numScrollSteps(): number {
+      return viewport.getNumberOfSlices();
+    },
+    get currentStepIndex(): number {
+      return viewport.getSliceIndex();
+    },
+    get frameTimeVectorEnabled(): boolean {
+      // It is always in acquired orientation
+      return true;
+    },
+    waitForRenderedCount: 0,
+    scroll(delta: number): void {
+      if (
+        this.waitForRenderedCount <= waitForRendered &&
+        viewport.viewportStatus !== ViewportStatus.RENDERED
+      ) {
+        this.waitForRenderedCount++;
+        return;
+      }
+      this.waitForRenderedCount = 0;
+      scroll(viewport, { delta, debounceLoading: debounced });
+    },
+    play(fps?: number): number {
+      if (fps) {
+        // This is a bit of a kludge to correspond to playback rates
+        // for other viewports
+        viewport.setPlaybackRate(fps / 24);
+      }
+      viewport.play();
+      return viewport.getFrameRate();
+    },
+  };
+}
+
 function _createVolumeViewportCinePlayContext(
   viewport: VolumeViewport,
   volume: Types.IImageVolume
@@ -475,6 +527,13 @@ function _createCinePlayContext(
     return _createVolumeViewportCinePlayContext(viewport, volume);
   }
 
+  if (viewport instanceof VideoViewport) {
+    return _createVideoViewportCinePlayContext(
+      viewport,
+      playClipOptions.waitForRendered ?? 30
+    );
+  }
+
   throw new Error('Unknown viewport type');
 }
 

package/src/utilities/planar/filterAnnotationsWithinPlane.ts

@@ -0,0 +1,76 @@
+import { vec3 } from 'gl-matrix';
+import { CONSTANTS, metaData } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { Annotations, Annotation } from '../../types';
+
+const { EPSILON } = CONSTANTS;
+
+const PARALLEL_THRESHOLD = 1 - EPSILON;
+
+/**
+ * given some `Annotations`, and the slice defined by the camera's normal
+ * direction and the spacing in the normal, filter the `Annotations` which
+ * is within the slice.
+ *
+ * @param annotations - Annotations
+ * @param camera - The camera
+ * @param spacingInNormalDirection - The spacing in the normal direction
+ * @returns The filtered `Annotations`.
+ */
+export function filterAnnotationsWithinSamePlane(
+  annotations: Annotations,
+  camera: Types.ICamera
+): Annotations {
+  const { viewPlaneNormal } = camera;
+
+  // The reason we use parallel normals instead of actual orientation is that
+  // flipped action is done through camera API, so we can't rely on the
+  // orientation (viewplaneNormal and viewUp) since even the same image and
+  // same slice if flipped will have different orientation, but still rendering
+  // the same slice. Instead, we choose to use the parallel normals to filter
+  // the annotations and later we fine tune it with the annotation within slice
+  // logic down below.
+  const annotationsWithParallelNormals = annotations.filter(
+    (td: Annotation) => {
+      let annotationViewPlaneNormal = td.metadata.viewPlaneNormal;
+
+      if (!annotationViewPlaneNormal) {
+        // This code is run to set the annotation view plane normal
+        // for historical data which was saved without the normal.
+        const { referencedImageId } = td.metadata;
+        const { imageOrientationPatient } = metaData.get(
+          'imagePlaneModule',
+          referencedImageId
+        );
+        const rowCosineVec = vec3.fromValues(
+          imageOrientationPatient[0],
+          imageOrientationPatient[1],
+          imageOrientationPatient[2]
+        );
+
+        const colCosineVec = vec3.fromValues(
+          imageOrientationPatient[3],
+          imageOrientationPatient[4],
+          imageOrientationPatient[5]
+        );
+
+        annotationViewPlaneNormal = vec3.create() as Types.Point3;
+
+        vec3.cross(annotationViewPlaneNormal, rowCosineVec, colCosineVec);
+        td.metadata.viewPlaneNormal = annotationViewPlaneNormal;
+      }
+      const isParallel =
+        Math.abs(vec3.dot(viewPlaneNormal, annotationViewPlaneNormal)) >
+        PARALLEL_THRESHOLD;
+
+      return annotationViewPlaneNormal && isParallel;
+    }
+  );
+
+  // No in plane annotations.
+  if (!annotationsWithParallelNormals.length) {
+    return [];
+  }
+
+  return annotationsWithParallelNormals;
+}

package/src/utilities/planar/index.ts

@@ -3,6 +3,7 @@ import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorne
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
 import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
 import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
+import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 
 export default {
   filterAnnotationsWithinSlice,
@@ -10,6 +11,7 @@ export default {
   filterAnnotationsForDisplay,
   getPointInLineOfSightWithCriteria,
   isPlaneIntersectingAABB,
+  filterAnnotationsWithinSamePlane,
 };
 
 export {
@@ -18,4 +20,5 @@ export {
   filterAnnotationsForDisplay,
   getPointInLineOfSightWithCriteria,
   isPlaneIntersectingAABB,
+  filterAnnotationsWithinSamePlane,
 };

package/src/utilities/stackPrefetch/stackContextPrefetch.ts

@@ -64,7 +64,10 @@ const resetPrefetchDelay = 5;
 const enable = (element): void => {
   const stack = getStackData(element);
 
-  if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+  if (!stack) {
+    return;
+  }
+  if (!stack.imageIds?.length) {
     console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
     return;
   }
@@ -90,6 +93,9 @@ const enable = (element): void => {
 
 function prefetch(element) {
   const stack = getStackData(element);
+  if (!stack) {
+    return;
+  }
   if (!stack?.imageIds?.length) {
     console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
     return;
@@ -273,7 +279,11 @@ const signum = (x) => (x < 0 ? -1 : 1);
 
 const updateToolState = (element, usage?: number) => {
   const stack = getStackData(element);
-  if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+  if (!stack) {
+    // Other viewport type - no message
+    return;
+  }
+  if (!stack.imageIds?.length) {
     console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
     return;
   }

package/src/utilities/stackPrefetch/stackPrefetchUtils.ts

@@ -1,4 +1,10 @@
-import { getEnabledElement, StackViewport, Enums } from '@cornerstonejs/core';
+import {
+  getEnabledElement,
+  StackViewport,
+  Enums,
+  VideoViewport,
+  WSIViewport,
+} from '@cornerstonejs/core';
 import { getToolState } from './state';
 
 export const requestType = Enums.RequestType.Prefetch;
@@ -54,10 +60,6 @@ export function getStackData(element) {
   if (!(viewport instanceof StackViewport)) {
     // we shouldn't throw error here, since the viewport might have
     // changed from stack to volume during prefetch
-    console.warn(
-      'stackPrefetch: element must be a StackViewport, VolumeViewport stackPrefetch not yet implemented'
-    );
-
     return null;
   }
 

package/src/utilities/viewport/isViewportPreScaled.ts

@@ -3,6 +3,7 @@ import {
   StackViewport,
   Types,
   BaseVolumeViewport,
+  utilities,
 } from '@cornerstonejs/core';
 
 function isViewportPreScaled(
@@ -10,11 +11,7 @@ function isViewportPreScaled(
   targetId: string
 ): boolean {
   if (viewport instanceof BaseVolumeViewport) {
-    const targetIdTokens = targetId.split('volumeId:');
-    const volumeId =
-      targetIdTokens.length > 1
-        ? targetIdTokens[1].split('?')[0]
-        : targetIdTokens[0];
+    const volumeId = utilities.getVolumeId(targetId);
     const volume = cache.getVolume(volumeId);
     return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
   } else if (viewport instanceof StackViewport) {

package/src/utilities/viewport/jumpToSlice.ts

@@ -54,11 +54,11 @@ function _getImageSliceData(
         ? viewport.getTargetImageIdIndex()
         : viewport.getCurrentImageIdIndex(),
     };
-  } else if (viewport instanceof VolumeViewport) {
-    return csUtils.getImageSliceDataForVolumeViewport(viewport);
-  } else {
-    throw new Error('Unsupported viewport type');
   }
+  return {
+    numberOfSlices: viewport.getNumberOfSlices(),
+    imageIndex: viewport.getSliceIndex(),
+  };
 }
 
 function _getImageIndexToJump(