@cornerstonejs/tools 1.54.2 → 1.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.54.2",
+  "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.54.2",
+    "@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": "6e3d8ea3d2aa05751ca8dcba38716d65324cc5f4"
+  "gitHead": "73863e2aac88c70974cf966ca4e0eae11c1e67dc"
 }

package/src/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.ts

@@ -242,7 +242,7 @@ function getContourHolesData(
   });
 }
 
-async function combinePolylines(
+function combinePolylines(
   viewport: Types.IViewport,
   targetAnnotation: ContourSegmentationAnnotation,
   targetPolyline: Types.Point2[],

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/annotation/LivewireContourTool.ts

@@ -32,7 +32,6 @@ import { LivewireScissors } from '../../utilities/livewire/LivewireScissors';
 import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
-import updateContourPolyline from '../../utilities/contours/updateContourPolyline';
 
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2; // px
 
@@ -108,6 +107,20 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
            */
           showInterpolationPolyline: false,
         },
+
+        /**
+         * The polyline may get processed in order to reduce the number of points
+         * for better performance and storage.
+         */
+        decimate: {
+          enabled: false,
+          /** A maximum given distance 'epsilon' to decide if a point should or
+           * shouldn't be added the resulting polyline which will have a lower
+           * number of points for higher `epsilon` values.
+           */
+          epsilon: 0.1,
+        },
+
         actions: {
           undo: {
             method: 'undo',
@@ -922,7 +935,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
       imagePoints = [...imagePoints, imagePoints[0]];
     }
 
-    updateContourPolyline(
+    this.updateContourPolyline(
       annotation,
       {
         points: imagePoints,

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -231,6 +231,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
           // interpolation is complete.
           onInterpolationComplete: null,
         },
+        /**
+         * The polyline may get processed in order to reduce the number of points
+         * for better performance and storage.
+         */
+        decimate: {
+          enabled: false,
+          /** A maximum given distance 'epsilon' to decide if a point should or
+           * shouldn't be added the resulting polyline which will have a lower
+           * number of points for higher `epsilon` values.
+           */
+          epsilon: 0.1,
+        },
         calculateStats: false,
         getTextLines: defaultGetTextLines,
         statsCalculator: BasicStatsCalculator,

package/src/tools/annotation/SplineROITool.ts

@@ -56,7 +56,6 @@ import { LinearSpline } from './splines/LinearSpline';
 import { CatmullRomSpline } from './splines/CatmullRomSpline';
 import { BSpline } from './splines/BSpline';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
-import updateContourPolyline from '../../utilities/contours/updateContourPolyline';
 
 const SPLINE_MIN_POINTS = 3;
 const SPLINE_CLICK_CLOSE_CURVE_DIST = 10;
@@ -121,6 +120,18 @@ class SplineROITool extends ContourSegmentationBaseTool {
          * modifier must be pressed when the first point of a new contour is added.
          */
         contourHoleAdditionModifierKey: KeyboardBindings.Shift,
+        /**
+         * The polyline may get processed in order to reduce the number of points
+         * for better performance and storage.
+         */
+        decimate: {
+          enabled: false,
+          /** A maximum given distance 'epsilon' to decide if a point should or
+           * shouldn't be added the resulting polyline which will have a lower
+           * number of points for higher `epsilon` values.
+           */
+          epsilon: 0.1,
+        },
         spline: {
           configuration: {
             [SplineTypesEnum.Cardinal]: {
@@ -693,7 +704,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
         const spline = this._updateSplineInstance(element, annotation);
         const splinePolylineCanvas = spline.getPolylinePoints();
 
-        updateContourPolyline(
+        this.updateContourPolyline(
           annotation,
           {
             points: splinePolylineCanvas,

package/src/tools/annotation/planarFreehandROITool/drawLoop.ts

@@ -18,7 +18,6 @@ import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotati
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 import { polyline } from '../../../utilities/math';
 import { removeAnnotation } from '../../../stateManagement/annotation/annotationState';
-import { updateContourPolyline } from '../../../utilities/contours/';
 import reverseIfAntiClockwise from '../../../utilities/contours/reverseIfAntiClockwise';
 
 const {
@@ -238,7 +237,7 @@ function completeDrawClosedContour(
   // contours. A future optimization if we use this for segmentation is to re-do
   // this rendering with the GPU rather than SVG.
 
-  updateContourPolyline(
+  this.updateContourPolyline(
     annotation,
     {
       points: updatedPoints,
@@ -315,7 +314,7 @@ function completeDrawOpenContour(
   // contours. A future optimisation if we use this for segmentation is to re-do
   // this rendering with the GPU rather than SVG.
 
-  updateContourPolyline(
+  this.updateContourPolyline(
     annotation,
     {
       points: updatedPoints,

package/src/tools/base/ContourBaseTool.ts

@@ -17,7 +17,9 @@ import type {
 import { drawPath as drawPathSvg } from '../../drawingSvg';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 import AnnotationTool from './AnnotationTool';
+import { updateContourPolyline } from '../../utilities/contours/';
 import { getContourHolesDataCanvas } from '../../utilities/contours';
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
 
 /**
  * A contour base class responsible for rendering contour instances such as
@@ -210,6 +212,27 @@ abstract class ContourBaseTool extends AnnotationTool {
     );
   }
 
+  protected updateContourPolyline(
+    annotation: ContourAnnotation,
+    polylineData: {
+      points: Types.Point2[];
+      closed?: boolean;
+      targetWindingDirection?: ContourWindingDirection;
+    },
+    transforms: {
+      canvasToWorld: (point: Types.Point2) => Types.Point3;
+    }
+  ) {
+    const decimateConfig = this.configuration?.decimate || {};
+
+    updateContourPolyline(annotation, polylineData, transforms, {
+      decimate: {
+        enabled: !!decimateConfig.enabled,
+        epsilon: decimateConfig.epsilon,
+      },
+    });
+  }
+
   /**
    * Get polyline points in world space.
    * Just to give a chance for child classes to override it.

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/contours/updateContourPolyline.ts

@@ -14,6 +14,12 @@ import {
  * @param viewport - Viewport
  * @param polylineData - Polyline data (points, winding direction and closed)
  * @param transforms - Methods to convert points to/from canvas and world spaces
+ * @param options - Options
+ *   - decimate: allow to set some parameters to decimate the polyline reducing
+ *   the amount of points stored which also affects how fast it will draw the
+ *   annotation in a viewport, compute the winding direction, append/remove
+ *   contours and create holes. A higher `epsilon` value results in a polyline
+ *   with less points.
  */
 export default function updateContourPolyline(
   annotation: ContourAnnotation,
@@ -24,11 +30,27 @@ export default function updateContourPolyline(
   },
   transforms: {
     canvasToWorld: (point: Types.Point2) => Types.Point3;
+  },
+  options?: {
+    decimate?: {
+      enabled?: boolean;
+      epsilon?: number;
+    };
   }
 ) {
   const { canvasToWorld } = transforms;
   const { data } = annotation;
-  const { points: polyline, targetWindingDirection } = polylineData;
+  const { targetWindingDirection } = polylineData;
+  let { points: polyline } = polylineData;
+
+  // Decimate the polyline to reduce tha amount of points
+  if (options?.decimate?.enabled) {
+    polyline = math.polyline.decimate(
+      polylineData.points,
+      options?.decimate?.epsilon
+    );
+  }
+
   let { closed } = polylineData;
   const numPoints = polyline.length;
   const polylineWorldPoints = new Array(numPoints);

package/src/utilities/math/line/distanceToPointSquaredInfo.ts

@@ -24,7 +24,8 @@ export default function distanceToPointSquaredInfo(
   let closestPoint: Types.Point2;
   const distanceSquared = math.point.distanceToPointSquared(lineStart, lineEnd);
 
-  // Check if lineStart is the same as lineEnd which means
+  // Check if lineStart equal to the lineEnd which means the closest point
+  // is any of these two points
   if (lineStart[0] === lineEnd[0] && lineStart[1] === lineEnd[1]) {
     closestPoint = lineStart;
   }