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

package/dist/{99.bundle.f7e8de6d86029ec75605.js → 4675.bundle.b7e00e5915520885fa1f.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[99],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[4675],{
 
 /***/ 19742:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -10,7 +10,7 @@
 /* harmony export */ });
 /* harmony import */ var _cornerstoneStreamingImageVolumeLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55500);
 /* harmony import */ var _cornerstoneStreamingDynamicImageVolumeLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(55509);
-/* harmony import */ var _geometryLoader__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39459);
+/* harmony import */ var _geometryLoader__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(89926);
 /* harmony import */ var _imageLoader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(80068);
 /* harmony import */ var _volumeLoader__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(39561);
 
@@ -21,6 +21,971 @@
 
 
 
+/***/ }),
+
+/***/ 56983:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  canComputeRequestedRepresentation: () => (/* reexport */ canComputeRequestedRepresentation),
+  computeContourData: () => (/* reexport */ computeContourData),
+  computeLabelmapData: () => (/* reexport */ computeLabelmapData),
+  computeSurfaceData: () => (/* reexport */ computeSurfaceData),
+  init: () => (/* binding */ init),
+  updateSurfaceData: () => (/* reexport */ updateSurfaceData)
+});
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
+var esm = __webpack_require__(81985);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js
+var dist_esm = __webpack_require__(4667);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Contour/utils/extractContourData.js
+function extractContourData(polyDataCache) {
+    const rawResults = new Map();
+    for (const [segmentIndex, intersectionInfo] of polyDataCache) {
+        const segmentIndexNumber = Number(segmentIndex);
+        for (const [_, result] of intersectionInfo) {
+            if (!result) {
+                continue;
+            }
+            if (!rawResults.has(segmentIndexNumber)) {
+                rawResults.set(segmentIndexNumber, []);
+            }
+            rawResults.get(segmentIndexNumber).push(result);
+        }
+    }
+    return rawResults;
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Surface/convertContourToSurface.js
+
+
+const { WorkerTypes } = dist_esm.Enums;
+const { getAnnotation } = dist_esm.annotation.state;
+const workerManager = (0,esm.getWebWorkerManager)();
+const triggerWorkerProgress = (eventTarget, progress, id) => {
+    (0,esm.triggerEvent)(eventTarget, esm.Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: WorkerTypes.POLYSEG_CONTOUR_TO_SURFACE,
+        id,
+    });
+};
+async function convertContourToSurface(contourRepresentationData, segmentIndex) {
+    const { annotationUIDsMap } = contourRepresentationData;
+    const polylines = [];
+    const numPointsArray = [];
+    const annotationUIDs = annotationUIDsMap.get(segmentIndex);
+    for (const annotationUID of annotationUIDs) {
+        const annotation = getAnnotation(annotationUID);
+        const { polyline } = annotation.data.contour;
+        numPointsArray.push(polyline.length);
+        polyline.forEach((polyline) => polylines.push(...polyline));
+    }
+    triggerWorkerProgress(esm.eventTarget, 0, segmentIndex);
+    const results = await workerManager.executeTask('polySeg', 'convertContourToSurface', {
+        polylines,
+        numPointsArray,
+    }, {
+        callbacks: [
+            (progress) => {
+                triggerWorkerProgress(esm.eventTarget, progress, segmentIndex);
+            },
+        ],
+    });
+    triggerWorkerProgress(esm.eventTarget, 100, segmentIndex);
+    return results;
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Surface/createAndCacheSurfacesFromRaw.js
+
+
+const { getSegmentation } = dist_esm.segmentation.state;
+const { getSegmentIndexColor } = dist_esm.segmentation.config.color;
+async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
+    const segmentation = getSegmentation(segmentationId);
+    const geometryIds = new Map();
+    const promises = Object.keys(rawSurfacesData).map(async (index) => {
+        const rawSurfaceData = rawSurfacesData[index];
+        const segmentIndex = rawSurfaceData.segmentIndex;
+        const color = getSegmentIndexColor(options.viewport.id, segmentation.segmentationId, segmentIndex).slice(0, 3);
+        if (!color) {
+            throw new Error('No color found for segment index, unable to create surface');
+        }
+        const closedSurface = {
+            id: `segmentation_${segmentation.segmentationId}_surface_${segmentIndex}`,
+            color,
+            frameOfReferenceUID: 'test-frameOfReferenceUID',
+            points: rawSurfaceData.data.points,
+            polys: rawSurfaceData.data.polys,
+            segmentIndex,
+        };
+        const geometryId = closedSurface.id;
+        geometryIds.set(segmentIndex, geometryId);
+        return esm.geometryLoader.createAndCacheGeometry(geometryId, {
+            type: esm.Enums.GeometryType.SURFACE,
+            geometryData: closedSurface,
+        });
+    });
+    await Promise.all(promises);
+    return {
+        geometryIds,
+    };
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Surface/convertLabelmapToSurface.js
+
+
+const { WorkerTypes: convertLabelmapToSurface_WorkerTypes } = dist_esm.Enums;
+const { computeVolumeLabelmapFromStack } = dist_esm.utilities.segmentation;
+const convertLabelmapToSurface_workerManager = (0,esm.getWebWorkerManager)();
+const convertLabelmapToSurface_triggerWorkerProgress = (eventTarget, progress, id) => {
+    (0,esm.triggerEvent)(eventTarget, esm.Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: convertLabelmapToSurface_WorkerTypes.POLYSEG_LABELMAP_TO_SURFACE,
+        id,
+    });
+};
+async function convertLabelmapToSurface(labelmapRepresentationData, segmentIndex) {
+    let volumeId;
+    if (labelmapRepresentationData
+        .volumeId) {
+        volumeId = labelmapRepresentationData.volumeId;
+    }
+    else {
+        const { imageIds } = labelmapRepresentationData;
+        ({ volumeId } = await computeVolumeLabelmapFromStack({
+            imageIds,
+        }));
+    }
+    const volume = esm.cache.getVolume(volumeId);
+    const scalarData = volume.voxelManager.getCompleteScalarDataArray();
+    const { dimensions, spacing, origin, direction } = volume;
+    convertLabelmapToSurface_triggerWorkerProgress(esm.eventTarget, 0, segmentIndex);
+    const results = await convertLabelmapToSurface_workerManager.executeTask('polySeg', 'convertLabelmapToSurface', {
+        scalarData,
+        dimensions,
+        spacing,
+        origin,
+        direction,
+        segmentIndex,
+    }, {
+        callbacks: [
+            (progress) => {
+                convertLabelmapToSurface_triggerWorkerProgress(esm.eventTarget, progress, segmentIndex);
+            },
+        ],
+    });
+    convertLabelmapToSurface_triggerWorkerProgress(esm.eventTarget, 100, segmentIndex);
+    return results;
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Surface/surfaceComputationStrategies.js
+
+
+
+
+const { getUniqueSegmentIndices } = dist_esm.utilities.segmentation;
+const { getSegmentation: surfaceComputationStrategies_getSegmentation } = dist_esm.segmentation.state;
+async function computeSurfaceData(segmentationId, options = {}) {
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    let rawSurfacesData;
+    const segmentation = surfaceComputationStrategies_getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    try {
+        if (representationData.Contour) {
+            rawSurfacesData = await computeSurfaceFromContourSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+        else if (representationData.Labelmap) {
+            rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(segmentation.segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    if (!rawSurfacesData) {
+        throw new Error('Not enough data to convert to surface, currently only support converting volume labelmap to surface if available');
+    }
+    const surfacesData = await createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options);
+    return surfacesData;
+}
+async function computeSurfaceFromLabelmapSegmentation(segmentationId, options = {}) {
+    const segmentation = surfaceComputationStrategies_getSegmentation(segmentationId);
+    if (!segmentation?.representationData?.Labelmap) {
+        console.warn('Only support surface update from labelmaps');
+        return;
+    }
+    const labelmapRepresentationData = segmentation.representationData.Labelmap;
+    const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
+    const promises = segmentIndices.map((index) => {
+        const surface = convertLabelmapToSurface(labelmapRepresentationData, index);
+        return surface;
+    });
+    const surfaces = await Promise.allSettled(promises);
+    const errors = surfaces.filter((p) => p.status === 'rejected');
+    if (errors.length > 0) {
+        console.error(errors);
+        throw new Error('Failed to convert labelmap to surface');
+    }
+    const rawSurfacesData = surfaces
+        .map((surface, index) => {
+        if (surface.status === 'fulfilled') {
+            return { segmentIndex: segmentIndices[index], data: surface.value };
+        }
+    })
+        .filter(Boolean);
+    return rawSurfacesData;
+}
+async function computeSurfaceFromContourSegmentation(segmentationId, options = {}) {
+    const segmentation = surfaceComputationStrategies_getSegmentation(segmentationId);
+    const contourRepresentationData = segmentation.representationData.Contour;
+    const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
+    const promises = segmentIndices.map(async (index) => {
+        const surface = await convertContourToSurface(contourRepresentationData, index);
+        return { segmentIndex: index, data: surface };
+    });
+    const surfaces = await Promise.all(promises);
+    return surfaces;
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/registerPolySegWorker.js
+
+let registered = false;
+function registerPolySegWorker() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    const workerFn = () => {
+        return new Worker(new URL(/* worker import */ __webpack_require__.p + __webpack_require__.u(572), __webpack_require__.b), {
+            name: 'polySeg',
+            type: undefined,
+        });
+    };
+    const workerManager = (0,esm.getWebWorkerManager)();
+    const options = {
+        maxWorkerInstances: 1,
+        autoTerminateOnIdle: {
+            enabled: true,
+            idleTimeThreshold: 2000,
+        },
+    };
+    workerManager.registerWorker('polySeg', workerFn, options);
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/utilities/clipAndCacheSurfacesForViewport.js
+
+
+
+const clipAndCacheSurfacesForViewport_workerManager = (0,esm.getWebWorkerManager)();
+const { WorkerTypes: clipAndCacheSurfacesForViewport_WorkerTypes } = dist_esm.Enums;
+const { pointToString } = dist_esm.utilities;
+const polyDataCache = new Map();
+const surfacesAABBCache = new Map();
+const clipAndCacheSurfacesForViewport_triggerWorkerProgress = (eventTarget, progress) => {
+    (0,esm.triggerEvent)(eventTarget, esm.Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: clipAndCacheSurfacesForViewport_WorkerTypes.SURFACE_CLIPPING,
+    });
+};
+async function clipAndCacheSurfacesForViewport(surfacesInfo, viewport) {
+    registerPolySegWorker();
+    const planesInfo = viewport.getSlicesClippingPlanes?.();
+    if (!planesInfo) {
+        return;
+    }
+    const currentSliceIndex = viewport.getSliceIndex();
+    planesInfo.sort((a, b) => {
+        const diffA = Math.abs(a.sliceIndex - currentSliceIndex);
+        const diffB = Math.abs(b.sliceIndex - currentSliceIndex);
+        return diffA - diffB;
+    });
+    clipAndCacheSurfacesForViewport_triggerWorkerProgress(esm.eventTarget, 0);
+    await updateSurfacesAABBCache(surfacesInfo);
+    const surfacesAABB = new Map();
+    surfacesInfo.forEach((surface) => {
+        surfacesAABB.set(surface.id, surfacesAABBCache.get(surface.id));
+    });
+    const camera = viewport.getCamera();
+    await clipAndCacheSurfacesForViewport_workerManager
+        .executeTask('polySeg', 'cutSurfacesIntoPlanes', {
+        surfacesInfo,
+        planesInfo,
+        surfacesAABB,
+    }, {
+        callbacks: [
+            ({ progress }) => {
+                clipAndCacheSurfacesForViewport_triggerWorkerProgress(esm.eventTarget, progress);
+            },
+            ({ sliceIndex, polyDataResults }) => {
+                polyDataResults.forEach((polyDataResult, segmentIndex) => {
+                    const segmentIndexNumber = Number(segmentIndex);
+                    const cacheId = generateCacheId(viewport, camera.viewPlaneNormal, sliceIndex);
+                    updatePolyDataCache(segmentIndexNumber, cacheId, polyDataResult);
+                });
+            },
+        ],
+    })
+        .catch((error) => {
+        console.error(error);
+    });
+    clipAndCacheSurfacesForViewport_triggerWorkerProgress(esm.eventTarget, 100);
+    return polyDataCache;
+}
+async function updateSurfacesAABBCache(surfacesInfo) {
+    const surfacesWithoutAABB = surfacesInfo.filter((surface) => !surfacesAABBCache.has(surface.id));
+    if (!surfacesWithoutAABB.length) {
+        return;
+    }
+    const surfacesAABB = await clipAndCacheSurfacesForViewport_workerManager.executeTask('polySeg', 'getSurfacesAABBs', {
+        surfacesInfo: surfacesWithoutAABB,
+    }, {
+        callbacks: [
+            ({ progress }) => {
+                clipAndCacheSurfacesForViewport_triggerWorkerProgress(esm.eventTarget, progress);
+            },
+        ],
+    });
+    surfacesAABB.forEach((aabb, id) => {
+        surfacesAABBCache.set(id, aabb);
+    });
+}
+function generateCacheId(viewport, viewPlaneNormal, sliceIndex) {
+    return `${viewport.id}-${pointToString(viewPlaneNormal)}-${sliceIndex}`;
+}
+function updatePolyDataCache(segmentIndex, cacheId, polyDataResult) {
+    const { points, lines, numberOfCells } = polyDataResult;
+    let segmentCache = polyDataCache.get(segmentIndex);
+    if (!segmentCache) {
+        segmentCache = new Map();
+        polyDataCache.set(segmentIndex, segmentCache);
+    }
+    segmentCache.set(cacheId, { points, lines, numberOfCells });
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.js
+
+
+const { addAnnotation } = dist_esm.annotation.state;
+function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId) {
+    const annotationUIDsMap = new Map();
+    for (const [segmentIndex, contoursData] of rawContourData) {
+        for (const contourData of contoursData) {
+            const { points } = contourData;
+            const { lineSegments, linesNumberOfPoints } = _extractLineSegments(contourData);
+            for (let i = 0; i < lineSegments.length; i++) {
+                const line = lineSegments[i];
+                const polyline = [];
+                for (let j = 0; j < linesNumberOfPoints[i]; j++) {
+                    const pointIndex = line[j];
+                    polyline.push([
+                        points[3 * pointIndex],
+                        points[3 * pointIndex + 1],
+                        points[3 * pointIndex + 2],
+                    ]);
+                }
+                if (polyline.length < 3) {
+                    continue;
+                }
+                const contourSegmentationAnnotation = {
+                    annotationUID: esm.utilities.uuidv4(),
+                    data: {
+                        contour: {
+                            closed: true,
+                            polyline,
+                        },
+                        segmentation: {
+                            segmentationId,
+                            segmentIndex,
+                        },
+                        handles: {},
+                    },
+                    handles: {},
+                    highlighted: false,
+                    autoGenerated: false,
+                    invalidated: false,
+                    isLocked: false,
+                    isVisible: true,
+                    metadata: {
+                        toolName: dist_esm.PlanarFreehandContourSegmentationTool.toolName,
+                        ...viewport.getViewReference(),
+                    },
+                };
+                addAnnotation(contourSegmentationAnnotation, viewport.element);
+                const currentSet = annotationUIDsMap?.get(segmentIndex) || new Set();
+                currentSet.add(contourSegmentationAnnotation.annotationUID);
+                annotationUIDsMap.set(segmentIndex, currentSet);
+            }
+        }
+    }
+    return annotationUIDsMap;
+}
+const _extractLineSegments = (contourData) => {
+    const { numberOfCells, lines } = contourData;
+    const lineSegments = [];
+    const linesNumberOfPoints = [];
+    for (let i = 0; i < lines.length;) {
+        const pointsInLine = lines[i];
+        linesNumberOfPoints.push(pointsInLine);
+        lineSegments.push(lines.slice(i + 1, i + pointsInLine + 1));
+        i += pointsInLine + 1;
+        if (lineSegments.length === numberOfCells) {
+            break;
+        }
+    }
+    return { lineSegments, linesNumberOfPoints };
+};
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Contour/contourComputationStrategies.js
+
+
+
+
+
+
+const { getUniqueSegmentIndices: contourComputationStrategies_getUniqueSegmentIndices } = dist_esm.utilities.segmentation;
+const { getSegmentation: contourComputationStrategies_getSegmentation } = dist_esm.segmentation.state;
+const { segmentationStyle } = dist_esm.segmentation;
+const { SegmentationRepresentations } = dist_esm.Enums;
+async function computeContourData(segmentationId, options = {}) {
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : contourComputationStrategies_getUniqueSegmentIndices(segmentationId);
+    let rawContourData;
+    const segmentation = contourComputationStrategies_getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    try {
+        if (representationData.Surface) {
+            rawContourData = await computeContourFromSurfaceSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+        else if (representationData.Labelmap) {
+            rawContourData = await computeContourFromLabelmapSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    if (!rawContourData) {
+        throw new Error('Not enough data to convert to contour, currently only support converting volume labelmap to contour if available');
+    }
+    const { viewport } = options;
+    const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
+    segmentationStyle.setStyle({ segmentationId, type: SegmentationRepresentations.Contour }, {
+        fillAlpha: 0,
+    });
+    return {
+        annotationUIDsMap,
+    };
+}
+async function computeContourFromLabelmapSegmentation(segmentationId, options = {}) {
+    if (!options.viewport) {
+        throw new Error('Viewport is required to compute contour from labelmap');
+    }
+    const results = await computeSurfaceFromLabelmapSegmentation(segmentationId, options);
+    if (!results?.length) {
+        console.error('Failed to convert labelmap to surface or labelmap is empty');
+        return;
+    }
+    const { viewport } = options;
+    const pointsAndPolys = results.map((surface) => {
+        return {
+            id: surface.segmentIndex.toString(),
+            points: surface.data.points,
+            polys: surface.data.polys,
+            segmentIndex: surface.segmentIndex,
+        };
+    });
+    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport);
+    const rawResults = extractContourData(polyDataCache);
+    return rawResults;
+}
+async function computeContourFromSurfaceSegmentation(segmentationId, options = {}) {
+    if (!options.viewport) {
+        throw new Error('Viewport is required to compute contour from surface');
+    }
+    const { viewport } = options;
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : contourComputationStrategies_getUniqueSegmentIndices(segmentationId);
+    const segmentIndexToSurfaceId = new Map();
+    const surfaceIdToSegmentIndex = new Map();
+    const segmentation = contourComputationStrategies_getSegmentation(segmentationId);
+    const representationData = segmentation.representationData.Surface;
+    const surfacesInfo = [];
+    representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+        if (segmentIndices.includes(segmentIndex)) {
+            segmentIndexToSurfaceId.set(segmentIndex, geometryId);
+            const surface = esm.cache.getGeometry(geometryId)?.data;
+            if (surface) {
+                surfacesInfo.push({
+                    id: geometryId,
+                    points: surface.points,
+                    polys: surface.polys,
+                    segmentIndex,
+                });
+            }
+        }
+    });
+    segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
+        surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
+    });
+    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport);
+    const rawResults = extractContourData(polyDataCache);
+    return rawResults;
+}
+
+
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js
+var gl_matrix_esm = __webpack_require__(40230);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Labelmap/convertContourToLabelmap.js
+
+
+
+const { WorkerTypes: convertContourToLabelmap_WorkerTypes } = dist_esm.Enums;
+const { getAnnotation: convertContourToLabelmap_getAnnotation } = dist_esm.annotation.state;
+const convertContourToLabelmap_workerManager = (0,esm.getWebWorkerManager)();
+const convertContourToLabelmap_triggerWorkerProgress = (eventTarget, progress) => {
+    (0,esm.triggerEvent)(eventTarget, esm.Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: convertContourToLabelmap_WorkerTypes.POLYSEG_CONTOUR_TO_LABELMAP,
+    });
+};
+async function convertContourToVolumeLabelmap(contourRepresentationData, options = {}) {
+    const viewport = options.viewport;
+    const volumeId = viewport.getVolumeId();
+    const imageIds = esm.utilities.getViewportImageIds(viewport);
+    if (!imageIds) {
+        throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
+    }
+    const segmentationVolumeId = esm.utilities.uuidv4();
+    const segmentationVolume = esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
+        volumeId: segmentationVolumeId,
+    });
+    const { dimensions, origin, direction, spacing, voxelManager } = segmentationVolume;
+    const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
+    convertContourToLabelmap_triggerWorkerProgress(esm.eventTarget, 0);
+    const newScalarData = await convertContourToLabelmap_workerManager.executeTask('polySeg', 'convertContourToVolumeLabelmap', {
+        segmentIndices,
+        dimensions,
+        scalarData: voxelManager.getCompleteScalarDataArray?.(),
+        origin,
+        direction,
+        spacing,
+        annotationUIDsInSegmentMap,
+    }, {
+        callbacks: [
+            (progress) => {
+                convertContourToLabelmap_triggerWorkerProgress(esm.eventTarget, progress);
+            },
+        ],
+    });
+    convertContourToLabelmap_triggerWorkerProgress(esm.eventTarget, 100);
+    voxelManager.setCompleteScalarDataArray(newScalarData);
+    segmentationVolume.modified();
+    return {
+        volumeId: segmentationVolume.volumeId,
+    };
+}
+async function convertContourToStackLabelmap(contourRepresentationData, options = {}) {
+    if (!options.viewport) {
+        throw new Error('No viewport provided, labelmap computation from contour requires viewports');
+    }
+    const viewport = options.viewport;
+    const imageIds = viewport.getImageIds();
+    if (!imageIds) {
+        throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
+    }
+    imageIds.forEach((imageId) => {
+        if (!esm.cache.getImageLoadObject(imageId)) {
+            throw new Error('ImageIds must be cached before converting contour to labelmap');
+        }
+    });
+    const segImages = await esm.imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
+    const segmentationImageIds = segImages.map((it) => it.imageId);
+    const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
+    const segmentationsInfo = new Map();
+    segmentationImageIds.forEach((segImageId, index) => {
+        const segImage = esm.cache.getImage(segImageId);
+        const imagePlaneModule = esm.metaData.get(esm.Enums.MetadataModules.IMAGE_PLANE, segImageId);
+        let { columnCosines, rowCosines, rowPixelSpacing, columnPixelSpacing, imagePositionPatient, } = imagePlaneModule;
+        columnCosines = columnCosines ?? [0, 1, 0];
+        rowCosines = rowCosines ?? [1, 0, 0];
+        rowPixelSpacing = rowPixelSpacing ?? 1;
+        columnPixelSpacing = columnPixelSpacing ?? 1;
+        imagePositionPatient = imagePositionPatient ?? [0, 0, 0];
+        const rowCosineVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+        const colCosineVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+        const scanAxisNormal = gl_matrix_esm/* vec3.create */.eR.create();
+        gl_matrix_esm/* vec3.cross */.eR.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+        const direction = [...rowCosineVec, ...colCosineVec, ...scanAxisNormal];
+        const spacing = [rowPixelSpacing, columnPixelSpacing, 1];
+        const origin = imagePositionPatient;
+        segmentationsInfo.set(imageIds[index], {
+            direction,
+            spacing,
+            origin,
+            scalarData: segImage.voxelManager.getScalarData(),
+            imageId: segImageId,
+            dimensions: [segImage.width, segImage.height, 1],
+        });
+    });
+    convertContourToLabelmap_triggerWorkerProgress(esm.eventTarget, 0);
+    const newSegmentationsScalarData = await convertContourToLabelmap_workerManager.executeTask('polySeg', 'convertContourToStackLabelmap', {
+        segmentationsInfo,
+        annotationUIDsInSegmentMap,
+        segmentIndices,
+    }, {
+        callbacks: [
+            (progress) => {
+                convertContourToLabelmap_triggerWorkerProgress(esm.eventTarget, progress);
+            },
+        ],
+    });
+    convertContourToLabelmap_triggerWorkerProgress(esm.eventTarget, 100);
+    const segImageIds = [];
+    newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {
+        const segmentationInfo = segmentationsInfo.get(referencedImageId);
+        const { imageId: segImageId } = segmentationInfo;
+        const segImage = esm.cache.getImage(segImageId);
+        segImage.voxelManager.getScalarData().set(scalarData);
+        segImage.imageFrame?.pixelData?.set(scalarData);
+        segImageIds.push(segImageId);
+    });
+    return {
+        imageIds: segImageIds,
+    };
+}
+function _getAnnotationMapFromSegmentation(contourRepresentationData, options = {}) {
+    const annotationMap = contourRepresentationData.annotationUIDsMap;
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : Array.from(annotationMap.keys());
+    const annotationUIDsInSegmentMap = new Map();
+    segmentIndices.forEach((index) => {
+        const annotationUIDsInSegment = annotationMap.get(index);
+        let uids = Array.from(annotationUIDsInSegment);
+        uids = uids.filter((uid) => !convertContourToLabelmap_getAnnotation(uid).parentAnnotationUID);
+        const annotations = uids.map((uid) => {
+            const annotation = convertContourToLabelmap_getAnnotation(uid);
+            const hasChildAnnotations = annotation.childAnnotationUIDs?.length;
+            return {
+                polyline: annotation.data.contour.polyline,
+                referencedImageId: annotation.metadata.referencedImageId,
+                holesPolyline: hasChildAnnotations &&
+                    annotation.childAnnotationUIDs.map((childUID) => {
+                        const childAnnotation = convertContourToLabelmap_getAnnotation(childUID);
+                        return childAnnotation.data.contour.polyline;
+                    }),
+            };
+        });
+        annotationUIDsInSegmentMap.set(index, annotations);
+    });
+    return { segmentIndices, annotationUIDsInSegmentMap };
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Labelmap/convertSurfaceToLabelmap.js
+
+
+const { WorkerTypes: convertSurfaceToLabelmap_WorkerTypes } = dist_esm.Enums;
+const convertSurfaceToLabelmap_workerManager = (0,esm.getWebWorkerManager)();
+const convertSurfaceToLabelmap_triggerWorkerProgress = (eventTarget, progress) => {
+    (0,esm.triggerEvent)(eventTarget, esm.Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: convertSurfaceToLabelmap_WorkerTypes.POLYSEG_SURFACE_TO_LABELMAP,
+    });
+};
+async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData, segmentationVolume) {
+    const { geometryIds } = surfaceRepresentationData;
+    if (!geometryIds?.size) {
+        throw new Error('No geometry IDs found for surface representation');
+    }
+    const segmentsInfo = new Map();
+    geometryIds.forEach((geometryId, segmentIndex) => {
+        const geometry = esm.cache.getGeometry(geometryId);
+        const geometryData = geometry.data;
+        const points = geometryData.points;
+        const polys = geometryData.polys;
+        segmentsInfo.set(segmentIndex, {
+            points,
+            polys,
+        });
+    });
+    const { dimensions, direction, origin, spacing, voxelManager } = segmentationVolume;
+    convertSurfaceToLabelmap_triggerWorkerProgress(esm.eventTarget, 0);
+    const newScalarData = await convertSurfaceToLabelmap_workerManager.executeTask('polySeg', 'convertSurfacesToVolumeLabelmap', {
+        segmentsInfo,
+        dimensions,
+        spacing,
+        direction,
+        origin,
+    }, {
+        callbacks: [
+            (progress) => {
+                convertSurfaceToLabelmap_triggerWorkerProgress(esm.eventTarget, progress);
+            },
+        ],
+    });
+    convertSurfaceToLabelmap_triggerWorkerProgress(esm.eventTarget, 100);
+    voxelManager.setCompleteScalarDataArray(newScalarData);
+    segmentationVolume.modified();
+    return {
+        volumeId: segmentationVolume.volumeId,
+    };
+}
+async function convertSurfaceToStackLabelmap() {
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Labelmap/labelmapComputationStrategies.js
+
+
+
+
+
+const { computeStackLabelmapFromVolume, getUniqueSegmentIndices: labelmapComputationStrategies_getUniqueSegmentIndices } = dist_esm.utilities.segmentation;
+const { getSegmentation: labelmapComputationStrategies_getSegmentation } = dist_esm.segmentation.state;
+async function computeLabelmapData(segmentationId, options = {}) {
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : labelmapComputationStrategies_getUniqueSegmentIndices(segmentationId);
+    let rawLabelmapData;
+    const segmentation = labelmapComputationStrategies_getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    try {
+        if (representationData.Contour) {
+            rawLabelmapData = await computeLabelmapFromContourSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+        else if (representationData.Surface) {
+            rawLabelmapData = await computeLabelmapFromSurfaceSegmentation(segmentation.segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    if (!rawLabelmapData) {
+        throw new Error('Not enough data to convert to surface, currently only support converting volume labelmap to surface if available');
+    }
+    return rawLabelmapData;
+}
+async function computeLabelmapFromContourSegmentation(segmentationId, options = {}) {
+    const isVolume = options.viewport
+        ? options.viewport instanceof esm.VolumeViewport
+        : true;
+    if (isVolume && !options.viewport) {
+        throw new Error('Cannot compute labelmap from contour segmentation without providing the viewport');
+    }
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : labelmapComputationStrategies_getUniqueSegmentIndices(segmentationId);
+    const segmentation = labelmapComputationStrategies_getSegmentation(segmentationId);
+    const representationData = segmentation.representationData.Contour;
+    const convertFunction = isVolume
+        ? convertContourToVolumeLabelmap
+        : convertContourToStackLabelmap;
+    const result = await convertFunction(representationData, {
+        segmentIndices,
+        viewport: options.viewport,
+    });
+    return result;
+}
+async function computeLabelmapFromSurfaceSegmentation(segmentationId, options = {}) {
+    const { viewport } = options;
+    const isVolume = viewport ? viewport instanceof esm.VolumeViewport : true;
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : labelmapComputationStrategies_getUniqueSegmentIndices(segmentationId);
+    const segmentation = labelmapComputationStrategies_getSegmentation(segmentationId);
+    const segmentsGeometryIds = new Map();
+    const representationData = segmentation.representationData.Surface;
+    representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+        if (segmentIndices.includes(segmentIndex)) {
+            segmentsGeometryIds.set(segmentIndex, geometryId);
+        }
+    });
+    if (isVolume && !viewport) {
+        throw new Error('Cannot compute labelmap from surface segmentation without providing the viewport');
+    }
+    let segmentationVolume;
+    if (isVolume) {
+        const volumeId = viewport.getVolumeId();
+        segmentationVolume =
+            esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
+    }
+    else {
+        const imageIds = options.viewport.getImageIds();
+        const segImages = esm.imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
+        const segImageIds = segImages.map((image) => image.imageId);
+        segmentationVolume = await esm.volumeLoader.createAndCacheVolumeFromImages('generatedSegmentationVolumeId', segImageIds);
+    }
+    const result = await convertSurfaceToVolumeLabelmap({ geometryIds: segmentsGeometryIds }, segmentationVolume);
+    if (isVolume) {
+        return result;
+    }
+    const stackData = (await computeStackLabelmapFromVolume({
+        volumeId: segmentationVolume.volumeId,
+    }));
+    return stackData;
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/canComputeRequestedRepresentation.js
+
+const { SegmentationRepresentations: canComputeRequestedRepresentation_SegmentationRepresentations } = dist_esm.Enums;
+const { getSegmentation: canComputeRequestedRepresentation_getSegmentation } = dist_esm.segmentation.state;
+const { validateLabelmap } = dist_esm.utilities.segmentation;
+const conversionPaths = new Map([
+    [
+        canComputeRequestedRepresentation_SegmentationRepresentations.Labelmap,
+        new Set([
+            canComputeRequestedRepresentation_SegmentationRepresentations.Surface,
+            canComputeRequestedRepresentation_SegmentationRepresentations.Contour,
+        ]),
+    ],
+    [
+        canComputeRequestedRepresentation_SegmentationRepresentations.Contour,
+        new Set([
+            canComputeRequestedRepresentation_SegmentationRepresentations.Labelmap,
+            canComputeRequestedRepresentation_SegmentationRepresentations.Surface,
+        ]),
+    ],
+    [
+        canComputeRequestedRepresentation_SegmentationRepresentations.Surface,
+        new Set([canComputeRequestedRepresentation_SegmentationRepresentations.Labelmap]),
+    ],
+]);
+function canComputeRequestedRepresentation(segmentationId, type) {
+    const { representationData } = canComputeRequestedRepresentation_getSegmentation(segmentationId);
+    const existingRepresentationTypes = getExistingRepresentationTypes(representationData);
+    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, type));
+}
+function getExistingRepresentationTypes(representationData) {
+    const supportedTypes = [];
+    Object.keys(representationData).forEach((representationType) => {
+        const representationTypeData = representationData[representationType];
+        let validateFn;
+        switch (representationType) {
+            case canComputeRequestedRepresentation_SegmentationRepresentations.Labelmap:
+                validateFn = validateLabelmap.validate;
+                break;
+        }
+        if (validateFn) {
+            try {
+                validateFn(representationTypeData);
+                supportedTypes.push(representationType);
+            }
+            catch (error) {
+                console.warn(`Validation failed for labelmap of type ${representationType}`);
+            }
+        }
+        else {
+            supportedTypes.push(representationType);
+        }
+    });
+    return supportedTypes;
+}
+async function canConvertFromTo(fromRepresentationType, toRepresentationType) {
+    return (conversionPaths.get(fromRepresentationType)?.has(toRepresentationType) ||
+        false);
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/Surface/updateSurfaceData.js
+
+
+
+
+const { utilities: { segmentation: { getUniqueSegmentIndices: updateSurfaceData_getUniqueSegmentIndices }, }, segmentation: { state: { getViewportIdsWithSegmentation, getSegmentation: updateSurfaceData_getSegmentation, getSegmentationRepresentation, }, triggerSegmentationEvents: { triggerSegmentationModified }, }, Enums: { SegmentationRepresentations: updateSurfaceData_SegmentationRepresentations }, } = dist_esm;
+async function updateSurfaceData(segmentationId) {
+    const surfacesObj = await computeSurfaceFromLabelmapSegmentation(segmentationId);
+    if (!surfacesObj) {
+        return;
+    }
+    const segmentation = updateSurfaceData_getSegmentation(segmentationId);
+    const indices = updateSurfaceData_getUniqueSegmentIndices(segmentationId);
+    if (!indices.length) {
+        const geometryIds = segmentation.representationData.Surface.geometryIds;
+        geometryIds.forEach((geometryId) => {
+            const geometry = esm.cache.getGeometry(geometryId);
+            const surface = geometry.data;
+            surface.points = [];
+            surface.polys = [];
+        });
+        triggerSegmentationModified(segmentationId);
+        return;
+    }
+    const promises = surfacesObj.map(({ data, segmentIndex }) => {
+        const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
+        const geometry = esm.cache.getGeometry(geometryId);
+        if (!geometry) {
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+            return viewportIds.map((viewportId) => {
+                const surfaceRepresentation = getSegmentationRepresentation(viewportId, {
+                    segmentationId,
+                    type: updateSurfaceData_SegmentationRepresentations.Surface,
+                });
+                return [surfaceRepresentation].map((surfaceRepresentation) => {
+                    segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
+                    return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
+                        segmentationId: surfaceRepresentation.segmentationId,
+                    });
+                });
+            });
+        }
+        else if (indices.includes(segmentIndex)) {
+            const surface = geometry.data;
+            surface.points = data.points;
+            surface.polys = data.polys;
+        }
+        else {
+            const surface = geometry.data;
+            surface.points = [];
+            surface.polys = [];
+        }
+    });
+    await Promise.all(promises);
+    triggerSegmentationModified(segmentationId);
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/index.js
+
+
+
+
+
+
+function init() {
+    registerPolySegWorker();
+}
+
+
+
 /***/ }),
 
 /***/ 91037: