@cornerstonejs/tools 0.56.1 → 0.56.3

package/src/types/IAnnotationManager.ts

@@ -0,0 +1,89 @@
+import AnnotationGroupSelector from './AnnotationGroupSelector';
+import {
+  Annotation,
+  Annotations,
+  GroupSpecificAnnotations,
+} from './AnnotationTypes';
+
+/**
+ * The interface for any annotation manager (custom or default)
+ */
+interface IAnnotationManager {
+  /**
+   * Annotations are stored in Groups. Our default annotation manager
+   * groups the annotations based on FrameOfReferenceUID, but it is possible
+   * that you can group them based on different aspects or you only have one group
+   * totally.
+   *
+   * This function returns the group key associated with the specified
+   * annotationGroupSelector. The annotationGroupSelector can be an HTML element
+   * or a string.
+   *
+   * @param annotationGroupSelector - The annotation group selector.
+   * @returns The group key associated with the element.
+   */
+  getGroupKey: (annotationGroupSelector: AnnotationGroupSelector) => string;
+
+  /**
+   * Adds an annotation to the specified group.
+   * @param annotation - The annotation to add.
+   * @param groupKey - The group key to add the annotation to.
+   */
+  addAnnotation: (annotation: Annotation, groupKey: string) => void;
+
+  /**
+   * Returns the annotations associated with the specified group, if the
+   * toolName is specified, it will return the annotations for the specified
+   * tool.
+   * @param groupKey - The group key to retrieve annotations for.
+   * @param toolName - The name of the tool to retrieve annotations for.
+   *
+   * @returns The annotations associated with the specified group and tool.
+   */
+  getAnnotations: (
+    groupKey: string,
+    toolName?: string
+  ) => GroupSpecificAnnotations | Annotations;
+
+  /**
+   * Returns the annotation with the specified UID.
+   * @param annotationUID - The UID of the annotation to retrieve.
+   * @returns The annotation with the specified UID.
+   */
+  getAnnotation: (annotationUID: string) => Annotation;
+
+  /**
+   * Removes the annotation with the specified UID.
+   * @param annotationUID - The UID of the annotation to remove.
+   */
+  removeAnnotation: (annotationUID: string) => void;
+
+  /**
+   * Removes all annotations associated with the specified group.
+   * @param groupKey - The group key to remove annotations for.
+   */
+  removeAnnotations: (groupKey: string) => void;
+
+  /**
+   * Removes all annotations.
+   */
+  removeAllAnnotations: () => void;
+
+  /**
+   * Returns the number of annotations associated with the specified group.
+   * If the toolName is specified, it will return the number of annotations
+   *
+   * @param groupKey - The group key to count annotations for.
+   * @param toolName - The name of the tool to count annotations for.
+   * @returns The number of annotations associated with the specified group.
+   */
+  getNumberOfAnnotations: (groupKey: string, toolName?: string) => number;
+
+  /**
+   * Returns the total number of annotations across all groups.
+   * @returns The total number of annotations across all groups.
+   */
+  getNumberOfAllAnnotations: () => number;
+}
+
+export default IAnnotationManager;

package/src/types/IDistance.ts

@@ -0,0 +1,16 @@
+/**
+ * Distance in page, client, canvas and world
+ * coordinates.
+ */
+type IDistance = {
+  /** page distance */
+  page: number;
+  /** client distance */
+  client: number;
+  /** canvas distance */
+  canvas: number;
+  /** world distance */
+  world: number;
+};
+
+export default IDistance;

package/src/types/IPoints.ts

@@ -0,0 +1,18 @@
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * Points in page, client, canvas and world
+ * coordinates.
+ */
+type IPoints = {
+  /** page coordinates of the point */
+  page: Types.Point2;
+  /** client coordinates of the point */
+  client: Types.Point2;
+  /** canvas coordinates of the point */
+  canvas: Types.Point2;
+  /** world coordinates of the point */
+  world: Types.Point3;
+};
+
+export default IPoints;

package/src/types/ISetToolModeOptions.ts

@@ -0,0 +1,29 @@
+import { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
+
+type ToolBindingMouseType = typeof MouseBindings[keyof typeof MouseBindings];
+
+type ToolBindingKeyboardType =
+  typeof KeyboardBindings[keyof typeof KeyboardBindings];
+
+type IToolBinding = {
+  /** Mouse button bindings e.g., MouseBindings.Primary/Secondary etc. */
+  mouseButton?: ToolBindingMouseType;
+  /** Keyboard bindings e.g., KeyboardBindings.Shift/Ctrl etc. */
+  modifierKey?: ToolBindingKeyboardType;
+  /** Number of touch points */
+  numTouchPoints?: number;
+};
+
+type SetToolBindingsType = {
+  /** bindings for the toolGroup's tool when it is set to be active */
+  bindings: IToolBinding[];
+};
+
+type ToolOptionsType = {
+  /** bindings for the toolGroup's tool when it is set to be active */
+  bindings: IToolBinding[];
+  /** mode of the tool */
+  mode: ToolModes;
+};
+
+export { IToolBinding, SetToolBindingsType, ToolOptionsType };

package/src/types/ISynchronizerEventHandler.ts

@@ -0,0 +1,11 @@
+import { Types } from '@cornerstonejs/core';
+import { Synchronizer } from '../store';
+
+export default interface ISynchronizerEventHandler {
+  (
+    synchronizer: Synchronizer,
+    sourceViewport: Types.IViewportId,
+    targetViewport: Types.IViewportId,
+    sourceEvent: any
+  ): void;
+}

package/src/types/IToolClassReference.ts

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

package/src/types/IToolGroup.ts

@@ -0,0 +1,72 @@
+import type { Types } from '@cornerstonejs/core';
+import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
+
+/**
+ * ToolGroup interface
+ */
+export default interface IToolGroup {
+  /** Unserializable instantiated tool classes, keyed by name */
+  _toolInstances: Record<string, any>;
+  /** ToolGroup ID */
+  id: string;
+  /** Viewports Info inside the ToolGroup - including viewportId and renderingEngineId */
+  viewportsInfo: Array<Types.IViewportId>;
+  /** Options for each tool including bindings and mode */
+  toolOptions: Record<string, any>;
+  /** Get viewportIds in the toolGroup*/
+  getViewportIds: () => string[];
+  /** Get viewports info in the toolGroup*/
+  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 };
+  /** 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;
+  };
+  /** Add viewports to share the tools for the ToolGroup */
+  addViewport: {
+    (viewportId: string, renderingEngineId?: string): void;
+  };
+  /** Remove viewports from the ToolGroup */
+  removeViewports: {
+    (renderingEngineId: string, viewportId?: string): void;
+  };
+  /** Setting the tool to be Active by its name*/
+  setToolActive: {
+    (toolName: string, toolBindingsOption?: SetToolBindingsType): void;
+  };
+  /** Setting the tool to be Passive by its name*/
+  setToolPassive: {
+    (toolName: string): void;
+  };
+  /** Setting the tool to be Enabled by its name*/
+  setToolEnabled: {
+    (toolName: string): void;
+  };
+  /** Setting the tool to be Disabled by its name*/
+  setToolDisabled: {
+    (toolName: string): void;
+  };
+  /** Returns the Tool options including tool bindings and tool mode*/
+  getToolOptions: {
+    (toolName: string): ToolOptionsType;
+  };
+  getActivePrimaryMouseButtonTool: {
+    (): undefined | string;
+  };
+  setViewportsCursorByToolName: {
+    (toolName: string, strategyName?: string): void;
+  };
+  setToolConfiguration: {
+    (
+      toolName: string,
+      configuration: Record<any, any>,
+      overwrite?: boolean
+    ): void;
+  };
+  getToolConfiguration: {
+    (toolName: string, configurationPath: string): any;
+  };
+}

package/src/types/ITouchPoints.ts

@@ -0,0 +1,14 @@
+import IPoints from './IPoints';
+
+type ITouchPoints = IPoints & {
+  /** Native Touch object properties which are JSON serializable*/
+  touch: {
+    identifier: string;
+    radiusX: number;
+    radiusY: number;
+    force: number;
+    rotationAngle: number;
+  };
+};
+
+export default ITouchPoints;

package/src/types/InteractionTypes.ts

@@ -0,0 +1,6 @@
+/**
+ * Supported Interactions for tools
+ */
+type InteractionTypes = 'Mouse' | 'Touch';
+
+export default InteractionTypes;

package/src/types/InternalToolTypes.ts

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

package/src/types/JumpToSliceOptions.ts

@@ -0,0 +1,7 @@
+type JumpToSliceOptions = {
+  imageIndex: number;
+  debounceLoading?: boolean;
+  volumeId?: string;
+};
+
+export default JumpToSliceOptions;

package/src/types/LabelmapTypes.ts

@@ -0,0 +1,41 @@
+import type { vtkColorTransferFunction } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import type { vtkPiecewiseFunction } from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+
+/**
+ * Label map config for the label map representation
+ */
+export type LabelmapConfig = {
+  /** whether to render segmentation outline  */
+  renderOutline?: boolean;
+  /** thickness of the outline when segmentation is active */
+  outlineWidthActive?: number;
+  /** thickness of the outline when segmentation is inactive */
+  outlineWidthInactive?: number;
+  /** whether to render segmentation filling */
+  renderFill?: boolean;
+  /** whether to render segmentation filling when inactive */
+  renderFillInactive?: boolean;
+  /** alpha of the fill */
+  fillAlpha?: number;
+  /** alpha of the fill when inactive */
+  fillAlphaInactive?: number;
+  /** alpha of outline for active segmentation */
+  outlineOpacity?: number;
+  /** alpha of outline for inactive segmentation */
+  outlineOpacityInactive?: number;
+};
+
+/**
+ * Labelmap representation type
+ */
+export type LabelmapRenderingConfig = {
+  /** color transfer function */
+  cfun?: vtkColorTransferFunction;
+  /** opacity transfer function */
+  ofun?: vtkPiecewiseFunction;
+};
+
+export type LabelmapSegmentationData = {
+  volumeId: string;
+  referencedVolumeId?: string;
+};

package/src/types/PlanarBoundingBox.ts

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

package/src/types/SVGDrawingHelper.ts

@@ -0,0 +1,10 @@
+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 default SVGDrawingHelper;

package/src/types/ScrollOptions.ts

@@ -0,0 +1,9 @@
+type ScrollOptions = {
+  // can be positive or negative
+  delta: number;
+  volumeId?: string;
+  debounceLoading?: boolean;
+  loop?: boolean;
+};
+
+export default ScrollOptions;

package/src/types/SegmentationStateTypes.ts

@@ -0,0 +1,248 @@
+import * as Enums from '../enums';
+import { ContourConfig, ContourSegmentationData } from './ContourTypes';
+import type {
+  LabelmapConfig,
+  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>;
+
+export type SegmentSpecificRepresentationConfig = {
+  [key: number]: RepresentationConfig;
+};
+/**
+ * Segmentation Config
+ */
+
+export type RepresentationConfig = {
+  /** labelmap configuration */
+  LABELMAP?: LabelmapConfig;
+  /** contour configuration */
+  CONTOUR?: ContourConfig;
+};
+
+export type SegmentationRepresentationConfig = {
+  /** Whether to render Inactive segmentations  */
+  renderInactiveSegmentations: boolean;
+  /** Representations configuration */
+  representations: RepresentationConfig;
+};
+
+export type SegmentationRepresentationData = {
+  LABELMAP?: LabelmapSegmentationData;
+  CONTOUR?: ContourSegmentationData;
+};
+
+/**
+ * Global Segmentation Data which is used for the segmentation
+ */
+export type Segmentation = {
+  /** segmentation id  */
+  segmentationId: string;
+  /** segmentation main representation type */
+  type: Enums.SegmentationRepresentations;
+  /** segmentation label */
+  label: string;
+  /**
+   * Active segment index in the segmentation, this index will get used
+   * inside the segmentation tools
+   */
+  activeSegmentIndex: number;
+  /**
+   * Locked segments in the segmentation, if a segment is locked no tool
+   * will be able to modify it
+   */
+  segmentsLocked: Set<number>;
+  /**
+   * If there is any derived statistics for the segmentation (e.g., mean, volume, etc)
+   */
+  cachedStats: { [key: string]: number };
+  segmentLabels: { [key: string]: string };
+  /**
+   * Representations of the segmentation. Each segmentation "can" be viewed
+   * in various representations. For instance, if a DICOM SEG is loaded, the main
+   * representation is the labelmap. However, for DICOM RT the main representation
+   * is contours, and other representations can be derived from the contour (currently
+   * only labelmap representation is supported)
+   */
+  representationData: SegmentationRepresentationData;
+};
+
+/**
+ * Representation state of the segmentation which is common between all
+ * representations (we don't need to separate these states for each representation)
+ */
+export type ToolGroupSpecificRepresentationState = {
+  /**
+   * Segmentation Representation UID
+   */
+  segmentationRepresentationUID: string;
+  /**
+   * The segmentationId that this representation is derived from
+   */
+  segmentationId: string;
+  /**
+   * The representation type
+   */
+  type: Enums.SegmentationRepresentations;
+  /**
+   * Whether the segmentation is the active (manipulatable) segmentation or not
+   * which means it is inactive
+   */
+  active: boolean;
+  /**
+   * Hidden segment indices in the segmentation
+   */
+  segmentsHidden: Set<number>;
+  /**
+   * The index of the colorLUT from the state that this segmentationData is
+   * using to render
+   */
+  colorLUTIndex: number;
+};
+
+/**
+ * ToolGroup Specific Segmentation Data for segmentations. As one segmentation
+ * can be represented in various ways (currently only labelmap is supported)
+ * we store ToolGroup specific segmentation data in this object
+ */
+export type ToolGroupSpecificLabelmapRepresentation =
+  ToolGroupSpecificRepresentationState & {
+    config: LabelmapRenderingConfig;
+    // Todo: we need to merge all these configs into one to make it easier
+    segmentationRepresentationSpecificConfig?: RepresentationConfig;
+    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+  };
+
+export type ToolGroupSpecificContourRepresentation =
+  ToolGroupSpecificRepresentationState & {
+    config: LabelmapRenderingConfig;
+    segmentationRepresentationSpecificConfig?: RepresentationConfig;
+    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+  };
+
+export type ToolGroupSpecificRepresentation =
+  ToolGroupSpecificLabelmapRepresentation; // | other ones
+
+export type ToolGroupSpecificRepresentations =
+  Array<ToolGroupSpecificRepresentation>;
+
+/**
+ * Segmentation State stored inside the cornerstone3DTools
+ *
+ * ```js
+ *  {
+ *   colorLUT: [],
+ *   globalConfig: {
+ *     renderInactiveSegmentations: false,
+ *     representations: {
+ *       LABELMAP: {
+ *         renderFill: true,
+ *         renderOutline: true,
+ *       },
+ *     },
+ *   },
+ *   segmentations: [
+ *     {
+ *       segmentationId: 'segmentation1',
+ *       mainType: 'Labelmap',
+ *       activeSegmentIndex: 0,
+ *       segmentsLocked: new Set(),
+ *       label: 'segmentation1',
+ *       cachedStats: {},
+ *       representationData: {
+ *         LABELMAP: {
+ *           volumeId: 'segmentation1',
+ *         },
+ *         CONTOUR: {
+ *           geometryIds: ['contourSet1', 'contourSet2'],
+ *         },
+ *       },
+ *     },
+ *     {
+ *       segmentationId: 'segmentation2',
+ *       type: 'Labelmap',
+ *       activeSegmentIndex: 1,
+ *       segmentsLocked: new Set(),
+ *       label: 'segmentation2',
+ *       cachedStats: {},
+ *       representationData: {
+ *         CONTOUR: {
+ *           points: Float32Array,
+ *         },
+ *       },
+ *     },
+ *   ],
+ *   toolGroups: {
+ *     toolGroupUID1: {
+ *       segmentationRepresentations: [
+ *         {
+ *           segmentationRepresentationUID: '12123123123132',
+ *           segmentationId: '123123',
+ *           type: 'Labelmap',
+ *           active: true,
+ *           colorLUTIndex: 0,
+ *           visibility: true,
+ *           segmentsHidden: Set(),
+ *           // LabelmapRenderingConfig
+ *           config: {
+ *             "cfun",
+ *             "ofun",
+ *           },
+ *         },
+ *       ],
+ *       config: {
+ *         renderInactiveSegmentations: false,
+ *         representations: {
+ *           LABELMAP: {
+ *             renderFill: true,
+ *             renderOutline: true,
+ *           },
+ *         },
+ *       },
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export type SegmentationState = {
+  /** Array of colorLUT for segmentation to render */
+  colorLUT: ColorLUT[];
+  /** segmentations */
+  segmentations: Segmentation[];
+  /** global segmentation state with config */
+  globalConfig: SegmentationRepresentationConfig;
+  /**
+   * ToolGroup specific segmentation state with config
+   */
+  toolGroups: {
+    /** toolGroupId and their toolGroup specific segmentation state with config */
+    [key: string]: {
+      segmentationRepresentations: ToolGroupSpecificRepresentations;
+      config: SegmentationRepresentationConfig;
+    };
+  };
+};
+
+export type SegmentationPublicInput = {
+  segmentationId: string;
+  representation: {
+    type: Enums.SegmentationRepresentations;
+    data: LabelmapSegmentationData | ContourSegmentationData;
+  };
+};
+
+export type RepresentationPublicInput = {
+  segmentationId: string;
+  type: Enums.SegmentationRepresentations;
+};

package/src/types/ToolHandle.ts

@@ -0,0 +1,26 @@
+import type { Types } from '@cornerstonejs/core';
+
+/** Handle position in the world coordinates */
+type AnnotationHandle = Types.Point3;
+
+/** TextBox handle type specifying its location
+ * in the world including bottomLeft and topRight
+ * and bottomRight and topLeft points, and its
+ * center world coordinates.
+ */
+type TextBoxHandle = {
+  hasMoved: boolean;
+  worldBoundingBox: {
+    bottomLeft: Types.Point3;
+    bottomRight: Types.Point3;
+    topLeft: Types.Point3;
+    topRight: Types.Point3;
+  };
+  worldPosition: Types.Point3;
+};
+
+/** Tool Handle type can be either AnnotationHandle or TextBoxHandle */
+type ToolHandle = AnnotationHandle | TextBoxHandle;
+
+export default ToolHandle;
+export type { AnnotationHandle, TextBoxHandle };

package/src/types/ToolProps.ts

@@ -0,0 +1,16 @@
+type SharedToolProp = {
+  /** supported interactions for the tool */
+  supportedInteractionTypes?: Array<string>;
+  /** tool specific tool configuration */
+  configuration?: Record<string, any>;
+};
+
+export type ToolProps = SharedToolProp;
+
+/**
+ * Tool specific tool properties which includes the supported interaction types
+ * and the configuration.
+ */
+export type PublicToolProps = SharedToolProp & {
+  name?: string;
+};