@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

package/src/metaData.ts

@@ -1,86 +0,0 @@
-// This module defines a way to access various metadata about an imageId.  This layer of abstraction exists
-// So metadata can be provided in different ways (e.g. by parsing DICOM P10 or by a WADO-RS document)
-
-const providers = [];
-
-/**
- * Adds a metadata provider with the specified priority
- * @param provider - Metadata provider function
- * @param priority - 0 is default/normal, > 0 is high, < 0 is low
- *
- * @category MetaData
- */
-export function addProvider(
-  provider: (type: string, ...query: string[]) => any,
-  priority = 0
-): void {
-  let i;
-
-  // Find the right spot to insert this provider based on priority
-  for (i = 0; i < providers.length; i++) {
-    if (providers[i].priority <= priority) {
-      break;
-    }
-  }
-
-  // Insert the decode task at position i
-  providers.splice(i, 0, {
-    priority,
-    provider,
-  });
-}
-
-/**
- * Removes the specified provider
- *
- * @param provider - Metadata provider function
- *
- * @category MetaData
- */
-export function removeProvider(
-  provider: (type: string, query: any) => { any }
-): void {
-  for (let i = 0; i < providers.length; i++) {
-    if (providers[i].provider === provider) {
-      providers.splice(i, 1);
-
-      break;
-    }
-  }
-}
-
-/**
- * Removes all providers
- *
- * @category MetaData
- */
-export function removeAllProviders(): void {
-  while (providers.length > 0) {
-    providers.pop();
-  }
-}
-
-/**
- * Gets metadata from the registered metadata providers.  Will call each one from highest priority to lowest
- * until one responds
- *
- * @param type -  The type of metadata requested from the metadata store
- * @param query - The query for the metadata store, often imageId
- *        Some metadata providers support multi-valued strings, which are interpretted
- *        as the provider chooses.
- *
- * @returns The metadata retrieved from the metadata store
- * @category MetaData
- */
-function getMetaData(type: string, ...queries): any {
-  // Invoke each provider in priority order until one returns something
-  for (let i = 0; i < providers.length; i++) {
-    const result = providers[i].provider(type, ...queries);
-
-    if (result !== undefined) {
-      return result;
-    }
-  }
-}
-
-export { getMetaData as get };

package/src/requestPool/imageLoadPoolManager.ts

@@ -1,43 +0,0 @@
-import { RequestPoolManager } from './requestPoolManager';
-import RequestType from '../enums/RequestType';
-
-/**
- * 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
- * )
- * ```
- */
-const imageLoadPoolManager = new RequestPoolManager('imageLoadPool');
-
-imageLoadPoolManager.grabDelay = 0;
-
-imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Interaction, 1000);
-imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Thumbnail, 1000);
-imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Prefetch, 1000);
-
-export default imageLoadPoolManager;

package/src/requestPool/imageRetrievalPoolManager.ts

@@ -1,25 +0,0 @@
-import { RequestPoolManager } from './requestPoolManager';
-import RequestType from '../enums/RequestType';
-
-/**
- * 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`.
- *
- * Retrieval (usually) === XHR requests
- */
-const imageRetrievalPoolManager = new RequestPoolManager('imageRetrievalPool');
-
-imageRetrievalPoolManager.setMaxSimultaneousRequests(
-  RequestType.Interaction,
-  200
-);
-imageRetrievalPoolManager.setMaxSimultaneousRequests(
-  RequestType.Thumbnail,
-  200
-);
-imageRetrievalPoolManager.setMaxSimultaneousRequests(RequestType.Prefetch, 200);
-imageRetrievalPoolManager.grabDelay = 0;
-
-export default imageRetrievalPoolManager;

package/src/requestPool/requestPoolManager.ts

@@ -1,348 +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,
-    compute: 0,
-  };
-  /* maximum number of requests of each type. */
-  public maxNumRequests: {
-    interaction: number;
-    thumbnail: number;
-    prefetch: number;
-    compute: 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: [] },
-      compute: { 0: [] },
-    };
-
-    this.grabDelay = 5;
-    this.awake = false;
-
-    this.numRequests = {
-      interaction: 0,
-      thumbnail: 0,
-      prefetch: 0,
-      compute: 0,
-    };
-
-    this.maxNumRequests = {
-      interaction: 6,
-      thumbnail: 6,
-      prefetch: 5,
-      // I believe there is a bug right now, where if there are two workers
-      // and one wants to run a compute job 6 times and the limit is just 5, then
-      // the other worker will never get a chance to run its compute job.
-      // we should probably have a separate limit for compute jobs per worker
-      // context as there is another layer of parallelism there. For this reason
-      // I'm setting the limit to 1000 for now.
-      compute: 1000,
-    };
-  }
-
-  /**
-   * 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);
-
-    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];
-    let syncImageCount = 0;
-
-    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;
-
-        let requestResult;
-        try {
-          requestResult = requestDetails.requestFn();
-        } catch (e) {
-          // This is the only warning one will get, so need a warn message
-          console.warn('sendRequest failed', e);
-        }
-        if (requestResult?.finally) {
-          requestResult.finally(() => {
-            this.numRequests[type]--;
-            this.startAgain();
-          });
-        } else {
-          // Handle non-async request functions too - typically just short circuit ones
-          this.numRequests[type]--;
-          syncImageCount++;
-        }
-      }
-    }
-    if (syncImageCount) {
-      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
-    );
-    const hasRemainingComputeRequests = this.sendRequests(RequestType.Compute);
-
-    if (
-      !hasRemainingInteractionRequests &&
-      !hasRemainingThumbnailRequests &&
-      !hasRemainingPrefetchRequests &&
-      !hasRemainingComputeRequests
-    ) {
-      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;
-  }
-}
-
-export { RequestPoolManager };

package/src/types/AABB2.ts

@@ -1,4 +0,0 @@
-// Axis-aligned bounding box 2D
-type AABB2 = { minX: number; maxX: number; minY: number; maxY: number };
-
-export type { AABB2 as default };

package/src/types/AABB3.ts

@@ -1,11 +0,0 @@
-// Axis-aligned bounding box 2D
-type AABB3 = {
-  minX: number;
-  maxX: number;
-  minY: number;
-  maxY: number;
-  minZ: number;
-  maxZ: number;
-};
-
-export type { AABB3 as default };

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/BoundsIJK.ts

@@ -1,5 +0,0 @@
-import type Point2 from './Point2';
-
-type BoundsIJK = [Point2, Point2, Point2];
-
-export default BoundsIJK;

package/src/types/BoundsLPS.ts

@@ -1,5 +0,0 @@
-import type Point2 from './Point3';
-
-type BoundsLPS = [Point2, Point2, Point2];
-
-export default BoundsLPS;

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;