@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/esm/tools/base/AnnotationDisplayTool.d.ts

@@ -1,13 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
 import BaseTool from './BaseTool';
-import { Annotation, Annotations, SVGDrawingHelper } from '../../types';
-import { StyleSpecifier } from '../../types/AnnotationStyle';
+import type { Annotation, Annotations, SVGDrawingHelper } from '../../types';
+import type { StyleSpecifier } from '../../types/AnnotationStyle';
 declare abstract class AnnotationDisplayTool extends BaseTool {
     static toolName: any;
     abstract renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): any;
     filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations | undefined;
     onImageSpacingCalibrated: (evt: Types.EventTypes.ImageSpacingCalibratedEvent) => void;
-    protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp: Types.Point3): string;
+    protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp?: Types.Point3): string;
     getStyle(property: string, specifications: StyleSpecifier, annotation?: Annotation): unknown;
 }
 export default AnnotationDisplayTool;

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

@@ -1,4 +1,4 @@
-import { utilities, getEnabledElement, StackViewport, cache, VideoViewport, } from '@cornerstonejs/core';
+import { utilities, getEnabledElement, StackViewport, cache, VideoViewport, BaseVolumeViewport, } from '@cornerstonejs/core';
 import BaseTool from './BaseTool';
 import { getAnnotationManager } from '../../stateManagement/annotation/annotationState';
 import triggerAnnotationRender from '../../utilities/triggerAnnotationRender';
@@ -43,14 +43,8 @@ class AnnotationDisplayTool extends BaseTool {
     }
     getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp) {
         const targetId = this.getTargetId(viewport);
-        let referencedImageId;
-        if (viewport instanceof StackViewport) {
-            referencedImageId = targetId.split('imageId:')[1];
-        }
-        else if (viewport instanceof VideoViewport) {
-            referencedImageId = targetId.split('videoId:')[1];
-        }
-        else {
+        let referencedImageId = targetId.split(/^[a-zA-Z]+:/)[1];
+        if (viewport instanceof BaseVolumeViewport) {
             const volumeId = utilities.getVolumeId(targetId);
             const imageVolume = cache.getVolume(volumeId);
             referencedImageId = utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);

package/dist/esm/tools/base/AnnotationTool.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
-import { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
-import { StyleSpecifier } from '../../types/AnnotationStyle';
+import type { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
+import type { AnnotationStyle, StyleSpecifier } from '../../types/AnnotationStyle';
 declare abstract class AnnotationTool extends AnnotationDisplayTool {
     static createAnnotation(...annotationBaseData: any[]): Annotation;
     static createAnnotationForViewport(viewport: any, ...annotationBaseData: any[]): Annotation;
@@ -20,18 +20,7 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
     protected getAnnotationStyle(context: {
         annotation: Annotation;
         styleSpecifier: StyleSpecifier;
-    }): {
-        visibility: boolean;
-        locked: boolean;
-        color: string;
-        lineWidth: number;
-        lineDash: string;
-        lineOpacity: number;
-        fillColor: string;
-        fillOpacity: number;
-        shadow: boolean;
-        textbox: Record<string, unknown>;
-    };
+    }): AnnotationStyle;
     private _imagePointNearToolOrHandle;
 }
 export default AnnotationTool;

package/dist/esm/tools/base/BaseTool.d.ts

@@ -1,14 +1,14 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
-import StrategyCallbacks from '../../enums/StrategyCallbacks';
-import { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
+import type StrategyCallbacks from '../../enums/StrategyCallbacks';
+import type { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
 export interface IBaseTool {
     toolGroupId: string;
     supportedInteractionTypes: InteractionTypes[];
     mode: ToolModes;
     configuration: {
         preventHandleOutsideImage?: boolean;
-        strategies?: Record<string, any>;
+        strategies?: Record<string, unknown>;
         defaultStrategy?: string;
         activeStrategy?: string;
         strategyOptions?: Record<string, unknown>;
@@ -26,7 +26,7 @@ declare abstract class BaseTool implements IBaseTool {
     applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string): any;
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
-    private getTargetVolumeId;
+    protected getTargetVolumeId(viewport: Types.IViewport): string | undefined;
     protected getTargetIdImage(targetId: string, renderingEngine: Types.IRenderingEngine): Types.IImageData | Types.CPUIImageData | Types.IImageVolume;
     protected getTargetId(viewport: Types.IViewport): string | undefined;
 }

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

@@ -89,7 +89,7 @@ class BaseTool {
         if (viewport instanceof BaseVolumeViewport) {
             return `volumeId:${this.getTargetVolumeId(viewport)}`;
         }
-        throw new Error('getTargetId: viewport must have a getTargetId method');
+        throw new Error('getTargetId: viewport must have a getReferenceId method');
     }
 }
 BaseTool.toolName = 'BaseTool';

package/dist/esm/tools/base/ContourBaseTool.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { Annotation, ContourAnnotation, EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, AnnotationRenderContext } from '../../types';
 import AnnotationTool from './AnnotationTool';
-import { ContourWindingDirection } from '../../types/ContourAnnotation';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
 declare abstract class ContourBaseTool extends AnnotationTool {
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;

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

@@ -138,11 +138,11 @@ class ContourBaseTool extends AnnotationTool {
         const childContours = getContourHolesDataCanvas(annotation, viewport);
         const allContours = [polylineCanvasPoints, ...childContours];
         drawPathSvg(svgDrawingHelper, annotationUID, 'contourPolyline', allContours, {
-            color,
-            lineDash,
+            color: color,
+            lineDash: lineDash,
             lineWidth: Math.max(0.1, lineWidth),
             fillColor: fillColor,
-            fillOpacity,
+            fillOpacity: fillOpacity,
         });
         return true;
     }

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

@@ -6,7 +6,7 @@ import { triggerSegmentationDataModified } from '../../stateManagement/segmentat
 import { InterpolationManager } from '../../utilities/contours/interpolation';
 import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../utilities/contourSegmentation';
 import { triggerAnnotationRenderForToolGroupIds } from '../../utilities';
-import { getActiveRepresentation, getRepresentationsBySegmentationId, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../stateManagement/segmentation/segmentationState';
+import { getActiveSegmentationRepresentation, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentations, getViewportIdsWithSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
@@ -30,7 +30,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (!this.isContourSegmentationTool()) {
             return contourAnnotation;
         }
-        const activeSeg = activeSegmentation.getActiveRepresentation(viewport.id);
+        const activeSeg = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
         if (!activeSeg) {
             throw new Error('No active segmentation detected, create one before using scissors tool');
         }
@@ -78,7 +78,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (invalidated && this.isContourSegmentationTool()) {
             const { segmentationId } = (annotation).data.segmentation;
             triggerSegmentationDataModified(segmentationId);
-            const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
             const toolGroupIds = viewportIds.map((viewportId) => {
                 const toolGroup = getToolGroupForViewport(viewportId);
                 return toolGroup.id;
@@ -91,14 +91,14 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
         const segmentation = segmentationState.getSegmentation(segmentationId);
-        const segmentationRepresentations = getRepresentationsBySegmentationId(segmentationId);
+        const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentationId);
         if (!segmentationRepresentations?.length) {
             return {};
         }
         const allUIDs = segmentationRepresentations.map((rep) => rep.segmentationRepresentationUID);
         let segmentationRepresentation;
         if (segmentationRepresentations.length > 1) {
-            const viewportReps = getRepresentationsForViewport(context.styleSpecifier.viewportId);
+            const viewportReps = getSegmentationRepresentations(context.styleSpecifier.viewportId);
             segmentationRepresentation = viewportReps.find((rep) => rep.segmentationId === segmentationId &&
                 allUIDs.includes(rep.segmentationRepresentationUID));
         }
@@ -107,19 +107,19 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         }
         const { segmentationRepresentationUID } = segmentationRepresentation;
         const { autoGenerated } = annotation;
-        const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+        const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
         const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         const viewportId = context.styleSpecifier.viewportId;
-        const segmentationVisible = segmentationConfig.visibility.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
+        const segmentationVisible = segmentationConfig.visibility.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
         const globalConfig = segmentationConfig.getGlobalConfig();
-        const getAllSegmentsConfig = segmentationConfig.getAllSegmentsConfig(segmentationRepresentationUID);
+        const getSegmentationRepresentationConfig = segmentationConfig.getSegmentationRepresentationConfig(segmentationRepresentationUID);
         const segmentConfig = segmentationConfig.getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
         const segmentVisible = segmentationConfig.visibility.getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
-        const activeSegRep = getActiveRepresentation(viewportId);
+        const activeSegRep = getActiveSegmentationRepresentation(viewportId);
         const isActive = activeSegRep.segmentationRepresentationUID ===
             segmentationRepresentationUID;
-        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, getAllSegmentsConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
+        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, getSegmentationRepresentationConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
         let lineWidth = 1;
         let lineDash = undefined;
         let lineOpacity = 1;

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

@@ -1,3 +1,3 @@
-import { ContourConfig } from '../../../types/ContourTypes';
+import type { ContourConfig } from '../../../types/ContourTypes';
 declare function getDefaultContourConfig(): ContourConfig;
 export default getDefaultContourConfig;

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

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

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

@@ -1,6 +1,7 @@
-import { getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import removeContourFromElement from './removeContourFromElement';
 import { deleteConfigCache } from './contourHandler/contourConfigCache';
 import { polySeg } from '../../../stateManagement/segmentation';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';

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

@@ -1,5 +1,5 @@
-import { Types, StackViewport } from '@cornerstonejs/core';
-import { ContourRepresentation } from '../../../../types/SegmentationStateTypes';
+import type { Types, StackViewport } from '@cornerstonejs/core';
+import type { 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;

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

@@ -4,8 +4,8 @@ import { getClosestImageIdForStackViewport } from '../../../../utilities/annotat
 import { getConfigCache, setConfigCache } from './contourConfigCache';
 import { addContourSegmentationAnnotation } from '../../../../utilities/contourSegmentation';
 import { validateGeometry } from './utils';
-import { getGlobalConfig, } from '../../../../stateManagement/segmentation/segmentationState';
-import { getSegmentsHidden } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
+import { getGlobalConfig, getPerSegmentConfig, } from '../../../../stateManagement/segmentation/segmentationState';
+import { getHiddenSegmentIndices } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
 import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config';
 function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
     const addOrUpdateFn = annotationUIDsMap.size
@@ -27,7 +27,7 @@ function updateContourSets(viewport, geometryIds, contourRepresentation) {
     }
     const segmentsToSetToInvisible = [];
     const segmentsToSetToVisible = [];
-    const segmentsHidden = getSegmentsHidden(viewport.id, segmentationRepresentationUID);
+    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
     for (const segmentIndex of segmentsHidden) {
         if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
             segmentsToSetToInvisible.push(segmentIndex);
@@ -116,7 +116,7 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
     const globalContourConfig = getGlobalConfig().representations.CONTOUR;
     const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
     const outlineWidthActive = newContourConfig.outlineWidthActive;
-    const segmentsHidden = getSegmentsHidden(viewport.id, segmentationRepresentationUID);
+    const segmentsHidden = getHiddenSegmentIndices(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,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 export declare function validateGeometry(geometry: Types.IGeometry): void;
 export declare function getPolyData(contourSet: Types.IContourSet): vtkPolyData;

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { getLabelmapImageIdsForViewport, getRepresentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getCurrentLabelmapImageIdForViewport, getSegmentationRepresentation, } from '../../../stateManagement/segmentation/segmentationState';
 async function addLabelmapToElement(element, labelMapData, segmentationRepresentationUID) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
@@ -20,8 +20,8 @@ async function addLabelmapToElement(element, labelMapData, segmentationRepresent
         await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
     }
     else {
-        const representation = getRepresentation(segmentationRepresentationUID);
-        const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, representation.segmentationId);
+        const representation = getSegmentationRepresentation(segmentationRepresentationUID);
+        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, representation.segmentationId);
         const stackInputs = [
             {
                 imageId: segmentationImageId,

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

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

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 { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
-declare function getRepresentationRenderingConfig(): {
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
+declare function getSegmentationRepresentationRenderingConfig(): {
     ofun: vtkPiecewiseFunction;
     cfun: vtkColorTransferFunction;
 };
 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;
+    getSegmentationRepresentationRenderingConfig: typeof getSegmentationRepresentationRenderingConfig;
     render: typeof render;
     removeRepresentation: typeof removeRepresentation;
 };
 export default _default;
-export { getRepresentationRenderingConfig, render, removeRepresentation };
+export { getSegmentationRepresentationRenderingConfig, render, removeRepresentation, };

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

@@ -7,10 +7,10 @@ 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';
+import { getHiddenSegmentIndices } from '../../../stateManagement/segmentation/config/segmentationVisibility';
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
-function getRepresentationRenderingConfig() {
+function getSegmentationRepresentationRenderingConfig() {
     const cfun = vtkColorTransferFunction.newInstance();
     const ofun = vtkPiecewiseFunction.newInstance();
     ofun.addPoint(0, 0);
@@ -99,7 +99,7 @@ async function render(viewport, representation) {
         if (viewport instanceof VolumeViewport) {
             return;
         }
-        const labelmapImageId = SegmentationState.getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+        const labelmapImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         if (!labelmapImageId) {
             return;
         }
@@ -115,7 +115,7 @@ async function render(viewport, representation) {
 }
 function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationRepresentation) {
     const { rendering, config, colorLUTIndex } = segmentationRepresentation;
-    const activeSegRep = SegmentationState.getActiveRepresentation(viewportId);
+    const activeSegRep = SegmentationState.getActiveSegmentationRepresentation(viewportId);
     const isActiveLabelmap = activeSegRep === segmentationRepresentation;
     const { cfun, ofun } = rendering;
     const { allSegments, perSegment } = config;
@@ -131,7 +131,7 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationReprese
     const numColors = Math.min(256, colorLUT.length);
     const { uid: actorUID } = actorEntry;
     const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap);
-    const segmentsHidden = getSegmentsHidden(viewportId, segmentationRepresentation.segmentationRepresentationUID);
+    const segmentsHidden = getHiddenSegmentIndices(viewportId, segmentationRepresentation.segmentationRepresentationUID);
     for (let i = 0; i < numColors; i++) {
         const segmentIndex = i;
         const segmentColor = colorLUT[segmentIndex];
@@ -237,7 +237,8 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
         oldFillAlpha !== fillAlpha ||
         oldRenderFill !== renderFill ||
         oldRenderOutline !== renderOutline ||
-        oldOutlineWidth !== outlineWidth ||
+        oldOutlineWidth !== outlineWidth;
+    if (forceOpacityUpdate || forceColorUpdate) {
         labelMapConfigCache.set(cacheUID, {
             fillAlpha,
             renderFill,
@@ -245,6 +246,7 @@ function _needsTransferFunctionUpdate(viewportId, actorUID, segmentIndex, { fill
             outlineWidth,
             segmentColor: segmentColor.slice(),
         });
+    }
     return {
         forceOpacityUpdate,
         forceColorUpdate,
@@ -254,8 +256,8 @@ async function _addLabelmapToViewport(viewport, labelmapData, segmentationRepres
     await addLabelmapToElement(viewport.element, labelmapData, segmentationRepresentationUID);
 }
 export default {
-    getRepresentationRenderingConfig,
+    getSegmentationRepresentationRenderingConfig,
     render,
     removeRepresentation,
 };
-export { getRepresentationRenderingConfig, render, removeRepresentation };
+export { getSegmentationRepresentationRenderingConfig, render, removeRepresentation, };

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

@@ -1,4 +1,4 @@
-import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
-import { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
+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/Surface/surfaceConfig.d.ts

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

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

@@ -1,5 +1,5 @@
-import { Types } from '@cornerstonejs/core';
-import { SegmentationRepresentation } from '../../../types/SegmentationStateTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { 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: {

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

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

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

@@ -21,6 +21,7 @@ import ScaleOverlayTool from './ScaleOverlayTool';
 import SculptorTool from './SculptorTool';
 import BidirectionalTool from './annotation/BidirectionalTool';
 import LengthTool from './annotation/LengthTool';
+import HeightTool from './annotation/HeightTool';
 import ProbeTool from './annotation/ProbeTool';
 import DragProbeTool from './annotation/DragProbeTool';
 import RectangleROITool from './annotation/RectangleROITool';
@@ -48,4 +49,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, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/index.js

@@ -21,6 +21,7 @@ import ScaleOverlayTool from './ScaleOverlayTool';
 import SculptorTool from './SculptorTool';
 import BidirectionalTool from './annotation/BidirectionalTool';
 import LengthTool from './annotation/LengthTool';
+import HeightTool from './annotation/HeightTool';
 import ProbeTool from './annotation/ProbeTool';
 import DragProbeTool from './annotation/DragProbeTool';
 import RectangleROITool from './annotation/RectangleROITool';
@@ -48,4 +49,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, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/segmentation/BrushTool.js

@@ -11,7 +11,7 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import { getLabelmapImageIdsForViewport } from '../../stateManagement/segmentation/segmentationState';
+import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/segmentationState';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -192,7 +192,7 @@ class BrushTool extends BaseTool {
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const activeRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
+        const activeRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
         if (!activeRepresentation) {
             throw new Error('No active segmentation detected, create a segmentation representation before using the brush tool');
         }
@@ -200,7 +200,7 @@ class BrushTool extends BaseTool {
         if (type === SegmentationRepresentations.Contour) {
             throw new Error('Not implemented yet');
         }
-        const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+        const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
         const { representationData } = segmentationState.getSegmentation(segmentationId);
         const labelmapData = representationData[SegmentationRepresentations.Labelmap];
         if (isVolumeSegmentation(labelmapData, viewport)) {
@@ -228,7 +228,7 @@ class BrushTool extends BaseTool {
             };
         }
         else {
-            const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+            const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
             if (!segmentationImageId) {
                 return;
             }
@@ -272,7 +272,7 @@ class BrushTool extends BaseTool {
     }
     getActiveSegmentationData(viewport) {
         const viewportId = viewport.id;
-        const activeRepresentation = activeSegmentation.getActiveRepresentation(viewportId);
+        const activeRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewportId);
         if (!activeRepresentation) {
             console.warn('No active segmentation detected, create one before using the brush tool');
             return;

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

@@ -1,15 +1,13 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
-import { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
-import { CircleROIStartEndThresholdAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
+import type { CircleROIStartEndThresholdAnnotation, ROICachedStats } from '../../types/ToolSpecificAnnotationTypes';
 import CircleROITool from '../annotation/CircleROITool';
 declare class CircleROIStartEndThresholdTool extends CircleROITool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: Array<string>;
         handleIndex?: number;
         newAnnotation?: boolean;
@@ -33,13 +31,18 @@ declare class CircleROIStartEndThresholdTool extends CircleROITool {
         };
         data: {
             label: string;
-            startSlice: number;
-            endSlice: number;
+            startCoordinate: number;
+            endCoordinate: number;
             handles: {
                 textBox: {
                     hasMoved: boolean;
-                    worldPosition: any;
-                    worldBoundingBox: any;
+                    worldPosition: Types.Point3;
+                    worldBoundingBox: {
+                        topLeft: Types.Point3;
+                        topRight: Types.Point3;
+                        bottomLeft: Types.Point3;
+                        bottomRight: Types.Point3;
+                    };
                 };
                 points: [Types.Point3, Types.Point3];
                 activeHandleIndex: any;
@@ -47,6 +50,7 @@ declare class CircleROIStartEndThresholdTool extends CircleROITool {
             cachedStats: {
                 pointsInVolume: any[];
                 projectionPoints: any[];
+                statistics: ROICachedStats;
             };
             labelmapUID: any;
         };
@@ -54,10 +58,11 @@ declare class CircleROIStartEndThresholdTool extends CircleROITool {
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     _computeProjectionPoints(annotation: CircleROIStartEndThresholdAnnotation, imageVolume: Types.IImageVolume): void;
-    _computePointsInsideVolume(annotation: any, imageVolume: any, enabledElement: any): void;
+    _computePointsInsideVolume(annotation: any, imageVolume: any, targetId: any, enabledElement: any): void;
     _calculateCachedStatsTool(annotation: any, enabledElement: any): any;
-    _getStartSliceIndex(imageVolume: Types.IImageVolume, worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
-    _getEndSliceIndex(imageVolume: Types.IImageVolume, worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
-    _getImageIdIndex(imageVolume: Types.IImageVolume, pos: vec3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getStartCoordinate(worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getEndCoordinate(worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal: Types.Point3): number;
+    _getCoordinateForViewplaneNormal(pos: vec3 | number, viewPlaneNormal: Types.Point3): number | undefined;
 }
 export default CircleROIStartEndThresholdTool;