@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.20

package/src/requestPool/requestPoolManager.ts

@@ -1,329 +0,0 @@
-import RequestType from '../enums/RequestType';
-import { IImage } from '../types';
-import { uuidv4 } from '../utilities';
-
-type AdditionalDetails = {
-  imageId?: string;
-  volumeId?: string;
-};
-
-type RequestDetailsInterface = {
-  requestFn: () => Promise<IImage | void>;
-  type: RequestType;
-  additionalDetails: AdditionalDetails;
-};
-
-type RequestPool = {
-  [name in RequestType]: { [key: number]: RequestDetailsInterface[] };
-};
-
-/**
- * RequestPool manager class is a base class that manages the request pools.
- * It is used imageRetrievalPoolManager, and imageLoadPoolManager to retrieve and load images.
- * Previously requestPoolManager was used to manage the retrieval and loading and decoding
- * of the images in a way that new requests were sent after the image was both loaded and decoded
- * which was not performant since it was waiting for the image to be loaded and decoded before
- * sending the next request which is a network request and can be done in parallel.
- * Now, we use separate imageRetrievalPoolManager and imageLoadPoolManager
- * to improve performance and both are extending the RequestPoolManager class which
- * is a basic queueing pool.
- *
- * A new requestPool can be created by instantiating a new RequestPoolManager class.
- *
- * ```javascript
- * const requestPoolManager = new RequestPoolManager()
- * ```
- *
- * ## ImageLoadPoolManager
- *
- * You can use the imageLoadPoolManager to load images, by providing a `requestFn`
- * that returns a promise for the image. You can provide a `type` to specify the type of
- * request (interaction, thumbnail, prefetch), and you can provide additional details
- * that will be passed to the requestFn. Below is an example of a requestFn that loads
- * an image from an imageId:
- *
- * ```javascript
- *
- * const priority = -5
- * const requestType = RequestType.Interaction
- * const additionalDetails = { imageId }
- * const options = {
- *   targetBuffer: {
- *     type: 'Float32Array',
- *     offset: null,
- *     length: null,
- *   },
- *   preScale: {
- *      enabled: true,
- *    },
- * }
- *
- * imageLoadPoolManager.addRequest(
- *   loadAndCacheImage(imageId, options).then(() => { // set on viewport}),
- *   requestType,
- *   additionalDetails,
- *   priority
- * )
- * ```
- * ### ImageRetrievalPoolManager
- * You don't need to directly use the imageRetrievalPoolManager to load images
- * since the imageLoadPoolManager will automatically use it for retrieval. However,
- * maximum number of concurrent requests can be set by calling `setMaxConcurrentRequests`.
- */
-class RequestPoolManager {
-  private id: string;
-  private awake: boolean;
-  private requestPool: RequestPool;
-  private numRequests = {
-    interaction: 0,
-    thumbnail: 0,
-    prefetch: 0,
-  };
-  /* maximum number of requests of each type. */
-  public maxNumRequests: {
-    interaction: number;
-    thumbnail: number;
-    prefetch: number;
-  };
-  /* A public property that is used to set the delay between requests. */
-  public grabDelay: number;
-  private timeoutHandle: number;
-
-  /**
-   * By default a request pool containing three priority groups, one for each
-   * of the request types, is created. Maximum number of requests of each type
-   * is set to 6.
-   */
-  constructor(id?: string) {
-    this.id = id ? id : uuidv4();
-
-    this.requestPool = {
-      interaction: { 0: [] },
-      thumbnail: { 0: [] },
-      prefetch: { 0: [] },
-    };
-
-    this.grabDelay = 5;
-    this.awake = false;
-
-    this.numRequests = {
-      interaction: 0,
-      thumbnail: 0,
-      prefetch: 0,
-    };
-
-    this.maxNumRequests = {
-      interaction: 6,
-      thumbnail: 6,
-      prefetch: 5,
-    };
-  }
-
-  /**
-   * This function sets the maximum number of requests for a given request type.
-   * @param type - The type of request you want to set the max number
-   * of requests for it can be either of interaction, prefetch, or thumbnail.
-   * @param maxNumRequests - The maximum number of requests that can be
-   * made at a time.
-   */
-  public setMaxSimultaneousRequests(
-    type: RequestType,
-    maxNumRequests: number
-  ): void {
-    this.maxNumRequests[type] = maxNumRequests;
-  }
-
-  /**
-   * It returns the maximum number of requests of a given type that can be made
-   * @param type - The type of request.
-   * @returns The maximum number of requests of a given type.
-   */
-  public getMaxSimultaneousRequests(type: RequestType): number {
-    return this.maxNumRequests[type];
-  }
-
-  /**
-   * Stops further fetching of the requests, all the ongoing requests will still
-   * be retrieved
-   */
-  public destroy(): void {
-    if (this.timeoutHandle) {
-      window.clearTimeout(this.timeoutHandle);
-    }
-  }
-
-  /**
-   * Adds the requests to the pool of requests.
-   *
-   * @param requestFn - A function that returns a promise which resolves in the image
-   * @param type - Priority category, it can be either of interaction, prefetch,
-   * or thumbnail.
-   * @param additionalDetails - Additional details that requests can contain.
-   * For instance the volumeId for the volume requests
-   * @param priority - Priority number for each category of requests. Its default
-   * value is priority 0. The lower the priority number, the higher the priority number
-   *
-   */
-  public addRequest(
-    requestFn: () => Promise<IImage | void>,
-    type: RequestType,
-    additionalDetails: Record<string, unknown>,
-    priority = 0
-  ): void {
-    // Describe the request
-    const requestDetails: RequestDetailsInterface = {
-      requestFn,
-      type,
-      additionalDetails,
-    };
-
-    // Check if the priority group exists on the request type
-    if (this.requestPool[type][priority] === undefined) {
-      this.requestPool[type][priority] = [];
-    }
-
-    // Adding the request to the correct priority group of the request type
-    this.requestPool[type][priority].push(requestDetails);
-
-    // Wake up
-    if (!this.awake) {
-      this.awake = true;
-      this.startGrabbing();
-    } else if (type === RequestType.Interaction) {
-      // Todo: this is a hack for interaction right now, we should separate
-      // the grabbing from the adding requests
-      this.startGrabbing();
-    }
-  }
-
-  /**
-   * Filter the requestPoolManager's pool of request based on the result of
-   * provided filter function. The provided filter function needs to return false or true
-   *
-   * @param filterFunction - The filter function for filtering of the requests to keep
-   */
-  public filterRequests(
-    filterFunction: (requestDetails: RequestDetailsInterface) => boolean
-  ): void {
-    Object.keys(this.requestPool).forEach((type: string) => {
-      const requestType = this.requestPool[type];
-      Object.keys(requestType).forEach((priority) => {
-        requestType[priority] = requestType[priority].filter(
-          (requestDetails: RequestDetailsInterface) => {
-            return filterFunction(requestDetails);
-          }
-        );
-      });
-    });
-  }
-
-  /**
-   * Clears the requests specific to the provided type. For instance, the
-   * pool of requests of type 'interaction' can be cleared via this function.
-   *
-   *
-   * @param type - category of the request (either interaction, prefetch or thumbnail)
-   */
-  public clearRequestStack(type: string): void {
-    if (!this.requestPool[type]) {
-      throw new Error(`No category for the type ${type} found`);
-    }
-    this.requestPool[type] = { 0: [] };
-  }
-
-  private sendRequests(type) {
-    const requestsToSend = this.maxNumRequests[type] - this.numRequests[type];
-
-    for (let i = 0; i < requestsToSend; i++) {
-      const requestDetails = this.getNextRequest(type);
-      if (requestDetails === null) {
-        return false;
-      } else if (requestDetails) {
-        this.numRequests[type]++;
-        this.awake = true;
-
-        requestDetails.requestFn().finally(() => {
-          this.numRequests[type]--;
-          this.startAgain();
-        });
-      }
-    }
-
-    return true;
-  }
-
-  private getNextRequest(type): RequestDetailsInterface | null {
-    const interactionPriorities = this.getSortedPriorityGroups(type);
-    for (const priority of interactionPriorities) {
-      if (this.requestPool[type][priority].length) {
-        return this.requestPool[type][priority].shift();
-      }
-    }
-
-    return null;
-  }
-
-  protected startGrabbing(): void {
-    const hasRemainingInteractionRequests = this.sendRequests(
-      RequestType.Interaction
-    );
-    const hasRemainingThumbnailRequests = this.sendRequests(
-      RequestType.Thumbnail
-    );
-    const hasRemainingPrefetchRequests = this.sendRequests(
-      RequestType.Prefetch
-    );
-
-    if (
-      !hasRemainingInteractionRequests &&
-      !hasRemainingThumbnailRequests &&
-      !hasRemainingPrefetchRequests
-    ) {
-      this.awake = false;
-    }
-  }
-
-  protected startAgain(): void {
-    if (!this.awake) {
-      return;
-    }
-
-    if (this.grabDelay !== undefined) {
-      // Prevents calling setTimeout hundreds of times when hundreds of requests
-      // are added which make it slower and works in an unexpected way when
-      // destroy/clearTimeout is called because only the last handle is stored.
-      if (!this.timeoutHandle) {
-        this.timeoutHandle = window.setTimeout(() => {
-          this.timeoutHandle = null;
-          this.startGrabbing();
-        }, this.grabDelay);
-      }
-    } else {
-      this.startGrabbing();
-    }
-  }
-
-  protected getSortedPriorityGroups(type: string): Array<number> {
-    const priorities = Object.keys(this.requestPool[type])
-      .map(Number)
-      .filter((priority) => this.requestPool[type][priority].length)
-      .sort((a, b) => a - b);
-    return priorities;
-  }
-
-  /**
-   * Returns the request pool containing different categories, their priority and
-   * the added request details.
-   *
-   * @returns the request pool which contains different categories, their priority and
-   * the added request details
-   */
-  getRequestPool(): RequestPool {
-    return this.requestPool;
-  }
-}
-
-const requestPoolManager = new RequestPoolManager();
-
-export { RequestPoolManager };
-export default requestPoolManager;

package/src/types/ActorSliceRange.ts

@@ -1,17 +0,0 @@
-import { VolumeActor } from './IActor';
-import Point3 from './Point3';
-
-/**
- * Object containing the min, max and current position in the normal direction
- * for the actor
- */
-type ActorSliceRange = {
-  actor: VolumeActor;
-  viewPlaneNormal: Point3;
-  focalPoint: Point3;
-  min: number;
-  max: number;
-  current: number;
-};
-
-export default ActorSliceRange;

package/src/types/AffineMatrix.ts

@@ -1,8 +0,0 @@
-type AffineMatrix = [
-  [number, number, number, number],
-  [number, number, number, number],
-  [number, number, number, number],
-  [number, number, number, number]
-];
-
-export type { AffineMatrix };

package/src/types/CPUFallbackColormap.ts

@@ -1,23 +0,0 @@
-import Point4 from './Point4';
-import CPUFallbackLookupTable from './CPUFallbackLookupTable';
-
-interface CPUFallbackColormap {
-  /** Get id of colormap */
-  getId: () => string;
-  getColorSchemeName: () => string;
-  setColorSchemeName: (name: string) => void;
-  getNumberOfColors: () => number;
-  setNumberOfColors: (numColors: number) => void;
-  getColor: (index: number) => Point4;
-  getColorRepeating: (index: number) => Point4;
-  setColor: (index: number, rgba: Point4) => void;
-  addColor: (rgba: Point4) => void;
-  insertColor: (index: number, rgba: Point4) => void;
-  removeColor: (index: number) => void;
-  clearColors: () => void;
-  buildLookupTable: (lut: CPUFallbackLookupTable) => void;
-  createLookupTable: () => CPUFallbackLookupTable;
-  isValidIndex: (index: number) => boolean;
-}
-
-export default CPUFallbackColormap;

package/src/types/CPUFallbackColormapData.ts

@@ -1,12 +0,0 @@
-import Point4 from './Point4';
-
-type CPUFallbackColormapData = {
-  name: string;
-  numOfColors?: number;
-  colors?: Point4[];
-  segmentedData?: unknown;
-  numColors?: number;
-  gamma?: number;
-};
-
-export default CPUFallbackColormapData;

package/src/types/CPUFallbackColormapsData.ts

@@ -1,7 +0,0 @@
-import CPUFallbackColormapData from './CPUFallbackColormapData';
-
-type CPUFallbackColormapsData = {
-  [key: string]: CPUFallbackColormapData;
-};
-
-export default CPUFallbackColormapsData;

package/src/types/CPUFallbackEnabledElement.ts

@@ -1,41 +0,0 @@
-import Point2 from './Point2';
-import Point3 from './Point3';
-import Mat3 from './Mat3';
-import IImage from './IImage';
-import CPUFallbackViewport from './CPUFallbackViewport';
-import CPUFallbackTransform from './CPUFallbackTransform';
-import CPUFallbackColormap from './CPUFallbackColormap';
-import CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
-import { ImagePlaneModule } from './ImagePlaneModule';
-import { ImagePixelModule } from './ImagePixelModule';
-
-interface CPUFallbackEnabledElement {
-  scale?: number;
-  pan?: Point2;
-  zoom?: number;
-  rotation?: number;
-  image?: IImage;
-  canvas?: HTMLCanvasElement;
-  viewport?: CPUFallbackViewport;
-  colormap?: CPUFallbackColormap;
-  options?: {
-    [key: string]: unknown;
-    colormap?: CPUFallbackColormap;
-  };
-  renderingTools?: CPUFallbackRenderingTools;
-  transform?: CPUFallbackTransform;
-  invalid?: boolean;
-  needsRedraw?: boolean;
-  metadata?: {
-    direction?: Mat3;
-    /** Last index is always 1 for CPU */
-    dimensions?: Point3;
-    /** Last spacing is always EPSILON for CPU */
-    spacing?: Point3;
-    origin?: Point3;
-    imagePlaneModule?: ImagePlaneModule;
-    imagePixelModule?: ImagePixelModule;
-  };
-}
-
-export default CPUFallbackEnabledElement;

package/src/types/CPUFallbackLUT.ts

@@ -1,5 +0,0 @@
-type CPUFallbackLUT = {
-  lut: number[];
-};
-
-export default CPUFallbackLUT;

package/src/types/CPUFallbackLookupTable.ts

@@ -1,17 +0,0 @@
-import Point4 from './Point4';
-
-interface CPUFallbackLookupTable {
-  setNumberOfTableValues: (number: number) => void;
-  setRamp: (ramp: string) => void;
-  setTableRange: (start: number, end: number) => void;
-  setHueRange: (start: number, end: number) => void;
-  setSaturationRange: (start: number, end: number) => void;
-  setValueRange: (start: number, end: number) => void;
-  setRange: (start: number, end: number) => void;
-  setAlphaRange: (start: number, end: number) => void;
-  getColor: (scalar: number) => Point4;
-  build: (force: boolean) => void;
-  setTableValue(index: number, rgba: Point4);
-}
-
-export default CPUFallbackLookupTable;

package/src/types/CPUFallbackRenderingTools.ts

@@ -1,25 +0,0 @@
-import CPUFallbackLookupTable from './CPUFallbackLookupTable';
-import CPUFallbackLUT from './CPUFallbackLUT';
-
-type CPUFallbackRenderingTools = {
-  renderCanvas?: HTMLCanvasElement;
-  lastRenderedIsColor?: boolean;
-  lastRenderedImageId?: string;
-  lastRenderedViewport?: {
-    windowWidth: number | number[];
-    windowCenter: number | number[];
-    invert: boolean;
-    rotation: number;
-    hflip: boolean;
-    vflip: boolean;
-    modalityLUT: CPUFallbackLUT;
-    voiLUT: CPUFallbackLUT;
-    colormap: unknown;
-  };
-  renderCanvasContext?: CanvasRenderingContext2D;
-  colormapId?: string;
-  colorLUT?: CPUFallbackLookupTable;
-  renderCanvasData?: ImageData;
-};
-
-export default CPUFallbackRenderingTools;

package/src/types/CPUFallbackTransform.ts

@@ -1,16 +0,0 @@
-import Point2 from './Point2';
-import TransformMatrix2D from './TransformMatrix2D';
-
-interface CPUFallbackTransform {
-  reset: () => void;
-  clone: () => CPUFallbackTransform;
-  multiply: (matrix: TransformMatrix2D) => void;
-  getMatrix: () => TransformMatrix2D;
-  invert: () => void;
-  rotate: (rad: number) => void;
-  translate: (x: number, y: number) => void;
-  scale: (sx: number, sy: number) => void;
-  transformPoint: (point: Point2) => Point2;
-}
-
-export default CPUFallbackTransform;

package/src/types/CPUFallbackViewport.ts

@@ -1,29 +0,0 @@
-import CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
-import CPUFallbackColormap from './CPUFallbackColormap';
-import CPUFallbackLUT from './CPUFallbackLUT';
-
-type CPUFallbackViewport = {
-  scale?: number;
-  parallelScale?: number;
-  focalPoint?: number[];
-  translation?: {
-    x: number;
-    y: number;
-  };
-  voi?: {
-    windowWidth: number;
-    windowCenter: number;
-  };
-  invert?: boolean;
-  pixelReplication?: boolean;
-  rotation?: number;
-  hflip?: boolean;
-  vflip?: boolean;
-  modalityLUT?: CPUFallbackLUT;
-  voiLUT?: CPUFallbackLUT;
-  colormap?: CPUFallbackColormap;
-  displayedArea?: CPUFallbackViewportDisplayedArea;
-  modality?: string;
-};
-
-export default CPUFallbackViewport;

package/src/types/CPUFallbackViewportDisplayedArea.ts

@@ -1,15 +0,0 @@
-type CPUFallbackViewportDisplayedArea = {
-  tlhc: {
-    x: number;
-    y: number;
-  };
-  brhc: {
-    x: number;
-    y: number;
-  };
-  rowPixelSpacing: number;
-  columnPixelSpacing: number;
-  presentationSizeMode: string;
-};
-
-export default CPUFallbackViewportDisplayedArea;

package/src/types/CPUIImageData.ts

@@ -1,50 +0,0 @@
-import { Point3, Scaling, Mat3, PixelDataTypedArray } from '../types';
-import IImageCalibration from './IImageCalibration';
-
-type CPUImageData = {
-  worldToIndex?: (point: Point3) => Point3;
-  indexToWorld?: (point: Point3) => Point3;
-  getWorldToIndex?: () => Point3;
-  getIndexToWorld?: () => Point3;
-  /** Last spacing is always EPSILON */
-  getSpacing?: () => Point3;
-  getDirection?: () => Mat3;
-  getScalarData?: () => PixelDataTypedArray;
-  /** Last index is always 1 */
-  getDimensions?: () => Point3;
-};
-
-type CPUIImageData = {
-  dimensions: Point3;
-  direction: Mat3;
-  spacing: Point3;
-  origin: Point3;
-  imageData: CPUImageData;
-  metadata: { Modality: string };
-  scalarData: PixelDataTypedArray;
-  scaling: Scaling;
-  /** whether the image has pixel spacing and it is not undefined */
-  hasPixelSpacing?: boolean;
-  calibration?: IImageCalibration;
-
-  /** 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 CPUIImageData;
-
-export { CPUImageData };

package/src/types/Colormap.ts

@@ -1,31 +0,0 @@
-import RGB from './RGB';
-
-type ColormapRegistration = {
-  ColorSpace: string;
-  Name: string;
-  RGBPoints: RGB[];
-};
-
-type OpacityMapping = {
-  /** value to map to opacity */
-  value: number;
-  /** opacity value */
-  opacity: number;
-};
-
-type ColormapPublic = {
-  /** name of the colormap */
-  name?: string;
-  opacity?: OpacityMapping[] | number;
-  /** midpoint mapping between values to opacity if the colormap
-   * is getting used for fusion, this is an array of arrays which
-   * each array containing 2 values, the first value is the value
-   * to map to opacity and the second value is the opacity value.
-   * By default, the minimum value is mapped to 0 opacity and the
-   * maximum value is mapped to 1 opacity, but you can configure
-   * the points in the middle to be mapped to different opacities
-   * instead of a linear mapping from 0 to 1.
-   */
-};
-
-export type { ColormapRegistration, ColormapPublic, OpacityMapping };

package/src/types/ContourData.ts

@@ -1,21 +0,0 @@
-import { ContourType } from '../enums';
-import Point3 from './Point3';
-
-type PublicContourSetData = ContourSetData;
-
-type ContourSetData = {
-  id: string;
-  data: ContourData[];
-  frameOfReferenceUID: string;
-  color?: Point3;
-  segmentIndex?: number;
-};
-
-type ContourData = {
-  points: Point3[];
-  type: ContourType;
-  color: Point3;
-  segmentIndex: number;
-};
-
-export type { PublicContourSetData, ContourSetData, ContourData };