@cornerstonejs/tools 0.56.1 → 0.56.3

package/src/tools/segmentation/strategies/fillRectangle.ts

@@ -0,0 +1,110 @@
+import { ImageVolume, utilities as csUtils } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
+import { pointInShapeCallback } from '../../../utilities';
+import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+
+const { transformWorldToIndex } = csUtils;
+
+type OperationData = {
+  segmentationId: string;
+  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+  volume: ImageVolume;
+  constraintFn: (x: [number, number, number]) => boolean;
+  segmentIndex: number;
+  segmentsLocked: number[];
+};
+
+/**
+ * For each point in the bounding box around the rectangle, if the point is inside
+ * the rectangle, set the scalar value to the segmentIndex
+ * @param toolGroupId - string
+ * @param operationData - OperationData
+ * @param constraintFn - can be used to perform threshold segmentation
+ * @param inside - boolean
+ */
+// Todo: why we have another constraintFn? in addition to the one in the operationData?
+function fillRectangle(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData,
+  inside = true
+): void {
+  const {
+    volume: segmentation,
+    points,
+    segmentsLocked,
+    segmentIndex,
+    segmentationId,
+    constraintFn,
+  } = operationData;
+  const { imageData, dimensions } = segmentation;
+  const scalarData = segmentation.getScalarData();
+
+  let rectangleCornersIJK = points.map((world) => {
+    return transformWorldToIndex(imageData, world);
+  });
+
+  // math round
+  rectangleCornersIJK = rectangleCornersIJK.map((point) => {
+    return point.map((coord) => {
+      return Math.round(coord);
+    });
+  });
+
+  const boundsIJK = getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
+
+  if (boundsIJK.every(([min, max]) => min !== max)) {
+    throw new Error('Oblique segmentation tools are not supported yet');
+  }
+
+  // Since always all points inside the boundsIJK is inside the rectangle...
+  const pointInRectangle = () => true;
+
+  const callback = ({ value, index, pointIJK }) => {
+    if (segmentsLocked.includes(value)) {
+      return;
+    }
+
+    if (!constraintFn) {
+      scalarData[index] = segmentIndex;
+      return;
+    }
+
+    if (constraintFn(pointIJK)) {
+      scalarData[index] = segmentIndex;
+    }
+  };
+
+  pointInShapeCallback(imageData, pointInRectangle, callback, boundsIJK);
+
+  triggerSegmentationDataModified(segmentationId);
+}
+
+/**
+ * Fill the inside of a rectangle
+ * @param toolGroupId - The unique identifier of the tool group.
+ * @param operationData - The data that will be used to create the
+ * new rectangle.
+ * @param constraintFn - can be used to perform threshold segmentation
+ */
+export function fillInsideRectangle(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  fillRectangle(enabledElement, operationData, true);
+}
+
+/**
+ * Fill the area outside of a rectangle for the toolGroupId and segmentationRepresentationUID.
+ * @param toolGroupId - The unique identifier of the tool group.
+ * @param operationData - The data that will be used to create the
+ * new rectangle.
+ * @param constraintFn - can be used to perform threshold segmentation
+ */
+export function fillOutsideRectangle(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  fillRectangle(enabledElement, operationData, false);
+}

package/src/tools/segmentation/strategies/fillSphere.ts

@@ -0,0 +1,88 @@
+import type { Types } from '@cornerstonejs/core';
+
+import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { pointInSurroundingSphereCallback } from '../../../utilities';
+
+type OperationData = {
+  points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+  volume: Types.IImageVolume;
+  segmentIndex: number;
+  segmentationId: string;
+  segmentsLocked: number[];
+  viewPlaneNormal: Types.Point3;
+  viewUp: Types.Point3;
+  constraintFn: () => boolean;
+};
+
+function fillSphere(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData,
+  _inside = true
+): void {
+  const { viewport } = enabledElement;
+  const {
+    volume: segmentation,
+    segmentsLocked,
+    segmentIndex,
+    segmentationId,
+    points,
+  } = operationData;
+
+  const { imageData, dimensions } = segmentation;
+  const scalarData = segmentation.getScalarData();
+  const scalarIndex = [];
+
+  const callback = ({ index, value }) => {
+    if (segmentsLocked.includes(value)) {
+      return;
+    }
+    scalarData[index] = segmentIndex;
+    scalarIndex.push(index);
+  };
+
+  pointInSurroundingSphereCallback(
+    imageData,
+    [points[0], points[1]],
+    callback,
+    viewport as Types.IVolumeViewport
+  );
+
+  // Since the scalar indexes start from the top left corner of the cube, the first
+  // slice that needs to be rendered can be calculated from the first mask coordinate
+  // divided by the zMultiple, as well as the last slice for the last coordinate
+  const zMultiple = dimensions[0] * dimensions[1];
+  const minSlice = Math.floor(scalarIndex[0] / zMultiple);
+  const maxSlice = Math.floor(scalarIndex[scalarIndex.length - 1] / zMultiple);
+  const sliceArray = Array.from(
+    { length: maxSlice - minSlice + 1 },
+    (v, k) => k + minSlice
+  );
+
+  triggerSegmentationDataModified(segmentationId, sliceArray);
+}
+
+/**
+ * Fill inside a sphere with the given segment index in the given operation data. The
+ * operation data contains the sphere required points.
+ * @param enabledElement - The element that is enabled and selected.
+ * @param operationData - OperationData
+ */
+export function fillInsideSphere(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  fillSphere(enabledElement, operationData, true);
+}
+
+/**
+ * Fill outside a sphere with the given segment index in the given operation data. The
+ * operation data contains the sphere required points.
+ * @param enabledElement - The element that is enabled and selected.
+ * @param operationData - OperationData
+ */
+export function fillOutsideSphere(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  fillSphere(enabledElement, operationData, false);
+}

package/src/tools/segmentation/strategies/index.ts

@@ -0,0 +1,9 @@
+import { fillInsideRectangle, fillOutsideRectangle } from './fillRectangle';
+import { fillInsideCircle, fillOutsideCircle } from './fillCircle';
+
+export {
+  fillInsideRectangle,
+  fillOutsideRectangle,
+  fillInsideCircle,
+  fillOutsideCircle,
+};

package/src/types/AnnotationGroupSelector.ts

@@ -0,0 +1,7 @@
+/**
+ * AnnotationGroupSelector is a type that can be used to specify the
+ * group of annotations to which an annotation should be added.
+ */
+type AnnotationGroupSelector = HTMLDivElement | string;
+
+export default AnnotationGroupSelector;

package/src/types/AnnotationStyle.ts

@@ -0,0 +1,42 @@
+type Modes = '' | 'Active' | 'Passive' | 'Enabled';
+type States = '' | 'Highlighted' | 'Selected' | 'Locked';
+
+type Properties =
+  | 'color'
+  | 'lineWidth'
+  | 'lineDash'
+  | 'textBoxFontFamily'
+  | 'textBoxFontSize'
+  | 'textBoxColor'
+  | 'textBoxBackground'
+  | 'textBoxLinkLineWidth'
+  | 'textBoxLinkLineDash';
+
+export type AnnotationStyle = {
+  [key in `${Properties}${States}${Modes}`]?: string;
+};
+
+export type ToolStyleConfig = {
+  [toolName: string]: AnnotationStyle;
+  global?: AnnotationStyle;
+};
+
+export type StyleConfig = {
+  annotations?: {
+    [annotationUID: string]: AnnotationStyle;
+  };
+  viewports?: {
+    [viewportId: string]: ToolStyleConfig;
+  };
+  toolGroups?: {
+    [toolGroupId: string]: ToolStyleConfig;
+  };
+  default: ToolStyleConfig;
+};
+
+export type StyleSpecifier = {
+  viewportId?: string;
+  toolGroupId?: string;
+  toolName?: string;
+  annotationUID?: string;
+};

package/src/types/AnnotationTypes.ts

@@ -0,0 +1,109 @@
+import type { Types } from '@cornerstonejs/core';
+
+type Annotation = {
+  /** A unique identifier for this annotation */
+  annotationUID?: string;
+  /** If the annotation is being hovered over and is highlighted */
+  highlighted?: boolean;
+  /** If the annotation is locked for manipulation */
+  isLocked?: boolean;
+  /** If the annotation is visible for manipulation */
+  isVisible?: boolean;
+  /** Has annotation data been invalidated (e.g., as a result of mouse interactions) */
+  invalidated?: boolean;
+  /** Metadata for annotation */
+  metadata: {
+    /**
+     * The position of the camera in world space
+     */
+    cameraPosition?: Types.Point3;
+    /**
+     * The focal point of the camera in world space
+     */
+    cameraFocalPoint?: Types.Point3;
+    /**
+     * The normal on which the tool was drawn
+     */
+    viewPlaneNormal?: Types.Point3;
+    /**
+     * The viewUp on which the tool was drawn.
+     */
+    viewUp?: Types.Point3;
+    /**
+     * The FrameOfReferenceUID
+     */
+    FrameOfReferenceUID: string;
+    /**
+     * The registered name of the tool
+     */
+    toolName: string;
+    /**
+     * An optional property used when annotating on a slice in a StackViewport,
+     * or when annotating in a VolumeViewport on a viewPlane that corresponds to
+     * original slice-based image data.
+     */
+    referencedImageId?: string;
+    /**
+     * VolumeId of the volume that the tool was configured to work on.
+     */
+    volumeId?: string;
+  };
+  /**
+   * Data for annotation, Derivatives need to define their own data types.
+   */
+  data: {
+    /** Annotation handles that are grabbable for manipulation */
+    handles?: {
+      /** world location of the handles in the space */
+      points?: Types.Point3[];
+      /** index of the active handle being manipulated */
+      activeHandleIndex?: number | null;
+      /** annotation text box information */
+      textBox?: {
+        /** whether the text box has moved */
+        hasMoved: boolean;
+        /** the world location of the text box */
+        worldPosition: Types.Point3;
+        /** text box bounding box information */
+        worldBoundingBox: {
+          /** Top left location of the text box in the world space */
+          topLeft: Types.Point3;
+          /** Top right location of the text box in the world space */
+          topRight: Types.Point3;
+          /** Bottom left location of the text box in the world space */
+          bottomLeft: Types.Point3;
+          /** Bottom right location of the text box in the world space */
+          bottomRight: Types.Point3;
+        };
+      };
+      [key: string]: any;
+    };
+    [key: string]: any;
+    /** Cached Annotation statistics which is specific to the tool */
+    cachedStats?: unknown;
+  };
+};
+
+/** Array of annotations */
+type Annotations = Array<Annotation>;
+
+type GroupSpecificAnnotations = {
+  /** Each tool annotations */
+  [toolName: string]: Annotations;
+};
+
+/**
+ * All frame of reference specific annotations for all tools.
+ */
+type AnnotationState = {
+  /**
+   * A string representing the key that can be used
+   * to retrieve the key-specific annotations. For instance, our default
+   * annotation state key is the FrameOfReferenceUID which is for our default
+   * frameOfReferenceAnnotationManager. You can write your own annotation manager
+   * that works for a different use case and use a different key.
+   */
+  [key: string]: GroupSpecificAnnotations;
+};
+
+export { Annotation, Annotations, GroupSpecificAnnotations, AnnotationState };

package/src/types/BoundsIJK.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+
+type BoundsIJK = [Types.Point2, Types.Point2, Types.Point2];
+
+export default BoundsIJK;

package/src/types/CINETypes.ts

@@ -0,0 +1,32 @@
+import { Types } from '@cornerstonejs/core';
+
+type PlayClipOptions = {
+  framesPerSecond?: number;
+  frameTimeVector?: number[];
+  reverse?: boolean;
+  loop?: boolean;
+  dynamicCineEnabled?: boolean;
+  frameTimeVectorSpeedMultiplier?: number;
+};
+
+interface ToolData {
+  intervalId: number | undefined;
+  framesPerSecond: number;
+  lastFrameTimeStamp: number | undefined;
+  frameTimeVector: number[] | undefined;
+  ignoreFrameTimeVector: boolean;
+  usingFrameTimeVector: boolean;
+  speed: number;
+  reverse: boolean;
+  loop: boolean;
+  dynamicCineEnabled?: boolean;
+}
+
+type CinePlayContext = {
+  get numScrollSteps(): number;
+  get currentStepIndex(): number;
+  get frameTimeVectorEnabled(): boolean;
+  scroll(delta: number): void;
+};
+
+export type { PlayClipOptions, ToolData, CinePlayContext };

package/src/types/ContourTypes.ts

@@ -0,0 +1,26 @@
+/**
+ * Label map config for the label map representation
+ */
+export type ContourConfig = {
+  /** thickness of the outline when segmentation is active */
+  outlineWidthActive?: number;
+  /** thickness of the outline when segmentation is inactive */
+  outlineWidthInactive?: number;
+  /** alpha of outline for active segmentation */
+  outlineOpacity?: number;
+  /** alpha of outline for inactive segmentation */
+  outlineOpacityInactive?: number;
+};
+
+/**
+ * Labelmap representation type
+ */
+export type ContourRenderingConfig = {
+  // not much here yet
+};
+
+export type ContourSegmentationData = {
+  // Ids of the contourSets that are part of this segmentation
+  // in the cache
+  geometryIds: string[];
+};

package/src/types/CursorTypes.ts

@@ -0,0 +1,12 @@
+export type SVGPoint = {
+  x: number;
+  y: number;
+};
+
+export type SVGCursorDescriptor = {
+  iconContent: string;
+  iconSize: number;
+  viewBox: SVGPoint;
+  mousePoint: SVGPoint;
+  mousePointerGroupString: string;
+};