@cornerstonejs/tools 4.12.6 → 4.13.0

package/dist/esm/enums/StrategyCallbacks.d.ts

@@ -1,4 +1,6 @@
 declare enum StrategyCallbacks {
+    CalculateCursorGeometry = "calculateCursorGeometry",
+    RenderCursor = "renderCursor",
     OnInteractionStart = "onInteractionStart",
     OnInteractionEnd = "onInteractionEnd",
     Preview = "preview",

package/dist/esm/enums/StrategyCallbacks.js

@@ -1,5 +1,7 @@
 var StrategyCallbacks;
 (function (StrategyCallbacks) {
+    StrategyCallbacks["CalculateCursorGeometry"] = "calculateCursorGeometry";
+    StrategyCallbacks["RenderCursor"] = "renderCursor";
     StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
     StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
     StrategyCallbacks["Preview"] = "preview";

package/dist/esm/stateManagement/segmentation/getCurrentLabelmapImageIdForViewport.d.ts

@@ -1,3 +1,3 @@
-export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string;
+export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
 export declare function getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[];
 export declare function getLabelmapImageIdsForImageId(imageId: string, segmentationId: string): string[];

package/dist/esm/stateManagement/segmentation/getCurrentLabelmapImageIdForViewport.js

@@ -1,6 +1,9 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
     const imageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+    if (!imageIds?.length) {
+        return;
+    }
     return imageIds[0];
 }
 export function getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {

package/dist/esm/tools/segmentation/BrushTool.js

@@ -290,51 +290,7 @@ class BrushTool extends LabelmapBaseTool {
     }
     _calculateCursor(element, centerCanvas) {
         const enabledElement = getEnabledElement(element);
-        const { viewport } = enabledElement;
-        const { canvasToWorld } = viewport;
-        const camera = viewport.getCamera();
-        const { brushSize } = this.configuration;
-        const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
-        const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
-        const viewRight = vec3.create();
-        vec3.cross(viewRight, viewUp, viewPlaneNormal);
-        const centerCursorInWorld = canvasToWorld([
-            centerCanvas[0],
-            centerCanvas[1],
-        ]);
-        const bottomCursorInWorld = vec3.create();
-        const topCursorInWorld = vec3.create();
-        const leftCursorInWorld = vec3.create();
-        const rightCursorInWorld = vec3.create();
-        for (let i = 0; i <= 2; i++) {
-            bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
-            topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
-            leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
-            rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
-        }
-        if (!this._hoverData) {
-            return;
-        }
-        const { brushCursor } = this._hoverData;
-        const { data } = brushCursor;
-        if (data.handles === undefined) {
-            data.handles = {};
-        }
-        data.handles.points = [
-            bottomCursorInWorld,
-            topCursorInWorld,
-            leftCursorInWorld,
-            rightCursorInWorld,
-        ];
-        const activeStrategy = this.configuration.activeStrategy;
-        const strategy = this.configuration.strategies[activeStrategy];
-        if (typeof strategy?.computeInnerCircleRadius === 'function') {
-            strategy.computeInnerCircleRadius({
-                configuration: this.configuration,
-                viewport,
-            });
-        }
-        data.invalidated = false;
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.CalculateCursorGeometry);
     }
     getStatistics(element, segmentIndices) {
         if (!element) {
@@ -396,40 +352,7 @@ class BrushTool extends LabelmapBaseTool {
             const { element } = viewport;
             this._calculateCursor(element, centerCanvas);
         }
-        const toolMetadata = brushCursor.metadata;
-        if (!toolMetadata) {
-            return;
-        }
-        const annotationUID = toolMetadata.brushCursorUID;
-        const data = brushCursor.data;
-        const { points } = data.handles;
-        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-        const bottom = canvasCoordinates[0];
-        const top = canvasCoordinates[1];
-        const center = [
-            Math.floor((bottom[0] + top[0]) / 2),
-            Math.floor((bottom[1] + top[1]) / 2),
-        ];
-        const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
-        const color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
-        if (!viewport.getRenderingEngine()) {
-            console.warn('Rendering Engine has been destroyed');
-            return;
-        }
-        const circleUID = '0';
-        drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
-            color,
-            lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
-        });
-        const { dynamicRadiusInCanvas } = this.configuration?.threshold || {
-            dynamicRadiusInCanvas: 0,
-        };
-        if (dynamicRadiusInCanvas) {
-            const circleUID1 = '1';
-            drawCircleSvg(svgDrawingHelper, annotationUID, circleUID1, center, dynamicRadiusInCanvas, {
-                color,
-            });
-        }
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(viewport.element), StrategyCallbacks.RenderCursor, svgDrawingHelper);
     }
 }
 BrushTool.toolName = 'Brush';

package/dist/esm/tools/segmentation/LabelmapBaseTool.js

@@ -221,6 +221,7 @@ export default class LabelmapBaseTool extends BaseTool {
             previewColor,
             previewSegmentIndex,
             createMemo: this.createMemo.bind(this),
+            hoverData: this._hoverData,
         };
         return operationData;
     }

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -26,6 +26,7 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
     activeStrategy: string;
     configuration?: {
         [key: string]: unknown;
+        brushSize: number;
         centerSegmentIndex?: {
             segmentIndex: number;
         };
@@ -36,6 +37,15 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
             dynamicRadiusInCanvas?: number;
         };
     };
+    hoverData?: {
+        brushCursor: any;
+        segmentationId: string;
+        segmentIndex: number;
+        segmentColor: [number, number, number, number];
+        viewportIdsToRender: string[];
+        centerCanvas?: Array<number>;
+        viewport: Types.IViewport;
+    };
     memo?: LabelmapMemo;
     modified?: boolean;
 };
@@ -90,6 +100,10 @@ export default class BrushStrategy {
         ensureImageVolumeFor3DManipulation: {
             ensureImageVolumeFor3DManipulation: (data: any) => void;
         };
+        circularCursor: {
+            calculateCursorGeometry: (enabledElement: any, operationData: InitializedOperationData) => void;
+            renderCursor: (enabledElement: any, operationData: InitializedOperationData, svgDrawingHelper: import("../../../types").SVGDrawingHelper) => void;
+        };
     };
     protected static childFunctions: {
         onInteractionStart: (brushStrategy: any, func: any) => void;
@@ -107,6 +121,8 @@ export default class BrushStrategy {
         ensureImageVolumeFor3DManipulation: (brushStrategy: any, func: any) => void;
         addPreview: (brushStrategy: any, func: any) => void;
         getStatistics: (brushStrategy: any, func: any) => void;
+        calculateCursorGeometry: (brushStrategy: any, func: any) => void;
+        renderCursor: (brushStrategy: any, func: any) => void;
         compositions: any;
     };
     compositions: Composition[];
@@ -128,4 +144,5 @@ export default class BrushStrategy {
     interpolate: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
     setValue: (operationData: InitializedOperationData, data: any) => void;
     createIsInThreshold: (operationData: InitializedOperationData) => any;
+    calculateCursorGeometry: (enabledElement: Types.IEnabledElement, operationData: InitializedOperationData) => void;
 }

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -21,6 +21,8 @@ export default class BrushStrategy {
         [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureImageVolumeFor3DManipulation),
         [StrategyCallbacks.AddPreview]: addListMethod(StrategyCallbacks.AddPreview),
         [StrategyCallbacks.GetStatistics]: addSingletonMethod(StrategyCallbacks.GetStatistics),
+        [StrategyCallbacks.CalculateCursorGeometry]: addSingletonMethod(StrategyCallbacks.CalculateCursorGeometry, true),
+        [StrategyCallbacks.RenderCursor]: addSingletonMethod(StrategyCallbacks.RenderCursor, true),
         compositions: null,
     }; }
     constructor(name, ...initializers) {
@@ -52,6 +54,18 @@ export default class BrushStrategy {
             return initializedData;
         };
         this.configurationName = name;
+        const cursorGeometryInitializer = initializers.find(init => init.hasOwnProperty(StrategyCallbacks.CalculateCursorGeometry));
+        const renderCursorInitializer = initializers.find(init => init.hasOwnProperty(StrategyCallbacks.RenderCursor));
+        if (!cursorGeometryInitializer) {
+            initializers.push({
+                [StrategyCallbacks.CalculateCursorGeometry]: compositions.circularCursor.calculateCursorGeometry
+            });
+        }
+        if (!renderCursorInitializer) {
+            initializers.push({
+                [StrategyCallbacks.RenderCursor]: compositions.circularCursor.renderCursor
+            });
+        }
         this.compositions = initializers;
         initializers.forEach((initializer) => {
             const result = typeof initializer === 'function' ? initializer() : initializer;

package/dist/esm/tools/segmentation/strategies/compositions/circularCursor.d.ts

@@ -0,0 +1,7 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+import type { SVGDrawingHelper } from '../../../../types';
+declare const _default: {
+    calculateCursorGeometry: (enabledElement: any, operationData: InitializedOperationData) => void;
+    renderCursor: (enabledElement: any, operationData: InitializedOperationData, svgDrawingHelper: SVGDrawingHelper) => void;
+};
+export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/circularCursor.js

@@ -0,0 +1,98 @@
+import { vec3 } from 'gl-matrix';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { drawCircle as drawCircleSvg } from '../../../../drawingSvg';
+export default {
+    [StrategyCallbacks.CalculateCursorGeometry]: function (enabledElement, operationData) {
+        if (!operationData) {
+            return;
+        }
+        const { configuration, activeStrategy, hoverData } = operationData;
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const { brushSize } = configuration;
+        const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
+        const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
+        const viewRight = vec3.create();
+        vec3.cross(viewRight, viewUp, viewPlaneNormal);
+        const { canvasToWorld } = viewport;
+        const { centerCanvas } = hoverData;
+        const centerCursorInWorld = canvasToWorld([
+            centerCanvas[0],
+            centerCanvas[1],
+        ]);
+        const bottomCursorInWorld = vec3.create();
+        const topCursorInWorld = vec3.create();
+        const leftCursorInWorld = vec3.create();
+        const rightCursorInWorld = vec3.create();
+        for (let i = 0; i <= 2; i++) {
+            bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
+            topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
+            leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
+            rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
+        }
+        if (!hoverData) {
+            return;
+        }
+        const { brushCursor } = hoverData;
+        const { data } = brushCursor;
+        if (data.handles === undefined) {
+            data.handles = {};
+        }
+        data.handles.points = [
+            bottomCursorInWorld,
+            topCursorInWorld,
+            leftCursorInWorld,
+            rightCursorInWorld,
+        ];
+        const strategy = configuration.strategies[activeStrategy];
+        if (typeof strategy?.computeInnerCircleRadius === 'function') {
+            strategy.computeInnerCircleRadius({
+                configuration,
+                viewport,
+            });
+        }
+        data.invalidated = false;
+    },
+    [StrategyCallbacks.RenderCursor]: function (enabledElement, operationData, svgDrawingHelper) {
+        if (!operationData) {
+            return;
+        }
+        const { configuration, hoverData } = operationData;
+        const { viewport } = enabledElement;
+        const { brushCursor } = hoverData;
+        const toolMetadata = brushCursor.metadata;
+        if (!toolMetadata) {
+            return;
+        }
+        const annotationUID = toolMetadata.brushCursorUID;
+        const data = brushCursor.data;
+        const { points } = data.handles;
+        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+        const bottom = canvasCoordinates[0];
+        const top = canvasCoordinates[1];
+        const center = [
+            Math.floor((bottom[0] + top[0]) / 2),
+            Math.floor((bottom[1] + top[1]) / 2),
+        ];
+        const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
+        const color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
+        if (!viewport.getRenderingEngine()) {
+            console.warn('Rendering Engine has been destroyed');
+            return;
+        }
+        const circleUID = '0';
+        drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
+            color,
+            lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
+        });
+        const { dynamicRadiusInCanvas } = configuration?.threshold || {
+            dynamicRadiusInCanvas: 0,
+        };
+        if (dynamicRadiusInCanvas) {
+            const circleUID1 = '1';
+            drawCircleSvg(svgDrawingHelper, annotationUID, circleUID1, center, dynamicRadiusInCanvas, {
+                color,
+            });
+        }
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js

@@ -53,9 +53,13 @@ export default {
     },
     [StrategyCallbacks.ComputeInnerCircleRadius]: (operationData) => {
         const { configuration, viewport } = operationData;
-        const { dynamicRadius = 0, isDynamic } = configuration.threshold;
+        const thresholdConfig = configuration?.threshold;
+        if (!thresholdConfig) {
+            return;
+        }
+        const { dynamicRadius = 0, isDynamic } = thresholdConfig;
         if (!isDynamic) {
-            configuration.threshold.dynamicRadiusInCanvas = 0;
+            thresholdConfig.dynamicRadiusInCanvas = 0;
             return;
         }
         if (dynamicRadius === 0) {
@@ -75,9 +79,9 @@ export default {
         const offSetCenterInWorld = centerCursorInWorld.map((coord) => coord + radiusInWorld);
         const offSetCenterCanvas = viewport.worldToCanvas(offSetCenterInWorld);
         const dynamicRadiusInCanvas = Math.abs(centerCanvas[0] - offSetCenterCanvas[0]);
-        if (!configuration.threshold.dynamicRadiusInCanvas) {
-            configuration.threshold.dynamicRadiusInCanvas = 0;
+        if (!thresholdConfig.dynamicRadiusInCanvas) {
+            thresholdConfig.dynamicRadiusInCanvas = 0;
         }
-        configuration.threshold.dynamicRadiusInCanvas = 3 + dynamicRadiusInCanvas;
+        thresholdConfig.dynamicRadiusInCanvas = 3 + dynamicRadiusInCanvas;
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/index.d.ts

@@ -42,5 +42,9 @@ declare const _default: {
     ensureImageVolumeFor3DManipulation: {
         ensureImageVolumeFor3DManipulation: (data: any) => void;
     };
+    circularCursor: {
+        calculateCursorGeometry: (enabledElement: any, operationData: import("../BrushStrategy").InitializedOperationData) => void;
+        renderCursor: (enabledElement: any, operationData: import("../BrushStrategy").InitializedOperationData, svgDrawingHelper: import("../../../../types").SVGDrawingHelper) => void;
+    };
 };
 export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/index.js

@@ -9,6 +9,7 @@ import threshold from './threshold';
 import labelmapStatistics from './labelmapStatistics';
 import ensureSegmentationVolumeFor3DManipulation from './ensureSegmentationVolume';
 import ensureImageVolumeFor3DManipulation from './ensureImageVolume';
+import circularCursor from './circularCursor';
 export default {
     determineSegmentIndex,
     dynamicThreshold,
@@ -21,4 +22,5 @@ export default {
     labelmapStatistics,
     ensureSegmentationVolumeFor3DManipulation,
     ensureImageVolumeFor3DManipulation,
+    circularCursor
 };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.12.6";
+export declare const version = "4.13.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.12.6';
+export const version = '4.13.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.12.6",
+  "version": "4.13.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.12.6",
+    "@cornerstonejs/core": "4.13.0",
     "@kitware/vtk.js": "34.15.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "67da5ec35cb711e4310f0f1971bd8ed090377338"
+  "gitHead": "782d0a3cb60f0c174d5f5445f7c7092c544bb9d1"
 }