@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.2

package/src/synchronizers/callbacks/stackImageSyncCallback.ts

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import { vec3, mat4 } from 'gl-matrix';
 import {
   getRenderingEngine,
   Types,
@@ -8,28 +8,27 @@ import {
 import { Synchronizer } from '../../store';
 import { jumpToSlice } from '../../utilities';
 import areViewportsCoplanar from './areViewportsCoplanar ';
+
+const getSpatialRegistration = (targetId, sourceId) =>
+  utilities.spatialRegistrationMetadataProvider.get(
+    'spatialRegistrationModule',
+    [targetId, sourceId]
+  );
+
 /**
  * Synchronizer callback to synchronize the source viewport image to the
- * target viewports closest image in its stack. There are two scenarios
+ * target viewports closest image in its stack.
  *
- * 1) viewports are in the same frameOfReferenceUID then we can use the
- * absolute imagePositionPatient for the source viewport's current image
- * and set the target viewport's image to the closest image in its stack
- * (which might have different slice thickness so cannot use slice number)
+ * This synchronizer does a setup (which can already be predefined as required)
+ * to register the target and soruce viewports.  The registration will default
+ * to the identity registration if the same FOR is present in both viewports,
+ * unless the option `useInitialPosition` is set in the target viewport.
  *
- * 2) viewports have different frameOfReferenceUIDs then we look inside the
- * registrationMetadataProvider to check if there is a corresponding matrix
- * for mapping between the source and target viewport if so it is used to
- * and is applied to the imagePositionPatient of the source viewport's to
- * get the imagePositionPatient of the target viewport's closest image in
- * its stack.
- * Note for 2) The consuming apps using Cornerstone3D (OHIF, etc) are responsible
- * to provide such data in the registrationMetadataProvider. This can be done
+ * The consuming apps using Cornerstone3D (OHIF, etc) MAY provide such data in
+ * the registrationMetadataProvider to override the data here. This can be done
  * by various methods 1) Using spatialRegistrationModule inside dicom 2) assuming
  * the user has actually manually scrolled the target viewport to the correct
  * slice before initiating the synchronization 3) using some other method
- * But overall, the consuming app is responsible for providing the data.
- *
  *
  * @param synchronizerInstance - The Instance of the Synchronizer
  * @param sourceViewport - The list of IDs defining the source viewport.
@@ -53,13 +52,16 @@ export default async function stackImageSyncCallback(
     sourceViewport.viewportId
   ) as Types.IStackViewport;
 
+  const options = synchronizerInstance.getOptions(targetViewport.viewportId);
+
+  if (options?.disabled) {
+    return;
+  }
+
   const tViewport = renderingEngine.getViewport(
     targetViewport.viewportId
   ) as Types.IStackViewport;
 
-  const frameOfReferenceUID1 = sViewport.getFrameOfReferenceUID();
-  const frameOfReferenceUID2 = tViewport.getFrameOfReferenceUID();
-
   const imageId1 = sViewport.getCurrentImageId();
   const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
   const sourceImagePositionPatient = imagePlaneModule1.imagePositionPatient;
@@ -70,69 +72,62 @@ export default async function stackImageSyncCallback(
     return;
   }
 
-  if (frameOfReferenceUID1 === frameOfReferenceUID2) {
-    // if frames of references are the same we can use the absolute
-    // imagePositionPatient to find the closest image in the target viewport's stack
-    const closestImageIdIndex = _getClosestImageIdIndex(
-      sourceImagePositionPatient,
-      targetImageIds
-    );
+  // if the frame of reference is different we need to use the registrationMetadataProvider
+  // and add that to the imagePositionPatient of the source viewport to get the
+  // imagePositionPatient of the target viewport's closest image in its stack
+  let registrationMatrixMat4 = getSpatialRegistration(
+    targetViewport.viewportId,
+    sourceViewport.viewportId
+  );
 
+  if (!registrationMatrixMat4) {
+    const frameOfReferenceUID1 = sViewport.getFrameOfReferenceUID();
+    const frameOfReferenceUID2 = tViewport.getFrameOfReferenceUID();
     if (
-      closestImageIdIndex.index !== -1 &&
-      tViewport.getCurrentImageIdIndex() !== closestImageIdIndex.index
+      frameOfReferenceUID1 === frameOfReferenceUID2 &&
+      options.useInitialPosition !== false
     ) {
-      // await tViewport.setImageIdIndex(closestImageIdIndex.index);
-      await jumpToSlice(tViewport.element, {
-        imageIndex: closestImageIdIndex.index,
-      });
-
-      return;
-    }
-  } else {
-    // if the frame of reference is different we need to use the registrationMetadataProvider
-    // and add that to the imagePositionPatient of the source viewport to get the
-    // imagePositionPatient of the target viewport's closest image in its stack
-    const registrationMatrixMat4 =
-      utilities.spatialRegistrationMetadataProvider.get(
-        'spatialRegistrationModule',
-        [targetViewport.viewportId, sourceViewport.viewportId]
+      registrationMatrixMat4 = mat4.identity(mat4.create());
+    } else {
+      utilities.calculateViewportsSpatialRegistration(sViewport, tViewport);
+      registrationMatrixMat4 = getSpatialRegistration(
+        targetViewport.viewportId,
+        sourceViewport.viewportId
       );
-
+    }
     if (!registrationMatrixMat4) {
-      throw new Error(
-        `No registration matrix found for sourceViewport: ${sourceViewport.viewportId} and targetViewport: ${targetViewport.viewportId}, viewports with different frameOfReferenceUIDs must have a registration matrix in the registrationMetadataProvider. Use calculateViewportsRegistrationMatrix to calculate the matrix.`
-      );
+      return;
     }
+  }
 
-    // apply the registration matrix to the source viewport's imagePositionPatient
-    // to get the target viewport's imagePositionPatient
-    const targetImagePositionPatientWithRegistrationMatrix = vec3.transformMat4(
-      vec3.create(),
-      sourceImagePositionPatient,
-      registrationMatrixMat4
-    );
+  // apply the registration matrix to the source viewport's imagePositionPatient
+  // to get the target viewport's imagePositionPatient
+  const targetImagePositionPatientWithRegistrationMatrix = vec3.transformMat4(
+    vec3.create(),
+    sourceImagePositionPatient,
+    registrationMatrixMat4
+  );
 
-    // find the closest image in the target viewport's stack to the
-    // targetImagePositionPatientWithRegistrationMatrix
-    const closestImageIdIndex2 = _getClosestImageIdIndex(
-      targetImagePositionPatientWithRegistrationMatrix,
-      targetImageIds
-    );
+  // find the closest image in the target viewport's stack to the
+  // targetImagePositionPatientWithRegistrationMatrix
+  const closestImageIdIndex2 = _getClosestImageIdIndex(
+    targetImagePositionPatientWithRegistrationMatrix,
+    targetImageIds
+  );
 
-    if (
-      closestImageIdIndex2.index !== -1 &&
-      tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index
-    ) {
-      await jumpToSlice(tViewport.element, {
-        imageIndex: closestImageIdIndex2.index,
-      });
-    }
+  if (
+    closestImageIdIndex2.index !== -1 &&
+    tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index
+  ) {
+    await jumpToSlice(tViewport.element, {
+      imageIndex: closestImageIdIndex2.index,
+    });
   }
 }
 
 function _getClosestImageIdIndex(targetPoint, imageIds) {
   // todo: this does not assume orientation yet, but that can be added later
+  // todo: handle multiframe images
   return imageIds.reduce(
     (closestImageIdIndex, imageId, index) => {
       const { imagePositionPatient } = metaData.get(

package/src/synchronizers/callbacks/voiSyncCallback.ts

@@ -39,7 +39,7 @@ export default function voiSyncCallback(
     voiRange: range,
   };
 
-  if (options.syncInvertState && invertStateChanged) {
+  if (options?.syncInvertState && invertStateChanged) {
     tProperties.invert = invert;
   }
 

package/src/tools/MIPJumpToClickTool.ts

@@ -80,9 +80,13 @@ class MIPJumpToClickTool extends BaseTool {
     const { targetViewportIds, toolGroupId } = this.configuration;
     // TODO - consider making this a utility
     const viewports = renderingEngine.getViewports().filter((vp) => {
-      if (targetViewportIds?.indexOf(vp.id) >= 0) return true;
+      if (targetViewportIds?.indexOf(vp.id) >= 0) {
+        return true;
+      }
       const foundToolGroup = getToolGroupForViewport(vp.id, renderingEngine.id);
-      if (toolGroupId && toolGroupId === foundToolGroup?.id) return true;
+      if (toolGroupId && toolGroupId === foundToolGroup?.id) {
+        return true;
+      }
       return false;
     });
 

package/src/tools/PlanarRotateTool.ts

@@ -56,7 +56,9 @@ class PlanarRotateTool extends BaseTool {
       angle = -angle;
     }
 
-    if (Number.isNaN(angle)) return;
+    if (Number.isNaN(angle)) {
+      return;
+    }
 
     if (viewport instanceof BaseVolumeViewport) {
       const rotAngle = (angle * Math.PI) / 180;

package/src/tools/ReferenceCursors.ts

@@ -104,26 +104,38 @@ class ReferenceCursors extends AnnotationDisplayTool {
 
   onSetToolActive(): void {
     this._disableCursorEnabled = this.configuration.disableCursor;
-    if (!this._disableCursorEnabled) return;
+    if (!this._disableCursorEnabled) {
+      return;
+    }
     const viewportIds = getToolGroup(this.toolGroupId).viewportsInfo;
-    if (!viewportIds) return;
+    if (!viewportIds) {
+      return;
+    }
     const enabledElements = viewportIds.map((e) =>
       getEnabledElementByIds(e.viewportId, e.renderingEngineId)
     );
 
     enabledElements.forEach((element) => {
-      if (element) hideElementCursor(element.viewport.element);
+      if (element) {
+        hideElementCursor(element.viewport.element);
+      }
     });
   }
   onSetToolDisabled(): void {
-    if (!this._disableCursorEnabled) return;
+    if (!this._disableCursorEnabled) {
+      return;
+    }
     const viewportIds = getToolGroup(this.toolGroupId).viewportsInfo;
-    if (!viewportIds) return;
+    if (!viewportIds) {
+      return;
+    }
     const enabledElements = viewportIds.map((e) =>
       getEnabledElementByIds(e.viewportId, e.renderingEngineId)
     );
     enabledElements.forEach((element) => {
-      if (element) resetElementCursor(element.viewport.element);
+      if (element) {
+        resetElementCursor(element.viewport.element);
+      }
     });
   }
 
@@ -132,14 +144,18 @@ class ReferenceCursors extends AnnotationDisplayTool {
     element: HTMLDivElement
   ): void => {
     const enabledElement = getEnabledElement(element);
-    if (!enabledElement) throw new Error('No enabled element found');
+    if (!enabledElement) {
+      throw new Error('No enabled element found');
+    }
     const { viewport, renderingEngine } = enabledElement;
 
     this.isDrawing = true;
 
     const camera = viewport.getCamera();
     const { viewPlaneNormal, viewUp } = camera;
-    if (!viewPlaneNormal || !viewUp) throw new Error('Camera not found');
+    if (!viewPlaneNormal || !viewUp) {
+      throw new Error('Camera not found');
+    }
 
     const referencedImageId = this.getReferencedImageId(
       viewport,
@@ -181,10 +197,14 @@ class ReferenceCursors extends AnnotationDisplayTool {
 
     const annotations = getAnnotations(this.getToolName(), element);
 
-    if (annotations.length > 0) return null;
+    if (annotations.length > 0) {
+      return null;
+    }
     const annotationId = addAnnotation(annotation, element);
 
-    if (annotationId === null) return;
+    if (annotationId === null) {
+      return;
+    }
 
     const viewportIdsToRender = getViewportIdsWithToolToRender(
       element,
@@ -212,8 +232,12 @@ class ReferenceCursors extends AnnotationDisplayTool {
     annotation: Annotation
   ): void {
     const worldPos = this._currentCursorWorldPosition;
-    if (!worldPos) return;
-    if (!annotation.data?.handles?.points) return;
+    if (!worldPos) {
+      return;
+    }
+    if (!annotation.data?.handles?.points) {
+      return;
+    }
     annotation.data.handles.points = [[...worldPos]];
     annotation.invalidated = true;
 
@@ -223,7 +247,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       false
     );
     const enabledElement = getEnabledElement(element);
-    if (!enabledElement) return;
+    if (!enabledElement) {
+      return;
+    }
     const { renderingEngine } = enabledElement;
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
   }
@@ -238,7 +264,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       | Types.IStackViewport;
 
     //only react to changes for element with cursor, otherwise would cause infinite loop
-    if (element !== this._elementWithCursor) return;
+    if (element !== this._elementWithCursor) {
+      return;
+    }
     //check if camera moved along its normal
     const oldFocalPoint = previousCamera.focalPoint;
     const cameraNormal = camera.viewPlaneNormal;
@@ -247,14 +275,20 @@ class ReferenceCursors extends AnnotationDisplayTool {
     const deltaCameraFocalPoint: Types.Point3 = [0, 0, 0];
     vtkMath.subtract(newFocalPoint, oldFocalPoint, deltaCameraFocalPoint);
     //check if focal point changed
-    if (deltaCameraFocalPoint.reduce((a, b) => a + b, 0) === 0) return;
+    if (deltaCameraFocalPoint.reduce((a, b) => a + b, 0) === 0) {
+      return;
+    }
     //if nomrmal is perpendicular to focal point change, then we are not moving along the normal
     const dotProduct = vtkMath.dot(deltaCameraFocalPoint, cameraNormal);
     //dot product is 0 -> perpendicular
-    if (Math.abs(dotProduct) < 1e-2) return;
+    if (Math.abs(dotProduct) < 1e-2) {
+      return;
+    }
 
     //need to update the position of the annotation since camera changed
-    if (!this._currentCanvasPosition) return;
+    if (!this._currentCanvasPosition) {
+      return;
+    }
 
     const newWorldPos = viewport.canvasToWorld(this._currentCanvasPosition);
     this._currentCursorWorldPosition = newWorldPos;
@@ -267,15 +301,23 @@ class ReferenceCursors extends AnnotationDisplayTool {
     annotations: Annotations
   ): Annotations {
     //calculate distance of current viewport to annotation
-    if (!(annotations instanceof Array) || annotations.length === 0) return [];
+    if (!(annotations instanceof Array) || annotations.length === 0) {
+      return [];
+    }
     const annotation = annotations[0];
     const viewport = getEnabledElement(element)?.viewport;
-    if (!viewport) return [];
+    if (!viewport) {
+      return [];
+    }
     const camera = viewport.getCamera();
     const { viewPlaneNormal, focalPoint } = camera;
-    if (!viewPlaneNormal || !focalPoint) return [];
+    if (!viewPlaneNormal || !focalPoint) {
+      return [];
+    }
     const points = annotation.data?.handles?.points;
-    if (!(points instanceof Array) || points.length !== 1) return [];
+    if (!(points instanceof Array) || points.length !== 1) {
+      return [];
+    }
     const worldPos = points[0];
     const plane = utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
     const distance = utilities.planar.planeDistanceToPoint(plane, worldPos);
@@ -333,7 +375,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       const { handles } = data;
       const { points } = handles;
 
-      if (!annotationUID) return renderStatus;
+      if (!annotationUID) {
+        return renderStatus;
+      }
       styleSpecifier.annotationUID = annotationUID;
 
       const lineWidthBase = parseFloat(
@@ -347,7 +391,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
       const color = this.getStyle('color', styleSpecifier, annotation);
 
-      if (points[0].some((e) => isNaN(e))) return renderStatus;
+      if (points[0].some((e) => isNaN(e))) {
+        return renderStatus;
+      }
       const canvasCoordinates = points.map((p) =>
         viewport.worldToCanvas(p)
       ) as [Types.Point2];
@@ -414,8 +460,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
   ): void {
     const currentMousePosition = this._currentCursorWorldPosition;
 
-    if (!currentMousePosition || currentMousePosition.some((e) => isNaN(e)))
+    if (!currentMousePosition || currentMousePosition.some((e) => isNaN(e))) {
       return;
+    }
 
     if (viewport instanceof StackViewport) {
       const closestIndex = utilities.getClosestStackImageIndexForPoint(
@@ -423,12 +470,17 @@ class ReferenceCursors extends AnnotationDisplayTool {
         viewport
       );
 
-      if (closestIndex === null) return;
-      if (closestIndex !== viewport.getCurrentImageIdIndex())
+      if (closestIndex === null) {
+        return;
+      }
+      if (closestIndex !== viewport.getCurrentImageIdIndex()) {
         viewport.setImageIdIndex(closestIndex);
+      }
     } else if (viewport instanceof VolumeViewport) {
       const { focalPoint, viewPlaneNormal } = viewport.getCamera();
-      if (!focalPoint || !viewPlaneNormal) return;
+      if (!focalPoint || !viewPlaneNormal) {
+        return;
+      }
       const plane = utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
       const currentDistance = utilities.planar.planeDistanceToPoint(
         plane,
@@ -436,7 +488,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
         true
       );
 
-      if (Math.abs(currentDistance) < 0.5) return;
+      if (Math.abs(currentDistance) < 0.5) {
+        return;
+      }
       const normalizedViewPlane = vec3.normalize(
         vec3.create(),
         vec3.fromValues(...viewPlaneNormal)
@@ -456,7 +510,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       if (isInBounds) {
         viewport.setCamera({ focalPoint: newFocalPoint });
         const renderingEngine = viewport.getRenderingEngine();
-        if (renderingEngine) renderingEngine.renderViewport(viewport.id);
+        if (renderingEngine) {
+          renderingEngine.renderViewport(viewport.id);
+        }
       }
     }
   }

package/src/tools/ScaleOverlayTool.ts

@@ -72,7 +72,9 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
     // get viewports with tool enabled
     const viewportIds = getToolGroup(this.toolGroupId).viewportsInfo;
 
-    if (!viewportIds) return;
+    if (!viewportIds) {
+      return;
+    }
 
     // get enabled elements
     const enabledElements = viewportIds.map((e) =>

package/src/tools/annotation/AngleTool.ts

@@ -74,6 +74,7 @@ class AngleTool extends AnnotationTool {
       configuration: {
         shadow: true,
         preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
       },
     }
   ) {
@@ -219,8 +220,12 @@ class AngleTool extends AnnotationTool {
       [canvasCoords[0], canvasCoords[1]]
     );
 
-    if (distanceToPoint <= proximity) return true;
-    if (!point3) return false;
+    if (distanceToPoint <= proximity) {
+      return true;
+    }
+    if (!point3) {
+      return false;
+    }
 
     const canvasPoint3 = viewport.worldToCanvas(point3);
 
@@ -740,7 +745,22 @@ class AngleTool extends AnnotationTool {
         continue;
       }
 
-      const textLines = this._getTextLines(data, targetId);
+      const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+      if (!options.visibility) {
+        data.handles.textBox = {
+          hasMoved: false,
+          worldPosition: <Types.Point3>[0, 0, 0],
+          worldBoundingBox: {
+            topLeft: <Types.Point3>[0, 0, 0],
+            topRight: <Types.Point3>[0, 0, 0],
+            bottomLeft: <Types.Point3>[0, 0, 0],
+            bottomRight: <Types.Point3>[0, 0, 0],
+          },
+        };
+        continue;
+      }
+
+      const textLines = this.configuration.getTextLines(data, targetId);
 
       if (!data.handles.textBox.hasMoved) {
         // linked to the vertex by default
@@ -763,7 +783,7 @@ class AngleTool extends AnnotationTool {
         textBoxPosition,
         canvasCoordinates,
         {},
-        this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+        options
       );
 
       const { x: left, y: top, width, height } = boundingBox;
@@ -779,20 +799,6 @@ class AngleTool extends AnnotationTool {
     return renderStatus;
   };
 
-  // text line for the current active angle annotation
-  _getTextLines(data, targetId) {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { angle } = cachedVolumeStats;
-
-    if (angle === undefined) {
-      return;
-    }
-
-    const textLines = [`${roundNumber(angle)} ${String.fromCharCode(176)}`];
-
-    return textLines;
-  }
-
   _calculateCachedStats(annotation, renderingEngine, enabledElement) {
     const data = annotation.data;
     const { viewportId, renderingEngineId } = enabledElement;
@@ -817,7 +823,7 @@ class AngleTool extends AnnotationTool {
       );
 
       cachedStats[targetId] = {
-        angle,
+        angle: isNaN(angle) ? 'Incomplete Angle' : angle,
       };
     }
 
@@ -837,5 +843,18 @@ class AngleTool extends AnnotationTool {
   }
 }
 
+function defaultGetTextLines(data, targetId): string[] {
+  const cachedVolumeStats = data.cachedStats[targetId];
+  const { angle } = cachedVolumeStats;
+
+  if (angle === undefined) {
+    return;
+  }
+
+  const textLines = [`${roundNumber(angle)} ${String.fromCharCode(176)}`];
+
+  return textLines;
+}
+
 AngleTool.toolName = 'Angle';
 export default AngleTool;

package/src/tools/annotation/ArrowAnnotateTool.ts

@@ -776,6 +776,21 @@ class ArrowAnnotateTool extends AnnotationTool {
         continue;
       }
 
+      const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+      if (!options.visibility) {
+        data.handles.textBox = {
+          hasMoved: false,
+          worldPosition: <Types.Point3>[0, 0, 0],
+          worldBoundingBox: {
+            topLeft: <Types.Point3>[0, 0, 0],
+            topRight: <Types.Point3>[0, 0, 0],
+            bottomLeft: <Types.Point3>[0, 0, 0],
+            bottomRight: <Types.Point3>[0, 0, 0],
+          },
+        };
+        continue;
+      }
+
       // Need to update to sync w/ annotation while unlinked/not moved
       if (!data.handles.textBox.hasMoved) {
         // linked to the point that doesn't have the arrowhead by default
@@ -798,7 +813,7 @@ class ArrowAnnotateTool extends AnnotationTool {
         textBoxPosition,
         canvasCoordinates,
         {},
-        this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+        options
       );
 
       const { x: left, y: top, width, height } = boundingBox;