@cornerstonejs/tools 2.0.0-beta.8 → 2.0.1

package/dist/esm/tools/ReferenceLinesTool.js

@@ -16,7 +16,7 @@ class ReferenceLines extends AnnotationDisplayTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
+        this.editData = null;
         this._init = () => {
             const renderingEngines = getRenderingEngines();
             const renderingEngine = renderingEngines[0];
@@ -32,7 +32,7 @@ class ReferenceLines extends AnnotationDisplayTool {
             const { element } = sourceViewport;
             const { viewUp, viewPlaneNormal } = sourceViewport.getCamera();
             const sourceViewportCanvasCornersInWorld = csUtils.getViewportImageCornersInWorld(sourceViewport);
-            let annotation = this.editData.annotation;
+            let annotation = this.editData?.annotation;
             const FrameOfReferenceUID = sourceViewport.getFrameOfReferenceUID();
             if (!annotation) {
                 const newAnnotation = {
@@ -63,7 +63,7 @@ class ReferenceLines extends AnnotationDisplayTool {
                 renderingEngine,
                 annotation,
             };
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewports
+            triggerAnnotationRenderForViewportIds(viewports
                 .filter((viewport) => viewport.id !== sourceViewport.id)
                 .map((viewport) => viewport.id));
         };
@@ -78,6 +78,9 @@ class ReferenceLines extends AnnotationDisplayTool {
         };
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             const { viewport: targetViewport } = enabledElement;
+            if (!this.editData) {
+                return false;
+            }
             const { annotation, sourceViewportId } = this.editData;
             let renderStatus = false;
             const { viewport: sourceViewport } = getEnabledElementByViewportId(sourceViewportId) || {};
@@ -153,7 +156,7 @@ class ReferenceLines extends AnnotationDisplayTool {
     handleFullDimension(targetViewport, lineStartWorld, viewPlaneNormal, viewUp, lineEndWorld, canvasCoordinates) {
         const renderingEngine = targetViewport.getRenderingEngine();
         const targetId = this.getTargetId(targetViewport);
-        const targetImage = this.getTargetIdImage(targetId, renderingEngine);
+        const targetImage = this.getTargetImageData(targetId);
         const referencedImageId = this.getReferencedImageId(targetViewport, lineStartWorld, viewPlaneNormal, viewUp);
         if (referencedImageId && targetImage) {
             try {
@@ -221,4 +224,3 @@ class ReferenceLines extends AnnotationDisplayTool {
 }
 ReferenceLines.toolName = 'ReferenceLines';
 export default ReferenceLines;
-//# sourceMappingURL=ReferenceLinesTool.js.map

package/dist/esm/tools/ScaleOverlayTool.d.ts

@@ -0,0 +1,38 @@
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+import type { ScaleOverlayAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+declare class ScaleOverlayTool extends AnnotationDisplayTool {
+    static toolName: any;
+    _throttledCalculateCachedStats: Function;
+    editData: {
+        renderingEngine: Types.IRenderingEngine;
+        viewport: Types.IViewport;
+        annotation: ScaleOverlayAnnotation;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _init: () => void;
+    onSetToolEnabled: () => void;
+    onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
+    _getTextLines(scaleSize: number): string[] | undefined;
+    computeScaleSize: (worldWidthViewport: number, worldHeightViewport: number, location: string) => any;
+    computeEndScaleTicks: (canvasCoordinates: any, location: any) => {
+        endTick1: any[][];
+        endTick2: any[][];
+    };
+    computeInnerScaleTicks: (scaleSize: number, location: string, annotationUID: string, leftTick: Types.Point2[], rightTick: Types.Point2[]) => {
+        tickIds: any[];
+        tickUIDs: any[];
+        tickCoordinates: any[];
+    };
+    computeWorldScaleCoordinates: (scaleSize: any, location: any, pointSet: any) => any;
+    computeCanvasScaleCoordinates: (canvasSize: any, canvasCoordinates: any, vscaleBounds: any, hscaleBounds: any, location: any) => any;
+    computeScaleBounds: (canvasSize: any, horizontalReduction: any, verticalReduction: any, location: any) => {
+        height: any;
+        width: any;
+    };
+}
+export default ScaleOverlayTool;

package/dist/esm/tools/ScaleOverlayTool.js

@@ -4,7 +4,6 @@ import { getEnabledElementByIds, getRenderingEngines, utilities as csUtils, } fr
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
 import { drawLine as drawLineSvg, drawTextBox as drawTextBoxSvg, } from '../drawingSvg';
 import { getToolGroup } from '../store/ToolGroupManager';
-const SCALEOVERLAYTOOL_ID = 'scaleoverlay-viewport';
 const viewportsWithAnnotations = [];
 class ScaleOverlayTool extends AnnotationDisplayTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -14,7 +13,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
+        this.editData = null;
         this._init = () => {
             const renderingEngines = getRenderingEngines();
             const renderingEngine = renderingEngines[0];
@@ -45,27 +44,30 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
             if (annotations.length) {
                 annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
             }
-            if (!viewportsWithAnnotations.includes(viewport.id)) {
-                const newAnnotation = {
-                    metadata: {
-                        toolName: this.getToolName(),
-                        viewPlaneNormal: [...viewPlaneNormal],
-                        viewUp: [...viewUp],
-                        FrameOfReferenceUID,
-                        referencedImageId: null,
-                    },
-                    data: {
-                        handles: {
-                            points: viewportCanvasCornersInWorld,
+            enabledElements.forEach((element) => {
+                const { viewport } = element;
+                if (!viewportsWithAnnotations.includes(viewport.id)) {
+                    const newAnnotation = {
+                        metadata: {
+                            toolName: this.getToolName(),
+                            viewPlaneNormal: [...viewPlaneNormal],
+                            viewUp: [...viewUp],
+                            FrameOfReferenceUID,
+                            referencedImageId: null,
                         },
-                        viewportId: viewport.id,
-                    },
-                };
-                viewportsWithAnnotations.push(viewport.id);
-                addAnnotation(newAnnotation, viewport.element);
-                annotation = newAnnotation;
-            }
-            else if (this.editData.annotation &&
+                        data: {
+                            handles: {
+                                points: csUtils.getViewportImageCornersInWorld(viewport),
+                            },
+                            viewportId: viewport.id,
+                        },
+                    };
+                    viewportsWithAnnotations.push(viewport.id);
+                    addAnnotation(newAnnotation, viewport.element);
+                    annotation = newAnnotation;
+                }
+            });
+            if (this.editData.annotation &&
                 this.editData.annotation.data.viewportId == viewport.id) {
                 this.editData.annotation.data.handles.points =
                     viewportCanvasCornersInWorld;
@@ -393,4 +395,3 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
 }
 ScaleOverlayTool.toolName = 'ScaleOverlay';
 export default ScaleOverlayTool;
-//# sourceMappingURL=ScaleOverlayTool.js.map

package/dist/esm/tools/SculptorTool/CircleSculptCursor.d.ts

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ISculptToolShape } from '../../types/ISculptToolShape';
+import type { SculptData } from '../SculptorTool';
+import type { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
+export type PushedHandles = {
+    first?: number;
+    last?: number;
+};
+declare class CircleSculptCursor implements ISculptToolShape {
+    static shapeName: string;
+    private toolInfo;
+    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: unknown): void;
+    pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
+    configureToolSize(evt: EventTypes.InteractionEventType): void;
+    updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotationData): void;
+    getMaxSpacing(minSpacing: number): number;
+    getInsertPosition(previousIndex: number, nextIndex: number, sculptData: SculptData): Types.Point3;
+    private pushOneHandle;
+}
+export default CircleSculptCursor;

package/dist/esm/tools/SculptorTool/CircleSculptCursor.js

@@ -105,4 +105,3 @@ class CircleSculptCursor {
     }
 }
 export default CircleSculptCursor;
-//# sourceMappingURL=CircleSculptCursor.js.map

package/dist/esm/tools/SculptorTool.d.ts

@@ -0,0 +1,41 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from './base';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { ISculptToolShape } from '../types/ISculptToolShape';
+export type SculptData = {
+    mousePoint: Types.Point3;
+    mouseCanvasPoint: Types.Point2;
+    points: Array<Types.Point3>;
+    maxSpacing: number;
+    element: HTMLDivElement;
+};
+declare class SculptorTool extends BaseTool {
+    static toolName: string;
+    registeredShapes: Map<any, any>;
+    private isActive;
+    private selectedShape;
+    private commonData;
+    private sculptData?;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    registerShapes<T extends ISculptToolShape>(shapeName: string, shapeClass: new () => T): void;
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
+    protected sculpt(eventData: any, points: Array<Types.Point3>): void;
+    protected interpolatePointsWithinMaxSpacing(i: number, points: Array<Types.Point3>, indicesToInsertAfter: Array<number>, maxSpacing: number): void;
+    private updateCursor;
+    private filterSculptableAnnotationsForElement;
+    private configureToolSize;
+    private insertNewHandles;
+    private findNewHandleIndices;
+    private insertHandleRadially;
+    private selectFreehandTool;
+    private getClosestFreehandToolOnElement;
+    private endCallback;
+    private dragCallback;
+    protected activateModify(element: HTMLDivElement): void;
+    protected deactivateModify(element: HTMLDivElement): void;
+    setToolShape(toolShape: string): void;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
+}
+export declare const contourIndex: (i: number, length: number) => number;
+export default SculptorTool;

package/dist/esm/tools/SculptorTool.js

@@ -3,13 +3,13 @@ import { BaseTool } from './base';
 import { getAnnotations } from '../stateManagement';
 import { point } from '../utilities/math';
 import { Events, ToolModes, AnnotationStyleStates } from '../enums';
-import { ToolGroupManager } from '../store';
 import { triggerAnnotationRenderForViewportIds } from '../utilities/triggerAnnotationRenderForViewportIds';
 import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
 import { getStyleProperty } from '../stateManagement/annotation/config/helpers';
 import { triggerAnnotationModified } from '../stateManagement/annotation/helpers/state';
 import CircleSculptCursor from './SculptorTool/CircleSculptCursor';
 import { distancePointToContour } from './distancePointToContour';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
 class SculptorTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -63,7 +63,7 @@ class SculptorTool extends BaseTool {
             this.deactivateModify(element);
             resetElementCursor(element);
             const { renderingEngineId, viewportId } = enabledElement;
-            const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+            const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
             const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
             const annotations = this.filterSculptableAnnotationsForElement(element);
             const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
@@ -141,14 +141,14 @@ class SculptorTool extends BaseTool {
             const canvasCoords = eventData.currentPoints.canvas;
             cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
         }
-        triggerAnnotationRenderForViewportIds(renderingEngine, this.commonData.viewportIdsToRender);
+        triggerAnnotationRenderForViewportIds(this.commonData.viewportIdsToRender);
     }
     filterSculptableAnnotationsForElement(element) {
         const config = this.configuration;
         const enabledElement = getEnabledElement(element);
         const { renderingEngineId, viewportId } = enabledElement;
         const sculptableAnnotations = [];
-        const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+        const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
         const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
         config.referencedToolNames.forEach((referencedToolName) => {
             const annotations = getAnnotations(referencedToolName, element);
@@ -287,4 +287,3 @@ export const contourIndex = (i, length) => {
 };
 SculptorTool.toolName = 'SculptorTool';
 export default SculptorTool;
-//# sourceMappingURL=SculptorTool.js.map

package/dist/esm/tools/SegmentationIntersectionTool.d.ts

@@ -0,0 +1,18 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+import type { Annotation } from '../types';
+export interface SegmentationIntersectionAnnotation extends Annotation {
+    data: {
+        actorsWorldPointsMap: Map<string, Map<string, object>>;
+    };
+}
+declare class SegmentationIntersectionTool extends AnnotationDisplayTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _init: () => void;
+    onSetToolEnabled: () => void;
+    onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+}
+export default SegmentationIntersectionTool;

package/dist/esm/tools/SegmentationIntersectionTool.js

@@ -43,7 +43,7 @@ class SegmentationIntersectionTool extends AnnotationDisplayTool {
                 };
                 addAnnotation(newAnnotation, frameOfReferenceUID);
             }
-            triggerAnnotationRenderForViewportIds(getRenderingEngine(viewportsInfo[0].renderingEngineId), viewportsInfo.map(({ viewportId }) => viewportId));
+            triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
         };
         this.onSetToolEnabled = () => {
             this._init();
@@ -175,4 +175,3 @@ function removeExtraPoints(viewport, worldPointsSet) {
 }
 SegmentationIntersectionTool.toolName = 'SegmentationIntersection';
 export default SegmentationIntersectionTool;
-//# sourceMappingURL=SegmentationIntersectionTool.js.map

package/dist/esm/tools/StackScrollTool.d.ts

@@ -0,0 +1,15 @@
+import { BaseTool } from './base';
+import type { PublicToolProps, ToolProps, EventTypes } from '../types';
+declare class StackScrollTool extends BaseTool {
+    static toolName: any;
+    deltaY: number;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback(evt: EventTypes.MouseWheelEventType): void;
+    mouseDragCallback(evt: EventTypes.InteractionEventType): void;
+    touchDragCallback(evt: EventTypes.InteractionEventType): void;
+    _dragCallback(evt: EventTypes.InteractionEventType): void;
+    _scrollDrag(evt: EventTypes.InteractionEventType): void;
+    _scroll(evt: EventTypes.MouseWheelEventType): void;
+    _getPixelPerImage(viewport: any): number;
+}
+export default StackScrollTool;

package/dist/esm/tools/StackScrollTool.js

@@ -1,6 +1,5 @@
-import { getEnabledElementByIds, VolumeViewport } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, VolumeViewport, BaseVolumeViewport, utilities, } from '@cornerstonejs/core';
 import { BaseTool } from './base';
-import { scroll } from '../utilities';
 class StackScrollTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -13,6 +12,9 @@ class StackScrollTool extends BaseTool {
         super(toolProps, defaultToolProps);
         this.deltaY = 1;
     }
+    mouseWheelCallback(evt) {
+        this._scroll(evt);
+    }
     mouseDragCallback(evt) {
         this._dragCallback(evt);
     }
@@ -20,14 +22,16 @@ class StackScrollTool extends BaseTool {
         this._dragCallback(evt);
     }
     _dragCallback(evt) {
+        this._scrollDrag(evt);
+    }
+    _scrollDrag(evt) {
         const { deltaPoints, viewportId, renderingEngineId } = evt.detail;
         const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-        const targetId = this.getTargetId(viewport);
         const { debounceIfNotLoaded, invert, loop } = this.configuration;
         const deltaPointY = deltaPoints.canvas[1];
         let volumeId;
         if (viewport instanceof VolumeViewport) {
-            volumeId = targetId.split(/volumeId:|\?/)[1];
+            volumeId = viewport.getVolumeId();
         }
         const pixelsPerImage = this._getPixelPerImage(viewport);
         const deltaY = deltaPointY + this.deltaY;
@@ -36,7 +40,7 @@ class StackScrollTool extends BaseTool {
         }
         if (Math.abs(deltaY) >= pixelsPerImage) {
             const imageIdIndexOffset = Math.round(deltaY / pixelsPerImage);
-            scroll(viewport, {
+            utilities.scroll(viewport, {
                 delta: invert ? -imageIdIndexOffset : imageIdIndexOffset,
                 volumeId,
                 debounceLoading: debounceIfNotLoaded,
@@ -48,6 +52,22 @@ class StackScrollTool extends BaseTool {
             this.deltaY = deltaY;
         }
     }
+    _scroll(evt) {
+        const { wheel, element } = evt.detail;
+        const { direction } = wheel;
+        const { invert } = this.configuration;
+        const { viewport } = getEnabledElement(element);
+        const delta = direction * (invert ? -1 : 1);
+        utilities.scroll(viewport, {
+            delta,
+            debounceLoading: this.configuration.debounceIfNotLoaded,
+            loop: this.configuration.loop,
+            volumeId: viewport instanceof BaseVolumeViewport
+                ? viewport.getVolumeId()
+                : undefined,
+            scrollSlabs: this.configuration.scrollSlabs,
+        });
+    }
     _getPixelPerImage(viewport) {
         const { element } = viewport;
         const numberOfSlices = viewport.getNumberOfSlices();
@@ -56,4 +76,3 @@ class StackScrollTool extends BaseTool {
 }
 StackScrollTool.toolName = 'StackScroll';
 export default StackScrollTool;
-//# sourceMappingURL=StackScrollTool.js.map

package/dist/esm/tools/TrackballRotateTool.d.ts

@@ -0,0 +1,19 @@
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
+import { BaseTool } from './base';
+declare class TrackballRotateTool extends BaseTool {
+    static toolName: any;
+    touchDragCallback: (evt: EventTypes.InteractionEventType) => void;
+    mouseDragCallback: (evt: EventTypes.InteractionEventType) => void;
+    cleanUp: () => void;
+    _resizeObservers: Map<any, any>;
+    _viewportAddedListener: (evt: any) => void;
+    _hasResolutionChanged: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    _getViewportsInfo: () => any[];
+    onSetToolActive: () => void;
+    onSetToolDisabled: () => void;
+    rotateCamera: (viewport: any, centerWorld: any, axis: any, angle: any) => void;
+    _dragCallback(evt: EventTypes.InteractionEventType): void;
+}
+export default TrackballRotateTool;

package/dist/esm/tools/TrackballRotateTool.js

@@ -22,6 +22,10 @@ class TrackballRotateTool extends BaseTool {
             const actorEntry = viewport.getDefaultActor();
             const actor = actorEntry.actor;
             const mapper = actor.getMapper();
+            const hasSampleDistance = 'getSampleDistance' in mapper || 'getCurrentSampleDistance' in mapper;
+            if (!hasSampleDistance) {
+                return true;
+            }
             const originalSampleDistance = mapper.getSampleDistance();
             if (!this._hasResolutionChanged) {
                 mapper.setSampleDistance(originalSampleDistance * 2);
@@ -171,4 +175,3 @@ class TrackballRotateTool extends BaseTool {
 }
 TrackballRotateTool.toolName = 'TrackballRotate';
 export default TrackballRotateTool;
-//# sourceMappingURL=TrackballRotateTool.js.map

package/dist/esm/tools/VolumeRotateTool.d.ts

@@ -0,0 +1,10 @@
+import { BaseTool } from './base';
+import type { PublicToolProps, ToolProps } from '../types';
+import type { MouseWheelEventType } from '../types/EventTypes';
+declare class VolumeRotateTool extends BaseTool {
+    static toolName: any;
+    _configuration: unknown;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback(evt: MouseWheelEventType): void;
+}
+export default VolumeRotateTool;

package/dist/esm/tools/VolumeRotateTool.js

@@ -0,0 +1,52 @@
+import { BaseTool } from './base';
+import { getEnabledElement } from '@cornerstonejs/core';
+import { mat4, vec3 } from 'gl-matrix';
+const DIRECTIONS = {
+    X: [1, 0, 0],
+    Y: [0, 1, 0],
+    Z: [0, 0, 1],
+    CUSTOM: [],
+};
+class VolumeRotateTool extends BaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            direction: DIRECTIONS.Z,
+            rotateIncrementDegrees: 30,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+    }
+    mouseWheelCallback(evt) {
+        const { element, wheel } = evt.detail;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const { direction, rotateIncrementDegrees } = this.configuration;
+        const camera = viewport.getCamera();
+        const { viewUp, position, focalPoint } = camera;
+        const { direction: deltaY } = wheel;
+        const [cx, cy, cz] = focalPoint;
+        const [ax, ay, az] = direction;
+        const angle = (deltaY * (rotateIncrementDegrees * Math.PI)) / 180;
+        const newPosition = [0, 0, 0];
+        const newFocalPoint = [0, 0, 0];
+        const newViewUp = [0, 0, 0];
+        const transform = mat4.identity(new Float32Array(16));
+        mat4.translate(transform, transform, [cx, cy, cz]);
+        mat4.rotate(transform, transform, angle, [ax, ay, az]);
+        mat4.translate(transform, transform, [-cx, -cy, -cz]);
+        vec3.transformMat4(newPosition, position, transform);
+        vec3.transformMat4(newFocalPoint, focalPoint, transform);
+        mat4.identity(transform);
+        mat4.rotate(transform, transform, angle, [ax, ay, az]);
+        vec3.transformMat4(newViewUp, viewUp, transform);
+        viewport.setCamera({
+            position: newPosition,
+            viewUp: newViewUp,
+            focalPoint: newFocalPoint,
+        });
+        viewport.render();
+    }
+}
+VolumeRotateTool.toolName = 'VolumeRotateMouseWheel';
+export default VolumeRotateTool;

package/dist/esm/tools/WindowLevelRegionTool.d.ts

@@ -0,0 +1,26 @@
+import { AnnotationTool } from './base';
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, ToolProps, PublicToolProps, SVGDrawingHelper, Annotation } from '../types';
+declare class WindowLevelRegionTool extends AnnotationTool {
+    static toolName: any;
+    editData: {
+        annotation: Annotation;
+        viewportIdsToRender: string[];
+    } | null;
+    isDrawing: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => Annotation;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragCallback: (evt: EventTypes.InteractionEventType) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    applyWindowLevelRegion: (annotation: any, element: any) => void;
+    cancel: () => void;
+    isPointNearTool: () => any;
+    toolSelectedCallback: () => void;
+    handleSelectedCallback: () => void;
+    _activateModify: () => void;
+    _deactivateModify: () => void;
+}
+export default WindowLevelRegionTool;

package/dist/esm/tools/WindowLevelRegionTool.js

@@ -3,13 +3,12 @@ import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement';
 import { triggerAnnotationCompleted } from '../stateManagement/annotation/helpers/state';
 import { drawRect as drawRectSvg } from '../drawingSvg';
-import { state } from '../store';
+import { state } from '../store/state';
 import { Events } from '../enums';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
 import { resetElementCursor, hideElementCursor, } from '../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
 import { windowLevel } from '../utilities/voi';
-import { clip } from '../utilities';
 class WindowLevelRegionTool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -23,7 +22,7 @@ class WindowLevelRegionTool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
@@ -60,7 +59,7 @@ class WindowLevelRegionTool extends AnnotationTool {
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return annotation;
         };
         this._endCallback = (evt) => {
@@ -69,11 +68,10 @@ class WindowLevelRegionTool extends AnnotationTool {
             const { annotation, viewportIdsToRender } = this.editData;
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const { renderingEngine } = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             removeAnnotation(annotation.annotationUID);
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             triggerAnnotationCompleted(annotation);
             this.applyWindowLevelRegion(annotation, element);
         };
@@ -105,8 +103,7 @@ class WindowLevelRegionTool extends AnnotationTool {
             points[1] = bottomRightWorld;
             points[2] = topLeftWorld;
             annotation.invalidated = true;
-            const { renderingEngine } = enabledElement;
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._activateDraw = (element) => {
             state.isInteractingWithTool = true;
@@ -183,8 +180,8 @@ class WindowLevelRegionTool extends AnnotationTool {
             let top = Math.min(startCanvas[1], endCanvas[1]);
             let width = Math.abs(startCanvas[0] - endCanvas[0]);
             let height = Math.abs(startCanvas[1] - endCanvas[1]);
-            left = clip(left, 0, imageData.width);
-            top = clip(top, 0, imageData.height);
+            left = utilities.clip(left, 0, imageData.width);
+            top = utilities.clip(top, 0, imageData.height);
             width = Math.floor(Math.min(width, Math.abs(imageData.width - left)));
             height = Math.floor(Math.min(height, Math.abs(imageData.height - top)));
             const pixelLuminanceData = windowLevel.getLuminanceFromRegion(imageData, Math.round(left), Math.round(top), width, height);
@@ -220,4 +217,3 @@ class WindowLevelRegionTool extends AnnotationTool {
 }
 WindowLevelRegionTool.toolName = 'WindowLevelRegion';
 export default WindowLevelRegionTool;
-//# sourceMappingURL=WindowLevelRegionTool.js.map

package/dist/esm/tools/WindowLevelTool.d.ts

@@ -0,0 +1,37 @@
+import { BaseTool } from './base';
+import type { EventTypes } from '../types';
+declare class WindowLevelTool extends BaseTool {
+    static toolName: any;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+    });
+    touchDragCallback(evt: EventTypes.InteractionEventType): void;
+    mouseDragCallback(evt: EventTypes.InteractionEventType): void;
+    getPTScaledNewRange({ deltaPointsCanvas, lower, upper, clientHeight, viewport, volumeId, isPreScaled, }: {
+        deltaPointsCanvas: any;
+        lower: any;
+        upper: any;
+        clientHeight: any;
+        viewport: any;
+        volumeId: any;
+        isPreScaled: any;
+    }): {
+        lower: any;
+        upper: any;
+    };
+    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }: {
+        viewport: any;
+        deltaPointsCanvas: any;
+        volumeId: any;
+        lower: any;
+        upper: any;
+    }): {
+        lower: number;
+        upper: number;
+    };
+    _getMultiplierFromDynamicRange(viewport: any, volumeId: any): number;
+    _getImageDynamicRangeFromViewport(viewport: any): number;
+    _getImageDynamicRangeFromMiddleSlice: (scalarData: any, dimensions: any) => number;
+    private _getMinMax;
+}
+export default WindowLevelTool;