@cornerstonejs/core 2.0.0-beta.6 → 2.0.0-beta.8

package/src/types/Colormap.ts

@@ -3,7 +3,7 @@ import RGB from './RGB';
 type ColormapRegistration = {
   ColorSpace: string;
   Name: string;
-  RGBPoints: RGB[];
+  RGBPoints: RGB[] | number[];
 };
 
 type OpacityMapping = {

package/src/types/Cornerstone3DConfig.ts

@@ -8,6 +8,11 @@ type Cornerstone3DConfig = {
    * https://github.com/pmndrs/detect-gpu/blob/master/src/index.ts#L82
    */
   gpuTier?: TierResult;
+
+  /**
+   * Whether the device is mobile or not.
+   */
+  isMobile: boolean;
   /**
    * When the `gpuTier` is not provided, the `detectGPUConfig` is passed as
    * an argument to the `getGPUTier` method.
@@ -51,6 +56,18 @@ type Cornerstone3DConfig = {
      */
     strictZSpacingForVolumeViewport: boolean;
   };
+  /**
+   * This flag controls whether to enable cache optimization or not. Basically,
+   * when we have a stack viewport (image stack) and we convert it to a volume
+   * the volume will be cached as well as the stack. However, if we can optimize this
+   * by going back to the image cache and create a view at the correct offset
+   * of the bigger volume array buffer, this will save memory. This will get enabled
+   * if cornerstone3D is configured to use SharedArrayBuffer, the reason is that
+   * when we modify the image cache then the images are referring to a different
+   * buffer (SharedArrayBuffer) and some systems don't support shared array
+   * buffers.
+   */
+  enableCacheOptimization: boolean;
 };
 
 export default Cornerstone3DConfig;

package/src/types/EventTypes.ts

@@ -11,6 +11,7 @@ import VOILUTFunctionType from '../enums/VOILUTFunctionType';
 import ViewportStatus from '../enums/ViewportStatus';
 import type DisplayArea from './displayArea';
 import IImageCalibration from './IImageCalibration';
+import { ColormapPublic } from './Colormap';
 
 /**
  * CAMERA_MODIFIED Event's data
@@ -30,6 +31,23 @@ type CameraModifiedEventDetail = {
   rotation?: number;
 };
 
+/**
+ * CAMERA_RESET Event's data
+ */
+
+type CameraResetEventDetail = {
+  /** Viewport HTML element in the DOM */
+  element: HTMLDivElement;
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** Unique ID for the renderingEngine */
+  renderingEngineId: string;
+  /** Camera properties */
+  camera: ICamera;
+};
+
+type CameraResetEvent = CustomEventType<CameraResetEventDetail>;
+
 /**
  * VOI_MODIFIED Event's data
  */
@@ -46,6 +64,17 @@ type VoiModifiedEventDetail = {
   invert?: boolean;
   /** Indicates if the 'invert' state has changed from the previous state */
   invertStateChanged?: boolean;
+  /** color map */
+  colormap?: ColormapPublic;
+};
+
+type ColormapModifiedEventDetail = {
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** The new colormap */
+  colormap: ColormapPublic;
+  /** Unique ID for the volume in the cache */
+  volumeId?: string;
 };
 
 /**
@@ -109,6 +138,10 @@ type ImageVolumeModifiedEventDetail = {
   imageVolume: IImageVolume;
   /** FrameOfReferenceUID where the volume belongs to */
   FrameOfReferenceUID: string;
+  /** number of frames */
+  numberOfFrames: number;
+  /** framesProcessed */
+  framesProcessed: number;
 };
 
 /**
@@ -287,6 +320,11 @@ type CameraModifiedEvent = CustomEventType<CameraModifiedEventDetail>;
  */
 type VoiModifiedEvent = CustomEventType<VoiModifiedEventDetail>;
 
+/**
+ * COLORMAP_MODIFIED Event type
+ */
+type ColormapModifiedEvent = CustomEventType<ColormapModifiedEventDetail>;
+
 /**
  * DISPLAY_AREA_MODIFIED Event type
  */
@@ -398,6 +436,8 @@ export type {
   CameraModifiedEvent,
   VoiModifiedEvent,
   VoiModifiedEventDetail,
+  ColormapModifiedEvent,
+  ColormapModifiedEventDetail,
   DisplayAreaModifiedEvent,
   DisplayAreaModifiedEventDetail,
   ElementDisabledEvent,
@@ -438,4 +478,6 @@ export type {
   StackViewportNewStackEventDetail,
   StackViewportScrollEvent,
   StackViewportScrollEventDetail,
+  CameraResetEvent,
+  CameraResetEventDetail,
 };

package/src/types/IActor.ts

@@ -6,6 +6,18 @@ export type Actor = vtkActor;
 export type VolumeActor = vtkVolume;
 export type ImageActor = vtkImageSlice;
 
+export interface ICanvasActor {
+  render(viewport, context): void;
+
+  getMapper();
+
+  getProperty();
+
+  isA(actorType): boolean;
+
+  getClassName(): string;
+}
+
 /**
  * Cornerstone Actor Entry including actor uid, actual Actor, and
  * slabThickness for the actor. ActorEntry is the object that
@@ -15,9 +27,11 @@ export type ActorEntry = {
   /** actor UID */
   uid: string;
   /** actual actor object */
-  actor: Actor | VolumeActor | ImageActor;
+  actor: Actor | VolumeActor | ImageActor | ICanvasActor;
   /** the id of the reference volume from which this actor is derived or created*/
   referenceId?: string;
   /** slab thickness for the actor */
   slabThickness?: number;
+  /** clipping filter applied to actor surfaces*/
+  clippingFilter?: any;
 };

package/src/types/IDynamicImageVolume.ts

@@ -1,4 +1,4 @@
-import { IImageVolume, VolumeScalarData } from '../types';
+import { IImageVolume, PixelDataTypedArray } from '../types';
 
 /**
  * Cornerstone ImageVolume interface. Todo: we should define new IVolume class
@@ -12,7 +12,7 @@ interface IDynamicImageVolume extends IImageVolume {
   /** Returns the number of time points */
   get numTimePoints(): number;
   /** return scalar data arrays (one per timepoint) */
-  getScalarDataArrays(): VolumeScalarData[];
+  getScalarDataArrays(): PixelDataTypedArray[];
 }
 
 export default IDynamicImageVolume;

package/src/types/IEnabledElement.ts

@@ -6,7 +6,10 @@ import type IVolumeViewport from './IVolumeViewport';
  * Cornerstone Enabled Element interface
  */
 interface IEnabledElement {
-  /** Cornerstone Viewport instance - can be Stack or Volume Viewport as of now */
+  /** Cornerstone Viewport instance - can be Stack or Volume, or Video Viewport as of now.
+   * For the moment, need to cast to unknown first before casting to IVideoViewport
+   * (TODO) - this will be done as part of adding annotation tools for video
+   */
   viewport: IStackViewport | IVolumeViewport;
   /** Cornerstone Rendering Engine instance */
   renderingEngine: IRenderingEngine;

package/src/types/IGeometry.ts

@@ -1,11 +1,12 @@
 import { GeometryType } from '../enums';
 import { IContourSet } from './IContourSet';
+import { ISurface } from './ISurface';
 
 // interface IGeometry can be array of IContourSet
 interface IGeometry {
   id: string;
   type: GeometryType;
-  data: IContourSet; // | Array<IClosedSurface> , etc
+  data: IContourSet | ISurface;
   sizeInBytes: number;
 }
 

package/src/types/IImage.ts

@@ -2,7 +2,10 @@ import type CPUFallbackLUT from './CPUFallbackLUT';
 import type CPUFallbackColormap from './CPUFallbackColormap';
 import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
 import type { PixelDataTypedArray } from './PixelDataTypedArray';
+import type VoxelManager from '../utilities/VoxelManager';
 import { ImageQualityStatus } from '../enums';
+import IImageCalibration from './IImageCalibration';
+import RGB from './RGB';
 
 /**
  * Cornerstone Image interface, it is used for both CPU and GPU rendering
@@ -10,11 +13,14 @@ import { ImageQualityStatus } from '../enums';
 interface IImage {
   /** Image Id */
   imageId: string;
+  /** referenced imageId if this image is derived from */
+  referencedImageId?: string;
   sharedCacheKey?: string;
   /** Whether the image is Pre-scaled during loading */
   isPreScaled?: boolean;
   /** preScale object */
   preScale?: {
+    enabled: boolean;
     /** boolean flag to indicate whether the image has been scaled */
     scaled?: boolean;
     /** scaling parameters */
@@ -116,6 +122,15 @@ interface IImage {
   };
 
   imageQualityStatus?: ImageQualityStatus;
+  calibration?: IImageCalibration;
+  imageFrame?: any;
+
+  voxelManager?: VoxelManager<number> | VoxelManager<RGB>;
+
+  bufferView?: {
+    buffer: ArrayBuffer;
+    offset: number;
+  };
 }
 
 export default IImage;

package/src/types/IImageVolume.ts

@@ -1,10 +1,12 @@
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { VoxelManager } from '../utilities';
 import {
   Metadata,
-  VolumeScalarData,
+  PixelDataTypedArray,
   Point3,
   IImageLoadObject,
   Mat3,
+  RGB,
 } from '../types';
 
 /**
@@ -49,8 +51,12 @@ interface IImageVolume {
   imageIds: Array<string>;
   /** volume referencedVolumeId (if it is derived from another volume) */
   referencedVolumeId?: string; // if volume is derived from another volume
+  /** volume referencedImageIds (if it is derived from set of images in the image cache) */
+  referencedImageIds?: Array<string>;
   /** whether the metadata for the pixel spacing is not undefined  */
   hasPixelSpacing: boolean;
+  /** Property to store additional information */
+  additionalDetails?: Record<string, any>;
   /** 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 */
@@ -63,7 +69,12 @@ interface IImageVolume {
   cancelLoading?: () => void;
 
   /** return the volume scalar data */
-  getScalarData(): VolumeScalarData;
+  getScalarData(): PixelDataTypedArray;
+
+  /** A voxel manager to manage the scalar data */
+  voxelManager?: VoxelManager<number> | VoxelManager<RGB>;
+
+  convertToImageSlicesAndCache(): string[];
 
   /** return the index of a given imageId */
   getImageIdIndex(imageId: string): number;
@@ -73,6 +84,20 @@ interface IImageVolume {
 
   /** destroy the volume and make it unusable */
   destroy(): void;
+
+  /** decache */
+  decache?: (completelyRemove?: boolean) => void;
+
+  /** */
+  get imageCacheOffsetMap(): Map<string, any>;
+
+  /**
+   * Mark the volume as having had the pixel data changed externally
+   * which in background will re-configure the volume to use the new
+   * pixel data.
+   *
+   */
+  modified(): void;
 }
 
 export default IImageVolume;

package/src/types/ILoadObject.ts

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

package/src/types/IRenderingEngine.ts

@@ -1,6 +1,8 @@
 import IStackViewport from './IStackViewport';
 import { PublicViewportInput } from './IViewport';
 import IVolumeViewport from './IVolumeViewport';
+import { IViewport } from './IViewport';
+import IVideoViewport from './IVideoViewport';
 
 export default interface IRenderingEngine {
   id: string;
@@ -9,8 +11,8 @@ export default interface IRenderingEngine {
   offScreenCanvasContainer: any;
   setViewports(viewports: Array<PublicViewportInput>): void;
   resize(immediate?: boolean, keepCamera?: boolean): void;
-  getViewport(id: string): IStackViewport | IVolumeViewport;
-  getViewports(): Array<IStackViewport | IVolumeViewport>;
+  getViewport(id: string): IViewport;
+  getViewports(): Array<IViewport>;
   render(): void;
   renderViewports(viewportIds: Array<string>): void;
   renderViewport(viewportId: string): void;
@@ -23,6 +25,7 @@ export default interface IRenderingEngine {
   disableElement(viewportId: string): void;
   getStackViewports(): Array<IStackViewport>;
   getVolumeViewports(): Array<IVolumeViewport>;
+  getVideoViewports(): Array<IVideoViewport>;
   destroy(): void;
   _debugRender(): void;
 }

package/src/types/IStackInput.ts

@@ -0,0 +1,30 @@
+import { ImageActor } from './IActor';
+
+/**
+ * Stack input callback type, used to perform operations on the image data
+ * after it has been loaded.
+ */
+type StackInputCallback = (params: {
+  /** vtk image actor */
+  imageActor: ImageActor;
+  /** unique image Id in the cache */
+  imageId: string;
+}) => unknown;
+
+/**
+ * StackInput that can be used to add an image actor  to a viewport. It includes
+ * mandatory `imageId` but other options such as `visibility` and `callback`
+ * can also be provided
+ */
+interface IStackInput {
+  /** imageId of the image in the cache */
+  imageId: string;
+  // actorUID of the imageActor being added
+  actorUID?: string;
+  /** Visibility of the image actor - by default it is true */
+  visibility?: boolean;
+  /** Callback to be called when the image is added to the viewport */
+  callback?: StackInputCallback;
+}
+
+export type { IStackInput, StackInputCallback };

package/src/types/IStackViewport.ts

@@ -1,147 +1,3 @@
-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';
-import { ColormapRegistration } from './Colormap';
-import type IImage from './IImage';
+import type IStackViewport from '../RenderingEngine/StackViewport';
 
-/**
- * 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;
-  /**
-   * Returns the raw/loaded image being shown inside the stack viewport.
-   */
-  getCornerstoneImage: () => IImage;
-  /**
-   * 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.
-   *
-   * @param retrieveConfiguration - Set this to a progressive retriever of your
-   *       choice for progressive retrieval, or leave empty for non-progressive.
-   */
-  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 | ColormapRegistration): void;
-  /**
-   * It sets the colormap to the default colormap.
-   */
-  unsetColormap(): void;
-}
+export default IStackViewport;

package/src/types/ISurface.ts

@@ -0,0 +1,14 @@
+import Point3 from './Point3';
+
+export interface ISurface {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  readonly frameOfReferenceUID: string;
+  getColor(): Point3;
+  setColor(color: Point3): void;
+  getPoints(): number[];
+  getPolys(): number[];
+  getSizeInBytes(): number;
+  setPoints(points: number[]): void;
+  setPolys(polys: number[]): void;
+}

package/src/types/IVideoViewport.ts

@@ -0,0 +1,87 @@
+import { IViewport } from './IViewport';
+import VideoViewportProperties from './VideoViewportProperties';
+
+/**
+ * Interface for Stack Viewport
+ */
+export default interface IVideoViewport extends IViewport {
+  /**
+   * Resizes the viewport - only used in CPU fallback for StackViewport. The
+   * GPU resizing happens inside the RenderingEngine.
+   */
+  resize: () => void;
+  /**
+   * Sets the properties for the viewport on the default actor.
+   */
+  setProperties(props: VideoViewportProperties, suppressEvents?: boolean): void;
+  /**
+   * Retrieve the viewport properties
+   */
+  getProperties: () => VideoViewportProperties;
+
+  /**
+   * Sets the video to play.
+   * The video should have at least some metadata in the metadata provider,
+   * including:
+   *   * study/series/sop common module for UIDs
+   *   * `cineModule` for information on number of frames and playback rate
+   *   * `imageUrlModule` - to get the URL for the image under the `rendered` attribute
+   *
+   * Without these, other tools requiring metadata wont work, although basic
+   * playback does work if the setVideoURL is used instead.
+   */
+  setVideo: (imageIds: string, imageIdIndex?: number) => Promise<unknown>;
+
+  /**
+   * Displays a raw video, without any metadata associated with it.  Plays back,
+   * but does not permit tools to apply to the viewport, which requires providing
+   * additional metadata for the study.
+   *
+   * @param url - to display
+   */
+  setVideoURL: (url: string) => void;
+
+  play: () => void;
+
+  pause: () => void;
+
+  /**
+   * Reset the viewport properties to the default values
+   */
+  resetProperties(): void;
+
+  /**
+   * Gets the current image id, including frame selction or frameless.
+   */
+  getCurrentImageId(): string;
+
+  /**
+   * Gets the current frame, 1 based
+   */
+  getFrameNumber(): number;
+
+  /**
+   * Sets the current frame
+   */
+  setFrameNumber(frameNo: number);
+
+  /**
+   * Sets the current video time, in seconds
+   */
+  setTime(time: number);
+
+  /**
+   * Sets the range of frames for displaying.  This is the range of frames
+   * that are shown/looped over when the video is playing.
+   * Note that ability to playback a frame range depends on the server
+   * implementing byte range requests, OR the video being easily cached in memory.
+   */
+  setFrameRange(range?: [number, number]);
+
+  getFrameRange(): [number, number];
+
+  /**
+   * Centers Pan and resets the zoom for stack viewport.
+   */
+  resetCamera(resetPan?: boolean, resetZoom?: boolean): boolean;
+}