@ohif/app 3.13.0-beta.88 → 3.13.0-beta.89

package/dist/{4287.bundle.4f28e48c1e39a46dfc87.js → 9400.bundle.a56bfccf2bf7a51ed297.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[4287],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9400],{
 
 /***/ 97181
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -73,6 +73,23 @@ var Events;
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Events);
 
 
+/***/ },
+
+/***/ 18682
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+var SegmentationRepresentations;
+(function (SegmentationRepresentations) {
+    SegmentationRepresentations["Labelmap"] = "Labelmap";
+    SegmentationRepresentations["Contour"] = "Contour";
+    SegmentationRepresentations["Surface"] = "Surface";
+})(SegmentationRepresentations || (SegmentationRepresentations = {}));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (SegmentationRepresentations);
+
+
 /***/ },
 
 /***/ 76910
@@ -359,6 +376,849 @@ function validateSegmentationInput(segmentationInputArray) {
 /* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ((/* unused pure expression or super */ null && (validateSegmentationInput)));
 
 
+/***/ },
+
+/***/ 72759
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Qk: () => (/* binding */ beginLabelmapEditTransaction),
+/* harmony export */   Ry: () => (/* binding */ eraseLabelmapEditTransactionOverwrites),
+/* harmony export */   VQ: () => (/* binding */ resolveLabelmapLayerEditTarget)
+/* harmony export */ });
+/* unused harmony exports collectCrossLayerEraseBindings, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(80973);
+/* harmony import */ var _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7296);
+/* harmony import */ var _privateLabelmap__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(99380);
+
+
+
+
+function getProtectedSegmentIndicesForLayer(segmentation, labelmapId, segmentIndex, overwriteSegmentIndices = []) {
+    return (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentsOnLabelmap */ .I3)(segmentation, labelmapId).filter((candidateSegmentIndex) => candidateSegmentIndex !== segmentIndex &&
+        !overwriteSegmentIndices.includes(candidateSegmentIndex));
+}
+function hasProtectedSegmentOverwrite(segmentation, labelmapId, protectedSegmentIndices, voxelManager, options = {}) {
+    if (!voxelManager || !protectedSegmentIndices.length) {
+        return false;
+    }
+    const protectedSet = new Set(protectedSegmentIndices);
+    let hasConflict = false;
+    voxelManager.forEach(({ value }) => {
+        if (!value || hasConflict) {
+            return;
+        }
+        const candidateSegmentIndex = (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentIndexForLabelValue */ .Mx)(segmentation, labelmapId, Number(value));
+        if (candidateSegmentIndex && protectedSet.has(candidateSegmentIndex)) {
+            hasConflict = true;
+        }
+    }, {
+        imageData: options.segmentationImageData,
+        isInObject: options.isInObject,
+        boundsIJK: options.isInObjectBoundsIJK,
+    });
+    return hasConflict;
+}
+function collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices = []) {
+    if (!labelmapId || !overwriteSegmentIndices.length) {
+        return [];
+    }
+    return overwriteSegmentIndices
+        .map((overwriteSegmentIndex) => (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentBinding */ .hM)(segmentation, overwriteSegmentIndex))
+        .filter((binding) => !!binding && binding.labelmapId !== labelmapId);
+}
+function beginLabelmapEditTransaction(segmentation, options) {
+    const { segmentIndex } = options;
+    const overwriteSegmentIndices = options.overwriteSegmentIndices ?? [];
+    if (!segmentIndex) {
+        return {
+            segmentIndex,
+            labelValue: 0,
+            overwriteSegmentIndices,
+            protectedSegmentIndices: [],
+            crossLayerEraseBindings: [],
+            movedSegment: false,
+        };
+    }
+    const binding = (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentBinding */ .hM)(segmentation, segmentIndex);
+    const sourceLayer = binding
+        ? (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmap */ .Hs)(segmentation, binding.labelmapId)
+        : undefined;
+    if (!binding || !sourceLayer) {
+        return {
+            segmentIndex,
+            labelValue: segmentIndex,
+            overwriteSegmentIndices,
+            protectedSegmentIndices: [],
+            crossLayerEraseBindings: [],
+            movedSegment: false,
+        };
+    }
+    let activeLayer = sourceLayer;
+    let labelmapId = binding.labelmapId;
+    let labelValue = binding.labelValue;
+    let movedSegment = false;
+    const protectedSegmentIndices = getProtectedSegmentIndicesForLayer(segmentation, labelmapId, segmentIndex, overwriteSegmentIndices);
+    const shouldMoveSegment = hasProtectedSegmentOverwrite(segmentation, labelmapId, protectedSegmentIndices, options.segmentationVoxelManager, {
+        segmentationImageData: options.segmentationImageData,
+        isInObject: options.isInObject,
+        isInObjectBoundsIJK: options.isInObjectBoundsIJK,
+    });
+    if (shouldMoveSegment) {
+        const moveSegmentToPrivateLabelmap = options.moveSegmentToPrivateLabelmap ??
+            _privateLabelmap__WEBPACK_IMPORTED_MODULE_3__/* .moveSegmentToPrivateLabelmap */ .J;
+        const privateLayer = moveSegmentToPrivateLabelmap(segmentation, segmentIndex);
+        const privateBinding = (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentBinding */ .hM)(segmentation, segmentIndex);
+        if (privateLayer && privateBinding) {
+            activeLayer = privateLayer;
+            labelmapId = privateBinding.labelmapId;
+            labelValue = privateBinding.labelValue;
+            movedSegment = privateLayer.labelmapId !== sourceLayer.labelmapId;
+        }
+        else if (privateLayer) {
+            activeLayer = privateLayer;
+            labelmapId = privateLayer.labelmapId;
+            labelValue = 1;
+            movedSegment = privateLayer.labelmapId !== sourceLayer.labelmapId;
+        }
+    }
+    return {
+        segmentIndex,
+        labelmapId,
+        labelValue,
+        sourceLayer,
+        activeLayer,
+        overwriteSegmentIndices,
+        protectedSegmentIndices,
+        crossLayerEraseBindings: collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices),
+        movedSegment,
+    };
+}
+function getViewportImageIds(viewport) {
+    const stackViewport = viewport;
+    return typeof stackViewport?.getImageIds === 'function'
+        ? stackViewport.getImageIds()
+        : [];
+}
+function getCurrentViewportImageId(viewport) {
+    const stackViewport = viewport;
+    return typeof stackViewport?.getCurrentImageId === 'function'
+        ? stackViewport.getCurrentImageId()
+        : undefined;
+}
+function getLayerImageIndex(layer, options) {
+    const currentImageId = options.imageId ?? getCurrentViewportImageId(options.viewport);
+    if (!currentImageId) {
+        return -1;
+    }
+    const sourceImageIndex = options.sourceLayer?.imageIds?.indexOf(currentImageId) ?? -1;
+    if (sourceImageIndex >= 0) {
+        return sourceImageIndex;
+    }
+    const layerImageIndex = layer.imageIds?.indexOf(currentImageId) ?? -1;
+    if (layerImageIndex >= 0) {
+        return layerImageIndex;
+    }
+    return getViewportImageIds(options.viewport).indexOf(currentImageId);
+}
+function getLabelmapLayerImageId(layer, options = {}) {
+    const targetIndex = getLayerImageIndex(layer, options);
+    return targetIndex >= 0 ? layer.imageIds?.[targetIndex] : layer.imageIds?.[0];
+}
+function resolveLabelmapLayerEditTarget(layer, options = {}) {
+    const imageId = getLabelmapLayerImageId(layer, options);
+    if (options.preferVolume ||
+        layer.volumeId ||
+        options.viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.BaseVolumeViewport) {
+        const volume = (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getOrCreateLabelmapVolume */ .kL)(layer);
+        return {
+            imageId,
+            imageData: volume?.imageData,
+            voxelManager: volume?.voxelManager,
+            volume,
+        };
+    }
+    const image = imageId ? _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(imageId) : undefined;
+    return {
+        imageId,
+        voxelManager: image?.voxelManager,
+        image,
+    };
+}
+function eraseVolumeLayer(layer, binding, options, modifiedSlices) {
+    const volume = (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getOrCreateLabelmapVolume */ .kL)(layer);
+    if (!volume) {
+        return;
+    }
+    volume.voxelManager.forEach(({ value, index, pointIJK }) => {
+        if (value !== binding.labelValue) {
+            return;
+        }
+        const worldPoint = volume.imageData.indexToWorld(pointIJK);
+        if (!options.isInObject(worldPoint)) {
+            return;
+        }
+        volume.voxelManager.setAtIndex(index, 0);
+    }, {
+        imageData: volume.imageData,
+        boundsIJK: options.isInObjectBoundsIJK,
+    });
+    volume.voxelManager
+        ?.getArrayOfModifiedSlices?.()
+        ?.forEach((sliceIndex) => modifiedSlices.add(sliceIndex));
+}
+function eraseStackLayer(layer, binding, options, modifiedSlices) {
+    const stackViewport = options.viewport;
+    const currentImageId = getCurrentViewportImageId(options.viewport) ?? options.imageId;
+    const { image, voxelManager } = resolveLabelmapLayerEditTarget(layer, {
+        viewport: options.viewport,
+        imageId: currentImageId,
+    });
+    if (!image || !voxelManager) {
+        return;
+    }
+    voxelManager.forEach(({ value, index, pointIJK }) => {
+        if (value !== binding.labelValue) {
+            return;
+        }
+        const worldPoint = options.referenceImageData.indexToWorld(pointIJK);
+        if (!options.isInObject(worldPoint)) {
+            return;
+        }
+        voxelManager.setAtIndex(index, 0);
+    }, {
+        imageData: options.referenceImageData,
+        boundsIJK: options.isInObjectBoundsIJK,
+    });
+    const currentSlice = stackViewport.getCurrentImageIdIndex?.();
+    if (typeof currentSlice === 'number') {
+        modifiedSlices.add(currentSlice);
+    }
+}
+function eraseLabelmapEditTransactionOverwrites(segmentation, transaction, options) {
+    if (!transaction?.crossLayerEraseBindings?.length) {
+        return [];
+    }
+    const modifiedSlices = new Set();
+    transaction.crossLayerEraseBindings.forEach((binding) => {
+        const layer = (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmap */ .Hs)(segmentation, binding.labelmapId);
+        if (!layer) {
+            return;
+        }
+        if (options.viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.BaseVolumeViewport || layer.volumeId) {
+            eraseVolumeLayer(layer, binding, options, modifiedSlices);
+            return;
+        }
+        eraseStackLayer(layer, binding, options, modifiedSlices);
+    });
+    return Array.from(modifiedSlices);
+}
+
+
+
+/***/ },
+
+/***/ 52133
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Zd: () => (/* binding */ forEachLabelmapImageReference),
+/* harmony export */   dm: () => (/* binding */ hasMultipleLabelmapImagesPerReferencedImageId),
+/* harmony export */   s_: () => (/* binding */ getLabelmapImageIdsForReferencedImageId)
+/* harmony export */ });
+/* unused harmony export getReferencedImageIdForImageIndex */
+function getReferencedImageIdForImageIndex(layer, imageIndex) {
+    const imageIds = layer.imageIds ?? [];
+    const referencedImageIds = layer.referencedImageIds ?? imageIds;
+    if (!referencedImageIds.length) {
+        return;
+    }
+    if (layer.referencedImageIds?.length &&
+        imageIds.length > referencedImageIds.length &&
+        imageIds.length % referencedImageIds.length === 0) {
+        return referencedImageIds[imageIndex % referencedImageIds.length];
+    }
+    return referencedImageIds[imageIndex];
+}
+function forEachLabelmapImageReference(layer, callback) {
+    layer.imageIds?.forEach((labelmapImageId, imageIndex) => {
+        const referencedImageId = getReferencedImageIdForImageIndex(layer, imageIndex);
+        if (!referencedImageId || !labelmapImageId) {
+            return;
+        }
+        callback(referencedImageId, labelmapImageId, imageIndex);
+    });
+}
+function getLabelmapImageIdsForReferencedImageId(layer, referencedImageId) {
+    const imageIds = [];
+    forEachLabelmapImageReference(layer, (candidateReference, imageId) => {
+        if (candidateReference === referencedImageId) {
+            imageIds.push(imageId);
+        }
+    });
+    return imageIds;
+}
+function hasMultipleLabelmapImagesPerReferencedImageId(layer) {
+    const imageIdsByReference = new Map();
+    forEachLabelmapImageReference(layer, (referencedImageId) => {
+        imageIdsByReference.set(referencedImageId, (imageIdsByReference.get(referencedImageId) ?? 0) + 1);
+    });
+    return Array.from(imageIdsByReference.values()).some((count) => count > 1);
+}
+
+
+
+/***/ },
+
+/***/ 62851
+(__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 _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _helpers_getViewportLabelmapRenderMode__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33214);
+/* harmony import */ var _normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(830);
+/* harmony import */ var _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(80973);
+/* harmony import */ var _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(7296);
+/* harmony import */ var _labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(91573);
+/* harmony import */ var _labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(52133);
+
+
+
+
+
+
+
+class LabelmapImageReferenceResolver {
+    constructor(getSegmentation) {
+        this.stackLabelmapImageIdReferenceMap = new Map();
+        this.labelmapImageIdReferenceMap = new Map();
+        this.keysBySegmentationId = new Map();
+        this.getSegmentation = getSegmentation;
+    }
+    reset() {
+        this.stackLabelmapImageIdReferenceMap.clear();
+        this.labelmapImageIdReferenceMap.clear();
+        this.keysBySegmentationId.clear();
+    }
+    removeSegmentation(segmentationId) {
+        this.stackLabelmapImageIdReferenceMap.delete(segmentationId);
+        const keys = this.keysBySegmentationId.get(segmentationId);
+        if (keys) {
+            for (const key of keys) {
+                this.labelmapImageIdReferenceMap.delete(key);
+            }
+            this.keysBySegmentationId.delete(segmentationId);
+        }
+    }
+    setLabelmapImageIds(segmentationId, key, labelmapImageIds) {
+        this.labelmapImageIdReferenceMap.set(key, labelmapImageIds);
+        let keys = this.keysBySegmentationId.get(segmentationId);
+        if (!keys) {
+            keys = new Set();
+            this.keysBySegmentationId.set(segmentationId, keys);
+        }
+        keys.add(key);
+    }
+    getLabelmapImageIds(representationData) {
+        const labelmapData = representationData.Labelmap;
+        let labelmapImageIds;
+        if (!labelmapData) {
+            return;
+        }
+        if (labelmapData?.labelmaps) {
+            const imageIds = Object.values(labelmapData.labelmaps).flatMap((layer) => {
+                if (layer.imageIds?.length) {
+                    return layer.imageIds;
+                }
+                if (layer.volumeId) {
+                    return _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(layer.volumeId)
+                        ?.imageIds;
+                }
+                return [];
+            });
+            return Array.from(new Set(imageIds.filter(Boolean)));
+        }
+        if (labelmapData.imageIds) {
+            labelmapImageIds = labelmapData
+                .imageIds;
+        }
+        else if (labelmapData.volumeId) {
+            const volumeId = labelmapData
+                .volumeId;
+            const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+            labelmapImageIds = volume.imageIds;
+        }
+        return labelmapImageIds;
+    }
+    getLabelmapImageIdsForImageId(imageId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation?.representationData?.Labelmap) {
+            return;
+        }
+        (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_2__/* .ensureLabelmapState */ .uk)(segmentation);
+        return (0,_labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_5__/* .getReferencedImageIdToCurrentImageIdMap */ ._)(segmentation).get(imageId);
+    }
+    updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        if (!this.stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this.stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const { representationData } = segmentation;
+        if (!representationData.Labelmap) {
+            return;
+        }
+        const labelmapImageIds = this.getLabelmapImageIds(representationData);
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement || !labelmapImageIds?.length) {
+            return;
+        }
+        return this.updateLabelmapSegmentationReferences(segmentationId, enabledElement.viewport, labelmapImageIds);
+    }
+    getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const viewportRenderMode = (0,_helpers_getViewportLabelmapRenderMode__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(viewport);
+        if (viewportRenderMode !== 'image' ||
+            typeof viewport.getCurrentImageId !== 'function') {
+            return;
+        }
+        const referenceImageId = viewport.getCurrentImageId();
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_2__/* .ensureLabelmapState */ .uk)(segmentation);
+        const viewportImageIds = viewport.getImageIds();
+        const currentIndex = viewportImageIds.indexOf(referenceImageId);
+        const labelmapImageIds = [];
+        (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_3__/* .getLabelmaps */ .m)(segmentation).forEach((layer) => {
+            const referencedLabelmapImageIds = (0,_labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_6__/* .getLabelmapImageIdsForReferencedImageId */ .s_)(layer, referenceImageId);
+            if (referencedLabelmapImageIds.length) {
+                labelmapImageIds.push(...referencedLabelmapImageIds);
+                return;
+            }
+            if (currentIndex !== -1 && layer.imageIds?.[currentIndex]) {
+                labelmapImageIds.push(layer.imageIds[currentIndex]);
+                return;
+            }
+            layer.imageIds?.some((candidateImageId) => {
+                const viewableImageId = viewport.isReferenceViewable({ referencedImageId: candidateImageId }, { asOverlay: true });
+                if (viewableImageId) {
+                    labelmapImageIds.push(candidateImageId);
+                }
+                return !!viewableImageId;
+            });
+        });
+        const resolvedImageIds = Array.from(new Set(labelmapImageIds));
+        const key = this.generateMapKey({
+            segmentationId,
+            referenceImageId,
+        });
+        this.setLabelmapImageIds(segmentationId, key, resolvedImageIds);
+        if (!this.stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this.stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const activeSegmentIndex = Object.keys(segmentation.segments).find((segmentIndex) => segmentation.segments[segmentIndex].active);
+        const activeImageId = activeSegmentIndex
+            ? (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_4__/* .getLabelmapForSegment */ .r)(segmentation, Number(activeSegmentIndex))
+                ?.imageIds?.[currentIndex]
+            : undefined;
+        this.stackLabelmapImageIdReferenceMap
+            .get(segmentationId)
+            .set(referenceImageId, activeImageId ?? resolvedImageIds[0]);
+        return resolvedImageIds;
+    }
+    getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const viewportRenderMode = (0,_helpers_getViewportLabelmapRenderMode__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(viewport);
+        if (viewportRenderMode !== 'image' ||
+            typeof viewport.getCurrentImageId !== 'function') {
+            return;
+        }
+        const currentImageId = viewport.getCurrentImageId();
+        const currentImageIds = this.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+        if (!currentImageIds?.length) {
+            return;
+        }
+        const segmentation = this.getSegmentation(segmentationId);
+        const currentIndex = viewport
+            .getImageIds()
+            .indexOf(currentImageId);
+        const activeSegmentIndex = segmentation
+            ? Object.keys(segmentation.segments).find((segmentIndex) => segmentation.segments[segmentIndex].active)
+            : undefined;
+        const activeImageId = segmentation && activeSegmentIndex
+            ? (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_4__/* .getLabelmapForSegment */ .r)(segmentation, Number(activeSegmentIndex))
+                ?.imageIds?.[currentIndex]
+            : undefined;
+        return activeImageId ?? currentImageIds[0];
+    }
+    getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return [];
+        }
+        this.updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId);
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+        const imageIds = enabledElement?.viewport.getImageIds?.() ?? [];
+        const imageIdMap = (0,_labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_5__/* .getReferencedImageIdToCurrentImageIdMap */ ._)(segmentation);
+        return imageIds.flatMap((imageId) => imageIdMap.get(imageId) ?? []);
+    }
+    updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds, updateCallback) {
+        const referenceImageId = viewport.getCurrentImageId();
+        let viewableLabelmapImageIdFound = false;
+        for (const labelmapImageId of labelmapImageIds) {
+            const viewableImageId = viewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
+            if (viewableImageId) {
+                viewableLabelmapImageIdFound = true;
+                this.stackLabelmapImageIdReferenceMap
+                    .get(segmentationId)
+                    .set(referenceImageId, labelmapImageId);
+                this.updateLabelmapImageIdReferenceMap({
+                    segmentationId,
+                    referenceImageId,
+                    labelmapImageId,
+                });
+            }
+        }
+        updateCallback?.(viewport, segmentationId, labelmapImageIds);
+        return viewableLabelmapImageIdFound
+            ? this.stackLabelmapImageIdReferenceMap
+                .get(segmentationId)
+                .get(referenceImageId)
+            : undefined;
+    }
+    updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        if (!this.stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this.stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const { representationData } = segmentation;
+        if (!representationData.Labelmap) {
+            return;
+        }
+        const labelmapImageIds = this.getLabelmapImageIds(representationData);
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement || !labelmapImageIds?.length) {
+            return;
+        }
+        const stackViewport = enabledElement.viewport;
+        this.updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
+            const imageIds = stackViewport.getImageIds();
+            imageIds.forEach((referenceImageId, index) => {
+                for (const labelmapImageId of labelmapImageIds) {
+                    const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId, sliceIndex: index }, { asOverlay: true, withNavigation: true });
+                    if (viewableImageId) {
+                        this.stackLabelmapImageIdReferenceMap
+                            .get(segmentationId)
+                            .set(referenceImageId, labelmapImageId);
+                        this.updateLabelmapImageIdReferenceMap({
+                            segmentationId,
+                            referenceImageId,
+                            labelmapImageId,
+                        });
+                    }
+                }
+            });
+        });
+    }
+    updateLabelmapImageIdReferenceMap({ segmentationId, referenceImageId, labelmapImageId, }) {
+        const key = this.generateMapKey({ segmentationId, referenceImageId });
+        if (!this.labelmapImageIdReferenceMap.has(key)) {
+            this.setLabelmapImageIds(segmentationId, key, [labelmapImageId]);
+            return;
+        }
+        const currentValues = this.labelmapImageIdReferenceMap.get(key) ?? [];
+        const newValues = Array.from(new Set([...currentValues, labelmapImageId]));
+        this.setLabelmapImageIds(segmentationId, key, newValues);
+    }
+    generateMapKey({ segmentationId, referenceImageId }) {
+        return `${segmentationId}-${referenceImageId}`;
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (LabelmapImageReferenceResolver);
+
+
+/***/ },
+
+/***/ 91573
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   _: () => (/* binding */ getReferencedImageIdToCurrentImageIdMap),
+/* harmony export */   x: () => (/* binding */ syncLegacyLabelmapData)
+/* harmony export */ });
+/* harmony import */ var _normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(830);
+/* harmony import */ var _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(80973);
+/* harmony import */ var _labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(52133);
+
+
+
+function syncOptionalLegacyProperty(target, key, value) {
+    if (value == null) {
+        delete target[key];
+        return;
+    }
+    target[key] = value;
+}
+function syncLegacyLabelmapData(segmentation) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__/* .ensureLabelmapState */ .uk)(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    const firstSegmentIndex = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__/* .getSegmentOrder */ .gV)(segmentation)[0] ?? 1;
+    const primaryLabelmapId = labelmapState.primaryLabelmapId ??
+        labelmapState.segmentBindings[firstSegmentIndex]?.labelmapId ??
+        Object.keys(labelmapState.labelmaps)[0];
+    const primaryLayer = labelmapState.labelmaps[primaryLabelmapId];
+    if (!primaryLayer) {
+        return;
+    }
+    syncOptionalLegacyProperty(labelmapState, 'volumeId', primaryLayer.volumeId);
+    syncOptionalLegacyProperty(labelmapState, 'referencedVolumeId', primaryLayer.referencedVolumeId);
+    syncOptionalLegacyProperty(labelmapState, 'imageIds', primaryLayer.imageIds);
+    syncOptionalLegacyProperty(labelmapState, 'referencedImageIds', primaryLayer.referencedImageIds);
+}
+function getReferencedImageIdToCurrentImageIdMap(segmentation) {
+    const map = new Map();
+    (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmaps */ .m)(segmentation).forEach((layer) => {
+        (0,_labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_2__/* .forEachLabelmapImageReference */ .Zd)(layer, (referenceImageId, labelmapImageId) => {
+            const values = map.get(referenceImageId) ?? [];
+            if (!values.includes(labelmapImageId)) {
+                values.push(labelmapImageId);
+            }
+            map.set(referenceImageId, values);
+        });
+    });
+    return map;
+}
+
+
+
+/***/ },
+
+/***/ 830
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   gV: () => (/* binding */ getSegmentOrder),
+/* harmony export */   uk: () => (/* binding */ ensureLabelmapState)
+/* harmony export */ });
+/* unused harmony exports SOURCE_REPRESENTATION_NAME, getPrimaryLabelmapId */
+const SOURCE_REPRESENTATION_NAME = 'binaryLabelmap';
+function getSegmentOrder(segmentation) {
+    if (segmentation.segmentOrder?.length) {
+        return [...segmentation.segmentOrder];
+    }
+    return Object.keys(segmentation.segments)
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+function getPrimaryLabelmapId(segmentationId) {
+    return `${segmentationId}-storage-0`;
+}
+function getPrimaryLabelmapType(labelmapData) {
+    return labelmapData.volumeId ? 'volume' : 'stack';
+}
+function createPrimaryLabelmapLayer(segmentation, labelmapData, labelmapId = getPrimaryLabelmapId(segmentation.segmentationId)) {
+    const layer = {
+        labelmapId,
+        type: getPrimaryLabelmapType(labelmapData),
+        labelToSegmentIndex: {},
+    };
+    if (labelmapData.volumeId != null) {
+        layer.volumeId = labelmapData.volumeId;
+    }
+    if (labelmapData.referencedVolumeId != null) {
+        layer.referencedVolumeId = labelmapData.referencedVolumeId;
+    }
+    if (labelmapData.referencedImageIds != null) {
+        layer.referencedImageIds = labelmapData.referencedImageIds;
+    }
+    if (labelmapData.imageIds != null) {
+        layer.imageIds = labelmapData.imageIds;
+    }
+    return layer;
+}
+function resolvePrimaryLabelmapId(segmentation, labelmapData) {
+    const storedLabelmapId = labelmapData.primaryLabelmapId;
+    if (storedLabelmapId && labelmapData.labelmaps?.[storedLabelmapId]) {
+        return storedLabelmapId;
+    }
+    const fallbackLabelmapId = Object.keys(labelmapData.labelmaps ?? {})[0] ??
+        getPrimaryLabelmapId(segmentation.segmentationId);
+    labelmapData.primaryLabelmapId = fallbackLabelmapId;
+    return fallbackLabelmapId;
+}
+function ensureLabelmapState(segmentation) {
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (!labelmapData) {
+        return;
+    }
+    labelmapData.labelmaps ||= {};
+    const primaryLabelmapId = resolvePrimaryLabelmapId(segmentation, labelmapData);
+    labelmapData.labelmaps[primaryLabelmapId] ||= createPrimaryLabelmapLayer(segmentation, labelmapData, primaryLabelmapId);
+    labelmapData.segmentBindings ||= {};
+    labelmapData.sourceRepresentationName ||= SOURCE_REPRESENTATION_NAME;
+    getSegmentOrder(segmentation).forEach((segmentIndex) => {
+        labelmapData.segmentBindings[segmentIndex] ||= {
+            labelmapId: primaryLabelmapId,
+            labelValue: segmentIndex,
+        };
+    });
+    Object.values(labelmapData.labelmaps).forEach((layer) => {
+        layer.labelToSegmentIndex = {};
+    });
+    Object.entries(labelmapData.segmentBindings).forEach(([segmentIndex, binding]) => {
+        const layer = labelmapData.labelmaps[binding.labelmapId];
+        if (!layer) {
+            return;
+        }
+        layer.labelToSegmentIndex ||= {};
+        layer.labelToSegmentIndex[binding.labelValue] = Number(segmentIndex);
+    });
+    return labelmapData;
+}
+
+
+
+/***/ },
+
+/***/ 99380
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   J: () => (/* binding */ moveSegmentToPrivateLabelmap)
+/* harmony export */ });
+/* unused harmony export createPrivateLabelmap */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(80973);
+/* harmony import */ var _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7296);
+/* harmony import */ var _labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(91573);
+
+
+
+
+function createPrivateVolumeLabelmap(segmentation, sourceLabelmap) {
+    const sourceVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(sourceLabelmap.volumeId);
+    const volumeId = `${segmentation.segmentationId}-storage-${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.uuidv4()}`;
+    const referencedVolumeId = sourceLabelmap.referencedVolumeId ??
+        sourceVolume?.referencedVolumeId ??
+        sourceLabelmap.volumeId;
+    const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.volumeLoader.createAndCacheDerivedLabelmapVolume(referencedVolumeId, {
+        volumeId,
+    });
+    return {
+        labelmapId: volumeId,
+        type: 'volume',
+        volumeId,
+        imageIds: volume.imageIds,
+        referencedVolumeId,
+        referencedImageIds: sourceLabelmap.referencedImageIds ?? sourceVolume?.referencedImageIds,
+        labelToSegmentIndex: {},
+    };
+}
+function createPrivateStackLabelmap(segmentation, sourceLabelmap) {
+    const referencedImageIds = sourceLabelmap.referencedImageIds ?? sourceLabelmap.imageIds ?? [];
+    const sourceImageIds = sourceLabelmap.imageIds ?? [];
+    const sourceImage = sourceImageIds[0]
+        ? _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(sourceImageIds[0])
+        : null;
+    const targetType = sourceImage?.voxelManager?.getConstructor?.().name ?? 'Uint8Array';
+    const images = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.imageLoader.createAndCacheDerivedImages(referencedImageIds, {
+        getDerivedImageId: (referencedImageId) => `${segmentation.segmentationId}-storage-${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.uuidv4()}-${referencedImageId.slice(-12)}`,
+        targetBuffer: {
+            type: targetType,
+        },
+    });
+    return {
+        labelmapId: `${segmentation.segmentationId}-storage-${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.uuidv4()}`,
+        type: 'stack',
+        imageIds: images.map((image) => image.imageId),
+        referencedVolumeId: sourceLabelmap.referencedVolumeId,
+        referencedImageIds,
+        labelToSegmentIndex: {},
+    };
+}
+function createPrivateLabelmap(segmentation, sourceLabelmap) {
+    if (sourceLabelmap.imageIds?.length ||
+        sourceLabelmap.referencedImageIds?.length) {
+        return createPrivateStackLabelmap(segmentation, sourceLabelmap);
+    }
+    if (sourceLabelmap.volumeId) {
+        return createPrivateVolumeLabelmap(segmentation, sourceLabelmap);
+    }
+    return createPrivateStackLabelmap(segmentation, sourceLabelmap);
+}
+function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
+    const binding = (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentBinding */ .hM)(segmentation, segmentIndex);
+    if (!binding) {
+        return;
+    }
+    const sourceLabelmap = (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmap */ .Hs)(segmentation, binding.labelmapId);
+    if (!sourceLabelmap) {
+        return;
+    }
+    if ((0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .getSegmentsOnLabelmap */ .I3)(segmentation, sourceLabelmap.labelmapId).length <= 1) {
+        return sourceLabelmap;
+    }
+    const privateLabelmap = createPrivateLabelmap(segmentation, sourceLabelmap);
+    (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .registerLabelmap */ .AD)(segmentation, privateLabelmap);
+    if (sourceLabelmap.volumeId && privateLabelmap.volumeId) {
+        const sourceVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(sourceLabelmap.volumeId);
+        const targetVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(privateLabelmap.volumeId);
+        sourceVolume.voxelManager.forEach(({ value, index }) => {
+            if (value !== binding.labelValue) {
+                return;
+            }
+            targetVolume.voxelManager.setAtIndex(index, 1);
+            sourceVolume.voxelManager.setAtIndex(index, 0);
+        });
+    }
+    else {
+        const sourceImageIds = sourceLabelmap.imageIds ?? [];
+        const targetImageIds = privateLabelmap.imageIds ?? [];
+        sourceImageIds.forEach((imageId, imageIndex) => {
+            const sourceImage = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(imageId);
+            const targetImage = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(targetImageIds[imageIndex]);
+            if (!sourceImage || !targetImage) {
+                return;
+            }
+            sourceImage.voxelManager.forEach(({ value, index }) => {
+                if (value !== binding.labelValue) {
+                    return;
+                }
+                targetImage.voxelManager.setAtIndex(index, 1);
+                sourceImage.voxelManager.setAtIndex(index, 0);
+            });
+        });
+    }
+    (0,_labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_2__/* .setSegmentBinding */ .Zs)(segmentation, segmentIndex, {
+        labelmapId: privateLabelmap.labelmapId,
+        labelValue: 1,
+    });
+    (0,_labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_3__/* .syncLegacyLabelmapData */ .x)(segmentation);
+    return privateLabelmap;
+}
+
+
+
 /***/ },
 
 /***/ 57999
@@ -2090,7 +2950,6 @@ var SegmentationStateManager = __webpack_require__(59475);
 
 
 class ContourSegmentationBaseTool extends ContourBaseTool {
-    static { this.PreviewSegmentIndex = 255; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
         if (this.configuration.interpolation?.enabled) {
@@ -2234,482 +3093,43 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             textbox: {
                 color,
             },
-            visibility,
-            locked: annotationLocked,
-        };
-    }
-}
-
-
-
-/***/ },
-
-/***/ 67772
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-const defaultContourConfig = {
-    renderOutline: true,
-    outlineWidthAutoGenerated: 3,
-    outlineWidth: 1,
-    outlineWidthInactive: 1,
-    outlineOpacity: 1,
-    outlineOpacityInactive: 0.85,
-    outlineDash: undefined,
-    outlineDashInactive: undefined,
-    outlineDashAutoGenerated: '5,3',
-    activeSegmentOutlineWidthDelta: 0,
-    renderFill: true,
-    fillAlpha: 0.5,
-    fillAlphaInactive: 0.3,
-    fillAlphaAutoGenerated: 0.3,
-};
-function getDefaultContourStyle() {
-    return defaultContourConfig;
-}
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getDefaultContourStyle);
-
-
-/***/ },
-
-/***/ 22384
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  d: () => (/* binding */ handleContourSegmentation)
-});
-
-// UNUSED EXPORTS: addContourSetsToElement
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationState.js
-var annotationState = __webpack_require__(82056);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
-var esm = __webpack_require__(15327);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/annotationHydration.js
-var annotationHydration = __webpack_require__(64485);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contourSegmentation/index.js + 1 modules
-var contourSegmentation = __webpack_require__(56534);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
-var CellArray = __webpack_require__(32461);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
-var Points = __webpack_require__(74973);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
-var PolyData = __webpack_require__(27480);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/utils.js
-/* unused harmony import specifier */ var Enums;
-/* unused harmony import specifier */ var vtkCellArray;
-/* unused harmony import specifier */ var vtkPoints;
-/* unused harmony import specifier */ var vtkPolyData;
-
-
-
-
-function validateGeometry(geometry) {
-    if (!geometry) {
-        throw new Error(`No contours found for geometryId ${geometry.id}`);
-    }
-    const geometryId = geometry.id;
-    if (geometry.type !== esm.Enums.GeometryType.CONTOUR) {
-        throw new Error(`Geometry type ${geometry.type} not supported for rendering.`);
-    }
-    if (!geometry.data) {
-        console.warn(`No contours found for geometryId ${geometryId}. Skipping render.`);
-        return;
-    }
-}
-function getPolyData(contourSet) {
-    const pointArray = [];
-    const points = vtkPoints.newInstance();
-    const lines = vtkCellArray.newInstance();
-    let pointIndex = 0;
-    contourSet.contours.forEach((contour) => {
-        const pointList = contour.points;
-        const flatPoints = contour.flatPointsArray;
-        const type = contour.type;
-        const pointIndexes = pointList.map((_, pointListIndex) => pointListIndex + pointIndex);
-        if (type === Enums.ContourType.CLOSED_PLANAR) {
-            pointIndexes.push(pointIndexes[0]);
-        }
-        const linePoints = Float32Array.from(flatPoints);
-        pointArray.push(...linePoints);
-        lines.insertNextCell([...pointIndexes]);
-        pointIndex = pointIndex + pointList.length;
-    });
-    points.setData(pointArray, 3);
-    const polygon = vtkPolyData.newInstance();
-    polygon.setPoints(points);
-    polygon.setLines(lines);
-    return polygon;
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
-var enums = __webpack_require__(29857);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/SegmentationStyle.js
-var SegmentationStyle = __webpack_require__(92686);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js
-
-
-
-
-
-
-
-function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
-    if (annotationUIDsMap.size) {
-        viewport.render();
-    }
-    else {
-        addContourSetsToElement(viewport, geometryIds, contourRepresentation);
-    }
-}
-function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
-    const { segmentationId } = contourRepresentation;
-    const segmentSpecificMap = new Map();
-    geometryIds.forEach((geometryId) => {
-        const geometry = esm.cache.getGeometry(geometryId);
-        if (!geometry) {
-            console.warn(`No geometry found for geometryId ${geometryId}. Skipping render.`);
-            return;
-        }
-        const segmentIndex = geometry.data.segmentIndex;
-        validateGeometry(geometry);
-        const segmentSpecificConfig = SegmentationStyle/* segmentationStyle */.Y.getStyle({
-            viewportId: viewport.id,
-            segmentationId,
-            type: enums.SegmentationRepresentations.Contour,
-            segmentIndex,
-        });
-        const contourSet = geometry.data;
-        const viewPlaneNormal = viewport.getCamera().viewPlaneNormal;
-        contourSet.contours.forEach((contour) => {
-            const { points, color, id } = contour;
-            const referencedImageId = (0,annotationHydration/* getClosestImageIdForStackViewport */.x)(viewport, points[0], viewPlaneNormal);
-            const contourSegmentationAnnotation = {
-                annotationUID: esm.utilities.uuidv4(),
-                data: {
-                    contour: {
-                        closed: true,
-                        polyline: points,
-                    },
-                    segmentation: {
-                        segmentationId,
-                        segmentIndex,
-                        color,
-                        id,
-                    },
-                    handles: {},
-                },
-                handles: {},
-                highlighted: false,
-                autoGenerated: false,
-                invalidated: false,
-                isLocked: true,
-                isVisible: true,
-                metadata: {
-                    referencedImageId,
-                    toolName: 'PlanarFreehandContourSegmentationTool',
-                    FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
-                    viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
-                },
-            };
-            const annotationGroupSelector = viewport.element;
-            (0,annotationState.addAnnotation)(contourSegmentationAnnotation, annotationGroupSelector);
-            (0,contourSegmentation.addContourSegmentationAnnotation)(contourSegmentationAnnotation);
-        });
-        if (segmentSpecificConfig) {
-            segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
-        }
-    });
-    viewport.render();
-}
-
-
-
-/***/ },
-
-/***/ 87420
-(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
-
-/* unused harmony import specifier */ var getSegmentation;
-/* unused harmony import specifier */ var removeAnnotation;
-/* harmony import */ var _stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33283);
-/* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6802);
-
-
-function removeContourFromElement(viewportId, segmentationId, removeFromCache = false) {
-    const segmentation = getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.Contour;
-    annotationUIDsMap.forEach((annotationSet) => {
-        annotationSet.forEach((annotationUID) => {
-            removeAnnotation(annotationUID);
-        });
-    });
-}
-/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ((/* unused pure expression or super */ null && (removeContourFromElement)));
-
-
-/***/ },
-
-/***/ 63597
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  A: () => (/* binding */ Labelmap_addLabelmapToElement)
-});
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
-var esm = __webpack_require__(15327);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getCurrentLabelmapImageIdForViewport.js
-var getCurrentLabelmapImageIdForViewport = __webpack_require__(97577);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
-var getSegmentation = __webpack_require__(33283);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js
-var triggerSegmentationEvents = __webpack_require__(49906);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
-var enums = __webpack_require__(29857);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.js
-
-
-
-const internalCache = new Map();
-const load = ({ cfun, ofun, actor }) => {
-    actor.getProperty().setRGBTransferFunction(1, cfun);
-    actor.getProperty().setScalarOpacity(1, ofun);
-};
-async function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }) {
-    const defaultActor = viewport.getDefaultActor();
-    const { actor } = defaultActor;
-    const { uid } = defaultActor;
-    const referenceVolumeId = viewport.getVolumeId();
-    if (internalCache.get(uid)?.added) {
-        return {
-            uid,
-            actor,
-        };
-    }
-    const volumeInputArray = volumeInputs;
-    const firstImageVolume = esm.cache.getVolume(volumeInputArray[0].volumeId);
-    if (!firstImageVolume) {
-        throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
-    }
-    const { volumeId } = volumeInputArray[0];
-    const segImageVolume = await esm.volumeLoader.loadVolume(volumeId);
-    if (!segImageVolume) {
-        throw new Error(`segImageVolume with id: ${segImageVolume.volumeId} does not exist`);
-    }
-    const segVoxelManager = segImageVolume.voxelManager;
-    const segData = segVoxelManager.getCompleteScalarDataArray();
-    const { imageData: segImageData } = segImageVolume;
-    const baseVolume = esm.cache.getVolume(referenceVolumeId);
-    const volumeTexture = baseVolume.vtkOpenGLTexture;
-    const hasPendingFrames = volumeTexture.hasUpdatedFrames();
-    if (hasPendingFrames) {
-        return;
-    }
-    const baseVoxelManager = baseVolume.voxelManager;
-    const baseData = baseVoxelManager.getCompleteScalarDataArray();
-    const newComp = 2;
-    const cubeData = new Float32Array(newComp * baseVolume.voxelManager.getScalarDataLength());
-    const dims = segImageData.getDimensions();
-    for (let z = 0; z < dims[2]; ++z) {
-        for (let y = 0; y < dims[1]; ++y) {
-            for (let x = 0; x < dims[0]; ++x) {
-                const iTuple = x + dims[0] * (y + dims[1] * z);
-                cubeData[iTuple * newComp + 0] = baseData[iTuple];
-                cubeData[iTuple * newComp + 1] = segData[iTuple];
-            }
-        }
-    }
-    viewport.removeActors([uid]);
-    const oldMapper = actor.getMapper();
-    const mapper = (0,esm.convertMapperToNotSharedMapper)(oldMapper);
-    actor.setMapper(mapper);
-    mapper.setBlendMode(esm.Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND);
-    const arrayAgain = mapper.getInputData().getPointData().getArray(0);
-    arrayAgain.setData(cubeData);
-    arrayAgain.setNumberOfComponents(2);
-    const oldColorMixPreset = actor.getProperty().getColorMixPreset();
-    actor.getProperty().setColorMixPreset(1);
-    const oldForceNearestInterpolation = actor
-        .getProperty()
-        .getForceNearestInterpolation(1);
-    actor.getProperty().setForceNearestInterpolation(1, true);
-    const oldIndependentComponents = actor
-        .getProperty()
-        .getIndependentComponents();
-    actor.getProperty().setIndependentComponents(true);
-    viewport.addActor({
-        ...defaultActor,
-        representationUID: `${segmentationId}-${enums.SegmentationRepresentations.Labelmap}`,
-    });
-    internalCache.set(uid, {
-        added: true,
-        segmentationRepresentationUID: `${segmentationId}`,
-        originalBlendMode: viewport.getBlendMode(),
-    });
-    const oldPreLoad = actor.get('preLoad');
-    actor.set({
-        preLoad: load,
-    });
-    function onSegmentationDataModified(evt) {
-        const { segmentationId } = evt.detail;
-        const { representationData } = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
-        const { volumeId: segVolumeId } = representationData.Labelmap;
-        if (segVolumeId !== segImageVolume.volumeId) {
-            return;
-        }
-        const segmentationVolume = esm.cache.getVolume(segVolumeId);
-        const segVoxelManager = segmentationVolume.voxelManager;
-        const imageData = mapper.getInputData();
-        const array = imageData.getPointData().getArray(0);
-        const baseData = array.getData();
-        const newComp = 2;
-        const dims = segImageData.getDimensions();
-        const slices = Array.from({ length: dims[2] }, (_, i) => i);
-        for (const z of slices) {
-            for (let y = 0; y < dims[1]; ++y) {
-                for (let x = 0; x < dims[0]; ++x) {
-                    const iTuple = x + dims[0] * (y + dims[1] * z);
-                    baseData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
-                }
-            }
-        }
-        array.setData(baseData);
-        imageData.modified();
-        viewport.render();
-    }
-    esm.eventTarget.addEventListenerDebounced(enums.Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified, 200);
-    function onSegmentationRepresentationRemoved(evt) {
-        if (evt.detail.viewportId !== viewport.id) {
-            return;
-        }
-        esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
-        esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_REPRESENTATION_REMOVED, onSegmentationRepresentationRemoved);
-        const actorEntry = viewport.getActor(uid);
-        if (actorEntry) {
-            viewport.removeActors([uid]);
-        }
-        internalCache.delete(uid);
-        if (viewport.isDisabled) {
-            return;
-        }
-        actor.setMapper(oldMapper);
-        actor.getProperty().setColorMixPreset(oldColorMixPreset);
-        actor
-            .getProperty()
-            .setForceNearestInterpolation(1, oldForceNearestInterpolation);
-        actor.getProperty().setIndependentComponents(oldIndependentComponents);
-        viewport.addActor({
-            ...defaultActor,
-        });
-        actor.set(oldPreLoad);
-        viewport.render();
+            visibility,
+            locked: annotationLocked,
+        };
     }
-    esm.eventTarget.addEventListener(enums.Events.SEGMENTATION_REPRESENTATION_REMOVED, onSegmentationRepresentationRemoved);
-    return {
-        uid,
-        actor,
-    };
 }
-
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js
-
+ContourSegmentationBaseTool.PreviewSegmentIndex = 255;
 
 
 
+/***/ },
 
+/***/ 67772
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-const { uuidv4 } = esm.utilities;
-async function addLabelmapToElement(element, labelMapData, segmentationId, config) {
-    const enabledElement = (0,esm.getEnabledElement)(element);
-    const { renderingEngine, viewport } = enabledElement;
-    const { id: viewportId } = viewport;
-    const visibility = true;
-    const immediateRender = false;
-    const suppressEvents = true;
-    if (viewport instanceof esm.BaseVolumeViewport) {
-        const volumeLabelMapData = labelMapData;
-        const volumeId = _ensureVolumeHasVolumeId(volumeLabelMapData, segmentationId);
-        if (!esm.cache.getVolume(volumeId)) {
-            await _handleMissingVolume(labelMapData);
-        }
-        let blendMode = config?.blendMode ?? esm.Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-        let useIndependentComponents = blendMode === esm.Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
-        if (useIndependentComponents) {
-            const referenceVolumeId = viewport.getVolumeId();
-            const baseVolume = esm.cache.getVolume(referenceVolumeId);
-            const segVolume = esm.cache.getVolume(volumeId);
-            const segDims = segVolume.dimensions;
-            const refDims = baseVolume.dimensions;
-            if (segDims[0] !== refDims[0] ||
-                segDims[1] !== refDims[1] ||
-                segDims[2] !== refDims[2]) {
-                useIndependentComponents = false;
-                blendMode = esm.Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-                console.debug('Dimensions mismatch - falling back to regular volume addition');
-            }
-        }
-        const volumeInputs = [
-            {
-                volumeId,
-                visibility,
-                representationUID: `${segmentationId}-${enums.SegmentationRepresentations.Labelmap}`,
-                useIndependentComponents,
-                blendMode,
-            },
-        ];
-        if (!volumeInputs[0].useIndependentComponents) {
-            await (0,esm.addVolumesToViewports)(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
-        }
-        else {
-            const result = await addVolumesAsIndependentComponents({
-                viewport,
-                volumeInputs,
-                segmentationId,
-            });
-            return result;
-        }
-    }
-    else {
-        const segmentationImageIds = (0,getCurrentLabelmapImageIdForViewport/* getCurrentLabelmapImageIdsForViewport */.aF)(viewport.id, segmentationId);
-        const stackInputs = segmentationImageIds.map((imageId) => ({
-            imageId,
-            representationUID: `${segmentationId}-${enums.SegmentationRepresentations.Labelmap}-${imageId}`,
-        }));
-        (0,esm.addImageSlicesToViewports)(renderingEngine, stackInputs, [viewportId]);
-    }
-    (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
-}
-function _ensureVolumeHasVolumeId(labelMapData, segmentationId) {
-    let { volumeId } = labelMapData;
-    if (!volumeId) {
-        volumeId = uuidv4();
-        const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
-        segmentation.representationData.Labelmap = {
-            ...segmentation.representationData.Labelmap,
-            volumeId,
-        };
-        labelMapData.volumeId = volumeId;
-        (0,triggerSegmentationEvents.triggerSegmentationModified)(segmentationId);
-    }
-    return volumeId;
-}
-async function _handleMissingVolume(labelMapData) {
-    const stackData = labelMapData;
-    const hasImageIds = stackData.imageIds.length > 0;
-    if (!hasImageIds) {
-        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
-    }
-    const volume = await esm.volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId || uuidv4(), stackData.imageIds);
-    return volume;
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+const defaultContourConfig = {
+    renderOutline: true,
+    outlineWidthAutoGenerated: 3,
+    outlineWidth: 1,
+    outlineWidthInactive: 1,
+    outlineOpacity: 1,
+    outlineOpacityInactive: 0.85,
+    outlineDash: undefined,
+    outlineDashInactive: undefined,
+    outlineDashAutoGenerated: '5,3',
+    activeSegmentOutlineWidthDelta: 0,
+    renderFill: true,
+    fillAlpha: 0.5,
+    fillAlphaInactive: 0.3,
+    fillAlphaAutoGenerated: 0.3,
+};
+function getDefaultContourStyle() {
+    return defaultContourConfig;
 }
-/* harmony default export */ const Labelmap_addLabelmapToElement = (addLabelmapToElement);
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getDefaultContourStyle);
 
 
 /***/ },
@@ -2741,181 +3161,177 @@ function getDefaultLabelmapStyle() {
 
 /***/ },
 
-/***/ 88234
+/***/ 18543
 (__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 _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
-/* harmony import */ var _stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(59452);
 
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (/* binding */ strategies_BrushStrategy)
+});
 
-function removeLabelmapFromElement(element, segmentationId) {
-    const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
-    const { viewport } = enabledElement;
-    const actorEntries = (0,_stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmapActorEntries */ .ED)(viewport.id, segmentationId);
-    if (actorEntries?.length) {
-        viewport.removeActors(actorEntries.map((entry) => entry.uid));
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js
+var triggerSegmentationEvents = __webpack_require__(49906);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/index.js + 11 modules
+var compositions = __webpack_require__(64664);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js
+var getStrategyData = __webpack_require__(40905);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
+var enums = __webpack_require__(29857);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var getSegmentation = __webpack_require__(33283);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/labelmapSegmentationState.js
+var labelmapSegmentationState = __webpack_require__(90660);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/crossLayerErase.js
+/* unused harmony import specifier */ var crossLayerErase_getSegmentation;
+/* unused harmony import specifier */ var collectCrossLayerEraseBindings;
+
+
+function collectCrossLayerEraseBindingsForOperation(operationData) {
+    const { segmentationId, labelmapId, overwriteSegmentIndices } = operationData;
+    const segmentation = crossLayerErase_getSegmentation(segmentationId);
+    operationData.crossLayerEraseBindings = segmentation
+        ? collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices)
+        : [];
+}
+function eraseCrossLayerOverwrites(operationData) {
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(operationData.segmentationId);
+    if (!segmentation) {
+        return [];
     }
+    return (0,labelmapSegmentationState/* eraseLabelmapEditTransactionOverwrites */.Ry)(segmentation, operationData.labelmapEditTransaction, {
+        viewport: operationData.viewport,
+        referenceImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+        imageId: operationData.imageId,
+    });
 }
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (removeLabelmapFromElement);
-
-
-/***/ },
-
-/***/ 18796
-(__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 _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
-/* harmony import */ var _kitware_vtk_js_Rendering_Core_Mapper__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(81418);
-/* harmony import */ var _kitware_vtk_js_Rendering_Core_Actor__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(44404);
-/* harmony import */ var _kitware_vtk_js_Common_DataModel_PolyData__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(27480);
-/* harmony import */ var _kitware_vtk_js_Common_Core_CellArray__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(32461);
-/* harmony import */ var _stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(59452);
 
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/config.js
+var config = __webpack_require__(36625);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentationRepresentation.js
+var getSegmentationRepresentation = __webpack_require__(93210);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/overwritePolicy.js
 
 
 
 
-function addOrUpdateSurfaceToElement(viewport, surface, segmentationId) {
-    const surfaceActorEntry = (0,_stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_5__/* .getSurfaceActorEntry */ .Th)(viewport.id, segmentationId, surface.segmentIndex);
-    const surfaceActor = surfaceActorEntry?.actor;
-    const isVisible = surface.visible;
-    if (surfaceActor) {
-        surfaceActor.setVisibility(isVisible);
-        if (!isVisible) {
-            return;
-        }
-        const surfaceMapper = surfaceActor.getMapper();
-        const currentPolyData = surfaceMapper.getInputData();
-        const newPoints = surface.points;
-        const newPolys = surface.polys;
-        const currentPoints = currentPolyData.getPoints().getData();
-        const currentPolys = currentPolyData.getPolys().getData();
-        if (newPoints.length === currentPoints.length &&
-            newPolys.length === currentPolys.length) {
-            return;
-        }
-        const polyData = _kitware_vtk_js_Common_DataModel_PolyData__WEBPACK_IMPORTED_MODULE_3__/* ["default"].newInstance */ .Ay.newInstance();
-        polyData.getPoints().setData(newPoints, 3);
-        const triangles = _kitware_vtk_js_Common_Core_CellArray__WEBPACK_IMPORTED_MODULE_4__/* ["default"].newInstance */ .Ay.newInstance({
-            values: Float32Array.from(newPolys),
-        });
-        polyData.setPolys(triangles);
-        surfaceMapper.setInputData(polyData);
-        surfaceMapper.modified();
-        viewport.getRenderer().resetCameraClippingRange();
-        return;
+function resolveOverwriteSegmentIndices(operationData) {
+    const { segmentationId, segmentIndex, segmentsLocked, viewport } = operationData;
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+    if (!segmentation || segmentIndex === 0) {
+        return [];
     }
-    const points = surface.points;
-    const polys = surface.polys;
-    const color = surface.color;
-    const surfacePolyData = _kitware_vtk_js_Common_DataModel_PolyData__WEBPACK_IMPORTED_MODULE_3__/* ["default"].newInstance */ .Ay.newInstance();
-    surfacePolyData.getPoints().setData(points, 3);
-    const triangles = _kitware_vtk_js_Common_Core_CellArray__WEBPACK_IMPORTED_MODULE_4__/* ["default"].newInstance */ .Ay.newInstance({
-        values: Float32Array.from(polys),
-    });
-    surfacePolyData.setPolys(triangles);
-    const mapper = _kitware_vtk_js_Rendering_Core_Mapper__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance({});
-    let clippingFilter;
-    mapper.setInputData(surfacePolyData);
-    const actor = _kitware_vtk_js_Rendering_Core_Actor__WEBPACK_IMPORTED_MODULE_2__/* ["default"].newInstance */ .Ay.newInstance();
-    actor.setMapper(mapper);
-    actor.getProperty().setColor(color[0] / 255, color[1] / 255, color[2] / 255);
-    actor.getProperty().setLineWidth(2);
-    const representationUID = (0,_stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_5__/* .getSurfaceRepresentationUID */ .DU)(segmentationId, surface.segmentIndex);
-    viewport.addActor({
-        uid: _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.uuidv4(),
-        actor: actor,
-        clippingFilter,
-        representationUID,
+    const overwriteMode = (0,config/* getConfig */.zj)().segmentation?.overwriteMode ?? 'all';
+    if (overwriteMode === 'none') {
+        return [];
+    }
+    const allSegmentIndices = Object.keys(segmentation.segments)
+        .map(Number)
+        .filter((candidateSegmentIndex) => candidateSegmentIndex !== segmentIndex &&
+        !segmentsLocked.includes(candidateSegmentIndex));
+    if (overwriteMode === 'all') {
+        return allSegmentIndices;
+    }
+    const representation = (0,getSegmentationRepresentation/* getSegmentationRepresentation */.Ut)(viewport.id, {
+        segmentationId,
+        type: enums.SegmentationRepresentations.Labelmap,
     });
-    viewport.resetCamera();
-    viewport.getRenderer().resetCameraClippingRange();
-    viewport.render();
+    if (!representation?.visible) {
+        return [];
+    }
+    return allSegmentIndices.filter((candidateSegmentIndex) => representation.segments[candidateSegmentIndex]?.visible !== false);
 }
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (addOrUpdateSurfaceToElement);
 
 
-/***/ },
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/labelmapOverlap.js
 
-/***/ 20552
-(__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 _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 
-function removeSurfaceFromElement(element, segmentationId) {
-    const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
-    const { viewport } = enabledElement;
-    const actorEntries = viewport.getActors();
-    const filteredSurfaceActors = actorEntries.filter((actor) => actor.representationUID &&
-        typeof actor.representationUID === 'string' &&
-        actor.representationUID.startsWith(segmentationId));
-    viewport.removeActors(filteredSurfaceActors.map((actor) => actor.uid));
-}
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (removeSurfaceFromElement);
 
+function prepareOverlapOperationData(operationData) {
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(operationData.segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    operationData.overwriteSegmentIndices =
+        resolveOverwriteSegmentIndices(operationData);
+    const transaction = (0,labelmapSegmentationState/* beginLabelmapEditTransaction */.Qk)(segmentation, {
+        segmentIndex: operationData.segmentIndex,
+        overwriteSegmentIndices: operationData.overwriteSegmentIndices,
+        segmentationVoxelManager: operationData.segmentationVoxelManager,
+        segmentationImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+    });
+    operationData.labelmapEditTransaction = transaction;
+    operationData.labelValue = transaction.labelValue;
+    operationData.labelmapId = transaction.labelmapId;
+    operationData.crossLayerEraseBindings = transaction.crossLayerEraseBindings;
+    if (transaction.movedSegment && transaction.activeLayer) {
+        const target = (0,labelmapSegmentationState/* resolveLabelmapLayerEditTarget */.VQ)(transaction.activeLayer, {
+            viewport: operationData.viewport,
+            imageId: operationData.imageId,
+            sourceLayer: transaction.sourceLayer,
+        });
+        if (target.imageId) {
+            operationData.imageId = target.imageId;
+        }
+        if (target.imageData) {
+            operationData.segmentationImageData = target.imageData;
+        }
+        if (target.voxelManager) {
+            operationData.segmentationVoxelManager = target.voxelManager;
+        }
+    }
+}
 
-/***/ },
 
-/***/ 55887
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/utils/shouldUseLazyLabelmapEditing.js
+var shouldUseLazyLabelmapEditing = __webpack_require__(86986);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/BrushStrategy.js
 
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ BrushStrategy)
-/* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
-/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(64664);
-/* harmony import */ var _utils_getStrategyData__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40905);
-/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29857);
 
 
 
 
 
 class BrushStrategy {
-    static { this.COMPOSITIONS = _compositions__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A; }
-    static { this.childFunctions = {
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionStart]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionStart, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionEnd]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionEnd, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CreateIsInThreshold),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Interpolate]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Interpolate, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AcceptPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AcceptPreview, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RejectPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RejectPreview, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.INTERNAL_setValue),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Preview]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Preview, false),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.ComputeInnerCircleRadius),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.EnsureImageVolumeFor3DManipulation),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AddPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AddPreview),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.GetStatistics]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.GetStatistics),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CalculateCursorGeometry]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CalculateCursorGeometry, true),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RenderCursor]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RenderCursor, true),
-        compositions: null,
-    }; }
     constructor(name, ...initializers) {
         this._initialize = [];
         this._fill = [];
         this._onInteractionStart = [];
         this.fill = (enabledElement, operationData) => {
-            const initializedData = this.initialize(enabledElement, operationData, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill);
+            const initializedData = this.initialize(enabledElement, operationData, enums.StrategyCallbacks.Fill);
             if (!initializedData) {
                 return;
             }
+            const isLazyLabelmapEditing = (0,shouldUseLazyLabelmapEditing/* shouldUseLazyLabelmapEditing */.v)(initializedData.viewport);
+            const shouldPrepareOverlap = !isLazyLabelmapEditing || !initializedData.previewOnHover;
+            const originalSegmentationVoxelManager = initializedData.segmentationVoxelManager;
+            const originalSegmentationImageData = initializedData.segmentationImageData;
+            if (shouldPrepareOverlap) {
+                prepareOverlapOperationData(initializedData);
+            }
+            if (initializedData.memo?.segmentationVoxelManager !==
+                initializedData.segmentationVoxelManager) {
+                initializedData.memo = initializedData.createMemo(initializedData.segmentationId, initializedData.segmentationVoxelManager);
+            }
+            if (initializedData.segmentationVoxelManager !==
+                originalSegmentationVoxelManager ||
+                initializedData.segmentationImageData !== originalSegmentationImageData) {
+                this._initialize.forEach((func) => func(initializedData));
+            }
             this._fill.forEach((func) => func(initializedData));
             const { segmentationVoxelManager, segmentIndex } = initializedData;
-            (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__.triggerSegmentationDataModified)(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), segmentIndex);
+            const crossLayerModifiedSlices = eraseCrossLayerOverwrites(initializedData);
+            const modifiedSlices = new Set([
+                ...(segmentationVoxelManager.getArrayOfModifiedSlices() ?? []),
+                ...crossLayerModifiedSlices,
+            ]);
+            (0,triggerSegmentationEvents.triggerSegmentationDataModified)(initializedData.segmentationId, Array.from(modifiedSlices), segmentIndex);
             return initializedData;
         };
         this.onInteractionStart = (enabledElement, operationData) => {
@@ -2926,23 +3342,23 @@ class BrushStrategy {
             this._onInteractionStart.forEach((func) => func.call(this, initializedData));
         };
         this.addPreview = (enabledElement, operationData) => {
-            const initializedData = this.initialize(enabledElement, operationData, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AddPreview);
+            const initializedData = this.initialize(enabledElement, operationData, enums.StrategyCallbacks.AddPreview);
             if (!initializedData) {
                 return;
             }
             return initializedData;
         };
         this.configurationName = name;
-        const cursorGeometryInitializer = initializers.find((init) => init.hasOwnProperty(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CalculateCursorGeometry));
-        const renderCursorInitializer = initializers.find((init) => init.hasOwnProperty(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RenderCursor));
+        const cursorGeometryInitializer = initializers.find((init) => init.hasOwnProperty(enums.StrategyCallbacks.CalculateCursorGeometry));
+        const renderCursorInitializer = initializers.find((init) => init.hasOwnProperty(enums.StrategyCallbacks.RenderCursor));
         if (!cursorGeometryInitializer) {
             initializers.push({
-                [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CalculateCursorGeometry]: _compositions__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.circularCursor.calculateCursorGeometry,
+                [enums.StrategyCallbacks.CalculateCursorGeometry]: compositions/* default */.A.circularCursor.calculateCursorGeometry,
             });
         }
         if (!renderCursorInitializer) {
             initializers.push({
-                [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RenderCursor]: _compositions__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.circularCursor.renderCursor,
+                [enums.StrategyCallbacks.RenderCursor]: compositions/* default */.A.circularCursor.renderCursor,
             });
         }
         this.compositions = initializers;
@@ -2967,7 +3383,7 @@ class BrushStrategy {
     }
     initialize(enabledElement, operationData, operationName) {
         const { viewport } = enabledElement;
-        const data = (0,_utils_getStrategyData__WEBPACK_IMPORTED_MODULE_3__/* .getStrategyData */ .S)({ operationData, viewport, strategy: this });
+        const data = (0,getStrategyData/* getStrategyData */.S)({ operationData, viewport, strategy: this });
         if (!data ||
             !data.imageVoxelManager ||
             !data.segmentationVoxelManager ||
@@ -2995,6 +3411,28 @@ class BrushStrategy {
         return initializedData;
     }
 }
+BrushStrategy.COMPOSITIONS = compositions/* default */.A;
+BrushStrategy.childFunctions = {
+    [enums.StrategyCallbacks.OnInteractionStart]: addListMethod(enums.StrategyCallbacks.OnInteractionStart, enums.StrategyCallbacks.Initialize),
+    [enums.StrategyCallbacks.OnInteractionEnd]: addListMethod(enums.StrategyCallbacks.OnInteractionEnd, enums.StrategyCallbacks.Initialize),
+    [enums.StrategyCallbacks.Fill]: addListMethod(enums.StrategyCallbacks.Fill),
+    [enums.StrategyCallbacks.Initialize]: addListMethod(enums.StrategyCallbacks.Initialize),
+    [enums.StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(enums.StrategyCallbacks.CreateIsInThreshold),
+    [enums.StrategyCallbacks.Interpolate]: addListMethod(enums.StrategyCallbacks.Interpolate, enums.StrategyCallbacks.Initialize),
+    [enums.StrategyCallbacks.AcceptPreview]: addListMethod(enums.StrategyCallbacks.AcceptPreview, enums.StrategyCallbacks.Initialize),
+    [enums.StrategyCallbacks.RejectPreview]: addListMethod(enums.StrategyCallbacks.RejectPreview, enums.StrategyCallbacks.Initialize),
+    [enums.StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(enums.StrategyCallbacks.INTERNAL_setValue),
+    [enums.StrategyCallbacks.Preview]: addSingletonMethod(enums.StrategyCallbacks.Preview, false),
+    [enums.StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(enums.StrategyCallbacks.ComputeInnerCircleRadius),
+    [enums.StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: addListMethod(enums.StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation),
+    [enums.StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: addListMethod(enums.StrategyCallbacks.EnsureImageVolumeFor3DManipulation),
+    [enums.StrategyCallbacks.AddPreview]: addListMethod(enums.StrategyCallbacks.AddPreview),
+    [enums.StrategyCallbacks.GetStatistics]: addSingletonMethod(enums.StrategyCallbacks.GetStatistics),
+    [enums.StrategyCallbacks.CalculateCursorGeometry]: addSingletonMethod(enums.StrategyCallbacks.CalculateCursorGeometry, true),
+    [enums.StrategyCallbacks.RenderCursor]: addSingletonMethod(enums.StrategyCallbacks.RenderCursor, true),
+    compositions: null,
+};
+/* harmony default export */ const strategies_BrushStrategy = (BrushStrategy);
 function addListMethod(name, createInitialized) {
     const listName = `_${name}`;
     return (brushStrategy, func) => {
@@ -3047,7 +3485,7 @@ var StrategyCallbacks = __webpack_require__(84093);
 
 /* harmony default export */ const determineSegmentIndex = ({
     [StrategyCallbacks/* default */.A.OnInteractionStart]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, configuration, } = operationData;
+        const { segmentIndex, labelValue, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, configuration, } = operationData;
         if (!configuration?.useCenterSegmentIndex) {
             operationData.centerSegmentIndexInfo.segmentIndex = null;
             operationData.centerSegmentIndexInfo.hasSegmentIndex = false;
@@ -3069,7 +3507,7 @@ var StrategyCallbacks = __webpack_require__(84093);
             nestedBounds[2] = [centerIJK[2], centerIJK[2]];
         }
         const callback = ({ value }) => {
-            hasSegmentIndex ||= value === segmentIndex;
+            hasSegmentIndex ||= value === (labelValue ?? segmentIndex);
             hasPreviewIndex ||= value === previewSegmentIndex;
         };
         segmentationVoxelManager.forEach(callback, {
@@ -3090,9 +3528,12 @@ var StrategyCallbacks = __webpack_require__(84093);
 
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var esm = __webpack_require__(3823);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getViewportICamera.js
+var getViewportICamera = __webpack_require__(29604);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js
 
 
+
 /* harmony default export */ const dynamicThreshold = ({
     [StrategyCallbacks/* default */.A.Initialize]: (operationData) => {
         const { operationName, centerIJK, segmentationVoxelManager, imageVoxelManager, configuration, segmentIndex, viewport, } = operationData;
@@ -3106,7 +3547,10 @@ var esm = __webpack_require__(3823);
         const boundsIJK = segmentationVoxelManager.getBoundsIJK();
         const { range: oldThreshold, dynamicRadius = 0 } = configuration.threshold;
         const useDelta = oldThreshold ? 0 : dynamicRadius;
-        const { viewPlaneNormal } = viewport.getCamera();
+        const { viewPlaneNormal } = (0,getViewportICamera/* default */.A)(viewport);
+        if (!viewPlaneNormal) {
+            return;
+        }
         const nestedBounds = boundsIJK.map((ijk, idx) => {
             const [min, max] = ijk;
             return [
@@ -3197,7 +3641,7 @@ var segmentation_islandRemoval = __webpack_require__(67912);
 
 /* harmony default export */ const islandRemovalComposition = ({
     [StrategyCallbacks/* default */.A.OnInteractionEnd]: (operationData) => {
-        const { previewSegmentIndex, segmentIndex, viewport, segmentationVoxelManager, activeStrategy, memo, } = operationData;
+        const { previewSegmentIndex, segmentIndex, labelValue, viewport, segmentationVoxelManager, activeStrategy, memo, } = operationData;
         if (activeStrategy !== 'THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL' ||
             segmentIndex === null) {
             return;
@@ -3206,7 +3650,7 @@ var segmentation_islandRemoval = __webpack_require__(67912);
         const voxelManager = memo?.voxelManager || segmentationVoxelManager;
         if (!islandRemoval.initialize(viewport, voxelManager, {
             previewSegmentIndex,
-            segmentIndex,
+            segmentIndex: labelValue ?? segmentIndex,
         })) {
             return;
         }
@@ -3261,7 +3705,7 @@ var getViewportIdsWithSegmentation = __webpack_require__(58859);
         operationData.modified = true;
     },
     [StrategyCallbacks/* default */.A.AcceptPreview]: (operationData) => {
-        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, centerSegmentIndexInfo, } = operationData || {};
+        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, labelValue, centerSegmentIndexInfo, } = operationData || {};
         const { changedIndices } = centerSegmentIndexInfo || {};
         const labelmapMemo = memo;
         const callback = ({ index }) => {
@@ -3273,7 +3717,7 @@ var getViewportIdsWithSegmentation = __webpack_require__(58859);
             }
             else {
                 if (oldValue === previewSegmentIndex) {
-                    labelmapMemo.voxelManager.setAtIndex(index, segmentIndex);
+                    labelmapMemo.voxelManager.setAtIndex(index, labelValue ?? segmentIndex);
                 }
             }
         };
@@ -3330,10 +3774,11 @@ var getViewportIdsWithSegmentation = __webpack_require__(58859);
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/handleUseSegmentCenterIndex.js
 function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
-    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, } = operationData;
+    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, labelValue, } = operationData;
+    const activeLabelValue = labelValue ?? segmentIndex;
     const { hasPreviewIndex, hasSegmentIndex, segmentIndex: centerSegmentIndex, } = centerSegmentIndexInfo;
     if (centerSegmentIndex === 0 && hasSegmentIndex && hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (previewOnHover) {
@@ -3346,7 +3791,7 @@ function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
         return;
     }
     if (centerSegmentIndex === 0 && hasSegmentIndex && !hasPreviewIndex) {
-        if (existingValue === 0 || existingValue !== segmentIndex) {
+        if (existingValue === 0 || existingValue !== activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -3354,7 +3799,7 @@ function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
         return;
     }
     if (centerSegmentIndex === 0 && !hasSegmentIndex && hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (previewOnHover) {
@@ -3367,7 +3812,7 @@ function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
         return;
     }
     if (centerSegmentIndex === 0 && !hasSegmentIndex && !hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (existingValue === previewSegmentIndex) {
@@ -3379,7 +3824,7 @@ function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
     if (centerSegmentIndex === previewSegmentIndex &&
         hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -3388,25 +3833,25 @@ function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
     if (centerSegmentIndex === previewSegmentIndex &&
         !hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
         return;
     }
-    if (centerSegmentIndex === segmentIndex &&
+    if (centerSegmentIndex === activeLabelValue &&
         hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
         return;
     }
-    if (centerSegmentIndex === segmentIndex &&
+    if (centerSegmentIndex === activeLabelValue &&
         hasSegmentIndex &&
         !hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -3414,29 +3859,41 @@ function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
     }
 }
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var getSegmentation = __webpack_require__(33283);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/labelmapSegmentationState.js
+var labelmapSegmentationState = __webpack_require__(90660);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/setValue.js
 
 
+
+
 /* harmony default export */ const setValue = ({
     [StrategyCallbacks/* default */.A.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, } = operationData;
+        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, labelValue, labelmapId, segmentationId, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
-        if (segmentsLocked.includes(value)) {
+        const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+        const existingSegmentIndex = segmentation && labelmapId
+            ? (0,labelmapSegmentationState/* getSegmentIndexForLabelValue */.Mx)(segmentation, labelmapId, existingValue)
+            : existingValue;
+        const writeValue = previewSegmentIndex ?? labelValue ?? segmentIndex;
+        if (segmentsLocked.includes(existingSegmentIndex)) {
             return;
         }
-        if (!centerSegmentIndexInfo && existingValue === segmentIndex) {
+        if (!centerSegmentIndexInfo &&
+            existingValue === (labelValue ?? segmentIndex)) {
             return;
         }
         if (centerSegmentIndexInfo?.segmentIndex !== 0 &&
-            existingValue === segmentIndex) {
+            existingValue === (labelValue ?? segmentIndex)) {
             return;
         }
         if (centerSegmentIndexInfo?.segmentIndex === null) {
-            memo.voxelManager.setAtIndex(index, previewSegmentIndex ?? segmentIndex);
+            memo.voxelManager.setAtIndex(index, writeValue);
             return;
         }
         if (!previewSegmentIndex) {
-            let useSegmentIndex = segmentIndex;
+            let useSegmentIndex = labelValue ?? segmentIndex;
             if (centerSegmentIndexInfo) {
                 useSegmentIndex = centerSegmentIndexInfo.segmentIndex;
             }
@@ -3500,6 +3957,7 @@ var drawingSvg = __webpack_require__(74347);
 
 
 
+
 /* harmony default export */ const circularCursor = ({
     [StrategyCallbacks/* default */.A.CalculateCursorGeometry]: function (enabledElement, operationData) {
         if (!operationData) {
@@ -3507,8 +3965,11 @@ var drawingSvg = __webpack_require__(74347);
         }
         const { configuration, activeStrategy, hoverData } = operationData;
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
+        const camera = (0,getViewportICamera/* default */.A)(viewport);
         const { brushSize } = configuration;
+        if (!camera.viewUp || !camera.viewPlaneNormal) {
+            return;
+        }
         const viewUp = esm/* vec3.fromValues */.eR.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
         const viewPlaneNormal = esm/* vec3.fromValues */.eR.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
         const viewRight = esm/* vec3.create */.eR.create();
@@ -3543,6 +4004,7 @@ var drawingSvg = __webpack_require__(74347);
             leftCursorInWorld,
             rightCursorInWorld,
         ];
+        data.editPoints = [...data.handles.points];
         const strategy = configuration.strategies[activeStrategy];
         if (typeof strategy?.computeInnerCircleRadius === 'function') {
             strategy.computeInnerCircleRadius({
@@ -3563,35 +4025,58 @@ var drawingSvg = __webpack_require__(74347);
         if (!toolMetadata) {
             return;
         }
-        const annotationUID = toolMetadata.brushCursorUID;
+        const annotationUID = toolMetadata.brushCursorUID || 'brushCursor';
         const data = brushCursor.data;
-        const { points } = data.handles;
-        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-        const bottom = canvasCoordinates[0];
-        const top = canvasCoordinates[1];
-        const center = [
-            Math.floor((bottom[0] + top[0]) / 2),
-            Math.floor((bottom[1] + top[1]) / 2),
-        ];
-        const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
         const color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
         if (!viewport.getRenderingEngine()) {
             console.warn('Rendering Engine has been destroyed');
             return;
         }
-        const circleUID = '0';
-        (0,drawingSvg.drawCircle)(svgDrawingHelper, annotationUID, circleUID, center, radius, {
-            color,
-            lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
-        });
+        const points = data.handles?.points || [];
+        const totalCircles = Math.floor((points?.length || 0) / 4);
+        const circleGeometries = [];
+        for (let i = 0; i < points.length; i += 4) {
+            const circlePoints = points.slice(i, i + 4);
+            if (circlePoints.length < 2) {
+                continue;
+            }
+            const canvasCoordinates = circlePoints.map((p) => viewport.worldToCanvas(p));
+            const bottom = canvasCoordinates[0];
+            const top = canvasCoordinates[1];
+            const center = [
+                Math.floor((bottom[0] + top[0]) / 2),
+                Math.floor((bottom[1] + top[1]) / 2),
+            ];
+            const radius = Math.round(Math.abs(bottom[1] - center[1]));
+            circleGeometries.push({ center, radius });
+        }
+        const currentCircle = circleGeometries[circleGeometries.length - 1];
+        if (circleGeometries.length > 1) {
+            (0,drawingSvg.drawPath)(svgDrawingHelper, annotationUID, 'stroke-preview', circleGeometries.map((circle) => circle.center), {
+                color,
+                lineWidth: currentCircle.radius * 2,
+                strokeOpacity: 0.35,
+                lineCap: 'round',
+                lineJoin: 'round',
+                lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? '6,4' : undefined,
+            });
+        }
+        if (currentCircle) {
+            (0,drawingSvg.drawCircle)(svgDrawingHelper, annotationUID, 'current-circle', currentCircle.center, currentCircle.radius, {
+                color,
+                lineWidth: 2,
+                strokeOpacity: 1,
+                lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
+            }, 'brush-cursor');
+        }
         const { dynamicRadiusInCanvas } = configuration?.threshold || {
             dynamicRadiusInCanvas: 0,
         };
-        if (dynamicRadiusInCanvas) {
-            const circleUID1 = '1';
-            (0,drawingSvg.drawCircle)(svgDrawingHelper, annotationUID, circleUID1, center, dynamicRadiusInCanvas, {
+        if (dynamicRadiusInCanvas && currentCircle) {
+            const circleUID1 = 'dynamic-radius';
+            (0,drawingSvg.drawCircle)(svgDrawingHelper, annotationUID, circleUID1, currentCircle.center, dynamicRadiusInCanvas, {
                 color,
-            });
+            }, 'brush-cursor');
         }
     },
 });
@@ -3633,7 +4118,7 @@ var drawingSvg = __webpack_require__(74347);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   r: () => (/* binding */ eraseInsideCircle)
 /* harmony export */ });
-/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55887);
+/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18543);
 /* harmony import */ var _fillCircle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(56789);
 /* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(64664);
 
@@ -3652,7 +4137,7 @@ const eraseInsideCircle = ERASE_CIRCLE_STRATEGY.strategyFunction;
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   _: () => (/* binding */ eraseInsideSphere)
 /* harmony export */ });
-/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55887);
+/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18543);
 /* harmony import */ var _fillSphere__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(17492);
 /* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(64664);
 
@@ -3677,7 +4162,7 @@ const eraseInsideSphere = ERASE_SPHERE_STRATEGY.strategyFunction;
 /* unused harmony export fillOutsideSphere */
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3823);
-/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(55887);
+/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(18543);
 /* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(64664);
 /* harmony import */ var _enums_StrategyCallbacks__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84093);
 /* harmony import */ var _fillCircle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(56789);
@@ -3688,7 +4173,7 @@ const eraseInsideSphere = ERASE_SPHERE_STRATEGY.strategyFunction;
 
 
 
-const { transformWorldToIndex } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
+const { transformWorldToIndex, getNormalizedAspectRatio } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
 
 const sphereComposition = {
     [_enums_StrategyCallbacks__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A.Initialize]: (operationData) => {
@@ -3710,7 +4195,13 @@ const sphereComposition = {
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
         const corners = (0,_fillCircle__WEBPACK_IMPORTED_MODULE_5__/* .getEllipseCornersFromCanvasCoordinates */ .C$)(canvasCoordinates);
         const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
-        const strokeRadius = points.length >= 2 ? gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .eR.distance(points[0], points[1]) / 2 : undefined;
+        const aspectRatio = getNormalizedAspectRatio(viewport.getAspectRatio());
+        const yRadius = points.length >= 2
+            ? gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .eR.distance(points[0], points[1]) / 2 / aspectRatio[1]
+            : 0;
+        const xRadius = points.length >= 2
+            ? gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .eR.distance(points[2], points[3]) / 2 / aspectRatio[0]
+            : 0;
         const strokeCenters = operationData.strokePointsWorld &&
             operationData.strokePointsWorld.length > 0
             ? operationData.strokePointsWorld
@@ -3774,7 +4265,9 @@ const sphereComposition = {
         operationData.isInObject = (0,_fillCircle__WEBPACK_IMPORTED_MODULE_5__/* .createEllipseInPoint */ .mu)(cornersInWorld, {
             strokePointsWorld: operationData.strokePointsWorld,
             segmentationImageData,
-            radius: strokeRadius,
+            xRadius,
+            yRadius,
+            aspectRatio,
         });
     },
 };
@@ -3790,6 +4283,170 @@ function fillOutsideSphere() {
 
 
 
+/***/ },
+
+/***/ 81668
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (/* binding */ utils_LazyBrushEditController)
+});
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(15327);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
+var enums = __webpack_require__(29857);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/utils/lazyBrushPreview.js
+const EPSILON = 1e-3;
+function clonePoint(point) {
+    return [point[0], point[1], point[2]];
+}
+function isSamePoint(a, b) {
+    return (Math.abs(a[0] - b[0]) < EPSILON &&
+        Math.abs(a[1] - b[1]) < EPSILON &&
+        Math.abs(a[2] - b[2]) < EPSILON);
+}
+function appendLazyBrushStrokePoint(points = [], point) {
+    if (!point) {
+        return points;
+    }
+    if (points.length && isSamePoint(points[points.length - 1], point)) {
+        return points;
+    }
+    return [...points, clonePoint(point)];
+}
+function appendLazyBrushPreviewCircle(existingPoints = [], circlePoints = []) {
+    if (!circlePoints.length) {
+        return existingPoints;
+    }
+    const nextCircle = circlePoints.map((point) => clonePoint(point));
+    if (!existingPoints.length) {
+        return nextCircle;
+    }
+    const previousCircle = existingPoints.slice(-nextCircle.length);
+    const isDuplicateCircle = previousCircle.length === nextCircle.length &&
+        previousCircle.every((point, index) => isSamePoint(point, nextCircle[index]));
+    if (isDuplicateCircle) {
+        return existingPoints;
+    }
+    return [...existingPoints, ...nextCircle];
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/utils/LazyBrushEditController.js
+
+
+
+class LazyBrushEditController {
+    constructor() {
+        this.strokePointsWorld = [];
+        this.previewPoints = [];
+        this.pendingPreviewCleanup = null;
+    }
+    reset() {
+        this.strokePointsWorld = [];
+        this.previewPoints = [];
+    }
+    clearPendingCleanup() {
+        if (!this.pendingPreviewCleanup) {
+            return;
+        }
+        esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_RENDERED, this.pendingPreviewCleanup.listener);
+        this.pendingPreviewCleanup = null;
+    }
+    appendStrokePoint(worldPoint) {
+        this.strokePointsWorld = appendLazyBrushStrokePoint(this.strokePointsWorld, worldPoint);
+    }
+    getStrokePointsWorld() {
+        return this.strokePointsWorld;
+    }
+    capturePreviewCircle(hoverData) {
+        if (!hoverData) {
+            return;
+        }
+        const circlePoints = hoverData.brushCursor?.data?.editPoints;
+        this.previewPoints = appendLazyBrushPreviewCircle(this.previewPoints, circlePoints);
+        hoverData.brushCursor.data.handles.points = this.previewPoints;
+    }
+    scheduleCleanup({ element, centerCanvas, viewportId, segmentationId, refreshCursor, }) {
+        this.clearPendingCleanup();
+        const listener = ((evt) => {
+            const detail = evt.detail;
+            if (detail.viewportId !== viewportId ||
+                detail.segmentationId !== segmentationId) {
+                return;
+            }
+            this.clearPendingCleanup();
+            this.reset();
+            refreshCursor(element, centerCanvas);
+        });
+        this.pendingPreviewCleanup = {
+            viewportId,
+            segmentationId,
+            listener,
+        };
+        esm.eventTarget.addEventListener(enums.Events.SEGMENTATION_RENDERED, listener);
+    }
+}
+/* harmony default export */ const utils_LazyBrushEditController = (LazyBrushEditController);
+
+
+/***/ },
+
+/***/ 86986
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   v: () => (/* binding */ shouldUseLazyLabelmapEditing)
+/* harmony export */ });
+/* unused harmony export isCPUViewport */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(36625);
+
+
+const CPU_RENDER_MODES = new Set([
+    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ActorRenderMode.CPU_IMAGE,
+    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ActorRenderMode.CPU_VOLUME,
+]);
+function getDefaultActor(viewport) {
+    try {
+        return viewport.getDefaultActor?.();
+    }
+    catch {
+        return;
+    }
+}
+function isCPUViewport(viewport) {
+    if (!viewport) {
+        return (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getShouldUseCPURendering)();
+    }
+    const cpuViewport = viewport;
+    if (cpuViewport.useCPURendering === true) {
+        return true;
+    }
+    if (cpuViewport._cpuFallbackEnabledElement) {
+        return true;
+    }
+    const defaultActor = getDefaultActor(viewport);
+    const renderMode = defaultActor?.actorMapper?.renderMode;
+    if (renderMode && CPU_RENDER_MODES.has(renderMode)) {
+        return true;
+    }
+    const actorClassName = typeof defaultActor?.actor?.getClassName === 'function'
+        ? defaultActor.actor.getClassName()
+        : undefined;
+    if (actorClassName === 'CanvasActor') {
+        return true;
+    }
+    return (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getShouldUseCPURendering)();
+}
+function shouldUseLazyLabelmapEditing(viewport) {
+    return ((0,_config__WEBPACK_IMPORTED_MODULE_1__/* .getConfig */ .zj)().segmentation?.overwriteMode !== undefined ||
+        isCPUViewport(viewport));
+}
+
+
 /***/ },
 
 /***/ 109
@@ -4616,6 +5273,40 @@ function _generateClosedContour(points) {
 /* harmony default export */ const interpolation_interpolate = (interpolate);
 
 
+/***/ },
+
+/***/ 29604
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getViewportICamera)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+
+function getViewportICamera(viewport, viewReference = viewport.getViewReference()) {
+    const genericViewport = viewport;
+    const camera = (genericViewport.getResolvedView?.()?.toICamera?.() ||
+        viewport.getCamera?.() ||
+        {});
+    const focalPoint = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.clonePoint3(viewReference?.cameraFocalPoint || camera.focalPoint);
+    const viewPlaneNormal = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.clonePoint3(viewReference?.viewPlaneNormal || camera.viewPlaneNormal);
+    const viewUp = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.clonePoint3(viewReference?.viewUp || camera.viewUp);
+    const position = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.clonePoint3(camera.position ||
+        (focalPoint &&
+            viewPlaneNormal && [
+            focalPoint[0] - viewPlaneNormal[0],
+            focalPoint[1] - viewPlaneNormal[1],
+            focalPoint[2] - viewPlaneNormal[2],
+        ]));
+    return {
+        focalPoint,
+        position,
+        viewPlaneNormal,
+        viewUp,
+    };
+}
+
+
 /***/ },
 
 /***/ 69013
@@ -4627,6 +5318,7 @@ function _generateClosedContour(points) {
 /* harmony export */ });
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _Calculator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(28364);
+var _a;
 
 
 const { PointsManager } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
@@ -4833,20 +5525,21 @@ function basicGetStatistics(state, unit) {
     return named;
 }
 class BasicStatsCalculator extends _Calculator__WEBPACK_IMPORTED_MODULE_1__/* .Calculator */ .t {
-    static { this.state = createBasicStatsState(true); }
     static statsInit(options) {
         if (!options.storePointData) {
             this.state.pointsInShape = null;
         }
         this.state = createBasicStatsState(options.storePointData);
     }
-    static { this.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = null, }) => {
-        basicStatsCallback(this.state, newValue, pointLPS, pointIJK);
-    }; }
-    static { this.getStatistics = (options) => {
-        return basicGetStatistics(this.state, options?.unit);
-    }; }
 }
+_a = BasicStatsCalculator;
+BasicStatsCalculator.state = createBasicStatsState(true);
+BasicStatsCalculator.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = null, }) => {
+    basicStatsCallback(_a.state, newValue, pointLPS, pointIJK);
+};
+BasicStatsCalculator.getStatistics = (options) => {
+    return basicGetStatistics(_a.state, options?.unit);
+};
 class InstanceBasicStatsCalculator extends _Calculator__WEBPACK_IMPORTED_MODULE_1__/* .InstanceCalculator */ .I {
     constructor(options) {
         super(options);
@@ -5526,29 +6219,6 @@ function deleteRelatedAnnotations(viewportData) {
 }
 
 
-/***/ },
-
-/***/ 27479
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   d: () => (/* binding */ computeAndAddRepresentation)
-/* harmony export */ });
-/* harmony import */ var _stateManagement_segmentation_internalAddRepresentationData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44188);
-
-async function computeAndAddRepresentation(segmentationId, type, computeFunction, onComputationComplete) {
-    const data = await computeFunction();
-    (0,_stateManagement_segmentation_internalAddRepresentationData__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)({
-        segmentationId,
-        type,
-        data,
-    });
-    onComputationComplete?.();
-    return data;
-}
-
-
-
 /***/ },
 
 /***/ 86644
@@ -5665,7 +6335,7 @@ function getViewportIdsWithToolToRender(element, toolName, requireParallelNormal
     viewports = (0,_filterViewportsWithToolEnabled__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(viewports, toolName);
     const viewport = renderingEngine.getViewport(enabledElement.viewportId);
     if (requireParallelNormals) {
-        viewports = (0,_filterViewportsWithParallelNormals__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(viewports, viewport.getCamera());
+        viewports = (0,_filterViewportsWithParallelNormals__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(viewports, viewport);
     }
     const viewportIds = viewports.map((vp) => vp.id);
     return viewportIds;