@cornerstonejs/tools 2.0.0-beta.17 → 2.0.0-beta.18

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

@@ -1,37 +1,36 @@
-import { getEnabledElementByIds, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
-import removeContourFromElement from './removeContourFromElement';
 import { deleteConfigCache } from './contourHandler/contourConfigCache';
 import { polySeg } from '../../../stateManagement/segmentation';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
 let polySegConversionInProgress = false;
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, renderImmediate = false) {
-    _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID);
-    SegmentationState.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
+function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    SegmentationState.removeRepresentation(segmentationRepresentationUID);
     deleteConfigCache(segmentationRepresentationUID);
-    if (renderImmediate) {
-        const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-            enabledElement.viewport.render();
-        });
+    if (!renderImmediate) {
+        return;
     }
+    viewport.render();
 }
-async function render(viewport, representationConfig, toolGroupConfig) {
-    const { segmentationId } = representationConfig;
+async function render(viewport, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
     const segmentation = SegmentationState.getSegmentation(segmentationId);
     if (!segmentation) {
         return;
     }
     let contourData = segmentation.representationData[Representations.Contour];
     if (!contourData &&
-        polySeg.canComputeRequestedRepresentation(representationConfig.segmentationRepresentationUID) &&
+        polySeg.canComputeRequestedRepresentation(contourRepresentation.segmentationRepresentationUID) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         contourData = await polySeg.computeAndAddContourRepresentation(segmentationId, {
-            segmentationRepresentationUID: representationConfig.segmentationRepresentationUID,
+            segmentationRepresentationUID: contourRepresentation.segmentationRepresentationUID,
             viewport,
         });
     }
@@ -39,22 +38,10 @@ async function render(viewport, representationConfig, toolGroupConfig) {
         return;
     }
     if (contourData?.geometryIds?.length) {
-        handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, representationConfig, toolGroupConfig);
-    }
-}
-function _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID) {
-    const toolGroup = getToolGroup(toolGroupId);
-    if (toolGroup === undefined) {
-        throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
-    }
-    const { viewportsInfo } = toolGroup;
-    for (const viewportInfo of viewportsInfo) {
-        const { viewportId, renderingEngineId } = viewportInfo;
-        const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-        removeContourFromElement(segmentationRepresentationUID, toolGroupId);
+        handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, contourRepresentation);
     }
 }
 export default {
     render,
-    removeSegmentationRepresentation,
+    removeRepresentation,
 };

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.d.ts

@@ -1,6 +1,6 @@
 import { Types, StackViewport } from '@cornerstonejs/core';
-import { SegmentationRepresentationConfig, ToolGroupSpecificContourRepresentation } from '../../../../types';
-declare function handleContourSegmentation(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], annotationUIDsMap: Map<number, Set<string>>, contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;
-declare function updateContourSets(viewport: Types.IVolumeViewport | StackViewport, geometryIds: string[], contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;
-declare function addContourSetsToElement(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;
+import { ContourRepresentation } from '../../../../types/SegmentationStateTypes';
+declare function handleContourSegmentation(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], annotationUIDsMap: Map<number, Set<string>>, contourRepresentation: ContourRepresentation): void;
+declare function updateContourSets(viewport: Types.IVolumeViewport | StackViewport, geometryIds: string[], contourRepresentation: ContourRepresentation): void;
+declare function addContourSetsToElement(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], contourRepresentation: ContourRepresentation): void;
 export { handleContourSegmentation, updateContourSets, addContourSetsToElement, };

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

@@ -2,18 +2,22 @@ import { addAnnotation } from '../../../../stateManagement';
 import { cache, utilities } from '@cornerstonejs/core';
 import { getClosestImageIdForStackViewport } from '../../../../utilities/annotationHydration';
 import { getConfigCache, setConfigCache } from './contourConfigCache';
-import { getSegmentSpecificConfig } from './utils';
 import { addContourSegmentationAnnotation } from '../../../../utilities/contourSegmentation';
 import { validateGeometry } from './utils';
-function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation, contourRepresentationConfig) {
+import { getGlobalConfig, } from '../../../../stateManagement/segmentation/segmentationState';
+import { getSegmentsHidden } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
+import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config';
+function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
     const addOrUpdateFn = annotationUIDsMap.size
         ? updateContourSets
         : addContourSetsToElement;
-    addOrUpdateFn(viewport, geometryIds, contourRepresentation, contourRepresentationConfig);
+    addOrUpdateFn(viewport, geometryIds, contourRepresentation);
 }
-function updateContourSets(viewport, geometryIds, contourRepresentation, contourRepresentationConfig) {
-    const { segmentationRepresentationUID, segmentsHidden } = contourRepresentation;
-    const newContourConfig = contourRepresentationConfig.representations.CONTOUR;
+function updateContourSets(viewport, geometryIds, contourRepresentation) {
+    const { segmentationRepresentationUID, config } = contourRepresentation;
+    const baseConfig = config?.allSegments?.CONTOUR;
+    const globalContourConfig = getGlobalConfig().representations.CONTOUR;
+    const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
     const cachedConfig = getConfigCache(segmentationRepresentationUID);
     const newOutlineWithActive = newContourConfig.outlineWidthActive;
     if (cachedConfig?.outlineWidthActive !== newOutlineWithActive) {
@@ -23,6 +27,7 @@ function updateContourSets(viewport, geometryIds, contourRepresentation, contour
     }
     const segmentsToSetToInvisible = [];
     const segmentsToSetToVisible = [];
+    const segmentsHidden = getSegmentsHidden(viewport.id, segmentationRepresentationUID);
     for (const segmentIndex of segmentsHidden) {
         if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
             segmentsToSetToInvisible.push(segmentIndex);
@@ -40,7 +45,7 @@ function updateContourSets(viewport, geometryIds, contourRepresentation, contour
         const geometry = cache.getGeometry(geometryId);
         const { data: contourSet } = geometry;
         const segmentIndex = contourSet.getSegmentIndex();
-        const segmentSpecificConfig = getSegmentSpecificConfig(contourRepresentation, geometryId, segmentIndex);
+        const segmentSpecificConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
         acc.segmentSpecificConfigs[segmentIndex] = segmentSpecificConfig ?? {};
         return acc;
     }, { contourSets: [], segmentSpecificConfigs: {} });
@@ -56,8 +61,8 @@ function updateContourSets(viewport, geometryIds, contourRepresentation, contour
     }
     viewport.render();
 }
-function addContourSetsToElement(viewport, geometryIds, contourRepresentation, contourRepresentationConfig) {
-    const { segmentationRepresentationUID, segmentationId, segmentsHidden } = contourRepresentation;
+function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
+    const { segmentationRepresentationUID, segmentationId } = contourRepresentation;
     const segmentSpecificMap = new Map();
     geometryIds.forEach((geometryId) => {
         const geometry = cache.getGeometry(geometryId);
@@ -67,7 +72,7 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation, c
         }
         const segmentIndex = geometry.data.getSegmentIndex();
         validateGeometry(geometry);
-        const segmentSpecificConfig = getSegmentSpecificConfig(contourRepresentation, geometryId, segmentIndex);
+        const segmentSpecificConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
         const contourSet = geometry.data;
         contourSet.contours.forEach((contour) => {
             const { points, color, id } = contour;
@@ -107,7 +112,11 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation, c
             segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
         }
     });
-    const outlineWidthActive = contourRepresentationConfig.representations.CONTOUR.outlineWidthActive;
+    const baseConfig = contourRepresentation.config?.allSegments.CONTOUR;
+    const globalContourConfig = getGlobalConfig().representations.CONTOUR;
+    const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
+    const outlineWidthActive = newContourConfig.outlineWidthActive;
+    const segmentsHidden = getSegmentsHidden(viewport.id, segmentationRepresentationUID);
     setConfigCache(segmentationRepresentationUID, Object.assign({}, getConfigCache(segmentationRepresentationUID), {
         segmentsHidden: new Set(segmentsHidden),
         segmentSpecificMap,

package/dist/esm/tools/displayTools/Contour/contourHandler/utils.d.ts

@@ -1,6 +1,4 @@
 import { Types } from '@cornerstonejs/core';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-import { ToolGroupSpecificContourRepresentation } from '../../../../types';
-export declare function getSegmentSpecificConfig(contourRepresentation: ToolGroupSpecificContourRepresentation, segmentId: string, index: number): import("../../../../types/ContourTypes").ContourConfig;
 export declare function validateGeometry(geometry: Types.IGeometry): void;
 export declare function getPolyData(contourSet: Types.IContourSet): vtkPolyData;

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

@@ -2,17 +2,6 @@ import { Enums } from '@cornerstonejs/core';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
 import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-export function getSegmentSpecificConfig(contourRepresentation, segmentId, index) {
-    let segmentSpecificConfig = contourRepresentation.segmentSpecificConfig?.[segmentId];
-    if (!segmentSpecificConfig) {
-        segmentSpecificConfig =
-            contourRepresentation.segmentSpecificConfig?.[index];
-    }
-    if (!segmentSpecificConfig) {
-        return null;
-    }
-    return segmentSpecificConfig.CONTOUR;
-}
 export function validateGeometry(geometry) {
     if (!geometry) {
         throw new Error(`No contours found for geometryId ${geometry.id}`);

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

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

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

@@ -1,7 +1,7 @@
-import { getSegmentationRepresentationByUID, getSegmentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getRepresentation, getSegmentation, } from '../../../stateManagement/segmentation/segmentationState';
 import { removeAnnotation } from '../../../stateManagement';
-function removeContourFromElement(segmentationRepresentationUID, toolGroupId, removeFromCache = false) {
-    const segmentationRepresentation = getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
+    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
     const { segmentationId } = segmentationRepresentation;
     const segmentation = getSegmentation(segmentationId);
     const { annotationUIDsMap } = segmentation.representationData.CONTOUR;

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

@@ -1,17 +1,17 @@
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import { Types } from '@cornerstonejs/core';
-import { SegmentationRepresentationConfig, ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
+import { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
 declare function getRepresentationRenderingConfig(): {
     ofun: vtkPiecewiseFunction;
     cfun: vtkColorTransferFunction;
 };
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
-declare function render(viewport: Types.IVolumeViewport | Types.IStackViewport, representation: ToolGroupSpecificRepresentation, toolGroupConfig: SegmentationRepresentationConfig): Promise<void>;
+declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
 declare const _default: {
     getRepresentationRenderingConfig: typeof getRepresentationRenderingConfig;
     render: typeof render;
-    removeSegmentationRepresentation: typeof removeSegmentationRepresentation;
+    removeRepresentation: typeof removeRepresentation;
 };
 export default _default;
-export { getRepresentationRenderingConfig, render, removeSegmentationRepresentation, };
+export { getRepresentationRenderingConfig, render, removeRepresentation };

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

@@ -1,13 +1,13 @@
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { cache, getEnabledElementByIds, StackViewport, VolumeViewport, } from '@cornerstonejs/core';
+import { cache, getEnabledElementByViewportId, StackViewport, VolumeViewport, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
 import addLabelmapToElement from './addLabelmapToElement';
 import removeLabelmapFromElement from './removeLabelmapFromElement';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
 import { polySeg } from '../../../stateManagement/segmentation';
+import { getSegmentsHidden } from '../../../stateManagement/segmentation/config/segmentationVisibility';
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
 function getRepresentationRenderingConfig() {
@@ -20,16 +20,18 @@ function getRepresentationRenderingConfig() {
     };
 }
 let polySegConversionInProgress = false;
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, renderImmediate = false) {
-    _removeLabelmapFromToolGroupViewports(toolGroupId, segmentationRepresentationUID);
-    SegmentationState.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    if (renderImmediate) {
-        const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-            enabledElement.viewport.render();
-        });
+function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
     }
+    const { viewport } = enabledElement;
+    removeLabelmapFromElement(viewport.element, segmentationRepresentationUID);
+    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    if (!renderImmediate) {
+        return;
+    }
+    viewport.render();
 }
 function isSameFrameOfReference(viewport, referencedVolumeId) {
     if (!referencedVolumeId) {
@@ -51,8 +53,8 @@ function isSameFrameOfReference(viewport, referencedVolumeId) {
     }
     return false;
 }
-async function render(viewport, representation, toolGroupConfig) {
-    const { colorLUTIndex, active, segmentationId, segmentationRepresentationUID, segmentsHidden, config: renderingConfig, } = representation;
+async function render(viewport, representation) {
+    const { segmentationId, segmentationRepresentationUID } = representation;
     const segmentation = SegmentationState.getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
@@ -110,29 +112,38 @@ async function render(viewport, representation, toolGroupConfig) {
     if (!actorEntry) {
         return;
     }
-    const { cfun, ofun } = renderingConfig;
-    const renderInactiveSegmentations = toolGroupConfig.renderInactiveSegmentations;
-    _setLabelmapColorAndOpacity(viewport.id, actorEntry, cfun, ofun, colorLUTIndex, toolGroupConfig.representations[Representations.Labelmap], representation, active, renderInactiveSegmentations, segmentsHidden);
+    _setLabelmapColorAndOpacity(viewport.id, actorEntry, representation);
 }
-function _setLabelmapColorAndOpacity(viewportId, actorEntry, cfun, ofun, colorLUTIndex, toolGroupLabelmapConfig, segmentationRepresentation, isActiveLabelmap, renderInactiveSegmentations, segmentsHidden) {
-    const { segmentSpecificConfig, segmentationRepresentationSpecificConfig } = segmentationRepresentation;
-    const segmentationRepresentationLabelmapConfig = segmentationRepresentationSpecificConfig[Representations.Labelmap];
+function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationRepresentation) {
+    const { rendering, config, colorLUTIndex } = segmentationRepresentation;
+    const activeSegRep = SegmentationState.getActiveRepresentation(viewportId);
+    const isActiveLabelmap = activeSegRep === segmentationRepresentation;
+    const { cfun, ofun } = rendering;
+    const { allSegments, perSegment } = config;
+    const globalLabelmapConfig = SegmentationState.getGlobalConfig().representations[Representations.Labelmap];
+    const globalConfig = SegmentationState.getGlobalConfig();
+    const renderInactiveRepresentations = globalConfig.renderInactiveRepresentations;
+    const configToUse = {
+        ...globalLabelmapConfig,
+        ...allSegments[Representations.Labelmap],
+    };
+    const labelmapConfig = configToUse;
     const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
     const numColors = Math.min(256, colorLUT.length);
     const { uid: actorUID } = actorEntry;
-    const { outlineWidth, renderOutline, outlineOpacity } = _getLabelmapConfig(toolGroupLabelmapConfig, segmentationRepresentationLabelmapConfig, isActiveLabelmap);
+    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap);
+    const segmentsHidden = getSegmentsHidden(viewportId, segmentationRepresentation.segmentationRepresentationUID);
     for (let i = 0; i < numColors; i++) {
         const segmentIndex = i;
         const segmentColor = colorLUT[segmentIndex];
-        const segmentSpecificLabelmapConfig = segmentSpecificConfig[segmentIndex]?.[Representations.Labelmap];
-        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(toolGroupLabelmapConfig, segmentationRepresentationLabelmapConfig, isActiveLabelmap, segmentSpecificLabelmapConfig);
+        const segmentSpecificLabelmapConfig = perSegment?.[segmentIndex]?.[Representations.Labelmap];
+        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentSpecificLabelmapConfig);
         const { forceOpacityUpdate, forceColorUpdate } = _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, {
             fillAlpha,
             renderFill,
             renderOutline,
             segmentColor,
             outlineWidth,
-            segmentsHidden,
         });
         if (forceColorUpdate) {
             cfun.addRGBPoint(segmentIndex, segmentColor[0] / MAX_NUMBER_COLORS, segmentColor[1] / MAX_NUMBER_COLORS, segmentColor[2] / MAX_NUMBER_COLORS);
@@ -167,18 +178,17 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, cfun, ofun, colorLU
         }
         outlineWidths[i - 1] =
             i === activeSegmentIndex
-                ? outlineWidth + toolGroupLabelmapConfig.activeSegmentOutlineWidthDelta
+                ? outlineWidth + activeSegmentOutlineWidthDelta
                 : outlineWidth;
     }
     actor.getProperty().setLabelOutlineThickness(outlineWidths);
-    const visible = isActiveLabelmap || renderInactiveSegmentations;
+    const visible = isActiveLabelmap || renderInactiveRepresentations;
     actor.setVisibility(visible);
 }
-function _getLabelmapConfig(toolGroupLabelmapConfig, segmentationRepresentationLabelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
+function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
     const segmentLabelmapConfig = segmentsLabelmapConfig || {};
     const configToUse = {
-        ...toolGroupLabelmapConfig,
-        ...segmentationRepresentationLabelmapConfig,
+        ...labelmapConfig,
         ...segmentLabelmapConfig,
     };
     const fillAlpha = isActiveLabelmap
@@ -194,15 +204,17 @@ function _getLabelmapConfig(toolGroupLabelmapConfig, segmentationRepresentationL
     const outlineOpacity = isActiveLabelmap
         ? configToUse.outlineOpacity
         : configToUse.outlineOpacityInactive;
+    const activeSegmentOutlineWidthDelta = configToUse.activeSegmentOutlineWidthDelta;
     return {
         fillAlpha,
         outlineWidth,
         renderFill,
         renderOutline,
         outlineOpacity,
+        activeSegmentOutlineWidthDelta,
     };
 }
-function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fillAlpha, renderFill, renderOutline, segmentColor, outlineWidth, segmentsHidden, }) {
+function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fillAlpha, renderFill, renderOutline, segmentColor, outlineWidth, }) {
     const cacheUID = `${viewportId}-${actorUID}-${segmentIndex}`;
     const oldConfig = labelMapConfigCache.get(cacheUID);
     if (!oldConfig) {
@@ -212,14 +224,13 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
             renderOutline,
             outlineWidth,
             segmentColor: segmentColor.slice(),
-            segmentsHidden: new Set(segmentsHidden),
         });
         return {
             forceOpacityUpdate: true,
             forceColorUpdate: true,
         };
     }
-    const { fillAlpha: oldFillAlpha, renderFill: oldRenderFill, renderOutline: oldRenderOutline, outlineWidth: oldOutlineWidth, segmentColor: oldSegmentColor, segmentsHidden: oldSegmentsHidden, } = oldConfig;
+    const { fillAlpha: oldFillAlpha, renderFill: oldRenderFill, renderOutline: oldRenderOutline, outlineWidth: oldOutlineWidth, segmentColor: oldSegmentColor, } = oldConfig;
     const forceColorUpdate = oldSegmentColor[0] !== segmentColor[0] ||
         oldSegmentColor[1] !== segmentColor[1] ||
         oldSegmentColor[2] !== segmentColor[2];
@@ -228,38 +239,24 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
         oldRenderFill !== renderFill ||
         oldRenderOutline !== renderOutline ||
         oldOutlineWidth !== outlineWidth ||
-        oldSegmentsHidden.has(segmentIndex) !== segmentsHidden.has(segmentIndex);
-    labelMapConfigCache.set(cacheUID, {
-        fillAlpha,
-        renderFill,
-        renderOutline,
-        outlineWidth,
-        segmentColor: segmentColor.slice(),
-        segmentsHidden: new Set(segmentsHidden),
-    });
+        labelMapConfigCache.set(cacheUID, {
+            fillAlpha,
+            renderFill,
+            renderOutline,
+            outlineWidth,
+            segmentColor: segmentColor.slice(),
+        });
     return {
         forceOpacityUpdate,
         forceColorUpdate,
     };
 }
-function _removeLabelmapFromToolGroupViewports(toolGroupId, segmentationRepresentationUID) {
-    const toolGroup = getToolGroup(toolGroupId);
-    if (toolGroup === undefined) {
-        throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
-    }
-    const { viewportsInfo } = toolGroup;
-    for (const viewportInfo of viewportsInfo) {
-        const { viewportId, renderingEngineId } = viewportInfo;
-        const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-        removeLabelmapFromElement(enabledElement.viewport.element, segmentationRepresentationUID);
-    }
-}
 async function _addLabelmapToViewport(viewport, labelmapData, segmentationRepresentationUID) {
     await addLabelmapToElement(viewport.element, labelmapData, segmentationRepresentationUID);
 }
 export default {
     getRepresentationRenderingConfig,
     render,
-    removeSegmentationRepresentation,
+    removeRepresentation,
 };
-export { getRepresentationRenderingConfig, render, removeSegmentationRepresentation, };
+export { getRepresentationRenderingConfig, render, removeRepresentation };

package/dist/esm/tools/displayTools/SegmentationRenderingEngine.d.ts

@@ -0,0 +1,19 @@
+import { Types } from '@cornerstonejs/core';
+declare class SegmentationRenderingEngine {
+    private _needsRender;
+    private _animationFrameSet;
+    private _animationFrameHandle;
+    hasBeenDestroyed: boolean;
+    renderSegmentations(segmentationId?: string): void;
+    renderSegmentationsForViewports(viewportIds?: string[]): void;
+    _getAllViewports: () => Types.IViewport[];
+    _getViewportIdsForSegmentation(segmentationId?: string): string[];
+    private _throwIfDestroyed;
+    private _setViewportsToBeRenderedNextFrame;
+    private _render;
+    private _renderFlaggedSegmentations;
+    _triggerRender(viewportId?: string): void;
+    _addPlanarFreeHandToolIfAbsent(viewport: any): void;
+}
+declare const segmentationRenderingEngine: SegmentationRenderingEngine;
+export { segmentationRenderingEngine };

package/dist/esm/tools/displayTools/SegmentationRenderingEngine.js

@@ -0,0 +1,136 @@
+import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
+import Representations from '../../enums/SegmentationRepresentations';
+import { getRepresentationsForViewport } from '../../stateManagement/segmentation/segmentationState';
+import { surfaceDisplay } from './Surface';
+import { contourDisplay } from './Contour';
+import { labelmapDisplay } from './Labelmap';
+import { addTool, state } from '../../store';
+import PlanarFreehandContourSegmentationTool from '../annotation/PlanarFreehandContourSegmentationTool';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+const renderers = {
+    [Representations.Labelmap]: labelmapDisplay,
+    [Representations.Contour]: contourDisplay,
+    [Representations.Surface]: surfaceDisplay,
+};
+const planarContourToolName = PlanarFreehandContourSegmentationTool.toolName;
+class SegmentationRenderingEngine {
+    constructor() {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._getAllViewports = () => {
+            const renderingEngine = getRenderingEngines();
+            return renderingEngine.flatMap((renderingEngine) => renderingEngine.getViewports());
+        };
+        this._renderFlaggedSegmentations = () => {
+            this._throwIfDestroyed();
+            const viewportIds = Array.from(this._needsRender);
+            viewportIds.forEach((viewportId) => {
+                this._triggerRender(viewportId);
+            });
+            this._needsRender.clear();
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+        };
+    }
+    renderSegmentations(segmentationId) {
+        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    renderSegmentationsForViewports(viewportIds) {
+        if (!viewportIds?.length) {
+            const allViewports = this._getAllViewports();
+            this._setViewportsToBeRenderedNextFrame(allViewports.map((viewport) => viewport.id));
+        }
+        else {
+            this._setViewportsToBeRenderedNextFrame(viewportIds);
+        }
+    }
+    _getViewportIdsForSegmentation(segmentationId) {
+        const viewports = this._getAllViewports();
+        const viewportIds = [];
+        for (const viewport of viewports) {
+            const viewportId = viewport.id;
+            const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+            if (segmentationId) {
+                const hasSegmentationRepresentation = segmentationRepresentations.some((representation) => representation.segmentationId === segmentationId);
+                if (hasSegmentationRepresentation) {
+                    viewportIds.push(viewportId);
+                }
+            }
+            else {
+                if (segmentationRepresentations.length > 0) {
+                    viewportIds.push(viewportId);
+                }
+            }
+        }
+        return viewportIds;
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+    _setViewportsToBeRenderedNextFrame(viewportIds) {
+        viewportIds.forEach((viewportId) => {
+            this._needsRender.add(viewportId);
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedSegmentations);
+            this._animationFrameSet = true;
+        }
+    }
+    _triggerRender(viewportId) {
+        const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+        if (!segmentationRepresentations?.length) {
+            return;
+        }
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        const viewportRenderList = [];
+        const segmentationRenderList = segmentationRepresentations.map((representation) => {
+            if (representation.type === SegmentationRepresentations.Contour) {
+                this._addPlanarFreeHandToolIfAbsent(viewport);
+            }
+            const display = renderers[representation.type];
+            try {
+                const viewportId = display.render(viewport, representation);
+                viewportRenderList.push(viewportId);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return Promise.resolve();
+        });
+        function onSegmentationRender(evt) {
+            const { element, viewportId } = evt.detail;
+            element.removeEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+            const eventDetail = {
+                viewportId,
+            };
+            triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
+                ...eventDetail,
+            });
+        }
+        Promise.allSettled(segmentationRenderList).then(() => {
+            const element = viewport.element;
+            element.addEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+            viewport.render();
+        });
+    }
+    _addPlanarFreeHandToolIfAbsent(viewport) {
+        if (!(planarContourToolName in state.tools)) {
+            addTool(PlanarFreehandContourSegmentationTool);
+        }
+        const toolGroup = getToolGroupForViewport(viewport.id);
+        if (!toolGroup.hasTool(planarContourToolName)) {
+            toolGroup.addTool(planarContourToolName);
+            toolGroup.setToolPassive(planarContourToolName);
+        }
+    }
+}
+const segmentationRenderingEngine = new SegmentationRenderingEngine();
+export { segmentationRenderingEngine };

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

@@ -1,10 +1,10 @@
 import { Types } from '@cornerstonejs/core';
-import { ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
-declare function render(viewport: Types.IVolumeViewport, representation: ToolGroupSpecificRepresentation): Promise<void>;
+import { SegmentationRepresentation } from '../../../types/SegmentationStateTypes';
+declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+declare function render(viewport: Types.IVolumeViewport | Types.IStackViewport, representation: SegmentationRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;
-    removeSegmentationRepresentation: typeof removeSegmentationRepresentation;
+    removeRepresentation: typeof removeRepresentation;
 };
 export default _default;
-export { render, removeSegmentationRepresentation };
+export { render, removeRepresentation };