@ohif/app 3.9.0-beta.57 → 3.9.0-beta.59

package/dist/{29.bundle.976319462f33868497c2.js → 117.bundle.403581eea72534ff9c7e.js}

@@ -1,4 +1,731 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[29,497],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[117,497],{
+
+/***/ 49001:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(72076);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7187);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(30023);
+/* harmony import */ var _helpers_cpuFallback_rendering_transform__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(30742);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(56309);
+/* harmony import */ var _Viewport__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(77614);
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(25281);
+/* harmony import */ var _CanvasActor__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(40046);
+/* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(82253);
+
+
+
+
+
+
+
+
+
+class VideoViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z {
+    constructor(props) {
+        super({
+            ...props,
+            canvas: props.canvas || (0,_helpers__WEBPACK_IMPORTED_MODULE_6__/* .getOrCreateCanvas */ .uy)(props.element),
+        });
+        this.videoWidth = 0;
+        this.videoHeight = 0;
+        this.loop = true;
+        this.mute = true;
+        this.isPlaying = false;
+        this.scrollSpeed = 1;
+        this.playbackRate = 1;
+        this.frameRange = [0, 0];
+        this.fps = 30;
+        this.videoCamera = {
+            panWorld: [0, 0],
+            parallelScale: 1,
+        };
+        this.voiRange = {
+            lower: 0,
+            upper: 255,
+        };
+        this.getProperties = () => {
+            return {
+                loop: this.videoElement.loop,
+                muted: this.videoElement.muted,
+                playbackRate: this.playbackRate,
+                scrollSpeed: this.scrollSpeed,
+                voiRange: { ...this.voiRange },
+            };
+        };
+        this.resetCamera = () => {
+            this.refreshRenderValues();
+            this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+            if (this.isPlaying === false) {
+                this.renderFrame();
+            }
+            return true;
+        };
+        this.getNumberOfSlices = () => {
+            const computedSlices = Math.round((this.videoElement.duration * this.fps) / this.scrollSpeed);
+            return isNaN(computedSlices) ? this.numberOfFrames : computedSlices;
+        };
+        this.getFrameOfReferenceUID = () => {
+            return this.videoElement.src;
+        };
+        this.resize = () => {
+            const canvas = this.canvas;
+            const { clientWidth, clientHeight } = canvas;
+            if (canvas.width !== clientWidth || canvas.height !== clientHeight) {
+                canvas.width = clientWidth;
+                canvas.height = clientHeight;
+            }
+            this.refreshRenderValues();
+            if (this.isPlaying === false) {
+                this.renderFrame();
+            }
+        };
+        this.canvasToWorld = (canvasPos, destPos = [0, 0, 0]) => {
+            const pan = this.videoCamera.panWorld;
+            const worldToCanvasRatio = this.getWorldToCanvasRatio();
+            const panOffsetCanvas = [
+                pan[0] * worldToCanvasRatio,
+                pan[1] * worldToCanvasRatio,
+            ];
+            const subCanvasPos = [
+                canvasPos[0] - panOffsetCanvas[0],
+                canvasPos[1] - panOffsetCanvas[1],
+            ];
+            destPos.splice(0, 2, subCanvasPos[0] / worldToCanvasRatio, subCanvasPos[1] / worldToCanvasRatio);
+            return destPos;
+        };
+        this.worldToCanvas = (worldPos) => {
+            const pan = this.videoCamera.panWorld;
+            const worldToCanvasRatio = this.getWorldToCanvasRatio();
+            const canvasPos = [
+                (worldPos[0] + pan[0]) * worldToCanvasRatio,
+                (worldPos[1] + pan[1]) * worldToCanvasRatio,
+            ];
+            return canvasPos;
+        };
+        this.getRotation = () => 0;
+        this.canvasToIndex = (canvasPos) => {
+            const transform = this.getTransform();
+            transform.invert();
+            return transform.transformPoint(canvasPos.map((it) => it * devicePixelRatio));
+        };
+        this.indexToCanvas = (indexPos) => {
+            const transform = this.getTransform();
+            return (transform.transformPoint(indexPos).map((it) => it / devicePixelRatio));
+        };
+        this.customRenderViewportToCanvas = () => {
+            this.renderFrame();
+        };
+        this.renderFrame = () => {
+            const transform = this.getTransform();
+            const transformationMatrix = transform.getMatrix();
+            const ctx = this.canvasContext;
+            ctx.resetTransform();
+            ctx.transform(transformationMatrix[0], transformationMatrix[1], transformationMatrix[2], transformationMatrix[3], transformationMatrix[4], transformationMatrix[5]);
+            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth || 1024, this.videoHeight || 1024);
+            for (const actor of this.getActors()) {
+                actor.actor.render(this, this.canvasContext);
+            }
+            this.canvasContext.resetTransform();
+            (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.STACK_NEW_IMAGE, {
+                element: this.element,
+                viewportId: this.id,
+                viewport: this,
+                renderingEngineId: this.renderingEngineId,
+                time: this.videoElement.currentTime,
+                duration: this.videoElement.duration,
+            });
+            (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.IMAGE_RENDERED, {
+                element: this.element,
+                viewportId: this.id,
+                viewport: this,
+                imageIndex: this.getCurrentImageIdIndex(),
+                numberOfSlices: this.numberOfFrames,
+                renderingEngineId: this.renderingEngineId,
+                time: this.videoElement.currentTime,
+                duration: this.videoElement.duration,
+            });
+            this.initialRender?.();
+            const frame = this.getFrameNumber();
+            if (this.isPlaying) {
+                if (frame < this.frameRange[0]) {
+                    this.setFrameNumber(this.frameRange[0]);
+                }
+                else if (frame > this.frameRange[1]) {
+                    if (this.loop) {
+                        this.setFrameNumber(this.frameRange[0]);
+                    }
+                    else {
+                        this.pause();
+                    }
+                }
+            }
+        };
+        this.renderWhilstPlaying = () => {
+            this.renderFrame();
+            if (this.isPlaying) {
+                requestAnimationFrame(this.renderWhilstPlaying);
+            }
+        };
+        this.canvasContext = this.canvas.getContext('2d');
+        this.renderingEngineId = props.renderingEngineId;
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+        this.videoElement = document.createElement('video');
+        this.videoElement.muted = this.mute;
+        this.videoElement.loop = this.loop;
+        this.videoElement.autoplay = true;
+        this.videoElement.crossOrigin = 'anonymous';
+        this.addEventListeners();
+        this.resize();
+    }
+    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
+    static get useCustomRenderingPipeline() {
+        return true;
+    }
+    addEventListeners() {
+        this.canvas.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.ELEMENT_DISABLED, this.elementDisabledHandler);
+    }
+    removeEventListeners() {
+        this.canvas.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.ELEMENT_DISABLED, this.elementDisabledHandler);
+    }
+    elementDisabledHandler() {
+        this.removeEventListeners();
+        this.videoElement.remove();
+    }
+    getImageDataMetadata(image) {
+        const imageId = typeof image === 'string' ? image : image.imageId;
+        const imagePlaneModule = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.IMAGE_PLANE, imageId);
+        let rowCosines = imagePlaneModule.rowCosines;
+        let columnCosines = imagePlaneModule.columnCosines;
+        if (rowCosines == null || columnCosines == null) {
+            rowCosines = [1, 0, 0];
+            columnCosines = [0, 1, 0];
+        }
+        const rowCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .R3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+        const colCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .R3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+        const { rows, columns } = imagePlaneModule;
+        const scanAxisNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .R3.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .R3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+        let origin = imagePlaneModule.imagePositionPatient;
+        if (origin == null) {
+            origin = [0, 0, 0];
+        }
+        const xSpacing = imagePlaneModule.columnPixelSpacing || 1;
+        const ySpacing = imagePlaneModule.rowPixelSpacing || 1;
+        const xVoxels = imagePlaneModule.columns;
+        const yVoxels = imagePlaneModule.rows;
+        const zSpacing = 1;
+        const zVoxels = 1;
+        this.hasPixelSpacing = !!imagePlaneModule.columnPixelSpacing;
+        return {
+            bitsAllocated: 8,
+            numComps: 3,
+            origin,
+            rows,
+            columns,
+            direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
+            dimensions: [xVoxels, yVoxels, zVoxels],
+            spacing: [xSpacing, ySpacing, zSpacing],
+            hasPixelSpacing: this.hasPixelSpacing,
+            numVoxels: xVoxels * yVoxels * zVoxels,
+            imagePlaneModule,
+        };
+    }
+    setDataIds(imageIds, options) {
+        this.setVideo(imageIds[0], options?.viewReference?.sliceIndex || 1);
+    }
+    setVideo(imageId, frameNumber) {
+        this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
+        const imageUrlModule = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.IMAGE_URL, imageId);
+        if (!imageUrlModule?.rendered) {
+            throw new Error(`Video Image ID ${imageId} does not have a rendered video view`);
+        }
+        const { rendered } = imageUrlModule;
+        const generalSeries = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.GENERAL_SERIES, imageId);
+        this.modality = generalSeries?.Modality;
+        this.metadata = this.getImageDataMetadata(imageId);
+        let { cineRate, numberOfFrames } = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.CINE, imageId);
+        this.numberOfFrames = numberOfFrames;
+        return this.setVideoURL(rendered).then(() => {
+            if (!numberOfFrames || numberOfFrames === 1) {
+                numberOfFrames = Math.round(this.videoElement.duration * (cineRate || 30));
+            }
+            if (!cineRate) {
+                cineRate = Math.round(numberOfFrames / this.videoElement.duration);
+            }
+            this.fps = cineRate;
+            this.numberOfFrames = numberOfFrames;
+            this.setFrameRange([1, numberOfFrames]);
+            this.initialRender = () => {
+                this.initialRender = null;
+                this.pause();
+                this.setFrameNumber(frameNumber || 1);
+            };
+            return new Promise((resolve) => {
+                window.setTimeout(() => {
+                    this.setFrameNumber(frameNumber || 1);
+                    resolve(this);
+                }, 25);
+            });
+        });
+    }
+    async setVideoURL(videoURL) {
+        return new Promise((resolve) => {
+            this.videoElement.src = videoURL;
+            this.videoElement.preload = 'auto';
+            const loadedMetadataEventHandler = () => {
+                this.videoWidth = this.videoElement.videoWidth;
+                this.videoHeight = this.videoElement.videoHeight;
+                this.videoElement.removeEventListener('loadedmetadata', loadedMetadataEventHandler);
+                this.refreshRenderValues();
+                resolve(true);
+            };
+            this.videoElement.addEventListener('loadedmetadata', loadedMetadataEventHandler);
+        });
+    }
+    getImageIds() {
+        const imageIds = new Array(this.numberOfFrames);
+        const baseImageId = this.imageId.replace(/[0-9]+$/, '');
+        for (let i = 0; i < this.numberOfFrames; i++) {
+            imageIds[i] = `${baseImageId}${i + 1}`;
+        }
+        return imageIds;
+    }
+    togglePlayPause() {
+        if (this.isPlaying) {
+            this.pause();
+            return false;
+        }
+        else {
+            this.play();
+            return true;
+        }
+    }
+    async play() {
+        try {
+            if (!this.isPlaying) {
+                this.isPlaying = true;
+                await this.videoElement.play();
+                this.renderWhilstPlaying();
+            }
+        }
+        catch (e) {
+        }
+    }
+    pause() {
+        try {
+            this.isPlaying = false;
+            this.videoElement.pause();
+        }
+        catch (e) {
+        }
+    }
+    async scroll(delta = 1) {
+        await this.pause();
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        const currentTime = videoElement.currentTime;
+        const newTime = currentTime + (delta * this.scrollSpeed) / this.fps;
+        videoElement.currentTime = newTime;
+        const seekEventListener = (evt) => {
+            renderFrame();
+            videoElement.removeEventListener('seeked', seekEventListener);
+        };
+        videoElement.addEventListener('seeked', seekEventListener);
+    }
+    async start() {
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        videoElement.currentTime = 0;
+        if (videoElement.paused) {
+            const seekEventListener = (evt) => {
+                renderFrame();
+                videoElement.removeEventListener('seeked', seekEventListener);
+            };
+            videoElement.addEventListener('seeked', seekEventListener);
+        }
+    }
+    async end() {
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        videoElement.currentTime = videoElement.duration;
+        if (videoElement.paused) {
+            const seekEventListener = (evt) => {
+                renderFrame();
+                videoElement.removeEventListener('seeked', seekEventListener);
+            };
+            videoElement.addEventListener('seeked', seekEventListener);
+        }
+    }
+    async setTime(timeInSeconds) {
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        videoElement.currentTime = timeInSeconds;
+        if (videoElement.paused) {
+            const seekEventListener = (evt) => {
+                renderFrame();
+                videoElement.removeEventListener('seeked', seekEventListener);
+            };
+            videoElement.addEventListener('seeked', seekEventListener);
+        }
+    }
+    async setFrameNumber(frame) {
+        this.setTime((frame - 1) / this.fps);
+    }
+    setFrameRange(frameRange) {
+        if (!frameRange) {
+            this.frameRange = [1, this.numberOfFrames];
+            return;
+        }
+        if (frameRange.length !== 2 || frameRange[0] === frameRange[1]) {
+            return;
+        }
+        this.frameRange = [frameRange[0], frameRange[1]];
+    }
+    getFrameRange() {
+        return this.frameRange;
+    }
+    setProperties(props) {
+        if (props.loop !== undefined) {
+            this.videoElement.loop = props.loop;
+        }
+        if (props.muted !== undefined) {
+            this.videoElement.muted = props.muted;
+        }
+        if (props.playbackRate !== undefined) {
+            this.setPlaybackRate(props.playbackRate);
+        }
+        if (props.scrollSpeed !== undefined) {
+            this.setScrollSpeed(props.scrollSpeed);
+        }
+        if (props.voiRange) {
+            this.setVOI(props.voiRange);
+        }
+    }
+    setPlaybackRate(rate = 1) {
+        this.playbackRate = rate;
+        if (rate < 0.0625) {
+            this.pause();
+            return;
+        }
+        if (!this.videoElement) {
+            return;
+        }
+        this.videoElement.playbackRate = rate;
+        this.play();
+    }
+    setScrollSpeed(scrollSpeed = 1, unit = _enums__WEBPACK_IMPORTED_MODULE_1__.VideoEnums.SpeedUnit.FRAME) {
+        this.scrollSpeed =
+            unit === _enums__WEBPACK_IMPORTED_MODULE_1__.VideoEnums.SpeedUnit.SECOND
+                ? scrollSpeed * this.fps
+                : scrollSpeed;
+    }
+    resetProperties() {
+        this.setProperties({
+            loop: false,
+            muted: true,
+        });
+    }
+    getScalarData() {
+        if (this.scalarData?.frameNumber === this.getFrameNumber()) {
+            return this.scalarData;
+        }
+        const canvas = document.createElement('canvas');
+        canvas.width = this.videoWidth;
+        canvas.height = this.videoHeight;
+        const context = canvas.getContext('2d');
+        context.drawImage(this.videoElement, 0, 0);
+        const canvasData = context.getImageData(0, 0, this.videoWidth, this.videoHeight);
+        const scalarData = canvasData.data;
+        scalarData.getRange = () => [0, 255];
+        scalarData.frameNumber = this.getFrameNumber();
+        this.scalarData = scalarData;
+        return scalarData;
+    }
+    getImageData() {
+        const { metadata } = this;
+        const spacing = metadata.spacing;
+        const imageData = {
+            dimensions: metadata.dimensions,
+            spacing,
+            origin: metadata.origin,
+            direction: metadata.direction,
+            metadata: { Modality: this.modality },
+            getScalarData: () => this.getScalarData(),
+            imageData: {
+                getDirection: () => metadata.direction,
+                getDimensions: () => metadata.dimensions,
+                getRange: () => [0, 255],
+                getScalarData: () => this.getScalarData(),
+                getSpacing: () => metadata.spacing,
+                worldToIndex: (point) => {
+                    const canvasPoint = this.worldToCanvas(point);
+                    const pixelCoord = this.canvasToIndex(canvasPoint);
+                    return [pixelCoord[0], pixelCoord[1], 0];
+                },
+                indexToWorld: (point, destPoint) => {
+                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                    return this.canvasToWorld(canvasPoint, destPoint);
+                },
+            },
+            hasPixelSpacing: this.hasPixelSpacing,
+            calibration: this.calibration,
+            preScale: {
+                scaled: false,
+            },
+        };
+        Object.defineProperty(imageData, 'scalarData', {
+            get: () => this.getScalarData(),
+            enumerable: true,
+        });
+        return imageData;
+    }
+    hasImageURI(imageURI) {
+        const framesMatch = imageURI.match(VideoViewport.frameRangeExtractor);
+        const testURI = framesMatch
+            ? imageURI.substring(0, framesMatch.index)
+            : imageURI;
+        return this.imageId.indexOf(testURI) !== -1;
+    }
+    setVOI(voiRange) {
+        this.voiRange = voiRange;
+        this.setColorTransform();
+    }
+    setWindowLevel(windowWidth = 256, windowCenter = 128) {
+        const lower = windowCenter - windowWidth / 2;
+        const upper = windowCenter + windowWidth / 2 - 1;
+        this.setVOI({ lower, upper });
+        this.setColorTransform();
+    }
+    setAverageWhite(averageWhite) {
+        this.averageWhite = averageWhite;
+        this.setColorTransform();
+    }
+    setColorTransform() {
+        if (!this.voiRange && !this.averageWhite) {
+            this.feFilter = null;
+            return;
+        }
+        const white = this.averageWhite || [255, 255, 255];
+        const maxWhite = Math.max(...white);
+        const scaleWhite = white.map((c) => maxWhite / c);
+        const { lower = 0, upper = 255 } = this.voiRange || {};
+        const wlScale = (upper - lower + 1) / 255;
+        const wlDelta = lower / 255;
+        this.feFilter = `url('data:image/svg+xml,\
+      <svg xmlns="http://www.w3.org/2000/svg">\
+        <filter id="colour" color-interpolation-filters="linearRGB">\
+        <feColorMatrix type="matrix" \
+        values="\
+          ${scaleWhite[0] * wlScale} 0 0 0 ${wlDelta} \
+          0 ${scaleWhite[1] * wlScale} 0 0 ${wlDelta} \
+          0 0 ${scaleWhite[2] * wlScale} 0 ${wlDelta} \
+          0 0 0 1 0" />\
+        </filter>\
+      </svg>#colour')`;
+        this.canvas.style.filter = this.feFilter;
+    }
+    setCamera(camera) {
+        const { parallelScale, focalPoint } = camera;
+        if (parallelScale) {
+            this.videoCamera.parallelScale =
+                this.element.clientHeight / 2 / parallelScale;
+        }
+        if (focalPoint !== undefined) {
+            const focalPointCanvas = this.worldToCanvas(focalPoint);
+            const canvasCenter = [
+                this.element.clientWidth / 2,
+                this.element.clientHeight / 2,
+            ];
+            const panWorldDelta = [
+                (focalPointCanvas[0] - canvasCenter[0]) /
+                    this.videoCamera.parallelScale,
+                (focalPointCanvas[1] - canvasCenter[1]) /
+                    this.videoCamera.parallelScale,
+            ];
+            this.videoCamera.panWorld = [
+                this.videoCamera.panWorld[0] - panWorldDelta[0],
+                this.videoCamera.panWorld[1] - panWorldDelta[1],
+            ];
+        }
+        this.canvasContext.fillStyle = 'rgba(0,0,0,1)';
+        this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        if (this.isPlaying === false) {
+            this.renderFrame();
+        }
+    }
+    getCurrentImageId() {
+        const current = this.imageId.replace('/frames/1', this.isPlaying
+            ? `/frames/${this.frameRange[0]}-${this.frameRange[1]}`
+            : `/frames/${this.getFrameNumber()}`);
+        return current;
+    }
+    getReferenceId(specifier = {}) {
+        const { sliceIndex: sliceIndex } = specifier;
+        if (sliceIndex === undefined) {
+            return `videoId:${this.getCurrentImageId()}`;
+        }
+        if (Array.isArray(sliceIndex)) {
+            return `videoId:${this.imageId.substring(0, this.imageId.length - 1)}${sliceIndex[0] + 1}-${sliceIndex[1] + 1}`;
+        }
+        const baseTarget = this.imageId.replace('/frames/1', `/frames/${1 + sliceIndex}`);
+        return `videoId:${baseTarget}`;
+    }
+    isReferenceViewable(viewRef, options = {}) {
+        let { imageURI } = options;
+        const { referencedImageId, sliceIndex: sliceIndex } = viewRef;
+        if (!super.isReferenceViewable(viewRef)) {
+            return false;
+        }
+        const imageId = this.getCurrentImageId();
+        if (!imageURI) {
+            const colonIndex = imageId.indexOf(':');
+            imageURI = imageId.substring(colonIndex + 1, imageId.length - 1);
+        }
+        if (options.withNavigation) {
+            return true;
+        }
+        const currentIndex = this.getSliceIndex();
+        if (Array.isArray(sliceIndex)) {
+            return currentIndex >= sliceIndex[0] && currentIndex <= sliceIndex[1];
+        }
+        if (sliceIndex !== undefined) {
+            return currentIndex === sliceIndex;
+        }
+        if (!referencedImageId) {
+            return false;
+        }
+        const match = referencedImageId.match(VideoViewport.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return true;
+        }
+        const range = match[2].split('-').map((it) => Number(it));
+        const frame = currentIndex + 1;
+        return range[0] <= frame && frame <= (range[1] ?? range[0]);
+    }
+    setViewReference(viewRef) {
+        if (typeof viewRef.sliceIndex === 'number') {
+            this.setFrameNumber(viewRef.sliceIndex + 1);
+        }
+        else if (Array.isArray(viewRef.sliceIndex)) {
+            this.setFrameRange(viewRef.sliceIndex);
+        }
+    }
+    getViewReference(viewRefSpecifier) {
+        let sliceIndex = viewRefSpecifier?.sliceIndex;
+        if (!sliceIndex) {
+            sliceIndex = this.isPlaying
+                ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
+                : this.getCurrentImageIdIndex();
+        }
+        return {
+            ...super.getViewReference(viewRefSpecifier),
+            referencedImageId: this.getReferenceId(viewRefSpecifier),
+            sliceIndex: sliceIndex,
+        };
+    }
+    getFrameNumber() {
+        return 1 + this.getCurrentImageIdIndex();
+    }
+    getCurrentImageIdIndex() {
+        return Math.round(this.videoElement.currentTime * this.fps);
+    }
+    getSliceIndex() {
+        return this.getCurrentImageIdIndex() / this.scrollSpeed;
+    }
+    getCamera() {
+        const { parallelScale } = this.videoCamera;
+        const canvasCenter = [
+            this.element.clientWidth / 2,
+            this.element.clientHeight / 2,
+        ];
+        const canvasCenterWorld = this.canvasToWorld(canvasCenter);
+        return {
+            parallelProjection: true,
+            focalPoint: canvasCenterWorld,
+            position: [0, 0, 0],
+            viewUp: [0, -1, 0],
+            parallelScale: this.element.clientHeight / 2 / parallelScale,
+            viewPlaneNormal: [0, 0, 1],
+        };
+    }
+    getFrameRate() {
+        return this.fps;
+    }
+    getPan() {
+        const panWorld = this.videoCamera.panWorld;
+        return [panWorld[0], panWorld[1]];
+    }
+    refreshRenderValues() {
+        let worldToCanvasRatio = this.canvas.offsetWidth / this.videoWidth;
+        if (this.videoHeight * worldToCanvasRatio > this.canvas.height) {
+            worldToCanvasRatio = this.canvas.offsetHeight / this.videoHeight;
+        }
+        const drawWidth = Math.floor(this.videoWidth * worldToCanvasRatio);
+        const drawHeight = Math.floor(this.videoHeight * worldToCanvasRatio);
+        const xOffsetCanvas = (this.canvas.offsetWidth - drawWidth) / 2;
+        const yOffsetCanvas = (this.canvas.offsetHeight - drawHeight) / 2;
+        const xOffsetWorld = xOffsetCanvas / worldToCanvasRatio;
+        const yOffsetWorld = yOffsetCanvas / worldToCanvasRatio;
+        this.videoCamera.panWorld = [xOffsetWorld, yOffsetWorld];
+        this.videoCamera.parallelScale = worldToCanvasRatio;
+    }
+    getWorldToCanvasRatio() {
+        return this.videoCamera.parallelScale;
+    }
+    getCanvasToWorldRatio() {
+        return 1.0 / this.videoCamera.parallelScale;
+    }
+    getTransform() {
+        const panWorld = this.videoCamera.panWorld;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const worldToCanvasRatio = this.getWorldToCanvasRatio();
+        const canvasToWorldRatio = this.getCanvasToWorldRatio();
+        const halfCanvas = [
+            this.canvas.offsetWidth / 2,
+            this.canvas.offsetHeight / 2,
+        ];
+        const halfCanvasWorldCoordinates = [
+            halfCanvas[0] * canvasToWorldRatio,
+            halfCanvas[1] * canvasToWorldRatio,
+        ];
+        const transform = new _helpers_cpuFallback_rendering_transform__WEBPACK_IMPORTED_MODULE_3__/* .Transform */ .w();
+        transform.scale(devicePixelRatio, devicePixelRatio);
+        transform.translate(halfCanvas[0], halfCanvas[1]);
+        transform.scale(worldToCanvasRatio, worldToCanvasRatio);
+        transform.translate(panWorld[0], panWorld[1]);
+        transform.translate(-halfCanvasWorldCoordinates[0], -halfCanvasWorldCoordinates[1]);
+        return transform;
+    }
+    updateCameraClippingPlanesAndRange() {
+    }
+    addImages(stackInputs) {
+        const actors = this.getActors();
+        stackInputs.forEach((stackInput) => {
+            const image = _cache__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .ZP.getImage(stackInput.imageId);
+            const imageActor = this.createActorMapper(image);
+            if (imageActor) {
+                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                if (stackInput.callback) {
+                    stackInput.callback({ imageActor, imageId: stackInput.imageId });
+                }
+            }
+        });
+        this.setActors(actors);
+    }
+    createActorMapper(image) {
+        return new _CanvasActor__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z(this, image);
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (VideoViewport);
+
+
+/***/ }),
 
 /***/ 68467:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -1023,8 +1750,8 @@ function storedPixelDataToCanvasImageDataPseudocolorLUTPET(image, lutFunction, c
 }
 /* harmony default export */ const rendering_storedPixelDataToCanvasImageDataPseudocolorLUTPET = (storedPixelDataToCanvasImageDataPseudocolorLUTPET);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 67 modules
-var utilities = __webpack_require__(11723);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 66 modules
+var utilities = __webpack_require__(56309);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderPseudoColorImage.js
 
 
@@ -1633,6 +2360,97 @@ function relativeRescale(enabledElement, oldCanvasWidth, oldCanvasHeight) {
 }
 
 
+/***/ }),
+
+/***/ 30742:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   w: () => (/* binding */ Transform)
+/* harmony export */ });
+class Transform {
+    constructor() {
+        this.reset();
+    }
+    getMatrix() {
+        return this.m;
+    }
+    reset() {
+        this.m = [1, 0, 0, 1, 0, 0];
+    }
+    clone() {
+        const transform = new Transform();
+        transform.m[0] = this.m[0];
+        transform.m[1] = this.m[1];
+        transform.m[2] = this.m[2];
+        transform.m[3] = this.m[3];
+        transform.m[4] = this.m[4];
+        transform.m[5] = this.m[5];
+        return transform;
+    }
+    multiply(matrix) {
+        const m11 = this.m[0] * matrix[0] + this.m[2] * matrix[1];
+        const m12 = this.m[1] * matrix[0] + this.m[3] * matrix[1];
+        const m21 = this.m[0] * matrix[2] + this.m[2] * matrix[3];
+        const m22 = this.m[1] * matrix[2] + this.m[3] * matrix[3];
+        const dx = this.m[0] * matrix[4] + this.m[2] * matrix[5] + this.m[4];
+        const dy = this.m[1] * matrix[4] + this.m[3] * matrix[5] + this.m[5];
+        this.m[0] = m11;
+        this.m[1] = m12;
+        this.m[2] = m21;
+        this.m[3] = m22;
+        this.m[4] = dx;
+        this.m[5] = dy;
+    }
+    invert() {
+        const d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
+        const m0 = this.m[3] * d;
+        const m1 = -this.m[1] * d;
+        const m2 = -this.m[2] * d;
+        const m3 = this.m[0] * d;
+        const m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
+        const m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
+        this.m[0] = m0;
+        this.m[1] = m1;
+        this.m[2] = m2;
+        this.m[3] = m3;
+        this.m[4] = m4;
+        this.m[5] = m5;
+    }
+    rotate(rad) {
+        const c = Math.cos(rad);
+        const s = Math.sin(rad);
+        const m11 = this.m[0] * c + this.m[2] * s;
+        const m12 = this.m[1] * c + this.m[3] * s;
+        const m21 = this.m[0] * -s + this.m[2] * c;
+        const m22 = this.m[1] * -s + this.m[3] * c;
+        this.m[0] = m11;
+        this.m[1] = m12;
+        this.m[2] = m21;
+        this.m[3] = m22;
+    }
+    translate(x, y) {
+        this.m[4] += this.m[0] * x + this.m[2] * y;
+        this.m[5] += this.m[1] * x + this.m[3] * y;
+    }
+    scale(sx, sy) {
+        this.m[0] *= sx;
+        this.m[1] *= sx;
+        this.m[2] *= sy;
+        this.m[3] *= sy;
+    }
+    transformPoint(point) {
+        const x = point[0];
+        const y = point[1];
+        return [
+            x * this.m[0] + y * this.m[2] + this.m[4],
+            x * this.m[1] + y * this.m[3] + this.m[5],
+        ];
+    }
+}
+
+
 /***/ }),
 
 /***/ 6737:
@@ -1820,8 +2638,8 @@ var vtkVolume$1 = {
 var volumeLoader = __webpack_require__(18588);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/createVolumeMapper.js
 var createVolumeMapper = __webpack_require__(49046);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 67 modules
-var utilities = __webpack_require__(11723);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 66 modules
+var utilities = __webpack_require__(56309);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js + 4 modules
 var enums = __webpack_require__(7187);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.js
@@ -1891,7 +2709,7 @@ function triggerVOIModified(element, viewportId, volumeActor, volumeId) {
 /* harmony export */ });
 /* harmony import */ var _loaders_imageLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62990);
 /* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30023);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(56309);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7187);
 /* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(82253);
 
@@ -2072,240 +2890,35 @@ const newInstance = _kitware_vtk_js_macros__WEBPACK_IMPORTED_MODULE_0__/* ["defa
 
 /***/ }),
 
-/***/ 90261:
+/***/ 5287:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (/* binding */ Settings)
+/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-const DEFAULT_SETTINGS = Symbol('DefaultSettings');
-const RUNTIME_SETTINGS = Symbol('RuntimeSettings');
-const OBJECT_SETTINGS_MAP = Symbol('ObjectSettingsMap');
-const DICTIONARY = Symbol('Dictionary');
-class Settings {
-    constructor(base) {
-        const dictionary = Object.create((base instanceof Settings && DICTIONARY in base
-            ? base[DICTIONARY]
-            : null));
-        Object.seal(Object.defineProperty(this, DICTIONARY, {
-            value: dictionary,
-        }));
-    }
-    set(key, value) {
-        return set(this[DICTIONARY], key, value, null);
-    }
-    get(key) {
-        return get(this[DICTIONARY], key);
-    }
-    unset(key) {
-        return unset(this[DICTIONARY], key + '');
-    }
-    forEach(callback) {
-        iterate(this[DICTIONARY], callback);
-    }
-    extend() {
-        return new Settings(this);
-    }
-    import(root) {
-        if (isPlainObject(root)) {
-            Object.keys(root).forEach((key) => {
-                set(this[DICTIONARY], key, root[key], null);
-            });
-        }
-    }
-    dump() {
-        const context = {};
-        iterate(this[DICTIONARY], (key, value) => {
-            if (typeof value !== 'undefined') {
-                deepSet(context, key, value);
-            }
-        });
-        return context;
-    }
-    static assert(subject) {
-        return subject instanceof Settings
-            ? subject
-            : Settings.getRuntimeSettings();
-    }
-    static getDefaultSettings(subfield = null) {
-        let defaultSettings = Settings[DEFAULT_SETTINGS];
-        if (!(defaultSettings instanceof Settings)) {
-            defaultSettings = new Settings();
-            Settings[DEFAULT_SETTINGS] = defaultSettings;
-        }
-        if (subfield) {
-            const settingObj = {};
-            defaultSettings.forEach((name) => {
-                if (name.startsWith(subfield)) {
-                    const setting = name.split(`${subfield}.`)[1];
-                    settingObj[setting] = defaultSettings.get(name);
-                }
-            });
-            return settingObj;
-        }
-        return defaultSettings;
-    }
-    static getRuntimeSettings() {
-        let runtimeSettings = Settings[RUNTIME_SETTINGS];
-        if (!(runtimeSettings instanceof Settings)) {
-            runtimeSettings = new Settings(Settings.getDefaultSettings());
-            Settings[RUNTIME_SETTINGS] = runtimeSettings;
-        }
-        return runtimeSettings;
-    }
-    static getObjectSettings(subject, from) {
-        let settings = null;
-        if (subject instanceof Settings) {
-            settings = subject;
-        }
-        else if (typeof subject === 'object' && subject !== null) {
-            let objectSettingsMap = Settings[OBJECT_SETTINGS_MAP];
-            if (!(objectSettingsMap instanceof WeakMap)) {
-                objectSettingsMap = new WeakMap();
-                Settings[OBJECT_SETTINGS_MAP] = objectSettingsMap;
-            }
-            settings = objectSettingsMap.get(subject);
-            if (!(settings instanceof Settings)) {
-                settings = new Settings(Settings.assert(Settings.getObjectSettings(from)));
-                objectSettingsMap.set(subject, settings);
-            }
-        }
-        return settings;
-    }
-    static extendRuntimeSettings() {
-        return Settings.getRuntimeSettings().extend();
-    }
-}
-function unset(dictionary, name) {
-    if (name.endsWith('.')) {
-        let deleteCount = 0;
-        const namespace = name;
-        const base = namespace.slice(0, -1);
-        const deleteAll = base.length === 0;
-        for (const key in dictionary) {
-            if (Object.prototype.hasOwnProperty.call(dictionary, key) &&
-                (deleteAll || key.startsWith(namespace) || key === base)) {
-                delete dictionary[key];
-                ++deleteCount;
-            }
-        }
-        return deleteCount > 0;
-    }
-    return delete dictionary[name];
-}
-function iterate(dictionary, callback) {
-    for (const key in dictionary) {
-        callback(key, dictionary[key]);
-    }
-}
-function setAll(dictionary, prefix, record, references) {
-    let failCount;
-    if (references.has(record)) {
-        return set(dictionary, prefix, null, references);
-    }
-    references.add(record);
-    failCount = 0;
-    for (const field in record) {
-        if (Object.prototype.hasOwnProperty.call(record, field)) {
-            const key = field.length === 0 ? prefix : `${prefix}.${field}`;
-            if (!set(dictionary, key, record[field], references)) {
-                ++failCount;
-            }
-        }
-    }
-    references.delete(record);
-    return failCount === 0;
-}
-function set(dictionary, key, value, references) {
-    if (isValidKey(key)) {
-        if (isPlainObject(value)) {
-            return setAll(dictionary, key, value, references instanceof WeakSet ? references : new WeakSet());
-        }
-        dictionary[key] = value;
-        return true;
-    }
-    return false;
-}
-function get(dictionary, key) {
-    return dictionary[key];
-}
-function isValidKey(key) {
-    let last, current, previous;
-    if (typeof key !== 'string' || (last = key.length - 1) < 0) {
-        return false;
-    }
-    previous = -1;
-    while ((current = key.indexOf('.', previous + 1)) >= 0) {
-        if (current - previous < 2 || current === last) {
-            return false;
-        }
-        previous = current;
-    }
-    return true;
-}
-function isPlainObject(subject) {
-    if (typeof subject === 'object' && subject !== null) {
-        const prototype = Object.getPrototypeOf(subject);
-        if (prototype === Object.prototype || prototype === null) {
-            return true;
-        }
-    }
-    return false;
-}
-function deepSet(context, key, value) {
-    const separator = key.indexOf('.');
-    if (separator >= 0) {
-        const subKey = key.slice(0, separator);
-        let subContext = context[subKey];
-        if (typeof subContext !== 'object' || subContext === null) {
-            const subContextValue = subContext;
-            subContext = {};
-            if (typeof subContextValue !== 'undefined') {
-                subContext[''] = subContextValue;
-            }
-            context[subKey] = subContext;
-        }
-        deepSet(subContext, key.slice(separator + 1, key.length), value);
-    }
-    else {
-        context[key] = value;
-    }
-}
-Settings.getDefaultSettings().set('useCursors', true);
-
-
-/***/ }),
-
-/***/ 5287:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-/* unused harmony export Cache */
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11723);
-/* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74238);
-/* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19546);
-/* harmony import */ var _classes_ImageVolume__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(84326);
-
-
-
-
-const ONE_GB = 1073741824;
-class Cache {
-    constructor() {
-        this._imageCache = new Map();
-        this._volumeCache = new Map();
-        this._imageCacheSize = 0;
-        this._volumeCacheSize = 0;
-        this._maxCacheSize = 3 * ONE_GB;
-        this._maxInstanceSize = 4 * ONE_GB - 8;
-        this.setMaxCacheSize = (newMaxCacheSize) => {
-            if (!newMaxCacheSize || typeof newMaxCacheSize !== 'number') {
-                const errorMessage = `New max cacheSize ${this._maxCacheSize} should be defined and should be a number.`;
-                throw new Error(errorMessage);
+/* unused harmony export Cache */
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(56309);
+/* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74238);
+/* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19546);
+/* harmony import */ var _classes_ImageVolume__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(84326);
+
+
+
+
+const ONE_GB = 1073741824;
+class Cache {
+    constructor() {
+        this._imageCache = new Map();
+        this._volumeCache = new Map();
+        this._imageCacheSize = 0;
+        this._volumeCacheSize = 0;
+        this._maxCacheSize = 3 * ONE_GB;
+        this._maxInstanceSize = 4 * ONE_GB - 8;
+        this.setMaxCacheSize = (newMaxCacheSize) => {
+            if (!newMaxCacheSize || typeof newMaxCacheSize !== 'number') {
+                const errorMessage = `New max cacheSize ${this._maxCacheSize} should be defined and should be a number.`;
+                throw new Error(errorMessage);
             }
             this._maxCacheSize = newMaxCacheSize;
         };
@@ -2322,7 +2935,11 @@ class Cache {
         this.getMaxInstanceSize = () => this._maxInstanceSize;
         this.getCacheSize = () => this._imageCacheSize + this._volumeCacheSize;
         this._decacheImage = (imageId) => {
-            const { imageLoadObject } = this._imageCache.get(imageId);
+            const cachedImage = this._imageCache.get(imageId);
+            if (!cachedImage) {
+                return;
+            }
+            const { imageLoadObject } = cachedImage;
             if (imageLoadObject.cancelFn) {
                 imageLoadObject.cancelFn();
             }
@@ -2333,7 +2950,13 @@ class Cache {
         };
         this._decacheVolume = (volumeId) => {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volumeLoadObject, volume } = cachedVolume;
+            if (!volume) {
+                return;
+            }
             if (volume.cancelLoading) {
                 volume.cancelLoading();
             }
@@ -2379,7 +3002,7 @@ class Cache {
                 throw new Error('getVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
@@ -2390,7 +3013,7 @@ class Cache {
                 throw new Error('getGeometry: geometryId must not be undefined');
             }
             const cachedGeometry = this._geometryCache.get(geometryId);
-            if (cachedGeometry === undefined) {
+            if (!cachedGeometry) {
                 return;
             }
             cachedGeometry.timeStamp = Date.now();
@@ -2401,7 +3024,7 @@ class Cache {
                 throw new Error('getImage: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 return;
             }
             cachedImage.timeStamp = Date.now();
@@ -2412,7 +3035,7 @@ class Cache {
                 throw new Error('getVolume: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
@@ -2433,7 +3056,7 @@ class Cache {
                 throw new Error('removeImageLoadObject: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 throw new Error('removeImageLoadObject: imageId was not present in imageCache');
             }
             this.incrementImageCacheSize(-cachedImage.sizeInBytes);
@@ -2449,7 +3072,7 @@ class Cache {
                 throw new Error('removeVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 throw new Error('removeVolumeLoadObject: volumeId was not present in volumeCache');
             }
             this.incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
@@ -2616,7 +3239,7 @@ class Cache {
             throw new Error('getImageLoadObject: imageId must not be undefined');
         }
         const cachedImage = this._imageCache.get(imageId);
-        if (cachedImage === undefined) {
+        if (!cachedImage) {
             return;
         }
         cachedImage.timeStamp = Date.now();
@@ -2634,6 +3257,9 @@ class Cache {
         const imageIdToUse = (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.imageIdToURI)(imageId);
         for (const volumeId of volumeIds) {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volume } = cachedVolume;
             if (!volume?.imageIds?.length) {
                 return;
@@ -2739,32 +3365,49 @@ const cache = new Cache();
 
 /***/ }),
 
-/***/ 34061:
+/***/ 19247:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-const EPSILON = 1e-3;
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (EPSILON);
-
 
-/***/ }),
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  EPSILON: () => (/* reexport */ epsilon),
+  MPR_CAMERA_VALUES: () => (/* reexport */ mprCameraValues/* default */.Z),
+  RENDERING_DEFAULTS: () => (/* reexport */ rendering),
+  VIEWPORT_PRESETS: () => (/* reexport */ viewportPresets/* default */.Z)
+});
 
-/***/ 87525:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+// UNUSED EXPORTS: BACKGROUND_COLORS, CPU_COLORMAPS
 
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/cpuColormaps.js
+var cpuColormaps = __webpack_require__(52813);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/rendering.js
 const RENDERING_DEFAULTS = {
     MINIMUM_SLAB_THICKNESS: 5e-2,
     MAXIMUM_RAY_DISTANCE: 1e6,
 };
 Object.freeze(RENDERING_DEFAULTS);
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (RENDERING_DEFAULTS);
+/* harmony default export */ const rendering = (RENDERING_DEFAULTS);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/epsilon.js
+const EPSILON = 1e-3;
+/* harmony default export */ const epsilon = (EPSILON);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/mprCameraValues.js + 1 modules
+var mprCameraValues = __webpack_require__(21306);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/viewportPresets.js
+var viewportPresets = __webpack_require__(89469);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/backgroundColors.js
+var backgroundColors = __webpack_require__(43220);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/index.js
+
+
+
+
+
+
+
 
 
 /***/ }),
@@ -2811,98 +3454,478 @@ var ViewportStatus;
 /***/ 7187:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-"use strict";
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BlendModes: () => (/* reexport */ enums_BlendModes),
+  CalibrationTypes: () => (/* reexport */ enums_CalibrationTypes),
+  DynamicOperatorType: () => (/* reexport */ enums_DynamicOperatorType),
+  Events: () => (/* reexport */ Events/* default */.Z),
+  GeometryType: () => (/* reexport */ enums_GeometryType),
+  ImageQualityStatus: () => (/* reexport */ ImageQualityStatus/* default */.Z),
+  InterpolationType: () => (/* reexport */ InterpolationType/* default */.Z),
+  MetadataModules: () => (/* reexport */ MetadataModules/* default */.Z),
+  OrientationAxis: () => (/* reexport */ OrientationAxis/* default */.Z),
+  RequestType: () => (/* reexport */ RequestType/* default */.Z),
+  SharedArrayBufferModes: () => (/* reexport */ SharedArrayBufferModes/* default */.Z),
+  VOILUTFunctionType: () => (/* reexport */ VOILUTFunctionType/* default */.Z),
+  VideoEnums: () => (/* reexport */ VideoEnums),
+  ViewportStatus: () => (/* reexport */ ViewportStatus/* default */.Z),
+  ViewportType: () => (/* reexport */ ViewportType/* default */.Z)
+});
+
+// UNUSED EXPORTS: ContourType
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/Events.js
+var Events = __webpack_require__(19546);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/RequestType.js
+var RequestType = __webpack_require__(49334);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportType.js
+var ViewportType = __webpack_require__(68032);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/InterpolationType.js
+var InterpolationType = __webpack_require__(75677);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/VolumeMapper/Constants.js
+var Constants = __webpack_require__(83336);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/BlendModes.js
+
+const { BlendMode } = Constants["default"];
+var BlendModes;
+(function (BlendModes) {
+    BlendModes[BlendModes["COMPOSITE"] = 0] = "COMPOSITE";
+    BlendModes[BlendModes["MAXIMUM_INTENSITY_BLEND"] = 1] = "MAXIMUM_INTENSITY_BLEND";
+    BlendModes[BlendModes["MINIMUM_INTENSITY_BLEND"] = 2] = "MINIMUM_INTENSITY_BLEND";
+    BlendModes[BlendModes["AVERAGE_INTENSITY_BLEND"] = 3] = "AVERAGE_INTENSITY_BLEND";
+})(BlendModes || (BlendModes = {}));
+/* harmony default export */ const enums_BlendModes = (BlendModes);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/OrientationAxis.js
+var OrientationAxis = __webpack_require__(96426);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/SharedArrayBufferModes.js
+var SharedArrayBufferModes = __webpack_require__(91799);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/GeometryType.js
+var GeometryType;
+(function (GeometryType) {
+    GeometryType["CONTOUR"] = "contour";
+    GeometryType["SURFACE"] = "Surface";
+})(GeometryType || (GeometryType = {}));
+/* harmony default export */ const enums_GeometryType = (GeometryType);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ContourType.js
+var ContourType = __webpack_require__(2689);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VOILUTFunctionType.js
+var VOILUTFunctionType = __webpack_require__(67751);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/DynamicOperatorType.js
+var DynamicOperatorType;
+(function (DynamicOperatorType) {
+    DynamicOperatorType["SUM"] = "SUM";
+    DynamicOperatorType["AVERAGE"] = "AVERAGE";
+    DynamicOperatorType["SUBTRACT"] = "SUBTRACT";
+})(DynamicOperatorType || (DynamicOperatorType = {}));
+/* harmony default export */ const enums_DynamicOperatorType = (DynamicOperatorType);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/CalibrationTypes.js
+var CalibrationTypes;
+(function (CalibrationTypes) {
+    CalibrationTypes["NOT_APPLICABLE"] = "";
+    CalibrationTypes["ERMF"] = "ERMF";
+    CalibrationTypes["USER"] = "User";
+    CalibrationTypes["PROJECTION"] = "Proj";
+    CalibrationTypes["REGION"] = "Region";
+    CalibrationTypes["ERROR"] = "Error";
+    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
+})(CalibrationTypes || (CalibrationTypes = {}));
+/* harmony default export */ const enums_CalibrationTypes = (CalibrationTypes);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportStatus.js
+var ViewportStatus = __webpack_require__(84659);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ImageQualityStatus.js
+var ImageQualityStatus = __webpack_require__(83521);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VideoEnums.js
+var VideoEnums = __webpack_require__(40373);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/MetadataModules.js
+var MetadataModules = __webpack_require__(636);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 65279:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   O: () => (/* binding */ getEnabledElementByIds),
+/* harmony export */   Yz: () => (/* binding */ getEnabledElementByViewportId),
+/* harmony export */   ZP: () => (/* binding */ getEnabledElement),
+/* harmony export */   wN: () => (/* binding */ getEnabledElements)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9138);
+
+function getEnabledElement(element) {
+    if (!element) {
+        return;
+    }
+    const { viewportUid, renderingEngineUid } = element.dataset;
+    return getEnabledElementByIds(viewportUid, renderingEngineUid);
+}
+function getEnabledElementByIds(viewportId, renderingEngineId) {
+    if (!renderingEngineId || !viewportId) {
+        return;
+    }
+    const renderingEngine = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(renderingEngineId);
+    if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
+        return;
+    }
+    const viewport = renderingEngine.getViewport(viewportId);
+    if (!viewport) {
+        return;
+    }
+    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+    return {
+        viewport,
+        renderingEngine,
+        viewportId,
+        renderingEngineId,
+        FrameOfReferenceUID,
+    };
+}
+function getEnabledElementByViewportId(viewportId) {
+    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
+    for (let i = 0; i < renderingEngines.length; i++) {
+        const renderingEngine = renderingEngines[i];
+        const viewport = renderingEngine.getViewport(viewportId);
+        if (viewport) {
+            return getEnabledElementByIds(viewportId, renderingEngine.id);
+        }
+    }
+}
+function getEnabledElements() {
+    const enabledElements = [];
+    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
+    renderingEngines.forEach((renderingEngine) => {
+        const viewports = renderingEngine.getViewports();
+        viewports.forEach(({ element }) => {
+            enabledElements.push(getEnabledElement(element));
+        });
+    });
+    return enabledElements;
+}
+
+
+/***/ }),
+
+/***/ 12651:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BaseVolumeViewport: () => (/* reexport */ BaseVolumeViewport/* default */.Z),
+  CONSTANTS: () => (/* reexport */ constants),
+  EVENTS: () => (/* reexport */ enums.Events),
+  Enums: () => (/* reexport */ enums),
+  Settings: () => (/* reexport */ Settings),
+  StackViewport: () => (/* reexport */ StackViewport/* default */.Z),
+  VideoViewport: () => (/* reexport */ VideoViewport/* default */.Z),
+  VolumeViewport: () => (/* reexport */ VolumeViewport/* default */.Z),
+  VolumeViewport3D: () => (/* reexport */ VolumeViewport3D/* default */.Z),
+  addImageSlicesToViewports: () => (/* reexport */ helpers/* addImageSlicesToViewports */.PN),
+  addVolumesToViewports: () => (/* reexport */ helpers/* addVolumesToViewports */.gc),
+  cache: () => (/* reexport */ cache/* default */.ZP),
+  eventTarget: () => (/* reexport */ eventTarget/* default */.Z),
+  geometryLoader: () => (/* reexport */ geometryLoader),
+  getConfiguration: () => (/* reexport */ init/* getConfiguration */.P_),
+  getEnabledElement: () => (/* reexport */ getEnabledElement/* default */.ZP),
+  getEnabledElementByIds: () => (/* reexport */ getEnabledElement/* getEnabledElementByIds */.O),
+  getEnabledElementByViewportId: () => (/* reexport */ getEnabledElement/* getEnabledElementByViewportId */.Yz),
+  getEnabledElements: () => (/* reexport */ getEnabledElement/* getEnabledElements */.wN),
+  getRenderingEngine: () => (/* reexport */ getRenderingEngine/* getRenderingEngine */.Pr),
+  getRenderingEngines: () => (/* reexport */ getRenderingEngine/* getRenderingEngines */.Uu),
+  getWebWorkerManager: () => (/* reexport */ init/* getWebWorkerManager */.Pt),
+  imageLoadPoolManager: () => (/* reexport */ imageLoadPoolManager/* default */.Z),
+  imageLoader: () => (/* reexport */ imageLoader),
+  metaData: () => (/* reexport */ metaData),
+  triggerEvent: () => (/* reexport */ triggerEvent/* default */.Z),
+  utilities: () => (/* reexport */ utilities),
+  volumeLoader: () => (/* reexport */ volumeLoader)
+});
+
+// UNUSED EXPORTS: ImageVolume, ProgressiveRetrieveImages, RenderingEngine, Surface, Viewport, WSIViewport, canRenderFloatTextures, createVolumeActor, createVolumeMapper, getOrCreateCanvas, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, imageRetrievalPoolManager, init, isCornerstoneInitialized, peerImport, registerImageLoader, requestPoolManager, resetUseCPURendering, resetUseSharedArrayBuffer, setConfiguration, setPreferSizeOverAccuracy, setUseCPURendering, setUseSharedArrayBuffer, setVolumesForViewports
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js + 4 modules
+var enums = __webpack_require__(7187);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/index.js + 2 modules
+var constants = __webpack_require__(19247);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/index.js + 3 modules
+var RenderingEngine = __webpack_require__(69552);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/VolumeViewport.js
+var VolumeViewport = __webpack_require__(32932);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/VolumeViewport3D.js
+var VolumeViewport3D = __webpack_require__(46190);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/BaseVolumeViewport.js
+var BaseVolumeViewport = __webpack_require__(36205);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/StackViewport.js
+var StackViewport = __webpack_require__(98715);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/VideoViewport.js
+var VideoViewport = __webpack_require__(49001);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/WSIViewport.js
+var WSIViewport = __webpack_require__(86057);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/Viewport.js
+var Viewport = __webpack_require__(77614);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/eventTarget.js
+var eventTarget = __webpack_require__(74238);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/getRenderingEngine.js
+var getRenderingEngine = __webpack_require__(9138);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/cache/index.js
+var cache = __webpack_require__(82253);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/requestPool/imageRetrievalPoolManager.js
+var imageRetrievalPoolManager = __webpack_require__(22717);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/requestPool/imageLoadPoolManager.js
+var imageLoadPoolManager = __webpack_require__(96506);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/getEnabledElement.js
+var getEnabledElement = __webpack_require__(65279);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/metaData.js
+var metaData = __webpack_require__(30023);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/init.js + 1 modules
+var init = __webpack_require__(28719);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/Settings.js
+const DEFAULT_SETTINGS = Symbol('DefaultSettings');
+const RUNTIME_SETTINGS = Symbol('RuntimeSettings');
+const OBJECT_SETTINGS_MAP = Symbol('ObjectSettingsMap');
+const DICTIONARY = Symbol('Dictionary');
+class Settings {
+    constructor(base) {
+        const dictionary = Object.create((base instanceof Settings && DICTIONARY in base
+            ? base[DICTIONARY]
+            : null));
+        Object.seal(Object.defineProperty(this, DICTIONARY, {
+            value: dictionary,
+        }));
+    }
+    set(key, value) {
+        return set(this[DICTIONARY], key, value, null);
+    }
+    get(key) {
+        return get(this[DICTIONARY], key);
+    }
+    unset(key) {
+        return unset(this[DICTIONARY], key + '');
+    }
+    forEach(callback) {
+        iterate(this[DICTIONARY], callback);
+    }
+    extend() {
+        return new Settings(this);
+    }
+    import(root) {
+        if (isPlainObject(root)) {
+            Object.keys(root).forEach((key) => {
+                set(this[DICTIONARY], key, root[key], null);
+            });
+        }
+    }
+    dump() {
+        const context = {};
+        iterate(this[DICTIONARY], (key, value) => {
+            if (typeof value !== 'undefined') {
+                deepSet(context, key, value);
+            }
+        });
+        return context;
+    }
+    static assert(subject) {
+        return subject instanceof Settings
+            ? subject
+            : Settings.getRuntimeSettings();
+    }
+    static getDefaultSettings(subfield = null) {
+        let defaultSettings = Settings[DEFAULT_SETTINGS];
+        if (!(defaultSettings instanceof Settings)) {
+            defaultSettings = new Settings();
+            Settings[DEFAULT_SETTINGS] = defaultSettings;
+        }
+        if (subfield) {
+            const settingObj = {};
+            defaultSettings.forEach((name) => {
+                if (name.startsWith(subfield)) {
+                    const setting = name.split(`${subfield}.`)[1];
+                    settingObj[setting] = defaultSettings.get(name);
+                }
+            });
+            return settingObj;
+        }
+        return defaultSettings;
+    }
+    static getRuntimeSettings() {
+        let runtimeSettings = Settings[RUNTIME_SETTINGS];
+        if (!(runtimeSettings instanceof Settings)) {
+            runtimeSettings = new Settings(Settings.getDefaultSettings());
+            Settings[RUNTIME_SETTINGS] = runtimeSettings;
+        }
+        return runtimeSettings;
+    }
+    static getObjectSettings(subject, from) {
+        let settings = null;
+        if (subject instanceof Settings) {
+            settings = subject;
+        }
+        else if (typeof subject === 'object' && subject !== null) {
+            let objectSettingsMap = Settings[OBJECT_SETTINGS_MAP];
+            if (!(objectSettingsMap instanceof WeakMap)) {
+                objectSettingsMap = new WeakMap();
+                Settings[OBJECT_SETTINGS_MAP] = objectSettingsMap;
+            }
+            settings = objectSettingsMap.get(subject);
+            if (!(settings instanceof Settings)) {
+                settings = new Settings(Settings.assert(Settings.getObjectSettings(from)));
+                objectSettingsMap.set(subject, settings);
+            }
+        }
+        return settings;
+    }
+    static extendRuntimeSettings() {
+        return Settings.getRuntimeSettings().extend();
+    }
+}
+function unset(dictionary, name) {
+    if (name.endsWith('.')) {
+        let deleteCount = 0;
+        const namespace = name;
+        const base = namespace.slice(0, -1);
+        const deleteAll = base.length === 0;
+        for (const key in dictionary) {
+            if (Object.prototype.hasOwnProperty.call(dictionary, key) &&
+                (deleteAll || key.startsWith(namespace) || key === base)) {
+                delete dictionary[key];
+                ++deleteCount;
+            }
+        }
+        return deleteCount > 0;
+    }
+    return delete dictionary[name];
+}
+function iterate(dictionary, callback) {
+    for (const key in dictionary) {
+        callback(key, dictionary[key]);
+    }
+}
+function setAll(dictionary, prefix, record, references) {
+    let failCount;
+    if (references.has(record)) {
+        return set(dictionary, prefix, null, references);
+    }
+    references.add(record);
+    failCount = 0;
+    for (const field in record) {
+        if (Object.prototype.hasOwnProperty.call(record, field)) {
+            const key = field.length === 0 ? prefix : `${prefix}.${field}`;
+            if (!set(dictionary, key, record[field], references)) {
+                ++failCount;
+            }
+        }
+    }
+    references.delete(record);
+    return failCount === 0;
+}
+function set(dictionary, key, value, references) {
+    if (isValidKey(key)) {
+        if (isPlainObject(value)) {
+            return setAll(dictionary, key, value, references instanceof WeakSet ? references : new WeakSet());
+        }
+        dictionary[key] = value;
+        return true;
+    }
+    return false;
+}
+function get(dictionary, key) {
+    return dictionary[key];
+}
+function isValidKey(key) {
+    let last, current, previous;
+    if (typeof key !== 'string' || (last = key.length - 1) < 0) {
+        return false;
+    }
+    previous = -1;
+    while ((current = key.indexOf('.', previous + 1)) >= 0) {
+        if (current - previous < 2 || current === last) {
+            return false;
+        }
+        previous = current;
+    }
+    return true;
+}
+function isPlainObject(subject) {
+    if (typeof subject === 'object' && subject !== null) {
+        const prototype = Object.getPrototypeOf(subject);
+        if (prototype === Object.prototype || prototype === null) {
+            return true;
+        }
+    }
+    return false;
+}
+function deepSet(context, key, value) {
+    const separator = key.indexOf('.');
+    if (separator >= 0) {
+        const subKey = key.slice(0, separator);
+        let subContext = context[subKey];
+        if (typeof subContext !== 'object' || subContext === null) {
+            const subContextValue = subContext;
+            subContext = {};
+            if (typeof subContextValue !== 'undefined') {
+                subContext[''] = subContextValue;
+            }
+            context[subKey] = subContext;
+        }
+        deepSet(subContext, key.slice(separator + 1, key.length), value);
+    }
+    else {
+        context[key] = value;
+    }
+}
+Settings.getDefaultSettings().set('useCursors', true);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/volumeLoader.js
+var volumeLoader = __webpack_require__(18588);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/imageLoader.js
+var imageLoader = __webpack_require__(62990);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/geometryLoader.js + 26 modules
+var geometryLoader = __webpack_require__(59469);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/ProgressiveRetrieveImages.js + 4 modules
+var ProgressiveRetrieveImages = __webpack_require__(27654);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 66 modules
+var utilities = __webpack_require__(56309);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/triggerEvent.js
+var triggerEvent = __webpack_require__(85041);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/index.js + 1 modules
+var helpers = __webpack_require__(25281);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
 
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  BlendModes: () => (/* reexport */ enums_BlendModes),
-  CalibrationTypes: () => (/* reexport */ enums_CalibrationTypes),
-  DynamicOperatorType: () => (/* reexport */ enums_DynamicOperatorType),
-  Events: () => (/* reexport */ Events/* default */.Z),
-  GeometryType: () => (/* reexport */ enums_GeometryType),
-  ImageQualityStatus: () => (/* reexport */ ImageQualityStatus/* default */.Z),
-  InterpolationType: () => (/* reexport */ InterpolationType/* default */.Z),
-  MetadataModules: () => (/* reexport */ MetadataModules/* default */.Z),
-  OrientationAxis: () => (/* reexport */ OrientationAxis/* default */.Z),
-  RequestType: () => (/* reexport */ RequestType/* default */.Z),
-  SharedArrayBufferModes: () => (/* reexport */ SharedArrayBufferModes/* default */.Z),
-  VOILUTFunctionType: () => (/* reexport */ VOILUTFunctionType/* default */.Z),
-  VideoEnums: () => (/* reexport */ VideoEnums),
-  ViewportStatus: () => (/* reexport */ ViewportStatus/* default */.Z),
-  ViewportType: () => (/* reexport */ ViewportType/* default */.Z)
-});
 
-// UNUSED EXPORTS: ContourType
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/Events.js
-var Events = __webpack_require__(19546);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/RequestType.js
-var RequestType = __webpack_require__(49334);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportType.js
-var ViewportType = __webpack_require__(68032);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/InterpolationType.js
-var InterpolationType = __webpack_require__(75677);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/VolumeMapper/Constants.js
-var Constants = __webpack_require__(83336);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/BlendModes.js
 
-const { BlendMode } = Constants["default"];
-var BlendModes;
-(function (BlendModes) {
-    BlendModes[BlendModes["COMPOSITE"] = 0] = "COMPOSITE";
-    BlendModes[BlendModes["MAXIMUM_INTENSITY_BLEND"] = 1] = "MAXIMUM_INTENSITY_BLEND";
-    BlendModes[BlendModes["MINIMUM_INTENSITY_BLEND"] = 2] = "MINIMUM_INTENSITY_BLEND";
-    BlendModes[BlendModes["AVERAGE_INTENSITY_BLEND"] = 3] = "AVERAGE_INTENSITY_BLEND";
-})(BlendModes || (BlendModes = {}));
-/* harmony default export */ const enums_BlendModes = (BlendModes);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/OrientationAxis.js
-var OrientationAxis = __webpack_require__(96426);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/SharedArrayBufferModes.js
-var SharedArrayBufferModes = __webpack_require__(91799);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/GeometryType.js
-var GeometryType;
-(function (GeometryType) {
-    GeometryType["CONTOUR"] = "contour";
-    GeometryType["SURFACE"] = "Surface";
-})(GeometryType || (GeometryType = {}));
-/* harmony default export */ const enums_GeometryType = (GeometryType);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ContourType.js
-var ContourType = __webpack_require__(2689);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VOILUTFunctionType.js
-var VOILUTFunctionType = __webpack_require__(67751);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/DynamicOperatorType.js
-var DynamicOperatorType;
-(function (DynamicOperatorType) {
-    DynamicOperatorType["SUM"] = "SUM";
-    DynamicOperatorType["AVERAGE"] = "AVERAGE";
-    DynamicOperatorType["SUBTRACT"] = "SUBTRACT";
-})(DynamicOperatorType || (DynamicOperatorType = {}));
-/* harmony default export */ const enums_DynamicOperatorType = (DynamicOperatorType);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/CalibrationTypes.js
-var CalibrationTypes;
-(function (CalibrationTypes) {
-    CalibrationTypes["NOT_APPLICABLE"] = "";
-    CalibrationTypes["ERMF"] = "ERMF";
-    CalibrationTypes["USER"] = "User";
-    CalibrationTypes["PROJECTION"] = "Proj";
-    CalibrationTypes["REGION"] = "Region";
-    CalibrationTypes["ERROR"] = "Error";
-    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
-})(CalibrationTypes || (CalibrationTypes = {}));
-/* harmony default export */ const enums_CalibrationTypes = (CalibrationTypes);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportStatus.js
-var ViewportStatus = __webpack_require__(84659);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ImageQualityStatus.js
-var ImageQualityStatus = __webpack_require__(83521);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VideoEnums.js
-var VideoEnums = __webpack_require__(40373);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/MetadataModules.js
-var MetadataModules = __webpack_require__(636);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js
 
 
 
@@ -2922,69 +3945,9 @@ var MetadataModules = __webpack_require__(636);
 
 
 
-/***/ }),
 
-/***/ 65279:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   O: () => (/* binding */ getEnabledElementByIds),
-/* harmony export */   Yz: () => (/* binding */ getEnabledElementByViewportId),
-/* harmony export */   ZP: () => (/* binding */ getEnabledElement),
-/* harmony export */   wN: () => (/* binding */ getEnabledElements)
-/* harmony export */ });
-/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9138);
 
-function getEnabledElement(element) {
-    if (!element) {
-        return;
-    }
-    const { viewportUid, renderingEngineUid } = element.dataset;
-    return getEnabledElementByIds(viewportUid, renderingEngineUid);
-}
-function getEnabledElementByIds(viewportId, renderingEngineId) {
-    if (!renderingEngineId || !viewportId) {
-        return;
-    }
-    const renderingEngine = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(renderingEngineId);
-    if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
-        return;
-    }
-    const viewport = renderingEngine.getViewport(viewportId);
-    if (!viewport) {
-        return;
-    }
-    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-    return {
-        viewport,
-        renderingEngine,
-        viewportId,
-        renderingEngineId,
-        FrameOfReferenceUID,
-    };
-}
-function getEnabledElementByViewportId(viewportId) {
-    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
-    for (let i = 0; i < renderingEngines.length; i++) {
-        const renderingEngine = renderingEngines[i];
-        const viewport = renderingEngine.getViewport(viewportId);
-        if (viewport) {
-            return getEnabledElementByIds(viewportId, renderingEngine.id);
-        }
-    }
-}
-function getEnabledElements() {
-    const enabledElements = [];
-    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
-    renderingEngines.forEach((renderingEngine) => {
-        const viewports = renderingEngine.getViewports();
-        viewports.forEach(({ element }) => {
-            enabledElements.push(getEnabledElement(element));
-        });
-    });
-    return enabledElements;
-}
 
 
 /***/ }),
@@ -3014,9 +3977,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(82253);
 /* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19546);
 /* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(74238);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(56309);
 /* harmony import */ var _requestPool_imageLoadPoolManager__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(96506);
-/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62709);
+/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(12651);
 
 
 
@@ -3296,7 +4259,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(85041);
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(11677);
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep__WEBPACK_IMPORTED_MODULE_8__);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(56309);
 /* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(28719);
 /* harmony import */ var _utilities_cacheUtils__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(85654);
 
@@ -3617,6 +4580,56 @@ function generateVolumeScalarData(targetBuffer, scalarLength) {
 }
 
 
+/***/ }),
+
+/***/ 30023:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   addProvider: () => (/* binding */ addProvider),
+/* harmony export */   get: () => (/* binding */ getMetaData),
+/* harmony export */   removeAllProviders: () => (/* binding */ removeAllProviders),
+/* harmony export */   removeProvider: () => (/* binding */ removeProvider)
+/* harmony export */ });
+const providers = [];
+function addProvider(provider, priority = 0) {
+    let i;
+    for (i = 0; i < providers.length; i++) {
+        if (providers[i].priority <= priority) {
+            break;
+        }
+    }
+    providers.splice(i, 0, {
+        priority,
+        provider,
+    });
+}
+function removeProvider(provider) {
+    for (let i = 0; i < providers.length; i++) {
+        if (providers[i].provider === provider) {
+            providers.splice(i, 1);
+            break;
+        }
+    }
+}
+function removeAllProviders() {
+    while (providers.length > 0) {
+        providers.pop();
+    }
+}
+function getMetaData(type, ...queries) {
+    for (let i = 0; i < providers.length; i++) {
+        const result = providers[i].provider(type, ...queries);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+}
+
+
+
 /***/ }),
 
 /***/ 96506:
@@ -3648,7 +4661,7 @@ imageLoadPoolManager.setMaxSimultaneousRequests(_enums_RequestType__WEBPACK_IMPO
 /* harmony export */   P: () => (/* binding */ RequestPoolManager)
 /* harmony export */ });
 /* harmony import */ var _enums_RequestType__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(49334);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(56309);
 
 
 class RequestPoolManager {
@@ -4488,6 +5501,13 @@ const CursorSVG = {
             y: 24,
         },
     }),
+    Height: extend(BASE, {
+        iconContent: `<path d="m 6 22 l 8.5 0 v -16 h 8" stroke-width="3" fill="none" stroke="{{color}}" />`,
+        viewBox: {
+            x: 24,
+            y: 24,
+        },
+    }),
     Probe: extend(BASE, {
         iconContent: `<path fill="{{color}}" d="M1152 896q0 106-75 181t-181 75-181-75-75-181 75-181 181-75 181 75
     75 181zm-256-544q-148 0-273 73t-198 198-73 273 73 273 198 198 273 73 273-73
@@ -4720,8 +5740,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/index.js + 4 modules
 var store = __webpack_require__(33232);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/getSvgDrawingHelper.js
 
 
@@ -4832,7 +5852,7 @@ var ToolModes;
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33232);
 /* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(69562);
 /* harmony import */ var _synchronizers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(93423);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(86785);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(25876);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(42975);
 /* harmony import */ var _cursors__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(60020);
 /* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(35106);
@@ -4925,8 +5945,8 @@ var lodash_get_default = /*#__PURE__*/__webpack_require__.n(lodash_get);
 // EXTERNAL MODULE: ../../../node_modules/lodash.clonedeep/index.js
 var lodash_clonedeep = __webpack_require__(11677);
 var lodash_clonedeep_default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/index.js + 4 modules
 var cursors = __webpack_require__(60020);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/elementCursor.js
@@ -5509,7 +6529,7 @@ function getToolGroupsWithToolName(toolName) {
 /* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(72076);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12651);
 /* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39661);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(42975);
 /* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(93382);
@@ -5518,7 +6538,7 @@ function getToolGroupsWithToolName(toolName) {
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(11163);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(41836);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(36705);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(86785);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(25876);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(33232);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(68096);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(46966);
@@ -6267,7 +7287,7 @@ BidirectionalTool.toolName = 'Bidirectional';
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
 /* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39661);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(42975);
@@ -6283,7 +7303,7 @@ BidirectionalTool.toolName = 'Bidirectional';
 /* harmony import */ var _planarFreehandROITool_openContourEndEditLoop__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(82571);
 /* harmony import */ var _planarFreehandROITool_renderMethods__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(54435);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(36705);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(86785);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(25876);
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(20724);
 /* harmony import */ var _utilities_math_polyline__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(42744);
 /* harmony import */ var _utilities_pointInShapeCallback__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(31955);
@@ -6441,45 +7461,12 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
                 }
                 const { imageData, metadata } = image;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-                const canvasPoint = canvasCoordinates[0];
-                const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
-                const deltaXPoint = viewport.canvasToWorld([
-                    canvasPoint[0] + 1,
-                    canvasPoint[1],
-                ]);
-                const deltaYPoint = viewport.canvasToWorld([
-                    canvasPoint[0],
-                    canvasPoint[1] + 1,
-                ]);
-                const deltaInX = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaXPoint);
-                const deltaInY = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaYPoint);
-                const worldPosIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[0]);
-                worldPosIndex[0] = Math.floor(worldPosIndex[0]);
-                worldPosIndex[1] = Math.floor(worldPosIndex[1]);
-                worldPosIndex[2] = Math.floor(worldPosIndex[2]);
-                let iMin = worldPosIndex[0];
-                let iMax = worldPosIndex[0];
-                let jMin = worldPosIndex[1];
-                let jMax = worldPosIndex[1];
-                let kMin = worldPosIndex[2];
-                let kMax = worldPosIndex[2];
-                for (let j = 1; j < points.length; j++) {
-                    const worldPosIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[j]);
-                    worldPosIndex[0] = Math.floor(worldPosIndex[0]);
-                    worldPosIndex[1] = Math.floor(worldPosIndex[1]);
-                    worldPosIndex[2] = Math.floor(worldPosIndex[2]);
-                    iMin = Math.min(iMin, worldPosIndex[0]);
-                    iMax = Math.max(iMax, worldPosIndex[0]);
-                    jMin = Math.min(jMin, worldPosIndex[1]);
-                    jMax = Math.max(jMax, worldPosIndex[1]);
-                    kMin = Math.min(kMin, worldPosIndex[2]);
-                    kMax = Math.max(kMax, worldPosIndex[2]);
-                }
-                const worldPosIndex2 = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[1]);
-                worldPosIndex2[0] = Math.floor(worldPosIndex2[0]);
-                worldPosIndex2[1] = Math.floor(worldPosIndex2[1]);
-                worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
-                const { scale, areaUnits } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .mh)(image, () => {
+                const modalityUnitOptions = {
+                    isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_20__/* .isViewportPreScaled */ .P)(viewport, targetId),
+                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                };
+                const modalityUnit = (0,_utilities_getModalityUnit__WEBPACK_IMPORTED_MODULE_21__/* .getModalityUnit */ .F)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const calibratedScale = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .mh)(image, () => {
                     const polyline = data.contour.polyline;
                     const numPoints = polyline.length;
                     const projectedPolyline = new Array(numPoints);
@@ -6487,10 +7474,7 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
                         projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
                     }
                     const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = _utilities__WEBPACK_IMPORTED_MODULE_3__.math.polyline.getAABB(projectedPolyline);
-                    const topLeftBBWorld = viewport.canvasToWorld([
-                        canvasMinX,
-                        canvasMinY,
-                    ]);
+                    const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
                     const topLeftBBIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, topLeftBBWorld);
                     const bottomRightBBWorld = viewport.canvasToWorld([
                         canvasMaxX,
@@ -6499,71 +7483,29 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
                     const bottomRightBBIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
                     return [topLeftBBIndex, bottomRightBBIndex];
                 });
-                let area = _utilities_math__WEBPACK_IMPORTED_MODULE_4__.polyline.getArea(canvasCoordinates) / scale / scale;
-                area *= deltaInX * deltaInY;
-                const iDelta = 0.01 * (iMax - iMin);
-                const jDelta = 0.01 * (jMax - jMin);
-                const kDelta = 0.01 * (kMax - kMin);
-                iMin = Math.floor(iMin - iDelta);
-                iMax = Math.ceil(iMax + iDelta);
-                jMin = Math.floor(jMin - jDelta);
-                jMax = Math.ceil(jMax + jDelta);
-                kMin = Math.floor(kMin - kDelta);
-                kMax = Math.ceil(kMax + kDelta);
-                const boundsIJK = [
-                    [iMin, iMax],
-                    [jMin, jMax],
-                    [kMin, kMax],
-                ];
-                const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
-                const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
-                let curRow = 0;
-                let intersections = [];
-                let intersectionCounter = 0;
-                const pointsInShape = (0,_utilities_pointInShapeCallback__WEBPACK_IMPORTED_MODULE_19__/* ["default"] */ .Z)(imageData, (pointLPS, pointIJK) => {
-                    let result = true;
-                    const point = viewport.worldToCanvas(pointLPS);
-                    if (point[1] != curRow) {
-                        intersectionCounter = 0;
-                        curRow = point[1];
-                        intersections = (0,_utilities_math_polyline__WEBPACK_IMPORTED_MODULE_18__.getLineSegmentIntersectionsCoordinates)(canvasCoordinates, point, [canvasPosEnd[0], point[1]]);
-                        intersections.sort((function (index) {
-                            return function (a, b) {
-                                return a[index] === b[index]
-                                    ? 0
-                                    : a[index] < b[index]
-                                        ? -1
-                                        : 1;
-                            };
-                        })(0));
-                    }
-                    if (intersections.length && point[0] > intersections[0][0]) {
-                        intersections.shift();
-                        intersectionCounter++;
-                    }
-                    if (intersectionCounter % 2 === 0) {
-                        result = false;
-                    }
-                    return result;
-                }, this.configuration.statsCalculator.statsCallback, boundsIJK);
-                const modalityUnitOptions = {
-                    isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_20__/* .isViewportPreScaled */ .P)(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                const modalityUnit = (0,_utilities_getModalityUnit__WEBPACK_IMPORTED_MODULE_21__/* .getModalityUnit */ .F)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
-                const stats = this.configuration.statsCalculator.getStatistics();
-                cachedStats[targetId] = {
-                    Modality: metadata.Modality,
-                    area,
-                    perimeter: (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_23__/* ["default"] */ .Z)(canvasCoordinates, closed),
-                    mean: stats.mean?.value,
-                    max: stats.max?.value,
-                    stdDev: stats.stdDev?.value,
-                    statsArray: stats.array,
-                    pointsInShape: pointsInShape,
-                    areaUnit: areaUnits,
-                    modalityUnit,
-                };
+                if (closed) {
+                    this.updateClosedCachedStats({
+                        targetId,
+                        viewport,
+                        canvasCoordinates,
+                        points,
+                        imageData,
+                        metadata,
+                        cachedStats,
+                        modalityUnit,
+                        calibratedScale,
+                    });
+                }
+                else {
+                    this.updateOpenCachedStats({
+                        metadata,
+                        canvasCoordinates,
+                        targetId,
+                        cachedStats,
+                        modalityUnit,
+                        calibratedScale,
+                    });
+                }
             }
             (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_15__/* .triggerAnnotationModified */ .hg)(annotation, enabledElement.viewport.element, _enums__WEBPACK_IMPORTED_MODULE_25__.ChangeTypes.StatsUpdated);
             annotation.invalidated = false;
@@ -6756,10 +7698,117 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
             }
         }
     }
+    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }) {
+        const { scale, areaUnits, units } = calibratedScale;
+        const canvasPoint = canvasCoordinates[0];
+        const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+        const deltaXPoint = viewport.canvasToWorld([
+            canvasPoint[0] + 1,
+            canvasPoint[1],
+        ]);
+        const deltaYPoint = viewport.canvasToWorld([
+            canvasPoint[0],
+            canvasPoint[1] + 1,
+        ]);
+        const deltaInX = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaXPoint);
+        const deltaInY = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaYPoint);
+        const worldPosIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[0]);
+        worldPosIndex[0] = Math.floor(worldPosIndex[0]);
+        worldPosIndex[1] = Math.floor(worldPosIndex[1]);
+        worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+        let iMin = worldPosIndex[0];
+        let iMax = worldPosIndex[0];
+        let jMin = worldPosIndex[1];
+        let jMax = worldPosIndex[1];
+        let kMin = worldPosIndex[2];
+        let kMax = worldPosIndex[2];
+        for (let j = 1; j < points.length; j++) {
+            const worldPosIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[j]);
+            worldPosIndex[0] = Math.floor(worldPosIndex[0]);
+            worldPosIndex[1] = Math.floor(worldPosIndex[1]);
+            worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+            iMin = Math.min(iMin, worldPosIndex[0]);
+            iMax = Math.max(iMax, worldPosIndex[0]);
+            jMin = Math.min(jMin, worldPosIndex[1]);
+            jMax = Math.max(jMax, worldPosIndex[1]);
+            kMin = Math.min(kMin, worldPosIndex[2]);
+            kMax = Math.max(kMax, worldPosIndex[2]);
+        }
+        const worldPosIndex2 = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[1]);
+        worldPosIndex2[0] = Math.floor(worldPosIndex2[0]);
+        worldPosIndex2[1] = Math.floor(worldPosIndex2[1]);
+        worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
+        let area = _utilities_math__WEBPACK_IMPORTED_MODULE_4__.polyline.getArea(canvasCoordinates) / scale / scale;
+        area *= deltaInX * deltaInY;
+        const iDelta = 0.01 * (iMax - iMin);
+        const jDelta = 0.01 * (jMax - jMin);
+        const kDelta = 0.01 * (kMax - kMin);
+        iMin = Math.floor(iMin - iDelta);
+        iMax = Math.ceil(iMax + iDelta);
+        jMin = Math.floor(jMin - jDelta);
+        jMax = Math.ceil(jMax + jDelta);
+        kMin = Math.floor(kMin - kDelta);
+        kMax = Math.ceil(kMax + kDelta);
+        const boundsIJK = [
+            [iMin, iMax],
+            [jMin, jMax],
+            [kMin, kMax],
+        ];
+        const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
+        const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
+        let curRow = 0;
+        let intersections = [];
+        let intersectionCounter = 0;
+        const pointsInShape = (0,_utilities_pointInShapeCallback__WEBPACK_IMPORTED_MODULE_19__/* ["default"] */ .Z)(imageData, (pointLPS, _pointIJK) => {
+            let result = true;
+            const point = viewport.worldToCanvas(pointLPS);
+            if (point[1] != curRow) {
+                intersectionCounter = 0;
+                curRow = point[1];
+                intersections = (0,_utilities_math_polyline__WEBPACK_IMPORTED_MODULE_18__.getLineSegmentIntersectionsCoordinates)(canvasCoordinates, point, [canvasPosEnd[0], point[1]]);
+                intersections.sort((function (index) {
+                    return function (a, b) {
+                        return a[index] === b[index] ? 0 : a[index] < b[index] ? -1 : 1;
+                    };
+                })(0));
+            }
+            if (intersections.length && point[0] > intersections[0][0]) {
+                intersections.shift();
+                intersectionCounter++;
+            }
+            if (intersectionCounter % 2 === 0) {
+                result = false;
+            }
+            return result;
+        }, this.configuration.statsCalculator.statsCallback, boundsIJK);
+        const stats = this.configuration.statsCalculator.getStatistics();
+        cachedStats[targetId] = {
+            Modality: metadata.Modality,
+            area,
+            perimeter: (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_23__/* ["default"] */ .Z)(canvasCoordinates, closed) / scale,
+            mean: stats.mean?.value,
+            max: stats.max?.value,
+            stdDev: stats.stdDev?.value,
+            statsArray: stats.array,
+            pointsInShape: pointsInShape,
+            areaUnit: areaUnits,
+            modalityUnit,
+            unit: units,
+        };
+    }
+    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }) {
+        const { scale, units } = calibratedScale;
+        cachedStats[targetId] = {
+            Modality: metadata.Modality,
+            length: (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_23__/* ["default"] */ .Z)(canvasCoordinates, false) / scale,
+            modalityUnit,
+            unit: units,
+        };
+    }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, perimeter, max, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats || {};
+    const { area, mean, stdDev, length, perimeter, max, isEmptyArea, areaUnit, modalityUnit, unit, } = cachedVolumeStats || {};
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
@@ -6777,7 +7826,10 @@ function defaultGetTextLines(data, targetId) {
         textLines.push(`Std Dev: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(stdDev)} ${modalityUnit}`);
     }
     if (perimeter) {
-        textLines.push(`Perimeter: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(perimeter)} ${modalityUnit}`);
+        textLines.push(`Perimeter: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(perimeter)} ${unit}`);
+    }
+    if (length) {
+        textLines.push(`${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(length)} ${unit}`);
     }
     return textLines;
 }
@@ -6794,7 +7846,7 @@ PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74297);
 /* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(95482);
 /* harmony import */ var _stateManagement_segmentation_config_segmentationVisibility__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39949);
@@ -6927,7 +7979,7 @@ __webpack_require__.d(__webpack_exports__, {
   xX: () => (/* reexport */ SegmentationDisplayTool/* default */.Z)
 });
 
-// UNUSED EXPORTS: AngleTool, AnnotationDisplayTool, ArrowAnnotateTool, BaseTool, BidirectionalTool, BrushTool, CircleROIStartEndThresholdTool, CircleROITool, CircleScissorsTool, CobbAngleTool, CrosshairsTool, DragProbeTool, EllipticalROITool, EraserTool, KeyImageTool, LengthTool, LivewireContourSegmentationTool, LivewireContourTool, MIPJumpToClickTool, MagnifyTool, OrientationMarkerTool, OverlayGridTool, PaintFillTool, PanTool, PlanarRotateTool, ProbeTool, RectangleROITool, RectangleScissorsTool, ReferenceCursors, ReferenceLines, ReferenceLinesTool, ScaleOverlayTool, SculptorTool, SegmentSelectTool, SegmentationIntersectionTool, SphereScissorsTool, SplineContourSegmentationTool, SplineROITool, StackScrollMouseWheelTool, StackScrollTool, TrackballRotateTool, UltrasoundDirectionalTool, VolumeRotateMouseWheelTool, WindowLevelRegionTool, WindowLevelTool, ZoomTool
+// UNUSED EXPORTS: AngleTool, AnnotationDisplayTool, ArrowAnnotateTool, BaseTool, BidirectionalTool, BrushTool, CircleROIStartEndThresholdTool, CircleROITool, CircleScissorsTool, CobbAngleTool, CrosshairsTool, DragProbeTool, EllipticalROITool, EraserTool, HeightTool, KeyImageTool, LengthTool, LivewireContourSegmentationTool, LivewireContourTool, MIPJumpToClickTool, MagnifyTool, OrientationMarkerTool, OverlayGridTool, PaintFillTool, PanTool, PlanarRotateTool, ProbeTool, RectangleROITool, RectangleScissorsTool, ReferenceCursors, ReferenceLines, ReferenceLinesTool, ScaleOverlayTool, SculptorTool, SegmentSelectTool, SegmentationIntersectionTool, SphereScissorsTool, SplineContourSegmentationTool, SplineROITool, StackScrollMouseWheelTool, StackScrollTool, TrackballRotateTool, UltrasoundDirectionalTool, VolumeRotateMouseWheelTool, WindowLevelRegionTool, WindowLevelTool, ZoomTool
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/base/index.js
 var base = __webpack_require__(93382);
@@ -6973,6 +8025,8 @@ var SculptorTool = __webpack_require__(86684);
 var BidirectionalTool = __webpack_require__(56611);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/LengthTool.js
 var LengthTool = __webpack_require__(3098);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/HeightTool.js
+var HeightTool = __webpack_require__(76131);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/ProbeTool.js
 var ProbeTool = __webpack_require__(86479);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/DragProbeTool.js
@@ -7015,14 +8069,14 @@ var RectangleScissorsTool = __webpack_require__(13354);
 var CircleScissorsTool = __webpack_require__(30809);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/SphereScissorsTool.js
 var SphereScissorsTool = __webpack_require__(30862);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/index.js
 var stateManagement = __webpack_require__(50097);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationLocking.js
 var annotationLocking = __webpack_require__(11163);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/index.js + 18 modules
-var drawingSvg = __webpack_require__(86785);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/index.js + 19 modules
+var drawingSvg = __webpack_require__(25876);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewportFilters/index.js + 4 modules
 var viewportFilters = __webpack_require__(46966);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/elementCursor.js
@@ -7180,12 +8234,26 @@ class RectangleROIThresholdTool extends RectangleROITool/* default */.Z {
 RectangleROIThresholdTool.toolName = 'RectangleROIThreshold';
 /* harmony default export */ const segmentation_RectangleROIThresholdTool = (RectangleROIThresholdTool);
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getCalibratedUnits.js
+var getCalibratedUnits = __webpack_require__(39661);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var gl_matrix_esm = __webpack_require__(72076);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/throttle.js
 var throttle = __webpack_require__(90685);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/drawing/index.js + 1 modules
+var drawing = __webpack_require__(20724);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planar/getWorldWidthAndHeightFromCorners.js
+var getWorldWidthAndHeightFromCorners = __webpack_require__(88582);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/index.js + 1 modules
 var utilities = __webpack_require__(42975);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getModalityUnit.js
+var getModalityUnit = __webpack_require__(15607);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewport/isViewportPreScaled.js
+var isViewportPreScaled = __webpack_require__(20752);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/index.js + 2 modules
+var basic = __webpack_require__(51053);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planar/index.js
+var planar = __webpack_require__(44037);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/RectangleROIStartEndThresholdTool.js
 
 
@@ -7200,6 +8268,13 @@ var utilities = __webpack_require__(42975);
 
 
 
+
+
+
+
+
+
+
 
 const { transformWorldToIndex } = esm.utilities;
 class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z {
@@ -7207,6 +8282,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         configuration: {
             numSlicesToPropagate: 10,
             computePointsInsideVolume: false,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: basic.BasicStatsCalculator,
+            showTextBox: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -7229,12 +8307,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                 imageVolume = esm.cache.getVolume(volumeId);
                 referencedImageId = esm.utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
             }
-            if (!referencedImageId) {
-                throw new Error('This tool does not work on non-acquisition planes');
-            }
-            const startIndex = viewport.getCurrentImageIdIndex();
             const spacingInNormal = esm.utilities.getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
-            const endIndex = this._getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal);
+            const startCoord = this._getStartCoordinate(worldPos, viewPlaneNormal);
+            const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             const annotation = {
                 highlighted: true,
@@ -7251,18 +8326,24 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                 },
                 data: {
                     label: '',
-                    startSlice: startIndex,
-                    endSlice: endIndex,
+                    startCoordinate: startCoord,
+                    endCoordinate: endCoord,
                     cachedStats: {
                         pointsInVolume: [],
                         projectionPoints: [],
                         projectionPointsImageIds: [referencedImageId],
+                        statistics: [],
                     },
                     handles: {
                         textBox: {
                             hasMoved: false,
-                            worldPosition: null,
-                            worldBoundingBox: null,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
                         },
                         points: [
                             [...worldPos],
@@ -7313,7 +8394,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
             const targetId = this.getTargetId(enabledElement.viewport);
             const imageVolume = esm.cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
             if (this.configuration.calculatePointsInsideVolume) {
-                this._computePointsInsideVolume(annotation, imageVolume, enabledElement);
+                this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
             }
             (0,triggerAnnotationRenderForViewportIds/* default */.Z)(enabledElement.renderingEngine, viewportIdsToRender);
             if (newAnnotation) {
@@ -7323,11 +8404,11 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             let renderStatus = false;
             const { viewport } = enabledElement;
-            const annotations = (0,stateManagement/* getAnnotations */.fy)(this.getToolName(), viewport.element);
+            let annotations = (0,stateManagement/* getAnnotations */.fy)(this.getToolName(), viewport.element);
             if (!annotations?.length) {
                 return renderStatus;
             }
-            const sliceIndex = viewport.getCurrentImageIdIndex();
+            annotations = (0,planar.filterAnnotationsWithinSamePlane)(annotations, viewport.getCamera());
             const styleSpecifier = {
                 toolGroupId: this.toolGroupId,
                 toolName: this.getToolName(),
@@ -7336,22 +8417,37 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
             for (let i = 0; i < annotations.length; i++) {
                 const annotation = annotations[i];
                 const { annotationUID, data } = annotation;
-                const { startSlice, endSlice } = data;
+                const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
                 const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
                 const color = this.getStyle('color', styleSpecifier, annotation);
-                if (sliceIndex < Math.min(startSlice, endSlice) ||
-                    sliceIndex > Math.max(startSlice, endSlice)) {
+                const focalPoint = viewport.getCamera().focalPoint;
+                const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+                let startCoord = startCoordinate;
+                let endCoord = endCoordinate;
+                if (Array.isArray(startCoordinate)) {
+                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                }
+                if (Array.isArray(endCoordinate)) {
+                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                }
+                const roundedStartCoord = esm.utilities.roundToPrecision(startCoord);
+                const roundedEndCoord = esm.utilities.roundToPrecision(endCoord);
+                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCoord = esm.utilities.roundToPrecision(coord);
+                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
                 }
                 if (annotation.invalidated) {
                     this._throttledCalculateCachedStats(annotation, enabledElement);
                 }
                 let firstOrLastSlice = false;
-                if (sliceIndex === startSlice || sliceIndex === endSlice) {
+                if (roundedCoord === roundedStartCoord ||
+                    roundedCoord === roundedEndCoord) {
                     firstOrLastSlice = true;
                 }
                 if (!viewport.getRenderingEngine()) {
@@ -7385,6 +8481,42 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                     lineWidth,
                 });
                 renderStatus = true;
+                if (this.configuration.showTextBox &&
+                    this.configuration.calculatePointsInsideVolume) {
+                    const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                    if (!options.visibility) {
+                        data.handles.textBox = {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        };
+                        continue;
+                    }
+                    const textLines = this.configuration.getTextLines(data);
+                    if (!textLines || textLines.length === 0) {
+                        continue;
+                    }
+                    if (!data.handles.textBox.hasMoved) {
+                        const canvasTextBoxCoords = (0,drawing.getTextBoxCoordsCanvas)(canvasCoordinates);
+                        data.handles.textBox.worldPosition =
+                            viewport.canvasToWorld(canvasTextBoxCoords);
+                    }
+                    const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                    const textBoxUID = '1';
+                    const boundingBox = (0,drawingSvg.drawLinkedTextBox)(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                    const { x: left, y: top, width, height } = boundingBox;
+                    data.handles.textBox.worldBoundingBox = {
+                        topLeft: viewport.canvasToWorld([left, top]),
+                        topRight: viewport.canvasToWorld([left + width, top]),
+                        bottomLeft: viewport.canvasToWorld([left, top + height]),
+                        bottomRight: viewport.canvasToWorld([left + width, top + height]),
+                    };
+                }
             }
             return renderStatus;
         };
@@ -7394,17 +8526,26 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         const { data, metadata } = annotation;
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { imageData } = imageVolume;
-        const { startSlice, endSlice } = data;
+        const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
         const startIJK = transformWorldToIndex(imageData, points[0]);
-        if (startIJK[2] !== startSlice) {
-            throw new Error('Start slice does not match');
-        }
-        const endIJK = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(startIJK[0], startIJK[1], endSlice);
+        const endIJK = transformWorldToIndex(imageData, points[0]);
         const startWorld = gl_matrix_esm/* vec3.create */.R3.create();
         imageData.indexToWorldVec3(startIJK, startWorld);
         const endWorld = gl_matrix_esm/* vec3.create */.R3.create();
         imageData.indexToWorldVec3(endIJK, endWorld);
+        if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 2) {
+            startWorld[2] = startCoordinate;
+            endWorld[2] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0) {
+            startWorld[0] = startCoordinate;
+            endWorld[0] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1) {
+            startWorld[1] = startCoordinate;
+            endWorld[1] = endCoordinate;
+        }
         const distance = gl_matrix_esm/* vec3.distance */.R3.distance(startWorld, endWorld);
         const newProjectionPoints = [];
         for (let dist = 0; dist < distance; dist += spacingInNormal) {
@@ -7415,34 +8556,45 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
             }));
         }
         data.cachedStats.projectionPoints = newProjectionPoints;
-        const projectionPointsImageIds = [];
-        for (const RectanglePoints of newProjectionPoints) {
-            const imageId = esm.utilities.getClosestImageId(imageVolume, RectanglePoints[0], viewPlaneNormal);
-            projectionPointsImageIds.push(imageId);
-        }
-        data.cachedStats.projectionPointsImageIds = projectionPointsImageIds;
     }
-    _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-        const { data } = annotation;
+    _computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, viewUp } = metadata;
+        const { viewport, renderingEngine } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
+        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const worldPos1 = data.handles.points[0];
+        const worldPos2 = data.handles.points[3];
+        const { worldWidth, worldHeight } = (0,getWorldWidthAndHeightFromCorners/* default */.Z)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+        const measureInfo = (0,getCalibratedUnits/* getCalibratedLengthUnitsAndScale */.mh)(image, data.habdles);
+        const area = Math.abs(worldWidth * worldHeight) /
+            (measureInfo.scale * measureInfo.scale);
+        const modalityUnitOptions = {
+            isPreScaled: (0,isViewportPreScaled/* isViewportPreScaled */.P)(viewport, targetId),
+            isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+        };
+        const modalityUnit = (0,getModalityUnit/* getModalityUnit */.F)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
             }
             const projectionPoint = projectionPoints[i][0];
-            const worldPos1 = data.handles.points[0];
-            const worldPos2 = data.handles.points[3];
             const { dimensions, imageData } = imageVolume;
             const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
             const worldProjectionPointIndex = transformWorldToIndex(imageData, projectionPoint);
+            const indexOfProjection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
             worldPos1Index[0] = Math.floor(worldPos1Index[0]);
             worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-            worldPos1Index[2] = Math.floor(worldProjectionPointIndex[2]);
+            worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+            worldPos1Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
             worldPos2Index[0] = Math.floor(worldPos2Index[0]);
             worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-            worldPos2Index[2] = Math.floor(worldProjectionPointIndex[2]);
+            worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+            worldPos2Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
                 this.isHandleOutsideImage = false;
                 const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
@@ -7456,11 +8608,22 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                     [jMin, jMax],
                     [kMin, kMax],
                 ];
-                const pointsInShape = (0,utilities.pointInShapeCallback)(imageData, () => true, null, boundsIJK);
+                const pointsInShape = (0,utilities.pointInShapeCallback)(imageData, () => true, this.configuration.statsCalculator.statsCallback, boundsIJK);
                 pointsInsideVolume.push(pointsInShape);
             }
         }
+        const stats = this.configuration.statsCalculator.getStatistics();
         data.cachedStats.pointsInVolume = pointsInsideVolume;
+        data.cachedStats.statistics = {
+            Modality: metadata.Modality,
+            area,
+            mean: stats.mean?.value,
+            stdDev: stats.stdDev?.value,
+            max: stats.max?.value,
+            statsArray: stats.array,
+            areaUnit: measureInfo.areaUnits,
+            modalityUnit,
+        };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
         const data = annotation.data;
@@ -7473,25 +8636,44 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         (0,state/* triggerAnnotationModified */.hg)(annotation, viewport.element);
         return cachedStats;
     }
-    _getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal) {
+    _getStartCoordinate(worldPos, viewPlaneNormal) {
+        const startPos = worldPos;
+        const startCoord = this._getCoordinateForViewplaneNormal(startPos, viewPlaneNormal);
+        return startCoord;
+    }
+    _getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
         const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
         const endPos = gl_matrix_esm/* vec3.create */.R3.create();
         gl_matrix_esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagate * spacingInNormal);
-        const halfSpacingInNormalDirection = spacingInNormal / 2;
-        const { imageIds } = imageVolume;
-        let imageIdIndex;
-        for (let i = 0; i < imageIds.length; i++) {
-            const imageId = imageIds[i];
-            const { imagePositionPatient } = esm.metaData.get('imagePlaneModule', imageId);
-            const dir = gl_matrix_esm/* vec3.create */.R3.create();
-            gl_matrix_esm/* vec3.sub */.R3.sub(dir, endPos, imagePositionPatient);
-            const dot = gl_matrix_esm/* vec3.dot */.R3.dot(dir, viewPlaneNormal);
-            if (Math.abs(dot) < halfSpacingInNormalDirection) {
-                imageIdIndex = i;
-            }
-        }
-        return imageIdIndex;
+        const endCoord = this._getCoordinateForViewplaneNormal(endPos, viewPlaneNormal);
+        return endCoord;
+    }
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) {
+        const viewplaneNormalAbs = [
+            Math.abs(viewPlaneNormal[0]),
+            Math.abs(viewPlaneNormal[1]),
+            Math.abs(viewPlaneNormal[2]),
+        ];
+        const indexOfDirection = viewplaneNormalAbs.indexOf(Math.max(...viewplaneNormalAbs));
+        return indexOfDirection;
+    }
+    _getCoordinateForViewplaneNormal(pos, viewPlaneNormal) {
+        const indexOfDirection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+        return pos[indexOfDirection];
+    }
+}
+function defaultGetTextLines(data) {
+    const cachedVolumeStats = data.cachedStats.statistics;
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
     }
+    const textLines = [];
+    textLines.push(`Area: ${(0,utilities.roundNumber)(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${(0,utilities.roundNumber)(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${(0,utilities.roundNumber)(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${(0,utilities.roundNumber)(stdDev)} ${modalityUnit}`);
+    return textLines;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 /* harmony default export */ const segmentation_RectangleROIStartEndThresholdTool = (RectangleROIStartEndThresholdTool);
@@ -7559,6 +8741,7 @@ var SegmentSelectTool = __webpack_require__(45986);
 
 
 
+
 
 
 /***/ }),
@@ -7649,8 +8832,8 @@ __webpack_require__.d(orientation_namespaceObject, {
   invertOrientationStringLPS: () => (invertOrientationStringLPS/* default */.Z)
 });
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getAnnotationNearPoint.js
 var getAnnotationNearPoint = __webpack_require__(62358);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/debounce.js