@cornerstonejs/core 0.36.3 → 0.36.4

package/src/types/EventTypes.ts

@@ -0,0 +1,403 @@
+import type { mat4 } from 'gl-matrix';
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type CustomEventType from '../types/CustomEventType';
+import type ICachedImage from './ICachedImage';
+import type ICachedVolume from './ICachedVolume';
+import type ICamera from './ICamera';
+import type IImage from './IImage';
+import type IImageVolume from './IImageVolume';
+import type { VOIRange } from './voi';
+import type VOILUTFunctionType from '../enums/VOILUTFunctionType';
+/**
+ * CAMERA_MODIFIED Event's data
+ */
+type CameraModifiedEventDetail = {
+  /** Previous camera properties */
+  previousCamera: ICamera;
+  /** Current camera properties */
+  camera: ICamera;
+  /** Viewport HTML element in the DOM */
+  element: HTMLDivElement;
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** Unique ID for the renderingEngine */
+  renderingEngineId: string;
+  /** Rotation Optional */
+  rotation?: number;
+};
+
+/**
+ * VOI_MODIFIED Event's data
+ */
+type VoiModifiedEventDetail = {
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** new VOI range */
+  range: VOIRange;
+  /** Unique ID for the volume in the cache */
+  volumeId?: string;
+  /** VOILUTFunction */
+  VOILUTFunction?: VOILUTFunctionType;
+};
+
+/**
+ * ELEMENT_DISABLED Event's data
+ */
+type ElementDisabledEventDetail = {
+  /** Viewport HTML element in the DOM */
+  element: HTMLDivElement;
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** Unique ID for the renderingEngine */
+  renderingEngineId: string;
+};
+
+/**
+ * ELEMENT_Enabled Event's data
+ */
+type ElementEnabledEventDetail = {
+  /** Viewport HTML element in the DOM */
+  element: HTMLDivElement;
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** Unique ID for the renderingEngine */
+  renderingEngineId: string;
+};
+
+/**
+ * IMAGE_RENDERED Event's data
+ */
+type ImageRenderedEventDetail = {
+  /** Viewport HTML element in the DOM */
+  element: HTMLDivElement;
+  /** Viewport Unique ID in the renderingEngine */
+  viewportId: string;
+  /** Unique ID for the renderingEngine */
+  renderingEngineId: string;
+  /** Whether to suppress the event */
+  suppressEvents?: boolean;
+};
+/**
+ * IMAGE_VOLUME_MODIFIED Event's data
+ */
+type ImageVolumeModifiedEventDetail = {
+  /** the modified volume */
+  imageVolume: IImageVolume;
+  /** FrameOfReferenceUID where the volume belongs to */
+  FrameOfReferenceUID: string;
+};
+
+/**
+ * IMAGE_LOADED Event's data
+ */
+type ImageLoadedEventDetail = {
+  /** the loaded image */
+  image: IImage;
+};
+
+/**
+ * IMAGE_LOADED_FAILED Event's data
+ */
+type ImageLoadedFailedEventDetail = {
+  /** the imageId for the image */
+  imageId: string;
+  error: unknown;
+};
+
+/**
+ * VOLUME_LOADED Event's data
+ */
+type VolumeLoadedEventDetail = {
+  /** the loaded volume */
+  volume: IImageVolume;
+};
+
+/**
+ * VOLUME_LOADED_FAILED Event's data
+ */
+type VolumeLoadedFailedEventDetail = {
+  /** the volumeId for the volume */
+  volumeId: string;
+  error: unknown;
+};
+
+/**
+ * IMAGE_CACHE_IMAGE_REMOVED Event's data
+ */
+type ImageCacheImageRemovedEventDetail = {
+  /** the removed image id */
+  imageId: string;
+};
+
+/**
+ * IMAGE_CACHE_IMAGE_ADDED Event's data
+ */
+type ImageCacheImageAddedEventDetail = {
+  /** the added image */
+  image: ICachedImage;
+};
+
+/**
+ * VOLUME_CACHE_VOLUME_REMOVED Event's data
+ */
+type VolumeCacheVolumeRemovedEventDetail = {
+  /** the removed volume id */
+  volumeId: string;
+};
+
+/**
+ * VOLUME_CACHE_VOLUME_ADDED Event's data
+ */
+type VolumeCacheVolumeAddedEventDetail = {
+  /** the added volume */
+  volume: ICachedVolume;
+};
+
+/**
+ * PRE_STACK_NEW_IMAGE Event's data
+ */
+type PreStackNewImageEventDetail = {
+  /** the image imageId */
+  imageId: string;
+  /** the index of imageId in the stack */
+  imageIdIndex: number;
+  /** unique id for the viewport */
+  viewportId: string;
+  /** unique id for the renderingEngine */
+  renderingEngineId: string;
+};
+
+/**
+ * STACK_NEW_IMAGE Event's data
+ */
+type StackNewImageEventDetail = {
+  /** the new image set on the stack viewport */
+  image: IImage;
+  /** the image imageId */
+  imageId: string;
+  /** the index of imageId in the stack */
+  imageIdIndex: number;
+  /** unique id for the viewport */
+  viewportId: string;
+  /** unique id for the renderingEngine */
+  renderingEngineId: string;
+};
+
+/**
+ * VOLUME_NEW_IMAGE Event's data
+ */
+type VolumeNewImageEventDetail = {
+  /** image index */
+  imageIndex: number;
+  /** number of slices */
+  numberOfSlices: number;
+  /** unique id for the viewport */
+  viewportId: string;
+  /** unique id for the renderingEngine */
+  renderingEngineId: string;
+};
+
+/**
+ * IMAGE_SPACING_CALIBRATED Event's data
+ */
+type ImageSpacingCalibratedEventDetail = {
+  element: HTMLDivElement;
+  viewportId: string;
+  renderingEngineId: string;
+  imageId: string;
+  rowScale: number;
+  columnScale: number;
+  imageData: vtkImageData;
+  worldToIndex: mat4;
+};
+
+/**
+ * IMAGE_LOAD_PROGRESS Event's data. Note this is only for one image load and NOT volume load.
+ */
+type ImageLoadProgressEventDetail = {
+  /** url we are loading from */
+  url: string;
+  /** loading image image id */
+  imageId: string;
+  /** the bytes browser receive */
+  loaded: number;
+  /** the total bytes settled by the header */
+  total: number;
+  /** loaded divided by total * 100 - shows the percentage of the image loaded */
+  percent: number;
+};
+
+/**
+ * The STACK_VIEWPORT_NEW_STACK event's data, when a new stack is set on a StackViewport
+ */
+type StackViewportNewStackEventDetail = {
+  imageIds: string[];
+  viewportId: string;
+  element: HTMLDivElement;
+  currentImageIdIndex: number;
+};
+
+/**
+ * Stack Scroll event detail
+ */
+type StackViewportScrollEventDetail = {
+  /** the new imageId index in the stack that we just scroll to */
+  newImageIdIndex: number;
+  /** the new imageId in the stack that we just scroll to */
+  imageId: string;
+  /** direction of the scroll */
+  direction: number;
+};
+
+/**
+ * CameraModified Event type
+ */
+type CameraModifiedEvent = CustomEventType<CameraModifiedEventDetail>;
+
+/**
+ * VOI_MODIFIED Event type
+ */
+type VoiModifiedEvent = CustomEventType<VoiModifiedEventDetail>;
+
+/**
+ * ELEMENT_DISABLED Event type
+ */
+type ElementDisabledEvent = CustomEventType<ElementDisabledEventDetail>;
+
+/**
+ * ELEMENT_ENABLED Event type
+ */
+type ElementEnabledEvent = CustomEventType<ElementEnabledEventDetail>;
+
+/**
+ * IMAGE_RENDERED Event type
+ */
+type ImageRenderedEvent = CustomEventType<ElementEnabledEventDetail>;
+
+/**
+ * IMAGE_VOLUME_MODIFIED Event type
+ */
+type ImageVolumeModifiedEvent = CustomEventType<ImageVolumeModifiedEventDetail>;
+
+/**
+ * IMAGE_LOADED Event type
+ */
+type ImageLoadedEvent = CustomEventType<ImageLoadedEventDetail>;
+
+/**
+ * IMAGE_LOADED_FAILED Event type
+ */
+type ImageLoadedFailedEvent = CustomEventType<ImageLoadedFailedEventDetail>;
+
+/**
+ * VOLUME_LOADED Event type
+ */
+type VolumeLoadedEvent = CustomEventType<VolumeLoadedEventDetail>;
+
+/**
+ * VOLUME_LOADED_FAILED Event type
+ */
+type VolumeLoadedFailedEvent = CustomEventType<VolumeLoadedFailedEventDetail>;
+
+/**
+ * IMAGE_CACHE_IMAGE_ADDED Event type
+ */
+type ImageCacheImageAddedEvent =
+  CustomEventType<ImageCacheImageAddedEventDetail>;
+
+/**
+ * IMAGE_CACHE_IMAGE_REMOVED Event type
+ */
+type ImageCacheImageRemovedEvent =
+  CustomEventType<ImageCacheImageRemovedEventDetail>;
+
+/**
+ * VOLUME_CACHE_VOLUME_ADDED Event type
+ */
+type VolumeCacheVolumeAddedEvent =
+  CustomEventType<VolumeCacheVolumeAddedEventDetail>;
+
+/**
+ * VOLUME_CACHE_VOLUME_REMOVED Event type
+ */
+type VolumeCacheVolumeRemovedEvent =
+  CustomEventType<VolumeCacheVolumeRemovedEventDetail>;
+
+/**
+ * START_NEW_IMAGE
+ */
+type StackNewImageEvent = CustomEventType<StackNewImageEventDetail>;
+
+/**
+ * VOLUME_NEW_IMAGE
+ */
+type VolumeNewImageEvent = CustomEventType<VolumeNewImageEventDetail>;
+
+/**
+ * START_NEW_IMAGE
+ */
+type PreStackNewImageEvent = CustomEventType<PreStackNewImageEventDetail>;
+
+/**
+ * IMAGE_SPACING_CALIBRATED
+ */
+type ImageSpacingCalibratedEvent =
+  CustomEventType<ImageSpacingCalibratedEventDetail>;
+
+/**
+ * IMAGE_LOAD_PROGRESS
+ */
+type ImageLoadProgressEvent = CustomEventType<ImageLoadProgressEventDetail>;
+
+/**
+ * STACK_VIEWPORT_NEW_STACK
+ */
+type StackViewportNewStackEvent =
+  CustomEventType<StackViewportNewStackEventDetail>;
+
+type StackViewportScrollEvent = CustomEventType<StackViewportScrollEventDetail>;
+
+export type {
+  CameraModifiedEventDetail,
+  CameraModifiedEvent,
+  VoiModifiedEvent,
+  VoiModifiedEventDetail,
+  ElementDisabledEvent,
+  ElementDisabledEventDetail,
+  ElementEnabledEvent,
+  ElementEnabledEventDetail,
+  ImageRenderedEventDetail,
+  ImageRenderedEvent,
+  ImageVolumeModifiedEvent,
+  ImageVolumeModifiedEventDetail,
+  ImageLoadedEvent,
+  ImageLoadedEventDetail,
+  ImageLoadedFailedEventDetail,
+  ImageLoadedFailedEvent,
+  VolumeLoadedEvent,
+  VolumeLoadedEventDetail,
+  VolumeLoadedFailedEvent,
+  VolumeLoadedFailedEventDetail,
+  ImageCacheImageAddedEvent,
+  ImageCacheImageAddedEventDetail,
+  ImageCacheImageRemovedEvent,
+  ImageCacheImageRemovedEventDetail,
+  VolumeCacheVolumeAddedEvent,
+  VolumeCacheVolumeAddedEventDetail,
+  VolumeCacheVolumeRemovedEvent,
+  VolumeCacheVolumeRemovedEventDetail,
+  StackNewImageEvent,
+  StackNewImageEventDetail,
+  PreStackNewImageEvent,
+  PreStackNewImageEventDetail,
+  ImageSpacingCalibratedEvent,
+  ImageSpacingCalibratedEventDetail,
+  ImageLoadProgressEvent,
+  ImageLoadProgressEventDetail,
+  VolumeNewImageEvent,
+  VolumeNewImageEventDetail,
+  StackViewportNewStackEvent,
+  StackViewportNewStackEventDetail,
+  StackViewportScrollEvent,
+  StackViewportScrollEventDetail,
+};

package/src/types/FlipDirection.ts

@@ -0,0 +1,9 @@
+/**
+ * Flip direction which can be horizontal or vertical.
+ */
+type FlipDirection = {
+  flipHorizontal?: boolean;
+  flipVertical?: boolean;
+};
+
+export default FlipDirection;

package/src/types/IActor.ts

@@ -0,0 +1,23 @@
+import type vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+
+export type Actor = vtkActor;
+export type VolumeActor = vtkVolume;
+export type ImageActor = vtkImageSlice;
+
+/**
+ * Cornerstone Actor Entry including actor uid, actual Actor, and
+ * slabThickness for the actor. ActorEntry is the object that
+ * is retrieved from viewport when calling viewport.getActor(s)
+ */
+export type ActorEntry = {
+  /** actor UID */
+  uid: string;
+  /** actual actor object */
+  actor: Actor | VolumeActor | ImageActor;
+  /** the id of the reference volume from which this actor is derived or created*/
+  referenceId?: string;
+  /** slab thickness for the actor */
+  slabThickness?: number;
+};

package/src/types/ICache.ts

@@ -0,0 +1,28 @@
+import { IImageLoadObject, IVolumeLoadObject } from './ILoadObject';
+
+interface ICache {
+  /** Set the maximum cache size  */
+  setMaxCacheSize: (maxCacheSize: number) => void;
+  /** Get the maximum cache size  */
+  getMaxCacheSize: () => number;
+  /** Get the current cache size  */
+  getCacheSize: () => number;
+  /** Stores the imageLoad Object inside the cache */
+  putImageLoadObject: (
+    imageId: string,
+    imageLoadObject: IImageLoadObject
+  ) => Promise<any>;
+  /** Retrieves the imageLoad Object from the cache */
+  getImageLoadObject: (imageId: string) => IImageLoadObject | void;
+  /** Stores the volumeLoad Object inside the cache */
+  putVolumeLoadObject: (
+    volumeId: string,
+    volumeLoadObject: IVolumeLoadObject
+  ) => Promise<any>;
+  /** Retrieves the volumeLoad Object from the cache */
+  getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject | void;
+  /** Purge cache both image and volume */
+  purgeCache: () => void;
+}
+
+export default ICache;

package/src/types/ICachedGeometry.ts

@@ -0,0 +1,13 @@
+import IGeometry from './IGeometry';
+import { IGeometryLoadObject } from './ILoadObject';
+
+interface ICachedGeometry {
+  geometryId: string;
+  geometryLoadObject: IGeometryLoadObject;
+  loaded: boolean;
+  timeStamp: number;
+  sizeInBytes: number;
+  geometry?: IGeometry;
+}
+
+export default ICachedGeometry;

package/src/types/ICachedImage.ts

@@ -0,0 +1,13 @@
+import { IImage, IImageLoadObject } from '../types';
+
+interface ICachedImage {
+  image?: IImage;
+  imageId: string;
+  imageLoadObject: IImageLoadObject;
+  loaded: boolean;
+  sharedCacheKey?: string;
+  timeStamp: number;
+  sizeInBytes: number;
+}
+
+export default ICachedImage;

package/src/types/ICachedVolume.ts

@@ -0,0 +1,12 @@
+import { IImageVolume, IVolumeLoadObject } from '../types';
+
+interface ICachedVolume {
+  volume?: IImageVolume;
+  volumeId: string;
+  volumeLoadObject: IVolumeLoadObject;
+  loaded: boolean;
+  timeStamp: number;
+  sizeInBytes: number;
+}
+
+export default ICachedVolume;

package/src/types/ICamera.ts

@@ -0,0 +1,36 @@
+import Point3 from './Point3';
+import Point2 from './Point2';
+
+/**
+ * Camera Interface. See {@link https://kitware.github.io/vtk-examples/site/VTKBook/03Chapter3/#35-cameras} if you
+ * want to know more about the camera.
+ */
+interface ICamera {
+  /** Camera Focal point */
+  focalPoint?: Point3;
+  /** Camera Parallel Projection flag - whether camera is using parallel projection */
+  parallelProjection?: boolean;
+  /** Camera parallel scale - used for parallel projection zoom, smaller values zoom in */
+  parallelScale?: number;
+  /**
+   * Scale factor for the camera, it is the ratio of how much an image pixel takes
+   * up one screen pixel
+   */
+  scale?: number;
+  /** Camera position */
+  position?: Point3;
+  /** Camera view angle - 90 degrees is orthographic */
+  viewAngle?: number;
+  /** Camera viewPlaneNormal - negative of the direction the camera is pointing or directionOfProjection*/
+  viewPlaneNormal?: Point3;
+  /** Camera viewUp - the direction of viewUP in camera */
+  viewUp?: Point3;
+  /** flip Horizontal */
+  flipHorizontal?: boolean;
+  /** flip Vertical */
+  flipVertical?: boolean;
+  /** clipping range */
+  clippingRange?: Point2;
+}
+
+export default ICamera;

package/src/types/IContour.ts

@@ -0,0 +1,18 @@
+import { Point3 } from '.';
+import { ContourType } from '../enums';
+
+export interface IContour {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  points: Point3[];
+  color: any;
+  _getSizeInBytes(): number;
+  /**
+   * It returns the value of the points property of the data object
+   * @returns The points property of the data object.
+   */
+  getPoints(): Point3[];
+  getColor(): Point3;
+  getType(): ContourType;
+  getFlatPointsArray(): number[];
+}

package/src/types/IContourSet.ts

@@ -0,0 +1,56 @@
+import { ContourData, IContour, Point3 } from './';
+
+/**
+ * This class represents a set of contours in 3d space.
+ * Usually contours are grouped together in a contour set to represent a meaningful shape.
+ */
+export interface IContourSet {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  readonly frameOfReferenceUID: string;
+  contours: IContour[];
+  _createEachContour(data: ContourData[]): void;
+  getSizeInBytes(): number;
+  getColor(): any;
+  /**
+   * This function returns the contours of the image
+   * @returns The contours of the image.
+   */
+  getContours(): IContour[];
+  /**
+   * It returns an array of all the points in the glyph
+   * @returns An array of points.
+   */
+  getFlatPointsArray(): Point3[];
+  /**
+   * This function returns the number of contours in the current shape.
+   * @returns The number of contours in the glyph.
+   */
+  getNumberOfContours(): number;
+  /**
+   * It loops through each contour in the `contours` array, and adds the number of
+   * points in each contour to the `numberOfPoints` variable
+   * @returns The number of points in the contours.
+   */
+  getTotalNumberOfPoints(): number;
+  /**
+   * It returns an array of the number of points in each contour.
+   * @returns An array of numbers.
+   */
+  getNumberOfPointsArray(): number[];
+  /**
+   * It returns the points in a contour.
+   * @param contourIndex - The index of the contour you want to get the
+   * points from.
+   * @returns An array of Point3 objects.
+   */
+  getPointsInContour(contourIndex: number): Point3[];
+  /**
+   * "This function returns the number of points in a contour."
+   *
+   * @param contourIndex - The index of the contour you want to get the
+   * number of points from.
+   * @returns The number of points in the contour.
+   */
+  getNumberOfPointsInAContour(contourIndex: number): number;
+}

package/src/types/IDynamicImageVolume.ts

@@ -0,0 +1,18 @@
+import { IImageVolume, VolumeScalarData } 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 IDynamicImageVolume extends IImageVolume {
+  /** Returns the active time point index */
+  get timePointIndex(): number;
+  /** Set the active time point index which also updates the active scalar data */
+  set timePointIndex(newTimePointIndex: number);
+  /** Returns the number of time points */
+  get numTimePoints(): number;
+  /** return scalar data arrays (one per timepoint) */
+  getScalarDataArrays(): VolumeScalarData[];
+}
+
+export default IDynamicImageVolume;

package/src/types/IEnabledElement.ts

@@ -0,0 +1,21 @@
+import type { IRenderingEngine } from '../types';
+import type IStackViewport from './IStackViewport';
+import type IVolumeViewport from './IVolumeViewport';
+
+/**
+ * Cornerstone Enabled Element interface
+ */
+interface IEnabledElement {
+  /** Cornerstone Viewport instance - can be Stack or Volume Viewport as of now */
+  viewport: IStackViewport | IVolumeViewport;
+  /** Cornerstone Rendering Engine instance */
+  renderingEngine: IRenderingEngine;
+  /** Unique ID of the viewport in the renderingEngine */
+  viewportId: string;
+  /** Unique ID of the renderingEngine */
+  renderingEngineId: string;
+  /** FrameOfReference the enabledElement is rendering inside */
+  FrameOfReferenceUID: string;
+}
+
+export default IEnabledElement;

package/src/types/IGeometry.ts

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