@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/src/types/FloodFillTypes.ts

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

package/src/types/IAnnotationManager.ts

@@ -1,89 +0,0 @@
-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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

package/src/types/IToolClassReference.ts

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

package/src/types/IToolGroup.ts

@@ -1,85 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
-import { MouseBindings } from '../enums';
-import { ToolConfiguration } from '../types';
-/**
- * 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 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;
-  };
-  /** 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: ToolConfiguration,
-      overwrite?: boolean
-    ): void;
-  };
-  getToolConfiguration: {
-    (toolName: string, configurationPath: string): any;
-  };
-  getDefaultMousePrimary: {
-    (): MouseBindings;
-  };
-
-  clone: {
-    (
-      newToolGroupId: string,
-      fnToolFilter: (toolName: string) => boolean
-    ): IToolGroup;
-  };
-}

package/src/types/ITouchPoints.ts

@@ -1,14 +0,0 @@
-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

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

package/src/types/InternalToolTypes.ts

@@ -1,19 +0,0 @@
-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

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

package/src/types/LabelmapTypes.ts

@@ -1,41 +0,0 @@
-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

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

package/src/types/SVGDrawingHelper.ts

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

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

package/src/types/SegmentationStateTypes.ts

@@ -1,262 +0,0 @@
-import * as Enums from '../enums';
-import {
-  ContourConfig,
-  ContourRenderingConfig,
-  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 | string]: RepresentationConfig;
-};
-
-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: ContourRenderingConfig;
-    segmentationRepresentationSpecificConfig?: RepresentationConfig;
-    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
-  };
-
-export type ToolGroupSpecificRepresentation =
-  | ToolGroupSpecificLabelmapRepresentation
-  | ToolGroupSpecificContourRepresentation;
-
-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(),
- *           // rendering config
- *           config: {
- *             "cfun",
- *             "ofun",
- *           },
- *           // segmentation representation specific config, has priority over the one in the outer scope
- *           segmentationRepresentationSpecificConfig: {
- *             LABELMAP: {
- *               renderFill: true,
- *             }
- *           }
- *           // segment specific config
- *           segmentSpecificConfig: {
- *             1: {
- *              renderFill: false,
- *              }
- *           },
- *         },
- *       ],
- *       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;
-};