@cornerstonejs/core 2.0.0-beta.8 → 2.0.0

package/src/utilities/getClosestStackImageIndexForPoint.ts

@@ -1,128 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { planar } from '.';
-import { metaData } from '..';
-import { IStackViewport, Point3 } from '../types';
-
-/**
- * Given a point in 3D space and a viewport it returns the index of the closest imageId, it assumes that stack images are sorted according to their sliceLocation
- * @param point - [A, B, C] coordinates of the point in 3D space
- * @param viewport - The StackViewport to search for the closest imageId
- *
- * @returns The imageId index of the closest imageId or null if no imageId is found
- */
-export default function getClosestStackImageIndexForPoint(
-  point: Point3,
-  viewport: IStackViewport
-): number | null {
-  const minimalDistance = calculateMinimalDistanceForStackViewport(
-    point,
-    viewport
-  );
-  return minimalDistance ? minimalDistance.index : null;
-}
-
-//assumes that imageIds are sorted by slice location
-export function calculateMinimalDistanceForStackViewport(
-  point: Point3,
-  viewport: IStackViewport
-): { distance: number; index: number } | null {
-  const imageIds = viewport.getImageIds();
-  const currentImageIdIndex = viewport.getCurrentImageIdIndex();
-
-  if (imageIds.length === 0) {
-    return null;
-  }
-
-  const getDistance = (imageId: string): null | number => {
-    const planeMetadata = getPlaneMetadata(imageId);
-    if (!planeMetadata) {
-      return null;
-    }
-    const plane = planar.planeEquation(
-      planeMetadata.planeNormal,
-      planeMetadata.imagePositionPatient
-    );
-    const distance = planar.planeDistanceToPoint(plane, point);
-    return distance;
-  };
-
-  const closestStack = {
-    distance: getDistance(imageIds[currentImageIdIndex]) ?? Infinity,
-    index: currentImageIdIndex,
-  };
-
-  //check higher indices
-  const higherImageIds = imageIds.slice(currentImageIdIndex + 1);
-
-  for (let i = 0; i < higherImageIds.length; i++) {
-    const id = higherImageIds[i];
-    const distance = getDistance(id);
-    if (distance === null) {
-      continue;
-    }
-    if (distance <= closestStack.distance) {
-      closestStack.distance = distance;
-      closestStack.index = i + currentImageIdIndex + 1;
-    } else {
-      break;
-    }
-  }
-  //check lower indices
-  const lowerImageIds = imageIds.slice(0, currentImageIdIndex);
-  for (let i = lowerImageIds.length - 1; i >= 0; i--) {
-    const id = lowerImageIds[i];
-    const distance = getDistance(id);
-    if (distance === null || distance === closestStack.distance) {
-      continue;
-    }
-    if (distance < closestStack.distance) {
-      closestStack.distance = distance;
-      closestStack.index = i;
-    } else {
-      break;
-    }
-  }
-  return closestStack.distance === Infinity ? null : closestStack;
-}
-
-function getPlaneMetadata(imageId: string): null | {
-  rowCosines: Point3;
-  columnCosines: Point3;
-  imagePositionPatient: Point3;
-  planeNormal: Point3;
-} {
-  const targetImagePlane = metaData.get('imagePlaneModule', imageId);
-
-  if (
-    !targetImagePlane ||
-    !(
-      targetImagePlane.rowCosines instanceof Array &&
-      targetImagePlane.rowCosines.length === 3
-    ) ||
-    !(
-      targetImagePlane.columnCosines instanceof Array &&
-      targetImagePlane.columnCosines.length === 3
-    ) ||
-    !(
-      targetImagePlane.imagePositionPatient instanceof Array &&
-      targetImagePlane.imagePositionPatient.length === 3
-    )
-  ) {
-    return null;
-  }
-  const {
-    rowCosines,
-    columnCosines,
-    imagePositionPatient,
-  }: {
-    rowCosines: Point3;
-    columnCosines: Point3;
-    imagePositionPatient: Point3;
-  } = targetImagePlane;
-
-  const rowVec = vec3.set(vec3.create(), ...rowCosines);
-  const colVec = vec3.set(vec3.create(), ...columnCosines);
-  const planeNormal = vec3.cross(vec3.create(), rowVec, colVec) as Point3;
-
-  return { rowCosines, columnCosines, imagePositionPatient, planeNormal };
-}

package/src/utilities/getCurrentVolumeViewportSlice.ts

@@ -1,166 +0,0 @@
-import { glMatrix, mat4, vec3 } from 'gl-matrix';
-import { IVolumeViewport, Point3 } from '../types';
-import { transformIJKToCanvas } from './transformIJKToCanvas';
-import { transformCanvasToIJK } from './transformCanvasToIJK';
-
-/**
- * Get the image data for the current slice rendered on the viewport. The image
- * data returned is the full slice and not only the region that is visible on
- * the viewport. It does not work for oblique views.
- * @param viewport - Volume viewport
- * @returns Slice image dataand  matrices to convert from volume
- *   to slice and vice-versa
- */
-function getCurrentVolumeViewportSlice(viewport: IVolumeViewport) {
-  const { dimensions, scalarData } = viewport.getImageData();
-  const { width: canvasWidth, height: canvasHeight } = viewport.getCanvas();
-
-  // Get three points from the canvas to help us identify the orientation of
-  // the slice. Using canvas width/height to get point far away for each other
-  // because points such as (0,0), (1,0) and (0,1) may be converted to the same
-  // ijk index when the image is zoomed in.
-  const ijkOriginPoint = transformCanvasToIJK(viewport, [0, 0]);
-  const ijkRowPoint = transformCanvasToIJK(viewport, [canvasWidth - 1, 0]);
-  const ijkColPoint = transformCanvasToIJK(viewport, [0, canvasHeight - 1]);
-
-  // Subtract the points to get the row and column vectors in index space
-  const ijkRowVec = vec3.sub(vec3.create(), ijkRowPoint, ijkOriginPoint);
-  const ijkColVec = vec3.sub(vec3.create(), ijkColPoint, ijkOriginPoint);
-  const ijkSliceVec = vec3.cross(vec3.create(), ijkRowVec, ijkColVec);
-
-  vec3.normalize(ijkRowVec, ijkRowVec);
-  vec3.normalize(ijkColVec, ijkColVec);
-  vec3.normalize(ijkSliceVec, ijkSliceVec);
-
-  // Any unit vector parallel to IJK have one component equal to 1 and
-  // the other two components equal to 0. If two of them are parallel
-  // the third one is also parallel
-  const maxIJKRowVec = Math.max(
-    Math.abs(ijkRowVec[0]),
-    Math.abs(ijkRowVec[1]),
-    Math.abs(ijkRowVec[2])
-  );
-  const maxIJKColVec = Math.max(
-    Math.abs(ijkColVec[0]),
-    Math.abs(ijkColVec[1]),
-    Math.abs(ijkColVec[2])
-  );
-
-  // Using glMatrix.equals() because the number may be not exactly equal to
-  // 1 due to rounding issues
-  if (!glMatrix.equals(1, maxIJKRowVec) || !glMatrix.equals(1, maxIJKColVec)) {
-    throw new Error('Livewire is not available for rotate/oblique viewports');
-  }
-
-  const [sx, sy, sz] = dimensions;
-
-  // All eight volume corners in index space
-  // prettier-ignore
-  const ijkCorners: Point3[] = [
-    [     0,        0,        0], // top-left-front
-    [sx - 1,        0,        0], // top-right-front
-    [     0,   sy - 1,        0], // bottom-left-front
-    [sx - 1,   sy - 1,        0], // bottom-right-front
-    [     0,        0,   sz - 1], // top-left-back
-    [sx - 1,        0,   sz - 1], // top-right-back
-    [     0,   sy - 1,   sz - 1], // bottom-left-back
-    [sx - 1,   sy - 1,   sz - 1], // bottom-right-back
-  ];
-
-  // Project the volume corners onto the canvas
-  const canvasCorners = ijkCorners.map((ijkCorner) =>
-    transformIJKToCanvas(viewport, ijkCorner)
-  );
-
-  // Calculate the AABB from the corners project onto the canvas
-  const canvasAABB = canvasCorners.reduce(
-    (aabb, canvasPoint) => {
-      aabb.minX = Math.min(aabb.minX, canvasPoint[0]);
-      aabb.minY = Math.min(aabb.minY, canvasPoint[1]);
-      aabb.maxX = Math.max(aabb.maxX, canvasPoint[0]);
-      aabb.maxY = Math.max(aabb.maxY, canvasPoint[1]);
-
-      return aabb;
-    },
-    { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity }
-  );
-
-  // Get the top-left, bottom-right and the diagonal vector of
-  // the slice in index space
-  const ijkTopLeft = transformCanvasToIJK(viewport, [
-    canvasAABB.minX,
-    canvasAABB.minY,
-  ]);
-  const ijkBottomRight = transformCanvasToIJK(viewport, [
-    canvasAABB.maxX,
-    canvasAABB.maxY,
-  ]);
-  const ijkDiagonal = vec3.sub(vec3.create(), ijkBottomRight, ijkTopLeft);
-
-  // prettier-ignore
-  const sliceToIndexMatrix = mat4.fromValues(
-      ijkRowVec[0],   ijkRowVec[1],   ijkRowVec[2],  0,
-      ijkColVec[0],   ijkColVec[1],   ijkColVec[2],  0,
-    ijkSliceVec[0], ijkSliceVec[1], ijkSliceVec[2],  0,
-     ijkTopLeft[0],  ijkTopLeft[1],  ijkTopLeft[2],  1
-  );
-
-  const indexToSliceMatrix = mat4.invert(mat4.create(), sliceToIndexMatrix);
-
-  // Dot the diagonal with row/column to find the image width/height
-  const sliceWidth = vec3.dot(ijkRowVec, ijkDiagonal) + 1;
-  const sliceHeight = vec3.dot(ijkColVec, ijkDiagonal) + 1;
-
-  // Create a TypedArray with same type from the original scalarData
-  const TypedArray = (scalarData as any).constructor;
-  const sliceData = new TypedArray(sliceWidth * sliceHeight);
-
-  // We need to know how many pixels to jump for every change in Z direction
-  const pixelsPerSlice = dimensions[0] * dimensions[1];
-
-  // Create two vectors to keep track of each row/column it is, reducing
-  // the amount of vec3 instances created and simplifying the math.
-  const ijkPixelRow = vec3.clone(ijkTopLeft);
-  const ijkPixelCol = vec3.create();
-
-  // Use an independent index to avoid multiple (x,y) to index conversions
-  let slicePixelIndex = 0;
-
-  for (let y = 0; y < sliceHeight; y++) {
-    vec3.copy(ijkPixelCol, ijkPixelRow);
-
-    for (let x = 0; x < sliceWidth; x++) {
-      const volumePixelIndex =
-        ijkPixelCol[2] * pixelsPerSlice +
-        ijkPixelCol[1] * dimensions[0] +
-        ijkPixelCol[0];
-
-      // It may never throw any "out of bounds" error but just to be safe
-      if (volumePixelIndex < scalarData.length) {
-        sliceData[slicePixelIndex] = scalarData[volumePixelIndex];
-      }
-
-      // Move to next slice pixel
-      slicePixelIndex++;
-
-      // Move to the next voxel
-      vec3.add(ijkPixelCol, ijkPixelCol, ijkRowVec);
-    }
-
-    // Move to the next row
-    vec3.add(ijkPixelRow, ijkPixelRow, ijkColVec);
-  }
-
-  return {
-    width: sliceWidth,
-    height: sliceHeight,
-    scalarData: sliceData,
-    sliceToIndexMatrix,
-    indexToSliceMatrix,
-  };
-}
-
-export {
-  getCurrentVolumeViewportSlice as default,
-  getCurrentVolumeViewportSlice,
-};

package/src/utilities/getImageLegacy.ts

@@ -1,29 +0,0 @@
-import { StackViewport, Types } from '..';
-import getEnabledElement from '../getEnabledElement';
-
-/**
- * Gets the IImage rendered by the given element. This is provided as a
- * convenience for the legacy cornerstone getImage function. However it is
- * encouraged for IStackViewport.getImage to be used instead.
- * @param element - the element rendering/containing the image
- * @returns the image
- */
-function getImageLegacy(element: HTMLDivElement): Types.IImage | undefined {
-  const enabledElement = getEnabledElement(element);
-
-  if (!enabledElement) {
-    return;
-  }
-
-  const { viewport } = enabledElement;
-
-  if (!(viewport instanceof StackViewport)) {
-    throw new Error(
-      `An image can only be fetched for a stack viewport and not for a viewport of type: ${viewport.type}`
-    );
-  }
-
-  return viewport.getCornerstoneImage();
-}
-
-export default getImageLegacy;

package/src/utilities/getImageSliceDataForVolumeViewport.ts

@@ -1,61 +0,0 @@
-import { ImageSliceData, IVolumeViewport, VolumeActor } from '../types';
-import getSliceRange from './getSliceRange';
-import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
-
-/**
- * It calculates the number of slices and the current slice index for a given
- * Volume viewport
- * @param viewport - volume viewport
- * @returns An object with two properties: numberOfSlices and imageIndex.
- */
-function getImageSliceDataForVolumeViewport(
-  viewport: IVolumeViewport
-): ImageSliceData {
-  const camera = viewport.getCamera();
-
-  const { spacingInNormalDirection, imageVolume } =
-    getTargetVolumeAndSpacingInNormalDir(viewport, camera);
-
-  if (!imageVolume) {
-    return;
-  }
-
-  const { viewPlaneNormal, focalPoint } = camera;
-
-  const actorEntry = viewport
-    .getActors()
-    .find(
-      (a) =>
-        a.referenceId === imageVolume.volumeId || a.uid === imageVolume.volumeId
-    );
-
-  if (!actorEntry) {
-    console.warn('No actor found for with actorUID of', imageVolume.volumeId);
-  }
-
-  const volumeActor = actorEntry.actor as VolumeActor;
-  const sliceRange = getSliceRange(volumeActor, viewPlaneNormal, focalPoint);
-
-  const { min, max, current } = sliceRange;
-
-  // calculate number of steps from min to max with current normal spacing in direction
-  const numberOfSlices = Math.round((max - min) / spacingInNormalDirection) + 1;
-
-  // calculate the imageIndex based on min, max, current
-  let imageIndex = ((current - min) / (max - min)) * numberOfSlices;
-  imageIndex = Math.floor(imageIndex);
-
-  // Clamp imageIndex
-  if (imageIndex > numberOfSlices - 1) {
-    imageIndex = numberOfSlices - 1;
-  } else if (imageIndex < 0) {
-    imageIndex = 0;
-  }
-
-  return {
-    numberOfSlices,
-    imageIndex,
-  };
-}
-
-export default getImageSliceDataForVolumeViewport;

package/src/utilities/getMinMax.ts

@@ -1,31 +0,0 @@
-/**
- * Calculate the minimum and maximum values in an Array
- *
- * @param storedPixelData - The pixel data to calculate the min and max values for
- * @returns an object with two properties: min and max
- */
-export default function getMinMax(storedPixelData: number[]): {
-  min: number;
-  max: number;
-} {
-  // we always calculate the min max values since they are not always
-  // present in DICOM and we don't want to trust them anyway as cornerstone
-  // depends on us providing reliable values for these
-  let min = storedPixelData[0];
-
-  let max = storedPixelData[0];
-
-  let storedPixel;
-  const numPixels = storedPixelData.length;
-
-  for (let index = 1; index < numPixels; index++) {
-    storedPixel = storedPixelData[index];
-    min = Math.min(min, storedPixel);
-    max = Math.max(max, storedPixel);
-  }
-
-  return {
-    min,
-    max,
-  };
-}

package/src/utilities/getRandomSampleFromArray.ts

@@ -1,30 +0,0 @@
-/**
- * Gets a random sample of specified size from the array.
- * If the requested size is greater than the array length, returns a shuffled clone of the original array.
- * @param array - The source array from which to sample.
- * @param size - The number of elements to sample from the array.
- * @returns A new array containing the random sample.
- */
-export function getRandomSampleFromArray<T>(array: T[], size: number): T[] {
-  const clonedArray = [...array]; // Copy the original array
-
-  // If requested size is greater than array length, shuffle and return clone of the original array
-  if (size >= clonedArray.length) {
-    shuffleArray(clonedArray);
-    return clonedArray;
-  }
-
-  shuffleArray(clonedArray);
-  return clonedArray.slice(0, size);
-}
-
-/**
- * Shuffles an array
- * @param array - The array to shuffle.
- */
-function shuffleArray<T>(array: T[]): void {
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]]; // Swap elements
-  }
-}

package/src/utilities/getRuntimeId.ts

@@ -1,56 +0,0 @@
-const LAST_RUNTIME_ID = Symbol('LastRuntimeId');
-const GLOBAL_CONTEXT = {};
-const DEFAULT_MAX = 0xffffffff; // Max 32-bit integer
-const DEFAULT_SEPARATOR = '-';
-
-/**
- * Generate a unique numeric ID string valid during a single runtime session;
- *
- * @param context - An optional object to be used as context.
- *  Defaults to a global context;
- * @param separator - The component separator. Defaults to "-";
- * @param max - The maximum component value. Defaults to 4294967295;
- * @returns The string representation of the the unique ID;
- */
-export default function getRuntimeId(
-  context?: unknown,
-  separator?: string,
-  max?: number
-): string {
-  return getNextRuntimeId(
-    // @ts-ignore
-    context !== null && typeof context === 'object' ? context : GLOBAL_CONTEXT,
-    LAST_RUNTIME_ID,
-    (typeof max === 'number' && max > 0 ? max : DEFAULT_MAX) >>> 0
-  ).join(typeof separator === 'string' ? separator : DEFAULT_SEPARATOR);
-}
-
-/*
- * Helpers
- */
-
-function getNextRuntimeId(
-  context: Record<symbol, Array<number>>,
-  symbol: symbol,
-  max: number
-): Array<number> {
-  let idComponents = context[symbol];
-  if (!(idComponents instanceof Array)) {
-    idComponents = [0];
-    Object.defineProperty(context, symbol, { value: idComponents });
-  }
-  for (let carry = true, i = 0; carry && i < idComponents.length; ++i) {
-    let n = idComponents[i] | 0;
-    if (n < max) {
-      carry = false;
-      n = n + 1;
-    } else {
-      n = 0;
-      if (i + 1 === idComponents.length) {
-        idComponents.push(0);
-      }
-    }
-    idComponents[i] = n;
-  }
-  return idComponents;
-}

package/src/utilities/getScalarDataType.ts

@@ -1,31 +0,0 @@
-import { ScalingParameters } from '../types';
-
-/**
- * If the scalar data is a Uint8Array, return 'Uint8Array'. If the scalar data is a
- * Float32Array, return 'Float32Array'. If the scalar data is a Int16Array, return
- * 'Int16Array'. If the scalar data is a Uint16Array, return 'Uint16Array'. If the
- * scalar data is none of the above, throw an error.
- * @param {ScalingParameters} scalingParameters - {
- * @param {any} [scalarData] - The data to be converted.
- * @returns The data type of the scalar data.
- */
-export default function getScalarDataType(
-  scalingParameters: ScalingParameters,
-  scalarData?: any
-): string {
-  let type;
-
-  if (scalarData && scalarData instanceof Uint8Array) {
-    type = 'Uint8Array';
-  } else if (scalarData instanceof Float32Array) {
-    type = 'Float32Array';
-  } else if (scalarData instanceof Int16Array) {
-    type = 'Int16Array';
-  } else if (scalarData instanceof Uint16Array) {
-    type = 'Uint16Array';
-  } else {
-    throw new Error('Unsupported array type');
-  }
-
-  return type;
-}

package/src/utilities/getScalingParameters.ts

@@ -1,35 +0,0 @@
-import { get as metaDataGet } from '../metaData';
-import { ScalingParameters } from '../types';
-
-/**
- * It returns the scaling parameters for the image with the given imageId. This can be
- * used to get passed (as an option) to the imageLoader in order to apply scaling to the image inside
- * the imageLoader.
- * @param imageId - The imageId of the image
- * @returns ScalingParameters
- */
-export default function getScalingParameters(
-  imageId: string
-): ScalingParameters {
-  const modalityLutModule = metaDataGet('modalityLutModule', imageId) || {};
-  const generalSeriesModule = metaDataGet('generalSeriesModule', imageId) || {};
-
-  const { modality } = generalSeriesModule;
-
-  const scalingParameters = {
-    rescaleSlope: modalityLutModule.rescaleSlope || 1,
-    rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
-    modality,
-  };
-
-  const suvFactor = metaDataGet('scalingModule', imageId) || {};
-
-  return {
-    ...scalingParameters,
-    ...(modality === 'PT' && {
-      suvbw: suvFactor.suvbw,
-      suvbsa: suvFactor.suvbsa,
-      suvlbm: suvFactor.suvlbm,
-    }),
-  };
-}

package/src/utilities/getSliceRange.ts

@@ -1,86 +0,0 @@
-import vtkMatrixBuilder from '@kitware/vtk.js/Common/Core/MatrixBuilder';
-import getVolumeActorCorners from './getVolumeActorCorners';
-import type { VolumeActor, Point3, ActorSliceRange } from '../types';
-import { EPSILON } from '../constants';
-
-const SMALL_EPSILON = EPSILON * EPSILON;
-const isOne = (v) => Math.abs(Math.abs(v) - 1) < SMALL_EPSILON;
-const isUnit = (v, off) =>
-  isOne(v[off]) || isOne(v[off + 1]) || isOne(v[off + 2]);
-
-const isOrthonormal = (v) => isUnit(v, 0) && isUnit(v, 3) && isUnit(v, 6);
-
-/**
- * Given a `vtkVolumeActor`, and a normal direction,
- * calculate the range of slices in the focal normal direction that encapsulate
- * the volume. Also project the `focalPoint` onto this range.
- *
- * @param volumeActor - The `vtkVolumeActor`.
- * @param viewPlaneNormal - The normal to the camera view.
- * @param focalPoint - The focal point of the camera.
- *
- * @returns an object containing the `min`, `max` and `current`
- * positions in the normal direction.
- */
-export default function getSliceRange(
-  volumeActor: VolumeActor,
-  viewPlaneNormal: Point3,
-  focalPoint: Point3
-): ActorSliceRange {
-  const imageData = volumeActor.getMapper().getInputData();
-  let corners;
-  const direction = imageData.getDirection();
-
-  if (isOrthonormal(direction)) {
-    // This logic is only valid when the IJK vectors are unit vectors
-    corners = getVolumeActorCorners(volumeActor);
-  } else {
-    // This logic works for both unit and non-unit vectors, but is slower
-    const [dx, dy, dz] = imageData.getDimensions();
-    const cornersIdx = [
-      [0, 0, 0],
-      [dx - 1, 0, 0],
-      [0, dy - 1, 0],
-      [dx - 1, dy - 1, 0],
-      [0, 0, dz - 1],
-      [dx - 1, 0, dz - 1],
-      [0, dy - 1, dz - 1],
-      [dx - 1, dy - 1, dz - 1],
-    ];
-    corners = cornersIdx.map((it) => imageData.indexToWorld(it));
-  }
-  // Get rotation matrix from normal to +X (since bounds is aligned to XYZ)
-  const transform = vtkMatrixBuilder
-    .buildFromDegree()
-    .identity()
-    .rotateFromDirections(viewPlaneNormal, [1, 0, 0]);
-
-  corners.forEach((pt) => transform.apply(pt));
-
-  const transformedFocalPoint = [...focalPoint];
-  transform.apply(transformedFocalPoint);
-
-  const currentSlice = transformedFocalPoint[0];
-
-  // range is now maximum X distance
-  let minX = Infinity;
-  let maxX = -Infinity;
-  for (let i = 0; i < 8; i++) {
-    const x = corners[i][0];
-    if (x > maxX) {
-      maxX = x;
-    }
-    if (x < minX) {
-      minX = x;
-    }
-  }
-
-  return {
-    min: minX,
-    max: maxX,
-    current: currentSlice,
-    actor: volumeActor,
-    viewPlaneNormal,
-    focalPoint,
-  };
-}