@cornerstonejs/tools 4.22.13 → 5.0.0

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

@@ -1,10 +1,25 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getSegmentation } from './getSegmentation';
+import { getActiveSegmentIndex } from './getActiveSegmentIndex';
+import { getLabelmapForSegment } from './helpers/labelmapSegmentationState';
 export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
     const imageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
     if (!imageIds?.length) {
         return;
     }
-    return imageIds[0];
+    if (imageIds.length === 1) {
+        return imageIds[0];
+    }
+    const segmentation = getSegmentation(segmentationId);
+    const activeSegmentIndex = getActiveSegmentIndex(segmentationId);
+    const activeLayer = activeSegmentIndex
+        ? getLabelmapForSegment(segmentation, activeSegmentIndex)
+        : undefined;
+    if (!activeLayer?.imageIds?.length) {
+        return imageIds[0];
+    }
+    return (imageIds.find((imageId) => activeLayer.imageIds.includes(imageId)) ??
+        imageIds[0]);
 }
 export function getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
     const segmentationStateManager = defaultSegmentationStateManager;

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

@@ -2,16 +2,17 @@ import { cache, utilities } from '@cornerstonejs/core';
 import { getSegmentation } from '../getSegmentation';
 import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
 import { createLabelmapMemo } from '../../../utilities/segmentation/createLabelmapMemo';
+import { getSegmentBinding, getLabelmapForSegment, removeSegmentBinding, } from './labelmapSegmentationState';
 const { DefaultHistoryMemo } = utilities.HistoryMemo;
 export function clearSegmentValue(segmentationId, segmentIndex, options) {
     const segmentation = getSegmentation(segmentationId);
     if (segmentation.representationData.Labelmap) {
-        const { representationData } = segmentation;
-        const labelmapData = representationData.Labelmap;
-        if ('imageIds' in labelmapData || 'volumeId' in labelmapData) {
-            const items = 'imageIds' in labelmapData
-                ? labelmapData.imageIds.map((imageId) => cache.getImage(imageId))
-                : [cache.getVolume(labelmapData.volumeId)];
+        const binding = getSegmentBinding(segmentation, segmentIndex);
+        const layer = getLabelmapForSegment(segmentation, segmentIndex);
+        if (binding && layer) {
+            const items = layer.volumeId
+                ? [cache.getVolume(layer.volumeId)]
+                : (layer.imageIds ?? []).map((imageId) => cache.getImage(imageId));
             items.forEach((item) => {
                 if (!item) {
                     return;
@@ -22,7 +23,7 @@ export function clearSegmentValue(segmentationId, segmentIndex, options) {
                     : null;
                 const useVoxelManager = memo?.voxelManager ?? voxelManager;
                 voxelManager.forEach(({ value, index }) => {
-                    if (value === segmentIndex) {
+                    if (value === binding.labelValue) {
                         useVoxelManager.setAtIndex(index, 0);
                     }
                 });
@@ -30,6 +31,7 @@ export function clearSegmentValue(segmentationId, segmentIndex, options) {
                     DefaultHistoryMemo.push(memo);
                 }
             });
+            removeSegmentBinding(segmentation, segmentIndex);
         }
         triggerSegmentationDataModified(segmentationId);
     }

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 export declare function getLabelmapActorUID(viewportId: string, segmentationId: string): string | undefined;
 export declare function getLabelmapActorEntries(viewportId: string, segmentationId: string): Types.ActorEntry[];
-export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string): Types.ActorEntry;
+export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string, referencedId?: string): Types.ActorEntry;
 export declare function getSurfaceActorEntry(viewportId: string, segmentationId: string, segmentIndex?: number | string): Types.ActorEntry;
 export declare function getSurfaceRepresentationUID(segmentationId: string, segmentIndex?: number | string): string;

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

@@ -33,8 +33,9 @@ export function getLabelmapActorUID(viewportId, segmentationId) {
 export function getLabelmapActorEntries(viewportId, segmentationId) {
     return getActorEntries(viewportId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
 }
-export function getLabelmapActorEntry(viewportId, segmentationId) {
-    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
+export function getLabelmapActorEntry(viewportId, segmentationId, referencedId) {
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`) &&
+        (!referencedId || actor.referencedId === referencedId));
 }
 export function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
     return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID ===

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

@@ -0,0 +1,5 @@
+import { type Types } from '@cornerstonejs/core';
+export type ViewportLabelmapRenderMode = 'image' | 'volume' | 'unsupported';
+export default function getViewportLabelmapRenderMode(viewport: Types.IViewport, options?: {
+    useSliceRendering?: boolean;
+}): ViewportLabelmapRenderMode;

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

@@ -0,0 +1,58 @@
+import { ActorRenderMode, BaseVolumeViewport, StackViewport, Enums, } from '@cornerstonejs/core';
+import { canRenderVolumeViewportLabelmapAsImage, isSliceRenderingEnabled, } from './labelmapImageMapperSupport';
+export default function getViewportLabelmapRenderMode(viewport, options) {
+    const compatibilityViewport = viewport;
+    const useSliceRendering = isSliceRenderingEnabled(options);
+    if (useSliceRendering && canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return 'image';
+    }
+    if (viewport instanceof BaseVolumeViewport) {
+        return 'volume';
+    }
+    if (viewport instanceof StackViewport) {
+        return 'image';
+    }
+    const defaultActor = typeof compatibilityViewport.getDefaultActor === 'function'
+        ? compatibilityViewport.getDefaultActor()
+        : undefined;
+    const actorMapper = defaultActor?.actorMapper;
+    const renderMode = actorMapper?.renderMode;
+    if (renderMode === ActorRenderMode.VTK_VOLUME ||
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE) {
+        return 'volume';
+    }
+    if (renderMode === ActorRenderMode.CPU_VOLUME) {
+        return 'volume';
+    }
+    if (renderMode === ActorRenderMode.VTK_IMAGE ||
+        renderMode === ActorRenderMode.CPU_IMAGE) {
+        return 'image';
+    }
+    const actorClassName = typeof defaultActor?.actor?.getClassName === 'function'
+        ? defaultActor.actor.getClassName()
+        : undefined;
+    if (actorClassName === 'vtkVolume') {
+        return 'volume';
+    }
+    if (actorClassName === 'vtkImageSlice') {
+        return 'image';
+    }
+    if (actorClassName === 'CanvasActor') {
+        const defaultActorRenderMode = actorMapper?.renderMode;
+        if (defaultActorRenderMode === ActorRenderMode.CPU_VOLUME) {
+            return 'volume';
+        }
+        return 'image';
+    }
+    if (compatibilityViewport.type === Enums.ViewportType.PLANAR_NEXT) {
+        if (compatibilityViewport.getVolumeId?.()) {
+            return 'volume';
+        }
+        return typeof compatibilityViewport.getCurrentImageId === 'function'
+            ? 'image'
+            : 'unsupported';
+    }
+    return typeof compatibilityViewport.getCurrentImageId === 'function'
+        ? 'image'
+        : 'unsupported';
+}

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

@@ -0,0 +1,52 @@
+import { Enums, type Types } from '@cornerstonejs/core';
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+declare const DIRECTION_ALIGNMENT_TOLERANCE = 0.999;
+export declare const LABELMAP_IMAGE_MAPPER_URL_PARAM = "labelmapImageMapper";
+export type VolumeViewportLabelmapImageMapperState = {
+    key: string;
+    sliceIndex: number;
+    supported: boolean;
+};
+type ViewportLabelmapImageMapperCompatibilityViewport = Types.IViewport & {
+    getCamera?: () => Pick<Types.ICamera, 'viewPlaneNormal' | 'viewUp'>;
+    getCurrentImageIdIndex?: () => number;
+    getDisplaySetRenderMode?: (displaySetId: string) => Types.ActorRenderMode | string | undefined;
+    getDisplaySetRole?: (displaySetId: string) => 'source' | 'overlay' | undefined;
+    getDisplaySetPresentation?: (dataId: string) => {
+        blendMode?: Enums.BlendModes;
+        slabThickness?: number;
+    };
+    getDefaultActor?: () => (Types.ActorEntry & {
+        actorMapper?: {
+            actor?: {
+                getMapper?: () => {
+                    getBlendMode?: () => Enums.BlendModes;
+                    getSlabThickness?: () => number;
+                };
+            };
+            mapper?: {
+                getBlendMode?: () => Enums.BlendModes;
+                getSlabThickness?: () => number;
+            };
+            renderMode?: Types.ActorRenderMode;
+        };
+    }) | undefined;
+    getSliceViewInfo?: () => {
+        sliceIndex: number;
+    };
+    getSourceDataId?: () => string | undefined;
+    getVolumeId?: () => string | undefined;
+    getResolvedView?: () => {
+        toICamera?: () => Pick<Types.ICamera, 'viewPlaneNormal' | 'viewUp'>;
+    } | undefined;
+    type?: string;
+};
+export declare function isSliceRenderingEnabled(options?: {
+    useSliceRendering?: boolean;
+}): boolean;
+export declare function shouldUseSliceRendering(segmentation?: Segmentation, options?: {
+    useSliceRendering?: boolean;
+}): boolean;
+export declare function canRenderVolumeViewportLabelmapAsImage(viewport: Types.IViewport): viewport is ViewportLabelmapImageMapperCompatibilityViewport;
+export declare function getVolumeViewportLabelmapImageMapperState(viewport: Types.IViewport): VolumeViewportLabelmapImageMapperState;
+export { DIRECTION_ALIGNMENT_TOLERANCE };

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

@@ -0,0 +1,246 @@
+import { ActorRenderMode, Enums, VolumeViewport, } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import { getLabelmaps } from '../labelmapModel/labelmapLayerStore';
+const DIRECTION_ALIGNMENT_TOLERANCE = 0.999;
+const MINIMUM_SLAB_THICKNESS = 0.1;
+const SLAB_THICKNESS_EPSILON = 1e-3;
+export const LABELMAP_IMAGE_MAPPER_URL_PARAM = 'labelmapImageMapper';
+function isSupportedImageMapperBlendMode(blendMode) {
+    return (blendMode === Enums.BlendModes.COMPOSITE ||
+        blendMode === Enums.BlendModes.AVERAGE_INTENSITY_BLEND);
+}
+function isPlanarGpuVolumeSliceViewport(viewport) {
+    const compatibilityViewport = viewport;
+    if (compatibilityViewport.type !== Enums.ViewportType.PLANAR_NEXT) {
+        return false;
+    }
+    return (getPlanarPrimaryRenderMode(compatibilityViewport) ===
+        ActorRenderMode.VTK_VOLUME_SLICE);
+}
+function getPlanarPrimaryRenderMode(viewport) {
+    const primaryDataId = getPlanarPrimaryDataId(viewport);
+    if (primaryDataId) {
+        const renderMode = viewport.getDisplaySetRenderMode?.(primaryDataId);
+        if (renderMode) {
+            return renderMode;
+        }
+    }
+    return viewport.getDefaultActor?.()?.actorMapper?.renderMode;
+}
+function getPlanarVolumeSliceMapper(viewport) {
+    const defaultActor = viewport.getDefaultActor?.();
+    return (defaultActor?.actorMapper?.mapper ??
+        defaultActor?.actorMapper?.actor?.getMapper?.());
+}
+function getPlanarPrimaryDataId(viewport) {
+    const sourceDataId = viewport.getSourceDataId?.();
+    if (sourceDataId) {
+        return sourceDataId;
+    }
+    const renderModes = viewport._debug?.renderModes;
+    if (!renderModes) {
+        return;
+    }
+    return (Object.entries(renderModes).find(([dataId, renderMode]) => viewport.getDisplaySetRole?.(dataId) === 'source' &&
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE)?.[0] ??
+        Object.entries(renderModes).find(([, renderMode]) => renderMode === ActorRenderMode.VTK_VOLUME_SLICE)?.[0]);
+}
+function getLabelmapImageMapperCamera(viewport) {
+    const compatibilityViewport = viewport;
+    const resolvedCamera = compatibilityViewport
+        .getResolvedView?.()
+        ?.toICamera?.();
+    if (isLabelmapImageMapperCamera(resolvedCamera)) {
+        return resolvedCamera;
+    }
+    const legacyCamera = compatibilityViewport.getCamera?.();
+    return isLabelmapImageMapperCamera(legacyCamera) ? legacyCamera : undefined;
+}
+function isLabelmapImageMapperCamera(camera) {
+    const candidate = camera;
+    return Boolean(candidate &&
+        isPoint3Like(candidate.viewPlaneNormal) &&
+        isPoint3Like(candidate.viewUp));
+}
+function isPoint3Like(value) {
+    const candidate = value;
+    return Boolean(candidate &&
+        typeof candidate.length === 'number' &&
+        candidate.length >= 3 &&
+        Number.isFinite(Number(candidate[0])) &&
+        Number.isFinite(Number(candidate[1])) &&
+        Number.isFinite(Number(candidate[2])));
+}
+function getPlanarVolumeDataPresentation(viewport) {
+    if (!viewport.getDisplaySetPresentation) {
+        return;
+    }
+    const primaryDataId = getPlanarPrimaryDataId(viewport);
+    return primaryDataId
+        ? viewport.getDisplaySetPresentation(primaryDataId)
+        : undefined;
+}
+function getCompatibilityBlendMode(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        return viewport.getBlendMode?.();
+    }
+    if (!isPlanarGpuVolumeSliceViewport(viewport)) {
+        return;
+    }
+    const presentationBlendMode = getPlanarVolumeDataPresentation(viewport)?.blendMode;
+    if (presentationBlendMode !== undefined) {
+        return presentationBlendMode;
+    }
+    return Enums.BlendModes.AVERAGE_INTENSITY_BLEND;
+}
+function getCompatibilitySlabThickness(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        return viewport.getSlabThickness?.() ?? MINIMUM_SLAB_THICKNESS;
+    }
+    if (!isPlanarGpuVolumeSliceViewport(viewport)) {
+        return MINIMUM_SLAB_THICKNESS;
+    }
+    const mapperSlabThickness = getPlanarVolumeSliceMapper(viewport)?.getSlabThickness?.();
+    if (typeof mapperSlabThickness === 'number') {
+        return mapperSlabThickness;
+    }
+    return (getPlanarVolumeDataPresentation(viewport)?.slabThickness ??
+        MINIMUM_SLAB_THICKNESS);
+}
+export function isSliceRenderingEnabled(options) {
+    if (options?.useSliceRendering) {
+        return true;
+    }
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    const params = new URLSearchParams(window.location.search);
+    if (!params.has(LABELMAP_IMAGE_MAPPER_URL_PARAM)) {
+        return false;
+    }
+    const value = params.get(LABELMAP_IMAGE_MAPPER_URL_PARAM);
+    if (value === null || value === '') {
+        return true;
+    }
+    const normalizedValue = value.trim().toLowerCase();
+    return (normalizedValue !== '0' &&
+        normalizedValue !== 'false' &&
+        normalizedValue !== 'off');
+}
+export function shouldUseSliceRendering(segmentation, options) {
+    if (isSliceRenderingEnabled(options)) {
+        return true;
+    }
+    if (!segmentation?.representationData?.Labelmap) {
+        return false;
+    }
+    const layers = getLabelmaps(segmentation);
+    return layers.length > 1 && layers.some((layer) => layer.type === 'stack');
+}
+export function canRenderVolumeViewportLabelmapAsImage(viewport) {
+    const isLegacyVolumeViewport = viewport instanceof VolumeViewport;
+    const isNextPlanarViewport = isPlanarGpuVolumeSliceViewport(viewport);
+    if (!isLegacyVolumeViewport && !isNextPlanarViewport) {
+        return false;
+    }
+    const blendMode = getCompatibilityBlendMode(viewport);
+    if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
+        return false;
+    }
+    const slabThickness = getCompatibilitySlabThickness(viewport);
+    if (slabThickness > MINIMUM_SLAB_THICKNESS + SLAB_THICKNESS_EPSILON) {
+        return false;
+    }
+    if (isLegacyVolumeViewport) {
+        try {
+            viewport.getSliceViewInfo();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+export function getVolumeViewportLabelmapImageMapperState(viewport) {
+    const compatibilityViewport = viewport;
+    const isLegacyVolumeViewport = viewport instanceof VolumeViewport;
+    const isNextPlanarViewport = isPlanarGpuVolumeSliceViewport(viewport);
+    if (!isLegacyVolumeViewport && !isNextPlanarViewport) {
+        return {
+            key: 'unsupported:viewport',
+            sliceIndex: NaN,
+            supported: false,
+        };
+    }
+    const camera = getLabelmapImageMapperCamera(viewport);
+    if (!camera) {
+        return {
+            key: 'unsupported:camera',
+            sliceIndex: NaN,
+            supported: false,
+        };
+    }
+    const { viewPlaneNormal, viewUp } = camera;
+    const normalizedNormal = vec3.normalize(vec3.create(), viewPlaneNormal);
+    const normalizedViewUp = vec3.normalize(vec3.create(), viewUp);
+    let sliceIndex;
+    if (isLegacyVolumeViewport) {
+        try {
+            sliceIndex = viewport.getSliceViewInfo().sliceIndex;
+        }
+        catch {
+            sliceIndex = undefined;
+        }
+    }
+    else {
+        sliceIndex = compatibilityViewport.getCurrentImageIdIndex?.();
+    }
+    const blendMode = getCompatibilityBlendMode(viewport);
+    const slabThickness = getCompatibilitySlabThickness(viewport);
+    const orientationKey = [
+        normalizedNormal.map((value) => value.toFixed(3)).join(','),
+        normalizedViewUp.map((value) => value.toFixed(3)).join(','),
+    ].join('|');
+    if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
+        return {
+            key: `unsupported:blend:${blendMode}:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    if (slabThickness > MINIMUM_SLAB_THICKNESS + SLAB_THICKNESS_EPSILON) {
+        return {
+            key: `unsupported:slab:${slabThickness.toFixed(3)}:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    if (isLegacyVolumeViewport) {
+        try {
+            viewport.getSliceViewInfo();
+        }
+        catch {
+            return {
+                key: `unsupported:oblique:${orientationKey}`,
+                sliceIndex: sliceIndex ?? NaN,
+                supported: false,
+            };
+        }
+    }
+    if (isNextPlanarViewport &&
+        getPlanarPrimaryRenderMode(compatibilityViewport) !==
+            ActorRenderMode.VTK_VOLUME_SLICE) {
+        return {
+            key: `unsupported:renderMode:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    return {
+        key: `supported:${orientationKey}:${sliceIndex ?? 0}`,
+        sliceIndex: sliceIndex ?? NaN,
+        supported: true,
+    };
+}
+export { DIRECTION_ALIGNMENT_TOLERANCE };

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

@@ -0,0 +1 @@
+export * from '../labelmapModel';

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

@@ -0,0 +1 @@
+export * from '../labelmapModel';

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

@@ -1,5 +1,6 @@
 import { SegmentationRepresentations } from '../../../enums';
 import { cache } from '@cornerstonejs/core';
+import { ensureLabelmapState, syncLegacyLabelmapData, } from './labelmapSegmentationState';
 function normalizeSegmentationInput(segmentationInput) {
     const { segmentationId, representation, config } = segmentationInput;
     const { type, data: inputData } = representation;
@@ -12,18 +13,27 @@ function normalizeSegmentationInput(segmentationInput) {
     }
     const normalizedSegments = normalizeSegments(config?.segments, type, data);
     delete config?.segments;
-    return {
+    const segmentation = {
         segmentationId,
         label: config?.label ?? null,
         fallbackLabel: config?.fallbackLabel ?? null,
         cachedStats: config?.cachedStats ?? {},
         segments: normalizedSegments,
+        segmentOrder: config?.segmentOrder ??
+            Object.keys(normalizedSegments)
+                .map(Number)
+                .sort((a, b) => a - b),
         representationData: {
             [type]: {
                 ...data,
             },
         },
     };
+    if (type === SegmentationRepresentations.Labelmap) {
+        ensureLabelmapState(segmentation);
+        syncLegacyLabelmapData(segmentation);
+    }
+    return segmentation;
 }
 function normalizeContourData(contourData) {
     contourData.geometryIds = contourData.geometryIds ?? [];

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

@@ -1,4 +1,4 @@
-import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId, utilities } from '@cornerstonejs/core';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { SegmentationRepresentations } from '../../enums';
@@ -40,7 +40,7 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
 function getColorLUTIndex(config) {
     const { colorLUTOrIndex } = config || {};
     if (colorLUTOrIndex === undefined) {
-        const index = addColorLUT(JSON.parse(JSON.stringify(CORNERSTONE_COLOR_LUT)));
+        const index = addColorLUT(utilities.deepClone(CORNERSTONE_COLOR_LUT));
         return index;
     }
     if (typeof colorLUTOrIndex === 'number') {
@@ -51,7 +51,7 @@ function getColorLUTIndex(config) {
         const index = addColorLUT(colorLUTOrIndex);
         return index;
     }
-    const index = addColorLUT(JSON.parse(JSON.stringify(CORNERSTONE_COLOR_LUT)));
+    const index = addColorLUT(utilities.deepClone(CORNERSTONE_COLOR_LUT));
     return index;
 }
 export { internalAddSegmentationRepresentation };

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

@@ -0,0 +1,9 @@
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, } from './normalizeLabelmapSegmentationData';
+export type { LabelmapSegmentationWithState } from './normalizeLabelmapSegmentationData';
+export { getConstructorNameForLabelmap, getLabelmap, getLabelmapDataById, getLabelmapForImageId, getLabelmapForVolumeId, getLabelmapIds, getLabelmaps, getOrCreateLabelmapVolume, getScalarArrayLengthFromLabelmap, registerLabelmap, removeLabelmap, } from './labelmapLayerStore';
+export { getReferencedImageIdToCurrentImageIdMap, syncLegacyLabelmapData, } from './labelmapLegacyAdapter';
+export { getLabelmapForSegment, getLabelValueForSegment, getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, removeSegmentBinding, resolveLabelmapForSegment, setSegmentBinding, } from './labelmapSegmentBindings';
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap, } from './privateLabelmap';
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, } from './labelmapEditTransaction';
+export type { BeginLabelmapEditTransactionOptions, EraseLabelmapEditTransactionOptions, LabelmapEditTransaction, LabelmapLayerEditTarget, ResolveLabelmapLayerEditTargetOptions, } from './labelmapEditTransaction';
+export { default as LabelmapImageReferenceResolver } from './labelmapImageReferenceResolver';

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

@@ -0,0 +1,7 @@
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, } from './normalizeLabelmapSegmentationData';
+export { getConstructorNameForLabelmap, getLabelmap, getLabelmapDataById, getLabelmapForImageId, getLabelmapForVolumeId, getLabelmapIds, getLabelmaps, getOrCreateLabelmapVolume, getScalarArrayLengthFromLabelmap, registerLabelmap, removeLabelmap, } from './labelmapLayerStore';
+export { getReferencedImageIdToCurrentImageIdMap, syncLegacyLabelmapData, } from './labelmapLegacyAdapter';
+export { getLabelmapForSegment, getLabelValueForSegment, getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, removeSegmentBinding, resolveLabelmapForSegment, setSegmentBinding, } from './labelmapSegmentBindings';
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap, } from './privateLabelmap';
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, } from './labelmapEditTransaction';
+export { default as LabelmapImageReferenceResolver } from './labelmapImageReferenceResolver';

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapEditTransaction.d.ts

@@ -0,0 +1,54 @@
+import type { Types } from '@cornerstonejs/core';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer, SegmentLabelmapBindingState } from '../../../types/LabelmapTypes';
+type MoveSegmentToPrivateLabelmap = (segmentation: Segmentation, segmentIndex: number) => LabelmapLayer | undefined;
+type BeginLabelmapEditTransactionOptions = {
+    segmentIndex: number;
+    overwriteSegmentIndices?: number[];
+    segmentationVoxelManager?: Types.IVoxelManager<number>;
+    segmentationImageData?: vtkImageData;
+    isInObject?: (point: Types.Point3) => boolean;
+    isInObjectBoundsIJK?: Types.BoundsIJK;
+    moveSegmentToPrivateLabelmap?: MoveSegmentToPrivateLabelmap;
+};
+type LabelmapEditTransaction = {
+    segmentIndex: number;
+    labelmapId?: string;
+    labelValue: number;
+    sourceLayer?: LabelmapLayer;
+    activeLayer?: LabelmapLayer;
+    overwriteSegmentIndices: number[];
+    protectedSegmentIndices: number[];
+    crossLayerEraseBindings: SegmentLabelmapBindingState[];
+    movedSegment: boolean;
+};
+type ResolveLabelmapLayerEditTargetOptions = {
+    viewport?: Types.IViewport;
+    imageId?: string;
+    sourceLayer?: LabelmapLayer;
+    preferVolume?: boolean;
+};
+type LabelmapLayerEditTarget = {
+    imageId?: string;
+    imageData?: vtkImageData;
+    voxelManager?: Types.IVoxelManager<number>;
+    volume?: Types.IImageVolume;
+    image?: Types.IImage;
+};
+type EraseLabelmapEditTransactionOptions = {
+    viewport: Types.IViewport;
+    referenceImageData: vtkImageData;
+    isInObject: (point: Types.Point3) => boolean;
+    isInObjectBoundsIJK?: Types.BoundsIJK;
+    imageId?: string;
+};
+declare function getProtectedSegmentIndicesForLayer(segmentation: Segmentation, labelmapId: string, segmentIndex: number, overwriteSegmentIndices?: number[]): number[];
+declare function hasProtectedSegmentOverwrite(segmentation: Segmentation, labelmapId: string, protectedSegmentIndices: number[], voxelManager?: Types.IVoxelManager<number>, options?: Pick<BeginLabelmapEditTransactionOptions, 'segmentationImageData' | 'isInObject' | 'isInObjectBoundsIJK'>): boolean;
+declare function collectCrossLayerEraseBindings(segmentation: Segmentation, labelmapId: string | undefined, overwriteSegmentIndices?: number[]): SegmentLabelmapBindingState[];
+declare function beginLabelmapEditTransaction(segmentation: Segmentation, options: BeginLabelmapEditTransactionOptions): LabelmapEditTransaction;
+declare function getLabelmapLayerImageId(layer: LabelmapLayer, options?: ResolveLabelmapLayerEditTargetOptions): string | undefined;
+declare function resolveLabelmapLayerEditTarget(layer: LabelmapLayer, options?: ResolveLabelmapLayerEditTargetOptions): LabelmapLayerEditTarget;
+declare function eraseLabelmapEditTransactionOverwrites(segmentation: Segmentation, transaction: LabelmapEditTransaction | undefined, options: EraseLabelmapEditTransactionOptions): number[];
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, };
+export type { BeginLabelmapEditTransactionOptions, EraseLabelmapEditTransactionOptions, LabelmapEditTransaction, LabelmapLayerEditTarget, ResolveLabelmapLayerEditTargetOptions, };