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

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

@@ -1,5 +1,6 @@
 const defaultLabelmapConfig = {
     renderOutline: true,
+    renderOutlineInactive: true,
     outlineWidthActive: 3,
     outlineWidthInactive: 2,
     activeSegmentOutlineWidthDelta: 0,
@@ -10,22 +11,7 @@ const defaultLabelmapConfig = {
     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 { cache, getEnabledElementByViewportId, VolumeViewport, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 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/getActiveSegmentation';
 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';
 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 labelmapActor = getSegmentationActor(viewport.id, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
     if (!labelmapData &&
-        canComputeRequestedRepresentation(segmentationRepresentationUID) &&
+        canComputeRequestedRepresentation(segmentationId, Representations.Labelmap) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         labelmapData = await computeAndAddLabelmapRepresentation(segmentationId, {
-            segmentationRepresentationUID,
             viewport,
         });
         if (!labelmapData) {
@@ -73,71 +55,70 @@ async function render(viewport, representation) {
     if (!labelmapData) {
         return;
     }
-    if (isVolumeSegmentation(labelmapData, viewport)) {
-        if (viewport instanceof StackViewport) {
-            return;
-        }
-        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);
+    if (viewport instanceof VolumeViewport) {
+        if (!labelmapActor) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
         }
-        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, colorLUTIndex } = segmentationRepresentation.config;
+    const activeSegmentation = getActiveSegmentation(viewportId);
+    const isActiveLabelmap = activeSegmentation?.segmentationId === segmentationId;
+    const { style: labelmapStyle, renderInactiveSegmentations } = segmentationStyle.getStyle({
+        viewportId,
+        type: Representations.Labelmap,
+        segmentationId,
+    });
     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 = getHiddenSegmentIndices(viewportId, {
+        segmentationId,
+        type: Representations.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 { style: perSegmentStyle } = segmentationStyle.getStyle({
+            viewportId,
+            type: Representations.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,
+            cfun,
+            ofun,
         });
         if (forceColorUpdate) {
             cfun.addRGBPoint(segmentIndex, segmentColor[0] / MAX_NUMBER_COLORS, segmentColor[1] / MAX_NUMBER_COLORS, segmentColor[2] / MAX_NUMBER_COLORS);
@@ -155,13 +136,12 @@ 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);
+    labelmapActor.getProperty().setScalarOpacity(0, ofun);
+    labelmapActor.getProperty().setInterpolationTypeToNearest();
+    labelmapActor.getProperty().setUseLabelOutline(renderOutline);
+    labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
     const { activeSegmentIndex } = getSegmentation(segmentationRepresentation.segmentationId);
     const outlineWidths = new Array(numColors - 1);
     for (let i = 1; i < numColors; i++) {
@@ -175,9 +155,9 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationReprese
                 ? outlineWidth + activeSegmentOutlineWidthDelta
                 : outlineWidth;
     }
-    actor.getProperty().setLabelOutlineThickness(outlineWidths);
-    const visible = isActiveLabelmap || renderInactiveRepresentations;
-    actor.setVisibility(visible);
+    labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
+    const visible = isActiveLabelmap || renderInactiveSegmentations;
+    labelmapActor.setVisibility(visible);
 }
 function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
     const segmentLabelmapConfig = segmentsLabelmapConfig || {};
@@ -194,7 +174,9 @@ function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapCo
     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 +190,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 +200,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 +217,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 +226,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 +236,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;

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

@@ -1,8 +1,8 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-function removeLabelmapFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
+import { getLabelmapActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function removeLabelmapFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
-    viewport.removeActors([segmentationRepresentationUID]);
+    viewport.removeActors([getLabelmapActorUID(segmentationId)]);
 }
 export default removeLabelmapFromElement;
-//# sourceMappingURL=removeLabelmapFromElement.js.map

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

@@ -30,4 +30,3 @@ export function validatePublic(segmentationInput) {
 export function validate(segmentationRepresentationData) {
     validateRepresentationData(segmentationRepresentationData);
 }
-//# sourceMappingURL=validateLabelmap.js.map

package/dist/esm/tools/displayTools/Surface/addOrUpdateSurfaceToElement.d.ts

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-declare function addOrUpdateSurfaceToElement(element: HTMLDivElement, surface: Types.ISurface, segmentationRepresentationUID: string): void;
+declare function addOrUpdateSurfaceToElement(element: HTMLDivElement, surface: Types.ISurface, segmentationId: string): void;
 export default addOrUpdateSurfaceToElement;

package/dist/esm/tools/displayTools/Surface/addOrUpdateSurfaceToElement.js

@@ -3,9 +3,9 @@ import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
 import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
-import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport';
-function addOrUpdateSurfaceToElement(element, surface, segmentationRepresentationUID) {
-    const actorUID = getSurfaceActorUID(segmentationRepresentationUID, surface.id);
+import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
+    const actorUID = getSurfaceActorUID(segmentationId);
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const surfaceActor = viewport.getActor(actorUID)?.actor;
@@ -61,4 +61,3 @@ function addOrUpdateSurfaceToElement(element, surface, segmentationRepresentatio
     }, 0);
 }
 export default addOrUpdateSurfaceToElement;
-//# sourceMappingURL=addOrUpdateSurfaceToElement.js.map

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

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

package/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.d.ts

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

package/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.js

@@ -1,12 +1,13 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
+import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function removeSurfaceFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const actorEntries = viewport.getActors();
+    const actorUID = getSurfaceActorUID(segmentationId);
     const actorUIDsToRemove = actorEntries
-        .map(({ uid }) => uid.startsWith(segmentationRepresentationUID) ? uid : undefined)
+        .map(({ uid }) => (uid.startsWith(actorUID) ? uid : undefined))
         .filter(Boolean);
     viewport.removeActors(actorUIDsToRemove);
 }
-export default removeContourFromElement;
-//# sourceMappingURL=removeSurfaceFromElement.js.map
+export default removeSurfaceFromElement;

package/dist/esm/tools/displayTools/Surface/surfaceConfig.d.ts

@@ -1,3 +1,3 @@
-import type { SurfaceRenderingConfig } from '../../../types/SurfaceTypes';
-declare function getDefaultSurfaceConfig(): SurfaceRenderingConfig;
-export default getDefaultSurfaceConfig;
+import type { SurfaceStyle } from '../../../types/SurfaceTypes';
+declare function getDefaultSurfaceStyle(): SurfaceStyle;
+export default getDefaultSurfaceStyle;

package/dist/esm/tools/displayTools/Surface/surfaceConfig.js

@@ -2,8 +2,7 @@ const defaultSurfaceConfig = {
     renderFill: true,
     fillAlpha: 1,
 };
-function getDefaultSurfaceConfig() {
+function getDefaultSurfaceStyle() {
     return defaultSurfaceConfig;
 }
-export default getDefaultSurfaceConfig;
-//# sourceMappingURL=surfaceConfig.js.map
+export default getDefaultSurfaceStyle;

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.d.ts

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { SegmentationRepresentation } 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.IVolumeViewport | Types.IStackViewport, representation: SegmentationRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.js

@@ -1,27 +1,25 @@
 import { cache, getEnabledElementByViewportId, VolumeViewport3D, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
 import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
 import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
 import { computeAndAddSurfaceRepresentation } from '../../../stateManagement/segmentation/polySeg';
-function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     if (!enabledElement) {
         return;
     }
     const { viewport } = enabledElement;
-    removeSurfaceFromElement(viewport.element, segmentationRepresentationUID);
-    _removeRepresentation(segmentationRepresentationUID);
+    removeSurfaceFromElement(viewport.element, segmentationId);
     if (!renderImmediate) {
         return;
     }
     viewport.render();
 }
 async function render(viewport, representation) {
-    const { colorLUTIndex, segmentationId, segmentationRepresentationUID } = representation;
+    const { segmentationId } = representation;
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         return;
@@ -31,9 +29,9 @@ async function render(viewport, representation) {
     }
     let SurfaceData = segmentation.representationData[Representations.Surface];
     if (!SurfaceData &&
-        canComputeRequestedRepresentation(segmentationRepresentationUID)) {
+        canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
         SurfaceData = await computeAndAddSurfaceRepresentation(segmentationId, {
-            segmentationRepresentationUID,
+            viewport,
         });
         if (!SurfaceData) {
             throw new Error(`No Surface data found for segmentationId ${segmentationId}.`);
@@ -43,6 +41,7 @@ async function render(viewport, representation) {
     if (!geometryIds?.size) {
         console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);
     }
+    const colorLUTIndex = representation.config?.colorLUTIndex;
     const colorLUT = getColorLUT(colorLUTIndex);
     const surfaces = [];
     geometryIds.forEach((geometryId, segmentIndex) => {
@@ -54,7 +53,7 @@ async function render(viewport, representation) {
         const surface = geometry.data;
         const color = colorLUT[segmentIndex];
         surface.setColor(color.slice(0, 3));
-        addOrUpdateSurfaceToElement(viewport.element, surface, segmentationRepresentationUID);
+        addOrUpdateSurfaceToElement(viewport.element, surface, segmentationId);
         surfaces.push(surface);
     });
     viewport.render();
@@ -64,4 +63,3 @@ export default {
     removeRepresentation,
 };
 export { render, removeRepresentation };
-//# sourceMappingURL=surfaceDisplay.js.map

package/dist/esm/tools/distancePointToContour.js

@@ -16,4 +16,3 @@ export const distancePointToContour = (viewport, annotation, coords) => {
     }
     return distance;
 };
-//# sourceMappingURL=distancePointToContour.js.map

package/dist/esm/tools/index.d.ts

@@ -6,7 +6,6 @@ import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
 import PlanarRotateTool from './PlanarRotateTool';
 import ZoomTool from './ZoomTool';
-import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
 import CrosshairsTool from './CrosshairsTool';
 import MagnifyTool from './MagnifyTool';
@@ -47,4 +46,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/index.js

@@ -6,7 +6,6 @@ import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
 import PlanarRotateTool from './PlanarRotateTool';
 import ZoomTool from './ZoomTool';
-import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
 import CrosshairsTool from './CrosshairsTool';
 import MagnifyTool from './MagnifyTool';
@@ -47,5 +46,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
-//# sourceMappingURL=index.js.map
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -56,7 +56,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
@@ -76,7 +75,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
@@ -92,7 +90,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
@@ -108,7 +105,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;