@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/tools/StackScrollTool.js

@@ -0,0 +1,78 @@
+import { getEnabledElementByIds, getEnabledElement, VolumeViewport, BaseVolumeViewport, utilities, } from '@cornerstonejs/core';
+import { BaseTool } from './base';
+class StackScrollTool extends BaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            invert: false,
+            debounceIfNotLoaded: true,
+            loop: false,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.deltaY = 1;
+    }
+    mouseWheelCallback(evt) {
+        this._scroll(evt);
+    }
+    mouseDragCallback(evt) {
+        this._dragCallback(evt);
+    }
+    touchDragCallback(evt) {
+        this._dragCallback(evt);
+    }
+    _dragCallback(evt) {
+        this._scrollDrag(evt);
+    }
+    _scrollDrag(evt) {
+        const { deltaPoints, viewportId, renderingEngineId } = evt.detail;
+        const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
+        const { debounceIfNotLoaded, invert, loop } = this.configuration;
+        const deltaPointY = deltaPoints.canvas[1];
+        let volumeId;
+        if (viewport instanceof VolumeViewport) {
+            volumeId = viewport.getVolumeId();
+        }
+        const pixelsPerImage = this._getPixelPerImage(viewport);
+        const deltaY = deltaPointY + this.deltaY;
+        if (!pixelsPerImage) {
+            return;
+        }
+        if (Math.abs(deltaY) >= pixelsPerImage) {
+            const imageIdIndexOffset = Math.round(deltaY / pixelsPerImage);
+            utilities.scroll(viewport, {
+                delta: invert ? -imageIdIndexOffset : imageIdIndexOffset,
+                volumeId,
+                debounceLoading: debounceIfNotLoaded,
+                loop: loop,
+            });
+            this.deltaY = deltaY % pixelsPerImage;
+        }
+        else {
+            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();
+        return Math.max(2, element.offsetHeight / Math.max(numberOfSlices, 8));
+    }
+}
+StackScrollTool.toolName = 'StackScroll';
+export default StackScrollTool;

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

@@ -0,0 +1,179 @@
+import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import { Events } from '../enums';
+import { eventTarget, getEnabledElement, getEnabledElementByIds, } from '@cornerstonejs/core';
+import { mat4, vec3 } from 'gl-matrix';
+import { BaseTool } from './base';
+import { getToolGroup } from '../store/ToolGroupManager';
+class TrackballRotateTool extends BaseTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            rotateIncrementDegrees: 2,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._resizeObservers = new Map();
+        this._hasResolutionChanged = false;
+        this.preMouseDownCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            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);
+                this._hasResolutionChanged = true;
+                if (this.cleanUp !== null) {
+                    document.removeEventListener('mouseup', this.cleanUp);
+                }
+                this.cleanUp = () => {
+                    mapper.setSampleDistance(originalSampleDistance);
+                    viewport.render();
+                    this._hasResolutionChanged = false;
+                };
+                document.addEventListener('mouseup', this.cleanUp, { once: true });
+            }
+            return true;
+        };
+        this._getViewportsInfo = () => {
+            const viewports = getToolGroup(this.toolGroupId).viewportsInfo;
+            return viewports;
+        };
+        this.onSetToolActive = () => {
+            const subscribeToElementResize = () => {
+                const viewportsInfo = this._getViewportsInfo();
+                viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                    if (!this._resizeObservers.has(viewportId)) {
+                        const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId) || { viewport: null };
+                        if (!viewport) {
+                            return;
+                        }
+                        const { element } = viewport;
+                        const resizeObserver = new ResizeObserver(() => {
+                            const element = getEnabledElementByIds(viewportId, renderingEngineId);
+                            if (!element) {
+                                return;
+                            }
+                            const { viewport } = element;
+                            const viewPresentation = viewport.getViewPresentation();
+                            viewport.resetCamera();
+                            viewport.setViewPresentation(viewPresentation);
+                            viewport.render();
+                        });
+                        resizeObserver.observe(element);
+                        this._resizeObservers.set(viewportId, resizeObserver);
+                    }
+                });
+            };
+            subscribeToElementResize();
+            this._viewportAddedListener = (evt) => {
+                if (evt.detail.toolGroupId === this.toolGroupId) {
+                    subscribeToElementResize();
+                }
+            };
+            eventTarget.addEventListener(Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
+        };
+        this.onSetToolDisabled = () => {
+            this._resizeObservers.forEach((resizeObserver, viewportId) => {
+                resizeObserver.disconnect();
+                this._resizeObservers.delete(viewportId);
+            });
+            if (this._viewportAddedListener) {
+                eventTarget.removeEventListener(Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
+                this._viewportAddedListener = null;
+            }
+        };
+        this.rotateCamera = (viewport, centerWorld, axis, angle) => {
+            const vtkCamera = viewport.getVtkActiveCamera();
+            const viewUp = vtkCamera.getViewUp();
+            const focalPoint = vtkCamera.getFocalPoint();
+            const position = vtkCamera.getPosition();
+            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, centerWorld);
+            mat4.rotate(transform, transform, angle, axis);
+            mat4.translate(transform, transform, [
+                -centerWorld[0],
+                -centerWorld[1],
+                -centerWorld[2],
+            ]);
+            vec3.transformMat4(newPosition, position, transform);
+            vec3.transformMat4(newFocalPoint, focalPoint, transform);
+            mat4.identity(transform);
+            mat4.rotate(transform, transform, angle, axis);
+            vec3.transformMat4(newViewUp, viewUp, transform);
+            viewport.setCamera({
+                position: newPosition,
+                viewUp: newViewUp,
+                focalPoint: newFocalPoint,
+            });
+        };
+        this.touchDragCallback = this._dragCallback.bind(this);
+        this.mouseDragCallback = this._dragCallback.bind(this);
+    }
+    _dragCallback(evt) {
+        const { element, currentPoints, lastPoints } = evt.detail;
+        const currentPointsCanvas = currentPoints.canvas;
+        const lastPointsCanvas = lastPoints.canvas;
+        const { rotateIncrementDegrees } = this.configuration;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const width = element.clientWidth;
+        const height = element.clientHeight;
+        const normalizedPosition = [
+            currentPointsCanvas[0] / width,
+            currentPointsCanvas[1] / height,
+        ];
+        const normalizedPreviousPosition = [
+            lastPointsCanvas[0] / width,
+            lastPointsCanvas[1] / height,
+        ];
+        const center = [width * 0.5, height * 0.5];
+        const centerWorld = viewport.canvasToWorld(center);
+        const normalizedCenter = [0.5, 0.5];
+        const radsq = (1.0 + Math.abs(normalizedCenter[0])) ** 2.0;
+        const op = [normalizedPreviousPosition[0], 0, 0];
+        const oe = [normalizedPosition[0], 0, 0];
+        const opsq = op[0] ** 2;
+        const oesq = oe[0] ** 2;
+        const lop = opsq > radsq ? 0 : Math.sqrt(radsq - opsq);
+        const loe = oesq > radsq ? 0 : Math.sqrt(radsq - oesq);
+        const nop = [op[0], 0, lop];
+        vtkMath.normalize(nop);
+        const noe = [oe[0], 0, loe];
+        vtkMath.normalize(noe);
+        const dot = vtkMath.dot(nop, noe);
+        if (Math.abs(dot) > 0.0001) {
+            const angleX = -2 *
+                Math.acos(vtkMath.clampValue(dot, -1.0, 1.0)) *
+                Math.sign(normalizedPosition[0] - normalizedPreviousPosition[0]) *
+                rotateIncrementDegrees;
+            const upVec = camera.viewUp;
+            const atV = camera.viewPlaneNormal;
+            const rightV = [0, 0, 0];
+            const forwardV = [0, 0, 0];
+            vtkMath.cross(upVec, atV, rightV);
+            vtkMath.normalize(rightV);
+            vtkMath.cross(atV, rightV, forwardV);
+            vtkMath.normalize(forwardV);
+            vtkMath.normalize(upVec);
+            this.rotateCamera(viewport, centerWorld, forwardV, angleX);
+            const angleY = (normalizedPreviousPosition[1] - normalizedPosition[1]) *
+                rotateIncrementDegrees;
+            this.rotateCamera(viewport, centerWorld, rightV, angleY);
+            viewport.render();
+        }
+    }
+}
+TrackballRotateTool.toolName = 'TrackballRotate';
+export default TrackballRotateTool;

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

@@ -0,0 +1,220 @@
+import { AnnotationTool } from './base';
+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/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';
+class WindowLevelRegionTool extends AnnotationTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            minWindowWidth: 10,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                invalidated: true,
+                highlighted: true,
+                metadata: {
+                    toolName: this.getToolName(),
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                },
+                data: {
+                    handles: {
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
+                    },
+                    cachedStats: {},
+                },
+            };
+            addAnnotation(annotation, element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+            };
+            this._activateDraw(element);
+            hideElementCursor(element);
+            evt.preventDefault();
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            return annotation;
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender } = this.editData;
+            this._deactivateDraw(element);
+            resetElementCursor(element);
+            this.editData = null;
+            this.isDrawing = false;
+            removeAnnotation(annotation.annotationUID);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            triggerAnnotationCompleted(annotation);
+            this.applyWindowLevelRegion(annotation, element);
+        };
+        this._dragCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender } = this.editData;
+            const { data } = annotation;
+            const { currentPoints } = eventDetail;
+            const enabledElement = getEnabledElement(element);
+            const { worldToCanvas, canvasToWorld } = enabledElement.viewport;
+            const worldPos = currentPoints.world;
+            const { points } = data.handles;
+            const DEFAULT_HANDLE_INDEX = 3;
+            points[DEFAULT_HANDLE_INDEX] = [...worldPos];
+            const bottomLeftCanvas = worldToCanvas(points[0]);
+            const topRightCanvas = worldToCanvas(points[3]);
+            const bottomRightCanvas = [
+                topRightCanvas[0],
+                bottomLeftCanvas[1],
+            ];
+            const topLeftCanvas = [
+                bottomLeftCanvas[0],
+                topRightCanvas[1],
+            ];
+            const bottomRightWorld = canvasToWorld(bottomRightCanvas);
+            const topLeftWorld = canvasToWorld(topLeftCanvas);
+            points[1] = bottomRightWorld;
+            points[2] = topLeftWorld;
+            annotation.invalidated = true;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        };
+        this._activateDraw = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateDraw = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = getAnnotations(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { points } = data.handles;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                styleSpecifier.annotationUID = annotationUID;
+                const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                const dataId = `${annotationUID}-rect`;
+                const rectangleUID = '0';
+                drawRectSvg(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates[0], canvasCoordinates[3], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                }, dataId);
+                renderStatus = true;
+            }
+            return renderStatus;
+        };
+        this.applyWindowLevelRegion = (annotation, element) => {
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const imageData = windowLevel.extractWindowLevelRegionToolData(viewport);
+            const { data } = annotation;
+            const { points } = data.handles;
+            const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+            const startCanvas = canvasCoordinates[0];
+            const endCanvas = canvasCoordinates[3];
+            let left = Math.min(startCanvas[0], endCanvas[0]);
+            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 = 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);
+            const minMaxMean = windowLevel.calculateMinMaxMean(pixelLuminanceData, imageData.minPixelValue, imageData.maxPixelValue);
+            if (this.configuration.minWindowWidth === undefined) {
+                this.configuration.minWindowWidth = 10;
+            }
+            const windowWidth = Math.max(Math.abs(minMaxMean.max - minMaxMean.min), this.configuration.minWindowWidth);
+            const windowCenter = minMaxMean.mean;
+            const voiLutFunction = viewport.getProperties().VOILUTFunction;
+            const voiRange = utilities.windowLevel.toLowHighRange(windowWidth, windowCenter, voiLutFunction);
+            viewport.setProperties({ voiRange });
+            viewport.render();
+        };
+        this.cancel = () => {
+            return null;
+        };
+        this.isPointNearTool = () => {
+            return null;
+        };
+        this.toolSelectedCallback = () => {
+            return null;
+        };
+        this.handleSelectedCallback = () => {
+            return null;
+        };
+        this._activateModify = () => {
+            return null;
+        };
+        this._deactivateModify = () => {
+            return null;
+        };
+    }
+}
+WindowLevelRegionTool.toolName = 'WindowLevelRegion';
+export default WindowLevelRegionTool;

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;