@cornerstonejs/tools 2.0.0-beta.27 → 2.0.0-beta.29

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js

@@ -1,68 +1,38 @@
 import { addAnnotation } from '../../../../stateManagement/annotation/annotationState';
 import { cache, utilities } from '@cornerstonejs/core';
 import { getClosestImageIdForStackViewport } from '../../../../utilities/annotationHydration';
-import { getConfigCache, setConfigCache } from './contourConfigCache';
 import { addContourSegmentationAnnotation } from '../../../../utilities/contourSegmentation';
 import { validateGeometry } from './utils';
-import { getGlobalConfig } from '../../../../stateManagement/segmentation/getGlobalConfig';
-import { getHiddenSegmentIndices } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
-import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config/segmentationConfig';
+import { SegmentationRepresentations } from '../../../../enums';
+import { segmentationStyle } from '../../../../stateManagement/segmentation/SegmentationStyle';
+import { internalGetHiddenSegmentIndices } from '../../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
 function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
-    const addOrUpdateFn = annotationUIDsMap.size
-        ? updateContourSets
-        : addContourSetsToElement;
-    addOrUpdateFn(viewport, geometryIds, contourRepresentation);
-}
-function updateContourSets(viewport, geometryIds, contourRepresentation) {
-    const { segmentationRepresentationUID, config } = contourRepresentation;
-    const baseConfig = config?.allSegments;
-    const globalContourConfig = getGlobalConfig().representations.Contour;
-    const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
-    const cachedConfig = getConfigCache(segmentationRepresentationUID);
-    const newOutlineWithActive = newContourConfig.outlineWidthActive;
-    if (cachedConfig?.outlineWidthActive !== newOutlineWithActive) {
-        setConfigCache(segmentationRepresentationUID, Object.assign({}, cachedConfig, {
-            outlineWidthActive: newOutlineWithActive,
-        }));
+    if (annotationUIDsMap.size) {
+        updateContourSets(viewport, geometryIds, contourRepresentation);
     }
-    const segmentsToSetToInvisible = [];
-    const segmentsToSetToVisible = [];
-    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
-    for (const segmentIndex of segmentsHidden) {
-        if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
-            segmentsToSetToInvisible.push(segmentIndex);
-        }
-    }
-    for (const segmentIndex of cachedConfig.segmentsHidden) {
-        if (!segmentsHidden.has(segmentIndex)) {
-            segmentsToSetToVisible.push(segmentIndex);
-        }
+    else {
+        addContourSetsToElement(viewport, geometryIds, contourRepresentation);
     }
-    const mergedInvisibleSegments = Array.from(cachedConfig.segmentsHidden)
-        .filter((segmentIndex) => !segmentsToSetToVisible.includes(segmentIndex))
-        .concat(segmentsToSetToInvisible);
+}
+function updateContourSets(viewport, geometryIds, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
     const { segmentSpecificConfigs } = geometryIds.reduce((acc, geometryId) => {
         const geometry = cache.getGeometry(geometryId);
         const { data: contourSet } = geometry;
         const segmentIndex = contourSet.getSegmentIndex();
-        const segmentSpecificConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
+        const segmentSpecificConfig = segmentationStyle.getStyle({
+            viewportId: viewport.id,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
         acc.segmentSpecificConfigs[segmentIndex] = segmentSpecificConfig ?? {};
         return acc;
     }, { contourSets: [], segmentSpecificConfigs: {} });
-    const affectedSegments = [
-        ...mergedInvisibleSegments,
-        ...segmentsToSetToVisible,
-    ];
-    const hasCustomSegmentSpecificConfig = Object.values(segmentSpecificConfigs).some((config) => Object.keys(config).length > 0);
-    if (affectedSegments.length || hasCustomSegmentSpecificConfig) {
-        setConfigCache(segmentationRepresentationUID, Object.assign({}, cachedConfig, {
-            segmentsHidden: new Set(segmentsHidden),
-        }));
-    }
     viewport.render();
 }
 function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
-    const { segmentationRepresentationUID, segmentationId } = contourRepresentation;
+    const { segmentationId } = contourRepresentation;
     const segmentSpecificMap = new Map();
     geometryIds.forEach((geometryId) => {
         const geometry = cache.getGeometry(geometryId);
@@ -72,7 +42,12 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
         }
         const segmentIndex = geometry.data.getSegmentIndex();
         validateGeometry(geometry);
-        const segmentSpecificConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
+        const segmentSpecificConfig = segmentationStyle.getStyle({
+            viewportId: viewport.id,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
         const contourSet = geometry.data;
         contourSet.contours.forEach((contour) => {
             const { points, color, id } = contour;
@@ -112,18 +87,7 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
             segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
         }
     });
-    const baseConfig = contourRepresentation.config?.allSegments;
-    const globalContourConfig = getGlobalConfig().representations.Contour;
-    const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
-    const outlineWidthActive = newContourConfig.outlineWidthActive;
-    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
-    setConfigCache(segmentationRepresentationUID, Object.assign({}, getConfigCache(segmentationRepresentationUID), {
-        segmentsHidden: new Set(segmentsHidden),
-        segmentSpecificMap,
-        outlineWidthActive,
-    }));
     viewport.resetCamera();
     viewport.render();
 }
 export { handleContourSegmentation, updateContourSets, addContourSetsToElement, };
-//# sourceMappingURL=handleContourSegmentation.js.map

package/dist/esm/tools/displayTools/Contour/contourHandler/utils.js

@@ -39,4 +39,3 @@ export function getPolyData(contourSet) {
     polygon.setLines(lines);
     return polygon;
 }
-//# sourceMappingURL=utils.js.map

package/dist/esm/tools/displayTools/Contour/index.js

@@ -1,3 +1,2 @@
 import contourDisplay from './contourDisplay';
 export { contourDisplay };
-//# sourceMappingURL=index.js.map

package/dist/esm/tools/displayTools/Contour/removeContourFromElement.d.ts

@@ -1,2 +1,2 @@
-declare function removeContourFromElement(element: HTMLDivElement, segmentationRepresentationUID: string, removeFromCache?: boolean): void;
+declare function removeContourFromElement(viewportId: string, segmentationId: string, removeFromCache?: boolean): void;
 export default removeContourFromElement;

package/dist/esm/tools/displayTools/Contour/removeContourFromElement.js

@@ -1,8 +1,6 @@
-import { getSegmentationRepresentation, getSegmentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { removeAnnotation } from '../../../stateManagement';
-function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
-    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
-    const { segmentationId } = segmentationRepresentation;
+function removeContourFromElement(viewportId, segmentationId, removeFromCache = false) {
     const segmentation = getSegmentation(segmentationId);
     const { annotationUIDsMap } = segmentation.representationData.Contour;
     annotationUIDsMap.forEach((annotationSet) => {
@@ -12,4 +10,3 @@ function removeContourFromElement(element, segmentationRepresentationUID, remove
     });
 }
 export default removeContourFromElement;
-//# sourceMappingURL=removeContourFromElement.js.map

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

@@ -1,3 +1,3 @@
 import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
-declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationRepresentationUID: string): Promise<void>;
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string): Promise<void>;
 export default addLabelmapToElement;

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

@@ -1,19 +1,26 @@
-import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, } from '@cornerstonejs/core';
-import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { getSegmentationRepresentation } from '../../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, cache, BaseVolumeViewport, volumeLoader, utilities, } from '@cornerstonejs/core';
 import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
-async function addLabelmapToElement(element, labelMapData, segmentationRepresentationUID) {
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { triggerSegmentationModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { SegmentationRepresentations } from '../../../enums';
+const { uuidv4 } = utilities;
+async function addLabelmapToElement(element, labelMapData, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
     const { id: viewportId } = viewport;
     const visibility = true;
     const immediateRender = false;
     const suppressEvents = true;
-    if (isVolumeSegmentation(labelMapData, viewport)) {
+    if (viewport instanceof BaseVolumeViewport) {
+        const volumeLabelMapData = labelMapData;
+        const volumeId = _ensureVolumeHasVolumeId(volumeLabelMapData, segmentationId);
+        if (!cache.getVolume(volumeId)) {
+            await _handleMissingVolume(labelMapData);
+        }
         const volumeInputs = [
             {
-                volumeId: labelMapData.volumeId,
-                actorUID: segmentationRepresentationUID,
+                volumeId,
+                actorUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
                 visibility,
                 blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
             },
@@ -21,16 +28,37 @@ async function addLabelmapToElement(element, labelMapData, segmentationRepresent
         await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
     }
     else {
-        const representation = getSegmentationRepresentation(segmentationRepresentationUID);
-        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, representation.segmentationId);
+        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         const stackInputs = [
             {
                 imageId: segmentationImageId,
-                actorUID: segmentationRepresentationUID,
+                actorUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
             },
         ];
         await addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
     }
 }
+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;
+}
 export default addLabelmapToElement;
-//# sourceMappingURL=addLabelmapToElement.js.map

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

@@ -2,4 +2,3 @@ import labelmapDisplay from './labelmapDisplay';
 import labelmapConfig from './labelmapConfig';
 import { validate as validateLabelmap, validatePublic as validateLabelmapPublic, } from './validateLabelmap';
 export { labelmapDisplay, labelmapConfig, validateLabelmap, validateLabelmapPublic, };
-//# sourceMappingURL=index.js.map

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

@@ -1,5 +1,3 @@
-import type { LabelmapConfig } from '../../../types/LabelmapTypes';
-declare function getDefaultLabelmapConfig(): LabelmapConfig;
-declare function isValidLabelmapConfig(config: any): boolean;
-export default getDefaultLabelmapConfig;
-export { isValidLabelmapConfig };
+import type { LabelmapStyle } from '../../../types/LabelmapTypes';
+declare function getDefaultLabelmapStyle(): LabelmapStyle;
+export default getDefaultLabelmapStyle;

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

@@ -1,31 +1,17 @@
 const defaultLabelmapConfig = {
     renderOutline: true,
-    outlineWidthActive: 3,
+    renderOutlineInactive: true,
+    outlineWidth: 3,
     outlineWidthInactive: 2,
     activeSegmentOutlineWidthDelta: 0,
     renderFill: true,
     renderFillInactive: true,
-    fillAlpha: 0.7,
-    fillAlphaInactive: 0.65,
+    fillAlpha: 0.5,
+    fillAlphaInactive: 0.4,
     outlineOpacity: 1,
     outlineOpacityInactive: 0.85,
 };
-function getDefaultLabelmapConfig() {
+function getDefaultLabelmapStyle() {
     return defaultLabelmapConfig;
 }
-function isValidLabelmapConfig(config) {
-    return (config &&
-        typeof config.renderOutline === 'boolean' &&
-        typeof config.outlineWidthActive === 'number' &&
-        typeof config.outlineWidthInactive === 'number' &&
-        typeof config.activeSegmentOutlineWidthDelta === 'number' &&
-        typeof config.renderFill === 'boolean' &&
-        typeof config.renderFillInactive === 'boolean' &&
-        typeof config.fillAlpha === 'number' &&
-        typeof config.fillAlphaInactive === 'number' &&
-        typeof config.outlineOpacity === 'number' &&
-        typeof config.outlineOpacityInactive === 'number');
-}
-export default getDefaultLabelmapConfig;
-export { isValidLabelmapConfig };
-//# sourceMappingURL=labelmapConfig.js.map
+export default getDefaultLabelmapStyle;

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
-declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;

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

@@ -1,68 +1,50 @@
-import { cache, getEnabledElementByViewportId, StackViewport, VolumeViewport, } from '@cornerstonejs/core';
-import Representations from '../../../enums/SegmentationRepresentations';
+import { getEnabledElementByViewportId, VolumeViewport, } from '@cornerstonejs/core';
 import addLabelmapToElement from './addLabelmapToElement';
 import removeLabelmapFromElement from './removeLabelmapFromElement';
-import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { getHiddenSegmentIndices } from '../../../stateManagement/segmentation/config/segmentationVisibility';
-import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
-import { getActiveSegmentationRepresentation } from '../../../stateManagement/segmentation/getActiveSegmentationRepresentation';
+import { getActiveSegmentation } from '../../../stateManagement/segmentation/activeSegmentation';
 import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
 import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
-import { getGlobalConfig } from '../../../stateManagement/segmentation/getGlobalConfig';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
 import { computeAndAddLabelmapRepresentation } from '../../../stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation';
+import { getSegmentationActor } from '../../../stateManagement/segmentation/helpers';
+import { segmentationStyle } from '../../../stateManagement/segmentation/SegmentationStyle';
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
 let polySegConversionInProgress = false;
-function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
+    _cleanupLabelMapConfigCache(viewportId, segmentationId);
     if (!enabledElement) {
         return;
     }
     const { viewport } = enabledElement;
-    removeLabelmapFromElement(viewport.element, segmentationRepresentationUID);
-    _removeRepresentation(segmentationRepresentationUID);
+    removeLabelmapFromElement(viewport.element, segmentationId);
     if (!renderImmediate) {
         return;
     }
     viewport.render();
 }
-function isSameFrameOfReference(viewport, referencedVolumeId) {
-    if (!referencedVolumeId) {
-        return true;
-    }
-    const defaultActor = viewport.getDefaultActor();
-    if (!defaultActor) {
-        return false;
-    }
-    const { uid: defaultActorUID } = defaultActor;
-    const volume = cache.getVolume(defaultActorUID);
-    if (volume) {
-        const referencedVolume = cache.getVolume(referencedVolumeId);
-        if (referencedVolume &&
-            volume.metadata.FrameOfReferenceUID ===
-                referencedVolume.metadata.FrameOfReferenceUID) {
-            return true;
-        }
-    }
-    return false;
-}
 async function render(viewport, representation) {
-    const { segmentationId, segmentationRepresentationUID } = representation;
+    const { segmentationId } = representation;
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
         return;
     }
-    let labelmapData = segmentation.representationData[Representations.Labelmap];
-    let actorEntry = viewport.getActor(segmentationRepresentationUID);
+    let labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
+    let labelmapActor = getSegmentationActor(viewport.id, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
     if (!labelmapData &&
-        canComputeRequestedRepresentation(segmentationRepresentationUID) &&
+        canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations.Labelmap) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         labelmapData = await computeAndAddLabelmapRepresentation(segmentationId, {
-            segmentationRepresentationUID,
             viewport,
         });
         if (!labelmapData) {
@@ -73,71 +55,72 @@ async function render(viewport, representation) {
     if (!labelmapData) {
         return;
     }
-    if (isVolumeSegmentation(labelmapData, viewport)) {
-        if (viewport instanceof StackViewport) {
-            return;
+    if (viewport instanceof VolumeViewport) {
+        if (!labelmapActor) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
         }
-        const { volumeId: labelmapUID } = labelmapData;
-        const labelmap = cache.getVolume(labelmapUID);
-        if (!labelmap) {
-            throw new Error(`No Labelmap found for volumeId: ${labelmapUID}`);
-        }
-        if (!isSameFrameOfReference(viewport, labelmapData?.referencedVolumeId)) {
-            return;
-        }
-        if (!actorEntry) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationRepresentationUID);
-        }
-        actorEntry = viewport.getActor(segmentationRepresentationUID);
+        labelmapActor = getSegmentationActor(viewport.id, {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        });
     }
     else {
-        if (viewport instanceof VolumeViewport) {
-            return;
-        }
         const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         if (!labelmapImageId) {
             return;
         }
-        if (!actorEntry) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationRepresentationUID);
+        if (!labelmapActor) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
         }
-        actorEntry = viewport.getActor(segmentationRepresentationUID);
+        labelmapActor = getSegmentationActor(viewport.id, {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        });
     }
-    if (!actorEntry) {
+    if (!labelmapActor) {
         return;
     }
-    _setLabelmapColorAndOpacity(viewport.id, actorEntry, representation);
+    _setLabelmapColorAndOpacity(viewport.id, labelmapActor, representation);
 }
-function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationRepresentation) {
-    const { rendering, config, colorLUTIndex } = segmentationRepresentation;
-    const activeSegRep = getActiveSegmentationRepresentation(viewportId);
-    const isActiveLabelmap = activeSegRep === segmentationRepresentation;
-    const { cfun, ofun } = rendering;
-    const { allSegments, perSegment } = config;
-    const globalLabelmapConfig = getGlobalConfig().representations[Representations.Labelmap];
-    const globalConfig = getGlobalConfig();
-    const renderInactiveRepresentations = globalConfig.renderInactiveRepresentations;
-    const configToUse = {
-        ...globalLabelmapConfig,
-        ...allSegments[Representations.Labelmap],
-    };
-    const labelmapConfig = configToUse;
+function _setLabelmapColorAndOpacity(viewportId, labelmapActor, segmentationRepresentation) {
+    const { segmentationId } = segmentationRepresentation;
+    const { cfun, ofun } = segmentationRepresentation.config;
+    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 numColors = Math.min(256, colorLUT.length);
-    const { uid: actorUID } = actorEntry;
-    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap);
-    const segmentsHidden = getHiddenSegmentIndices(viewportId, segmentationRepresentation.segmentationRepresentationUID);
+    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapStyle, isActiveLabelmap);
+    const segmentsHidden = internalGetHiddenSegmentIndices(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
     for (let i = 0; i < numColors; i++) {
         const segmentIndex = i;
         const segmentColor = colorLUT[segmentIndex];
-        const segmentSpecificLabelmapConfig = perSegment?.[segmentIndex]?.[Representations.Labelmap];
-        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentSpecificLabelmapConfig);
-        const { forceOpacityUpdate, forceColorUpdate } = _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, {
+        const perSegmentStyle = segmentationStyle.getStyle({
+            viewportId,
+            type: SegmentationRepresentations.Labelmap,
+            segmentationId,
+            segmentIndex,
+        });
+        const segmentSpecificLabelmapConfig = perSegmentStyle;
+        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(labelmapStyle, isActiveLabelmap, segmentSpecificLabelmapConfig);
+        const { forceOpacityUpdate, forceColorUpdate } = _needsTransferFunctionUpdate(viewportId, segmentationId, segmentIndex, {
             fillAlpha,
             renderFill,
             renderOutline,
             segmentColor,
             outlineWidth,
+            segmentsHidden: segmentsHidden,
+            cfun,
+            ofun,
         });
         if (forceColorUpdate) {
             cfun.addRGBPoint(segmentIndex, segmentColor[0] / MAX_NUMBER_COLORS, segmentColor[1] / MAX_NUMBER_COLORS, segmentColor[2] / MAX_NUMBER_COLORS);
@@ -155,29 +138,35 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationReprese
             }
         }
     }
-    const actor = actorEntry.actor;
-    actor.getProperty().setRGBTransferFunction(0, cfun);
+    labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
     ofun.setClamping(false);
-    actor.getProperty().setScalarOpacity(0, ofun);
-    actor.getProperty().setInterpolationTypeToNearest();
-    actor.getProperty().setUseLabelOutline(renderOutline);
-    actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-    const { activeSegmentIndex } = getSegmentation(segmentationRepresentation.segmentationId);
-    const outlineWidths = new Array(numColors - 1);
-    for (let i = 1; i < numColors; i++) {
-        const isHidden = segmentsHidden.has(i);
-        if (isHidden) {
-            outlineWidths[i - 1] = 0;
-            continue;
+    labelmapActor.getProperty().setScalarOpacity(0, ofun);
+    labelmapActor.getProperty().setInterpolationTypeToNearest();
+    if (renderOutline) {
+        labelmapActor.getProperty().setUseLabelOutline(renderOutline);
+        labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
+        const activeSegmentIndex = getActiveSegmentIndex(segmentationRepresentation.segmentationId);
+        const outlineWidths = new Array(numColors - 1);
+        for (let i = 1; i < numColors; i++) {
+            const isHidden = segmentsHidden.has(i);
+            if (isHidden) {
+                outlineWidths[i - 1] = 0;
+                continue;
+            }
+            outlineWidths[i - 1] =
+                i === activeSegmentIndex
+                    ? outlineWidth + activeSegmentOutlineWidthDelta
+                    : outlineWidth;
         }
-        outlineWidths[i - 1] =
-            i === activeSegmentIndex
-                ? outlineWidth + activeSegmentOutlineWidthDelta
-                : outlineWidth;
+        labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
     }
-    actor.getProperty().setLabelOutlineThickness(outlineWidths);
-    const visible = isActiveLabelmap || renderInactiveRepresentations;
-    actor.setVisibility(visible);
+    else {
+        labelmapActor
+            .getProperty()
+            .setLabelOutlineThickness(new Array(numColors - 1).fill(0));
+    }
+    const visible = isActiveLabelmap || renderInactiveSegmentations;
+    labelmapActor.setVisibility(visible);
 }
 function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
     const segmentLabelmapConfig = segmentsLabelmapConfig || {};
@@ -189,12 +178,14 @@ function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapCo
         ? configToUse.fillAlpha
         : configToUse.fillAlphaInactive;
     const outlineWidth = isActiveLabelmap
-        ? configToUse.outlineWidthActive
+        ? configToUse.outlineWidth
         : configToUse.outlineWidthInactive;
     const renderFill = isActiveLabelmap
         ? configToUse.renderFill
         : configToUse.renderFillInactive;
-    const renderOutline = configToUse.renderOutline;
+    const renderOutline = isActiveLabelmap
+        ? configToUse.renderOutline
+        : configToUse.renderOutlineInactive;
     const outlineOpacity = isActiveLabelmap
         ? configToUse.outlineOpacity
         : configToUse.outlineOpacityInactive;
@@ -208,7 +199,7 @@ function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapCo
         activeSegmentOutlineWidthDelta,
     };
 }
-function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fillAlpha, renderFill, renderOutline, segmentColor, outlineWidth, }) {
+function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fillAlpha, renderFill, renderOutline, segmentColor, outlineWidth, segmentsHidden, cfun, ofun, }) {
     const cacheUID = `${viewportId}-${actorUID}-${segmentIndex}`;
     const oldConfig = labelMapConfigCache.get(cacheUID);
     if (!oldConfig) {
@@ -218,13 +209,16 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
             renderOutline,
             outlineWidth,
             segmentColor: segmentColor.slice(),
+            segmentsHidden: new Set(segmentsHidden),
+            cfunMTime: cfun.getMTime(),
+            ofunMTime: ofun.getMTime(),
         });
         return {
             forceOpacityUpdate: true,
             forceColorUpdate: true,
         };
     }
-    const { fillAlpha: oldFillAlpha, renderFill: oldRenderFill, renderOutline: oldRenderOutline, outlineWidth: oldOutlineWidth, segmentColor: oldSegmentColor, } = oldConfig;
+    const { fillAlpha: oldFillAlpha, renderFill: oldRenderFill, renderOutline: oldRenderOutline, outlineWidth: oldOutlineWidth, segmentColor: oldSegmentColor, segmentsHidden: oldSegmentsHidden, cfunMTime: oldCfunMTime, ofunMTime: oldOfunMTime, } = oldConfig;
     const forceColorUpdate = oldSegmentColor[0] !== segmentColor[0] ||
         oldSegmentColor[1] !== segmentColor[1] ||
         oldSegmentColor[2] !== segmentColor[2];
@@ -232,7 +226,8 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
         oldFillAlpha !== fillAlpha ||
         oldRenderFill !== renderFill ||
         oldRenderOutline !== renderOutline ||
-        oldOutlineWidth !== outlineWidth;
+        oldOutlineWidth !== outlineWidth ||
+        oldSegmentsHidden !== segmentsHidden;
     if (forceOpacityUpdate || forceColorUpdate) {
         labelMapConfigCache.set(cacheUID, {
             fillAlpha,
@@ -240,6 +235,9 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
             renderOutline,
             outlineWidth,
             segmentColor: segmentColor.slice(),
+            segmentsHidden: new Set(segmentsHidden),
+            cfunMTime: cfun.getMTime(),
+            ofunMTime: ofun.getMTime(),
         });
     }
     return {
@@ -247,12 +245,18 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
         forceColorUpdate,
     };
 }
-async function _addLabelmapToViewport(viewport, labelmapData, segmentationRepresentationUID) {
-    await addLabelmapToElement(viewport.element, labelmapData, segmentationRepresentationUID);
+async function _addLabelmapToViewport(viewport, labelmapData, segmentationId) {
+    await addLabelmapToElement(viewport.element, labelmapData, segmentationId);
+}
+function _cleanupLabelMapConfigCache(viewportId, segmentationId) {
+    for (const key of labelMapConfigCache.keys()) {
+        if (key.startsWith(`${viewportId}-${segmentationId}-`)) {
+            labelMapConfigCache.delete(key);
+        }
+    }
 }
 export default {
     render,
     removeRepresentation,
 };
 export { render, removeRepresentation };
-//# sourceMappingURL=labelmapDisplay.js.map

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

@@ -1,2 +1,2 @@
-declare function removeLabelmapFromElement(element: HTMLDivElement, segmentationRepresentationUID: string, removeFromCache?: boolean): void;
+declare function removeLabelmapFromElement(element: HTMLDivElement, segmentationId: string): void;
 export default removeLabelmapFromElement;