@ohif/app 3.13.0-beta.119 → 3.13.0-beta.120

package/dist/{8668.bundle.93c88419e37dc076.js → 8668.bundle.0e47f7231aa07da2.js}

@@ -6279,6 +6279,9 @@ __webpack_require__.d(__webpack_exports__, {
   loadImageToCanvas: () => (/* reexport */ loadImageToCanvas/* ["default"] */.A),
   logger: () => (/* reexport */ logger),
   makeVolumeMetadata: () => (/* reexport */ makeVolumeMetadata/* ["default"] */.A),
+  mapMappedBandToRawRange: () => (/* reexport */ viewportVoiIntensityMapping/* .mapMappedBandToRawRange */.j_),
+  mapScalarToViewportVoiIntensity: () => (/* reexport */ viewportVoiIntensityMapping/* .mapScalarToViewportVoiIntensity */.fT),
+  mapViewportVoiIntensityToScalar: () => (/* reexport */ viewportVoiIntensityMapping/* .mapViewportVoiIntensityToScalar */.l2),
   planar: () => (/* reexport */ planar),
   pointInShapeCallback: () => (/* reexport */ pointInShapeCallback/* .pointInShapeCallback */.ii),
   renderToCanvasCPU: () => (/* reexport */ renderToCanvasCPU/* ["default"] */.A),
@@ -6545,6 +6548,8 @@ var calculateSpacingBetweenImageIds = __webpack_require__(66831);
 var logger = __webpack_require__(80977);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/calculateNeighborhoodStats.js
 var calculateNeighborhoodStats = __webpack_require__(5830);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/viewportVoiIntensityMapping.js
+var viewportVoiIntensityMapping = __webpack_require__(28656);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getPixelSpacingInformation.js
 var getPixelSpacingInformation = __webpack_require__(41840);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getPlaneCubeIntersectionDimensions.js
@@ -6675,6 +6680,7 @@ var isEqual = __webpack_require__(77981);
 
 
 
+
 
 
 const utilities_getViewportModality = (viewport, volumeId) => (0,getViewportModality/* ._getViewportModality */.p)(viewport, volumeId, cache/* ["default"].getVolume */.Ay.getVolume);
@@ -6683,6 +6689,29 @@ const utilities_getScalingDescriptor = (viewport, targetId) => (0,getScalingDesc
 
 
 
+},
+80977(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  aiLog: () => (aiLog),
+  coreLog: () => (coreLog),
+  cs3dLog: () => (cs3dLog),
+  dicomConsistencyLog: () => (dicomConsistencyLog),
+  examplesLog: () => (examplesLog),
+  getLogger: () => (getLogger),
+  getRootLogger: () => (getRootLogger),
+  growCutLog: () => (growCutLog),
+  imageConsistencyLog: () => (imageConsistencyLog),
+  loaderLog: () => (loaderLog),
+  toolsLog: () => (toolsLog),
+  workerLog: () => (workerLog)
+});
+/* import */ var _cornerstonejs_utils__rspack_import_0 = __webpack_require__(53103);
+
+const { /* getRootLogger */pp: getRootLogger, /* getLogger */tZ: getLogger, /* cs3dLog */gE: cs3dLog, /* workerLog */bM: workerLog, /* coreLog */uu: coreLog, /* toolsLog */UA: toolsLog, /* loaderLog */_E: loaderLog, /* aiLog */RZ: aiLog, /* examplesLog */UX: examplesLog, /* dicomConsistencyLog */HL: dicomConsistencyLog, /* imageConsistencyLog */U5: imageConsistencyLog, } = _cornerstonejs_utils__rspack_import_0/* .logging */.m9;
+const growCutLog = toolsLog.getLogger('growCut');
+
+
 },
 25481(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
@@ -8262,6 +8291,7 @@ __webpack_require__.d(__webpack_exports__, {
 },
 88392(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
+  $n: () => (removeLabelmap),
   AD: () => (registerLabelmap),
   Hs: () => (getLabelmap),
   kL: () => (getOrCreateLabelmapVolume),
@@ -8291,13 +8321,13 @@ function registerLabelmap(segmentation, layer) {
     labelmapState.labelmaps[layer.labelmapId] = layer;
 }
 function removeLabelmap(segmentation, labelmapId) {
-    const labelmapState = ensureLabelmapState(segmentation);
+    const labelmapState = (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation);
     if (!labelmapState) {
         return;
     }
     const layer = labelmapState.labelmaps[labelmapId];
-    if (layer?.geometryVolumeId && cache.getVolume(layer.geometryVolumeId)) {
-        cache.removeVolumeLoadObject(layer.geometryVolumeId);
+    if (layer?.geometryVolumeId && _cornerstonejs_core__rspack_import_0.cache.getVolume(layer.geometryVolumeId)) {
+        _cornerstonejs_core__rspack_import_0.cache.removeVolumeLoadObject(layer.geometryVolumeId);
     }
     delete labelmapState.labelmaps[labelmapId];
 }
@@ -9549,6 +9579,7 @@ class BrushTool extends _LabelmapBaseTool_js__rspack_import_9/* ["default"] */.A
             };
             this._hoverData = this.createHoverData(element, canvasPoint);
             if (!this._hoverData) {
+                this._editData = null;
                 return false;
             }
             this._calculateCursor(element, canvasPoint);
@@ -11796,6 +11827,199 @@ function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
 
 
 
+},
+29827(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (IslandRemoval)
+});
+/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
+/* import */ var _normalizeViewportPlane_js__rspack_import_1 = __webpack_require__(95972);
+
+
+const { RLEVoxelMap, VoxelManager } = _cornerstonejs_core__rspack_import_0.utilities;
+const MAX_IMAGE_SIZE = 65535;
+var SegmentationEnum;
+(function (SegmentationEnum) {
+    SegmentationEnum[SegmentationEnum["SEGMENT"] = -1] = "SEGMENT";
+    SegmentationEnum[SegmentationEnum["ISLAND"] = -2] = "ISLAND";
+    SegmentationEnum[SegmentationEnum["INTERIOR"] = -3] = "INTERIOR";
+    SegmentationEnum[SegmentationEnum["EXTERIOR"] = -4] = "EXTERIOR";
+    SegmentationEnum[SegmentationEnum["INTERIOR_SMALL"] = -5] = "INTERIOR_SMALL";
+    SegmentationEnum[SegmentationEnum["INTERIOR_TEST"] = -6] = "INTERIOR_TEST";
+})(SegmentationEnum || (SegmentationEnum = {}));
+class IslandRemoval {
+    constructor(options) {
+        this.fillInternalEdge = false;
+        this.maxInternalRemove = 128;
+        this.maxInternalRemove =
+            options?.maxInternalRemove ?? this.maxInternalRemove;
+        this.fillInternalEdge = options?.fillInternalEdge ?? this.fillInternalEdge;
+    }
+    initialize(viewport, segmentationVoxels, options) {
+        const hasSource = !!segmentationVoxels.sourceVoxelManager;
+        const segmentationVoxelManager = hasSource
+            ? segmentationVoxels.sourceVoxelManager
+            : segmentationVoxels;
+        const previewVoxelManager = hasSource
+            ? segmentationVoxels
+            : VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+        const { segmentIndex = 1, previewSegmentIndex = 1 } = options;
+        const clickedPoints = options.points || segmentationVoxelManager.getPoints();
+        if (!clickedPoints?.length) {
+            return;
+        }
+        const boundsIJK = segmentationVoxelManager
+            .getBoundsIJK()
+            .map((bound, i) => [
+            Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
+            Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
+        ]);
+        if (boundsIJK.find((it) => it[0] < 0 || it[1] > MAX_IMAGE_SIZE)) {
+            return;
+        }
+        const { toIJK, fromIJK, boundsIJKPrime, error } = (0,_normalizeViewportPlane_js__rspack_import_1/* ["default"] */.A)(viewport, boundsIJK);
+        if (error) {
+            console.warn('Not performing island removal for planes not orthogonal to acquisition plane', error);
+            return;
+        }
+        const [width, height, depth] = fromIJK(segmentationVoxelManager.dimensions);
+        const segmentSet = new RLEVoxelMap(width, height, depth);
+        const getter = (i, j, k) => {
+            const index = segmentationVoxelManager.toIndex(toIJK([i, j, k]));
+            const oldVal = segmentationVoxelManager.getAtIndex(index);
+            if (oldVal === previewSegmentIndex || oldVal === segmentIndex) {
+                return SegmentationEnum.SEGMENT;
+            }
+        };
+        segmentSet.fillFrom(getter, boundsIJKPrime);
+        segmentSet.normalizer = { toIJK, fromIJK, boundsIJKPrime };
+        this.segmentSet = segmentSet;
+        this.previewVoxelManager = previewVoxelManager;
+        this.segmentIndex = segmentIndex;
+        this.previewSegmentIndex = previewSegmentIndex ?? segmentIndex;
+        this.selectedPoints = clickedPoints;
+        return true;
+    }
+    floodFillSegmentIsland() {
+        const { selectedPoints: clickedPoints, segmentSet } = this;
+        let floodedCount = 0;
+        const { fromIJK } = segmentSet.normalizer;
+        clickedPoints.forEach((clickedPoint) => {
+            const ijkPrime = fromIJK(clickedPoint);
+            const index = segmentSet.toIndex(ijkPrime);
+            const [iPrime, jPrime, kPrime] = ijkPrime;
+            if (segmentSet.get(index) === SegmentationEnum.SEGMENT) {
+                floodedCount += segmentSet.floodFill(iPrime, jPrime, kPrime, SegmentationEnum.ISLAND);
+            }
+        });
+        return floodedCount;
+    }
+    removeExternalIslands() {
+        const { previewVoxelManager, segmentSet } = this;
+        const { toIJK } = segmentSet.normalizer;
+        const callback = (index, rle) => {
+            const [, jPrime, kPrime] = segmentSet.toIJK(index);
+            if (rle.value !== SegmentationEnum.ISLAND) {
+                for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                    const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                    const v = previewVoxelManager.getAtIJKPoint(clearPoint);
+                    previewVoxelManager.setAtIJKPoint(clearPoint, v === undefined ? 0 : null);
+                }
+            }
+        };
+        segmentSet.forEach(callback, { rowModified: true });
+    }
+    removeInternalIslands() {
+        const { segmentSet, previewVoxelManager, previewSegmentIndex } = this;
+        const { height, normalizer, width } = segmentSet;
+        const { toIJK } = normalizer;
+        segmentSet.forEachRow((baseIndex, row) => {
+            let lastRle;
+            for (const rle of [...row]) {
+                if (rle.value !== SegmentationEnum.ISLAND) {
+                    continue;
+                }
+                if (!lastRle) {
+                    if (this.fillInternalEdge && rle.start > 0) {
+                        for (let iPrime = 0; iPrime < rle.start; iPrime++) {
+                            segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                        }
+                    }
+                    lastRle = rle;
+                    continue;
+                }
+                for (let iPrime = lastRle.end; iPrime < rle.start; iPrime++) {
+                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                }
+                lastRle = rle;
+            }
+            if (this.fillInternalEdge && lastRle?.end < width) {
+                for (let iPrime = lastRle.end; iPrime < width; iPrime++) {
+                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                }
+            }
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR) {
+                return;
+            }
+            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
+            const rowPrev = jPrime > 0 ? segmentSet.getRun(jPrime - 1, kPrime) : null;
+            const rowNext = jPrime + 1 < height ? segmentSet.getRun(jPrime + 1, kPrime) : null;
+            const isLast = jPrime === height - 1;
+            const isFirst = jPrime === 0;
+            const prevCovers = IslandRemoval.covers(rle, rowPrev) ||
+                (isFirst && this.fillInternalEdge);
+            const nextCovers = IslandRemoval.covers(rle, rowNext) || (isLast && this.fillInternalEdge);
+            if (rle.end - rle.start > 2 && (!prevCovers || !nextCovers)) {
+                segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.EXTERIOR, { singlePlane: true });
+            }
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR) {
+                return;
+            }
+            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
+            const size = segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.INTERIOR_TEST);
+            const isBig = size > this.maxInternalRemove;
+            const newType = isBig
+                ? SegmentationEnum.EXTERIOR
+                : SegmentationEnum.INTERIOR_SMALL;
+            segmentSet.floodFill(rle.start, jPrime, kPrime, newType);
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR_SMALL) {
+                return;
+            }
+            for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                const clearPoint = toIJK(segmentSet.toIJK(baseIndex + iPrime));
+                previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
+                this.onInternalPointFilled(clearPoint);
+            }
+        });
+        return previewVoxelManager.getArrayOfModifiedSlices();
+    }
+    onInternalPointFilled(_point) {
+    }
+    static covers(rle, row) {
+        if (!row) {
+            return false;
+        }
+        let { start } = rle;
+        const { end } = rle;
+        for (const rowRle of row) {
+            if (start >= rowRle.start && start < rowRle.end) {
+                start = rowRle.end;
+                if (start >= end) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+
+
 },
 42692(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {

package/dist/{9402.bundle.0dd1b538f0708077.js → 9402.bundle.928437e2e48c12dd.js}

@@ -11273,8 +11273,8 @@ function AboutModalDefault() {
     name
   } = (0,browser_detect_es5/* ["default"] */.A)();
   const browser = `${name[0].toUpperCase()}${name.substr(1)} ${version}`;
-  const versionNumber = "3.13.0-beta.119";
-  const commitHash = "1eee3e6119cf7d34edac9e9e71cdbd3286dc9bb1";
+  const versionNumber = "3.13.0-beta.120";
+  const commitHash = "9c76afa075e42a5e7197d42c89e10ef4c8b461a4";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* .AboutModal */.VTU, {
     className: "w-[400px]"