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

package/src/types/displayArea.ts

@@ -1,10 +1,42 @@
+import InterpolationType from '../enums/InterpolationType';
+
+/**
+ * The display area type allows specifying or updating the image position and
+ * size based on the display area that it is shown in and based on the image
+ * size.
+ *
+ * Two types are currently defined, the default 'FIT', specifies scaling
+ * to fit the given image area.  For this type, the area  that is scaled to
+ * fit is the imageArea times the image size.  For example, an imageArea of
+ * `[0.5,2]` with a 512 square image will try to fit 0.5*512 = 256 pixels width wise,
+ * and 2*512 = 1024 height wise.
+ *
+ * The type 'SCALE' means to use a scale factor, such as 1.0, which means to make
+ * every image pixel fit one physical display pixel.
+ *
+ * Then, the image is positioned such that the image fractional position imagePoint
+ * is located at the canvas fractional point canvasPoint.  Using fractional
+ * points allows being independent of image size.
+ *
+ * Finally, the store as initial camera allows the zoom and pan values to be
+ * set to 1 and [0,0] respectively for the initially displayed position, as well
+ * as having the reset camera reset to the specified display area.
+ */
 type DisplayArea = {
-  imageArea: [number, number]; // areaX, areaY
-  imageCanvasPoint: {
+  type?: 'SCALE' | 'FIT';
+  scale?: number;
+  interpolationType?: InterpolationType;
+  imageArea?: [number, number]; // areaX, areaY
+  imageCanvasPoint?: {
+    /** Use the fractional imagePoint as the target image point to position */
     imagePoint: [number, number]; // imageX, imageY
-    canvasPoint: [number, number]; // canvasX, canvasY
+    /** Pan the image such that the target imagePoint is located at the
+     * canvas point fraction of the canvas.
+     */
+    canvasPoint?: [number, number]; // canvasX, canvasY
   };
-  storeAsInitialCamera: boolean;
+  /** Make this display area the default and reset/navigate will reapply this */
+  storeAsInitialCamera?: boolean;
 };
 
 export default DisplayArea;

package/src/types/index.ts

@@ -3,7 +3,7 @@ import type Cornerstone3DConfig from './Cornerstone3DConfig';
 import type ICamera from './ICamera';
 import type IEnabledElement from './IEnabledElement';
 import type ICache from './ICache';
-import type { IVolume, VolumeScalarData } from './IVolume';
+import type { IVolume } from './IVolume';
 import type { VOI, VOIRange } from './voi';
 import type DisplayArea from './displayArea';
 import type ImageLoaderFn from './ImageLoaderFn';
@@ -13,8 +13,22 @@ import type VolumeLoaderFn from './VolumeLoaderFn';
 import type IRegisterImageLoader from './IRegisterImageLoader';
 import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
-import type { IViewport, PublicViewportInput } from './IViewport';
-import type { VolumeActor, Actor, ActorEntry } from './IActor';
+import type {
+  IViewport,
+  PublicViewportInput,
+  ViewReferenceSpecifier,
+  ReferenceCompatibleOptions,
+  ViewReference,
+  ViewPresentation,
+  ViewPresentationSelector,
+} from './IViewport';
+import type {
+  VolumeActor,
+  Actor,
+  ActorEntry,
+  ImageActor,
+  ICanvasActor,
+} from './IActor';
 import type {
   IImageLoadObject,
   IVolumeLoadObject,
@@ -22,9 +36,12 @@ import type {
 } 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';
@@ -62,6 +79,7 @@ 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';
@@ -72,13 +90,17 @@ import type {
   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 } from './PixelDataTypedArray';
+import type {
+  PixelDataTypedArray,
+  PixelDataTypedArrayString,
+} from './PixelDataTypedArray';
 import type { ImagePixelModule } from './ImagePixelModule';
 import type { ImagePlaneModule } from './ImagePlaneModule';
 import type { AffineMatrix } from './AffineMatrix';
@@ -92,6 +114,21 @@ export type {
   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
@@ -99,17 +136,19 @@ export type {
   //
   ICamera,
   IStackViewport,
+  IVideoViewport,
   IVolumeViewport,
   IEnabledElement,
   ICache,
   IVolume,
-  VolumeScalarData,
   IViewportId,
   IImageVolume,
+  ImageVolumeProps,
   IDynamicImageVolume,
   IRenderingEngine,
   ScalingParameters,
   PTScaling,
+  PointsManager,
   Scaling,
   IStreamingImageVolume,
   IImage,
@@ -123,6 +162,11 @@ export type {
   IRegisterImageLoader,
   IStreamingVolumeProperties,
   IViewport,
+  ViewReference,
+  ViewPresentation,
+  ViewPresentationSelector,
+  ReferenceCompatibleOptions,
+  ViewReferenceSpecifier,
   StackViewportProperties,
   VolumeViewportProperties,
   ViewportProperties,
@@ -130,20 +174,28 @@ export type {
   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,
@@ -176,14 +228,27 @@ export type {
   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/utilities/PointsManager.ts

@@ -0,0 +1,260 @@
+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 });
+  }
+}