@cornerstonejs/core 0.36.3 → 0.36.5

package/src/cache/classes/Contour.ts

@@ -0,0 +1,70 @@
+import { Point3, ContourData, IContour } from '../../types';
+import { ContourType } from '../../enums';
+
+type ContourProps = {
+  id: string;
+  data: ContourData;
+  color: Point3;
+};
+
+/**
+ * The `Contour` class implements the `IContour` interface and represents a contour in 3D space.
+ * It holds information about the contour's id, size in bytes, points, color, and type.
+ * The class also provides methods to retrieve the points, color, and type of the contour.
+ * Each Contour is part of a ContourSet, and each ContourSet is part of a Geometry.
+ */
+export class Contour implements IContour {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  points: Point3[];
+  color: Point3;
+  type: ContourType;
+
+  constructor(props: ContourProps) {
+    const { points, type } = props.data;
+    this.id = props.id;
+    this.points = points;
+    this.type = type;
+    this.color = props.color;
+
+    this.sizeInBytes = this._getSizeInBytes();
+  }
+
+  _getSizeInBytes(): number {
+    let sizeInBytes = 0;
+
+    // Assuming each point is 1 byte
+    sizeInBytes += this.points.length * 3;
+    return sizeInBytes;
+  }
+
+  /**
+   * It returns the value of the points property of the data object
+   * @returns The points property of the data object.
+   */
+  public getPoints(): Point3[] {
+    return this.points;
+  }
+
+  public getFlatPointsArray(): number[] {
+    return this.points.map((point) => [...point]).flat();
+  }
+
+  /**
+   * This function returns the color of the contour
+   * @returns The color of the contour
+   */
+  public getColor(): Point3 {
+    return this.color;
+  }
+
+  /**
+   * It returns the type of the contour, closed or open
+   * @returns The type of the contour.
+   */
+  public getType(): ContourType {
+    return this.type;
+  }
+}
+
+export default Contour;

package/src/cache/classes/ContourSet.ts

@@ -0,0 +1,151 @@
+import { Point3, IContourSet, IContour, ContourData } from '../../types';
+import Contour from './Contour';
+
+type ContourSetProps = {
+  id: string;
+  data: ContourData[];
+  frameOfReferenceUID: string;
+  color?: Point3;
+};
+
+/**
+ * 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 class ContourSet implements IContourSet {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  readonly frameOfReferenceUID: string;
+  private color: Point3 = [200, 0, 0]; // default color
+  contours: IContour[];
+
+  constructor(props: ContourSetProps) {
+    this.id = props.id;
+    this.contours = [];
+    this.color = props.color ?? this.color;
+    this.frameOfReferenceUID = props.frameOfReferenceUID;
+
+    this._createEachContour(props.data);
+    this.sizeInBytes = this._getSizeInBytes();
+  }
+
+  _createEachContour(contourDataArray: ContourData[]): void {
+    for (let i = 0; i < contourDataArray.length; i++) {
+      const contour = new Contour({
+        id: `${this.id}-${i}`,
+        data: {
+          points: contourDataArray[i].points,
+          type: contourDataArray[i].type,
+        },
+        color: contourDataArray[i].color ?? this.color,
+      });
+
+      this.contours.push(contour);
+    }
+  }
+
+  _getSizeInBytes(): number {
+    return this.contours.reduce((sizeInBytes, contour) => {
+      return sizeInBytes + contour.sizeInBytes;
+    }, 0);
+  }
+
+  public getColor(): Point3 {
+    // Currently, all contours in a contour set have the same color.
+    // This may change in the future.
+    return this.color;
+  }
+
+  /**
+   * This function returns the contours of the image
+   * @returns The contours of the image.
+   */
+  public getContours(): IContour[] {
+    return this.contours;
+  }
+
+  public getSizeInBytes(): number {
+    return this.sizeInBytes;
+  }
+
+  /**
+   * It returns an array of all the points in the glyph
+   * @returns An array of points.
+   */
+  public getFlatPointsArray(): Point3[] {
+    return this.contours.map((contour) => contour.getPoints()).flat();
+  }
+
+  /**
+   * This function returns the number of contours in the current shape.
+   * @returns The number of contours in the glyph.
+   */
+  public getNumberOfContours(): number {
+    return this.contours.length;
+  }
+
+  /**
+   * 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.
+   */
+  public getTotalNumberOfPoints(): number {
+    return this.contours.reduce((numberOfPoints, contour) => {
+      return numberOfPoints + contour.getPoints().length;
+    }, 0);
+  }
+
+  /**
+   * It returns an array of the number of points in each contour.
+   * @returns An array of numbers.
+   */
+  public getNumberOfPointsArray(): number[] {
+    return this.contours.reduce((acc, _, i) => {
+      acc[i] = this.getNumberOfPointsInAContour(i);
+      return acc;
+    }, []);
+  }
+
+  /**
+   * 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.
+   */
+  public getPointsInContour(contourIndex: number): Point3[] {
+    return this.contours[contourIndex].getPoints();
+  }
+  /**
+   * "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.
+   */
+  public getNumberOfPointsInAContour(contourIndex: number): number {
+    return this.getPointsInContour(contourIndex).length;
+  }
+
+  /**
+  public convertToClosedSurface(): ClosedSurface {
+    const flatPointsArray = this.getFlatPointsArray();
+    const numPointsArray = this.getNumberOfPointsArray();
+
+    const closedSurfaceData = polySeg.convertToClosedSurface(
+      flatPointsArray,
+      numPointsArray
+    );
+
+    const closedSurface = new ClosedSurface({
+      id: this.id,
+      data: closedSurfaceData,
+      color: this.color,
+    });
+
+    // cache the closed surface
+    return closedSurface;
+  }
+   */
+}
+
+export default Contour;

package/src/cache/classes/ImageVolume.ts

@@ -0,0 +1,155 @@
+import isTypedArray from '../../utilities/isTypedArray';
+import { imageIdToURI } from '../../utilities';
+import { vtkStreamingOpenGLTexture } from '../../RenderingEngine/vtkClasses';
+import {
+  IVolume,
+  VolumeScalarData,
+  Metadata,
+  Point3,
+  IImageVolume,
+  Mat3,
+} from '../../types';
+
+/** The base class for volume data. It includes the volume metadata
+ * and the volume data along with the loading status.
+ */
+export class ImageVolume implements IImageVolume {
+  private _imageIds: Array<string>;
+  private _imageIdsIndexMap = new Map();
+  private _imageURIsIndexMap = new Map();
+  /** volume scalar data 3D or 4D */
+  protected scalarData: VolumeScalarData | Array<VolumeScalarData>;
+
+  /** Read-only unique identifier for the volume */
+  readonly volumeId: string;
+  /** Dimensions of the volume */
+  dimensions: Point3;
+  /** volume direction in world space */
+  direction: Mat3;
+  /** volume metadata */
+  metadata: Metadata;
+  /** volume origin, Note this is an opinionated origin for the volume */
+  origin: Point3;
+  /** Whether preScaling has been performed on the volume */
+  isPrescaled = false;
+  /** volume scaling parameters if it contains scaled data */
+  scaling?: {
+    PET?: {
+      // @TODO: Do these values exist?
+      SUVlbmFactor?: number;
+      SUVbsaFactor?: number;
+      // accessed in ProbeTool
+      suvbwToSuvlbm?: number;
+      suvbwToSuvbsa?: number;
+    };
+  };
+  /** volume size in bytes */
+  sizeInBytes?: number; // Seems weird to pass this in? Why not grab it from scalarData.byteLength
+  /** volume spacing in 3d world space */
+  spacing: Point3;
+  /** volume number of voxels */
+  numVoxels: number;
+  /** volume image data */
+  imageData?: any;
+  /** open gl texture for the volume */
+  vtkOpenGLTexture: any; // No good way of referencing vtk classes as they aren't classes.
+  /** load status object for the volume */
+  loadStatus?: Record<string, any>;
+  /** optional reference volume id if the volume is derived from another volume */
+  referencedVolumeId?: string;
+  /** whether the metadata for the pixel spacing is not undefined  */
+  hasPixelSpacing: boolean;
+
+  constructor(props: IVolume) {
+    this.volumeId = props.volumeId;
+    this.metadata = props.metadata;
+    this.dimensions = props.dimensions;
+    this.spacing = props.spacing;
+    this.origin = props.origin;
+    this.direction = props.direction;
+    this.imageData = props.imageData;
+    this.scalarData = props.scalarData;
+    this.sizeInBytes = props.sizeInBytes;
+    this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance();
+    this.numVoxels =
+      this.dimensions[0] * this.dimensions[1] * this.dimensions[2];
+
+    if (props.scaling) {
+      this.scaling = props.scaling;
+    }
+
+    if (props.referencedVolumeId) {
+      this.referencedVolumeId = props.referencedVolumeId;
+    }
+  }
+
+  /** return the image ids for the volume if it is made of separated images */
+  public get imageIds(): Array<string> {
+    return this._imageIds;
+  }
+
+  /** updates the image ids */
+  public set imageIds(newImageIds: Array<string>) {
+    this._imageIds = newImageIds;
+    this._reprocessImageIds();
+  }
+
+  private _reprocessImageIds() {
+    this._imageIdsIndexMap.clear();
+    this._imageURIsIndexMap.clear();
+
+    this._imageIds.forEach((imageId, i) => {
+      const imageURI = imageIdToURI(imageId);
+
+      this._imageIdsIndexMap.set(imageId, i);
+      this._imageURIsIndexMap.set(imageURI, i);
+    });
+  }
+
+  cancelLoading: () => void;
+
+  /** return true if it is a 4D volume or false if it is 3D volume */
+  public isDynamicVolume(): boolean {
+    return false;
+  }
+
+  /**
+   * Return the scalar data for 3D volumes or the active scalar data
+   * (current time point) for 4D volumes
+   */
+  public getScalarData(): VolumeScalarData {
+    if (isTypedArray(this.scalarData)) {
+      return <VolumeScalarData>this.scalarData;
+    }
+
+    throw new Error('Unknow scalar data type');
+  }
+
+  /**
+   * return the index of a given imageId
+   * @param imageId - imageId
+   * @returns imageId index
+   */
+  public getImageIdIndex(imageId: string): number {
+    return this._imageIdsIndexMap.get(imageId);
+  }
+
+  /**
+   * return the index of a given imageURI
+   * @param imageId - imageURI
+   * @returns imageURI index
+   */
+  public getImageURIIndex(imageURI: string): number {
+    return this._imageURIsIndexMap.get(imageURI);
+  }
+
+  /**
+   * destroy the volume and make it unusable
+   */
+  destroy(): void {
+    this.vtkOpenGLTexture.delete();
+    this.scalarData = null;
+  }
+}
+
+export default ImageVolume;

package/src/cache/index.ts

@@ -0,0 +1,5 @@
+import cache, { Cache } from './cache';
+import ImageVolume from './classes/ImageVolume';
+
+export { ImageVolume, Cache };
+export default cache;