@cornerstonejs/tools 2.0.0-beta.6 → 2.0.0-beta.7

package/src/types/ContourTypes.ts

@@ -2,6 +2,8 @@
  * Label map config for the label map representation
  */
 export type ContourConfig = {
+  /** thickness of the outline when segmentation is auto generated */
+  outlineWidthAutoGenerated?: number;
   /** thickness of the outline when segmentation is active */
   outlineWidthActive?: number;
   /** thickness of the outline when segmentation is inactive */
@@ -10,6 +12,17 @@ export type ContourConfig = {
   outlineOpacity?: number;
   /** alpha of outline for inactive segmentation */
   outlineOpacityInactive?: number;
+  /** dash style of the outline when segmentation is active */
+  outlineDashActive?: string;
+  /** dash style of the outline when segmentation is inactive */
+  outlineDashInactive?: string;
+  /** delta thickness of the active segment index outline (0 means same thickness,
+   * 1 means 1px thicker, -1 means 1px thinner) */
+  activeSegmentOutlineWidthDelta?: number;
+  /**
+   * Dash style of the outline when segmentation is auto-generated
+   */
+  outlineDashAutoGenerated?: string;
   /** outline visibility */
   renderOutline?: boolean;
   /** render fill */
@@ -18,6 +31,8 @@ export type ContourConfig = {
   fillAlpha?: number;
   /** fillAlphaInactive */
   fillAlphaInactive?: number;
+  /** fillAlphaAutoGenerated */
+  fillAlphaAutoGenerated?: number;
 };
 
 /**
@@ -30,5 +45,8 @@ export type ContourRenderingConfig = {
 export type ContourSegmentationData = {
   // Ids of the contourSets that are part of this segmentation
   // in the cache
-  geometryIds: string[];
+  geometryIds?: string[];
+  // Ids of the annotations that are part of this segmentation
+  // grouped by segmentIndex
+  annotationUIDsMap?: Map<number, Set<string>>;
 };

package/src/types/ControlPointInfo.ts

@@ -0,0 +1,8 @@
+import { Types } from '@cornerstonejs/core';
+
+export type ControlPointInfo = {
+  /** Control point index */
+  index: number;
+  /** 2D coordinate */
+  point: Types.Point2;
+};

package/src/types/EventTypes.ts

@@ -6,6 +6,8 @@ import IDistance from './IDistance';
 import { SetToolBindingsType } from './ISetToolModeOptions';
 import { Swipe } from '../enums/Touch';
 import { ToolModes } from '../enums';
+import { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+import { ChangeTypes } from '../enums';
 
 /**
  * The normalized interaction event detail
@@ -104,9 +106,9 @@ type ToolActivatedEventDetail = {
  */
 type AnnotationAddedEventDetail = {
   /** unique id of the viewport */
-  viewportId: string;
+  viewportId?: string;
   /** unique id of the rendering engine */
-  renderingEngineId: string;
+  renderingEngineId?: string;
   /** The annotation that is being added to the annotations manager. */
   annotation: Annotation;
 };
@@ -118,6 +120,7 @@ type AnnotationAddedEventDetail = {
 type AnnotationCompletedEventDetail = {
   /** The annotation that is being added to the annotations manager. */
   annotation: Annotation;
+  changeType?: ChangeTypes.Completed;
 };
 
 /**
@@ -130,6 +133,8 @@ type AnnotationModifiedEventDetail = {
   renderingEngineId: string;
   /** The annotation that is being added to the annotations manager. */
   annotation: Annotation;
+  /** The type of this change */
+  changeType?: ChangeTypes;
 };
 
 /**
@@ -187,6 +192,36 @@ type AnnotationRenderedEventDetail = {
   renderingEngineId: string;
 };
 
+type AnnotationInterpolationCompletedEventDetail = {
+  /** The annotation that is being updated with a change in label. */
+  annotation: InterpolationROIAnnotation;
+  /** The HTML element that the annotation was rendered on. */
+  element: HTMLDivElement;
+  /** unique id of the viewport */
+  viewportId: string;
+  /** unique id of the rendering engine */
+  renderingEngineId: string;
+};
+
+type AnnotationInterpolationRemovedEventDetail = {
+  /** The annotations that is being removed . */
+  annotations: Array<InterpolationROIAnnotation>;
+  /** The HTML element that the annotation was rendered on. */
+  element: HTMLDivElement;
+  /** unique id of the viewport */
+  viewportId: string;
+  /** unique id of the rendering engine */
+  renderingEngineId: string;
+};
+
+/**
+ * The data that is passed to the event handler when a new contour annotation is
+ * completed drawing on the viewport.
+ */
+type ContourAnnotationCompletedEventDetail = AnnotationCompletedEventDetail & {
+  contourHoleProcessingEnabled: boolean;
+};
+
 /**
  * EventDetail for when a Segmentation Data is modified by a tool
  */
@@ -498,6 +533,18 @@ type AnnotationLockChangeEventType =
 type AnnotationVisibilityChangeEventType =
   Types.CustomEventType<AnnotationVisibilityChangeEventDetail>;
 
+/**
+ * The Annotation interpolation process completed event type
+ */
+type AnnotationInterpolationCompletedEventType =
+  Types.CustomEventType<AnnotationInterpolationCompletedEventDetail>;
+
+/**
+ * The Annotation interpolation removed event type
+ */
+type AnnotationInterpolationRemovedEventType =
+  Types.CustomEventType<AnnotationInterpolationRemovedEventDetail>;
+
 /**
  * Event for when SegmentationData is modified
  */
@@ -670,6 +717,11 @@ export {
   AnnotationVisibilityChangeEventDetail,
   AnnotationLockChangeEventType,
   AnnotationVisibilityChangeEventType,
+  AnnotationInterpolationCompletedEventDetail,
+  AnnotationInterpolationCompletedEventType,
+  AnnotationInterpolationRemovedEventDetail,
+  AnnotationInterpolationRemovedEventType,
+  ContourAnnotationCompletedEventDetail,
   SegmentationDataModifiedEventType,
   SegmentationRepresentationModifiedEventDetail,
   SegmentationRepresentationModifiedEventType,

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/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,9 +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 */
@@ -20,13 +26,15 @@ export default interface IToolGroup {
   getViewportsInfo: () => Array<Types.IViewportId>;
   /** Get the toolInstance of the toolName */
   getToolInstance: { (toolName: string): any };
+  /** 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: {
@@ -42,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: {
@@ -70,7 +81,7 @@ export default interface IToolGroup {
     ): void;
   };
   getToolConfiguration: {
-    (toolName: string, configurationPath: string): any;
+    (toolName: string, configurationPath?: string): any;
   };
   getDefaultMousePrimary: {
     (): MouseBindings;

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;