@cornerstonejs/core 0.36.3 → 0.36.5

package/src/types/IImage.ts

@@ -0,0 +1,113 @@
+import CPUFallbackLUT from './CPUFallbackLUT';
+import CPUFallbackColormap from './CPUFallbackColormap';
+import CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
+
+/**
+ * Cornerstone Image interface, it is used for both CPU and GPU rendering
+ */
+interface IImage {
+  /** Image Id */
+  imageId: string;
+  sharedCacheKey?: string;
+  /** Whether the image is Pre-scaled during loading */
+  isPreScaled?: boolean;
+  /** preScale object */
+  preScale?: {
+    /** boolean flag to indicate whether the image has been scaled */
+    scaled: boolean;
+    /** scaling parameters */
+    scalingParameters: {
+      /** modality of the image */
+      modality?: string;
+      /** rescale slop */
+      rescaleSlope?: number;
+      /** rescale intercept */
+      rescaleIntercept?: number;
+      /** PT suvbw */
+      suvbw?: number;
+    };
+  };
+  /** minimum pixel value of the image */
+  minPixelValue: number;
+  /* maximum pixel value of the image */
+  maxPixelValue: number;
+  /** slope from metadata for scaling */
+  slope: number;
+  /** intercept from metadata for scaling */
+  intercept: number;
+  /** windowCenter from metadata */
+  windowCenter: number[] | number;
+  /** windowWidth from metadata */
+  windowWidth: number[] | number;
+  /** voiLUTFunction from metadata */
+  voiLUTFunction: string;
+  /** function that returns the pixelData as an array */
+  getPixelData: () => Array<number>;
+  getCanvas: () => HTMLCanvasElement;
+  /** image number of rows */
+  rows: number;
+  /** image number of columns */
+  columns: number;
+  /** image height */
+  height: number;
+  /** image width */
+  width: number;
+  /** is image a color image */
+  color: boolean;
+  /** is image rgb and alpha */
+  rgba: boolean;
+  /** number of components in the image */
+  numComps: number;
+  /** CPU: custom render method for the image */
+  render?: (
+    enabledElement: CPUFallbackEnabledElement,
+    invalidated: boolean
+  ) => unknown;
+  /** column pixel spacing */
+  columnPixelSpacing: number;
+  /** row pixel spacing */
+  rowPixelSpacing: number;
+  /** slice thickness */
+  sliceThickness?: number;
+  /** whether image pixels are inverted in color */
+  invert: boolean;
+  /** image size in number of bytes */
+  sizeInBytes: number;
+  /** CPU: custom modality LUT for image  */
+  modalityLUT?: CPUFallbackLUT;
+  /** CPU: custom VOI LUT for image  */
+  voiLUT?: CPUFallbackLUT;
+  /** CPU: custom color map for image  */
+  colormap?: CPUFallbackColormap;
+  /** image scaling metadata - including PT suv values */
+  scaling?: {
+    PET?: {
+      // @TODO: Do these values exist?
+      SUVlbmFactor?: number;
+      SUVbsaFactor?: number;
+      // accessed in ProbeTool
+      suvbwToSuvlbm?: number;
+      suvbwToSuvbsa?: number;
+    };
+  };
+  /** CPU: image statistics for rendering */
+  stats?: {
+    lastStoredPixelDataToCanvasImageDataTime?: number;
+    lastGetPixelDataTime?: number;
+    lastPutImageDataTime?: number;
+    lastLutGenerateTime?: number;
+    lastRenderedViewport?: unknown;
+    lastRenderTime?: number;
+  };
+  /** CPU: image cached LUT */
+  cachedLut?: {
+    windowWidth?: number | number[];
+    windowCenter?: number | number[];
+    invert?: boolean;
+    lutArray?: Uint8ClampedArray;
+    modalityLUT?: unknown;
+    voiLUT?: CPUFallbackLUT;
+  };
+}
+
+export default IImage;

package/src/types/IImageData.ts

@@ -0,0 +1,45 @@
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { Point3, Scaling, Mat3 } from '../types';
+
+/**
+ * IImageData of an image, which stores actual scalarData and metaData about the image.
+ * IImageData is different from vtkImageData.
+ */
+interface IImageData {
+  /** image dimensions */
+  dimensions: Point3;
+  /** image direction */
+  direction: Mat3;
+  /** image spacing */
+  spacing: Point3;
+  /** image origin */
+  origin: Point3;
+  /** image scalarData which stores the array of pixelData */
+  scalarData: Float32Array | Uint16Array | Uint8Array | Int16Array;
+  /** vtkImageData object */
+  imageData: vtkImageData;
+  /** image metadata - currently only modality */
+  metadata: { Modality: string };
+  /** image scaling for scaling pixelArray */
+  scaling?: Scaling;
+  /** whether the image has pixel spacing and it is not undefined */
+  hasPixelSpacing?: boolean;
+  /** preScale object */
+  preScale?: {
+    /** boolean flag to indicate whether the image has been scaled */
+    scaled?: boolean;
+    /** scaling parameters */
+    scalingParameters?: {
+      /** modality of the image */
+      modality?: string;
+      /** rescale slop */
+      rescaleSlope?: number;
+      /** rescale intercept */
+      rescaleIntercept?: number;
+      /** PT suvbw */
+      suvbw?: number;
+    };
+  };
+}
+
+export default IImageData;

package/src/types/IImageVolume.ts

@@ -0,0 +1,78 @@
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import {
+  Metadata,
+  VolumeScalarData,
+  Point3,
+  IImageLoadObject,
+  Mat3,
+} from '../types';
+
+/**
+ * Cornerstone ImageVolume interface. Todo: we should define new IVolume class
+ * with appropriate typings for the other types of volume that don't have images (nrrd, nifti)
+ */
+interface IImageVolume {
+  /** unique identifier of the volume in the cache */
+  readonly volumeId: string;
+  /** volume dimensions */
+  dimensions: Point3;
+  /** volume direction */
+  direction: Mat3;
+  /** volume metadata */
+  metadata: Metadata;
+  /** volume origin - set to the imagePositionPatient of the last image in the volume */
+  origin: Point3;
+  /** Whether preScaling has been performed on the volume */
+  isPrescaled: boolean;
+  /** volume scaling metadata */
+  scaling?: {
+    PET?: {
+      SUVlbmFactor?: number;
+      SUVbsaFactor?: number;
+      suvbwToSuvlbm?: number;
+      suvbwToSuvbsa?: number;
+    };
+  };
+  /** volume size in bytes */
+  sizeInBytes?: number;
+  /** volume spacing */
+  spacing: Point3;
+  /** number of voxels in the volume */
+  numVoxels: number;
+  /** volume image data as vtkImageData */
+  imageData?: vtkImageData;
+  /** openGL texture for the volume */
+  vtkOpenGLTexture: any;
+  /** loading status object for the volume containing loaded/loading statuses */
+  loadStatus?: Record<string, any>;
+  /** imageIds of the volume (if it is built of separate imageIds) */
+  imageIds: Array<string>;
+  /** volume referencedVolumeId (if it is derived from another volume) */
+  referencedVolumeId?: string; // if volume is derived from another volume
+  /** whether the metadata for the pixel spacing is not undefined  */
+  hasPixelSpacing: boolean;
+  /** return true if it is a 4D volume or false if it is 3D volume */
+  isDynamicVolume(): boolean;
+  /** method to convert the volume data in the volume cache, to separate images in the image cache */
+  convertToCornerstoneImage?: (
+    imageId: string,
+    imageIdIndex: number
+  ) => IImageLoadObject;
+
+  //cancel load
+  cancelLoading?: () => void;
+
+  /** return the volume scalar data */
+  getScalarData(): VolumeScalarData;
+
+  /** return the index of a given imageId */
+  getImageIdIndex(imageId: string): number;
+
+  /** return the index of a given imageURI */
+  getImageURIIndex(imageURI: string): number;
+
+  /** destroy the volume and make it unusable */
+  destroy(): void;
+}
+
+export default IImageVolume;

package/src/types/ILoadObject.ts

@@ -0,0 +1,36 @@
+import { ImageVolume } from './../cache/classes/ImageVolume';
+import IGeometry from './IGeometry';
+import IImage from './IImage';
+
+/**
+ * ImageLoadObject interface which any imageLoader should return
+ */
+export interface IImageLoadObject {
+  /** promise that resolves to an image */
+  promise: Promise<IImage>;
+  /** optional cancel function for loading*/
+  cancelFn?: () => void;
+  /** optional decache function */
+  decache?: () => void;
+}
+
+/**
+ * VolumeLoadObject interface which any volumeLoader should return
+ */
+export interface IVolumeLoadObject {
+  /** promise that resolves to an ImageVolume */
+  promise: Promise<ImageVolume>;
+  /** optional cancel function for loading*/
+  cancelFn?: () => void;
+  /** optional decache function */
+  decache?: () => void;
+}
+
+export interface IGeometryLoadObject {
+  /** promise that resolves to an ImageVolume */
+  promise: Promise<IGeometry>;
+  /** optional cancel function for loading*/
+  cancelFn?: () => void;
+  /** optional decache function */
+  decache?: () => void;
+}

package/src/types/IRegisterImageLoader.ts

@@ -0,0 +1,10 @@
+import ImageLoaderFn from './ImageLoaderFn';
+
+/**
+ * Register image loader interface
+ */
+interface IRegisterImageLoader {
+  registerImageLoader: (scheme: string, imageLoader: ImageLoaderFn) => void;
+}
+
+export default IRegisterImageLoader;

package/src/types/IRenderingEngine.ts

@@ -0,0 +1,28 @@
+import IStackViewport from './IStackViewport';
+import { PublicViewportInput } from './IViewport';
+import IVolumeViewport from './IVolumeViewport';
+
+export default interface IRenderingEngine {
+  id: string;
+  hasBeenDestroyed: boolean;
+  offscreenMultiRenderWindow: any;
+  offScreenCanvasContainer: any;
+  setViewports(viewports: Array<PublicViewportInput>): void;
+  resize(immediate?: boolean, resetPan?: boolean, resetZoom?: boolean): void;
+  getViewport(id: string): IStackViewport | IVolumeViewport;
+  getViewports(): Array<IStackViewport | IVolumeViewport>;
+  render(): void;
+  renderViewports(viewportIds: Array<string>): void;
+  renderViewport(viewportId: string): void;
+  renderFrameOfReference(FrameOfReferenceUID: string): void;
+  fillCanvasWithBackgroundColor(
+    canvas: HTMLCanvasElement,
+    backgroundColor: [number, number, number]
+  ): void;
+  enableElement(viewportInputEntry: PublicViewportInput): void;
+  disableElement(viewportId: string): void;
+  getStackViewports(): Array<IStackViewport>;
+  getVolumeViewports(): Array<IVolumeViewport>;
+  destroy(): void;
+  _debugRender(): void;
+}

package/src/types/IStackViewport.ts

@@ -0,0 +1,138 @@
+import CPUFallbackColormapData from './CPUFallbackColormapData';
+import CPUIImageData from './CPUIImageData';
+import ICamera from './ICamera';
+import IImageData from './IImageData';
+import { IViewport } from './IViewport';
+import Point2 from './Point2';
+import Point3 from './Point3';
+import { Scaling } from './ScalingParameters';
+import StackViewportProperties from './StackViewportProperties';
+
+/**
+ * Interface for Stack Viewport
+ */
+export default interface IStackViewport extends IViewport {
+  modality: string;
+  /** Scaling parameters */
+  scaling: Scaling;
+  /**
+   * Resizes the viewport - only used in CPU fallback for StackViewport. The
+   * GPU resizing happens inside the RenderingEngine.
+   */
+  resize: () => void;
+  /**
+   * Returns the frame of reference UID, if the image doesn't have imagePlaneModule
+   * metadata, it returns undefined, otherwise, frameOfReferenceUID is returned.
+   */
+  getFrameOfReferenceUID: () => string;
+  /**
+   * Sets the properties for the viewport on the default actor. Properties include
+   * setting the VOI, inverting the colors and setting the interpolation type, rotation
+   */
+  setProperties(
+    { voiRange, invert, interpolationType, rotation }: StackViewportProperties,
+    suppressEvents?: boolean
+  ): void;
+  /**
+   * Retrieve the viewport properties
+   */
+  getProperties: () => StackViewportProperties;
+  /**
+   * canvasToWorld Returns the world coordinates of the given `canvasPos`
+   * projected onto the plane defined by the `Viewport`'s camera.
+   */
+  canvasToWorld: (canvasPos: Point2) => Point3;
+  /**
+   * Returns the canvas coordinates of the given `worldPos`
+   * projected onto the `Viewport`'s `canvas`.
+   */
+  worldToCanvas: (worldPos: Point3) => Point2;
+  /**
+   * Returns the index of the imageId being renderer
+   */
+  getCurrentImageIdIndex: () => number;
+  /**
+   * Returns the list of image Ids for the current viewport
+   */
+  getImageIds: () => string[];
+  /**
+   * Returns true if the viewport contains the imageId
+   */
+  hasImageId: (imageId: string) => boolean;
+  /**
+   * Returns true if the viewport contains the imageURI
+   */
+  hasImageURI: (imageURI: string) => boolean;
+  /**
+   * Returns the currently rendered imageId
+   */
+  getCurrentImageId: () => string;
+
+  /**
+   * Custom rendering pipeline for the rendering for the CPU fallback
+   */
+  customRenderViewportToCanvas: () => {
+    canvas: HTMLCanvasElement;
+    element: HTMLDivElement;
+    viewportId: string;
+    renderingEngineId: string;
+  };
+  /**
+   * 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)
+   */
+  getImageData(): IImageData | CPUIImageData;
+  /**
+   * Reset the viewport properties to the default values
+   */
+  resetProperties(): void;
+  /**
+   * If the user has selected CPU rendering, return the CPU camera, otherwise
+   * return the default camera
+   */
+  getCamera(): ICamera;
+  /**
+   * Set the camera based on the provided camera object.
+   */
+  setCamera(cameraInterface: ICamera): void;
+  /**
+   * Sets the imageIds to be visualized inside the stack viewport. It accepts
+   * list of imageIds, the index of the first imageId to be viewed. It is a
+   * asynchronous function that returns a promise resolving to imageId being
+   * displayed in the stack viewport.
+   */
+  setStack(
+    imageIds: Array<string>,
+    currentImageIdIndex?: number
+  ): Promise<string>;
+  /**
+   * Centers Pan and resets the zoom for stack viewport.
+   */
+  resetCamera(resetPan?: boolean, resetZoom?: boolean): boolean;
+  /**
+   * Loads the image based on the provided imageIdIndex. It is an Async function which
+   * returns a promise that resolves to the imageId.
+   */
+  setImageIdIndex(imageIdIndex: number): Promise<string>;
+  /**
+   * Calibrates the image with new metadata that has been added for imageId. To calibrate
+   * a viewport, you should add your calibration data manually to
+   * calibratedPixelSpacingMetadataProvider and call viewport.calibrateSpacing
+   * for it get applied.
+   */
+  calibrateSpacing(imageId: string): void;
+  /**
+   * If the renderer is CPU based, throw an error. Otherwise, returns the `vtkRenderer` responsible for rendering the `Viewport`.
+   */
+  getRenderer(): any;
+  /**
+   * Sets the colormap for the current viewport.
+   * @param colormap - The colormap data to use.
+   */
+  setColormap(colormap: CPUFallbackColormapData): void;
+  /**
+   * It sets the colormap to the default colormap.
+   */
+  unsetColormap(): void;
+}

package/src/types/IStreamingImageVolume.ts

@@ -0,0 +1,13 @@
+import { ImageVolume } from './../cache/classes/ImageVolume';
+
+/**
+ * Cornerstone StreamingImageVolume which extends ImageVolume
+ */
+export default interface IStreamingImageVolume extends ImageVolume {
+  /** method to load all the loading requests */
+  clearLoadCallbacks(): void;
+  /** method to convert the volume data in the volume cache, to separate images in the image cache */
+  convertToCornerstoneImage(imageId: string, imageIdIndex: number): any;
+  /** method to decache the volume from cache */
+  decache(completelyRemove: boolean): void;
+}

package/src/types/IStreamingVolumeProperties.ts

@@ -0,0 +1,14 @@
+interface IStreamingVolumeProperties {
+  /** imageIds of the volume  */
+  imageIds: Array<string>;
+
+  /** loading status object for the volume containing loaded/loading statuses */
+  loadStatus: {
+    loaded: boolean;
+    loading: boolean;
+    cachedFrames: Array<boolean>;
+    callbacks: Array<() => void>;
+  };
+}
+
+export default IStreamingVolumeProperties;

package/src/types/IViewport.ts

@@ -0,0 +1,149 @@
+import ICamera from './ICamera';
+import Point2 from './Point2';
+import Point3 from './Point3';
+import ViewportInputOptions from './ViewportInputOptions';
+import { ActorEntry } from './IActor';
+import ViewportType from '../enums/ViewportType';
+
+/**
+ * Viewport interface for cornerstone viewports
+ */
+interface IViewport {
+  /** unique identifier of the viewport */
+  id: string;
+  /** renderingEngineId the viewport belongs to */
+  renderingEngineId: string;
+  /** viewport type, can be ORTHOGRAPHIC or STACK for now */
+  type: ViewportType;
+  /** canvas associated to the viewport */
+  canvas: HTMLCanvasElement;
+  /** public DOM element associated to the viewport */
+  element: HTMLDivElement;
+  /** sx of the viewport on the offscreen canvas (if rendering using GPU) */
+  sx: number;
+  /** sy of the viewport on the offscreen canvas (if rendering using GPU) */
+  sy: number;
+  /** width of the viewport on the offscreen canvas (if rendering using GPU) */
+  sWidth: number;
+  /** height of the viewport on the offscreen canvas (if rendering using GPU) */
+  sHeight: number;
+  /** actors rendered in the viewport*/
+  _actors: Map<string, any>;
+  /** viewport default options including the axis, and background color  */
+  defaultOptions: any;
+  /** viewport options */
+  options: ViewportInputOptions;
+  /** Suppress events */
+  suppressEvents: boolean;
+  /** if the viewport has been disabled */
+  isDisabled: boolean;
+  /** the rotation applied to the view */
+  getRotation: () => number;
+  /** frameOfReferenceUID the viewport's default actor is rendering */
+  getFrameOfReferenceUID: () => string;
+  /** method to convert canvas to world coordinates */
+  canvasToWorld: (canvasPos: Point2) => Point3;
+  /** method to convert world to canvas coordinates */
+  worldToCanvas: (worldPos: Point3) => Point2;
+  /** get the first actor */
+  getDefaultActor(): ActorEntry;
+  /** returns all the actor entires for a viewport which is an object containing actor and its uid */
+  getActors(): Array<ActorEntry>;
+  /** returns specific actor by its uid */
+  getActor(actorUID: string): ActorEntry;
+  /** returns specific actor uid by array index */
+  getActorUIDByIndex(index: number): string;
+  /** returns specific actor by array index */
+  getActorByIndex(index: number): ActorEntry;
+  /** set and overwrite actors in a viewport */
+  setActors(actors: Array<ActorEntry>): void;
+  /** add actors to the list of actors */
+  addActors(actors: Array<ActorEntry>): void;
+  /** add one actor */
+  addActor(actorEntry: ActorEntry): void;
+  /** remove all actors from the viewport */
+  removeAllActors(): void;
+  /** remove array of uids */
+  removeActors(actorUIDs: Array<string>): void;
+  /** returns the renderingEngine instance the viewport belongs to */
+  getRenderingEngine(): any;
+  /** returns the vtkRenderer (for GPU rendering) of the viewport */
+  getRenderer(): void;
+  /** triggers render for all actors in the viewport */
+  render(): void;
+  /** set options for the viewport */
+  setOptions(options: ViewportInputOptions, immediate: boolean): void;
+  /** reset camera and options*/
+  reset(immediate: boolean): void;
+  /** returns the canvas */
+  getCanvas(): HTMLCanvasElement;
+  /** returns camera object */
+  getCamera(): ICamera;
+  /** returns the parallel zoom relative to the default (eg returns 1 after reset) */
+  getZoom(): number;
+  /** Sets the relative zoom - set to 1 to reset it */
+  setZoom(zoom: number, storeAsInitialCamera?: boolean);
+  /** Gets the canvas pan value */
+  getPan(): Point2;
+  /** Sets the canvas pan value */
+  setPan(pan: Point2, storeAsInitialCamera?: boolean);
+  /** sets the camera */
+  setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
+  /** whether the viewport has custom rendering */
+  customRenderViewportToCanvas: () => unknown;
+  _getCorners(bounds: Array<number>): Array<number>[];
+}
+
+/**
+ * Public Interface for viewport input to get enabled/disabled or set
+ */
+type PublicViewportInput = {
+  /** HTML element in the DOM */
+  element: HTMLDivElement;
+  /** unique id for the viewport in the renderingEngine */
+  viewportId: string;
+  /** type of the viewport */
+  type: ViewportType;
+  /** options for the viewport */
+  defaultOptions?: ViewportInputOptions;
+};
+
+type NormalizedViewportInput = {
+  /** HTML element in the DOM */
+  element: HTMLDivElement;
+  /** unique id for the viewport in the renderingEngine */
+  viewportId: string;
+  /** type of the viewport */
+  type: ViewportType;
+  /** options for the viewport */
+  defaultOptions: ViewportInputOptions;
+};
+
+type InternalViewportInput = {
+  element: HTMLDivElement;
+  canvas: HTMLCanvasElement;
+  viewportId: string;
+  type: ViewportType;
+  defaultOptions: ViewportInputOptions;
+};
+
+type ViewportInput = {
+  id: string;
+  element: HTMLDivElement;
+  canvas: HTMLCanvasElement;
+  renderingEngineId: string;
+  type: ViewportType;
+  sx: number;
+  sy: number;
+  sWidth: number;
+  sHeight: number;
+  defaultOptions: ViewportInputOptions;
+};
+
+export type {
+  IViewport,
+  ViewportInput,
+  PublicViewportInput,
+  InternalViewportInput,
+  NormalizedViewportInput,
+};

package/src/types/IViewportId.ts

@@ -0,0 +1,9 @@
+/**
+ * Interface to uniquely define a viewport in cornerstone. Note: viewportIds
+ * can be shared between different rendering engines, but having a renderingEngineId
+ * and a viewportId is required to uniquely define a viewport.
+ */
+export default interface IViewportId {
+  renderingEngineId: string;
+  viewportId: string;
+}

package/src/types/IVolume.ts

@@ -0,0 +1,45 @@
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type Point3 from './Point3';
+import type Metadata from './Metadata';
+import Mat3 from './Mat3';
+
+type VolumeScalarData = Float32Array | Uint8Array | Uint16Array | Int16Array;
+
+/**
+ * Cornerstone ImageVolume interface.
+ */
+interface IVolume {
+  /** unique identifier for the volume in the cache */
+  volumeId: string;
+  /** volume metadata */
+  metadata: Metadata;
+  /** volume dimensions */
+  dimensions: Point3;
+  /** volume spacing */
+  spacing: Point3;
+  /** volume origin */
+  origin: Point3;
+  /** volume direction */
+  direction: Mat3;
+  /** volume scalarData */
+  scalarData: VolumeScalarData | Array<VolumeScalarData>;
+  /** volume size in bytes */
+  sizeInBytes?: number;
+  /** volume image data as vtkImageData */
+  imageData?: vtkImageData;
+  /** referencedVolumeId if volume is derived from another volume */
+  referencedVolumeId?: string;
+  /** volume scaling metadata */
+  scaling?: {
+    PET?: {
+      // @TODO: Do these values exist?
+      SUVlbmFactor?: number;
+      SUVbsaFactor?: number;
+      // accessed in ProbeTool
+      suvbwToSuvlbm?: number;
+      suvbwToSuvbsa?: number;
+    };
+  };
+}
+
+export { IVolume as default, IVolume, VolumeScalarData };