@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/types/ISetToolModeOptions.d.ts

@@ -0,0 +1,16 @@
+import type { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
+type ToolBindingMouseType = (typeof MouseBindings)[keyof typeof MouseBindings];
+type ToolBindingKeyboardType = (typeof KeyboardBindings)[keyof typeof KeyboardBindings];
+type IToolBinding = {
+    mouseButton?: ToolBindingMouseType;
+    modifierKey?: ToolBindingKeyboardType;
+    numTouchPoints?: number;
+};
+type SetToolBindingsType = {
+    bindings: IToolBinding[];
+};
+type ToolOptionsType = {
+    bindings: IToolBinding[];
+    mode: ToolModes;
+};
+export type { IToolBinding, SetToolBindingsType, ToolOptionsType };

package/dist/esm/types/ISpline.d.ts

@@ -0,0 +1,30 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ClosestPoint, ClosestControlPoint, ClosestSplinePoint, ControlPointInfo } from './';
+export interface ISpline {
+    get numControlPoints(): number;
+    get resolution(): number;
+    set resolution(resolution: number);
+    get fixedResolution(): boolean;
+    get closed(): boolean;
+    set closed(closed: boolean);
+    get aabb(): Types.AABB2;
+    get length(): number;
+    get invalidated(): boolean;
+    hasTangentPoints(): boolean;
+    addControlPoint(point: Types.Point2): void;
+    addControlPoints(points: Types.Point2[]): void;
+    addControlPointAtU(u: number): ControlPointInfo;
+    deleteControlPointByIndex(index: number): boolean;
+    clearControlPoints(): void;
+    setControlPoints(points: Types.Point2[]): void;
+    updateControlPoint(index: number, newControlPoint: Types.Point2): void;
+    getControlPoints(): Types.Point2[];
+    getClosestControlPoint(point: Types.Point2): ClosestControlPoint;
+    getClosestControlPointWithinDistance(point: Types.Point2, range: number): ClosestControlPoint;
+    getClosestPoint(point: Types.Point2): ClosestSplinePoint;
+    getClosestPointOnControlPointLines(point: Types.Point2): ClosestPoint;
+    getPolylinePoints(): Types.Point2[];
+    getPreviewPolylinePoints(controlPointPreview: Types.Point2, closeDistance: number): Types.Point2[];
+    isPointNearCurve(point: Types.Point2, maxDist: number): boolean;
+    containsPoint(point: Types.Point2): boolean;
+}

package/dist/esm/types/ISynchronizerEventHandler.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../store';
+export default interface ISynchronizerEventHandler {
+    (synchronizer: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, sourceEvent: any, options?: unknown): Promise<void> | void;
+}

package/dist/esm/types/IToolClassReference.d.ts

@@ -0,0 +1,3 @@
+import type { BaseTool } from '../tools';
+type IToolClassReference = new <T extends BaseTool>(config: unknown) => T;
+export type { IToolClassReference as default };

package/dist/esm/types/IToolGroup.d.ts

@@ -0,0 +1,3 @@
+import type ToolGroup from '../store/ToolGroupManager/ToolGroup';
+type IToolGroup = ToolGroup;
+export type { IToolGroup as default };

package/dist/esm/types/ITouchPoints.d.ts

@@ -0,0 +1,11 @@
+import type IPoints from './IPoints';
+type ITouchPoints = IPoints & {
+    touch: {
+        identifier: string;
+        radiusX: number;
+        radiusY: number;
+        force: number;
+        rotationAngle: number;
+    };
+};
+export type { ITouchPoints as default };

package/dist/esm/types/InteractionTypes.d.ts

@@ -0,0 +1,2 @@
+type InteractionTypes = 'Mouse' | 'Touch';
+export type { InteractionTypes as default };

package/dist/esm/types/InternalToolTypes.d.ts

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+import type { AnnotationTool } from '../tools';
+import type { Annotation, Annotations } from './AnnotationTypes';
+type ToolAnnotationsPair = {
+    tool: AnnotationTool;
+    annotations: Annotations;
+};
+type ToolAnnotationPair = {
+    tool: AnnotationTool;
+    annotation: Annotation;
+};
+type ToolsWithMoveableHandles = ToolAnnotationPair & {
+    handle: Types.Point3;
+};
+export type { ToolsWithMoveableHandles, ToolAnnotationsPair, ToolAnnotationPair, };

package/dist/esm/types/InterpolationTypes.d.ts

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+import type { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+export type InterpolationViewportData = {
+    annotation: InterpolationROIAnnotation;
+    interpolationUID: string;
+    viewport: Types.IViewport;
+    sliceData: Types.ImageSliceData;
+    isInterpolationUpdate?: boolean;
+};
+export type ImageInterpolationData = {
+    sliceIndex: number;
+    annotations?: Annotation[];
+};
+export type AcceptInterpolationSelector = {
+    toolNames?: string[];
+    segmentationId?: string;
+    segmentIndex?: number;
+    sliceIndex?: number;
+};

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -0,0 +1,26 @@
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { LabelmapMemo } from '../utilities/segmentation/createLabelmapMemo';
+type LabelmapToolOperationData = {
+    segmentationId: string;
+    segmentIndex: number;
+    previewColors?: Record<number, [number, number, number, number]>;
+    segmentsLocked: number[];
+    viewPlaneNormal: number[];
+    viewUp: number[];
+    activeStrategy: string;
+    points: Types.Point3[];
+    voxelManager: any;
+    override: {
+        voxelManager: Types.IVoxelManager<number>;
+        imageData: vtkImageData;
+    };
+    preview: any;
+    toolGroupId: string;
+    createMemo: (segmentId: any, segmentVoxels: any, previewVoxels?: any, previewMemo?: any) => LabelmapMemo;
+};
+type LabelmapToolOperationDataStack = LabelmapToolOperationData & LabelmapSegmentationDataStack;
+type LabelmapToolOperationDataVolume = LabelmapToolOperationData & LabelmapSegmentationDataVolume;
+type LabelmapToolOperationDataAny = LabelmapToolOperationDataVolume | LabelmapToolOperationDataStack;
+export type { LabelmapToolOperationData, LabelmapToolOperationDataAny, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, };

package/dist/esm/types/LabelmapTypes.d.ts

@@ -0,0 +1,29 @@
+export type BaseLabelmapStyle = {
+    renderOutline?: boolean;
+    outlineWidth?: number;
+    activeSegmentOutlineWidthDelta?: number;
+    renderFill?: boolean;
+    fillAlpha?: number;
+    outlineOpacity?: number;
+};
+export type InactiveLabelmapStyle = {
+    renderOutlineInactive?: boolean;
+    outlineWidthInactive?: number;
+    renderFillInactive?: boolean;
+    fillAlphaInactive?: number;
+    outlineOpacityInactive?: number;
+};
+export type LabelmapStyle = BaseLabelmapStyle & InactiveLabelmapStyle;
+export type LabelmapSegmentationDataVolume = {
+    volumeId: string;
+    referencedVolumeId?: string;
+};
+export type LabelmapSegmentationDataStack = {
+    imageIds: string[];
+};
+export type LabelmapSegmentationData = LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack | {
+    volumeId?: string;
+    referencedVolumeId?: string;
+    referencedImageIds?: string[];
+    imageIds?: string[];
+};

package/dist/esm/types/PlanarBoundingBox.d.ts

@@ -0,0 +1,7 @@
+type PlanarBoundingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type { PlanarBoundingBox as default };

package/dist/esm/types/SVGDrawingHelper.d.ts

@@ -0,0 +1,9 @@
+type SVGDrawingHelper = {
+    svgLayerElement: HTMLDivElement;
+    svgNodeCacheForCanvas: Record<string, unknown>;
+    getSvgNode: (cacheKey: string) => SVGGElement | undefined;
+    appendNode: (svgNode: SVGElement, cacheKey: string) => void;
+    setNodeTouched: (cacheKey: string) => void;
+    clearUntouched: () => void;
+};
+export type { SVGDrawingHelper as default };

package/dist/esm/types/SegmentationStateTypes.d.ts

@@ -0,0 +1,96 @@
+import type { Enums as coreEnums, Types } from '@cornerstonejs/core';
+import type * as Enums from '../enums';
+import type { ContourSegmentationData } from './ContourTypes';
+import type { LabelmapSegmentationData } from './LabelmapTypes';
+import type { SurfaceSegmentationData } from './SurfaceTypes';
+import type vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import type vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+export type RepresentationsData = {
+    [Enums.SegmentationRepresentations.Labelmap]?: LabelmapSegmentationData;
+    [Enums.SegmentationRepresentations.Contour]?: ContourSegmentationData;
+    [Enums.SegmentationRepresentations.Surface]?: SurfaceSegmentationData;
+};
+export type RepresentationData = LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
+export type Segment = {
+    segmentIndex: number;
+    label: string;
+    locked: boolean;
+    cachedStats: {
+        [key: string]: unknown;
+    };
+    active: boolean;
+};
+export type Segmentation = {
+    segmentationId: string;
+    label: string;
+    segments: {
+        [segmentIndex: number]: Segment;
+    };
+    representationData: RepresentationsData;
+    cachedStats: {
+        [key: string]: unknown;
+    };
+};
+export type LabelmapRenderingConfig = {
+    cfun: vtkColorTransferFunction;
+    ofun: vtkPiecewiseFunction;
+    colorLUTIndex: number;
+    blendMode?: coreEnums.BlendModes;
+};
+export type ContourRenderingConfig = {};
+export type SurfaceRenderingConfig = {};
+export type RenderingConfig = LabelmapRenderingConfig | ContourRenderingConfig | SurfaceRenderingConfig;
+type BaseSegmentationRepresentation = {
+    colorLUTIndex: number;
+    segmentationId: string;
+    type: Enums.SegmentationRepresentations;
+    visible: boolean;
+    active: boolean;
+    segments: {
+        [segmentIndex: number]: {
+            visible: boolean;
+        };
+    };
+};
+export type LabelmapRepresentation = BaseSegmentationRepresentation & {
+    config: LabelmapRenderingConfig;
+};
+export type ContourRepresentation = BaseSegmentationRepresentation & {
+    config: ContourRenderingConfig;
+};
+export type SurfaceRepresentation = BaseSegmentationRepresentation & {
+    config: SurfaceRenderingConfig;
+};
+export type SegmentationRepresentation = LabelmapRepresentation | ContourRepresentation | SurfaceRepresentation;
+export type SegmentationState = {
+    colorLUT: Types.ColorLUT[];
+    segmentations: Segmentation[];
+    viewportSegRepresentations: {
+        [viewportId: string]: Array<SegmentationRepresentation>;
+    };
+};
+export type SegmentationPublicInput = {
+    segmentationId: string;
+    representation: {
+        type: Enums.SegmentationRepresentations;
+        data?: RepresentationData;
+    };
+    config?: {
+        segments?: {
+            [segmentIndex: number]: Partial<Segment>;
+        };
+        label?: string;
+        cachedStats?: {
+            [key: string]: unknown;
+        };
+    };
+};
+export type RepresentationPublicInput = {
+    segmentationId: string;
+    type?: Enums.SegmentationRepresentations;
+    config?: {
+        colorLUTOrIndex?: Types.ColorLUT | number;
+        blendMode?: coreEnums.BlendModes;
+    };
+};
+export {};

package/dist/esm/types/SplineCurveSegment.d.ts

@@ -0,0 +1,14 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SplineLineSegment } from './SplineLineSegment';
+export type SplineCurveSegment = {
+    controlPoints: {
+        p0: Types.Point2;
+        p1: Types.Point2;
+        p2: Types.Point2;
+        p3: Types.Point2;
+    };
+    aabb: Types.AABB2;
+    length: number;
+    previousCurveSegmentsLength: number;
+    lineSegments: SplineLineSegment[];
+};

package/dist/esm/types/SplineLineSegment.d.ts

@@ -0,0 +1,10 @@
+import type { Types } from '@cornerstonejs/core';
+export type SplineLineSegment = {
+    points: {
+        start: Types.Point2;
+        end: Types.Point2;
+    };
+    aabb: Types.AABB2;
+    length: number;
+    previousLineSegmentsLength: number;
+};

package/dist/esm/types/SplineProps.d.ts

@@ -0,0 +1,5 @@
+export type SplineProps = {
+    resolution?: number;
+    fixedResolution?: boolean;
+    closed?: boolean;
+};

package/dist/esm/types/SurfaceTypes.d.ts

@@ -0,0 +1,5 @@
+export type SurfaceStyle = {};
+export type SurfaceStateStyles = {};
+export type SurfaceSegmentationData = {
+    geometryIds: Map<number, string>;
+};

package/dist/esm/types/ToolAction.d.ts

@@ -0,0 +1,8 @@
+import type { Annotation } from './AnnotationTypes';
+import type { InteractionEventType } from './EventTypes';
+import type { SetToolBindingsType } from './ISetToolModeOptions';
+type ToolAction = {
+    method: string | ((evt: InteractionEventType, annotation: Annotation) => void);
+    bindings: SetToolBindingsType[];
+};
+export type { ToolAction as default };

package/dist/esm/types/ToolHandle.d.ts

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+type AnnotationHandle = Types.Point3;
+type TextBoxHandle = {
+    hasMoved: boolean;
+    worldBoundingBox: {
+        bottomLeft: Types.Point3;
+        bottomRight: Types.Point3;
+        topLeft: Types.Point3;
+        topRight: Types.Point3;
+    };
+    worldPosition: Types.Point3;
+};
+type ToolHandle = AnnotationHandle | TextBoxHandle;
+export type { AnnotationHandle, TextBoxHandle };
+export type { ToolHandle as default };

package/dist/esm/types/ToolProps.d.ts

@@ -0,0 +1,13 @@
+import type { Calculator } from '../utilities/math/basic';
+type SharedToolProp = {
+    supportedInteractionTypes?: Array<string>;
+    configuration?: ToolConfiguration;
+};
+export type ToolConfiguration = Record<string, any> & {
+    statsCalculator?: Calculator;
+};
+export type ToolProps = SharedToolProp;
+export type PublicToolProps = SharedToolProp & {
+    name?: string;
+};
+export {};