@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.11

package/src/types/FloodFillTypes.ts

@@ -5,13 +5,13 @@ type FloodFillResult = {
   boundaries: Types.Point2[] | Types.Point3[];
 };
 
-type FloodFillGetter3D = (x: number, y: number, z: number) => number;
-type FloodFillGetter2D = (x: number, y: number) => number;
+type FloodFillGetter3D = (x: number, y: number, z: number) => unknown;
+type FloodFillGetter2D = (x: number, y: number) => unknown;
 type FloodFillGetter = FloodFillGetter2D | FloodFillGetter3D;
 
 type FloodFillOptions = {
-  onFlood?: (x, y) => void;
-  onBoundary?: (x, y) => void;
+  onFlood?: (x: number, y: number, z?: number) => void;
+  onBoundary?: (x: number, y: number, z?: number) => void;
   equals?: (a, b) => boolean; // Equality operation for your datastructure. Defaults to a === b.
   diagonals?: boolean; // Whether to flood fill across diagonals. Default false.
 };

package/src/types/ISculptToolShape.ts

@@ -0,0 +1,63 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper, EventTypes, ContourAnnotation } from '.';
+import type { PushedHandles } from '../tools/SculptorTool/CircleSculptCursor';
+import type { SculptData } from '../tools/SculptorTool';
+
+/**
+ * This interface defines a contract for implementing various shapes within the sculptor tool.
+ * Classes such as `CircleSculptCursor` adhere to this interface,
+ * providing specific implementations for sculptor tools to utilize the shape
+ * during sculpting operations.
+ */
+export interface ISculptToolShape {
+  /**
+   * Used to render shapes supported for sculptor tool
+   *
+   * @param svgDrawingHelper - The svgDrawingHelper providing the context for drawing.
+   * @param canvasLocation - Current canvas location in canvas index coordinates
+   * @param options - Options for drawing shapes
+   */
+  renderShape(
+    svgDrawingHelper: SVGDrawingHelper,
+    canvasLocation: Types.Point2,
+    options
+  ): void;
+  /**
+   * Pushes the points radially away from the mouse if they are
+   * contained within the shape defined by the freehandSculpter tool
+   */
+  pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
+
+  /**
+   * Function configures the tool size
+   */
+  configureToolSize(evt: EventTypes.InteractionEventType): void;
+
+  /**
+   * Updates the tool size
+   * @param canvasCoords - Current canvas points
+   */
+  updateToolSize(
+    canvasCoords: Types.Point2,
+    viewport: Types.IViewport,
+    activeAnnotation: ContourAnnotation
+  ): void;
+
+  /**
+   * Function returns max spacing between two handles
+   * @param minSpacing -
+   */
+  getMaxSpacing(minSpacing: number): number;
+
+  /**
+   * Function returns the the position to insert new handle
+   * @param previousIndex - Previous handle index
+   * @param nextIndex - Next handle index
+   * @param sculptData - Sculpt data
+   */
+  getInsertPosition(
+    previousIndex: number,
+    nextIndex: number,
+    sculptData: SculptData
+  ): Types.Point3;
+}

package/src/types/ISetToolModeOptions.ts

@@ -1,9 +1,9 @@
 import { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
 
-type ToolBindingMouseType = typeof MouseBindings[keyof typeof MouseBindings];
+type ToolBindingMouseType = (typeof MouseBindings)[keyof typeof MouseBindings];
 
 type ToolBindingKeyboardType =
-  typeof KeyboardBindings[keyof typeof KeyboardBindings];
+  (typeof KeyboardBindings)[keyof typeof KeyboardBindings];
 
 type IToolBinding = {
   /** Mouse button bindings e.g., MouseBindings.Primary/Secondary etc. */

package/src/types/ISpline.ts

@@ -0,0 +1,167 @@
+import { Types } from '@cornerstonejs/core';
+import type {
+  ClosestPoint,
+  ClosestControlPoint,
+  ClosestSplinePoint,
+  ControlPointInfo,
+} from './';
+
+/**
+ * Spline curve interface
+ */
+export interface ISpline {
+  /** Number of control points */
+  get numControlPoints(): number;
+
+  /** Resolution of the spline curve (greater than or equal to 0) */
+  get resolution(): number;
+
+  /** Set the resolution of the spline curve */
+  set resolution(resolution: number);
+
+  /** Fixed resolution (eg: Linear Spline) */
+  get fixedResolution(): boolean;
+
+  /** Flag that is set to true when the curve is already closed */
+  get closed(): boolean;
+
+  /** Set the curve as closed which connects the last to the first point */
+  set closed(closed: boolean);
+
+  /** Axis-aligned bounding box (minX, minY, maxX, maxY) */
+  get aabb(): Types.AABB2;
+
+  /** Length of the spline curve in pixels */
+  get length(): number;
+
+  /**
+   * Flag that is set to true when the spline needs to be updated. The update
+   * runs automaticaly when needed (eg: getPolylinePoints).
+   */
+  get invalidated(): boolean;
+
+  /**
+   * Bézier curves have tangent points connected to control points
+   * @returns True if the spline has tangent point or false otherwise
+   */
+  hasTangentPoints(): boolean;
+
+  /**
+   * Add a control point to the end of the array
+   * @param point - Control point (2D)
+   */
+  addControlPoint(point: Types.Point2): void;
+
+  /**
+   * Add a list of control poits to the end of the array
+   * @param points - Control points to be added
+   */
+  addControlPoints(points: Types.Point2[]): void;
+
+  /**
+   * Add a control point specifying its `u` value in Parameter Space which is a number from 0 to N
+   * where N is the number of curve segments. The integer part is the curve segment index and the
+   * decimal part is the `t` value on that curve segment.
+   * @param u - `u` value in Parameter Space
+   */
+  addControlPointAtU(u: number): ControlPointInfo;
+
+  /**
+   * Delete a control point given its index
+   * @param index - Control point index to be removed
+   * @returns True if the control point is removed or false otherwise
+   */
+  deleteControlPointByIndex(index: number): boolean;
+
+  /**
+   * Remove all control points
+   */
+  clearControlPoints(): void;
+
+  /**
+   * Replace all control points by some new ones
+   * @param points - Control points to be added to the array
+   */
+  setControlPoints(points: Types.Point2[]): void;
+
+  /**
+   * Update the coordinate of a control point given its index
+   * @param index - Control point index
+   * @param newControlPoint - New control point
+   */
+  updateControlPoint(index: number, newControlPoint: Types.Point2): void;
+
+  /**
+   * Get a list with all control points. The control points are cloned to prevent
+   * any caller from changing them resulting in unexpected behaviors
+   * @returns - List of all control points
+   */
+  getControlPoints(): Types.Point2[];
+
+  /**
+   * Finds the closest control point given a 2D point
+   * @param point - Reference point
+   * @returns Closest control point
+   */
+  getClosestControlPoint(point: Types.Point2): ClosestControlPoint;
+
+  /**
+   * Finds the closest control point given a 2D point and a maximum distance
+   * @param point - Reference 2D point
+   * @param maxDist - Maximum distance
+   * @returns Closest control point that is within the given range or undefined otherwise
+   */
+  getClosestControlPointWithinDistance(
+    point: Types.Point2,
+    range: number
+  ): ClosestControlPoint;
+
+  /**
+   * Finds the closest point on the spline curve given 2D point
+   * @param point - Reference 2D point
+   * @returns Closest point on the spline curve
+   */
+  getClosestPoint(point: Types.Point2): ClosestSplinePoint;
+
+  /**
+   * Finds the closest point on the straight line that connects all control points given a 2D point
+   * @param point - Reference point
+   * @returns Closest point on the straight line that connects all control points
+   */
+  getClosestPointOnControlPointLines(point: Types.Point2): ClosestPoint;
+
+  /**
+   * Get all points necessary to draw a spline curve
+   * @returns Array with all points necessary to draw a spline curve
+   */
+  getPolylinePoints(): Types.Point2[];
+
+  /**
+   * Get all points necessary to draw the preview curve for a new possible control point
+   * @returns Array with all points necessary to draw the preview curve
+   */
+  getPreviewPolylinePoints(
+    controlPointPreview: Types.Point2,
+    closeDistance: number
+  ): Types.Point2[];
+
+  /**
+   * Checks if a point is near to the spline curve
+   * @param point - Reference point
+   * @param maxDist - Maximum allowed distance
+   * @returns True if the point is close to the spline curve or false otherwise
+   */
+  isPointNearCurve(point: Types.Point2, maxDist: number): boolean;
+
+  /**
+   * Checks if a 2D point is inside the spline curve.
+   *
+   * A point is inside a curve/polygon if the number of intersections between the horizontal
+   * ray emanating from the given point and to the right and the line segments is odd.
+   * https://www.eecs.umich.edu/courses/eecs380/HANDOUTS/PROJ2/InsidePoly.html
+   *
+   * @param point - 2D Point
+   * @returns True is the point is inside the spline curve or false otherwise
+   */
+  containsPoint(point: Types.Point2): boolean;
+}

package/src/types/ISynchronizerEventHandler.ts

@@ -8,5 +8,5 @@ export default interface ISynchronizerEventHandler {
     targetViewport: Types.IViewportId,
     sourceEvent: any,
     options?: any
-  ): void;
+  ): Promise<void> | void;
 }

package/src/types/IToolGroup.ts

@@ -1,8 +1,15 @@
 import type { Types } from '@cornerstonejs/core';
-import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
+import {
+  IToolBinding,
+  SetToolBindingsType,
+  ToolOptionsType,
+} from './ISetToolModeOptions';
 import { MouseBindings } from '../enums';
+import { ToolConfiguration } from '../types';
 /**
  * ToolGroup interface
+ * @deprecated - this is going away in favour of using the type import from the
+ *      tool group itself.
  */
 export default interface IToolGroup {
   /** Unserializable instantiated tool classes, keyed by name */
@@ -19,11 +26,15 @@ export default interface IToolGroup {
   getViewportsInfo: () => Array<Types.IViewportId>;
   /** Get the toolInstance of the toolName */
   getToolInstance: { (toolName: string): any };
-  /** Add a tool to toolGroup with its configuration */
-  addTool: { (toolName: string, toolConfiguration?: any): void };
+  /** Check if a tool is already added to the tool group */
+  hasTool(toolName: string): boolean;
+  /** Add a tool to toolGroup with its configuration and custom calculator if wanted */
+  addTool: {
+    (toolName: string, toolConfiguration?: ToolConfiguration): void;
+  };
   /** Add tool instance, if you want to create more than one instance from the same tool e.g., brush/eraser tool */
   addToolInstance: {
-    (ttoolName: string, parentClassName: string, configuration?: any): void;
+    (toolName: string, parentClassName: string, configuration?: any): void;
   };
   /** Add viewports to share the tools for the ToolGroup */
   addViewport: {
@@ -39,7 +50,10 @@ export default interface IToolGroup {
   };
   /** Setting the tool to be Passive by its name*/
   setToolPassive: {
-    (toolName: string): void;
+    (
+      toolName: string,
+      options?: { removeAllBindings?: boolean | IToolBinding[] }
+    ): void;
   };
   /** Setting the tool to be Enabled by its name*/
   setToolEnabled: {
@@ -62,14 +76,21 @@ export default interface IToolGroup {
   setToolConfiguration: {
     (
       toolName: string,
-      configuration: Record<any, any>,
+      configuration: ToolConfiguration,
       overwrite?: boolean
     ): void;
   };
   getToolConfiguration: {
-    (toolName: string, configurationPath: string): any;
+    (toolName: string, configurationPath?: string): any;
   };
   getDefaultMousePrimary: {
     (): MouseBindings;
   };
+
+  clone: {
+    (
+      newToolGroupId: string,
+      fnToolFilter: (toolName: string) => boolean
+    ): IToolGroup;
+  };
 }

package/src/types/InterpolationTypes.ts

@@ -0,0 +1,48 @@
+import { Types } from '@cornerstonejs/core';
+import { Annotation } from './AnnotationTypes';
+import { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+
+/**
+ * A base viewport and annotation information used to start interpolating
+ * between slices.
+ */
+export type InterpolationViewportData = {
+  /** The annotation that was just completed. */
+  annotation: InterpolationROIAnnotation;
+  /** The type of event, whether initializing the label or updating it. */
+  interpolationUID: string;
+  /** The viewport that this interpolation is occurring within */
+  viewport: Types.IViewport;
+  sliceData: Types.ImageSliceData;
+  /** True if the interpolation data is being regenerated because of an update */
+  isInterpolationUpdate?: boolean;
+};
+
+export type ImageInterpolationData = {
+  sliceIndex: number;
+  annotations?: Annotation[];
+};
+
+/**
+ * The selector object for accepting interpolation results.  This object
+ * can be specified to select a sub-set of interpolation results.
+ */
+export type AcceptInterpolationSelector = {
+  /**
+   *  Specify the tool names to apply this to, defaulting to all
+   *  interpolation tools registered
+   */
+  toolNames?: string[];
+  /**
+   * Applies just to the given segmentation
+   */
+  segmentationId?: string;
+  /**
+   * Applies just to the given segment index.
+   */
+  segmentIndex?: number;
+  /**
+   * Only apply to the given slice index
+   */
+  sliceIndex?: number;
+};

package/src/types/LabelmapToolOperationData.ts

@@ -0,0 +1,46 @@
+import type { Types } from '@cornerstonejs/core';
+
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from './LabelmapTypes';
+
+type LabelmapToolOperationData = {
+  segmentationId: string;
+  segmentIndex: number;
+  /**
+   * The colours to use for previewing
+   */
+  previewColors?: Record<number, [number, number, number, number]>;
+  segmentsLocked: number[];
+  viewPlaneNormal: number[];
+  viewUp: number[];
+  strategySpecificConfiguration: any;
+  // constraintFn: (pointIJK: number) => boolean;
+  segmentationRepresentationUID: string;
+  points: Types.Point3[];
+  /**
+   * preview is used for sharing preview data between views/interactions with
+   * a tool, and needs to be maintained by the tool side in order to be able
+   * to accept/reject/update the preview information.
+   */
+  preview: any;
+  toolGroupId: string;
+};
+
+type LabelmapToolOperationDataStack = LabelmapToolOperationData &
+  LabelmapSegmentationDataStack;
+
+type LabelmapToolOperationDataVolume = LabelmapToolOperationData &
+  LabelmapSegmentationDataVolume;
+
+type LabelmapToolOperationDataAny =
+  | LabelmapToolOperationDataVolume
+  | LabelmapToolOperationDataStack;
+
+export {
+  LabelmapToolOperationData,
+  LabelmapToolOperationDataAny,
+  LabelmapToolOperationDataStack,
+  LabelmapToolOperationDataVolume,
+};

package/src/types/LabelmapTypes.ts

@@ -7,10 +7,13 @@ import type { vtkPiecewiseFunction } from '@kitware/vtk.js/Common/DataModel/Piec
 export type LabelmapConfig = {
   /** whether to render segmentation outline  */
   renderOutline?: boolean;
-  /** thickness of the outline when segmentation is active */
+  /** thickness of the outline when segmentation is active - all segments */
   outlineWidthActive?: number;
-  /** thickness of the outline when segmentation is inactive */
+  /** thickness of the outline when segmentation is inactive - all segments */
   outlineWidthInactive?: number;
+  /** delta thickness of the active segment index outline (0 means same thickness,
+   * 1 means 1px thicker, -1 means 1px thinner) */
+  activeSegmentOutlineWidthDelta?: number;
   /** whether to render segmentation filling */
   renderFill?: boolean;
   /** whether to render segmentation filling when inactive */
@@ -35,7 +38,25 @@ export type LabelmapRenderingConfig = {
   ofun?: vtkPiecewiseFunction;
 };
 
-export type LabelmapSegmentationData = {
+export type LabelmapSegmentationDataVolume = {
   volumeId: string;
   referencedVolumeId?: string;
 };
+
+export type LabelmapSegmentationDataStack = {
+  /**
+   * This is a Map from referenced imageId to the segmentation (Derived) imageIds (can be
+   * multiple) that are associated with it.
+   */
+  imageIdReferenceMap: Map<string, string>;
+};
+
+export type LabelmapSegmentationData =
+  | LabelmapSegmentationDataVolume
+  | LabelmapSegmentationDataStack
+  // PolySeg version that has both
+  | {
+      volumeId?: string;
+      referencedVolumeId?: string;
+      imageIdReferenceMap?: Map<string, string>;
+    };

package/src/types/PolySeg.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+
+export type PolySegConversionOptions = {
+  segmentIndices?: number[];
+  segmentationRepresentationUID?: string;
+  viewport?: Types.IStackViewport | Types.IVolumeViewport;
+};

package/src/types/ScrollOptions.ts

@@ -4,6 +4,7 @@ type ScrollOptions = {
   volumeId?: string;
   debounceLoading?: boolean;
   loop?: boolean;
+  scrollSlabs?: boolean;
 };
 
 export default ScrollOptions;

package/src/types/SegmentationStateTypes.ts

@@ -1,3 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
 import * as Enums from '../enums';
 import {
   ContourConfig,
@@ -9,17 +10,10 @@ import type {
   LabelmapRenderingConfig,
   LabelmapSegmentationData,
 } from './LabelmapTypes';
-
-/**
- * Four elements RGBA as 0-255
- */
-export type Color = [number, number, number, number];
-
-/**
- * Color LUT Array - Array of colors
- * [[0,0,0,0], [200,200,200,200], ....]
- */
-export type ColorLUT = Array<Color>;
+import {
+  SurfaceSegmentationData,
+  SurfaceRenderingConfig,
+} from './SurfaceTypes';
 
 export type SegmentSpecificRepresentationConfig = {
   [key: number | string]: RepresentationConfig;
@@ -30,6 +24,8 @@ export type RepresentationConfig = {
   LABELMAP?: LabelmapConfig;
   /** contour configuration */
   CONTOUR?: ContourConfig;
+  /** surface configuration */
+  SURFACE?: any;
 };
 
 export type SegmentationRepresentationConfig = {
@@ -42,6 +38,7 @@ export type SegmentationRepresentationConfig = {
 export type SegmentationRepresentationData = {
   LABELMAP?: LabelmapSegmentationData;
   CONTOUR?: ContourSegmentationData;
+  SURFACE?: SurfaceSegmentationData;
 };
 
 /**
@@ -110,6 +107,13 @@ export type ToolGroupSpecificRepresentationState = {
    * using to render
    */
   colorLUTIndex: number;
+  /**
+   * Poly Seg generated
+   */
+  polySeg?: {
+    enabled: boolean;
+    options?: any;
+  };
 };
 
 /**
@@ -132,6 +136,13 @@ export type ToolGroupSpecificContourRepresentation =
     segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
   };
 
+export type ToolGroupSpecificSurfaceRepresentation =
+  ToolGroupSpecificRepresentationState & {
+    config: SurfaceRenderingConfig;
+    segmentationRepresentationSpecificConfig?: RepresentationConfig;
+    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+  };
+
 export type ToolGroupSpecificRepresentation =
   | ToolGroupSpecificLabelmapRepresentation
   | ToolGroupSpecificContourRepresentation;
@@ -231,7 +242,7 @@ export type ToolGroupSpecificRepresentations =
  */
 export type SegmentationState = {
   /** Array of colorLUT for segmentation to render */
-  colorLUT: ColorLUT[];
+  colorLUT: Types.ColorLUT[];
   /** segmentations */
   segmentations: Segmentation[];
   /** global segmentation state with config */
@@ -252,11 +263,28 @@ export type SegmentationPublicInput = {
   segmentationId: string;
   representation: {
     type: Enums.SegmentationRepresentations;
-    data: LabelmapSegmentationData | ContourSegmentationData;
+    data?:
+      | LabelmapSegmentationData
+      | ContourSegmentationData
+      | SurfaceSegmentationData;
   };
 };
 
 export type RepresentationPublicInput = {
   segmentationId: string;
   type: Enums.SegmentationRepresentations;
+  options?: RepresentationPublicInputOptions;
+};
+
+export type RepresentationPublicInputOptions = {
+  segmentationRepresentationUID?: string;
+  // color lut to use for this representation (optional), it can
+  // be either a colorLUT array or the index of the colorLUT in the state
+  colorLUTOrIndex?: Types.ColorLUT | number;
+  // whether to use polymorphic segmentation utilities to convert
+  // from other representations to this representation
+  polySeg?: {
+    enabled: boolean;
+    options?: any;
+  };
 };

package/src/types/SplineCurveSegment.ts

@@ -0,0 +1,28 @@
+import { Types } from '@cornerstonejs/core';
+import type { SplineLineSegment } from './SplineLineSegment';
+
+/**
+ * Spline curve segment the is part of a spline path
+ */
+export type SplineCurveSegment = {
+  /**
+   * Control Points that influences the spline curve segment.
+   *
+   * For cubic splines the curve goes from P1 and P2 but it is also influenced by the
+   * previous point (P0) and the next point (P3)
+   */
+  controlPoints: {
+    p0: Types.Point2;
+    p1: Types.Point2;
+    p2: Types.Point2;
+    p3: Types.Point2;
+  };
+  /** Axis-aligned bounding (minX, minY, maxX, maxY) */
+  aabb: Types.AABB2;
+  /** Length of the curve segment */
+  length: number;
+  /** Total length of all previous curve segments */
+  previousCurveSegmentsLength: number;
+  /** Line segments that makes the curve segment */
+  lineSegments: SplineLineSegment[];
+};

package/src/types/SplineLineSegment.ts

@@ -0,0 +1,20 @@
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * Line segment the is part of a curve segment based on its resolution.
+ * Each curve segment shall have 20 line segments when spline resolution
+ * is set to 20.
+ */
+export type SplineLineSegment = {
+  /** Start and end points for the line segment */
+  points: {
+    start: Types.Point2;
+    end: Types.Point2;
+  };
+  /** Axis-aligned bounding (minX, minY, maxX, maxY) */
+  aabb: Types.AABB2;
+  /** Length of the line segment */
+  length: number;
+  /** Total length of all previous line segments for a given curve segment */
+  previousLineSegmentsLength: number;
+};

package/src/types/SplineProps.ts

@@ -0,0 +1,25 @@
+export type SplineProps = {
+  /**
+   * Resolution of the spline curve
+   *
+   * The number assigned to the resolution is the number of intermediate points on each
+   * curve segment that makes the spline path. For example, if the resolution is set to 0
+   * that means that each curve segment will have no intermediate points but only a straight
+   * line similar to Linear Spline. For a resolution equal to 20 that means the curve shall
+   * have 20 intermediate points or 21 line segments total making it look more like a curve.
+   */
+  resolution?: number;
+
+  /**
+   * Fixed resolution (Linear spline)
+   *
+   * Splines with `fixedResolution` set to true shall attempt to change the
+   * resolution (eg: spline.resolution = 10). That is useful, for example, for
+   * linear splines because having more line segments between two control points
+   * would not change its resolution and that is why it is fixed to 0.
+   */
+  fixedResolution?: boolean;
+
+  /** Flag that is set to true when the curve is closed */
+  closed?: boolean;
+};