@cornerstonejs/tools 0.56.2 → 0.56.3

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -0,0 +1,311 @@
+import type { Types } from '@cornerstonejs/core';
+import { Annotation } from './AnnotationTypes';
+
+interface ROICachedStats {
+  [targetId: string]: {
+    Modality: string;
+    area: number;
+    areaUnit: string;
+    max: number;
+    mean: number;
+    stdDev: number;
+  };
+}
+
+export interface RectangleROIAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats?:
+      | ROICachedStats
+      | {
+          projectionPoints?: Types.Point3[];
+          projectionPointsImageIds?: string[];
+        };
+  };
+}
+
+export interface ProbeAnnotation extends Annotation {
+  data: {
+    handles: { points: Types.Point3[] };
+    cachedStats: {
+      [targetId: string]: {
+        Modality: string;
+        index: Types.Point3;
+        value: number;
+      };
+    };
+    label: string;
+  };
+}
+
+export interface LengthAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats: {
+      [targetId: string]: {
+        length: number;
+        unit: string;
+      };
+    };
+  };
+}
+
+export interface CircleROIAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: [Types.Point3, Types.Point3]; // [center, end]
+      activeHandleIndex: number | null;
+      textBox?: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats?: ROICachedStats & {
+      [targetId: string]: {
+        radius: number;
+        radiusUnit: string;
+        perimeter: number;
+      };
+    };
+  };
+}
+
+export interface EllipticalROIAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3]; // [bottom, top, left, right]
+      activeHandleIndex: number | null;
+      textBox?: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats?: ROICachedStats;
+    initialRotation: number;
+  };
+}
+
+export interface BidirectionalAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats: {
+      [targetId: string]: {
+        length: number;
+        width: number;
+        unit: string;
+      };
+    };
+  };
+}
+
+export interface RectangleROIThresholdAnnotation extends Annotation {
+  metadata: {
+    cameraPosition?: Types.Point3;
+    cameraFocalPoint?: Types.Point3;
+    viewPlaneNormal?: Types.Point3;
+    viewUp?: Types.Point3;
+    annotationUID?: string;
+    FrameOfReferenceUID: string;
+    referencedImageId?: string;
+    toolName: string;
+    enabledElement: Types.IEnabledElement; // Todo: how to remove this from the annotation??
+    volumeId: string;
+  };
+  data: {
+    label: string;
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+    };
+  };
+}
+
+export interface RectangleROIStartEndThresholdAnnotation extends Annotation {
+  metadata: {
+    cameraPosition?: Types.Point3;
+    cameraFocalPoint?: Types.Point3;
+    viewPlaneNormal?: Types.Point3;
+    viewUp?: Types.Point3;
+    annotationUID?: string;
+    FrameOfReferenceUID: string;
+    referencedImageId?: string;
+    toolName: string;
+    enabledElement: any; // Todo: how to remove this from the annotation??
+    volumeId: string;
+    spacingInNormal: number;
+  };
+  data: {
+    label: string;
+    startSlice: number;
+    endSlice: number;
+    cachedStats: {
+      projectionPoints: Types.Point3[][]; // first slice p1, p2, p3, p4; second slice p1, p2, p3, p4 ...
+      projectionPointsImageIds: string[];
+    };
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+    };
+  };
+}
+
+export interface PlanarFreehandROIAnnotation extends Annotation {
+  metadata: {
+    cameraPosition?: Types.Point3;
+    cameraFocalPoint?: Types.Point3;
+    viewPlaneNormal?: Types.Point3;
+    viewUp?: Types.Point3;
+    annotationUID?: string;
+    FrameOfReferenceUID: string;
+    referencedImageId?: string;
+    toolName: string;
+  };
+  data: {
+    polyline: Types.Point3[];
+    label?: string;
+    isOpenContour?: boolean;
+    isOpenUShapeContour?: boolean;
+    // Present if isOpenUShapeContour is true:
+    openUShapeContourVectorToPeak?: Types.Point3[];
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+  };
+}
+
+export interface ArrowAnnotation extends Annotation {
+  data: {
+    text: string;
+    handles: {
+      points: Types.Point3[];
+      arrowFirst: boolean;
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+  };
+}
+export interface AngleAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats: {
+      [targetId: string]: {
+        angle: number;
+      };
+    };
+  };
+}
+
+export interface ReferenceCursor extends Annotation {
+  data: {
+    handles: {
+      points: [Types.Point3];
+    };
+  };
+}
+
+export interface ReferenceLineAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+    };
+  };
+}
+
+export interface ScaleOverlayAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+    };
+    viewportId: string;
+  };
+}

package/src/types/index.ts

@@ -0,0 +1,115 @@
+import type {
+  Annotation,
+  Annotations,
+  AnnotationState,
+  GroupSpecificAnnotations,
+} from './AnnotationTypes';
+import type * as EventTypes from './EventTypes';
+import type * as LabelmapTypes from './LabelmapTypes';
+import type IPoints from './IPoints';
+import type ITouchPoints from './ITouchPoints';
+import type IDistance from './IDistance';
+import type PlanarBoundingBox from './PlanarBoundingBox';
+import type {
+  SetToolBindingsType,
+  IToolBinding,
+  ToolOptionsType,
+} from './ISetToolModeOptions';
+import type IToolGroup from './IToolGroup';
+import type * as ToolSpecificAnnotationTypes from './ToolSpecificAnnotationTypes';
+import type * as AnnotationStyle from './AnnotationStyle';
+import type ToolHandle from './ToolHandle';
+import type { AnnotationHandle, TextBoxHandle } from './ToolHandle';
+import type InteractionTypes from './InteractionTypes';
+import type { ToolProps, PublicToolProps } from './ToolProps';
+import type { SVGCursorDescriptor, SVGPoint } from './CursorTypes';
+import type JumpToSliceOptions from './JumpToSliceOptions';
+import type ScrollOptions from './ScrollOptions';
+import type BoundsIJK from './BoundsIJK';
+import type SVGDrawingHelper from './SVGDrawingHelper';
+import type * as CINETypes from './CINETypes';
+import type {
+  Color,
+  ColorLUT,
+  RepresentationConfig,
+  SegmentationRepresentationConfig,
+  SegmentationRepresentationData,
+  Segmentation,
+  ToolGroupSpecificRepresentationState,
+  ToolGroupSpecificLabelmapRepresentation,
+  ToolGroupSpecificRepresentation,
+  SegmentationState,
+  RepresentationPublicInput,
+} from './SegmentationStateTypes';
+import ISynchronizerEventHandler from './ISynchronizerEventHandler';
+import {
+  FloodFillGetter,
+  FloodFillOptions,
+  FloodFillResult,
+} from './FloodFillTypes';
+import IToolClassReference from './IToolClassReference';
+import { ContourSegmentationData } from './ContourTypes';
+import IAnnotationManager from './IAnnotationManager';
+import AnnotationGroupSelector from './AnnotationGroupSelector';
+
+export type {
+  // AnnotationState
+  Annotation,
+  Annotations,
+  IAnnotationManager,
+  GroupSpecificAnnotations,
+  AnnotationState,
+  AnnotationStyle,
+  ToolSpecificAnnotationTypes,
+  JumpToSliceOptions,
+  AnnotationGroupSelector,
+  // Geometry
+  PlanarBoundingBox,
+  ToolProps,
+  PublicToolProps,
+  // Event data
+  EventTypes,
+  IPoints,
+  ITouchPoints,
+  IDistance,
+  // ToolBindings
+  IToolBinding,
+  SetToolBindingsType,
+  ToolOptionsType,
+  InteractionTypes,
+  //
+  IToolGroup,
+  IToolClassReference,
+  ISynchronizerEventHandler,
+  ToolHandle,
+  AnnotationHandle,
+  TextBoxHandle,
+  // Segmentation
+  Segmentation,
+  SegmentationState,
+  SegmentationRepresentationData,
+  SegmentationRepresentationConfig,
+  RepresentationConfig,
+  ToolGroupSpecificRepresentationState,
+  ToolGroupSpecificLabelmapRepresentation,
+  ToolGroupSpecificRepresentation,
+  RepresentationPublicInput,
+  Color,
+  ColorLUT,
+  LabelmapTypes,
+  // Cursors
+  SVGCursorDescriptor,
+  SVGPoint,
+  // Scroll
+  ScrollOptions,
+  // CINE
+  CINETypes,
+  BoundsIJK,
+  SVGDrawingHelper,
+  // FloodFill
+  FloodFillResult,
+  FloodFillGetter,
+  FloodFillOptions,
+  // Contour
+  ContourSegmentationData,
+};

package/src/utilities/boundingBox/extend2DBoundingBoxInViewAxis.ts

@@ -0,0 +1,29 @@
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Uses the current bounds of the 2D rectangle and extends it in the view axis by numSlices
+ * It compares min and max of each IJK to find the view axis (for axial, zMin === zMax) and
+ * then calculates the extended range. It will assume the slice is relative to the
+ * current slice and will add the given slices to the current max of the boundingBox.
+ * @param boundsIJK - [[iMin, iMax], [jMin, jMax], [kMin, kMax]]
+ * @param slices - number of slices to project before and after
+ * @returns extended bounds
+ */
+function extend2DBoundingBoxInViewAxis(
+  boundsIJK: [Types.Point2, Types.Point2, Types.Point2],
+  numSlicesToProject: number
+): [Types.Point2, Types.Point2, Types.Point2] {
+  // find which index in boundsIJK has the same first and last value
+  const sliceNormalIndex = boundsIJK.findIndex(([min, max]) => min === max);
+
+  if (sliceNormalIndex === -1) {
+    throw new Error('3D bounding boxes not supported in an oblique plane');
+  }
+
+  // get the index and subtract slices from the min and add to the max
+  boundsIJK[sliceNormalIndex][0] -= numSlicesToProject;
+  boundsIJK[sliceNormalIndex][1] += numSlicesToProject;
+  return boundsIJK;
+}
+
+export default extend2DBoundingBoxInViewAxis;

package/src/utilities/boundingBox/getBoundingBoxAroundShape.ts

@@ -0,0 +1,57 @@
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * With a given vertices (points) coordinates in IJK, it calculates the minimum and maximum
+ * coordinate in each axis, and returns them. If dimensions are provided it also
+ * clip the min, max to the provided width, height and depth
+ *
+ * @param points - shape corner points coordinates (IJK)
+ * @param dimensions - dimensions of the image
+ * @returns [[xMin,xMax],[yMin,yMax], [zMin,zMax]]
+ */
+function getBoundingBoxAroundShape(
+  points: Types.Point3[],
+  dimensions?: Types.Point3
+): [Types.Point2, Types.Point2, Types.Point2] {
+  let xMin = Infinity;
+  let xMax = 0;
+  let yMin = Infinity;
+  let yMax = 0;
+  let zMin = Infinity;
+  let zMax = 0;
+
+  points.forEach((p) => {
+    xMin = Math.min(p[0], xMin);
+    xMax = Math.max(p[0], xMax);
+    yMin = Math.min(p[1], yMin);
+    yMax = Math.max(p[1], yMax);
+    zMin = Math.min(p[2], zMin);
+    zMax = Math.max(p[2], zMax);
+  });
+
+  xMin = Math.floor(xMin);
+  xMax = Math.floor(xMax);
+  yMin = Math.floor(yMin);
+  yMax = Math.floor(yMax);
+  zMin = Math.floor(zMin);
+  zMax = Math.floor(zMax);
+
+  if (dimensions) {
+    // clip the min, max to the provided width, height and depth
+    const [width, height, depth] = dimensions;
+    xMin = Math.max(0, xMin);
+    xMax = Math.min(width - 1, xMax);
+    yMin = Math.max(0, yMin);
+    yMax = Math.min(height - 1, yMax);
+    zMin = Math.max(0, zMin);
+    zMax = Math.min(depth - 1, zMax);
+  }
+
+  return [
+    [xMin, xMax],
+    [yMin, yMax],
+    [zMin, zMax],
+  ];
+}
+
+export default getBoundingBoxAroundShape;

package/src/utilities/boundingBox/index.ts

@@ -0,0 +1,4 @@
+import extend2DBoundingBoxInViewAxis from './extend2DBoundingBoxInViewAxis';
+import getBoundingBoxAroundShape from './getBoundingBoxAroundShape';
+
+export { extend2DBoundingBoxInViewAxis, getBoundingBoxAroundShape };

package/src/utilities/calibrateImageSpacing.ts

@@ -0,0 +1,46 @@
+import { utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+const { calibratedPixelSpacingMetadataProvider } = utilities;
+
+/**
+ * It adds the provided spacing to the Cornerstone internal calibratedPixelSpacing
+ * metadata provider, then it invalidates all the tools that have the imageId as
+ * their reference imageIds. Finally, it triggers a re-render for invalidated annotations.
+ * @param imageId - ImageId for the calibrated image
+ * @param rowPixelSpacing - Spacing in row direction
+ * @param columnPixelSpacing - Spacing in column direction
+ * @param renderingEngine - Cornerstone RenderingEngine instance
+ */
+export default function calibrateImageSpacing(
+  imageId: string,
+  renderingEngine: Types.IRenderingEngine,
+  rowPixelSpacing: number,
+  columnPixelSpacing: number
+): void {
+  // 1. Add the calibratedPixelSpacing metadata to the metadata provider
+  // If no column spacing provided, assume square pixels
+  if (!columnPixelSpacing) {
+    columnPixelSpacing = rowPixelSpacing;
+  }
+
+  calibratedPixelSpacingMetadataProvider.add(imageId, [
+    rowPixelSpacing,
+    columnPixelSpacing,
+  ]);
+
+  // 2. Update the actor for stackViewports
+  const viewports = renderingEngine.getStackViewports();
+
+  // 2.1 If imageId is already being used in a stackViewport -> update actor
+  viewports.forEach((viewport) => {
+    const imageIds = viewport.getImageIds();
+    if (imageIds.includes(imageId)) {
+      viewport.calibrateSpacing(imageId);
+    }
+  });
+
+  // 2.2 If imageId is cached but not being displayed in a viewport, stackViewport
+  // will handle using the calibratedPixelSpacing since it has been added
+  // to the provider
+}

package/src/utilities/cine/events.ts

@@ -0,0 +1,9 @@
+/**
+ * CINE Tool Events
+ */
+enum Events {
+  CLIP_STOPPED = 'CORNERSTONE_CINE_TOOL_STOPPED',
+  CLIP_STARTED = 'CORNERSTONE_CINE_TOOL_STARTED',
+}
+
+export default Events;

package/src/utilities/cine/index.ts

@@ -0,0 +1,5 @@
+import { playClip, stopClip } from './playClip';
+import Events from './events';
+import { getToolState, addToolState } from './state';
+
+export { playClip, stopClip, Events, getToolState, addToolState };