@ohif/app 3.10.0-beta.113 → 3.10.0-beta.114

package/dist/6752.bundle.e33e02dd8f006be51464.js

@@ -0,0 +1,2249 @@
+"use strict";
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[6752],{
+
+/***/ 5057:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _rendering_now__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(53586);
+/* harmony import */ var _rendering_renderColorImage__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(48080);
+/* harmony import */ var _rendering_renderGrayscaleImage__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(92885);
+/* harmony import */ var _rendering_renderPseudoColorImage__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(71209);
+
+
+
+
+/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(enabledElement, invalidated) {
+    const image = enabledElement.image;
+    if (!enabledElement.canvas || !enabledElement.image) {
+        return;
+    }
+    const start = (0,_rendering_now__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)();
+    image.stats = {
+        lastGetPixelDataTime: -1.0,
+        lastStoredPixelDataToCanvasImageDataTime: -1.0,
+        lastPutImageDataTime: -1.0,
+        lastRenderTime: -1.0,
+        lastLutGenerateTime: -1.0,
+    };
+    if (image) {
+        let render = image.render;
+        if (!render) {
+            if (enabledElement.viewport.colormap) {
+                render = _rendering_renderPseudoColorImage__WEBPACK_IMPORTED_MODULE_3__/* .renderPseudoColorImage */ .l;
+            }
+            else if (image.color) {
+                render = _rendering_renderColorImage__WEBPACK_IMPORTED_MODULE_1__/* .renderColorImage */ .f;
+            }
+            else {
+                render = _rendering_renderGrayscaleImage__WEBPACK_IMPORTED_MODULE_2__/* .renderGrayscaleImage */ .j;
+            }
+        }
+        render(enabledElement, invalidated);
+    }
+    const renderTimeInMs = (0,_rendering_now__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)() - start;
+    image.stats.lastRenderTime = renderTimeInMs;
+    enabledElement.invalid = false;
+    enabledElement.needsRedraw = false;
+}
+
+
+/***/ }),
+
+/***/ 7808:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(45354);
+
+/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(enabledElement, scale) {
+    const transform = new _transform__WEBPACK_IMPORTED_MODULE_0__/* .Transform */ .d();
+    if (!enabledElement.viewport.displayedArea) {
+        return transform;
+    }
+    transform.translate(enabledElement.canvas.width / 2, enabledElement.canvas.height / 2);
+    const angle = enabledElement.viewport.rotation;
+    if (angle !== 0) {
+        transform.rotate((angle * Math.PI) / 180);
+    }
+    let widthScale = enabledElement.viewport.scale;
+    let heightScale = enabledElement.viewport.scale;
+    const width = enabledElement.viewport.displayedArea.brhc.x -
+        (enabledElement.viewport.displayedArea.tlhc.x - 1);
+    const height = enabledElement.viewport.displayedArea.brhc.y -
+        (enabledElement.viewport.displayedArea.tlhc.y - 1);
+    if (enabledElement.viewport.displayedArea.presentationSizeMode === 'NONE') {
+        if (enabledElement.image.rowPixelSpacing <
+            enabledElement.image.columnPixelSpacing) {
+            widthScale *=
+                enabledElement.image.columnPixelSpacing /
+                    enabledElement.image.rowPixelSpacing;
+        }
+        else if (enabledElement.image.columnPixelSpacing <
+            enabledElement.image.rowPixelSpacing) {
+            heightScale *=
+                enabledElement.image.rowPixelSpacing /
+                    enabledElement.image.columnPixelSpacing;
+        }
+    }
+    else {
+        widthScale = enabledElement.viewport.displayedArea.columnPixelSpacing;
+        heightScale = enabledElement.viewport.displayedArea.rowPixelSpacing;
+        if (enabledElement.viewport.displayedArea.presentationSizeMode ===
+            'SCALE TO FIT') {
+            const verticalScale = enabledElement.canvas.height / (height * heightScale);
+            const horizontalScale = enabledElement.canvas.width / (width * widthScale);
+            widthScale = heightScale = Math.min(horizontalScale, verticalScale);
+            if (enabledElement.viewport.displayedArea.rowPixelSpacing <
+                enabledElement.viewport.displayedArea.columnPixelSpacing) {
+                widthScale *=
+                    enabledElement.viewport.displayedArea.columnPixelSpacing /
+                        enabledElement.viewport.displayedArea.rowPixelSpacing;
+            }
+            else if (enabledElement.viewport.displayedArea.columnPixelSpacing <
+                enabledElement.viewport.displayedArea.rowPixelSpacing) {
+                heightScale *=
+                    enabledElement.viewport.displayedArea.rowPixelSpacing /
+                        enabledElement.viewport.displayedArea.columnPixelSpacing;
+            }
+        }
+    }
+    transform.scale(widthScale, heightScale);
+    if (angle !== 0) {
+        transform.rotate((-angle * Math.PI) / 180);
+    }
+    transform.translate(enabledElement.viewport.translation.x, enabledElement.viewport.translation.y);
+    if (angle !== 0) {
+        transform.rotate((angle * Math.PI) / 180);
+    }
+    if (scale !== undefined) {
+        transform.scale(scale, scale);
+    }
+    if (enabledElement.viewport.hflip) {
+        transform.scale(-1, 1);
+    }
+    if (enabledElement.viewport.vflip) {
+        transform.scale(1, -1);
+    }
+    transform.translate(-width / 2, -height / 2);
+    return transform;
+}
+
+
+/***/ }),
+
+/***/ 36931:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _createViewport__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12132);
+/* harmony import */ var _getImageFitScale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(57162);
+
+
+/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(canvas, image, modality, colormap) {
+    if (canvas === undefined) {
+        throw new Error('getDefaultViewport: parameter canvas must not be undefined');
+    }
+    if (image === undefined) {
+        return (0,_createViewport__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)();
+    }
+    const scale = (0,_getImageFitScale__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(canvas, image, 0).scaleFactor;
+    let voi;
+    if (modality === 'PT' && image.isPreScaled) {
+        voi = {
+            windowWidth: 5,
+            windowCenter: 2.5,
+        };
+    }
+    else if (image.windowWidth !== undefined &&
+        image.windowCenter !== undefined) {
+        voi = {
+            windowWidth: Array.isArray(image.windowWidth)
+                ? image.windowWidth[0]
+                : image.windowWidth,
+            windowCenter: Array.isArray(image.windowCenter)
+                ? image.windowCenter[0]
+                : image.windowCenter,
+        };
+    }
+    return {
+        scale,
+        translation: {
+            x: 0,
+            y: 0,
+        },
+        voi,
+        invert: image.invert,
+        pixelReplication: false,
+        rotation: 0,
+        hflip: false,
+        vflip: false,
+        modalityLUT: image.modalityLUT,
+        modality,
+        voiLUT: image.voiLUT,
+        colormap: colormap !== undefined ? colormap : image.colormap,
+        displayedArea: {
+            tlhc: {
+                x: 1,
+                y: 1,
+            },
+            brhc: {
+                x: image.columns,
+                y: image.rows,
+            },
+            rowPixelSpacing: image.rowPixelSpacing === undefined ? 1 : image.rowPixelSpacing,
+            columnPixelSpacing: image.columnPixelSpacing === undefined ? 1 : image.columnPixelSpacing,
+            presentationSizeMode: 'NONE',
+        },
+    };
+}
+
+
+/***/ }),
+
+/***/ 56750:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ FrameRange)
+/* harmony export */ });
+class FrameRange {
+    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
+    static imageIdToFrames(imageId) {
+        const match = imageId.match(this.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return null;
+        }
+        const range = match[2].split('-').map((it) => Number(it));
+        if (range.length === 1) {
+            return range[0];
+        }
+        return range;
+    }
+    static imageIdToFrameEnd(imageId) {
+        const range = this.imageIdToFrames(imageId);
+        return Array.isArray(range) ? range[1] : range;
+    }
+    static imageIdToFrameStart(imageId) {
+        const range = this.imageIdToFrames(imageId);
+        return Array.isArray(range) ? range[0] : range;
+    }
+    static framesToString(range) {
+        if (Array.isArray(range)) {
+            return `${range[0]}-${range[1]}`;
+        }
+        return String(range);
+    }
+    static framesToImageId(imageId, range) {
+        const match = imageId.match(this.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return null;
+        }
+        const newRangeString = this.framesToString(range);
+        return imageId.replace(this.frameRangeExtractor, `${match[1]}${newRangeString}`);
+    }
+}
+
+
+/***/ }),
+
+/***/ 13876:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ PointsManager)
+/* harmony export */ });
+class PointsManager {
+    constructor(configuration = {}) {
+        this._dimensions = 3;
+        this._length = 0;
+        this._byteSize = 4;
+        this.growSize = 128;
+        const { initialSize = 1024, dimensions = 3, growSize = 128, } = configuration;
+        const itemLength = initialSize * dimensions;
+        this.growSize = growSize;
+        this.array = new ArrayBuffer(itemLength * this._byteSize);
+        this.data = new Float32Array(this.array);
+        this._dimensions = dimensions;
+    }
+    forEach(func) {
+        for (let i = 0; i < this._length; i++) {
+            func(this.getPoint(i), i);
+        }
+    }
+    get length() {
+        return this._length;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    get dimensionLength() {
+        return this._length * this._dimensions;
+    }
+    getPoint(index) {
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        return this.data.subarray(offset, offset + this._dimensions);
+    }
+    getPointArray(index) {
+        const array = [];
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        for (let i = 0; i < this._dimensions; i++) {
+            array.push(this.data[i + offset]);
+        }
+        return array;
+    }
+    grow(additionalSize = 1, growSize = this.growSize) {
+        if (this.dimensionLength + additionalSize * this._dimensions <=
+            this.data.length) {
+            return;
+        }
+        const newSize = this.data.length + growSize;
+        const newArray = new ArrayBuffer(newSize * this._dimensions * this._byteSize);
+        const newData = new Float32Array(newArray);
+        newData.set(this.data);
+        this.data = newData;
+        this.array = newArray;
+    }
+    reverse() {
+        const midLength = Math.floor(this._length / 2);
+        for (let i = 0; i < midLength; i++) {
+            const indexStart = i * this._dimensions;
+            const indexEnd = (this._length - 1 - i) * this._dimensions;
+            for (let dimension = 0; dimension < this._dimensions; dimension++) {
+                const valueStart = this.data[indexStart + dimension];
+                this.data[indexStart + dimension] = this.data[indexEnd + dimension];
+                this.data[indexEnd + dimension] = valueStart;
+            }
+        }
+    }
+    getTypedArray() {
+        return this.data;
+    }
+    push(point) {
+        this.grow(1);
+        const offset = this.length * this._dimensions;
+        for (let i = 0; i < this._dimensions; i++) {
+            this.data[i + offset] = point[i];
+        }
+        this._length++;
+    }
+    map(f) {
+        const mapData = [];
+        for (let i = 0; i < this._length; i++) {
+            mapData.push(f(this.getPoint(i), i));
+        }
+        return mapData;
+    }
+    get points() {
+        return this.map((p) => p);
+    }
+    toXYZ() {
+        const xyz = { x: [], y: [] };
+        if (this._dimensions >= 3) {
+            xyz.z = [];
+        }
+        const { x, y, z } = xyz;
+        this.forEach((p) => {
+            x.push(p[0]);
+            y.push(p[1]);
+            if (z) {
+                z.push(p[2]);
+            }
+        });
+        return xyz;
+    }
+    static fromXYZ({ x, y, z }) {
+        const array = PointsManager.create3(x.length);
+        let offset = 0;
+        for (let i = 0; i < x.length; i++) {
+            array.data[offset++] = x[i];
+            array.data[offset++] = y[i];
+            array.data[offset++] = z ? z[i] : 0;
+        }
+        array._length = x.length;
+        return array;
+    }
+    subselect(count = 10, offset = 0) {
+        const selected = new PointsManager({
+            initialSize: count,
+            dimensions: this._dimensions,
+        });
+        for (let i = 0; i < count; i++) {
+            const index = (offset + Math.floor((this.length * i) / count)) % this.length;
+            selected.push(this.getPoint(index));
+        }
+        return selected;
+    }
+    static create3(initialSize = 128, points) {
+        initialSize = Math.max(initialSize, points?.length || 0);
+        const newPoints = new PointsManager({ initialSize, dimensions: 3 });
+        if (points) {
+            points.forEach((point) => newPoints.push(point));
+        }
+        return newPoints;
+    }
+    static create2(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 2 });
+    }
+}
+
+
+/***/ }),
+
+/***/ 22191:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ ProgressiveIterator)
+/* harmony export */ });
+/* unused harmony export PromiseIterator */
+class PromiseIterator extends (/* unused pure expression or super */ null && (Promise)) {
+}
+class ProgressiveIterator {
+    constructor(name) {
+        this.name = name || 'unknown';
+    }
+    static as(promise) {
+        if (promise.iterator) {
+            return promise.iterator;
+        }
+        const iterator = new ProgressiveIterator('as iterator');
+        promise.then((v) => {
+            try {
+                iterator.add(v, true);
+            }
+            catch (e) {
+                iterator.reject(e);
+            }
+        }, (reason) => {
+            iterator.reject(reason);
+        });
+        return iterator;
+    }
+    add(x, done = false) {
+        this.nextValue = x;
+        this.done ||= done;
+        if (this.waiting) {
+            this.waiting.resolve(x);
+            this.waiting = undefined;
+        }
+    }
+    resolve() {
+        this.done = true;
+        if (this.waiting) {
+            this.waiting.resolve(this.nextValue);
+            this.waiting = undefined;
+        }
+    }
+    reject(reason) {
+        this.rejectReason = reason;
+        this.waiting?.reject(reason);
+    }
+    getRecent() {
+        if (this.rejectReason) {
+            throw this.rejectReason;
+        }
+        return this.nextValue;
+    }
+    async *[Symbol.asyncIterator]() {
+        while (!this.done) {
+            if (this.rejectReason) {
+                throw this.rejectReason;
+            }
+            if (this.nextValue !== undefined) {
+                yield this.nextValue;
+                if (this.done) {
+                    break;
+                }
+            }
+            if (!this.waiting) {
+                this.waiting = {};
+                this.waiting.promise = new Promise((resolve, reject) => {
+                    this.waiting.resolve = resolve;
+                    this.waiting.reject = reject;
+                });
+            }
+            await this.waiting.promise;
+        }
+        yield this.nextValue;
+    }
+    async forEach(callback, errorCallback) {
+        let index = 0;
+        try {
+            for await (const value of this) {
+                const { done } = this;
+                try {
+                    await callback(value, done, index);
+                    index++;
+                }
+                catch (e) {
+                    if (!done) {
+                        console.warn('Caught exception in intermediate value', e);
+                        continue;
+                    }
+                    if (errorCallback) {
+                        errorCallback(e, done);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (errorCallback) {
+                errorCallback(e, true);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    generate(processFunction, errorCallback) {
+        return processFunction(this, this.reject.bind(this)).then(() => {
+            if (!this.done) {
+                this.resolve();
+            }
+        }, (reason) => {
+            this.reject(reason);
+            if (errorCallback) {
+                errorCallback(reason);
+            }
+            else {
+                console.warn("Couldn't process because", reason);
+            }
+        });
+    }
+    async nextPromise() {
+        for await (const i of this) {
+            if (i) {
+                return i;
+            }
+        }
+        return this.nextValue;
+    }
+    async donePromise() {
+        for await (const i of this) {
+        }
+        return this.nextValue;
+    }
+    getNextPromise() {
+        const promise = this.nextPromise();
+        promise.iterator = this;
+        return promise;
+    }
+    getDonePromise() {
+        const promise = this.donePromise();
+        promise.iterator = this;
+        return promise;
+    }
+}
+
+
+/***/ }),
+
+/***/ 67645:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ RLEVoxelMap)
+/* harmony export */ });
+const ADJACENT_ALL = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, -1],
+    [0, 0, 1],
+];
+const ADJACENT_SINGLE_PLANE = [
+    [0, -1, 0],
+    [0, 1, 0],
+];
+const ADJACENT_IN = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, -1],
+];
+const ADJACENT_OUT = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, 1],
+];
+class RLEVoxelMap {
+    static copyMap(destination, source) {
+        for (const [index, row] of source.rows) {
+            destination.rows.set(index, structuredClone(row));
+        }
+    }
+    constructor(width, height, depth = 1) {
+        this.rows = new Map();
+        this.height = 1;
+        this.width = 1;
+        this.depth = 1;
+        this.jMultiple = 1;
+        this.kMultiple = 1;
+        this.numComps = 1;
+        this.pixelDataConstructor = Uint8Array;
+        this.updateScalarData = function (scalarData) {
+            scalarData.fill(0);
+            const callback = (index, rle, row) => {
+                const { start, end, value } = rle;
+                for (let i = start; i < end; i++) {
+                    scalarData[index + i] = value;
+                }
+            };
+            this.forEach(callback);
+        };
+        this.get = (index) => {
+            const i = index % this.jMultiple;
+            const j = (index - i) / this.jMultiple;
+            const rle = this.getRLE(i, j);
+            return rle?.value ?? this.defaultValue;
+        };
+        this.getRun = (j, k) => {
+            const runIndex = j + k * this.height;
+            return this.rows.get(runIndex);
+        };
+        this.set = (index, value) => {
+            if (value === undefined) {
+                return;
+            }
+            const i = index % this.width;
+            const j = (index - i) / this.width;
+            const row = this.rows.get(j);
+            if (!row) {
+                this.rows.set(j, [{ start: i, end: i + 1, value }]);
+                return;
+            }
+            const rleIndex = this.findIndex(row, i);
+            const rle1 = row[rleIndex];
+            const rle0 = row[rleIndex - 1];
+            if (!rle1) {
+                if (!rle0 || rle0.value !== value || rle0.end !== i) {
+                    row[rleIndex] = { start: i, end: i + 1, value };
+                    return;
+                }
+                rle0.end++;
+                return;
+            }
+            const { start, end, value: oldValue } = rle1;
+            if (value === oldValue && i >= start) {
+                return;
+            }
+            const rleInsert = { start: i, end: i + 1, value };
+            const isAfter = i > start;
+            const insertIndex = isAfter ? rleIndex + 1 : rleIndex;
+            const rlePrev = isAfter ? rle1 : rle0;
+            let rleNext = isAfter ? row[rleIndex + 1] : rle1;
+            if (rlePrev?.value === value && rlePrev?.end === i) {
+                rlePrev.end++;
+                if (rleNext?.value === value && rleNext.start === i + 1) {
+                    rlePrev.end = rleNext.end;
+                    row.splice(rleIndex, 1);
+                }
+                else if (rleNext?.start === i) {
+                    rleNext.start++;
+                    if (rleNext.start === rleNext.end) {
+                        row.splice(rleIndex, 1);
+                        rleNext = row[rleIndex];
+                        if (rleNext?.start === i + 1 && rleNext.value === value) {
+                            rlePrev.end = rleNext.end;
+                            row.splice(rleIndex, 1);
+                        }
+                    }
+                }
+                return;
+            }
+            if (rleNext?.value === value && rleNext.start === i + 1) {
+                rleNext.start--;
+                if (rlePrev?.end > i) {
+                    rlePrev.end = i;
+                    if (rlePrev.end === rlePrev.start) {
+                        row.splice(rleIndex, 1);
+                    }
+                }
+                return;
+            }
+            if (rleNext?.start === i && rleNext.end === i + 1) {
+                rleNext.value = value;
+                const nextnext = row[rleIndex + 1];
+                if (nextnext?.start == i + 1 && nextnext.value === value) {
+                    row.splice(rleIndex + 1, 1);
+                    rleNext.end = nextnext.end;
+                }
+                return;
+            }
+            if (i === rleNext?.start) {
+                rleNext.start++;
+            }
+            if (isAfter && end > i + 1) {
+                row.splice(insertIndex, 0, rleInsert, {
+                    start: i + 1,
+                    end: rlePrev.end,
+                    value: rlePrev.value,
+                });
+            }
+            else {
+                row.splice(insertIndex, 0, rleInsert);
+            }
+            if (rlePrev?.end > i) {
+                rlePrev.end = i;
+            }
+        };
+        this.width = width;
+        this.height = height;
+        this.depth = depth;
+        this.jMultiple = width;
+        this.kMultiple = this.jMultiple * height;
+    }
+    static { this.getScalarData = function (ArrayType = Uint8ClampedArray) {
+        const scalarData = new ArrayType(this.frameSize);
+        this.map.updateScalarData(scalarData);
+        return scalarData;
+    }; }
+    toIJK(index) {
+        const i = index % this.jMultiple;
+        const j = ((index - i) / this.jMultiple) % this.height;
+        const k = Math.floor(index / this.kMultiple);
+        return [i, j, k];
+    }
+    toIndex([i, j, k]) {
+        return i + k * this.kMultiple + j * this.jMultiple;
+    }
+    getRLE(i, j, k = 0) {
+        const row = this.rows.get(j + k * this.height);
+        if (!row) {
+            return;
+        }
+        const index = this.findIndex(row, i);
+        const rle = row[index];
+        return i >= rle?.start ? rle : undefined;
+    }
+    has(index) {
+        const i = index % this.jMultiple;
+        const j = (index - i) / this.jMultiple;
+        const rle = this.getRLE(i, j);
+        return rle?.value !== undefined;
+    }
+    delete(index) {
+        const i = index % this.width;
+        const j = (index - i) / this.width;
+        const row = this.rows.get(j);
+        if (!row) {
+            return;
+        }
+        const rleIndex = this.findIndex(row, i);
+        const rle = row[rleIndex];
+        if (!rle || rle.start > i) {
+            return;
+        }
+        if (rle.end === i + 1) {
+            rle.end--;
+            if (rle.start >= rle.end) {
+                row.splice(rleIndex, 1);
+                if (!row.length) {
+                    this.rows.delete(j);
+                }
+            }
+            return;
+        }
+        if (rle.start === i) {
+            rle.start++;
+            return;
+        }
+        const newRle = {
+            value: rle.value,
+            start: i + 1,
+            end: rle.end,
+        };
+        rle.end = i;
+        row.splice(rleIndex + 1, 0, newRle);
+    }
+    findIndex(row, i) {
+        for (let index = 0; index < row.length; index++) {
+            const { end: iEnd } = row[index];
+            if (i < iEnd) {
+                return index;
+            }
+        }
+        return row.length;
+    }
+    forEach(callback, options) {
+        const rowModified = options?.rowModified;
+        for (const [baseIndex, row] of this.rows) {
+            const rowToUse = rowModified ? [...row] : row;
+            for (const rle of rowToUse) {
+                callback(baseIndex * this.width, rle, row);
+            }
+        }
+    }
+    forEachRow(callback) {
+        for (const [baseIndex, row] of this.rows) {
+            callback(baseIndex * this.width, row);
+        }
+    }
+    clear() {
+        this.rows.clear();
+    }
+    keys() {
+        return [...this.rows.keys()];
+    }
+    getPixelData(k = 0, pixelData) {
+        if (!pixelData) {
+            pixelData = new this.pixelDataConstructor(this.width * this.height * this.numComps);
+        }
+        else {
+            pixelData.fill(0);
+        }
+        const { width, height, numComps } = this;
+        for (let j = 0; j < height; j++) {
+            const row = this.getRun(j, k);
+            if (!row) {
+                continue;
+            }
+            if (numComps === 1) {
+                for (const rle of row) {
+                    const rowOffset = j * width;
+                    const { start, end, value } = rle;
+                    for (let i = start; i < end; i++) {
+                        pixelData[rowOffset + i] = value;
+                    }
+                }
+            }
+            else {
+                for (const rle of row) {
+                    const rowOffset = j * width * numComps;
+                    const { start, end, value } = rle;
+                    for (let i = start; i < end; i += numComps) {
+                        for (let comp = 0; comp < numComps; comp++) {
+                            pixelData[rowOffset + i + comp] = value[comp];
+                        }
+                    }
+                }
+            }
+        }
+        return pixelData;
+    }
+    floodFill(i, j, k, value, options) {
+        const rle = this.getRLE(i, j, k);
+        if (!rle) {
+            throw new Error(`Initial point ${i},${j},${k} isn't in the RLE`);
+        }
+        const stack = [[rle, j, k]];
+        const replaceValue = rle.value;
+        if (replaceValue === value) {
+            throw new Error(`source (${replaceValue}) and destination (${value}) are identical`);
+        }
+        return this.flood(stack, replaceValue, value, options);
+    }
+    flood(stack, sourceValue, value, options) {
+        let sum = 0;
+        const { planar = true, diagonals = true, singlePlane = false, } = options || {};
+        const childOptions = { planar, diagonals, singlePlane };
+        while (stack.length) {
+            const top = stack.pop();
+            const [current] = top;
+            if (current.value !== sourceValue) {
+                continue;
+            }
+            current.value = value;
+            sum += current.end - current.start;
+            const adjacents = this.findAdjacents(top, childOptions).filter((adjacent) => adjacent && adjacent[0].value === sourceValue);
+            stack.push(...adjacents);
+        }
+        return sum;
+    }
+    fillFrom(getter, boundsIJK) {
+        for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+            for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                let rle;
+                let row;
+                for (let i = boundsIJK[0][0]; i <= boundsIJK[0][1]; i++) {
+                    const value = getter(i, j, k);
+                    if (value === undefined) {
+                        rle = undefined;
+                        continue;
+                    }
+                    if (!row) {
+                        row = [];
+                        this.rows.set(j + k * this.height, row);
+                    }
+                    if (rle && rle.value !== value) {
+                        rle = undefined;
+                    }
+                    if (!rle) {
+                        rle = { start: i, end: i, value };
+                        row.push(rle);
+                    }
+                    rle.end++;
+                }
+            }
+        }
+    }
+    findAdjacents(item, { diagonals = true, planar = true, singlePlane = false }) {
+        const [rle, j, k, adjacentsDelta] = item;
+        const { start, end } = rle;
+        const leftRle = start > 0 && this.getRLE(start - 1, j, k);
+        const rightRle = end < this.width && this.getRLE(end, j, k);
+        const range = diagonals
+            ? [start > 0 ? start - 1 : start, end < this.width ? end + 1 : end]
+            : [start, end];
+        const adjacents = [];
+        if (leftRle) {
+            adjacents.push([leftRle, j, k]);
+        }
+        if (rightRle) {
+            adjacents.push([rightRle, j, k]);
+        }
+        for (const delta of adjacentsDelta ||
+            (singlePlane ? ADJACENT_SINGLE_PLANE : ADJACENT_ALL)) {
+            const [, delta1, delta2] = delta;
+            const testJ = delta1 + j;
+            const testK = delta2 + k;
+            if (testJ < 0 || testJ >= this.height) {
+                continue;
+            }
+            if (testK < 0 || testK >= this.depth) {
+                continue;
+            }
+            const row = this.getRun(testJ, testK);
+            if (!row) {
+                continue;
+            }
+            for (const testRle of row) {
+                const newAdjacentDelta = adjacentsDelta ||
+                    (singlePlane && ADJACENT_SINGLE_PLANE) ||
+                    (planar && delta2 > 0 && ADJACENT_OUT) ||
+                    (planar && delta2 < 0 && ADJACENT_IN) ||
+                    ADJACENT_ALL;
+                if (!(testRle.end <= range[0] || testRle.start >= range[1])) {
+                    adjacents.push([testRle, testJ, testK, newAdjacentDelta]);
+                }
+            }
+        }
+        return adjacents;
+    }
+}
+
+
+/***/ }),
+
+/***/ 98039:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   N: () => (/* binding */ actorIsA),
+/* harmony export */   e: () => (/* binding */ isImageActor)
+/* harmony export */ });
+function isImageActor(actorEntry) {
+    return (actorIsA(actorEntry, 'vtkVolume') || actorIsA(actorEntry, 'vtkImageSlice'));
+}
+function actorIsA(actorEntry, actorType) {
+    const actorToCheck = 'isA' in actorEntry ? actorEntry : actorEntry.actor;
+    if (!actorToCheck) {
+        return false;
+    }
+    return !!actorToCheck.isA(actorType);
+}
+
+
+/***/ }),
+
+/***/ 96833:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ applyPreset)
+/* harmony export */ });
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33739);
+/* harmony import */ var _kitware_vtk_js_Common_DataModel_PiecewiseFunction__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99341);
+
+
+function applyPreset(actor, preset) {
+    const colorTransferArray = preset.colorTransfer
+        .split(' ')
+        .splice(1)
+        .map(parseFloat);
+    const { shiftRange } = getShiftRange(colorTransferArray);
+    const min = shiftRange[0];
+    const width = shiftRange[1] - shiftRange[0];
+    const cfun = _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance();
+    const normColorTransferValuePoints = [];
+    for (let i = 0; i < colorTransferArray.length; i += 4) {
+        let value = colorTransferArray[i];
+        const r = colorTransferArray[i + 1];
+        const g = colorTransferArray[i + 2];
+        const b = colorTransferArray[i + 3];
+        value = (value - min) / width;
+        normColorTransferValuePoints.push([value, r, g, b]);
+    }
+    applyPointsToRGBFunction(normColorTransferValuePoints, shiftRange, cfun);
+    actor.getProperty().setRGBTransferFunction(0, cfun);
+    const scalarOpacityArray = preset.scalarOpacity
+        .split(' ')
+        .splice(1)
+        .map(parseFloat);
+    const ofun = _kitware_vtk_js_Common_DataModel_PiecewiseFunction__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance();
+    const normPoints = [];
+    for (let i = 0; i < scalarOpacityArray.length; i += 2) {
+        let value = scalarOpacityArray[i];
+        const opacity = scalarOpacityArray[i + 1];
+        value = (value - min) / width;
+        normPoints.push([value, opacity]);
+    }
+    applyPointsToPiecewiseFunction(normPoints, shiftRange, ofun);
+    const property = actor.getProperty();
+    property.setScalarOpacity(0, ofun);
+    const [gradientMinValue, gradientMinOpacity, gradientMaxValue, gradientMaxOpacity,] = preset.gradientOpacity.split(' ').splice(1).map(parseFloat);
+    property.setUseGradientOpacity(0, true);
+    property.setGradientOpacityMinimumValue(0, gradientMinValue);
+    property.setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
+    property.setGradientOpacityMaximumValue(0, gradientMaxValue);
+    property.setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
+    if (preset.interpolation === '1') {
+        property.setInterpolationTypeToFastLinear();
+    }
+    property.setShade(preset.shade === '1');
+    const ambient = parseFloat(preset.ambient);
+    const diffuse = parseFloat(preset.diffuse);
+    const specular = parseFloat(preset.specular);
+    const specularPower = parseFloat(preset.specularPower);
+    property.setAmbient(ambient);
+    property.setDiffuse(diffuse);
+    property.setSpecular(specular);
+    property.setSpecularPower(specularPower);
+}
+function getShiftRange(colorTransferArray) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0; i < colorTransferArray.length; i += 4) {
+        min = Math.min(min, colorTransferArray[i]);
+        max = Math.max(max, colorTransferArray[i]);
+    }
+    const center = (max - min) / 2;
+    return {
+        shiftRange: [-center, center],
+        min,
+        max,
+    };
+}
+function applyPointsToRGBFunction(points, range, cfun) {
+    const width = range[1] - range[0];
+    const rescaled = points.map(([x, r, g, b]) => [
+        x * width + range[0],
+        r,
+        g,
+        b,
+    ]);
+    cfun.removeAllPoints();
+    rescaled.forEach(([x, r, g, b]) => cfun.addRGBPoint(x, r, g, b));
+    return rescaled;
+}
+function applyPointsToPiecewiseFunction(points, range, pwf) {
+    const width = range[1] - range[0];
+    const rescaled = points.map(([x, y]) => [x * width + range[0], y]);
+    pwf.removeAllPoints();
+    rescaled.forEach(([x, y]) => pwf.addPoint(x, y));
+    return rescaled;
+}
+
+
+/***/ }),
+
+/***/ 91979:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39536);
+/* harmony import */ var _getViewportsWithVolumeId__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(24724);
+
+
+const autoLoad = (volumeId) => {
+    const renderingEngineAndViewportIds = getRenderingEngineAndViewportsContainingVolume(volumeId);
+    if (!renderingEngineAndViewportIds?.length) {
+        return;
+    }
+    renderingEngineAndViewportIds.forEach(({ renderingEngine, viewportIds }) => {
+        if (!renderingEngine.hasBeenDestroyed) {
+            renderingEngine.renderViewports(viewportIds);
+        }
+    });
+};
+function getRenderingEngineAndViewportsContainingVolume(volumeId) {
+    const renderingEnginesArray = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .qO)();
+    const renderingEngineAndViewportIds = [];
+    renderingEnginesArray.forEach((renderingEngine) => {
+        const viewports = (0,_getViewportsWithVolumeId__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(volumeId);
+        if (viewports.length) {
+            renderingEngineAndViewportIds.push({
+                renderingEngine,
+                viewportIds: viewports.map((viewport) => viewport.id),
+            });
+        }
+    });
+    return renderingEngineAndViewportIds;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (autoLoad);
+
+
+/***/ }),
+
+/***/ 42384:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ calculateSpacingBetweenImageIds)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+/* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(59693);
+
+
+
+function calculateSpacingBetweenImageIds(imageIds) {
+    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
+    const rowCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+    const colCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+    const scanAxisNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    const refIppVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(referenceImagePositionPatient[0], referenceImagePositionPatient[1], referenceImagePositionPatient[2]);
+    const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
+    let spacing;
+    function getDistance(imageId) {
+        const { imagePositionPatient } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageId);
+        const positionVector = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        const ippVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imagePositionPatient[0], imagePositionPatient[1], imagePositionPatient[2]);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(positionVector, refIppVec, ippVec);
+        return gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(positionVector, scanAxisNormal);
+    }
+    if (!usingWadoUri) {
+        const distanceImagePairs = imageIds.map((imageId) => {
+            const distance = getDistance(imageId);
+            return {
+                distance,
+                imageId,
+            };
+        });
+        distanceImagePairs.sort((a, b) => b.distance - a.distance);
+        const numImages = distanceImagePairs.length;
+        spacing =
+            Math.abs(distanceImagePairs[numImages - 1].distance -
+                distanceImagePairs[0].distance) /
+                (numImages - 1);
+    }
+    else {
+        const prefetchedImageIds = [
+            imageIds[0],
+            imageIds[Math.floor(imageIds.length / 2)],
+        ];
+        const firstImageDistance = getDistance(prefetchedImageIds[0]);
+        const middleImageDistance = getDistance(prefetchedImageIds[1]);
+        const metadataForMiddleImage = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', prefetchedImageIds[1]);
+        if (!metadataForMiddleImage) {
+            throw new Error('Incomplete metadata required for volume construction.');
+        }
+        const positionVector = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        const middleIppVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(metadataForMiddleImage.imagePositionPatient[0], metadataForMiddleImage.imagePositionPatient[1], metadataForMiddleImage.imagePositionPatient[2]);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(positionVector, refIppVec, middleIppVec);
+        const distanceBetweenFirstAndMiddleImages = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(positionVector, scanAxisNormal);
+        spacing =
+            Math.abs(distanceBetweenFirstAndMiddleImages) /
+                Math.floor(imageIds.length / 2);
+    }
+    const { sliceThickness, spacingBetweenSlices } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
+    const { strictZSpacingForVolumeViewport } = (0,_init__WEBPACK_IMPORTED_MODULE_2__/* .getConfiguration */ .D0)().rendering;
+    if (spacing === 0 && !strictZSpacingForVolumeViewport) {
+        if (spacingBetweenSlices) {
+            console.debug('Could not calculate spacing. Using spacingBetweenSlices');
+            spacing = spacingBetweenSlices;
+        }
+        else if (sliceThickness) {
+            console.debug('Could not calculate spacing and no spacingBetweenSlices. Using sliceThickness');
+            spacing = sliceThickness;
+        }
+        else {
+            console.debug('Could not calculate spacing. The VolumeViewport visualization is compromised. Setting spacing to 1 to render');
+            spacing = 1;
+        }
+    }
+    return spacing;
+}
+
+
+/***/ }),
+
+/***/ 74657:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ createLinearRGBTransferFunction)
+/* harmony export */ });
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33739);
+
+function createLinearRGBTransferFunction(voiRange) {
+    const cfun = _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance();
+    let lower = 0;
+    let upper = 1024;
+    if (voiRange.lower !== undefined && voiRange.upper !== undefined) {
+        lower = voiRange.lower;
+        upper = voiRange.upper;
+    }
+    cfun.addRGBPoint(lower, 0.0, 0.0, 0.0);
+    cfun.addRGBPoint(upper, 1.0, 1.0, 1.0);
+    return cfun;
+}
+
+
+/***/ }),
+
+/***/ 40256:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ createSigmoidRGBTransferFunction)
+/* harmony export */ });
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33739);
+/* harmony import */ var _kitware_vtk_js_Common_Core_DataArray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(42008);
+/* harmony import */ var _windowLevel__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(68136);
+/* harmony import */ var _logit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(58977);
+
+
+
+
+function createSigmoidRGBTransferFunction(voiRange, approximationNodes = 1024) {
+    const { windowWidth, windowCenter } = _windowLevel__WEBPACK_IMPORTED_MODULE_2__.toWindowLevel(voiRange.lower, voiRange.upper);
+    const range = Array.from({ length: approximationNodes }, (_, i) => (i + 1) / (approximationNodes + 2));
+    const table = range.flatMap((y) => {
+        const x = (0,_logit__WEBPACK_IMPORTED_MODULE_3__/* .logit */ .i)(y, windowCenter, windowWidth);
+        return [x, y, y, y, 0.5, 0.0];
+    });
+    const cfun = _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance();
+    cfun.buildFunctionFromArray(_kitware_vtk_js_Common_Core_DataArray__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance({
+        values: table,
+        numberOfComponents: 6,
+    }));
+    return cfun;
+}
+
+
+/***/ }),
+
+/***/ 63470:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ decimate)
+/* harmony export */ });
+function decimate(list, interleave, offset = 0) {
+    const interleaveIndices = [];
+    for (let i = offset; i < list.length; i += interleave) {
+        interleaveIndices.push(i);
+    }
+    return interleaveIndices;
+}
+
+
+/***/ }),
+
+/***/ 99949:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   G: () => (/* binding */ deepClone)
+/* harmony export */ });
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (typeof obj === 'function') {
+        return obj;
+    }
+    if (typeof structuredClone === 'function') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(deepClone);
+    }
+    else {
+        const clonedObj = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                clonedObj[key] = deepClone(obj[key]);
+            }
+        }
+        return clonedObj;
+    }
+}
+
+
+/***/ }),
+
+/***/ 20286:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ fnv1aHash)
+/* harmony export */ });
+function fnv1aHash(str) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash +=
+            (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    return (hash >>> 0).toString(36);
+}
+
+
+/***/ }),
+
+/***/ 88619:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getClosestImageId)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+/* harmony import */ var _getSpacingInNormalDirection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(85008);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(19325);
+
+
+
+
+function getClosestImageId(imageVolume, worldPos, viewPlaneNormal) {
+    const { direction, spacing, imageIds } = imageVolume;
+    if (!imageIds.length) {
+        return;
+    }
+    const kVector = direction.slice(6, 9);
+    const dotProducts = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(kVector, viewPlaneNormal);
+    if (Math.abs(dotProducts) < 1 - _constants__WEBPACK_IMPORTED_MODULE_3__.EPSILON) {
+        return;
+    }
+    const spacingInNormalDirection = (0,_getSpacingInNormalDirection__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)({ direction, spacing }, viewPlaneNormal);
+    const halfSpacingInNormalDirection = spacingInNormalDirection / 2;
+    let imageIdForTool;
+    for (let i = 0; i < imageIds.length; i++) {
+        const imageId = imageIds[i];
+        const { imagePositionPatient } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageId);
+        const dir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(dir, worldPos, imagePositionPatient);
+        const dot = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(dir, viewPlaneNormal);
+        if (Math.abs(dot) < halfSpacingInNormalDirection) {
+            imageIdForTool = imageId;
+        }
+    }
+    return imageIdForTool;
+}
+
+
+/***/ }),
+
+/***/ 47476:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _getSliceRange__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20537);
+/* harmony import */ var _getTargetVolumeAndSpacingInNormalDir__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(65292);
+
+
+function getImageSliceDataForVolumeViewport(viewport) {
+    const camera = viewport.getCamera();
+    const { spacingInNormalDirection, imageVolume } = (0,_getTargetVolumeAndSpacingInNormalDir__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(viewport, camera);
+    if (!imageVolume) {
+        return;
+    }
+    const { viewPlaneNormal, focalPoint } = camera;
+    const actorEntry = viewport
+        .getActors()
+        .find((a) => a.referencedId === imageVolume.volumeId ||
+        a.uid === imageVolume.volumeId);
+    if (!actorEntry) {
+        console.warn('No actor found for with actorUID of', imageVolume.volumeId);
+    }
+    const volumeActor = actorEntry.actor;
+    const sliceRange = (0,_getSliceRange__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(volumeActor, viewPlaneNormal, focalPoint);
+    const { min, max, current } = sliceRange;
+    const numberOfSlices = Math.round((max - min) / spacingInNormalDirection) + 1;
+    let imageIndex = ((current - min) / (max - min)) * numberOfSlices;
+    imageIndex = Math.floor(imageIndex);
+    if (imageIndex > numberOfSlices - 1) {
+        imageIndex = numberOfSlices - 1;
+    }
+    else if (imageIndex < 0) {
+        imageIndex = 0;
+    }
+    return {
+        numberOfSlices,
+        imageIndex,
+    };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getImageSliceDataForVolumeViewport);
+
+
+/***/ }),
+
+/***/ 32173:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getScalingParameters)
+/* harmony export */ });
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74876);
+
+function getScalingParameters(imageId) {
+    const modalityLutModule = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('modalityLutModule', imageId) || {};
+    const generalSeriesModule = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('generalSeriesModule', imageId) || {};
+    const { modality } = generalSeriesModule;
+    const scalingParameters = {
+        rescaleSlope: modalityLutModule.rescaleSlope || 1,
+        rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
+        modality,
+    };
+    const suvFactor = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('scalingModule', imageId) || {};
+    return {
+        ...scalingParameters,
+        ...(modality === 'PT' && {
+            suvbw: suvFactor.suvbw,
+            suvbsa: suvFactor.suvbsa,
+            suvlbm: suvFactor.suvlbm,
+        }),
+    };
+}
+
+
+/***/ }),
+
+/***/ 20537:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getSliceRange)
+/* harmony export */ });
+/* harmony import */ var _kitware_vtk_js_Common_Core_MatrixBuilder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(89265);
+/* harmony import */ var _getVolumeActorCorners__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15105);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19325);
+
+
+
+const SMALL_EPSILON = _constants__WEBPACK_IMPORTED_MODULE_2__.EPSILON * _constants__WEBPACK_IMPORTED_MODULE_2__.EPSILON;
+const isOne = (v) => Math.abs(Math.abs(v) - 1) < SMALL_EPSILON;
+const isUnit = (v, off) => isOne(v[off]) || isOne(v[off + 1]) || isOne(v[off + 2]);
+const isOrthonormal = (v) => isUnit(v, 0) && isUnit(v, 3) && isUnit(v, 6);
+function getSliceRange(volumeActor, viewPlaneNormal, focalPoint) {
+    const imageData = volumeActor.getMapper().getInputData();
+    let corners;
+    const direction = imageData.getDirection();
+    if (isOrthonormal(direction)) {
+        corners = (0,_getVolumeActorCorners__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(volumeActor);
+    }
+    else {
+        const [dx, dy, dz] = imageData.getDimensions();
+        const cornersIdx = [
+            [0, 0, 0],
+            [dx - 1, 0, 0],
+            [0, dy - 1, 0],
+            [dx - 1, dy - 1, 0],
+            [0, 0, dz - 1],
+            [dx - 1, 0, dz - 1],
+            [0, dy - 1, dz - 1],
+            [dx - 1, dy - 1, dz - 1],
+        ];
+        corners = cornersIdx.map((it) => imageData.indexToWorld(it));
+    }
+    const transform = _kitware_vtk_js_Common_Core_MatrixBuilder__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A
+        .buildFromDegree()
+        .identity()
+        .rotateFromDirections(viewPlaneNormal, [1, 0, 0]);
+    corners.forEach((pt) => transform.apply(pt));
+    const transformedFocalPoint = [...focalPoint];
+    transform.apply(transformedFocalPoint);
+    const currentSlice = transformedFocalPoint[0];
+    let minX = Infinity;
+    let maxX = -Infinity;
+    for (let i = 0; i < 8; i++) {
+        const x = corners[i][0];
+        if (x > maxX) {
+            maxX = x;
+        }
+        if (x < minX) {
+            minX = x;
+        }
+    }
+    return {
+        min: minX,
+        max: maxX,
+        current: currentSlice,
+        actor: volumeActor,
+        viewPlaneNormal,
+        focalPoint,
+    };
+}
+
+
+/***/ }),
+
+/***/ 85008:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getSpacingInNormalDirection)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+
+function getSpacingInNormalDirection(imageVolume, viewPlaneNormal) {
+    const { direction, spacing } = imageVolume;
+    const iVector = direction.slice(0, 3);
+    const jVector = direction.slice(3, 6);
+    const kVector = direction.slice(6, 9);
+    const dotProducts = [
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(iVector, viewPlaneNormal),
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(jVector, viewPlaneNormal),
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(kVector, viewPlaneNormal),
+    ];
+    const projectedSpacing = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.set */ .eR.set(projectedSpacing, dotProducts[0] * spacing[0], dotProducts[1] * spacing[1], dotProducts[2] * spacing[2]);
+    const spacingInNormalDirection = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.length */ .eR.length(projectedSpacing);
+    return spacingInNormalDirection;
+}
+
+
+/***/ }),
+
+/***/ 65292:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getTargetVolumeAndSpacingInNormalDir)
+/* harmony export */ });
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(49038);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(19325);
+/* harmony import */ var _getSpacingInNormalDirection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(85008);
+/* harmony import */ var _loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39561);
+/* harmony import */ var _getVolumeId__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(12437);
+
+
+
+
+
+const EPSILON_PART = 1 + _constants__WEBPACK_IMPORTED_MODULE_1__.EPSILON;
+const startsWith = (str, starts) => starts === str.substring(0, Math.min(str.length, starts.length));
+const isPrimaryVolume = (volume) => !!(0,_loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_3__.getVolumeLoaderSchemes)().find((scheme) => startsWith(volume.volumeId, scheme));
+function getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetId, useSlabThickness = false) {
+    const { viewPlaneNormal } = camera;
+    const volumeActors = viewport.getActors();
+    if (!volumeActors.length) {
+        return {
+            spacingInNormalDirection: null,
+            imageVolume: null,
+            actorUID: null,
+        };
+    }
+    const imageVolumes = volumeActors
+        .map((va) => {
+        const actorUID = va.referencedId ?? va.uid;
+        return _cache_cache__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Ay.getVolume(actorUID);
+    })
+        .filter((iv) => !!iv);
+    if (targetId) {
+        const targetVolumeId = (0,_getVolumeId__WEBPACK_IMPORTED_MODULE_4__/* .getVolumeId */ .A)(targetId);
+        const imageVolumeIndex = imageVolumes.findIndex((iv) => targetVolumeId.includes(iv.volumeId));
+        const imageVolume = imageVolumes[imageVolumeIndex];
+        const { uid: actorUID } = volumeActors[imageVolumeIndex];
+        const spacingInNormalDirection = getSpacingInNormal(imageVolume, viewPlaneNormal, viewport, useSlabThickness);
+        return { imageVolume, spacingInNormalDirection, actorUID };
+    }
+    if (!imageVolumes.length) {
+        return {
+            spacingInNormalDirection: null,
+            imageVolume: null,
+            actorUID: null,
+        };
+    }
+    const smallest = {
+        spacingInNormalDirection: Infinity,
+        imageVolume: null,
+        actorUID: null,
+    };
+    const hasPrimaryVolume = imageVolumes.find(isPrimaryVolume);
+    for (let i = 0; i < imageVolumes.length; i++) {
+        const imageVolume = imageVolumes[i];
+        if (hasPrimaryVolume && !isPrimaryVolume(imageVolume)) {
+            continue;
+        }
+        const spacingInNormalDirection = getSpacingInNormal(imageVolume, viewPlaneNormal, viewport);
+        if (spacingInNormalDirection * EPSILON_PART <
+            smallest.spacingInNormalDirection) {
+            smallest.spacingInNormalDirection = spacingInNormalDirection;
+            smallest.imageVolume = imageVolume;
+            smallest.actorUID = volumeActors[i].uid;
+        }
+    }
+    return smallest;
+}
+function getSpacingInNormal(imageVolume, viewPlaneNormal, viewport, useSlabThickness = false) {
+    const { slabThickness } = viewport.getProperties();
+    let spacingInNormalDirection = slabThickness;
+    if (!slabThickness || !useSlabThickness) {
+        spacingInNormalDirection = (0,_getSpacingInNormalDirection__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(imageVolume, viewPlaneNormal);
+    }
+    return spacingInNormalDirection;
+}
+
+
+/***/ }),
+
+/***/ 24724:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39536);
+
+function getViewportsWithVolumeId(volumeId) {
+    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .qO)();
+    const targetViewports = [];
+    renderingEngines.forEach((renderingEngine) => {
+        const viewports = renderingEngine.getVolumeViewports();
+        const filteredViewports = viewports.filter((vp) => vp.hasVolumeId(volumeId));
+        targetViewports.push(...filteredViewports);
+    });
+    return targetViewports;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getViewportsWithVolumeId);
+
+
+/***/ }),
+
+/***/ 70210:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getVoiFromSigmoidRGBTransferFunction)
+/* harmony export */ });
+function getVoiFromSigmoidRGBTransferFunction(cfun) {
+    let cfunRange = [];
+    const [lower, upper] = cfun.getRange();
+    cfun.getTable(lower, upper, 1024, cfunRange);
+    cfunRange = cfunRange.filter((v, k) => k % 3 === 0);
+    const cfunDomain = [...Array(1024).keys()].map((v, k) => {
+        return lower + ((upper - lower) / (1024 - 1)) * k;
+    });
+    const y1 = cfunRange[256];
+    const logy1 = Math.log((1 - y1) / y1);
+    const x1 = cfunDomain[256];
+    const y2 = cfunRange[256 * 3];
+    const logy2 = Math.log((1 - y2) / y2);
+    const x2 = cfunDomain[256 * 3];
+    const ww = Math.round((4 * (x2 - x1)) / (logy1 - logy2));
+    const wc = Math.round(x1 + (ww * logy1) / 4);
+    return [Math.round(wc - ww / 2), Math.round(wc + ww / 2)];
+}
+
+
+/***/ }),
+
+/***/ 15105:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getVolumeActorCorners)
+/* harmony export */ });
+function getVolumeActorCorners(volumeActor) {
+    const imageData = volumeActor.getMapper().getInputData();
+    const bounds = imageData.extentToBounds(imageData.getExtent());
+    return [
+        [bounds[0], bounds[2], bounds[4]],
+        [bounds[0], bounds[2], bounds[5]],
+        [bounds[0], bounds[3], bounds[4]],
+        [bounds[0], bounds[3], bounds[5]],
+        [bounds[1], bounds[2], bounds[4]],
+        [bounds[1], bounds[2], bounds[5]],
+        [bounds[1], bounds[3], bounds[4]],
+        [bounds[1], bounds[3], bounds[5]],
+    ];
+}
+
+
+/***/ }),
+
+/***/ 12437:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getVolumeId)
+/* harmony export */ });
+const getVolumeId = (targetId) => {
+    const prefix = 'volumeId:';
+    const str = targetId.includes(prefix)
+        ? targetId.substring(prefix.length)
+        : targetId;
+    const index = str.indexOf('sliceIndex=');
+    return index === -1 ? str : str.substring(0, index - 1);
+};
+
+
+/***/ }),
+
+/***/ 4031:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _getSliceRange__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20537);
+/* harmony import */ var _getTargetVolumeAndSpacingInNormalDir__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(65292);
+
+
+function getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness = false) {
+    const camera = viewport.getCamera();
+    const { focalPoint, viewPlaneNormal } = camera;
+    const { spacingInNormalDirection, actorUID } = (0,_getTargetVolumeAndSpacingInNormalDir__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(viewport, camera, volumeId, useSlabThickness);
+    if (!actorUID) {
+        throw new Error(`Could not find image volume with id ${volumeId} in the viewport`);
+    }
+    const actorEntry = viewport.getActor(actorUID);
+    if (!actorEntry) {
+        console.warn('No actor found for with actorUID of', actorUID);
+        return null;
+    }
+    const volumeActor = actorEntry.actor;
+    const sliceRange = (0,_getSliceRange__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(volumeActor, viewPlaneNormal, focalPoint);
+    return {
+        sliceRange,
+        spacingInNormalDirection,
+        camera,
+    };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getVolumeSliceRangeInfo);
+
+
+/***/ }),
+
+/***/ 61375:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _getVolumeSliceRangeInfo__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4031);
+
+function getVolumeViewportScrollInfo(viewport, volumeId, useSlabThickness = false) {
+    const { sliceRange, spacingInNormalDirection, camera } = (0,_getVolumeSliceRangeInfo__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(viewport, volumeId, useSlabThickness);
+    const { min, max, current } = sliceRange;
+    const numScrollSteps = Math.round((max - min) / spacingInNormalDirection);
+    const fraction = (current - min) / (max - min);
+    const floatingStepNumber = fraction * numScrollSteps;
+    const currentStepIndex = Math.round(floatingStepNumber);
+    return {
+        numScrollSteps,
+        currentStepIndex,
+        sliceRangeInfo: {
+            sliceRange,
+            spacingInNormalDirection,
+            camera,
+        },
+    };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getVolumeViewportScrollInfo);
+
+
+/***/ }),
+
+/***/ 30169:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   a: () => (/* binding */ hasFloatScalingParameters)
+/* harmony export */ });
+const hasFloatScalingParameters = (scalingParameters) => {
+    const hasFloatRescale = Object.values(scalingParameters).some((value) => typeof value === 'number' && !Number.isInteger(value));
+    return hasFloatRescale;
+};
+
+
+/***/ }),
+
+/***/ 38883:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ hasNaNValues)
+/* harmony export */ });
+function hasNaNValues(input) {
+    if (Array.isArray(input)) {
+        return input.some((value) => Number.isNaN(value));
+    }
+    return Number.isNaN(input);
+}
+
+
+/***/ }),
+
+/***/ 39537:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ imageIdToURI)
+/* harmony export */ });
+function imageIdToURI(imageId) {
+    const colonIndex = imageId.indexOf(':');
+    return imageId.substring(colonIndex + 1);
+}
+
+
+/***/ }),
+
+/***/ 17791:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74876);
+
+const retrieveConfigurationState = new Map();
+const IMAGE_RETRIEVE_CONFIGURATION = 'imageRetrieveConfiguration';
+const imageRetrieveMetadataProvider = {
+    IMAGE_RETRIEVE_CONFIGURATION,
+    clear: () => {
+        retrieveConfigurationState.clear();
+    },
+    add: (key, payload) => {
+        retrieveConfigurationState.set(key, payload);
+    },
+    clone: () => {
+        return new Map(retrieveConfigurationState);
+    },
+    restore: (state) => {
+        retrieveConfigurationState.clear();
+        state.forEach((value, key) => {
+            retrieveConfigurationState.set(key, value);
+        });
+    },
+    get: (type, ...queries) => {
+        if (type === IMAGE_RETRIEVE_CONFIGURATION) {
+            return queries
+                .map((query) => retrieveConfigurationState.get(query))
+                .find((it) => it !== undefined);
+        }
+    },
+};
+(0,_metaData__WEBPACK_IMPORTED_MODULE_0__.addProvider)(imageRetrieveMetadataProvider.get.bind(imageRetrieveMetadataProvider));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (imageRetrieveMetadataProvider);
+
+
+/***/ }),
+
+/***/ 50134:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ invertRgbTransferFunction)
+/* harmony export */ });
+function invertRgbTransferFunction(rgbTransferFunction) {
+    if (!rgbTransferFunction) {
+        return;
+    }
+    const size = rgbTransferFunction.getSize();
+    for (let index = 0; index < size; index++) {
+        const nodeValue1 = [];
+        rgbTransferFunction.getNodeValue(index, nodeValue1);
+        nodeValue1[1] = 1 - nodeValue1[1];
+        nodeValue1[2] = 1 - nodeValue1[2];
+        nodeValue1[3] = 1 - nodeValue1[3];
+        rgbTransferFunction.setNodeValue(index, nodeValue1);
+    }
+}
+
+
+/***/ }),
+
+/***/ 1865:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ makeVolumeMetadata)
+/* harmony export */ });
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74876);
+
+function makeVolumeMetadata(imageIds) {
+    const imageId0 = imageIds[0];
+    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = (0,_metaData__WEBPACK_IMPORTED_MODULE_0__.get)('imagePixelModule', imageId0);
+    const voiLut = [];
+    const voiLutModule = (0,_metaData__WEBPACK_IMPORTED_MODULE_0__.get)('voiLutModule', imageId0);
+    let voiLUTFunction;
+    if (voiLutModule) {
+        const { windowWidth, windowCenter } = voiLutModule;
+        voiLUTFunction = voiLutModule?.voiLUTFunction;
+        if (Array.isArray(windowWidth)) {
+            for (let i = 0; i < windowWidth.length; i++) {
+                voiLut.push({
+                    windowWidth: windowWidth[i],
+                    windowCenter: windowCenter[i],
+                });
+            }
+        }
+        else {
+            voiLut.push({
+                windowWidth: windowWidth,
+                windowCenter: windowCenter,
+            });
+        }
+    }
+    else {
+        voiLut.push({
+            windowWidth: undefined,
+            windowCenter: undefined,
+        });
+    }
+    const { modality, seriesInstanceUID } = (0,_metaData__WEBPACK_IMPORTED_MODULE_0__.get)('generalSeriesModule', imageId0);
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = (0,_metaData__WEBPACK_IMPORTED_MODULE_0__.get)('imagePlaneModule', imageId0);
+    return {
+        BitsAllocated: bitsAllocated,
+        BitsStored: bitsStored,
+        SamplesPerPixel: samplesPerPixel,
+        HighBit: highBit,
+        PhotometricInterpretation: photometricInterpretation,
+        PixelRepresentation: pixelRepresentation,
+        Modality: modality,
+        ImageOrientationPatient: imageOrientationPatient,
+        PixelSpacing: pixelSpacing,
+        FrameOfReferenceUID: frameOfReferenceUID,
+        Columns: columns,
+        Rows: rows,
+        voiLut,
+        VOILUTFunction: voiLUTFunction,
+        SeriesInstanceUID: seriesInstanceUID,
+    };
+}
+
+
+/***/ }),
+
+/***/ 56577:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   X6: () => (/* binding */ iterateOverPointsInShapeVoxelManager),
+/* harmony export */   ii: () => (/* binding */ pointInShapeCallback)
+/* harmony export */ });
+/* unused harmony export iterateOverPointsInShape */
+/* harmony import */ var _createPositionCallback__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(87784);
+
+function pointInShapeCallback(imageData, options) {
+    const { pointInShapeFn, callback, boundsIJK, returnPoints = false } = options;
+    let scalarData;
+    if (imageData.getScalarData) {
+        scalarData = imageData.getScalarData();
+    }
+    else {
+        const scalars = imageData.getPointData().getScalars();
+        if (scalars) {
+            scalarData = scalars.getData();
+        }
+        else {
+            const { voxelManager } = imageData.get('voxelManager') || {};
+            if (voxelManager) {
+                scalarData = voxelManager.getCompleteScalarDataArray();
+            }
+        }
+    }
+    const dimensions = imageData.getDimensions();
+    const defaultBoundsIJK = [
+        [0, dimensions[0]],
+        [0, dimensions[1]],
+        [0, dimensions[2]],
+    ];
+    const bounds = boundsIJK || defaultBoundsIJK;
+    const pointsInShape = iterateOverPointsInShape({
+        imageData,
+        bounds,
+        scalarData,
+        pointInShapeFn,
+        callback,
+    });
+    return returnPoints ? pointsInShape : undefined;
+}
+function iterateOverPointsInShape({ imageData, bounds, scalarData, pointInShapeFn, callback, }) {
+    const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = bounds;
+    const { numComps } = imageData;
+    const dimensions = imageData.getDimensions();
+    const indexToWorld = (0,_createPositionCallback__WEBPACK_IMPORTED_MODULE_0__/* .createPositionCallback */ .P)(imageData);
+    const pointIJK = [0, 0, 0];
+    const xMultiple = numComps ||
+        scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
+    const yMultiple = dimensions[0] * xMultiple;
+    const zMultiple = dimensions[1] * yMultiple;
+    const pointsInShape = [];
+    for (let k = kMin; k <= kMax; k++) {
+        pointIJK[2] = k;
+        const indexK = k * zMultiple;
+        for (let j = jMin; j <= jMax; j++) {
+            pointIJK[1] = j;
+            const indexJK = indexK + j * yMultiple;
+            for (let i = iMin; i <= iMax; i++) {
+                pointIJK[0] = i;
+                const pointLPS = indexToWorld(pointIJK);
+                if (pointInShapeFn(pointLPS, pointIJK)) {
+                    const index = indexJK + i * xMultiple;
+                    let value;
+                    if (xMultiple > 2) {
+                        value = [
+                            scalarData[index],
+                            scalarData[index + 1],
+                            scalarData[index + 2],
+                        ];
+                    }
+                    else {
+                        value = scalarData[index];
+                    }
+                    pointsInShape.push({
+                        value,
+                        index,
+                        pointIJK,
+                        pointLPS: pointLPS.slice(),
+                    });
+                    callback({ value, index, pointIJK, pointLPS });
+                }
+            }
+        }
+    }
+    return pointsInShape;
+}
+function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, returnPoints, }) {
+    const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = bounds;
+    const indexToWorld = (0,_createPositionCallback__WEBPACK_IMPORTED_MODULE_0__/* .createPositionCallback */ .P)(imageData);
+    const pointIJK = [0, 0, 0];
+    const pointsInShape = [];
+    for (let k = kMin; k <= kMax; k++) {
+        pointIJK[2] = k;
+        for (let j = jMin; j <= jMax; j++) {
+            pointIJK[1] = j;
+            for (let i = iMin; i <= iMax; i++) {
+                pointIJK[0] = i;
+                const pointLPS = indexToWorld(pointIJK);
+                if (pointInShapeFn(pointLPS, pointIJK)) {
+                    const index = voxelManager.toIndex(pointIJK);
+                    const value = voxelManager.getAtIndex(index);
+                    if (returnPoints) {
+                        pointsInShape.push({
+                            value,
+                            index,
+                            pointIJK: [...pointIJK],
+                            pointLPS: pointLPS.slice(),
+                        });
+                    }
+                    callback?.({ value, index, pointIJK, pointLPS });
+                }
+            }
+        }
+    }
+    return pointsInShape;
+}
+
+
+/***/ }),
+
+/***/ 80500:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ snapFocalPointToSlice)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+
+function snapFocalPointToSlice(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, deltaFrames) {
+    const { min, max, current } = sliceRange;
+    const posDiffFromFocalPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(posDiffFromFocalPoint, position, focalPoint);
+    const steps = Math.round((max - min) / spacingInNormalDirection);
+    const fraction = (current - min) / (max - min);
+    const floatingStepNumber = fraction * steps;
+    let frameIndex = Math.round(floatingStepNumber);
+    let newFocalPoint = [
+        focalPoint[0] -
+            viewPlaneNormal[0] * floatingStepNumber * spacingInNormalDirection,
+        focalPoint[1] -
+            viewPlaneNormal[1] * floatingStepNumber * spacingInNormalDirection,
+        focalPoint[2] -
+            viewPlaneNormal[2] * floatingStepNumber * spacingInNormalDirection,
+    ];
+    frameIndex += deltaFrames;
+    if (frameIndex > steps) {
+        frameIndex = steps;
+    }
+    else if (frameIndex < 0) {
+        frameIndex = 0;
+    }
+    const newSlicePosFromMin = frameIndex * spacingInNormalDirection;
+    newFocalPoint = [
+        newFocalPoint[0] + viewPlaneNormal[0] * newSlicePosFromMin,
+        newFocalPoint[1] + viewPlaneNormal[1] * newSlicePosFromMin,
+        newFocalPoint[2] + viewPlaneNormal[2] * newSlicePosFromMin,
+    ];
+    const newPosition = [
+        newFocalPoint[0] + posDiffFromFocalPoint[0],
+        newFocalPoint[1] + posDiffFromFocalPoint[1],
+        newFocalPoint[2] + posDiffFromFocalPoint[2],
+    ];
+    return { newFocalPoint, newPosition };
+}
+
+
+/***/ }),
+
+/***/ 90537:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ sortImageIdsAndGetSpacing)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+/* harmony import */ var _calculateSpacingBetweenImageIds__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(42384);
+
+
+
+function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
+    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
+    if (!scanAxisNormal) {
+        const rowCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+        const colCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+        scanAxisNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    }
+    const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
+    const zSpacing = (0,_calculateSpacingBetweenImageIds__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(imageIds);
+    let sortedImageIds;
+    function getDistance(imageId) {
+        const { imagePositionPatient } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageId);
+        const positionVector = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(positionVector, referenceImagePositionPatient, imagePositionPatient);
+        return gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(positionVector, scanAxisNormal);
+    }
+    if (!usingWadoUri) {
+        const distanceImagePairs = imageIds.map((imageId) => {
+            const distance = getDistance(imageId);
+            return {
+                distance,
+                imageId,
+            };
+        });
+        distanceImagePairs.sort((a, b) => b.distance - a.distance);
+        sortedImageIds = distanceImagePairs.map((a) => a.imageId);
+    }
+    else {
+        const prefetchedImageIds = [
+            imageIds[0],
+            imageIds[Math.floor(imageIds.length / 2)],
+        ];
+        sortedImageIds = imageIds;
+        const firstImageDistance = getDistance(prefetchedImageIds[0]);
+        const middleImageDistance = getDistance(prefetchedImageIds[1]);
+        if (firstImageDistance - middleImageDistance < 0) {
+            sortedImageIds.reverse();
+        }
+    }
+    const { imagePositionPatient: origin } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', sortedImageIds[0]);
+    const result = {
+        zSpacing,
+        origin,
+        sortedImageIds,
+    };
+    return result;
+}
+
+
+/***/ }),
+
+/***/ 51919:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   e: () => (/* binding */ transformCanvasToIJK)
+/* harmony export */ });
+/* harmony import */ var _transformWorldToIndex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(38669);
+
+function transformCanvasToIJK(viewport, canvasPoint) {
+    const { imageData: vtkImageData } = viewport.getImageData();
+    const worldPoint = viewport.canvasToWorld(canvasPoint);
+    return (0,_transformWorldToIndex__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(vtkImageData, worldPoint);
+}
+
+
+/***/ }),
+
+/***/ 94741:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ transformIndexToWorld)
+/* harmony export */ });
+function transformIndexToWorld(imageData, voxelPos) {
+    return imageData.indexToWorld(voxelPos);
+}
+
+
+/***/ }),
+
+/***/ 45278:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   J: () => (/* binding */ updateVTKImageDataWithCornerstoneImage)
+/* harmony export */ });
+function updateVTKImageDataWithCornerstoneImage(sourceImageData, image) {
+    const pixelData = image.voxelManager.getScalarData();
+    if (!sourceImageData.getPointData) {
+        return;
+    }
+    const scalarData = sourceImageData
+        .getPointData()
+        .getScalars()
+        .getData();
+    if (image.color && image.rgba) {
+        const newPixelData = new Uint8Array(image.columns * image.rows * 3);
+        for (let i = 0; i < image.columns * image.rows; i++) {
+            newPixelData[i * 3] = pixelData[i * 4];
+            newPixelData[i * 3 + 1] = pixelData[i * 4 + 1];
+            newPixelData[i * 3 + 2] = pixelData[i * 4 + 2];
+        }
+        image.rgba = false;
+        image.getPixelData = () => newPixelData;
+        scalarData.set(newPixelData);
+    }
+    else {
+        scalarData.set(pixelData);
+    }
+    sourceImageData.modified();
+}
+
+
+
+/***/ })
+
+}]);