@cornerstonejs/tools 1.36.3 → 1.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.36.3",
+  "version": "1.37.1",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.36.3",
+    "@cornerstonejs/core": "^1.37.1",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
@@ -53,5 +53,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b6b6f9273ca4cff849336005d199c4b1b1570815"
+  "gitHead": "81e281d066bc2d92c2b7eb7cebbaae49da439fa8"
 }

package/src/drawingSvg/drawEllipse.ts

@@ -12,20 +12,20 @@ function drawEllipse(
   corner2: Types.Point2,
   options = {},
   dataId = ''
-){
-  const top: Types.Point2 = [ (corner1[0] + corner2[0]) / 2, corner1[1] ];
-  const bottom: Types.Point2 = [ (corner1[0] + corner2[0]) / 2, corner2[1] ];
-  const left: Types.Point2 = [ corner1[0], (corner1[1] + corner2[1]) / 2];
-  const right: Types.Point2 = [ corner2[0], (corner1[1] + corner2[1]) / 2];
+) {
+  const top: Types.Point2 = [(corner1[0] + corner2[0]) / 2, corner1[1]];
+  const bottom: Types.Point2 = [(corner1[0] + corner2[0]) / 2, corner2[1]];
+  const left: Types.Point2 = [corner1[0], (corner1[1] + corner2[1]) / 2];
+  const right: Types.Point2 = [corner2[0], (corner1[1] + corner2[1]) / 2];
 
   drawEllipseByCoordinates(
     svgDrawingHelper,
     annotationUID,
     ellipseUID,
     [bottom, top, left, right],
-    options = {},
-    dataId = ''
-  )
+    (options = {}),
+    (dataId = '')
+  );
 }
 
 export default drawEllipse;

package/src/drawingSvg/drawEllipseByCoordinates.ts

@@ -1,4 +1,3 @@
-2
 import type { Types } from '@cornerstonejs/core';
 import { SVGDrawingHelper } from '../types';
 
@@ -35,9 +34,10 @@ function drawEllipseByCoordinates(
 
   const w = Math.hypot(left[0] - right[0], left[1] - right[1]);
   const h = Math.hypot(top[0] - bottom[0], top[1] - bottom[1]);
-  const angle = Math.atan2(left[1] - right[1], left[0] - right[0]) * 180 / Math.PI;
+  const angle =
+    (Math.atan2(left[1] - right[1], left[0] - right[0]) * 180) / Math.PI;
 
-  const center = [(left[0] + right[0]) / 2 , ( top[1] + bottom[1] ) / 2];
+  const center = [(left[0] + right[0]) / 2, (top[1] + bottom[1]) / 2];
   const radiusX = w / 2;
   const radiusY = h / 2;
 
@@ -48,7 +48,7 @@ function drawEllipseByCoordinates(
     ry: `${radiusY}`,
     stroke: color,
     fill: 'transparent',
-    'transform': `rotate(${angle} ${center[0]} ${center[1]})`,
+    transform: `rotate(${angle} ${center[0]} ${center[1]})`,
     'stroke-width': strokeWidth,
     'stroke-dasharray': lineDash,
   };

package/src/enums/StrategyCallbacks.ts

@@ -0,0 +1,52 @@
+/**
+ * Defines the names of the strategy callbacks used for performing enhanced
+ * strategy operations.
+ */
+enum StrategyCallbacks {
+  /**
+   * startStrategy is called at the start of a strategy, typically on mouse down
+   * Note this is separate from preview and the endings for preview, which could
+   * be called alternatively, but this may be nested within a preview.
+   */
+  OnInteractionStart = 'onInteractionStart',
+  /**
+   * finishStrategy is called at the end of a strategy being applied, usually on
+   * mouse up.
+   */
+  OnInteractionEnd = 'onInteractionEnd',
+  /**
+   * The preview can be used for tools to show what would happen on accepting
+   * before the change is actually done.  For example, a spline tool might
+   * show a preview state, and allow that to be accepted or rejected.
+   */
+  Preview = 'preview',
+  RejectPreview = 'rejectPreview',
+  AcceptPreview = 'acceptPreview',
+
+  /**
+   * Fills the given reygion
+   */
+  Fill = 'fill',
+
+  /**
+   * The default strategy function, often synonymous with fill
+   */
+  StrategyFunction = 'strategyFunction',
+
+  /**
+   * For threshold functions, this creates the thresold test.  Mostly an internal
+   * detail, but might be useful to share between strategies.
+   */
+  CreateIsInThreshold = 'createIsInThreshold',
+
+  /**
+   *  Some strategy functions need to initialize some data before being runnable.
+   * This is mostly an internal detail, just useful to have an enum here for this.
+   */
+  Initialize = 'initialize',
+
+  // Internal Details
+  INTERNAL_setValue = 'setValue',
+}
+
+export default StrategyCallbacks;

package/src/enums/index.js

@@ -4,6 +4,7 @@ import AnnotationStyleStates from './AnnotationStyleStates';
 import Events from './Events';
 import SegmentationRepresentations from './SegmentationRepresentations';
 import { Swipe } from './Touch';
+import StrategyCallbacks from './StrategyCallbacks';
 
 export {
   MouseBindings,
@@ -13,4 +14,5 @@ export {
   Events,
   SegmentationRepresentations,
   Swipe,
+  StrategyCallbacks,
 };

package/src/eventDispatchers/keyboardEventHandlers/keyDown.ts

@@ -1,6 +1,8 @@
 import { ToolGroupManager } from '../../store';
 import getActiveToolForKeyboardEvent from '../shared/getActiveToolForKeyboardEvent';
+import getToolsWithActionsForKeyboardEvent from '../shared/getToolsWithActionsForKeyboardEvents';
 import { KeyDownEventType } from '../../types/EventTypes';
+import ToolModes from '../../enums/ToolModes';
 
 /**
  * KeyDown event listener to handle viewport cursor icon changes
@@ -11,19 +13,28 @@ export default function keyDown(evt: KeyDownEventType): void {
   // get the active tool given the key and mouse button
   const activeTool = getActiveToolForKeyboardEvent(evt);
 
-  if (!activeTool) {
-    return;
-  }
+  if (activeTool) {
+    const { renderingEngineId, viewportId } = evt.detail;
+
+    const toolGroup = ToolGroupManager.getToolGroupForViewport(
+      viewportId,
+      renderingEngineId
+    );
 
-  const { renderingEngineId, viewportId } = evt.detail;
+    const toolName = activeTool.getToolName();
+    if (Object.keys(toolGroup.toolOptions).includes(toolName)) {
+      toolGroup.setViewportsCursorByToolName(toolName);
+    }
+  }
 
-  const toolGroup = ToolGroupManager.getToolGroupForViewport(
-    viewportId,
-    renderingEngineId
-  );
+  const activeToolsWithEventBinding = getToolsWithActionsForKeyboardEvent(evt, [
+    ToolModes.Active,
+  ]);
 
-  const toolName = activeTool.getToolName();
-  if (Object.keys(toolGroup.toolOptions).includes(toolName)) {
-    toolGroup.setViewportsCursorByToolName(toolName);
+  if (activeToolsWithEventBinding?.size) {
+    const { element } = evt.detail;
+    for (const [key, value] of [...activeToolsWithEventBinding.entries()]) {
+      key[value.method](element);
+    }
   }
 }

package/src/eventDispatchers/shared/getActiveToolForKeyboardEvent.ts

@@ -1,5 +1,5 @@
 import { ToolGroupManager } from '../../store';
-import { ToolModes, MouseBindings } from '../../enums';
+import { ToolModes } from '../../enums';
 import { keyEventListener } from '../../eventListeners';
 import { EventTypes } from '../../types';
 import { getMouseButton } from '../../eventListeners/mouse/mouseDownListener';
@@ -24,6 +24,7 @@ export default function getActiveToolForKeyboardEvent(
   const mouseButton = getMouseButton();
 
   // If any keyboard modifier key is also pressed
+  // TODO - get the real modifier key
   const modifierKey = keyEventListener.getModifierKey();
 
   const toolGroup = ToolGroupManager.getToolGroupForViewport(
@@ -42,6 +43,9 @@ export default function getActiveToolForKeyboardEvent(
     const toolName = toolGroupToolNames[j];
     const toolOptions = toolGroup.toolOptions[toolName];
 
+    if (toolOptions.mode !== Active) {
+      continue;
+    }
     // tool has binding that matches the mouse button, if mouseEvent is undefined
     // it uses the primary button
     const correctBinding =
@@ -52,7 +56,7 @@ export default function getActiveToolForKeyboardEvent(
           binding.modifierKey === modifierKey
       );
 
-    if (toolOptions.mode === Active && correctBinding) {
+    if (correctBinding) {
       return toolGroup.getToolInstance(toolName);
     }
   }

package/src/eventDispatchers/shared/getToolsWithActionsForKeyboardEvents.ts

@@ -0,0 +1,53 @@
+import { ToolGroupManager } from '../../store';
+import { ToolModes } from '../../enums';
+import { EventTypes } from '../../types';
+
+/**
+ * Given the normalized mouse event and a filter of modes,
+ * find all the tools on the element that are in one of the specified modes.
+ * If the evtButton is specified, only tools with a matching binding will be returned.
+ * @param evt - The normalized mouseDown event.
+ * @param modesFilter - An array of entries from the `ToolModes` enum.
+ */
+export default function getToolsWithModesForKeyboardEvent(
+  evt: EventTypes.KeyDownEventType,
+  toolModes: ToolModes[]
+) {
+  const toolsWithActions = new Map();
+  const { renderingEngineId, viewportId } = evt.detail;
+  const toolGroup = ToolGroupManager.getToolGroupForViewport(
+    viewportId,
+    renderingEngineId
+  );
+
+  if (!toolGroup) {
+    return toolsWithActions;
+  }
+
+  const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+  const key = evt.detail.key;
+
+  for (let j = 0; j < toolGroupToolNames.length; j++) {
+    const toolName = toolGroupToolNames[j];
+    const tool = toolGroup.getToolInstance(toolName);
+    const actionsConfig = tool.configuration?.actions;
+    if (!actionsConfig) {
+      continue;
+    }
+    const actions = Object.values(actionsConfig);
+
+    if (!actions?.length || !toolModes.includes(tool.mode)) {
+      continue;
+    }
+
+    const action = actions.find((action: any) =>
+      action.bindings.some((binding) => binding.key === key)
+    );
+
+    if (action) {
+      toolsWithActions.set(tool, action);
+    }
+  }
+
+  return toolsWithActions;
+}

package/src/eventDispatchers/shared/getToolsWithActionsForMouseEvent.ts

@@ -5,8 +5,6 @@ import { ToolAction, EventTypes } from '../../types';
 import { keyEventListener } from '../../eventListeners';
 import getMouseModifier from './getMouseModifier';
 
-type ModesFilter = Array<ToolModes>;
-
 /**
  * Given the mouse event and a list of tool modes, find all tool instances
  * with actions that were added to the tool group associated with the viewport

package/src/stateManagement/segmentation/config/segmentationColor.ts

@@ -96,7 +96,14 @@ function getColorForSegmentIndex(
 
   // get colorLUT
   const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
-  return colorLUT[segmentIndex];
+  let colorValue = colorLUT[segmentIndex];
+  if (!colorValue) {
+    if (typeof segmentIndex !== 'number') {
+      throw new Error(`Can't create colour for LUT index ${segmentIndex}`);
+    }
+    colorValue = colorLUT[segmentIndex] = [0, 0, 0, 0];
+  }
+  return colorValue;
 }
 
 function setColorForSegmentIndex(

package/src/tools/annotation/EllipticalROITool.ts

@@ -785,9 +785,7 @@ class EllipticalROITool extends AnnotationTool {
       const rotation = Math.abs(
         viewport.getRotation() - (data.initialRotation || 0)
       );
-      let canvasCorners;
-
-      canvasCorners = <Array<Types.Point2>>(
+      const canvasCorners = <Array<Types.Point2>>(
         getCanvasEllipseCorners(canvasCoordinates) // bottom, top, left, right, keep as is
       );
 

package/src/tools/base/AnnotationTool.ts

@@ -1,6 +1,5 @@
 import {
   BaseVolumeViewport,
-  StackViewport,
   cache,
   getEnabledElement,
   metaData,

package/src/tools/base/BaseTool.ts

@@ -6,6 +6,7 @@ import {
 } from '@cornerstonejs/core';
 import { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
+import StrategyCallbacks from '../../enums/StrategyCallbacks';
 import { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
 
 export interface IBaseTool {
@@ -73,7 +74,8 @@ abstract class BaseTool implements IBaseTool {
   }
 
   /**
-   * It applies the active strategy to the enabled element.
+   * Applies the active strategy function to the enabled element with the specified
+   * operation data.
    * @param enabledElement - The element that is being operated on.
    * @param operationData - The data that needs to be passed to the strategy.
    * @returns The result of the strategy.
@@ -83,7 +85,35 @@ abstract class BaseTool implements IBaseTool {
     operationData: unknown
   ): any {
     const { strategies, activeStrategy } = this.configuration;
-    return strategies[activeStrategy].call(this, enabledElement, operationData);
+    return strategies[activeStrategy]?.call(
+      this,
+      enabledElement,
+      operationData
+    );
+  }
+
+  /**
+   * Applies the active strategy, with a given event type being applied.
+   * The event type function is found by indexing it on the active strategy
+   * function.
+   *
+   * @param enabledElement - The element that is being operated on.
+   * @param operationData - The data that needs to be passed to the strategy.
+   * @param callbackType - the type of the callback
+   *
+   * @returns The result of the strategy.
+   */
+  public applyActiveStrategyCallback(
+    enabledElement: Types.IEnabledElement,
+    operationData: unknown,
+    callbackType: StrategyCallbacks | string
+  ): any {
+    const { strategies, activeStrategy } = this.configuration;
+    return strategies[activeStrategy][callbackType]?.call(
+      this,
+      enabledElement,
+      operationData
+    );
   }
 
   /**