@cornerstonejs/tools 4.22.13 → 5.0.0

package/dist/esm/tools/base/ContourSegmentationBaseTool.js

@@ -14,7 +14,6 @@ import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segm
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 import { defaultSegmentationStateManager } from '../../stateManagement/segmentation/SegmentationStateManager';
 class ContourSegmentationBaseTool extends ContourBaseTool {
-    static { this.PreviewSegmentIndex = 255; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
         if (this.configuration.interpolation?.enabled) {
@@ -163,4 +162,5 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         };
     }
 }
+ContourSegmentationBaseTool.PreviewSegmentIndex = 255;
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

package/dist/esm/tools/base/GrowCutBaseTool.js

@@ -10,7 +10,6 @@ import { getOrCreateSegmentationVolume } from '../../utilities/segmentation';
 import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 const { transformWorldToIndex, transformIndexToWorld } = csUtils;
 class GrowCutBaseTool extends BaseTool {
-    static { this.lastGrowCutCommand = null; }
     constructor(toolProps, defaultToolProps) {
         const baseToolProps = csUtils.deepMerge({
             configuration: {
@@ -209,7 +208,7 @@ class GrowCutBaseTool extends BaseTool {
         const derivedVolume = new ImageVolume({
             volumeId,
             dataType: volumeProps.dataType,
-            metadata: structuredClone(volumeProps.metadata),
+            metadata: csUtils.deepClone(volumeProps.metadata),
             dimensions: volumeProps.dimensions,
             spacing: volumeProps.spacing,
             origin: volumeProps.origin,
@@ -276,5 +275,6 @@ class GrowCutBaseTool extends BaseTool {
         });
     }
 }
+GrowCutBaseTool.lastGrowCutCommand = null;
 GrowCutBaseTool.toolName = 'GrowCutBaseTool';
 export default GrowCutBaseTool;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.d.ts

@@ -1,7 +1,5 @@
 import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
 import type { LabelmapRenderingConfig } from '../../../types/SegmentationStateTypes';
-declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<void | {
-    uid: string;
-    actor: any;
-}>;
+import { type LabelmapRenderPlanMountResult } from './labelmapRenderPlan';
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<LabelmapRenderPlanMountResult>;
 export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -1,91 +1,21 @@
-import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, cache, BaseVolumeViewport, volumeLoader, utilities, } from '@cornerstonejs/core';
-import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getEnabledElement } from '@cornerstonejs/core';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
-import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { SegmentationRepresentations } from '../../../enums';
-import { addVolumesAsIndependentComponents } from './addVolumesAsIndependentComponents';
-const { uuidv4 } = utilities;
+import { resolveLabelmapRenderPlan, } from './labelmapRenderPlan';
 async function addLabelmapToElement(element, labelMapData, segmentationId, config) {
     const enabledElement = getEnabledElement(element);
-    const { renderingEngine, viewport } = enabledElement;
-    const { id: viewportId } = viewport;
-    const visibility = true;
-    const immediateRender = false;
-    const suppressEvents = true;
-    if (viewport instanceof BaseVolumeViewport) {
-        const volumeLabelMapData = labelMapData;
-        const volumeId = _ensureVolumeHasVolumeId(volumeLabelMapData, segmentationId);
-        if (!cache.getVolume(volumeId)) {
-            await _handleMissingVolume(labelMapData);
-        }
-        let blendMode = config?.blendMode ?? Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-        let useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
-        if (useIndependentComponents) {
-            const referenceVolumeId = viewport.getVolumeId();
-            const baseVolume = cache.getVolume(referenceVolumeId);
-            const segVolume = cache.getVolume(volumeId);
-            const segDims = segVolume.dimensions;
-            const refDims = baseVolume.dimensions;
-            if (segDims[0] !== refDims[0] ||
-                segDims[1] !== refDims[1] ||
-                segDims[2] !== refDims[2]) {
-                useIndependentComponents = false;
-                blendMode = Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-                console.debug('Dimensions mismatch - falling back to regular volume addition');
-            }
-        }
-        const volumeInputs = [
-            {
-                volumeId,
-                visibility,
-                representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
-                useIndependentComponents,
-                blendMode,
-            },
-        ];
-        if (!volumeInputs[0].useIndependentComponents) {
-            await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
-        }
-        else {
-            const result = await addVolumesAsIndependentComponents({
-                viewport,
-                volumeInputs,
-                segmentationId,
-            });
-            return result;
-        }
+    const { viewport } = enabledElement;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
     }
-    else {
-        const segmentationImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId);
-        const stackInputs = segmentationImageIds.map((imageId) => ({
-            imageId,
-            representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}-${imageId}`,
-        }));
-        addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
-    }
-    triggerSegmentationDataModified(segmentationId);
-}
-function _ensureVolumeHasVolumeId(labelMapData, segmentationId) {
-    let { volumeId } = labelMapData;
-    if (!volumeId) {
-        volumeId = uuidv4();
-        const segmentation = getSegmentation(segmentationId);
-        segmentation.representationData.Labelmap = {
-            ...segmentation.representationData.Labelmap,
-            volumeId,
-        };
-        labelMapData.volumeId = volumeId;
-        triggerSegmentationModified(segmentationId);
-    }
-    return volumeId;
-}
-async function _handleMissingVolume(labelMapData) {
-    const stackData = labelMapData;
-    const hasImageIds = stackData.imageIds.length > 0;
-    if (!hasImageIds) {
-        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
-    }
-    const volume = await volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId || uuidv4(), stackData.imageIds);
-    return volume;
+    const renderPlan = resolveLabelmapRenderPlan({
+        viewport,
+        segmentation,
+        representation: {
+            segmentationId,
+            config,
+        },
+    });
+    return renderPlan.mount({ labelMapData });
 }
 export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/labelmapActorStyle.d.ts

@@ -0,0 +1,5 @@
+import { type Types } from '@cornerstonejs/core';
+import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
+declare const MAX_NUMBER_COLORS = 255;
+declare function setLabelmapColorAndOpacity(viewportId: string, labelmapActorEntry: Types.ActorEntry, segmentationRepresentation: LabelmapRepresentation): void;
+export { MAX_NUMBER_COLORS, setLabelmapColorAndOpacity };

package/dist/esm/tools/displayTools/Labelmap/labelmapActorStyle.js

@@ -0,0 +1,191 @@
+import { ActorRenderMode } from '@cornerstonejs/core';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import { getActiveSegmentation } from '../../../stateManagement/segmentation/activeSegmentation';
+import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { getSegmentBinding } from '../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import { segmentationStyle } from '../../../stateManagement/segmentation/SegmentationStyle';
+import { getLabelmapForActorReference } from './volumeLabelmapImageMapper';
+const actorTransferFunctions = new WeakMap();
+const MAX_NUMBER_COLORS = 255;
+function setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentationRepresentation) {
+    const { segmentationId } = segmentationRepresentation;
+    const { colorLUTIndex } = segmentationRepresentation;
+    const activeSegmentation = getActiveSegmentation(viewportId);
+    const isActiveLabelmap = activeSegmentation?.segmentationId === segmentationId;
+    const labelmapStyle = segmentationStyle.getStyle({
+        viewportId,
+        type: SegmentationRepresentations.Labelmap,
+        segmentationId,
+    });
+    const renderInactiveSegmentations = segmentationStyle.getRenderInactiveSegmentations(viewportId);
+    const colorLUT = getColorLUT(colorLUTIndex);
+    const segmentation = getSegmentation(segmentationId);
+    const layer = getLabelmapForActorReference(segmentation, labelmapActorEntry.referencedId);
+    const layerBindings = Object.keys(segmentation.segments)
+        .map(Number)
+        .map((segmentIndex) => ({
+        segmentIndex,
+        binding: getSegmentBinding(segmentation, segmentIndex),
+    }))
+        .filter((entry) => !layer || entry.binding?.labelmapId === layer.labelmapId);
+    const maxLabelValue = Math.max(1, ...layerBindings.map((entry) => entry.binding?.labelValue ?? entry.segmentIndex));
+    const numColors = Math.max(colorLUT.length, maxLabelValue + 1);
+    const labelValueEntries = Array.from({ length: numColors - 1 }, (_, index) => {
+        const labelValue = index + 1;
+        const segmentIndex = layer?.labelToSegmentIndex?.[labelValue] ?? labelValue;
+        return {
+            labelValue,
+            segmentIndex,
+        };
+    });
+    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = getLabelmapConfig(labelmapStyle, isActiveLabelmap);
+    const segmentsHidden = internalGetHiddenSegmentIndices(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
+    const labelmapActor = labelmapActorEntry.actor;
+    const { cfun, ofun } = getOrCreateTransferFunctions(labelmapActor);
+    cfun.removeAllPoints();
+    ofun.removeAllPoints();
+    const colorNodes = [
+        { x: 0, r: 0, g: 0, b: 0, midpoint: 0.5, sharpness: 1.0 },
+    ];
+    const opacityNodes = [{ x: 0, y: 0, midpoint: 0.5, sharpness: 1.0 }];
+    labelValueEntries.forEach(({ labelValue, segmentIndex }) => {
+        const segmentColor = colorLUT[segmentIndex];
+        if (!segmentColor) {
+            return;
+        }
+        const perSegmentStyle = segmentationStyle.getStyle({
+            viewportId,
+            type: SegmentationRepresentations.Labelmap,
+            segmentationId,
+            segmentIndex,
+        });
+        const { fillAlpha, renderFill } = getLabelmapConfig(labelmapStyle, isActiveLabelmap, perSegmentStyle);
+        colorNodes.push({
+            x: labelValue,
+            r: segmentColor[0] / MAX_NUMBER_COLORS,
+            g: segmentColor[1] / MAX_NUMBER_COLORS,
+            b: segmentColor[2] / MAX_NUMBER_COLORS,
+            midpoint: 0.5,
+            sharpness: 1.0,
+        });
+        if (renderFill) {
+            const segmentOpacity = segmentsHidden.has(segmentIndex)
+                ? 0
+                : (segmentColor[3] / 255) * fillAlpha;
+            opacityNodes.push({
+                x: labelValue,
+                y: segmentOpacity,
+                midpoint: 0.5,
+                sharpness: 1.0,
+            });
+        }
+        else {
+            opacityNodes.push({
+                x: labelValue,
+                y: 0.01,
+                midpoint: 0.5,
+                sharpness: 1.0,
+            });
+        }
+    });
+    cfun.setNodes(colorNodes);
+    ofun.setNodes(opacityNodes);
+    ofun.setClamping(false);
+    const actorMapper = labelmapActorEntry.actorMapper;
+    const labelmapMapper = actorMapper?.mapper
+        ? actorMapper.mapper
+        : labelmapActor.getMapper();
+    const { preLoad } = labelmapActor.get?.('preLoad') || { preLoad: null };
+    if (preLoad) {
+        preLoad({ cfun, ofun, actor: labelmapActor });
+    }
+    else {
+        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
+        labelmapActor.getProperty().setScalarOpacity(0, ofun);
+        labelmapActor.getProperty().setInterpolationTypeToNearest();
+    }
+    if (labelmapActorEntry.actorMapper?.renderMode === ActorRenderMode.VTK_IMAGE ||
+        labelmapActorEntry.actorMapper?.renderMode ===
+            ActorRenderMode.VTK_VOLUME_SLICE) {
+        const imageSlice = labelmapActor;
+        imageSlice.setForceTranslucent(true);
+        imageSlice.setForceOpaque(false);
+        imageSlice.getProperty().setUseLookupTableScalarRange(true);
+    }
+    if (renderOutline) {
+        labelmapActor.getProperty().setUseLabelOutline(renderOutline);
+        labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
+        const activeSegmentIndex = getActiveSegmentIndex(segmentationRepresentation.segmentationId);
+        const outlineWidths = new Array(numColors - 1).fill(0);
+        labelValueEntries.forEach(({ labelValue, segmentIndex }) => {
+            const isHidden = segmentsHidden.has(segmentIndex);
+            if (isHidden) {
+                return;
+            }
+            outlineWidths[labelValue - 1] =
+                segmentIndex === activeSegmentIndex
+                    ? outlineWidth + activeSegmentOutlineWidthDelta
+                    : outlineWidth;
+        });
+        labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
+        labelmapActor.modified();
+        labelmapActor.getProperty().modified();
+        labelmapMapper?.modified?.();
+    }
+    else {
+        labelmapActor
+            .getProperty()
+            .setLabelOutlineThickness(new Array(numColors - 1).fill(0));
+    }
+    const visible = isActiveLabelmap || renderInactiveSegmentations;
+    labelmapActor.setVisibility(visible);
+    labelmapActor.modified();
+    labelmapActor.getProperty().modified();
+    labelmapMapper?.modified?.();
+}
+function getOrCreateTransferFunctions(actor) {
+    const existing = actorTransferFunctions.get(actor);
+    if (existing) {
+        return existing;
+    }
+    const cfun = vtkColorTransferFunction.newInstance();
+    const ofun = vtkPiecewiseFunction.newInstance();
+    ofun.addPoint(0, 0);
+    const created = { cfun, ofun };
+    actorTransferFunctions.set(actor, created);
+    return created;
+}
+function getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
+    const segmentLabelmapConfig = segmentsLabelmapConfig || {};
+    const configToUse = {
+        ...labelmapConfig,
+        ...segmentLabelmapConfig,
+    };
+    return {
+        fillAlpha: isActiveLabelmap
+            ? configToUse.fillAlpha
+            : configToUse.fillAlphaInactive,
+        outlineWidth: isActiveLabelmap
+            ? configToUse.outlineWidth
+            : configToUse.outlineWidthInactive,
+        renderFill: isActiveLabelmap
+            ? configToUse.renderFill
+            : configToUse.renderFillInactive,
+        renderOutline: isActiveLabelmap
+            ? configToUse.renderOutline
+            : configToUse.renderOutlineInactive,
+        outlineOpacity: isActiveLabelmap
+            ? configToUse.outlineOpacity
+            : configToUse.outlineOpacityInactive,
+        activeSegmentOutlineWidthDelta: configToUse.activeSegmentOutlineWidthDelta,
+    };
+}
+export { MAX_NUMBER_COLORS, setLabelmapColorAndOpacity };

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.d.ts

@@ -1,9 +1,10 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
-export declare const MAX_NUMBER_COLORS = 255;
+import { MAX_NUMBER_COLORS } from './labelmapActorStyle';
+export { MAX_NUMBER_COLORS };
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
-declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
-declare function getUpdateFunction(viewport: Types.IVolumeViewport | Types.IStackViewport): (segmentationId: string) => Promise<void> | null;
+declare function render(viewport: Types.IViewport, representation: LabelmapRepresentation): Promise<void>;
+declare function getUpdateFunction(_viewport: Types.IViewport): (segmentationId: string) => Promise<void> | null;
 declare const _default: {
     getUpdateFunction: typeof getUpdateFunction;
     render: typeof render;