@cornerstonejs/core 0.36.3 → 0.36.4

package/src/types/IVolumeInput.ts

@@ -0,0 +1,36 @@
+import { VolumeActor } from './IActor';
+import BlendModes from '../enums/BlendModes';
+
+/**
+ * Volume input callback type, used to perform operations on the volume data
+ * after it has been loaded.
+ */
+type VolumeInputCallback = (params: {
+  /** vtk volume actor */
+  volumeActor: VolumeActor;
+  /** unique volume Id in the cache */
+  volumeId: string;
+}) => unknown;
+
+/**
+ * VolumeInput that can be used to add a volume to a viewport. It includes
+ * mandatory `volumeId` but other options such as `visibility`, `blendMode`,
+ * `slabThickness` and `callback` can also be provided
+ */
+interface IVolumeInput {
+  /** Volume ID of the volume in the cache */
+  volumeId: string;
+  // actorUID for segmentations, since two segmentations with the same volumeId
+  // can have different representations
+  actorUID?: string;
+  /** Visibility of the volume - by default it is true */
+  visibility?: boolean;
+  /** Callback to be called when the volume is added to the viewport */
+  callback?: VolumeInputCallback;
+  /** Blend mode of the volume - by default it is `additive` */
+  blendMode?: BlendModes;
+  /** Slab thickness of the volume - by default it is 0.05*/
+  slabThickness?: number;
+}
+
+export type { IVolumeInput, VolumeInputCallback };

package/src/types/IVolumeViewport.ts

@@ -0,0 +1,141 @@
+import Point2 from './Point2';
+import Point3 from './Point3';
+import { IViewport } from './IViewport';
+import { IVolumeInput } from './IVolumeInput';
+import FlipDirection from './FlipDirection';
+import IImageData from './IImageData';
+import { BlendModes, OrientationAxis } from '../enums';
+import { VolumeViewportProperties } from '.';
+
+/**
+ * Interface for the Volume Viewport
+ */
+export default interface IVolumeViewport extends IViewport {
+  useCPURendering: boolean;
+  getFrameOfReferenceUID: () => string;
+  /**
+   * Retrieve the viewport properties
+   */
+  getProperties: () => VolumeViewportProperties;
+  /**
+   * canvasToWorld Returns the world coordinates of the given `canvasPos`
+   * projected onto the plane defined by the `Viewport`'s `vtkCamera`'s focal point
+   * and the direction of projection.
+   */
+  canvasToWorld: (canvasPos: Point2) => Point3;
+  /**
+   * Returns the canvas coordinates of the given `worldPos`
+   * projected onto the `Viewport`'s `canvas`.
+   */
+  worldToCanvas: (worldPos: Point3) => Point2;
+  /**
+   * Uses viewport camera and volume actor to decide if the viewport
+   * is looking at the volume in the direction of acquisition (imageIds).
+   * If so, it uses the origin and focalPoint to calculate the slice index.
+   */
+  getCurrentImageIdIndex: () => number;
+
+  /**
+   * Checks if the viewport has a volume actor with the given volumeId
+   */
+  hasVolumeId: (volumeId: string) => boolean;
+
+  /**
+   * if the volume viewport has imageURI (no loader schema)
+   * in one of its volume actors
+   */
+  hasImageURI: (imageURI: string) => boolean;
+
+  /**
+   * Uses viewport camera and volume actor to decide if the viewport
+   * is looking at the volume in the direction of acquisition (imageIds).
+   * If so, it uses the origin and focalPoint to find which imageId is
+   * currently being viewed.
+   */
+  getCurrentImageId: () => string;
+  /**
+   * Sets the properties for the viewport. If no volumeId is provided
+   * it applies the properties to the default volume actor (first volume)
+   */
+  setProperties(
+    { voiRange }: VolumeViewportProperties,
+    volumeId?: string,
+    suppressEvents?: boolean
+  ): void;
+  /**
+   * Creates volume actors for all volumes defined in the `volumeInputArray`.
+   * For each entry, if a `callback` is supplied, it will be called with the new volume actor as input.
+   * For each entry, if a `blendMode` and/or `slabThickness` is defined, this will be set on the actor's
+   * `VolumeMapper`.
+   */
+  setVolumes(
+    volumeInputArray: Array<IVolumeInput>,
+    immediate?: boolean,
+    suppressEvents?: boolean
+  ): Promise<void>;
+  /**
+   * Creates and adds volume actors for all volumes defined in the `volumeInputArray`.
+   * For each entry, if a `callback` is supplied, it will be called with the new volume actor as input.
+   */
+  addVolumes(
+    volumeInputArray: Array<IVolumeInput>,
+    immediate?: boolean,
+    suppressEvents?: boolean
+  ): Promise<void>;
+  /**
+   * It removes the volume actor from the Viewport. If the volume actor is not in
+   * the viewport, it does nothing.
+   */
+  removeVolumeActors(actorUIDs: Array<string>, immediate?: boolean): void;
+
+  /**
+   * Given a point in world coordinates, return the intensity at that point
+   */
+  getIntensityFromWorld(point: Point3): number;
+  /**
+   * getBounds gets the visible bounds of the viewport
+   */
+  getBounds(): any;
+  /**
+   * Flip the viewport along the desired axis
+   */
+  flip(flipDirection: FlipDirection): void;
+  /**
+   * Reset the camera for the volume viewport
+   */
+  resetCamera(
+    resetPan?: boolean,
+    resetZoom?: boolean,
+    resetToCenter?: boolean
+  ): boolean;
+  /**
+   * Sets the blendMode for actors of the viewport.
+   */
+  setBlendMode(
+    blendMode: BlendModes,
+    filterActorUIDs?: Array<string>,
+    immediate?: boolean
+  ): void;
+  /**
+   * Sets the slab thickness for actors of the viewport.
+   */
+  setSlabThickness(
+    slabThickness: number,
+    filterActorUIDs?: Array<string>
+  ): void;
+  /**
+   * Gets the slab thickness option in the `Viewport`'s `options`.
+   */
+  getSlabThickness(): number;
+  /**
+   * Returns the image and its properties that is being shown inside the
+   * stack viewport. It returns, the image dimensions, image direction,
+   * image scalar data, vtkImageData object, metadata, and scaling (e.g., PET suvbw)
+   * Note: since the volume viewport supports fusion, to get the
+   * image data for a specific volume, use the optional volumeId
+   * argument.
+   */
+  getImageData(volumeId?: string): IImageData | undefined;
+
+  setOrientation(orientation: OrientationAxis): void;
+}

package/src/types/ImageLoaderFn.ts

@@ -0,0 +1,16 @@
+/**
+ * Any imageLoader function should implement a loading given the imageId
+ * and returns a mandatory promise which will resolve to the loaded image object.
+ * Additional `cancelFn` and `decache` can be implemented.
+ */
+type ImageLoaderFn = (
+  imageId: string,
+  options?: Record<string, any>
+) => {
+  /** Promise that resolves to the image object */
+  promise: Promise<Record<string, any>>;
+  cancelFn?: () => void | undefined;
+  decache?: () => void | undefined;
+};
+
+export default ImageLoaderFn;

package/src/types/ImageSliceData.ts

@@ -0,0 +1,6 @@
+type ImageSliceData = {
+  numberOfSlices: number;
+  imageIndex: number;
+};
+
+export default ImageSliceData;

package/src/types/Mat3.ts

@@ -0,0 +1,16 @@
+/**
+ * This represents a 3x3 matrix of numbers
+ */
+type Mat3 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number
+];
+
+export default Mat3;

package/src/types/Metadata.ts

@@ -0,0 +1,39 @@
+import type { VOI } from './voi';
+
+/**
+ * Metadata for images, More information can be found in the
+ * {@link https://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html#table_C.7-11c}
+ */
+type Metadata = {
+  /** Number of bits allocated for each pixel sample. Each sample shall have the same number of bits allocated */
+  BitsAllocated: number;
+  /** Number of bits stored for each pixel sample */
+  BitsStored: number;
+  SamplesPerPixel: number;
+  /** Most significant bit for pixel sample data */
+  HighBit: number;
+  /** Specifies the intended interpretation of the pixel data */
+  PhotometricInterpretation: string;
+  /** Data representation of the pixel samples. */
+  PixelRepresentation: number;
+  /** Image Modality */
+  Modality: string;
+  /** SeriesInstanceUID of the volume */
+  SeriesInstanceUID?: string;
+  /** The direction cosines of the first row and the first column with respect to the patient */
+  ImageOrientationPatient: Array<number>;
+  /** Physical distance in the patient between the center of each pixel */
+  PixelSpacing: Array<number>;
+  /** Uniquely identifies the Frame of Reference for a Series */
+  FrameOfReferenceUID: string;
+  /** Number of columns in the image. */
+  Columns: number;
+  /** Number of rows in the image. */
+  Rows: number;
+  /** Window Level/Center for the image */
+  voiLut: Array<VOI>;
+  /** VOILUTFunction for the image which is LINEAR or SAMPLED_SIGMOID */
+  VOILUTFunction: string;
+};
+
+export default Metadata;

package/src/types/OrientationVectors.ts

@@ -0,0 +1,36 @@
+import { Point3 } from '../types';
+
+/**
+ * - `viewUp` - An array of three floating point numbers describing a vector
+ *  that represents the up direction for the view.
+ * - `viewPlaneNormal` - The direction of the projection
+ *
+ * see [Axial vs Sagittal vs Coronal](https://faculty.washington.edu/chudler/slice.html)
+ * see {@link https://kitware.github.io/vtk-js/api/Rendering_Core_Camera.html | VTK.js: Rendering_Core_Camera}
+ *
+ * @example
+ *
+ * ```javascript
+ * renderingEngine.setViewports([
+ *  {
+ *    viewportId: 'a-viewport-uid',
+ *    type: ViewportType.ORTHOGRAPHIC,
+ *    element: document.querySelector('div'),
+ *    defaultOptions: {
+ *      orientation: {
+ *       viewUp: [0, 0, 1],
+ *      viewPlaneNormal: [1, 0, 0],
+ *     },
+ *      background: [1, 0, 0],
+ *    },
+ *  }]);
+ * ```
+ */
+type OrientationVectors = {
+  /** Slice Normal for the viewport - the normal that points in the opposite direction of the slice normal out of screen and is negative of direction of projection */
+  viewPlaneNormal: Point3;
+  /** viewUp direction for the viewport - the vector that points from bottom to top of the viewport */
+  viewUp: Point3;
+};
+
+export default OrientationVectors;

package/src/types/Plane.ts

@@ -0,0 +1,6 @@
+/**
+ * Plane equation Ax+By+Cz=D, plane is defined by [A, B, C, D]
+ */
+type Plane = [number, number, number, number];
+
+export default Plane;

package/src/types/Point2.ts

@@ -0,0 +1,6 @@
+/**
+ * This duplicates the typing established in gl-matrix for a vec2
+ */
+type Point2 = [number, number];
+
+export default Point2;

package/src/types/Point3.ts

@@ -0,0 +1,6 @@
+/**
+ * This duplicates the typing established in gl-matrix for a vec3
+ */
+type Point3 = [number, number, number];
+
+export default Point3;

package/src/types/Point4.ts

@@ -0,0 +1,6 @@
+/**
+ * This represents a 4-vector or RGBA value.
+ */
+type Point4 = [number, number, number, number];
+
+export default Point4;

package/src/types/ScalingParameters.ts

@@ -0,0 +1,27 @@
+type ScalingParameters = {
+  /** m in m*p+b which specifies the linear transformation from stored pixels to memory value  */
+  rescaleSlope: number;
+  /** b in m*p+b which specifies the offset of the transformation */
+  rescaleIntercept: number;
+  /** modality */
+  modality: string;
+  /** SUV body weight */
+  suvbw?: number;
+  /** SUV lean body mass */
+  suvlbm?: number;
+  /** SUV body surface area */
+  suvbsa?: number;
+};
+
+type PTScaling = {
+  /** suv body weight to suv lean body mass */
+  suvbwToSuvlbm?: number;
+  /** suv body weight to suv body surface area */
+  suvbwToSuvbsa?: number;
+};
+
+type Scaling = {
+  PET?: PTScaling;
+};
+
+export { PTScaling, Scaling, ScalingParameters };

package/src/types/StackViewportProperties.ts

@@ -0,0 +1,25 @@
+import InterpolationType from '../enums/InterpolationType';
+import VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import { VOIRange } from './voi';
+
+/**
+ * Stack Viewport Properties
+ */
+type StackViewportProperties = {
+  /** voi range (upper, lower) for the viewport */
+  voiRange?: VOIRange;
+  /** VOILUTFunction type which is LINEAR or SAMPLED_SIGMOID */
+  VOILUTFunction?: VOILUTFunctionType;
+  /** invert flag - whether the image is inverted */
+  invert?: boolean;
+  /** interpolation type - linear or nearest neighbor */
+  interpolationType?: InterpolationType;
+  /** image rotation */
+  rotation?: number;
+  /** suppress events (optional) */
+  suppressEvents?: boolean;
+  /** Indicates if the voi is a computed VOI (not user set) */
+  isComputedVOI?: boolean;
+};
+
+export default StackViewportProperties;

package/src/types/TransformMatrix2D.ts

@@ -0,0 +1,4 @@
+/** used for CPU rendering */
+type TransformMatrix2D = [number, number, number, number, number, number];
+
+export default TransformMatrix2D;

package/src/types/ViewportInputOptions.ts

@@ -0,0 +1,21 @@
+import { OrientationAxis } from '../enums';
+import OrientationVectors from './OrientationVectors';
+
+/**
+ * This type defines the shape of viewport input options, so we can throw when it is incorrect.
+ */
+type ViewportInputOptions = {
+  /** background color */
+  background?: [number, number, number];
+  /** orientation of the viewport which can be either an Enum for axis Enums.OrientationAxis.[AXIAL|SAGITTAL|CORONAL|DEFAULT] or an object with viewPlaneNormal and viewUp */
+  orientation?: OrientationAxis | OrientationVectors;
+  /** whether the events should be suppressed and not fired*/
+  suppressEvents?: boolean;
+  /**
+   * parallel projection settings, Note that this will only be used for VOLUME_3D viewport. You can't modify the
+   * parallel projection of a stack viewport or volume viewport using viewport input options.
+   */
+  parallelProjection?: boolean;
+};
+
+export default ViewportInputOptions;

package/src/types/ViewportPreset.ts

@@ -0,0 +1,14 @@
+interface ViewportPreset {
+  name: string;
+  gradientOpacity: string;
+  specularPower: string;
+  scalarOpacity: string;
+  specular: string;
+  shade: string;
+  ambient: string;
+  colorTransfer: string;
+  diffuse: string;
+  interpolation: string;
+}
+
+export default ViewportPreset;

package/src/types/VolumeLoaderFn.ts

@@ -0,0 +1,18 @@
+/**
+ * Any volumeLoader function should implement a loading given the volumeId
+ * and returns a mandatory promise which will resolve to the loaded volume object.
+ * Additional `cancelFn` and `decache` can be implemented.
+ */
+type VolumeLoaderFn = (
+  volumeId: string,
+  options?: Record<string, any>
+) => {
+  /** promise that resolves to the volume object */
+  promise: Promise<Record<string, any>>;
+  /** cancel function */
+  cancelFn?: () => void | undefined;
+  /** decache function */
+  decache?: () => void | undefined;
+};
+
+export default VolumeLoaderFn;

package/src/types/VolumeViewportProperties.ts

@@ -0,0 +1,14 @@
+import { VOIRange } from './voi';
+import VOILUTFunctionType from '../enums/VOILUTFunctionType';
+
+/**
+ * Stack Viewport Properties
+ */
+type VolumeViewportProperties = {
+  /** voi range (upper, lower) for the viewport */
+  voiRange?: VOIRange;
+  /** VOILUTFunction type which is LINEAR or SAMPLED_SIGMOID */
+  VOILUTFunction?: VOILUTFunctionType;
+};
+
+export default VolumeViewportProperties;

package/src/types/index.ts

@@ -0,0 +1,157 @@
+// @see: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#-type-only-imports-and-export
+import type Cornerstone3DConfig from './Cornerstone3DConfig';
+import type ICamera from './ICamera';
+import type IEnabledElement from './IEnabledElement';
+import type ICache from './ICache';
+import type { IVolume, VolumeScalarData } from './IVolume';
+import type { VOI, VOIRange } from './voi';
+import type ImageLoaderFn from './ImageLoaderFn';
+import type IImageVolume from './IImageVolume';
+import type IDynamicImageVolume from './IDynamicImageVolume';
+import type VolumeLoaderFn from './VolumeLoaderFn';
+import type IRegisterImageLoader from './IRegisterImageLoader';
+import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
+import type CustomEventType from './CustomEventType';
+import type { IViewport, PublicViewportInput } from './IViewport';
+import type { VolumeActor, Actor, ActorEntry } from './IActor';
+import type {
+  IImageLoadObject,
+  IVolumeLoadObject,
+  IGeometryLoadObject,
+} from './ILoadObject';
+import type Metadata from './Metadata';
+import type OrientationVectors from './OrientationVectors';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type Point4 from './Point4';
+import type Mat3 from './Mat3';
+import type Plane from './Plane';
+import type IStreamingImageVolume from './IStreamingImageVolume';
+import type ViewportInputOptions from './ViewportInputOptions';
+import type IImageData from './IImageData';
+import type CPUIImageData from './CPUIImageData';
+import type { CPUImageData } from './CPUIImageData';
+import type IImage from './IImage';
+import type {
+  PTScaling,
+  Scaling,
+  ScalingParameters,
+} from './ScalingParameters';
+import type StackViewportProperties from './StackViewportProperties';
+import type VolumeViewportProperties from './VolumeViewportProperties';
+import type IViewportId from './IViewportId';
+import type FlipDirection from './FlipDirection';
+import type ICachedImage from './ICachedImage';
+import type ICachedVolume from './ICachedVolume';
+import type IStackViewport from './IStackViewport';
+import type IVolumeViewport from './IVolumeViewport';
+import type ViewportPreset from './ViewportPreset';
+
+// CPU types
+import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
+import type CPUFallbackViewport from './CPUFallbackViewport';
+import type CPUFallbackTransform from './CPUFallbackTransform';
+import type CPUFallbackColormapData from './CPUFallbackColormapData';
+import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
+import type CPUFallbackColormapsData from './CPUFallbackColormapsData';
+import type CPUFallbackColormap from './CPUFallbackColormap';
+import type TransformMatrix2D from './TransformMatrix2D';
+import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
+import type CPUFallbackLUT from './CPUFallbackLUT';
+import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
+import type { IVolumeInput, VolumeInputCallback } from './IVolumeInput';
+import type * as EventTypes from './EventTypes';
+import type IRenderingEngine from './IRenderingEngine';
+import type ActorSliceRange from './ActorSliceRange';
+import type ImageSliceData from './ImageSliceData';
+import type IGeometry from './IGeometry';
+import type {
+  PublicContourSetData,
+  ContourSetData,
+  ContourData,
+} from './ContourData';
+import type ICachedGeometry from './ICachedGeometry';
+import type { IContourSet } from './IContourSet';
+import type { IContour } from './IContour';
+
+export type {
+  // config
+  Cornerstone3DConfig,
+  //
+  ICamera,
+  IStackViewport,
+  IVolumeViewport,
+  IEnabledElement,
+  ICache,
+  IVolume,
+  VolumeScalarData,
+  IViewportId,
+  IImageVolume,
+  IDynamicImageVolume,
+  IRenderingEngine,
+  ScalingParameters,
+  PTScaling,
+  Scaling,
+  IStreamingImageVolume,
+  IImage,
+  IImageData,
+  CPUIImageData,
+  CPUImageData,
+  EventTypes,
+  ImageLoaderFn,
+  VolumeLoaderFn,
+  IRegisterImageLoader,
+  IStreamingVolumeProperties,
+  IViewport,
+  StackViewportProperties,
+  VolumeViewportProperties,
+  PublicViewportInput,
+  VolumeActor,
+  Actor,
+  ActorEntry,
+  IImageLoadObject,
+  IVolumeLoadObject,
+  IVolumeInput,
+  VolumeInputCallback,
+  ViewportPreset,
+  //
+  Metadata,
+  OrientationVectors,
+  Point2,
+  Point3,
+  Point4,
+  Mat3,
+  Plane,
+  ViewportInputOptions,
+  VOIRange,
+  VOI,
+  FlipDirection,
+  ICachedImage,
+  ICachedVolume,
+  // CPU fallback types
+  CPUFallbackEnabledElement,
+  CPUFallbackViewport,
+  CPUFallbackTransform,
+  CPUFallbackColormapData,
+  CPUFallbackViewportDisplayedArea,
+  CPUFallbackColormapsData,
+  CPUFallbackColormap,
+  TransformMatrix2D,
+  CPUFallbackLookupTable,
+  CPUFallbackLUT,
+  CPUFallbackRenderingTools,
+  //
+  CustomEventType,
+  ActorSliceRange,
+  ImageSliceData,
+  // Geometry
+  IGeometry,
+  IGeometryLoadObject,
+  ICachedGeometry,
+  // Contour
+  PublicContourSetData,
+  ContourSetData,
+  ContourData,
+  IContourSet,
+  IContour,
+};

package/src/types/voi.ts

@@ -0,0 +1,15 @@
+type VOI = {
+  /** Window Width for display */
+  windowWidth: number;
+  /** Window Center for display */
+  windowCenter: number;
+};
+
+type VOIRange = {
+  /** upper value for display */
+  upper: number;
+  /** lower value for display */
+  lower: number;
+};
+
+export type { VOI, VOIRange };

package/src/utilities/actorCheck.ts

@@ -0,0 +1,24 @@
+import { Types } from '..';
+
+type actorTypes = 'vtkActor' | 'vtkVolume' | 'vtkImageSlice';
+
+/**
+ * Checks if a vtk Actor is an image actor (vtkVolume or vtkImageSlice) otherwise returns false.
+ *
+ * @param actor - actor
+ * @returns A boolean value.
+ */
+export function isImageActor(actorEntry: Types.ActorEntry): boolean {
+  return (
+    actorIsA(actorEntry, 'vtkVolume') || actorIsA(actorEntry, 'vtkImageSlice')
+  );
+}
+
+export function actorIsA(
+  actorEntry: Types.ActorEntry,
+  actorType: actorTypes
+): boolean {
+  const actor = actorEntry.actor;
+
+  return !!actor.isA(actorType);
+}