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

package/src/tools/segmentation/strategies/eraseSphere.ts

@@ -4,6 +4,7 @@ import { fillInsideSphere } from './fillSphere';
 
 type OperationData = {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+  imageVolume: Types.IImageVolume;
   volume: Types.IImageVolume;
   segmentIndex: number;
   segmentationId: string;
@@ -11,6 +12,7 @@ type OperationData = {
   viewPlaneNormal: Types.Point3;
   viewUp: Types.Point3;
   constraintFn: () => boolean;
+  strategySpecificConfiguration: any;
 };
 
 export function eraseInsideSphere(

package/src/tools/segmentation/strategies/fillCircle.ts

@@ -9,6 +9,7 @@ import {
 import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { pointInShapeCallback } from '../../../utilities';
+import isWithinThreshold from './utils/isWithinThreshold';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -117,19 +118,6 @@ function fillCircle(
   triggerSegmentationDataModified(segmentationId, arrayOfSlices);
 }
 
-function isWithinThreshold(
-  index: number,
-  imageVolume: Types.IImageVolume,
-  strategySpecificConfiguration: any
-) {
-  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
-
-  const voxelValue = imageVolume.getScalarData()[index];
-  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
-
-  return threshold[0] <= voxelValue && voxelValue <= threshold[1];
-}
-
 /**
  * Fill inside the circular region segment inside the segmentation defined by the operationData.
  * It fills the segmentation pixels inside the defined circle.

package/src/tools/segmentation/strategies/fillSphere.ts

@@ -1,29 +1,36 @@
 import type { Types } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
 
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { pointInSurroundingSphereCallback } from '../../../utilities';
+import isWithinThreshold from './utils/isWithinThreshold';
 
 type OperationData = {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
   volume: Types.IImageVolume;
+  imageVolume: Types.IImageVolume;
   segmentIndex: number;
   segmentationId: string;
   segmentsLocked: number[];
   viewPlaneNormal: Types.Point3;
   viewUp: Types.Point3;
+  strategySpecificConfiguration: any;
   constraintFn: () => boolean;
 };
 
 function fillSphere(
   enabledElement: Types.IEnabledElement,
   operationData: OperationData,
-  _inside = true
+  _inside = true,
+  threshold = false
 ): void {
   const { viewport } = enabledElement;
   const {
     volume: segmentation,
     segmentsLocked,
     segmentIndex,
+    imageVolume,
+    strategySpecificConfiguration,
     segmentationId,
     points,
   } = operationData;
@@ -32,13 +39,30 @@ function fillSphere(
   const scalarData = segmentation.getScalarData();
   const scalarIndex = [];
 
-  const callback = ({ index, value }) => {
-    if (segmentsLocked.includes(value)) {
-      return;
-    }
-    scalarData[index] = segmentIndex;
-    scalarIndex.push(index);
-  };
+  let callback;
+
+  if (threshold) {
+    callback = ({ value, index, pointIJK }) => {
+      if (segmentsLocked.includes(value)) {
+        return;
+      }
+
+      if (
+        isWithinThreshold(index, imageVolume, strategySpecificConfiguration)
+      ) {
+        scalarData[index] = segmentIndex;
+        scalarIndex.push(index);
+      }
+    };
+  } else {
+    callback = ({ index, value }) => {
+      if (segmentsLocked.includes(value)) {
+        return;
+      }
+      scalarData[index] = segmentIndex;
+      scalarIndex.push(index);
+    };
+  }
 
   pointInSurroundingSphereCallback(
     imageData,
@@ -74,6 +98,30 @@ export function fillInsideSphere(
   fillSphere(enabledElement, operationData, true);
 }
 
+/**
+ * Fill inside the circular region segment inside the segmentation defined by the operationData.
+ * It fills the segmentation pixels inside the defined circle.
+ * @param enabledElement - The element for which the segment is being filled.
+ * @param operationData - EraseOperationData
+ */
+export function thresholdInsideSphere(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  const { volume, imageVolume } = operationData;
+
+  if (
+    !csUtils.isEqual(volume.dimensions, imageVolume.dimensions) ||
+    !csUtils.isEqual(volume.direction, imageVolume.direction)
+  ) {
+    throw new Error(
+      'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
+    );
+  }
+
+  fillSphere(enabledElement, operationData, true, true);
+}
+
 /**
  * Fill outside a sphere with the given segment index in the given operation data. The
  * operation data contains the sphere required points.

package/src/tools/segmentation/strategies/utils/isWithinThreshold.ts

@@ -0,0 +1,16 @@
+import { Types } from '@cornerstonejs/core';
+
+function isWithinThreshold(
+  index: number,
+  imageVolume: Types.IImageVolume,
+  strategySpecificConfiguration: any
+) {
+  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+
+  const voxelValue = imageVolume.getScalarData()[index];
+  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
+
+  return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+}
+
+export default isWithinThreshold;

package/src/types/CINETypes.ts

@@ -1,5 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-
 type PlayClipOptions = {
   framesPerSecond?: number;
   frameTimeVector?: number[];
@@ -7,6 +5,11 @@ type PlayClipOptions = {
   loop?: boolean;
   dynamicCineEnabled?: boolean;
   frameTimeVectorSpeedMultiplier?: number;
+  // How many CINE frames to wait for a rendered event to occur before
+  // trying to display the image after the next one
+  // A CINE frame is attempted every 1 / fps seconds
+  // The default is 30 tries, or 1.25 seconds at 24 fps
+  waitForRendered?: number;
 };
 
 interface ToolData {
@@ -26,6 +29,9 @@ type CinePlayContext = {
   get numScrollSteps(): number;
   get currentStepIndex(): number;
   get frameTimeVectorEnabled(): boolean;
+  // How many times has the wait for rendered been tried without showing
+  // the next image.
+  waitForRenderedCount?: number;
   scroll(delta: number): void;
 };
 

package/src/types/CalculatorTypes.ts

@@ -0,0 +1,7 @@
+type Statistics = {
+  name: string;
+  value: number;
+  unit: null | string;
+};
+
+export type { Statistics };

package/src/types/EventTypes.ts

@@ -3,7 +3,9 @@ import { Annotation } from './AnnotationTypes';
 import IPoints from './IPoints';
 import ITouchPoints from './ITouchPoints';
 import IDistance from './IDistance';
+import { SetToolBindingsType } from './ISetToolModeOptions';
 import { Swipe } from '../enums/Touch';
+import { ToolModes } from '../enums';
 
 /**
  * The normalized interaction event detail
@@ -70,6 +72,32 @@ type InteractionStartEventDetail = InteractionEventDetail;
 
 type InteractionEndEventDetail = InteractionEventDetail;
 
+/**
+ * The data that is passed to the event handler when tool mode changes
+ */
+type ToolModeChangedEventDetail = {
+  /** unique id of the toolGroup */
+  toolGroupId: string;
+  /** Tool name */
+  toolName: string;
+  /** Tool mode */
+  mode: ToolModes;
+  /** Tool binding options */
+  toolBindingsOptions?: SetToolBindingsType;
+};
+
+/**
+ * The data that is passed to the event handler when a tool is activated.
+ */
+type ToolActivatedEventDetail = {
+  /** unique id of the toolGroup */
+  toolGroupId: string;
+  /** Tool name */
+  toolName: string;
+  /** Tool binding options */
+  toolBindingsOptions: SetToolBindingsType;
+};
+
 /**
  * The data that is passed to the event handler when a new annotation is added
  * to the annotations.
@@ -411,6 +439,17 @@ type NormalizedMouseEventType = Types.CustomEventType<MouseCustomEventDetail>;
  */
 type NormalizedTouchEventType = Types.CustomEventType<TouchCustomEventDetail>;
 
+/**
+ * The ToolModeChanged event type
+ */
+type ToolModeChangedEventType =
+  Types.CustomEventType<ToolModeChangedEventDetail>;
+
+/**
+ * The ToolActivated event type
+ */
+type ToolActivatedEventType = Types.CustomEventType<ToolActivatedEventDetail>;
+
 /**
  * The AnnotationAdded event type
  */
@@ -611,6 +650,10 @@ export {
   NormalizedInteractionEventDetail,
   NormalizedMouseEventType,
   NormalizedTouchEventType,
+  ToolModeChangedEventDetail,
+  ToolModeChangedEventType,
+  ToolActivatedEventDetail,
+  ToolActivatedEventType,
   AnnotationAddedEventDetail,
   AnnotationAddedEventType,
   AnnotationCompletedEventDetail,

package/src/types/ISetToolModeOptions.ts

@@ -1,9 +1,9 @@
 import { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
 
-type ToolBindingMouseType = typeof MouseBindings[keyof typeof MouseBindings];
+type ToolBindingMouseType = (typeof MouseBindings)[keyof typeof MouseBindings];
 
 type ToolBindingKeyboardType =
-  typeof KeyboardBindings[keyof typeof KeyboardBindings];
+  (typeof KeyboardBindings)[keyof typeof KeyboardBindings];
 
 type IToolBinding = {
   /** Mouse button bindings e.g., MouseBindings.Primary/Secondary etc. */

package/src/types/IToolGroup.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
 import { MouseBindings } from '../enums';
+import { ToolConfiguration } from '../types';
 /**
  * ToolGroup interface
  */
@@ -19,8 +20,10 @@ export default interface IToolGroup {
   getViewportsInfo: () => Array<Types.IViewportId>;
   /** Get the toolInstance of the toolName */
   getToolInstance: { (toolName: string): any };
-  /** Add a tool to toolGroup with its configuration */
-  addTool: { (toolName: string, toolConfiguration?: any): void };
+  /** Add a tool to toolGroup with its configuration and custom calculator if wanted */
+  addTool: {
+    (toolName: string, toolConfiguration?: ToolConfiguration): void;
+  };
   /** Add tool instance, if you want to create more than one instance from the same tool e.g., brush/eraser tool */
   addToolInstance: {
     (ttoolName: string, parentClassName: string, configuration?: any): void;
@@ -62,7 +65,7 @@ export default interface IToolGroup {
   setToolConfiguration: {
     (
       toolName: string,
-      configuration: Record<any, any>,
+      configuration: ToolConfiguration,
       overwrite?: boolean
     ): void;
   };
@@ -72,4 +75,11 @@ export default interface IToolGroup {
   getDefaultMousePrimary: {
     (): MouseBindings;
   };
+
+  clone: {
+    (
+      newToolGroupId: string,
+      fnToolFilter: (toolName: string) => boolean
+    ): IToolGroup;
+  };
 }

package/src/types/ToolAction.ts

@@ -0,0 +1,54 @@
+import type { Annotation } from './AnnotationTypes';
+import type { InteractionEventType } from './EventTypes';
+import type { SetToolBindingsType } from './ISetToolModeOptions';
+
+/**
+ * An action that may be defined at the tool configuration level
+ *
+ * Annotations can have actions that run a specific task (ex: showing a dropdown
+ * containing a list of all predefined zoom levels - advanced magnifier glass).
+ * Each action must have at least one binding option (mouse button + [modifier(s)])
+ * and a action runs if and only if no other tool is using that same binding options
+ * to draw an annotation because action has lower priority.
+ *
+ * Actions are defined in the following way in a annotation tool constructor:
+ *
+ * class MyAnnotationTool extends AnnotationTool {
+ *   constructor(
+ *     toolProps: PublicToolProps = {},
+ *     defaultToolProps: ToolProps = {
+ *       configuration: {
+ *         actions: [
+ *           {
+ *             method: 'myAction',
+ *             bindings: [
+ *               {
+ *                 mouseButton: MouseBindings.Secondary,
+ *                 modifierKey: KeyboardBindings.Shift,
+ *               }
+ *             ]
+ *           }
+ *         ]
+ *       }
+ *     }
+ *   ) {
+ *     super(toolProps, defaultToolProps);
+ *   }
+ *
+ *   public myAction(evt: EventTypes.InteractionEventType, annotation: MyAnnotation) {
+ *     // action code
+ *   }
+ * }
+ *
+ * The "method" property may be a string or a javascript function. In case it is
+ * a string a function with same name must exists in the tool class. In both ways
+ * (string or function) the function is called in the tool's context (`this`)
+ */
+type ToolAction = {
+  method:
+    | string
+    | ((evt: InteractionEventType, annotation: Annotation) => void);
+  bindings: SetToolBindingsType[];
+};
+
+export default ToolAction;

package/src/types/ToolProps.ts

@@ -1,8 +1,14 @@
+import { Calculator } from '../utilities/math/basic';
+
 type SharedToolProp = {
   /** supported interactions for the tool */
   supportedInteractionTypes?: Array<string>;
   /** tool specific tool configuration */
-  configuration?: Record<string, any>;
+  configuration?: ToolConfiguration;
+};
+
+export type ToolConfiguration = Record<string, any> & {
+  statsCalculator?: Calculator;
 };
 
 export type ToolProps = SharedToolProp;

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -78,6 +78,18 @@ export interface LengthAnnotation extends Annotation {
   };
 }
 
+export interface AdvancedMagnifyAnnotation extends Annotation {
+  data: {
+    zoomFactor: number;
+    sourceViewportId: string;
+    magnifyViewportId: string;
+    handles: {
+      points: Types.Point3[]; // [top, right, bottom, left]
+      activeHandleIndex: number | null;
+    };
+  };
+}
+
 export interface CircleROIAnnotation extends Annotation {
   data: {
     handles: {
@@ -261,6 +273,7 @@ export interface ArrowAnnotation extends Annotation {
     };
   };
 }
+
 export interface AngleAnnotation extends Annotation {
   data: {
     handles: {
@@ -286,6 +299,51 @@ export interface AngleAnnotation extends Annotation {
   };
 }
 
+export interface CobbAngleAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats: {
+      [targetId: string]: {
+        angle: number;
+        arc1Angle: number;
+        arc2Angle: number;
+        points: {
+          world: {
+            arc1Start: Types.Point3;
+            arc1End: Types.Point3;
+            arc2Start: Types.Point3;
+            arc2End: Types.Point3;
+            arc1Angle: number;
+            arc2Angle: number;
+          };
+          canvas: {
+            arc1Start: Types.Point2;
+            arc1End: Types.Point2;
+            arc2Start: Types.Point2;
+            arc2End: Types.Point2;
+            arc1Angle: number;
+            arc2Angle: number;
+          };
+        };
+      };
+    };
+  };
+}
+
 export interface ReferenceCursor extends Annotation {
   data: {
     handles: {

package/src/types/index.ts

@@ -21,7 +21,12 @@ import type * as AnnotationStyle from './AnnotationStyle';
 import type ToolHandle from './ToolHandle';
 import type { AnnotationHandle, TextBoxHandle } from './ToolHandle';
 import type InteractionTypes from './InteractionTypes';
-import type { ToolProps, PublicToolProps } from './ToolProps';
+import type ToolAction from './ToolAction';
+import type {
+  ToolProps,
+  PublicToolProps,
+  ToolConfiguration,
+} from './ToolProps';
 import type { SVGCursorDescriptor, SVGPoint } from './CursorTypes';
 import type JumpToSliceOptions from './JumpToSliceOptions';
 import type ScrollOptions from './ScrollOptions';
@@ -52,6 +57,7 @@ import IToolClassReference from './IToolClassReference';
 import { ContourSegmentationData } from './ContourTypes';
 import IAnnotationManager from './IAnnotationManager';
 import AnnotationGroupSelector from './AnnotationGroupSelector';
+import { Statistics } from './CalculatorTypes';
 
 export type {
   // AnnotationState
@@ -68,6 +74,7 @@ export type {
   PlanarBoundingBox,
   ToolProps,
   PublicToolProps,
+  ToolConfiguration,
   // Event data
   EventTypes,
   IPoints,
@@ -78,6 +85,7 @@ export type {
   SetToolBindingsType,
   ToolOptionsType,
   InteractionTypes,
+  ToolAction,
   //
   IToolGroup,
   IToolClassReference,
@@ -114,4 +122,6 @@ export type {
   FloodFillOptions,
   // Contour
   ContourSegmentationData,
+  //Statistics
+  Statistics,
 };

package/src/utilities/cine/playClip.ts

@@ -6,6 +6,7 @@ import {
   VolumeViewport,
   cache,
   BaseVolumeViewport,
+  Enums,
 } from '@cornerstonejs/core';
 
 import { Types } from '@cornerstonejs/core';
@@ -14,6 +15,7 @@ import { addToolState, getToolState } from './state';
 import { CINETypes } from '../../types';
 import scroll from '../scroll';
 
+const { ViewportStatus } = Enums;
 const { triggerEvent } = csUtils;
 
 const debounced = true;
@@ -193,7 +195,9 @@ function stopClip(element: HTMLDivElement): void {
 
 function _stopClip(element: HTMLDivElement, stopDynamicCine: boolean): void {
   const enabledElement = getEnabledElement(element);
-  if (!enabledElement) return;
+  if (!enabledElement) {
+    return;
+  }
   const { viewport } = enabledElement;
   const cineToolData = getToolState(viewport.element);
 
@@ -313,7 +317,8 @@ function _getVolumeFromViewport(viewport): Types.IImageVolume {
 }
 
 function _createStackViewportCinePlayContext(
-  viewport: StackViewport
+  viewport: StackViewport,
+  waitForRendered: number
 ): CINETypes.CinePlayContext {
   const imageIds = viewport.getImageIds();
 
@@ -328,7 +333,16 @@ function _createStackViewportCinePlayContext(
       // 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 });
     },
   };
@@ -417,7 +431,10 @@ function _createCinePlayContext(
   playClipOptions: CINETypes.PlayClipOptions
 ): CINETypes.CinePlayContext {
   if (viewport instanceof StackViewport) {
-    return _createStackViewportCinePlayContext(viewport);
+    return _createStackViewportCinePlayContext(
+      viewport,
+      playClipOptions.waitForRendered ?? 30
+    );
   }
 
   if (viewport instanceof VolumeViewport) {

package/src/utilities/dynamicVolume/getDataInTime.ts

@@ -40,13 +40,16 @@ function getDataInTime(
 
   if (options.maskVolumeId) {
     const segmentationVolume = cache.getVolume(options.maskVolumeId);
+    const segScalarData = segmentationVolume.getScalarData();
+    const indexArray = [];
+
+    // Get the index of every non-zero voxel in mask
+    for (let i = 0, len = segScalarData.length; i < len; i++) {
+      if (segScalarData[i] !== 0) {
+        indexArray.push(i);
+      }
+    }
 
-    // Get the index of every non-zero voxel in mask by mapping indexes to
-    // new array, then using the array to filter
-    const indexArray = segmentationVolume
-      .getScalarData()
-      .map((_, i) => i)
-      .filter((i) => segmentationVolume.getScalarData()[i] !== 0);
     const dataInTime = _getTimePointDataMask(frames, indexArray, dynamicVolume);
 
     return dataInTime;

package/src/utilities/getCalibratedUnits.ts

@@ -23,10 +23,16 @@ const getCalibratedLengthUnits = (handles, image): string => {
   const { calibration, hasPixelSpacing } = image;
   // Anachronistic - moving to using calibration consistently, but not completed yet
   const units = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-  if (!calibration || !calibration.type) return units;
-  if (calibration.type === CalibrationTypes.UNCALIBRATED) return PIXEL_UNITS;
+  if (!calibration || !calibration.type) {
+    return units;
+  }
+  if (calibration.type === CalibrationTypes.UNCALIBRATED) {
+    return PIXEL_UNITS;
+  }
   // TODO - handle US regions properly
-  if (calibration.SequenceOfUltrasoundRegions) return 'US Region';
+  if (calibration.SequenceOfUltrasoundRegions) {
+    return 'US Region';
+  }
   return `${units} ${calibration.type}`;
 };
 
@@ -37,8 +43,12 @@ const SQUARE = '\xb2';
 const getCalibratedAreaUnits = (handles, image): string => {
   const { calibration, hasPixelSpacing } = image;
   const units = (hasPixelSpacing ? 'mm' : PIXEL_UNITS) + SQUARE;
-  if (!calibration || !calibration.type) return units;
-  if (calibration.SequenceOfUltrasoundRegions) return 'US Region';
+  if (!calibration || !calibration.type) {
+    return units;
+  }
+  if (calibration.SequenceOfUltrasoundRegions) {
+    return 'US Region';
+  }
   return `${units} ${calibration.type}`;
 };
 

package/src/utilities/getModalityUnit.ts

@@ -28,8 +28,14 @@ function _handlePTModality(imageId: string, options: ModalityUnitOptions) {
     return 'SUV';
   }
 
-  const petSeriesModule = metaData.get('petSeriesModule', imageId);
-  return petSeriesModule?.units || 'unitless';
+  const generalSeriesModule = metaData.get('generalSeriesModule', imageId);
+
+  // it might be possible that the referenceImageId is not the one
+  // that is being displayed. So we need to get the modality from imageId again
+  if (generalSeriesModule?.modality === 'PT') {
+    const petSeriesModule = metaData.get('petSeriesModule', imageId);
+    return petSeriesModule?.units || 'unitless';
+  }
 }
 
 export { getModalityUnit, ModalityUnitOptions };

package/src/utilities/index.ts

@@ -29,7 +29,7 @@ import * as cine from './cine';
 import * as boundingBox from './boundingBox';
 import * as planarFreehandROITool from './planarFreehandROITool';
 import * as rectangleROITool from './rectangleROITool';
-import * as stackPrefetch from './stackPrefetch';
+import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
 import * as viewport from './viewport';
 import * as touch from './touch';
 import * as dynamicVolume from './dynamicVolume';
@@ -65,6 +65,7 @@ export {
   rectangleROITool,
   planarFreehandROITool,
   stackPrefetch,
+  stackContextPrefetch,
   scroll,
   roundNumber,
 };