@cornerstonejs/tools 2.0.0-beta.7 → 2.0.0

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.js

@@ -1,31 +1,70 @@
 import { SegmentationRepresentations } from '../../../enums';
+import { cache } from '@cornerstonejs/core';
 function normalizeSegmentationInput(segmentationInput) {
-    const { segmentationId, representation } = segmentationInput;
-    const isContourRepresentation = representation.type === SegmentationRepresentations.Contour;
-    let data = representation.data ? { ...representation.data } : null;
-    data = !data && isContourRepresentation ? {} : data;
+    const { segmentationId, representation, config } = segmentationInput;
+    const { type, data: inputData } = representation;
+    const data = inputData ? { ...inputData } : {};
     if (!data) {
         throw new Error('Segmentation representation data may not be undefined');
     }
-    if (isContourRepresentation) {
-        const contourData = data;
-        contourData.geometryIds = contourData.geometryIds ?? [];
-        contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
+    if (type === SegmentationRepresentations.Contour) {
+        normalizeContourData(data);
     }
+    const normalizedSegments = normalizeSegments(config?.segments, type, data);
     return {
         segmentationId,
-        cachedStats: {},
-        segmentLabels: {},
-        label: null,
-        segmentsLocked: new Set(),
-        type: representation.type,
-        activeSegmentIndex: 1,
+        label: config?.label ?? null,
+        cachedStats: config?.cachedStats ?? {},
+        segments: normalizedSegments,
         representationData: {
-            [representation.type]: {
+            [type]: {
                 ...data,
             },
         },
     };
 }
+function normalizeContourData(contourData) {
+    contourData.geometryIds = contourData.geometryIds ?? [];
+    contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
+}
+function normalizeSegments(segmentsConfig, type, data) {
+    const normalizedSegments = {};
+    if (segmentsConfig) {
+        Object.entries(segmentsConfig).forEach(([segmentIndex, segment]) => {
+            normalizedSegments[segmentIndex] = {
+                segmentIndex: Number(segmentIndex),
+                label: segment.label ?? `Segment ${segmentIndex}`,
+                locked: segment.locked ?? false,
+                cachedStats: segment.cachedStats ?? {},
+                active: segment.active ?? false,
+            };
+        });
+    }
+    else if (type === SegmentationRepresentations.Surface) {
+        normalizeSurfaceSegments(normalizedSegments, data);
+    }
+    else {
+        normalizedSegments[1] = createDefaultSegment();
+    }
+    return normalizedSegments;
+}
+function normalizeSurfaceSegments(normalizedSegments, surfaceData) {
+    const { geometryIds } = surfaceData;
+    geometryIds.forEach((geometryId) => {
+        const geometry = cache.getGeometry(geometryId);
+        if (geometry?.data) {
+            const { segmentIndex } = geometry.data;
+            normalizedSegments[segmentIndex] = { segmentIndex };
+        }
+    });
+}
+function createDefaultSegment() {
+    return {
+        segmentIndex: 1,
+        label: 'Segment 1',
+        locked: false,
+        cachedStats: {},
+        active: true,
+    };
+}
 export default normalizeSegmentationInput;
-//# sourceMappingURL=normalizeSegmentationInput.js.map

package/dist/esm/stateManagement/segmentation/helpers/updateStackSegmentationState.d.ts

@@ -0,0 +1,8 @@
+export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }: {
+    segmentationId: string;
+    viewportId: string;
+    imageIds: string[];
+    options?: {
+        removeOriginal?: boolean;
+    };
+}): Promise<void>;

package/dist/esm/stateManagement/segmentation/helpers/updateStackSegmentationState.js

@@ -0,0 +1,31 @@
+import { cache, eventTarget } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../getSegmentation';
+import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
+import { addSegmentationRepresentations } from '../addSegmentationRepresentationsToViewport';
+export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (options?.removeOriginal) {
+        const data = segmentation.representationData
+            .Labelmap;
+        if (cache.getVolume(data.volumeId)) {
+            cache.removeVolumeLoadObject(data.volumeId);
+        }
+        segmentation.representationData.Labelmap = {
+            imageIds,
+        };
+    }
+    else {
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
+            imageIds,
+        };
+    }
+    await addSegmentationRepresentations(viewportId, [
+        {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        },
+    ]);
+    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
+}

package/dist/esm/stateManagement/segmentation/helpers/validateSegmentationInput.d.ts

@@ -0,0 +1,3 @@
+import type { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+declare function validateSegmentationInput(segmentationInputArray: SegmentationPublicInput[]): void;
+export default validateSegmentationInput;

package/dist/esm/stateManagement/segmentation/helpers/validateSegmentationInput.js

@@ -18,4 +18,3 @@ function validateSegmentationInput(segmentationInputArray) {
     });
 }
 export default validateSegmentationInput;
-//# sourceMappingURL=validateSegmentationInput.js.map

package/dist/esm/stateManagement/segmentation/index.d.ts

@@ -0,0 +1,25 @@
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
+import { updateSegmentations } from './updateSegmentations';
+import * as activeSegmentation from './activeSegmentation';
+import * as segmentLocking from './segmentLocking';
+import * as state from './segmentationState';
+import * as config from './config';
+import * as segmentIndex from './segmentIndex';
+import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
+import * as polySegManager from './polySeg';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
+import { getLabelmapImageIds } from './getLabelmapImageIds';
+import { removeAllSegmentations, removeSegmentation } from './removeSegmentation';
+declare const helpers: {
+    clearSegmentValue: typeof clearSegmentValue;
+    convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
+    computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
+    convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, };

package/dist/esm/stateManagement/segmentation/index.js

@@ -1,15 +1,25 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
-import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
-import addRepresentationData from './addRepresentationData';
-import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
-import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
+import { updateSegmentations } from './updateSegmentations';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
 import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addSegmentationRepresentations, removeSegmentationsFromToolGroup, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
-//# sourceMappingURL=index.js.map
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
+import { getLabelmapImageIds } from './getLabelmapImageIds';
+import { removeAllSegmentations, removeSegmentation, } from './removeSegmentation';
+const helpers = {
+    clearSegmentValue,
+    convertStackToVolumeLabelmap,
+    computeVolumeLabelmapFromStack,
+    convertVolumeToStackLabelmap,
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, };

package/dist/esm/stateManagement/segmentation/internalAddRepresentationData.d.ts

@@ -0,0 +1,12 @@
+import type { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import type { ContourSegmentationData } from '../../types/ContourTypes';
+import type { SurfaceSegmentationData } from '../../types/SurfaceTypes';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+type SegmentationData = LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
+type AddRepresentationData = {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+    data: SegmentationData;
+};
+declare function internalAddRepresentationData({ segmentationId, type, data, }: AddRepresentationData): void;
+export default internalAddRepresentationData;

package/dist/esm/stateManagement/segmentation/internalAddRepresentationData.js

@@ -0,0 +1,32 @@
+import { getSegmentation } from './getSegmentation';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+function internalAddRepresentationData({ segmentationId, type, data, }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        throw new Error(`Segmentation ${segmentationId} not found`);
+    }
+    if (segmentation.representationData[type]) {
+        console.warn(`Representation data of type ${type} already exists for segmentation ${segmentationId}, overwriting it.`);
+    }
+    switch (type) {
+        case SegmentationRepresentations.Labelmap:
+            if (data) {
+                segmentation.representationData[type] =
+                    data;
+            }
+            break;
+        case SegmentationRepresentations.Contour:
+            if (data) {
+                segmentation.representationData[type] = data;
+            }
+            break;
+        case SegmentationRepresentations.Surface:
+            if (data) {
+                segmentation.representationData[type] = data;
+            }
+            break;
+        default:
+            throw new Error(`Invalid representation type ${type}`);
+    }
+}
+export default internalAddRepresentationData;

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.d.ts

@@ -0,0 +1,3 @@
+import type { RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function internalAddSegmentationRepresentation(viewportId: string, representationInput: RepresentationPublicInput): void;
+export { internalAddSegmentationRepresentation };

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -0,0 +1,34 @@
+import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { SegmentationRepresentations } from '../../enums';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import { addColorLUT } from './addColorLUT';
+import { getNextColorLUTIndex } from './getNextColorLUTIndex';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getColorLUT } from './getColorLUT';
+function internalAddSegmentationRepresentation(viewportId, representationInput) {
+    const { segmentationId, config } = representationInput;
+    const renderingConfig = {
+        colorLUTIndex: getColorLUTIndex(config),
+    };
+    defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
+    if (representationInput.type === SegmentationRepresentations.Contour) {
+        triggerAnnotationRenderForViewportIds([viewportId]);
+    }
+    triggerSegmentationModified(segmentationId);
+}
+function getColorLUTIndex(config) {
+    const { colorLUTOrIndex } = config || {};
+    const isIndexProvided = typeof colorLUTOrIndex === 'number';
+    const selectedColorLUT = isIndexProvided
+        ? getColorLUT(colorLUTOrIndex)
+        : CORNERSTONE_COLOR_LUT;
+    const colorLUTIndex = isIndexProvided
+        ? colorLUTOrIndex
+        : getNextColorLUTIndex();
+    if (!isIndexProvided) {
+        addColorLUT(selectedColorLUT, colorLUTIndex);
+    }
+    return colorLUTIndex;
+}
+export { internalAddSegmentationRepresentation };

package/dist/esm/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.d.ts

@@ -0,0 +1,4 @@
+import type { PolySegConversionOptions } from '../../../../types';
+export declare function computeAndAddContourRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<{
+    annotationUIDsMap: Map<number, Set<string>>;
+}>;

package/dist/esm/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.js

@@ -4,4 +4,3 @@ import { computeContourData } from './contourComputationStrategies';
 export function computeAndAddContourRepresentation(segmentationId, options = {}) {
     return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Contour, () => computeContourData(segmentationId, options), () => undefined);
 }
-//# sourceMappingURL=computeAndAddContourRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.d.ts

@@ -0,0 +1,8 @@
+import type { PolySegConversionOptions } from '../../../../types';
+import type { SurfaceClipResult } from '../../helpers/clipAndCacheSurfacesForViewport';
+export type RawContourData = Map<number, SurfaceClipResult[]>;
+export declare function computeContourData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
+    annotationUIDsMap: Map<number, Set<string>>;
+}>;
+declare function computeContourFromLabelmapSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<RawContourData>;
+export { computeContourFromLabelmapSegmentation };

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.js

@@ -1,11 +1,12 @@
 import { cache } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, setSegmentationRepresentationSpecificConfig, } from '../../segmentationState';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
 import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
-import { clipAndCacheSurfacesForViewport, } from '../../helpers/clipAndCacheSurfacesForViewport';
+import { clipAndCacheSurfacesForViewport } from '../../helpers/clipAndCacheSurfacesForViewport';
 import { extractContourData } from './utils/extractContourData';
 import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
-import { getToolGroupForViewport } from '../../../../store/ToolGroupManager';
+import { getSegmentation } from '../../getSegmentation';
+import { segmentationStyle } from '../../SegmentationStyle';
+import { SegmentationRepresentations } from '../../../../enums';
 export async function computeContourData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -14,13 +15,13 @@ export async function computeContourData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.SURFACE) {
+        if (representationData.Surface) {
             rawContourData = await computeContourFromSurfaceSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.LABELMAP) {
+        else if (representationData.Labelmap) {
             rawContourData = await computeContourFromLabelmapSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
@@ -34,13 +35,10 @@ export async function computeContourData(segmentationId, options = {}) {
     if (!rawContourData) {
         throw new Error('Not enough data to convert to contour, currently only support converting volume labelmap to contour if available');
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    const toolGroupId = getToolGroupForViewport(viewport.id)?.id;
-    setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, {
-        CONTOUR: {
-            fillAlpha: 0,
-        },
+    segmentationStyle.setStyle({ segmentationId, type: SegmentationRepresentations.Contour }, {
+        fillAlpha: 0,
     });
     return {
         annotationUIDsMap,
@@ -55,7 +53,7 @@ async function computeContourFromLabelmapSegmentation(segmentationId, options =
         console.error('Failed to convert labelmap to surface or labelmap is empty');
         return;
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const pointsAndPolys = results.map((surface) => {
         return {
             id: surface.segmentIndex.toString(),
@@ -64,7 +62,7 @@ async function computeContourFromLabelmapSegmentation(segmentationId, options =
             segmentIndex: surface.segmentIndex,
         };
     });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport, segmentationRepresentationUID);
+    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport);
     const rawResults = extractContourData(polyDataCache);
     return rawResults;
 }
@@ -72,14 +70,14 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     if (!options.viewport) {
         throw new Error('Viewport is required to compute contour from surface');
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
     const segmentIndexToSurfaceId = new Map();
     const surfaceIdToSegmentIndex = new Map();
     const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData.SURFACE;
+    const representationData = segmentation.representationData.Surface;
     const surfacesInfo = [];
     representationData.geometryIds.forEach((geometryId, segmentIndex) => {
         if (segmentIndices.includes(segmentIndex)) {
@@ -88,8 +86,9 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
             if (surface) {
                 surfacesInfo.push({
                     id: geometryId,
-                    points: surface.getPoints(),
-                    polys: surface.getPolys(),
+                    points: surface.points,
+                    polys: surface.polys,
+                    segmentIndex,
                 });
             }
         }
@@ -97,9 +96,8 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
         surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
     });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID);
-    const rawResults = extractContourData(polyDataCache, surfaceIdToSegmentIndex);
+    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport);
+    const rawResults = extractContourData(polyDataCache);
     return rawResults;
 }
 export { computeContourFromLabelmapSegmentation };
-//# sourceMappingURL=contourComputationStrategies.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.d.ts

@@ -0,0 +1,3 @@
+import type { RawContourData } from '../contourComputationStrategies';
+import { type Types } from '@cornerstonejs/core';
+export declare function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData: RawContourData, viewport: Types.IViewport, segmentationId: string): Map<number, Set<string>>;

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.js

@@ -1,4 +1,4 @@
-import { PlanarFreehandContourSegmentationTool } from '../../../../../tools';
+import PlanarFreehandContourSegmentationTool from '../../../../../tools/annotation/PlanarFreehandContourSegmentationTool';
 import { addAnnotation } from '../../../../annotation/annotationState';
 import { utilities } from '@cornerstonejs/core';
 export function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId) {
@@ -69,4 +69,3 @@ const _extractLineSegments = (contourData) => {
     }
     return { lineSegments, linesNumberOfPoints };
 };
-//# sourceMappingURL=createAndAddContourSegmentationsFromClippedSurfaces.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.d.ts

@@ -0,0 +1,3 @@
+import type { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import type { RawContourData } from '../contourComputationStrategies';
+export declare function extractContourData(polyDataCache: PolyDataClipCacheType): RawContourData;

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.js

@@ -1,21 +1,16 @@
-export function extractContourData(polyDataCache, segmentIndexMap) {
+export function extractContourData(polyDataCache) {
     const rawResults = new Map();
-    for (const [cacheId, intersectionInfo] of polyDataCache) {
-        const surfaceId = cacheId.split('_')[1];
+    for (const [segmentIndex, intersectionInfo] of polyDataCache) {
+        const segmentIndexNumber = Number(segmentIndex);
         for (const [_, result] of intersectionInfo) {
             if (!result) {
                 continue;
             }
-            const segmentIndex = Number(surfaceId) || segmentIndexMap?.get(surfaceId);
-            if (!segmentIndex) {
-                continue;
-            }
-            if (!rawResults.has(segmentIndex)) {
-                rawResults.set(segmentIndex, []);
+            if (!rawResults.has(segmentIndexNumber)) {
+                rawResults.set(segmentIndexNumber, []);
             }
-            rawResults.get(segmentIndex).push(result);
+            rawResults.get(segmentIndexNumber).push(result);
         }
     }
     return rawResults;
 }
-//# sourceMappingURL=extractContourData.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/updateContoursOnCameraModified.d.ts

@@ -0,0 +1 @@
+export declare function updateContoursOnCameraModified(surfacesInfo: any, viewport: any, segmentationRepresentationUID: any): void;

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/updateContoursOnCameraModified.js

@@ -13,7 +13,7 @@ export function updateContoursOnCameraModified(surfacesInfo, viewport, segmentat
             return;
         }
         currentViewportNormal.set(surface1.id, viewPlaneNormal);
-        const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID);
+        const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport);
         const results = extractContourData(polyDataCache);
         createAndAddContourSegmentationsFromClippedSurfaces(results, viewport, segmentationRepresentationUID);
         viewport.render();
@@ -23,4 +23,3 @@ export function updateContoursOnCameraModified(surfacesInfo, viewport, segmentat
     viewport.element.removeEventListener(Enums.Events.CAMERA_MODIFIED, cameraModifiedCallback);
     viewport.element.addEventListener(Enums.Events.CAMERA_MODIFIED);
 }
-//# sourceMappingURL=updateContoursOnCameraModified.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation.d.ts

@@ -0,0 +1,2 @@
+import type { PolySegConversionOptions } from '../../../../types';
+export declare function computeAndAddLabelmapRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<import("./labelmapComputationStrategies").RawLabelmapData>;

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation.js

@@ -1,7 +1,13 @@
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
 import { computeLabelmapData } from './labelmapComputationStrategies';
-export function computeAndAddLabelmapRepresentation(segmentationId, options = {}) {
-    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => computeLabelmapData(segmentationId, options), () => undefined);
+import { defaultSegmentationStateManager } from '../../SegmentationStateManager';
+import { triggerSegmentationDataModified } from '../../triggerSegmentationEvents';
+export async function computeAndAddLabelmapRepresentation(segmentationId, options = {}) {
+    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => computeLabelmapData(segmentationId, options), () => null, () => {
+        defaultSegmentationStateManager.processLabelmapRepresentationAddition(options.viewport.id, segmentationId);
+        setTimeout(() => {
+            triggerSegmentationDataModified(segmentationId);
+        }, 0);
+    });
 }
-//# sourceMappingURL=computeAndAddLabelmapRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.d.ts

@@ -0,0 +1,7 @@
+import type { ContourSegmentationData, PolySegConversionOptions } from '../../../../types';
+export declare function convertContourToVolumeLabelmap(contourRepresentationData: ContourSegmentationData, options?: PolySegConversionOptions): Promise<{
+    volumeId: string;
+}>;
+export declare function convertContourToStackLabelmap(contourRepresentationData: ContourSegmentationData, options?: PolySegConversionOptions): Promise<{
+    imageIds: any[];
+}>;

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.js

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import { cache, utilities, getWebWorkerManager, volumeLoader, imageLoader, metaData, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
-import { getAnnotation } from '../../..';
+import { getAnnotation } from '../../../annotation/annotationState';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
 const triggerWorkerProgress = (eventTarget, progress) => {
@@ -10,29 +10,23 @@ const triggerWorkerProgress = (eventTarget, progress) => {
     });
 };
 export async function convertContourToVolumeLabelmap(contourRepresentationData, options = {}) {
-    const { viewport } = options;
+    const viewport = options.viewport;
+    const volumeId = viewport.getVolumeId();
     const imageIds = utilities.getViewportImageIds(viewport);
     if (!imageIds) {
         throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
     }
     const segmentationVolumeId = utilities.uuidv4();
-    const volumeProps = utilities.generateVolumePropsFromImageIds(imageIds, segmentationVolumeId);
-    const { metadata, dimensions, origin, direction, spacing, scalarData } = volumeProps;
-    const segmentationVolume = await volumeLoader.createLocalSegmentationVolume({
-        dimensions,
-        origin,
-        direction,
-        spacing,
-        metadata,
-        imageIds: imageIds.map((imageId) => `generated://${imageId}`),
-        referencedImageIds: imageIds,
-    }, segmentationVolumeId);
+    const segmentationVolume = volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
+        volumeId: segmentationVolumeId,
+    });
+    const { dimensions, origin, direction, spacing, voxelManager } = segmentationVolume;
     const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
     triggerWorkerProgress(eventTarget, 0);
     const newScalarData = await workerManager.executeTask('polySeg', 'convertContourToVolumeLabelmap', {
         segmentIndices,
         dimensions,
-        scalarData,
+        scalarData: voxelManager.getCompleteScalarDataArray?.(),
         origin,
         direction,
         spacing,
@@ -44,12 +38,8 @@ export async function convertContourToVolumeLabelmap(contourRepresentationData,
             },
         ],
     });
-    triggerWorkerProgress(eventTarget, 1);
-    segmentationVolume.imageData
-        .getPointData()
-        .getScalars()
-        .setData(newScalarData);
-    segmentationVolume.imageData.modified();
+    triggerWorkerProgress(eventTarget, 100);
+    voxelManager.setCompleteScalarDataArray(newScalarData);
     segmentationVolume.modified();
     return {
         volumeId: segmentationVolume.volumeId,
@@ -69,7 +59,8 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             throw new Error('ImageIds must be cached before converting contour to labelmap');
         }
     });
-    const { imageIds: segmentationImageIds } = await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+    const segImages = await imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
+    const segmentationImageIds = segImages.map((it) => it.imageId);
     const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
     const segmentationsInfo = new Map();
     segmentationImageIds.forEach((segImageId, index) => {
@@ -92,7 +83,7 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             direction,
             spacing,
             origin,
-            scalarData: segImage.getPixelData(),
+            scalarData: segImage.voxelManager.getScalarData(),
             imageId: segImageId,
             dimensions: [segImage.width, segImage.height, 1],
         });
@@ -109,18 +100,18 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             },
         ],
     });
-    triggerWorkerProgress(eventTarget, 1);
-    const imageIdReferenceMap = new Map();
+    triggerWorkerProgress(eventTarget, 100);
+    const segImageIds = [];
     newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {
         const segmentationInfo = segmentationsInfo.get(referencedImageId);
         const { imageId: segImageId } = segmentationInfo;
         const segImage = cache.getImage(segImageId);
-        segImage.getPixelData().set(scalarData);
+        segImage.voxelManager.getScalarData().set(scalarData);
         segImage.imageFrame?.pixelData?.set(scalarData);
-        imageIdReferenceMap.set(referencedImageId, segImageId);
+        segImageIds.push(segImageId);
     });
     return {
-        imageIdReferenceMap,
+        imageIds: segImageIds,
     };
 }
 function _getAnnotationMapFromSegmentation(contourRepresentationData, options = {}) {
@@ -150,4 +141,3 @@ function _getAnnotationMapFromSegmentation(contourRepresentationData, options =
     });
     return { segmentIndices, annotationUIDsInSegmentMap };
 }
-//# sourceMappingURL=convertContourToLabelmap.js.map