@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,267 @@
+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 { segmentationStyle } from '../../../stateManagement/segmentation/SegmentationStyle';
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getLabelmapActorEntry } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getPolySeg } from '../../../config';
+import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
+import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { defaultSegmentationStateManager } from '../../../stateManagement/segmentation/SegmentationStateManager';
+export const MAX_NUMBER_COLORS = 255;
+const labelMapConfigCache = new Map();
+let polySegConversionInProgress = false;
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    labelMapConfigCache.forEach((value, key) => {
+        if (key.includes(segmentationId)) {
+            labelMapConfigCache.delete(key);
+        }
+    });
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    removeLabelmapFromElement(viewport.element, segmentationId);
+    if (!renderImmediate) {
+        return;
+    }
+    viewport.render();
+}
+async function render(viewport, representation) {
+    const { segmentationId, config } = representation;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn('No segmentation found for segmentationId: ', segmentationId);
+        return;
+    }
+    let labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
+    let labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    if (!labelmapData &&
+        getPolySeg()?.canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations.Labelmap) &&
+        !polySegConversionInProgress) {
+        polySegConversionInProgress = true;
+        const polySeg = getPolySeg();
+        labelmapData = await computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => polySeg.computeLabelmapData(segmentationId, { viewport }), () => null, () => {
+            defaultSegmentationStateManager.processLabelmapRepresentationAddition(viewport.id, segmentationId);
+            setTimeout(() => {
+                triggerSegmentationDataModified(segmentationId);
+            }, 0);
+        });
+        if (!labelmapData) {
+            throw new Error(`No labelmap data found for segmentationId ${segmentationId}.`);
+        }
+        polySegConversionInProgress = false;
+    }
+    else if (!labelmapData && !getPolySeg()) {
+        console.debug(`No labelmap data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to labelmap. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
+    if (!labelmapData) {
+        return;
+    }
+    if (viewport instanceof VolumeViewport) {
+        if (!labelmapActorEntry) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
+        }
+        labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    }
+    else {
+        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+        if (!labelmapImageId) {
+            return;
+        }
+        if (!labelmapActorEntry) {
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
+        }
+        labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    }
+    if (!labelmapActorEntry) {
+        return;
+    }
+    _setLabelmapColorAndOpacity(viewport.id, labelmapActorEntry, representation);
+}
+function _setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, 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 { 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 perSegmentStyle = segmentationStyle.getStyle({
+            viewportId,
+            type: SegmentationRepresentations.Labelmap,
+            segmentationId,
+            segmentIndex,
+        });
+        const segmentSpecificLabelmapConfig = perSegmentStyle;
+        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(labelmapStyle, isActiveLabelmap, segmentSpecificLabelmapConfig);
+        const { forceOpacityUpdate, forceColorUpdate } = _needsTransferFunctionUpdate(viewportId, segmentationId, segmentIndex, {
+            fillAlpha,
+            renderFill,
+            renderOutline,
+            segmentColor,
+            outlineWidth,
+            segmentsHidden: segmentsHidden,
+            cfun,
+            ofun,
+        });
+        if (forceColorUpdate) {
+            cfun.addRGBPoint(segmentIndex, segmentColor[0] / MAX_NUMBER_COLORS, segmentColor[1] / MAX_NUMBER_COLORS, segmentColor[2] / MAX_NUMBER_COLORS);
+        }
+        if (forceOpacityUpdate) {
+            if (renderFill) {
+                const segmentOpacity = segmentsHidden.has(segmentIndex)
+                    ? 0
+                    : (segmentColor[3] / 255) * fillAlpha;
+                ofun.removePoint(segmentIndex);
+                ofun.addPointLong(segmentIndex, segmentOpacity, 0.5, 1.0);
+            }
+            else {
+                ofun.addPointLong(segmentIndex, 0.01, 0.5, 1.0);
+            }
+        }
+    }
+    ofun.setClamping(false);
+    const labelmapActor = labelmapActorEntry.actor;
+    const { preLoad } = labelmapActor.get?.('preLoad') || { preLoad: null };
+    if (preLoad) {
+        preLoad({ cfun, ofun, actor: labelmapActor });
+    }
+    else {
+        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
+        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;
+    labelmapActor.setVisibility(visible);
+}
+function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
+    const segmentLabelmapConfig = segmentsLabelmapConfig || {};
+    const configToUse = {
+        ...labelmapConfig,
+        ...segmentLabelmapConfig,
+    };
+    const fillAlpha = isActiveLabelmap
+        ? configToUse.fillAlpha
+        : configToUse.fillAlphaInactive;
+    const outlineWidth = isActiveLabelmap
+        ? configToUse.outlineWidth
+        : configToUse.outlineWidthInactive;
+    const renderFill = isActiveLabelmap
+        ? configToUse.renderFill
+        : configToUse.renderFillInactive;
+    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, segmentationId, segmentIndex, { fillAlpha, renderFill, renderOutline, segmentColor, outlineWidth, segmentsHidden, cfun, ofun, }) {
+    const cacheUID = `${viewportId}-${segmentationId}-${segmentIndex}`;
+    const oldConfig = labelMapConfigCache.get(cacheUID);
+    if (!oldConfig) {
+        labelMapConfigCache.set(cacheUID, {
+            fillAlpha,
+            renderFill,
+            renderOutline,
+            outlineWidth,
+            segmentColor: segmentColor.slice(),
+            segmentsHidden: new Set(segmentsHidden),
+            cfunMTime: cfun.getMTime(),
+            ofunMTime: ofun.getMTime(),
+        });
+        return {
+            forceOpacityUpdate: true,
+            forceColorUpdate: true,
+        };
+    }
+    const { fillAlpha: oldFillAlpha, renderFill: oldRenderFill, renderOutline: oldRenderOutline, outlineWidth: oldOutlineWidth, segmentColor: oldSegmentColor, segmentsHidden: oldSegmentsHidden, cfunMTime: oldCfunMTime, ofunMTime: oldOfunMTime, } = oldConfig;
+    const forceColorUpdate = oldSegmentColor[0] !== segmentColor[0] ||
+        oldSegmentColor[1] !== segmentColor[1] ||
+        oldSegmentColor[2] !== segmentColor[2];
+    const forceOpacityUpdate = oldSegmentColor[3] !== segmentColor[3] ||
+        oldFillAlpha !== fillAlpha ||
+        oldRenderFill !== renderFill ||
+        oldRenderOutline !== renderOutline ||
+        oldOutlineWidth !== outlineWidth ||
+        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,
+    };
+}
+async function _addLabelmapToViewport(viewport, labelmapData, segmentationId, config) {
+    const result = await addLabelmapToElement(viewport.element, labelmapData, segmentationId, config);
+    return result || undefined;
+}
+export default {
+    render,
+    removeRepresentation,
+};
+export { render, removeRepresentation };

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

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

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

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

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,67 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { utilities } 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 { getSurfaceActorEntry, getSurfaceRepresentationUID, } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
+    const enabledElement = getEnabledElement(element);
+    const { viewport } = enabledElement;
+    const surfaceActorEntry = getSurfaceActorEntry(viewport.id, segmentationId, surface.segmentIndex);
+    const surfaceActor = surfaceActorEntry?.actor;
+    const isVisible = surface.visible;
+    if (surfaceActor) {
+        surfaceActor.setVisibility(isVisible);
+        if (!isVisible) {
+            return;
+        }
+        const surfaceMapper = surfaceActor.getMapper();
+        const currentPolyData = surfaceMapper.getInputData();
+        const newPoints = surface.points;
+        const newPolys = surface.polys;
+        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();
+        viewport.getRenderer().resetCameraClippingRange();
+        return;
+    }
+    const points = surface.points;
+    const polys = surface.polys;
+    const color = surface.color;
+    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);
+    const representationUID = getSurfaceRepresentationUID(segmentationId, surface.segmentIndex);
+    viewport.addActor({
+        uid: utilities.uuidv4(),
+        actor: actor,
+        clippingFilter,
+        representationUID,
+    });
+    viewport.resetCamera();
+    viewport.getRenderer().resetCameraClippingRange();
+    viewport.render();
+}
+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,10 @@
+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 filteredSurfaceActors = actorEntries.filter((actor) => actor.uid.startsWith(getSurfaceActorUID(viewport.id, segmentationId, '')));
+    viewport.removeActors(filteredSurfaceActors.map((actor) => actor.uid));
+}
+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,76 @@
+import { cache, getEnabledElementByViewportId, Enums, } 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 { getPolySeg } from '../../../config';
+import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
+import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+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, type } = representation;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    let SurfaceData = segmentation.representationData[Representations.Surface];
+    if (!SurfaceData &&
+        getPolySeg()?.canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
+        const polySeg = getPolySeg();
+        SurfaceData = await computeAndAddRepresentation(segmentationId, Representations.Surface, () => polySeg.computeSurfaceData(segmentationId, { viewport }), () => polySeg.updateSurfaceData(segmentationId, { viewport }));
+        if (!SurfaceData) {
+            throw new Error(`No Surface data found for segmentationId ${segmentationId} even we tried to compute it`);
+        }
+    }
+    else if (!SurfaceData && !getPolySeg()) {
+        console.debug(`No surface data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to surface. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
+    if (!SurfaceData) {
+        console.warn(`No Surface data found for segmentationId ${segmentationId}. Skipping render.`);
+        return;
+    }
+    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) => {
+        const geometry = cache.getGeometry(geometryId);
+        if (!geometry?.data) {
+            console.warn(`No Surfaces found for geometryId ${geometryId}. Skipping render.`);
+            return;
+        }
+        const segmentIndex = geometry.data.segmentIndex;
+        const hiddenSegments = internalGetHiddenSegmentIndices(viewport.id, {
+            segmentationId,
+            type,
+        });
+        const isHidden = hiddenSegments.has(segmentIndex);
+        const surface = geometry.data;
+        const color = colorLUT[segmentIndex];
+        surface.color = color.slice(0, 3);
+        surface.visible = !isHidden;
+        surfaces.push(surface);
+        addOrUpdateSurfaceToElement(viewport.element, surface, segmentationId);
+    });
+    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;

package/dist/esm/tools/distancePointToContour.js

@@ -0,0 +1,18 @@
+import { point } from '../utilities/math';
+export const distancePointToContour = (viewport, annotation, coords) => {
+    if (!annotation?.data?.contour?.polyline?.length) {
+        return;
+    }
+    const { polyline } = annotation.data.contour;
+    const { length } = polyline;
+    let distance = Infinity;
+    for (let i = 0; i < length; i++) {
+        const canvasPoint = viewport.worldToCanvas(polyline[i]);
+        const distanceToPoint = point.distanceToPoint(canvasPoint, coords);
+        distance = Math.min(distance, distanceToPoint);
+    }
+    if (distance === Infinity || isNaN(distance)) {
+        return;
+    }
+    return distance;
+};

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

@@ -0,0 +1,57 @@
+import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
+import PanTool from './PanTool';
+import TrackballRotateTool from './TrackballRotateTool';
+import WindowLevelTool from './WindowLevelTool';
+import WindowLevelRegionTool from './WindowLevelRegionTool';
+import StackScrollTool from './StackScrollTool';
+import PlanarRotateTool from './PlanarRotateTool';
+import ZoomTool from './ZoomTool';
+import MIPJumpToClickTool from './MIPJumpToClickTool';
+import CrosshairsTool from './CrosshairsTool';
+import MagnifyTool from './MagnifyTool';
+import AdvancedMagnifyTool from './AdvancedMagnifyTool';
+import ReferenceLinesTool from './ReferenceLinesTool';
+import OverlayGridTool from './OverlayGridTool';
+import SegmentationIntersectionTool from './SegmentationIntersectionTool';
+import ReferenceCursors from './ReferenceCursors';
+import ScaleOverlayTool from './ScaleOverlayTool';
+import SculptorTool from './SculptorTool';
+import VolumeRotateTool from './VolumeRotateTool';
+import BidirectionalTool from './annotation/BidirectionalTool';
+import LabelTool from './annotation/LabelTool';
+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';
+import EllipticalROITool from './annotation/EllipticalROITool';
+import CircleROITool from './annotation/CircleROITool';
+import ETDRSGridTool from './annotation/ETDRSGridTool';
+import SplineROITool from './annotation/SplineROITool';
+import SplineContourSegmentationTool from './annotation/SplineContourSegmentationTool';
+import PlanarFreehandROITool from './annotation/PlanarFreehandROITool';
+import PlanarFreehandContourSegmentationTool from './annotation/PlanarFreehandContourSegmentationTool';
+import LivewireContourTool from './annotation/LivewireContourTool';
+import LivewireContourSegmentationTool from './annotation/LivewireContourSegmentationTool';
+import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
+import AngleTool from './annotation/AngleTool';
+import CobbAngleTool from './annotation/CobbAngleTool';
+import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
+import KeyImageTool from './annotation/KeyImageTool';
+import AnnotationEraserTool from './AnnotationEraserTool';
+import RegionSegmentTool from './annotation/RegionSegmentTool';
+import RegionSegmentPlusTool from './annotation/RegionSegmentPlusTool';
+import WholeBodySegmentTool from './annotation/WholeBodySegmentTool';
+import LabelmapBaseTool from './segmentation/LabelmapBaseTool';
+import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
+import CircleScissorsTool from './segmentation/CircleScissorsTool';
+import SphereScissorsTool from './segmentation/SphereScissorsTool';
+import RectangleROIThresholdTool from './segmentation/RectangleROIThresholdTool';
+import RectangleROIStartEndThresholdTool from './segmentation/RectangleROIStartEndThresholdTool';
+import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThresholdTool';
+import BrushTool from './segmentation/BrushTool';
+import PaintFillTool from './segmentation/PaintFillTool';
+import OrientationMarkerTool from './OrientationMarkerTool';
+import SegmentSelectTool from './segmentation/SegmentSelectTool';
+import * as strategies from './segmentation/strategies';
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, strategies, };

package/dist/esm/tools/index.js

@@ -0,0 +1,57 @@
+import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
+import PanTool from './PanTool';
+import TrackballRotateTool from './TrackballRotateTool';
+import WindowLevelTool from './WindowLevelTool';
+import WindowLevelRegionTool from './WindowLevelRegionTool';
+import StackScrollTool from './StackScrollTool';
+import PlanarRotateTool from './PlanarRotateTool';
+import ZoomTool from './ZoomTool';
+import MIPJumpToClickTool from './MIPJumpToClickTool';
+import CrosshairsTool from './CrosshairsTool';
+import MagnifyTool from './MagnifyTool';
+import AdvancedMagnifyTool from './AdvancedMagnifyTool';
+import ReferenceLinesTool from './ReferenceLinesTool';
+import OverlayGridTool from './OverlayGridTool';
+import SegmentationIntersectionTool from './SegmentationIntersectionTool';
+import ReferenceCursors from './ReferenceCursors';
+import ScaleOverlayTool from './ScaleOverlayTool';
+import SculptorTool from './SculptorTool';
+import VolumeRotateTool from './VolumeRotateTool';
+import BidirectionalTool from './annotation/BidirectionalTool';
+import LabelTool from './annotation/LabelTool';
+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';
+import EllipticalROITool from './annotation/EllipticalROITool';
+import CircleROITool from './annotation/CircleROITool';
+import ETDRSGridTool from './annotation/ETDRSGridTool';
+import SplineROITool from './annotation/SplineROITool';
+import SplineContourSegmentationTool from './annotation/SplineContourSegmentationTool';
+import PlanarFreehandROITool from './annotation/PlanarFreehandROITool';
+import PlanarFreehandContourSegmentationTool from './annotation/PlanarFreehandContourSegmentationTool';
+import LivewireContourTool from './annotation/LivewireContourTool';
+import LivewireContourSegmentationTool from './annotation/LivewireContourSegmentationTool';
+import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
+import AngleTool from './annotation/AngleTool';
+import CobbAngleTool from './annotation/CobbAngleTool';
+import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
+import KeyImageTool from './annotation/KeyImageTool';
+import AnnotationEraserTool from './AnnotationEraserTool';
+import RegionSegmentTool from './annotation/RegionSegmentTool';
+import RegionSegmentPlusTool from './annotation/RegionSegmentPlusTool';
+import WholeBodySegmentTool from './annotation/WholeBodySegmentTool';
+import LabelmapBaseTool from './segmentation/LabelmapBaseTool';
+import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
+import CircleScissorsTool from './segmentation/CircleScissorsTool';
+import SphereScissorsTool from './segmentation/SphereScissorsTool';
+import RectangleROIThresholdTool from './segmentation/RectangleROIThresholdTool';
+import RectangleROIStartEndThresholdTool from './segmentation/RectangleROIStartEndThresholdTool';
+import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThresholdTool';
+import BrushTool from './segmentation/BrushTool';
+import PaintFillTool from './segmentation/PaintFillTool';
+import OrientationMarkerTool from './OrientationMarkerTool';
+import SegmentSelectTool from './segmentation/SegmentSelectTool';
+import * as strategies from './segmentation/strategies';
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, strategies, };

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

@@ -0,0 +1,27 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
+import LabelmapBaseTool from './LabelmapBaseTool';
+declare class BrushTool extends LabelmapBaseTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    onSetToolPassive: (evt: any) => void;
+    onSetToolEnabled: () => void;
+    onSetToolDisabled: (evt: any) => void;
+    private disableCursor;
+    preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
+    mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
+    previewCallback: () => void;
+    protected updateCursor(evt: EventTypes.InteractionEventType): void;
+    private _dragCallback;
+    private _calculateCursor;
+    private _endCallback;
+    getStatistics(element: any, segmentIndices?: any): any;
+    rejectPreview(element?: HTMLDivElement): void;
+    interpolate(element: any, config: any): void;
+    acceptPreview(element?: HTMLDivElement): void;
+    private _activateDraw;
+    private _deactivateDraw;
+    invalidateBrushCursor(): void;
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
+}
+export default BrushTool;