@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,127 +1,126 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { cache, getEnabledElementByIds, utilities, } from '@cornerstonejs/core';
-import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
+import { getEnabledElementByViewportId, VolumeViewport, } from '@cornerstonejs/core';
 import addLabelmapToElement from './addLabelmapToElement';
 import removeLabelmapFromElement from './removeLabelmapFromElement';
+import { getActiveSegmentation } from '../../../stateManagement/segmentation/activeSegmentation';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+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();
-async function addSegmentationRepresentation(toolGroupId, representationInput, toolGroupSpecificConfig) {
-    const { segmentationId } = representationInput;
-    const segmentationRepresentationUID = utilities.uuidv4();
-    const segmentsHidden = new Set();
-    const colorLUTIndex = 0;
-    const active = true;
-    const cfun = vtkColorTransferFunction.newInstance();
-    const ofun = vtkPiecewiseFunction.newInstance();
-    ofun.addPoint(0, 0);
-    const toolGroupSpecificRepresentation = {
-        segmentationId,
-        segmentationRepresentationUID,
-        type: Representations.Labelmap,
-        segmentsHidden,
-        colorLUTIndex,
-        active,
-        segmentationRepresentationSpecificConfig: {},
-        segmentSpecificConfig: {},
-        config: {
-            cfun,
-            ofun,
-        },
-    };
-    if (toolGroupSpecificConfig) {
-        const currentToolGroupConfig = SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-        const mergedConfig = utilities.deepMerge(currentToolGroupConfig, toolGroupSpecificConfig);
-        SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
-            renderInactiveSegmentations: mergedConfig.renderInactiveSegmentations || true,
-            representations: {
-                ...mergedConfig.representations,
-            },
-        });
+let polySegConversionInProgress = false;
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    _cleanupLabelMapConfigCache(viewportId, segmentationId);
+    if (!enabledElement) {
+        return;
     }
-    SegmentationState.addSegmentationRepresentation(toolGroupId, toolGroupSpecificRepresentation);
-    return segmentationRepresentationUID;
-}
-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();
-        });
+    const { viewport } = enabledElement;
+    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;
+async function render(viewport, representation) {
+    const { segmentationId } = representation;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn('No segmentation found for segmentationId: ', segmentationId);
+        return;
     }
-    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;
+    let labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
+    let labelmapActor = getSegmentationActor(viewport.id, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
+    if (!labelmapData &&
+        canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations.Labelmap) &&
+        !polySegConversionInProgress) {
+        polySegConversionInProgress = true;
+        labelmapData = await computeAndAddLabelmapRepresentation(segmentationId, {
+            viewport,
+        });
+        if (!labelmapData) {
+            throw new Error(`No labelmap data found for segmentationId ${segmentationId}.`);
         }
+        polySegConversionInProgress = false;
     }
-    return false;
-}
-async function render(viewport, representation, toolGroupConfig) {
-    const { colorLUTIndex, active, segmentationId, segmentationRepresentationUID, segmentsHidden, config: renderingConfig, } = representation;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
-    const labelmapData = segmentation.representationData[Representations.Labelmap];
-    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)) {
+    if (!labelmapData) {
         return;
     }
-    let actorEntry = viewport.getActor(segmentationRepresentationUID);
-    if (!actorEntry) {
-        const segmentation = SegmentationState.getSegmentation(segmentationId);
-        const { volumeId } = segmentation.representationData[Representations.Labelmap];
-        await _addLabelmapToViewport(viewport, volumeId, segmentationRepresentationUID);
-        actorEntry = viewport.getActor(segmentationRepresentationUID);
+    if (viewport instanceof VolumeViewport) {
+        if (!labelmapActor) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
+        }
+        labelmapActor = getSegmentationActor(viewport.id, {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        });
     }
-    if (!actorEntry) {
+    else {
+        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+        if (!labelmapImageId) {
+            return;
+        }
+        if (!labelmapActor) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
+        }
+        labelmapActor = getSegmentationActor(viewport.id, {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        });
+    }
+    if (!labelmapActor) {
         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, labelmapActor, representation);
 }
-function _setLabelmapColorAndOpacity(viewportId, actorEntry, cfun, ofun, colorLUTIndex, toolGroupLabelmapConfig, segmentationRepresentation, isActiveLabelmap, renderInactiveSegmentations, segmentsHidden) {
-    const { segmentSpecificConfig, segmentationRepresentationSpecificConfig } = segmentationRepresentation;
-    const segmentationRepresentationLabelmapConfig = segmentationRepresentationSpecificConfig[Representations.Labelmap];
-    const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+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 volumeActor = actorEntry.actor;
-    const { uid: actorUID } = actorEntry;
-    const { outlineWidth, renderOutline, outlineOpacity } = _getLabelmapConfig(toolGroupLabelmapConfig, segmentationRepresentationLabelmapConfig, isActiveLabelmap);
+    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 = segmentSpecificConfig[segmentIndex]?.[Representations.Labelmap];
-        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(toolGroupLabelmapConfig, segmentationRepresentationLabelmapConfig, 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: segmentsHidden,
+            cfun,
+            ofun,
         });
         if (forceColorUpdate) {
             cfun.addRGBPoint(segmentIndex, segmentColor[0] / MAX_NUMBER_COLORS, segmentColor[1] / MAX_NUMBER_COLORS, segmentColor[2] / MAX_NUMBER_COLORS);
@@ -139,45 +138,68 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, cfun, ofun, colorLU
             }
         }
     }
-    volumeActor.getProperty().setRGBTransferFunction(0, cfun);
+    labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
     ofun.setClamping(false);
-    volumeActor.getProperty().setScalarOpacity(0, ofun);
-    volumeActor.getProperty().setInterpolationTypeToNearest();
-    volumeActor.getProperty().setUseLabelOutline(renderOutline);
-    volumeActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-    volumeActor.getProperty().setLabelOutlineThickness(outlineWidth);
+    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;
+        }
+        labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
+    }
+    else {
+        labelmapActor
+            .getProperty()
+            .setLabelOutlineThickness(new Array(numColors - 1).fill(0));
+    }
     const visible = isActiveLabelmap || renderInactiveSegmentations;
-    volumeActor.setVisibility(visible);
+    labelmapActor.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
         ? 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;
+    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, segmentsHidden, cfun, ofun, }) {
     const cacheUID = `${viewportId}-${actorUID}-${segmentIndex}`;
     const oldConfig = labelMapConfigCache.get(cacheUID);
     if (!oldConfig) {
@@ -188,13 +210,15 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
             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, segmentsHidden: oldSegmentsHidden, } = 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];
@@ -203,38 +227,36 @@ 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),
-    });
+        oldSegmentsHidden !== segmentsHidden;
+    if (forceOpacityUpdate || forceColorUpdate) {
+        labelMapConfigCache.set(cacheUID, {
+            fillAlpha,
+            renderFill,
+            renderOutline,
+            outlineWidth,
+            segmentColor: segmentColor.slice(),
+            segmentsHidden: new Set(segmentsHidden),
+            cfunMTime: cfun.getMTime(),
+            ofunMTime: ofun.getMTime(),
+        });
+    }
     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, segmentationId) {
+    await addLabelmapToElement(viewport.element, labelmapData, segmentationId);
 }
-async function _addLabelmapToViewport(viewport, volumeId, segmentationRepresentationUID) {
-    await addLabelmapToElement(viewport.element, volumeId, segmentationRepresentationUID);
+function _cleanupLabelMapConfigCache(viewportId, segmentationId) {
+    for (const key of labelMapConfigCache.keys()) {
+        if (key.startsWith(`${viewportId}-${segmentationId}-`)) {
+            labelMapConfigCache.delete(key);
+        }
+    }
 }
 export default {
     render,
-    addSegmentationRepresentation,
-    removeSegmentationRepresentation,
+    removeRepresentation,
 };
-//# sourceMappingURL=labelmapDisplay.js.map
+export { render, removeRepresentation };

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,13 +1,8 @@
-import { StackViewport, getEnabledElement } from '@cornerstonejs/core';
-function removeLabelmapFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
+import { getEnabledElement } from '@cornerstonejs/core';
+import { getLabelmapActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function removeLabelmapFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
-    if (viewport instanceof StackViewport) {
-        return;
-    }
-    viewport.removeVolumeActors([
-        segmentationRepresentationUID,
-    ]);
+    viewport.removeActors([getLabelmapActorUID(segmentationId)]);
 }
 export default removeLabelmapFromElement;
-//# sourceMappingURL=removeLabelmapFromElement.js.map

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

@@ -0,0 +1,4 @@
+import type { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
+export declare function validatePublic(segmentationInput: SegmentationPublicInput): void;
+export declare function validate(segmentationRepresentationData: LabelmapSegmentationData): void;

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

@@ -0,0 +1,32 @@
+import { cache } from '@cornerstonejs/core';
+function validateRepresentationData(segmentationRepresentationData) {
+    if ('volumeId' in segmentationRepresentationData) {
+        segmentationRepresentationData =
+            segmentationRepresentationData;
+        const cachedVolume = cache.getVolume(segmentationRepresentationData.volumeId);
+        if (!cachedVolume) {
+            throw new Error(`volumeId of ${segmentationRepresentationData.volumeId} not found in cache, you should load and cache volume before adding segmentation`);
+        }
+    }
+    else if ('imageIds' in segmentationRepresentationData) {
+        segmentationRepresentationData =
+            segmentationRepresentationData;
+        if (!segmentationRepresentationData.imageIds) {
+            throw new Error('The segmentationInput.representationData.imageIds is undefined, please provide a valid representationData.imageIds for stack data');
+        }
+    }
+    else {
+        throw new Error('The segmentationInput.representationData is undefined, please provide a valid representationData');
+    }
+}
+export function validatePublic(segmentationInput) {
+    if (!segmentationInput.representation.data) {
+        throw new Error('The segmentationInput.representationData.data is undefined, please provide a valid representationData.data');
+    }
+    const representationData = segmentationInput.representation
+        .data;
+    validateRepresentationData(representationData);
+}
+export function validate(segmentationRepresentationData) {
+    validateRepresentationData(segmentationRepresentationData);
+}

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

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

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

@@ -0,0 +1,63 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+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/getSegmentationActor';
+function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
+    const actorUID = getSurfaceActorUID(segmentationId);
+    const enabledElement = getEnabledElement(element);
+    const { viewport } = enabledElement;
+    const surfaceActor = viewport.getActor(actorUID)?.actor;
+    if (surfaceActor) {
+        const surfaceMapper = surfaceActor.getMapper();
+        const currentPolyData = surfaceMapper.getInputData();
+        const newPoints = surface.getPoints();
+        const newPolys = surface.getPolys();
+        const currentPoints = currentPolyData.getPoints().getData();
+        const currentPolys = currentPolyData.getPolys().getData();
+        if (newPoints.length === currentPoints.length &&
+            newPolys.length === currentPolys.length) {
+            return;
+        }
+        const polyData = vtkPolyData.newInstance();
+        polyData.getPoints().setData(newPoints, 3);
+        const triangles = vtkCellArray.newInstance({
+            values: Float32Array.from(newPolys),
+        });
+        polyData.setPolys(triangles);
+        surfaceMapper.setInputData(polyData);
+        surfaceMapper.modified();
+        setTimeout(() => {
+            viewport.getRenderer().resetCameraClippingRange();
+        }, 0);
+        return;
+    }
+    const points = surface.getPoints();
+    const polys = surface.getPolys();
+    const color = surface.getColor();
+    const surfacePolyData = vtkPolyData.newInstance();
+    surfacePolyData.getPoints().setData(points, 3);
+    const triangles = vtkCellArray.newInstance({
+        values: Float32Array.from(polys),
+    });
+    surfacePolyData.setPolys(triangles);
+    const mapper = vtkMapper.newInstance({});
+    let clippingFilter;
+    mapper.setInputData(surfacePolyData);
+    const actor = vtkActor.newInstance();
+    actor.setMapper(mapper);
+    actor.getProperty().setColor(color[0] / 255, color[1] / 255, color[2] / 255);
+    actor.getProperty().setLineWidth(2);
+    viewport.addActor({
+        actor: actor,
+        uid: actorUID,
+        clippingFilter,
+    });
+    viewport.resetCamera();
+    viewport.render();
+    setTimeout(() => {
+        viewport.getRenderer().resetCameraClippingRange();
+    }, 0);
+}
+export default addOrUpdateSurfaceToElement;

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

@@ -0,0 +1,2 @@
+import surfaceDisplay from './surfaceDisplay';
+export { surfaceDisplay };

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

@@ -0,0 +1,2 @@
+import surfaceDisplay from './surfaceDisplay';
+export { surfaceDisplay };

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

@@ -0,0 +1,2 @@
+declare function removeSurfaceFromElement(element: HTMLDivElement, segmentationId: string): void;
+export default removeSurfaceFromElement;

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

@@ -0,0 +1,13 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+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(actorUID) ? uid : undefined))
+        .filter(Boolean);
+    viewport.removeActors(actorUIDsToRemove);
+}
+export default removeSurfaceFromElement;

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

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

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

@@ -0,0 +1,8 @@
+const defaultSurfaceConfig = {
+    renderFill: true,
+    fillAlpha: 1,
+};
+function getDefaultSurfaceStyle() {
+    return defaultSurfaceConfig;
+}
+export default getDefaultSurfaceStyle;

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

@@ -0,0 +1,10 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SegmentationRepresentation } from '../../../types/SegmentationStateTypes';
+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;
+    removeRepresentation: typeof removeRepresentation;
+};
+export default _default;
+export { render, removeRepresentation };

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

@@ -0,0 +1,65 @@
+import { cache, getEnabledElementByViewportId, VolumeViewport3D, } from '@cornerstonejs/core';
+import Representations from '../../../enums/SegmentationRepresentations';
+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/Surface/computeAndAddSurfaceRepresentation';
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    removeSurfaceFromElement(viewport.element, segmentationId);
+    if (!renderImmediate) {
+        return;
+    }
+    viewport.render();
+}
+async function render(viewport, representation) {
+    const { segmentationId } = representation;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    if (!(viewport instanceof VolumeViewport3D)) {
+        throw new Error('Surface rendering is only supported in 3D viewports, if you need to visualize the surface cuts in 2D viewports, you can use the Contour representation, see polySeg converters');
+    }
+    let SurfaceData = segmentation.representationData[Representations.Surface];
+    if (!SurfaceData &&
+        canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
+        SurfaceData = await computeAndAddSurfaceRepresentation(segmentationId, {
+            viewport,
+        });
+        if (!SurfaceData) {
+            throw new Error(`No Surface data found for segmentationId ${segmentationId}.`);
+        }
+    }
+    const { geometryIds } = SurfaceData;
+    if (!geometryIds?.size) {
+        console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);
+    }
+    const { colorLUTIndex } = representation;
+    const colorLUT = getColorLUT(colorLUTIndex);
+    const surfaces = [];
+    geometryIds.forEach((geometryId, segmentIndex) => {
+        const geometry = cache.getGeometry(geometryId);
+        if (!geometry?.data) {
+            console.warn(`No Surfaces found for geometryId ${geometryId}. Skipping render.`);
+            return;
+        }
+        const surface = geometry.data;
+        const color = colorLUT[segmentIndex];
+        surface.setColor(color.slice(0, 3));
+        addOrUpdateSurfaceToElement(viewport.element, surface, segmentationId);
+        surfaces.push(surface);
+    });
+    viewport.render();
+}
+export default {
+    render,
+    removeRepresentation,
+};
+export { render, removeRepresentation };

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourAnnotationData } from '../types';
+export declare const distancePointToContour: (viewport: Types.IViewport, annotation: ContourAnnotationData, coords: Types.Point2) => number;