@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

package/src/types/index.ts

@@ -1,254 +0,0 @@
-// @see: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#-type-only-imports-and-export
-import type Cornerstone3DConfig from './Cornerstone3DConfig';
-import type ICamera from './ICamera';
-import type IEnabledElement from './IEnabledElement';
-import type ICache from './ICache';
-import type { IVolume } from './IVolume';
-import type { VOI, VOIRange } from './voi';
-import type DisplayArea from './displayArea';
-import type ImageLoaderFn from './ImageLoaderFn';
-import type IImageVolume from './IImageVolume';
-import type IDynamicImageVolume from './IDynamicImageVolume';
-import type VolumeLoaderFn from './VolumeLoaderFn';
-import type IRegisterImageLoader from './IRegisterImageLoader';
-import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
-import type CustomEventType from './CustomEventType';
-import type {
-  IViewport,
-  PublicViewportInput,
-  ViewReferenceSpecifier,
-  ReferenceCompatibleOptions,
-  ViewReference,
-  ViewPresentation,
-  ViewPresentationSelector,
-} from './IViewport';
-import type {
-  VolumeActor,
-  Actor,
-  ActorEntry,
-  ImageActor,
-  ICanvasActor,
-} from './IActor';
-import type {
-  IImageLoadObject,
-  IVolumeLoadObject,
-  IGeometryLoadObject,
-} from './ILoadObject';
-import type Metadata from './Metadata';
-import type OrientationVectors from './OrientationVectors';
-import type AABB2 from './AABB2';
-import type AABB3 from './AABB3';
-import type Point2 from './Point2';
-import type Point3 from './Point3';
-import type Point4 from './Point4';
-import type { PointsXYZ } from './Point3';
-import type Mat3 from './Mat3';
-import type Plane from './Plane';
-import type IStreamingImageVolume from './IStreamingImageVolume';
-import type ViewportInputOptions from './ViewportInputOptions';
-import type IImageData from './IImageData';
-import type IImageCalibration from './IImageCalibration';
-import type CPUIImageData from './CPUIImageData';
-import type { CPUImageData } from './CPUIImageData';
-import type IImage from './IImage';
-import type {
-  PTScaling,
-  Scaling,
-  ScalingParameters,
-} from './ScalingParameters';
-import type StackViewportProperties from './StackViewportProperties';
-import type VolumeViewportProperties from './VolumeViewportProperties';
-import type IViewportId from './IViewportId';
-import type FlipDirection from './FlipDirection';
-import type ICachedImage from './ICachedImage';
-import type ICachedVolume from './ICachedVolume';
-import type IStackViewport from './IStackViewport';
-import type IVolumeViewport from './IVolumeViewport';
-import type ViewportPreset from './ViewportPreset';
-
-// CPU types
-import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
-import type CPUFallbackViewport from './CPUFallbackViewport';
-import type CPUFallbackTransform from './CPUFallbackTransform';
-import type CPUFallbackColormapData from './CPUFallbackColormapData';
-import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
-import type CPUFallbackColormapsData from './CPUFallbackColormapsData';
-import type CPUFallbackColormap from './CPUFallbackColormap';
-import type TransformMatrix2D from './TransformMatrix2D';
-import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
-import type CPUFallbackLUT from './CPUFallbackLUT';
-import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
-import type { IVolumeInput, VolumeInputCallback } from './IVolumeInput';
-import type { IStackInput, StackInputCallback } from './IStackInput';
-import type * as EventTypes from './EventTypes';
-import type IRenderingEngine from './IRenderingEngine';
-import type ActorSliceRange from './ActorSliceRange';
-import type ImageSliceData from './ImageSliceData';
-import type IGeometry from './IGeometry';
-import type {
-  PublicContourSetData,
-  ContourSetData,
-  ContourData,
-} from './ContourData';
-import type { PublicSurfaceData, SurfaceData } from './SurfaceData';
-import type ICachedGeometry from './ICachedGeometry';
-import type { IContourSet } from './IContourSet';
-import type { IContour } from './IContour';
-import type RGB from './RGB';
-import { ColormapPublic, ColormapRegistration } from './Colormap';
-import type { ViewportProperties } from './ViewportProperties';
-import type {
-  PixelDataTypedArray,
-  PixelDataTypedArrayString,
-} from './PixelDataTypedArray';
-import type { ImagePixelModule } from './ImagePixelModule';
-import type { ImagePlaneModule } from './ImagePlaneModule';
-import type { AffineMatrix } from './AffineMatrix';
-export type {
-  RetrieveStage,
-  RetrieveOptions,
-  RangeRetrieveOptions,
-  StreamingRetrieveOptions,
-  NearbyFrames,
-  IRetrieveConfiguration,
-  IImagesLoader,
-} from './IRetrieveConfiguration';
-import type { ImageLoadListener } from './ImageLoadListener';
-import type { Color, ColorLUT } from './Color';
-import type VideoViewportProperties from './VideoViewportProperties';
-import type IVideoViewport from './IVideoViewport';
-import type {
-  InternalVideoCamera,
-  VideoViewportInput,
-} from './VideoViewportTypes';
-import { ISurface } from './ISurface';
-import type BoundsIJK from './BoundsIJK';
-import type { ImageVolumeProps } from './ImageVolumeProps';
-import type { VolumeProps } from './VolumeProps';
-import type BoundsLPS from './BoundsLPS';
-// Sometimes the type is needed rather than the class, so import
-// the type only here.
-import type PointsManager from '../utilities/PointsManager';
-
-export type {
-  // config
-  Cornerstone3DConfig,
-  //
-  ICamera,
-  IStackViewport,
-  IVideoViewport,
-  IVolumeViewport,
-  IEnabledElement,
-  ICache,
-  IVolume,
-  IViewportId,
-  IImageVolume,
-  ImageVolumeProps,
-  IDynamicImageVolume,
-  IRenderingEngine,
-  ScalingParameters,
-  PTScaling,
-  PointsManager,
-  Scaling,
-  IStreamingImageVolume,
-  IImage,
-  IImageData,
-  IImageCalibration,
-  CPUIImageData,
-  CPUImageData,
-  EventTypes,
-  ImageLoaderFn,
-  VolumeLoaderFn,
-  IRegisterImageLoader,
-  IStreamingVolumeProperties,
-  IViewport,
-  ViewReference,
-  ViewPresentation,
-  ViewPresentationSelector,
-  ReferenceCompatibleOptions,
-  ViewReferenceSpecifier,
-  StackViewportProperties,
-  VolumeViewportProperties,
-  ViewportProperties,
-  PublicViewportInput,
-  VolumeActor,
-  Actor,
-  ActorEntry,
-  ImageActor,
-  ICanvasActor,
-  IImageLoadObject,
-  IVolumeLoadObject,
-  IVolumeInput,
-  VolumeInputCallback,
-  IStackInput,
-  StackInputCallback,
-  ViewportPreset,
-  //
-  Metadata,
-  OrientationVectors,
-  AABB2,
-  AABB3,
-  Point2,
-  Point3,
-  PointsXYZ,
-  Point4,
-  Mat3,
-  Plane,
-  ViewportInputOptions,
-  VideoViewportProperties,
-  VOIRange,
-  VOI,
-  DisplayArea,
-  FlipDirection,
-  ICachedImage,
-  ICachedVolume,
-  // CPU fallback types
-  CPUFallbackEnabledElement,
-  CPUFallbackViewport,
-  CPUFallbackTransform,
-  CPUFallbackColormapData,
-  CPUFallbackViewportDisplayedArea,
-  CPUFallbackColormapsData,
-  CPUFallbackColormap,
-  TransformMatrix2D,
-  CPUFallbackLookupTable,
-  CPUFallbackLUT,
-  CPUFallbackRenderingTools,
-  //
-  CustomEventType,
-  ActorSliceRange,
-  ImageSliceData,
-  // Geometry
-  IGeometry,
-  IGeometryLoadObject,
-  ICachedGeometry,
-  // Contour
-  PublicContourSetData,
-  ContourSetData,
-  ContourData,
-  IContourSet,
-  IContour,
-  // Surface
-  PublicSurfaceData,
-  SurfaceData,
-  ISurface,
-  // Color
-  RGB,
-  ColormapPublic,
-  ColormapRegistration,
-  // PixelData
-  PixelDataTypedArray,
-  PixelDataTypedArrayString,
-  ImagePixelModule,
-  ImagePlaneModule,
-  AffineMatrix,
-  ImageLoadListener,
-  // video
-  InternalVideoCamera,
-  VideoViewportInput,
-  BoundsIJK,
-  BoundsLPS,
-  Color,
-  ColorLUT,
-  VolumeProps,
-};

package/src/types/voi.ts

@@ -1,15 +0,0 @@
-type VOI = {
-  /** Window Width for display */
-  windowWidth: number;
-  /** Window Center for display */
-  windowCenter: number;
-};
-
-type VOIRange = {
-  /** upper value for display */
-  upper: number;
-  /** lower value for display */
-  lower: number;
-};
-
-export type { VOI, VOIRange };

package/src/utilities/PointsManager.ts

@@ -1,260 +0,0 @@
-import type { Point2, Point3, PointsXYZ } from '../types';
-
-export type PolyDataPointConfiguration = {
-  /** The dimensionality of the points */
-  dimensions?: number;
-  /** The initial size of the backing array, not containing any data initially */
-  initialSize?: number;
-  /** The incremental size to grow by when required */
-  growSize?: number;
-};
-
-/**
- * PointsManager handles Point type data contained in a TypedArray representation
- * where all the point data is consecutive from start to end.  That is, the
- * organization is  `x0,y0,z0,x1,y1,z1,...,xn,yn,zn`.  This optimizes the storage
- * costs for large arrays of data, while still providing access to the point
- * data as though it were a simple array of objects.
- *
- * This representation is efficient for storing large numbers of points and for
- * transferring them amongst systems and is planned to have more methods added
- * for generic manipulation of data.
- */
-export default class PointsManager<T> {
-  /**
-   *  Allow storage for an index value to indicate where this array is
-   * contained in terms of the index location.
-   */
-  public kIndex: number;
-
-  /**
-   * Sources data for this array.  Just used for external access, not updated
-   * here.
-   */
-  public sources: PointsManager<T>[];
-
-  data: Float32Array;
-  _dimensions = 3;
-  _length = 0;
-  _byteSize = 4;
-  growSize = 128;
-  array: ArrayBuffer;
-
-  constructor(configuration: PolyDataPointConfiguration = {}) {
-    const {
-      initialSize = 1024,
-      dimensions = 3,
-      growSize = 128,
-    } = configuration;
-    const itemLength = initialSize * dimensions;
-    this.growSize = growSize;
-    // TODO - use resizeable arrays when they become available in all browsers
-    this.array = new ArrayBuffer(itemLength * this._byteSize);
-    this.data = new Float32Array(this.array);
-    this._dimensions = dimensions;
-  }
-
-  public forEach(func: (value: T, index: number) => void) {
-    for (let i = 0; i < this._length; i++) {
-      func(this.getPoint(i), i);
-    }
-  }
-
-  public get length() {
-    return this._length;
-  }
-
-  public get dimensions() {
-    return this._dimensions;
-  }
-
-  public get dimensionLength() {
-    return this._length * this._dimensions;
-  }
-
-  /**
-   * Returns a Float32Array view of the given point.
-   * Changes to the data in this point will affect the underlying data.
-   *
-   * @param index  - positive index from start, or negative from end
-   * @returns Float32Array view onto the point at the given index
-   */
-  public getPoint(index: number): T {
-    if (index < 0) {
-      index += this._length;
-    }
-    if (index < 0 || index >= this._length) {
-      return;
-    }
-    const offset = this._dimensions * index;
-    return this.data.subarray(
-      offset,
-      offset + this._dimensions
-    ) as unknown as T;
-  }
-
-  /**
-   * Returns a `number[]` version of the given point.
-   * Changes to the array will NOT affect the underlying data.
-   *
-   * @param index  - positive index from start, or negative from end
-   * @returns A new number[] instance of the given point.
-   */
-  public getPointArray(index: number): T {
-    const array = [];
-    if (index < 0) {
-      index += this._length;
-    }
-    if (index < 0 || index >= this._length) {
-      return;
-    }
-    const offset = this._dimensions * index;
-    for (let i = 0; i < this._dimensions; i++) {
-      array.push(this.data[i + offset]);
-    }
-    return array as unknown as T;
-  }
-
-  /**
-   * Updates the array size as needed to allow for at least the given
-   * additional number of elements.
-   */
-  protected grow(additionalSize = 1, growSize = this.growSize) {
-    if (
-      this.dimensionLength + additionalSize * this._dimensions <=
-      this.data.length
-    ) {
-      return;
-    }
-    const newSize = this.data.length + growSize;
-    const newArray = new ArrayBuffer(
-      newSize * this._dimensions * this._byteSize
-    );
-    const newData = new Float32Array(newArray);
-    newData.set(this.data);
-    this.data = newData;
-    this.array = newArray;
-  }
-
-  /**
-   * Reverse the points in place.
-   */
-  public reverse() {
-    const midLength = Math.floor(this._length / 2);
-
-    for (let i = 0; i < midLength; i++) {
-      const indexStart = i * this._dimensions;
-      const indexEnd = (this._length - 1 - i) * this._dimensions;
-      for (let dimension = 0; dimension < this._dimensions; dimension++) {
-        const valueStart = this.data[indexStart + dimension];
-        this.data[indexStart + dimension] = this.data[indexEnd + dimension];
-        this.data[indexEnd + dimension] = valueStart;
-      }
-    }
-  }
-
-  /**
-   * Push a new point onto this arrays object
-   */
-  public push(point: T) {
-    this.grow(1);
-    const offset = this.length * this._dimensions;
-    for (let i = 0; i < this._dimensions; i++) {
-      this.data[i + offset] = point[i];
-    }
-    this._length++;
-  }
-
-  /**
-   * Maps the array onto another type.
-   */
-  public map<R>(f: (value, index: number) => R): R[] {
-    const mapData = [];
-    for (let i = 0; i < this._length; i++) {
-      mapData.push(f(this.getPoint(i), i));
-    }
-    return mapData;
-  }
-
-  /**
-   * A points object containing Float32Array instances referring to the underlying
-   * data, contained in a FloatArray32[] instance.
-   * Note - changes to the data store will directly affect the points value
-   * returned here, even if stored separately.
-   */
-  public get points(): T[] {
-    return this.map((p) => p);
-  }
-
-  /**
-   * The XYZ representation of a points array is an object with three separate
-   * arrays, one for each of x,y and z, containing the point data, eg
-   * `x: {x0, x1, x2, ...., xn }`
-   * Will create just x,y for Point2 arrays.
-   *
-   * @returns An XYZ array
-   */
-  public toXYZ(): PointsXYZ {
-    const xyz = { x: [], y: [] } as PointsXYZ;
-    if (this._dimensions >= 3) {
-      xyz.z = [];
-    }
-    const { x, y, z } = xyz;
-
-    this.forEach((p) => {
-      x.push(p[0]);
-      y.push(p[1]);
-      if (z) {
-        z.push(p[2]);
-      }
-    });
-    return xyz;
-  }
-
-  /**
-   * Create an PointsArray3 from the x,y,z individual arrays (see toXYZ)
-   * Will create a Point3 array even if z is missing, with 0 as the value.
-   */
-  public static fromXYZ({ x, y, z }: PointsXYZ): PointsManager<Point3> {
-    const array = PointsManager.create3(x.length);
-    let offset = 0;
-    for (let i = 0; i < x.length; i++) {
-      array.data[offset++] = x[i];
-      array.data[offset++] = y[i];
-      array.data[offset++] = z ? z[i] : 0;
-    }
-    array._length = x.length;
-    return array;
-  }
-
-  /**
-   * Select the given number of points from the array, evenly spaced at the
-   * given offset (which must be between `(-count,count)`)
-   */
-  public subselect(count = 10, offset = 0): PointsManager<T> {
-    const selected = new PointsManager<T>({
-      initialSize: count,
-      dimensions: this._dimensions,
-    });
-    for (let i = 0; i < count; i++) {
-      const index =
-        (offset + Math.floor((this.length * i) / count)) % this.length;
-      selected.push(this.getPoint(index));
-    }
-    return selected;
-  }
-
-  /**
-   * Create a PointsManager<Point3> instance with available capacity of initialSize
-   */
-  public static create3(initialSize = 128) {
-    return new PointsManager<Point3>({ initialSize, dimensions: 3 });
-  }
-
-  /**
-   * Create a PointsManager<Point2> instance with available capacity of initialSize
-   */
-  public static create2(initialSize = 128) {
-    return new PointsManager<Point2>({ initialSize, dimensions: 2 });
-  }
-}

package/src/utilities/ProgressiveIterator.ts

@@ -1,190 +0,0 @@
-export class PromiseIterator<T> extends Promise<T> {
-  iterator?: ProgressiveIterator<T>;
-}
-
-export type ErrorCallback = (message: string | Error) => void;
-
-/**
- * A progressive iterator is an async iterator that can have data delivered
- * to it, with newer ones replacing older iterations which have not yet been
- * consume.  That allows iterating over sets of values and delivering updates,
- * but always getting the most recent instance.
- */
-export default class ProgressiveIterator<T> {
-  public done;
-  public name?: string;
-
-  private nextValue;
-  private waiting;
-  private rejectReason;
-
-  constructor(name?) {
-    this.name = name || 'unknown';
-  }
-
-  /** Casts a promise, progressive iterator or promise iterator to a
-   * progressive iterator, creating one if needed to resolve it.
-   */
-  public static as(promise) {
-    if (promise.iterator) {
-      return promise.iterator;
-    }
-    const iterator = new ProgressiveIterator('as iterator');
-    promise.then(
-      (v) => {
-        try {
-          iterator.add(v, true);
-        } catch (e) {
-          iterator.reject(e as Error);
-        }
-      },
-      (reason) => iterator.reject(reason)
-    );
-    return iterator;
-  }
-
-  /** Add a most recent result, indicating if the result is the final one */
-  public add(x: T, done = false) {
-    this.nextValue = x;
-    this.done ||= done;
-    if (this.waiting) {
-      this.waiting.resolve(x);
-      this.waiting = undefined;
-    }
-  }
-
-  public resolve() {
-    this.done = true;
-    if (this.waiting) {
-      this.waiting.resolve(this.nextValue);
-      this.waiting = undefined;
-    }
-  }
-
-  /** Reject the fetch.  This will prevent further iteration. */
-  public reject(reason: Error): void {
-    this.rejectReason = reason;
-    this.waiting?.reject(reason);
-  }
-
-  /** Gets the most recent value, without waiting */
-  public getRecent(): T {
-    if (this.rejectReason) {
-      throw this.rejectReason;
-    }
-    return this.nextValue;
-  }
-
-  /**
-   * Async iteration where the delivered values are the most recently available
-   * ones, so not necessarily all values are ever seen.
-   */
-  public async *[Symbol.asyncIterator]() {
-    while (!this.done) {
-      if (this.rejectReason) {
-        throw this.rejectReason;
-      }
-      if (this.nextValue !== undefined) {
-        // console.log('Yielding on', this.name, this.nextValue);
-        yield this.nextValue;
-        if (this.done) {
-          break;
-        }
-      }
-      if (!this.waiting) {
-        this.waiting = {};
-        this.waiting.promise = new Promise((resolve, reject) => {
-          this.waiting.resolve = resolve;
-          this.waiting.reject = reject;
-        });
-      }
-      // console.log('Awaiting on', this.name);
-      await this.waiting.promise;
-    }
-    // console.log('Final yield on', this.name);
-    yield this.nextValue;
-  }
-
-  /** Runs the forEach method on this filter */
-  public async forEach(callback, errorCallback) {
-    let index = 0;
-    // Need to catch basic iteration errors first
-    try {
-      for await (const value of this) {
-        const { done } = this;
-        // Separately catch errors in the callback function
-        try {
-          await callback(value, done, index);
-          index++;
-        } catch (e) {
-          if (!done) {
-            console.warn('Caught exception in intermediate value', e);
-            continue;
-          }
-          if (errorCallback) {
-            errorCallback(e, done);
-          } else {
-            throw e;
-          }
-        }
-      }
-    } catch (e) {
-      if (errorCallback) {
-        errorCallback(e, true);
-      } else {
-        throw e;
-      }
-    }
-  }
-
-  /** Calls an async function to generate the results on the iterator */
-  public generate(
-    processFunction,
-    errorCallback?: ErrorCallback
-  ): Promise<any> {
-    return processFunction(this, this.reject.bind(this)).then(
-      () => {
-        if (!this.done) {
-          // Set it to done
-          this.resolve();
-        }
-      },
-      (reason) => {
-        this.reject(reason);
-        if (errorCallback) {
-          errorCallback(reason);
-        } else {
-          console.warn("Couldn't process because", reason);
-        }
-      }
-    );
-  }
-
-  async nextPromise(): Promise<T> {
-    for await (const i of this) {
-      if (i) {
-        return i;
-      }
-    }
-    return this.nextValue;
-  }
-
-  async donePromise(): Promise<T> {
-    for await (const i of this) {
-      // No-op
-    }
-    return this.nextValue;
-  }
-
-  public getNextPromise() {
-    const promise = this.nextPromise() as PromiseIterator<T>;
-    promise.iterator = this;
-    return promise;
-  }
-
-  public getDonePromise() {
-    const promise = this.donePromise() as PromiseIterator<T>;
-    promise.iterator = this;
-    return promise;
-  }
-}