@cornerstonejs/tools 1.55.0 → 1.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.55.0",
+  "version": "1.56.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,12 +29,16 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.55.0",
+    "@cornerstonejs/core": "^1.56.0",
     "@icr/polyseg-wasm": "0.4.0",
+    "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
+  "devDependencies": {
+    "canvas": "^2.11.2"
+  },
   "peerDependencies": {
     "@icr/polyseg-wasm": "0.4.0",
     "@kitware/vtk.js": "29.3.0",
@@ -55,5 +59,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "78d3c2fd9e2cd07d1ec5b84201f9f909ff6ce7cf"
+  "gitHead": "73863e2aac88c70974cf966ca4e0eae11c1e67dc"
 }

package/src/eventListeners/segmentation/imageChangeEventListener.ts

@@ -1,7 +1,7 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import {
-  StackViewport,
+  BaseVolumeViewport,
   getEnabledElement,
   Enums,
   getEnabledElementByIds,
@@ -19,7 +19,7 @@ import triggerSegmentationRender from '../../utilities/segmentation/triggerSegme
 const enable = function (element: HTMLDivElement): void {
   const { viewport } = getEnabledElement(element);
 
-  if (!(viewport instanceof StackViewport)) {
+  if (viewport instanceof BaseVolumeViewport) {
     return;
   }
 
@@ -35,12 +35,6 @@ const enable = function (element: HTMLDivElement): void {
 };
 
 const disable = function (element: HTMLDivElement): void {
-  const { viewport } = getEnabledElement(element);
-
-  if (!(viewport instanceof StackViewport)) {
-    return;
-  }
-
   element.removeEventListener(
     Enums.Events.STACK_NEW_IMAGE,
     _imageChangeEventListener as EventListener
@@ -152,6 +146,16 @@ function _imageChangeEventListener(evt) {
       // this means that this slice doesn't have a segmentation for this representation
       // this can be a case where the segmentation was added to certain slices only
       // so we can keep the actor but empty out the imageData
+      if (segmentationImageData.setDerivedImage) {
+        // If the image data has a set derived image, then it should be called
+        // to update any vtk or actor data associated with it.  In this case, null
+        // is used to clear the data.  THis allows intercepting/alternative
+        // to vtk calls.  Eventually the vtk version should also use this.
+        segmentationImageData.setDerivedImage(null);
+        return;
+      }
+      // This is the vtk version of the clearing out the image data, and fails
+      // to work for non scalar image data.
       const scalarArray = vtkDataArray.newInstance({
         name: 'Pixels',
         numberOfComponents: 1,
@@ -169,7 +173,11 @@ function _imageChangeEventListener(evt) {
     const { dimensions, spacing, direction } =
       viewport.getImageDataMetadata(derivedImage);
 
-    const currentImage = cache.getImage(currentImageId);
+    const currentImage =
+      cache.getImage(currentImageId) ||
+      ({
+        imageId: currentImageId,
+      } as Types.IImage);
     const { origin: currentOrigin } =
       viewport.getImageDataMetadata(currentImage);
 
@@ -230,10 +238,17 @@ function _imageChangeEventListener(evt) {
       return;
     }
 
-    utilities.updateVTKImageDataWithCornerstoneImage(
-      segmentationImageData,
-      derivedImage
-    );
+    if (segmentationImageData.setDerivedImage) {
+      // Update the derived image data, whether vtk or other as appropriate
+      // to the actor(s) displaying the data.
+      segmentationImageData.setDerivedImage(derivedImage);
+    } else {
+      // TODO - use setDerivedImage for this functionality
+      utilities.updateVTKImageDataWithCornerstoneImage(
+        segmentationImageData,
+        derivedImage
+      );
+    }
     viewport.render();
 
     // This is put here to make sure that the segmentation is rendered

package/src/stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation.ts

@@ -20,6 +20,6 @@ export function computeAndAddLabelmapRepresentation(
     segmentationId,
     SegmentationRepresentations.Labelmap,
     () => computeLabelmapData(segmentationId, options),
-    () => {}
+    () => undefined
   );
 }

package/src/stateManagement/segmentation/polySeg/Labelmap/convertSurfaceToLabelmap.ts

@@ -86,4 +86,6 @@ export async function convertSurfaceToVolumeLabelmap(
   };
 }
 
-export async function convertSurfaceToStackLabelmap() {}
+export async function convertSurfaceToStackLabelmap() {
+  // TODO
+}

package/src/tools/segmentation/BrushTool.ts

@@ -484,7 +484,7 @@ class BrushTool extends BaseTool {
 
     this._previewData.preview = this.applyActiveStrategy(
       enabledElement,
-      this.getOperationData()
+      this.getOperationData(element)
     );
     this._previewData.element = element;
     // Add a bit of time to the timer start so small accidental movements dont

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

@@ -15,12 +15,17 @@ import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 const { VoxelManager } = csUtils;
 
 export type InitializedOperationData = LabelmapToolOperationDataAny & {
+  // Allow initialization that is operation specific by keying on the name
+  operationName?: string;
+
   // Additional data for performing the strategy
   enabledElement: Types.IEnabledElement;
   centerIJK?: Types.Point3;
   centerWorld: Types.Point3;
   viewport: Types.IViewport;
-  imageVoxelManager: csUtils.VoxelManager<number>;
+  imageVoxelManager:
+    | csUtils.VoxelManager<number>
+    | csUtils.VoxelManager<Types.RGB>;
   segmentationVoxelManager: csUtils.VoxelManager<number>;
   segmentationImageData: vtkImageData;
   previewVoxelManager: csUtils.VoxelManager<number>;
@@ -152,7 +157,16 @@ export default class BrushStrategy {
     enabledElement: Types.IEnabledElement,
     operationData: LabelmapToolOperationDataAny
   ) => {
-    const initializedData = this.initialize(enabledElement, operationData);
+    const initializedData = this.initialize(
+      enabledElement,
+      operationData,
+      StrategyCallbacks.Fill
+    );
+
+    if (!initializedData) {
+      // Happens when there is no label map
+      return;
+    }
 
     const { strategySpecificConfiguration = {}, centerIJK } = initializedData;
     // Store the center IJK location so that we can skip an immediate same-point update
@@ -186,7 +200,8 @@ export default class BrushStrategy {
 
   protected initialize(
     enabledElement: Types.IEnabledElement,
-    operationData: LabelmapToolOperationDataAny
+    operationData: LabelmapToolOperationDataAny,
+    operationName?: string
   ): InitializedOperationData {
     const { viewport } = enabledElement;
     const data = getStrategyData({ operationData, viewport });
@@ -228,6 +243,7 @@ export default class BrushStrategy {
     const previewSegmentIndex = previewEnabled ? 255 : undefined;
 
     const initializedData: InitializedOperationData = {
+      operationName,
       previewSegmentIndex,
       ...operationData,
       enabledElement,
@@ -263,6 +279,10 @@ export default class BrushStrategy {
       return;
     }
     const initializedData = this.initialize(enabledElement, operationData);
+    if (!initializedData) {
+      // Happens if there isn't a labelmap to apply to
+      return;
+    }
     this._onInteractionStart.forEach((func) =>
       func.call(this, initializedData)
     );
@@ -334,7 +354,8 @@ function addListMethod(name: string, createInitialized?: string) {
       ? (enabledElement, operationData) => {
           const initializedData = brushStrategy[createInitialized](
             enabledElement,
-            operationData
+            operationData,
+            name
           );
           brushStrategy[listName].forEach((func) =>
             func.call(brushStrategy, initializedData)

package/src/tools/segmentation/strategies/compositions/dynamicThreshold.ts

@@ -1,3 +1,4 @@
+import { vec3 } from 'gl-matrix';
 import type { InitializedOperationData } from '../BrushStrategy';
 import type BoundsIJK from '../../../../types/BoundsIJK';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
@@ -13,6 +14,7 @@ import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
   [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
     const {
+      operationName,
       centerIJK,
       strategySpecificConfiguration,
       segmentationVoxelManager: segmentationVoxelManager,
@@ -24,6 +26,12 @@ export default {
     if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
       return;
     }
+    if (
+      operationName === StrategyCallbacks.RejectPreview ||
+      operationName === StrategyCallbacks.OnInteractionEnd
+    ) {
+      return;
+    }
 
     const { boundsIJK } = segmentationVoxelManager;
     const { threshold: oldThreshold, dynamicRadius = 0 } = THRESHOLD;
@@ -37,9 +45,11 @@ export default {
     }) as BoundsIJK;
 
     const threshold = oldThreshold || [Infinity, -Infinity];
+    // TODO - threshold on all three values separately
     const callback = ({ value }) => {
-      threshold[0] = Math.min(value, threshold[0]);
-      threshold[1] = Math.max(value, threshold[1]);
+      const gray = Array.isArray(value) ? vec3.len(value as any) : value;
+      threshold[0] = Math.min(gray, threshold[0]);
+      threshold[1] = Math.max(gray, threshold[1]);
     };
     imageVoxelManager.forEach(callback, { boundsIJK: nestedBounds });
 

package/src/tools/segmentation/strategies/compositions/islandRemoval.ts

@@ -89,8 +89,7 @@ export default {
       floodedSet.add(index);
       floodedCount++;
     };
-
-    clickedPoints.forEach((clickedPoint, index) => {
+    clickedPoints.forEach((clickedPoint) => {
       // @ts-ignore - need to ignore the spread appication to array params
       if (getter(...clickedPoint) === 1) {
         floodFill(getter, clickedPoint, {

package/src/tools/segmentation/strategies/compositions/threshold.ts

@@ -1,3 +1,5 @@
+import { vec3 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
 import type { InitializedOperationData } from '../BrushStrategy';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 
@@ -10,11 +12,8 @@ export default {
   [StrategyCallbacks.CreateIsInThreshold]: (
     operationData: InitializedOperationData
   ) => {
-    const {
-      imageVoxelManager: imageVoxelManager,
-      strategySpecificConfiguration,
-      segmentIndex,
-    } = operationData;
+    const { imageVoxelManager, strategySpecificConfiguration, segmentIndex } =
+      operationData;
     if (!strategySpecificConfiguration || !segmentIndex) {
       return;
     }
@@ -23,13 +22,16 @@ export default {
         strategySpecificConfiguration;
 
       const voxelValue = imageVoxelManager.getAtIndex(index);
+      const gray = Array.isArray(voxelValue)
+        ? vec3.length(voxelValue as Types.Point3)
+        : voxelValue;
       // Prefer the generic version of the THRESHOLD configuration, but fallback
       // to the older THRESHOLD_INSIDE_CIRCLE version.
       const { threshold } = THRESHOLD || THRESHOLD_INSIDE_CIRCLE || {};
       if (!threshold?.length) {
         return true;
       }
-      return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+      return threshold[0] <= gray && gray <= threshold[1];
     };
   },
 };

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

@@ -9,6 +9,9 @@ function getStrategyData({ operationData, viewport }) {
   let segmentationImageData, segmentationScalarData, imageScalarData;
   let imageDimensions: Types.Point3;
   let segmentationDimensions: Types.Point3;
+  let imageVoxelManager;
+  let segmentationVoxelManager;
+
   if (isVolumeSegmentation(operationData, viewport)) {
     const { volumeId, referencedVolumeId } = operationData;
 
@@ -17,6 +20,7 @@ function getStrategyData({ operationData, viewport }) {
     if (!segmentationVolume) {
       return;
     }
+    segmentationVoxelManager = segmentationVolume.voxelManager;
 
     // we only need the referenceVolumeId if we do thresholding
     // but for other operations we don't need it so make it optional
@@ -46,32 +50,43 @@ function getStrategyData({ operationData, viewport }) {
     // and always circle modifies the current imageId which in fact is the imageData
     // of that actor at that moment so we have the imageData already
     const actor = viewport.getActor(segmentationRepresentationUID);
+    if (!actor) {
+      return;
+    }
     segmentationImageData = actor.actor.getMapper().getInputData();
+    segmentationVoxelManager = segmentationImageData.voxelManager;
     const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
 
     const segmentationImage = cache.getImage(currentSegmentationImageId);
-    segmentationScalarData = segmentationImage.getPixelData();
+    if (!segmentationImage) {
+      return;
+    }
+    segmentationScalarData = segmentationImage.getPixelData?.();
 
     const image = cache.getImage(currentImageId);
+    const imageData = image ? null : viewport.getImageData();
 
     // VERY IMPORTANT
     // This is the pixel data of the image that is being segmented in the cache
     // and we need to use this to for the modification
-    imageScalarData = image.getPixelData();
-    imageDimensions = [image.columns, image.rows, 1];
+    imageScalarData = image?.getPixelData() || imageData.getScalarData();
+    imageDimensions = image
+      ? [image.columns, image.rows, 1]
+      : imageData.dimensions;
     segmentationDimensions = [
       segmentationImage.columns,
       segmentationImage.rows,
       1,
     ];
+    imageVoxelManager = image?.voxelManager;
   }
 
-  const segmentationVoxelManager = VoxelManager.createVolumeVoxelManager(
+  segmentationVoxelManager ||= VoxelManager.createVolumeVoxelManager(
     segmentationDimensions,
     segmentationScalarData
   );
 
-  const imageVoxelManager =
+  imageVoxelManager ||=
     imageDimensions &&
     VoxelManager.createVolumeVoxelManager(imageDimensions, imageScalarData);
 

package/src/utilities/pointInShapeCallback.ts

@@ -47,6 +47,7 @@ export default function pointInShapeCallback(
   let iMin, iMax, jMin, jMax, kMin, kMax;
 
   let scalarData;
+  const { numComps } = imageData as any;
 
   // if getScalarData is a method on imageData
   if ((imageData as Types.CPUImageData).getScalarData) {
@@ -103,6 +104,7 @@ export default function pointInShapeCallback(
   );
 
   const xMultiple =
+    numComps ||
     scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
   const yMultiple = dimensions[0] * xMultiple;
   const zMultiple = dimensions[1] * yMultiple;

package/src/utilities/segmentation/floodFill.ts

@@ -7,22 +7,25 @@ import { Types } from '@cornerstonejs/core';
 
 /**
  * floodFill.js - Taken from MIT OSS lib - https://github.com/tuzz/n-dimensional-flood-fill
- * Refactored to ES6.
+ * Refactored to ES6.  Fixed the bounds/visits checks to use integer keys, restricting the
+ * total search spacing to +/- 32k in each dimension, but resulting in about a hundred time
+ * performance gain for larger regions since JavaScript does not have a hash map to allow the
+ * map to work on keys.
  *
- * @param {function} getter The getter to the elements of your data structure,
+ * @param getter The getter to the elements of your data structure,
  *                          e.g. getter(x,y) for a 2D interprettation of your structure.
- * @param {number[]} seed The seed for your fill. The dimensionality is infered
+ * @param seed The seed for your fill. The dimensionality is infered
  *                        by the number of dimensions of the seed.
- * @param {function} [options.onFlood] An optional callback to execute when each pixel is flooded.
+ * @param options.onFlood - An optional callback to execute when each pixel is flooded.
  *                             e.g. onFlood(x,y).
- * @param {function} [options.onBoundary] An optional callback to execute whenever a boundary is reached.
+ * @param options.onBoundary - An optional callback to execute whenever a boundary is reached.
  *                                a boundary could be another segmentIndex, or the edge of your
  *                                data structure (i.e. when your getter returns undefined).
- * @param {function} [options.equals] An optional equality method for your datastructure.
+ * @param options.equals - An optional equality method for your datastructure.
  *                            Default is simply value1 = value2.
- * @param {boolean} [options.diagonals] Whether you allow flooding through diagonals. Defaults to false.
+ * @param options.diagonals - Whether you allow flooding through diagonals. Defaults to false.
  *
- * @returns {Object}
+ * @returns Flood fill results
  */
 function floodFill(
   getter: FloodFillGetter,
@@ -31,14 +34,14 @@ function floodFill(
 ): FloodFillResult {
   const onFlood = options.onFlood;
   const onBoundary = options.onBoundary;
-  const equals = options.equals || defaultEquals;
+  const equals = options.equals;
   const diagonals = options.diagonals || false;
   const startNode = get(seed);
   const permutations = prunedPermutations();
   const stack = [];
   const flooded = [];
-  const visits = {};
-  const bounds = {};
+  const visits = new Set();
+  const bounds = new Map();
 
   stack.push({ currentArgs: seed });
 
@@ -68,18 +71,28 @@ function floodFill(
     }
   }
 
+  /**
+   * Indicates if the key has been visited.
+   * @param key is a 2 or 3 element vector with values -32768...32767
+   */
   function visited(key) {
-    return visits[key] === true;
+    const [x, y, z = 0] = key;
+    // Use an integer key value for checking visited, since JavaScript does not
+    // provide a generic hash key indexed hash map.
+    const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+    return visits.has(iKey);
   }
 
   function markAsVisited(key) {
-    visits[key] = true;
+    const [x, y, z = 0] = key;
+    const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+    visits.add(iKey);
   }
 
   function member(getArgs) {
-    const node = safely(get, [getArgs]);
+    const node = get(getArgs);
 
-    return safely(equals, [node, startNode]);
+    return equals ? equals(node, startNode) : node === startNode;
   }
 
   function markAsFlooded(getArgs) {
@@ -91,7 +104,11 @@ function floodFill(
   }
 
   function markAsBoundary(prevArgs) {
-    bounds[prevArgs] = prevArgs;
+    const [x, y, z = 0] = prevArgs;
+    // Use an integer key value for checking visited, since JavaScript does not
+    // provide a generic hash key indexed hash map.
+    const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+    bounds.set(iKey, prevArgs);
     if (onBoundary) {
       //@ts-ignore
       onBoundary(...prevArgs);
@@ -119,13 +136,15 @@ function floodFill(
     return getter(...getArgs);
   }
 
-  function safely(f, args) {
-    try {
-      return f(...args);
-    } catch (error) {
-      return;
-    }
-  }
+  // This is a significant performance hit - should be done as a wrapper
+  // only when needed.
+  // function safely(f, args) {
+  //   try {
+  //     return f(...args);
+  //   } catch (error) {
+  //     return;
+  //   }
+  // }
 
   function prunedPermutations() {
     const permutations = permute(seed.length);
@@ -156,14 +175,8 @@ function floodFill(
   }
 
   function boundaries() {
-    const array = [];
-
-    for (const key in bounds) {
-      if (bounds[key] !== undefined) {
-        array.unshift(bounds[key]);
-      }
-    }
-
+    const array = Array.from(bounds.values());
+    array.reverse();
     return array;
   }
 }

package/src/utilities/segmentation/getSegmentAtLabelmapBorder.ts

@@ -84,12 +84,13 @@ export function getSegmentAtLabelmapBorder(
   const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
 
   const dimensions = imageData.getDimensions();
-  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
-    dimensions,
-    imageData.getPointData().getScalars().getData()
-  );
+  const voxelManager = (imageData.voxelManager ||
+    utilities.VoxelManager.createVolumeVoxelManager(
+      dimensions,
+      imageData.getPointData().getScalars().getData()
+    )) as utilities.VoxelManager<number>;
 
-  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+  const segmentIndex = voxelManager.getAtIJKPoint(indexIJK as Types.Point3);
 
   const onEdge = isSegmentOnEdgeIJK(
     indexIJK as Types.Point3,

package/src/utilities/segmentation/getSegmentAtWorldPoint.ts

@@ -110,12 +110,13 @@ export function getSegmentAtWorldForLabelmap(
   const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
 
   const dimensions = imageData.getDimensions();
-  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
-    dimensions,
-    imageData.getPointData().getScalars().getData()
-  );
+  const voxelManager = (imageData.voxelManager ||
+    utilities.VoxelManager.createVolumeVoxelManager(
+      dimensions,
+      imageData.getPointData().getScalars().getData()
+    )) as utilities.VoxelManager<number>;
 
-  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+  const segmentIndex = voxelManager.getAtIJKPoint(indexIJK as Types.Point3);
 
   return segmentIndex;
 }