@cornerstonejs/core 0.36.2 → 0.36.4

package/src/utilities/getClosestImageId.ts

@@ -0,0 +1,80 @@
+import { vec3 } from 'gl-matrix';
+import * as metaData from '../metaData';
+import type { IImageVolume, Point3 } from '../types';
+
+import getSpacingInNormalDirection from './getSpacingInNormalDirection';
+
+/**
+ * Given an image, a point in space and the viewPlaneNormal it returns the
+ * closest imageId of the image volume that is within half voxel spacing
+ * of the point in space.
+ * @param imageVolume - The image volume
+ * @param worldPos - The position in the world coordinate system (from mouse click)
+ * @param viewPlaneNormal - The normal vector of the viewport
+ * @param viewUp - The viewUp vector of the camera.
+ *
+ * @returns The imageId for the tool.
+ */
+export default function getClosestImageId(
+  imageVolume: IImageVolume,
+  worldPos: Point3,
+  viewPlaneNormal: Point3,
+  viewUp: Point3
+): string {
+  if (!imageVolume) {
+    return;
+  }
+
+  const { direction, imageIds } = imageVolume;
+
+  if (!imageIds || !imageIds.length) {
+    return;
+  }
+
+  // 1. Get ScanAxis vector
+  const kVector = direction.slice(6, 9);
+
+  // 2. Check if scanAxis is not parallel to camera viewPlaneNormal
+  const dotProducts = vec3.dot(kVector as Point3, <vec3>viewPlaneNormal);
+
+  // 2.a if imagePlane is not parallel to the camera: tool is not drawn on an
+  // imaging plane, return
+  if (Math.abs(dotProducts) < 0.99) {
+    return;
+  }
+
+  // 3. Calculate Spacing the in the normal direction, this will get used to
+  // check whether we are withing a slice
+  const spacingInNormalDirection = getSpacingInNormalDirection(
+    imageVolume,
+    viewPlaneNormal
+  );
+
+  const halfSpacingInNormalDirection = spacingInNormalDirection / 2;
+
+  // 4. Iterate over all imageIds and check if the tool point (worldPos) is
+  // withing one of the slices defined by an imageId
+  let imageIdForTool;
+  for (let i = 0; i < imageIds.length; i++) {
+    const imageId = imageIds[i];
+
+    // 4.a Get metadata for the imageId
+    const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+
+    // 4.b Calculate the direction vector from annotation. point to the first voxel
+    // of this image defined by imageId
+    const dir = vec3.create();
+    vec3.sub(dir, worldPos, imagePositionPatient);
+
+    // 4.c Calculate the distance between the vector above and the viewplaneNormal
+    // i.e., projected distance
+    const dot = vec3.dot(dir, viewPlaneNormal);
+
+    // 4.d If the distance is withing range, return the imageId
+    if (Math.abs(dot) < halfSpacingInNormalDirection) {
+      imageIdForTool = imageId;
+    }
+  }
+
+  return imageIdForTool;
+}

package/src/utilities/getClosestStackImageIndexForPoint.ts

@@ -0,0 +1,116 @@
+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/getImageSliceDataForVolumeViewport.ts

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,31 @@
+/**
+ * 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/getRuntimeId.ts

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,35 @@
+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,
+    rescaleIntercept: modalityLutModule.rescaleIntercept,
+    modality,
+  };
+
+  const suvFactor = metaDataGet('scalingModule', imageId) || {};
+
+  return {
+    ...scalingParameters,
+    ...(modality === 'PT' && {
+      suvbw: suvFactor.suvbw,
+      suvbsa: suvFactor.suvbsa,
+      suvlbm: suvFactor.suvlbm,
+    }),
+  };
+}

package/src/utilities/getSliceRange.ts

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

package/src/utilities/getSpacingInNormalDirection.ts

@@ -0,0 +1,44 @@
+import { vec3 } from 'gl-matrix';
+import { IImageVolume, Point3 } from '../types';
+
+/**
+ * Given an `imageVolume` and a normal direction (`viewPlaneNormal`), calculates
+ * the spacing between voxels in the normal direction. If (`viewPlaneNormal`) is
+ * parallel to one of the directions you will obtain the spacing in that direction.
+ * Otherwise each of the `imageVolume`'s directions are projected onto the volume,
+ * so that you obtain a spacing of the order of "seeing a new set of voxels if the camera where to dolly".
+ *
+ * @param imageVolume - The image volume to calculate the spacing in the normal direction.
+ * @param viewPlaneNormal - The normal direction of the view plane.
+ * @returns
+ */
+export default function getSpacingInNormalDirection(
+  imageVolume: IImageVolume,
+  viewPlaneNormal: Point3
+): number {
+  const { direction, spacing } = imageVolume;
+
+  // Calculate size of spacing vector in normal direction
+  const iVector = direction.slice(0, 3) as Point3;
+  const jVector = direction.slice(3, 6) as Point3;
+  const kVector = direction.slice(6, 9) as Point3;
+
+  const dotProducts = [
+    vec3.dot(iVector, <vec3>viewPlaneNormal),
+    vec3.dot(jVector, <vec3>viewPlaneNormal),
+    vec3.dot(kVector, <vec3>viewPlaneNormal),
+  ];
+
+  const projectedSpacing = vec3.create();
+
+  vec3.set(
+    projectedSpacing,
+    dotProducts[0] * spacing[0],
+    dotProducts[1] * spacing[1],
+    dotProducts[2] * spacing[2]
+  );
+
+  const spacingInNormalDirection = vec3.length(projectedSpacing);
+
+  return spacingInNormalDirection;
+}

package/src/utilities/getTargetVolumeAndSpacingInNormalDir.ts

@@ -0,0 +1,126 @@
+import cache from '../cache/cache';
+import { EPSILON } from '../constants';
+// import type { VolumeViewport } from '../RenderingEngine'
+import { ICamera, IImageVolume, IVolumeViewport } from '../types';
+import getSpacingInNormalDirection from './getSpacingInNormalDirection';
+import { getVolumeLoaderSchemes } from '../loaders/volumeLoader';
+
+// One EPSILON part larger multiplier
+const EPSILON_PART = 1 + EPSILON;
+
+const startsWith = (str, starts) =>
+  starts === str.substring(0, Math.min(str.length, starts.length));
+
+// Check if this is a primary volume
+// For now, that means it came from some sort of image loader, but
+// should be specifically designated.
+const isPrimaryVolume = (volume): boolean =>
+  !!getVolumeLoaderSchemes().find((scheme) =>
+    startsWith(volume.volumeId, scheme)
+  );
+
+/**
+ * Given a volume viewport and camera, find the target volume.
+ * The imageVolume is retrieved from cache for the specified targetVolumeId or
+ * in case it is not provided, it chooses the volumeId on the viewport (there
+ * might be more than one in case of fusion) that has the finest resolution in the
+ * direction of view (normal).
+ *
+ * @param viewport - volume viewport
+ * @param camera - current camera
+ * @param targetVolumeId - If a target volumeId is given that volume
+ * is forced to be used.
+ *
+ * @returns An object containing the imageVolume and spacingInNormalDirection.
+ *
+ */
+export default function getTargetVolumeAndSpacingInNormalDir(
+  viewport: IVolumeViewport,
+  camera: ICamera,
+  targetVolumeId?: string
+): {
+  imageVolume: IImageVolume;
+  spacingInNormalDirection: number;
+  actorUID: string;
+} {
+  const { viewPlaneNormal } = camera;
+  const volumeActors = viewport.getActors();
+
+  if (!volumeActors || !volumeActors.length) {
+    return {
+      spacingInNormalDirection: null,
+      imageVolume: null,
+      actorUID: null,
+    };
+  }
+
+  const imageVolumes = volumeActors
+    .map((va) => {
+      // prefer the referenceUID if it is set, since it can be a derived actor
+      // and the uid does not necessarily match the volumeId
+      const actorUID = va.referenceId ?? va.uid;
+      return cache.getVolume(actorUID);
+    })
+    .filter((iv) => !!iv);
+
+  // If a volumeId is defined, set that volume as the target
+  if (targetVolumeId) {
+    const imageVolumeIndex = imageVolumes.findIndex(
+      (iv) => iv.volumeId === targetVolumeId
+    );
+
+    const imageVolume = imageVolumes[imageVolumeIndex];
+    const { uid: actorUID } = volumeActors[imageVolumeIndex];
+    const spacingInNormalDirection = getSpacingInNormalDirection(
+      imageVolume,
+      viewPlaneNormal
+    );
+
+    return { imageVolume, spacingInNormalDirection, actorUID };
+  }
+
+  if (!imageVolumes.length) {
+    return {
+      spacingInNormalDirection: null,
+      imageVolume: null,
+      actorUID: null,
+    };
+  }
+
+  // Fetch volume actor with finest resolution in direction of projection.
+  const smallest = {
+    spacingInNormalDirection: Infinity,
+    imageVolume: null,
+    actorUID: null,
+  };
+
+  const hasPrimaryVolume = imageVolumes.find(isPrimaryVolume);
+
+  for (let i = 0; i < imageVolumes.length; i++) {
+    const imageVolume = imageVolumes[i];
+
+    if (hasPrimaryVolume && !isPrimaryVolume(imageVolume)) {
+      // Secondary volumes like segmentation don't count towards spacing
+      continue;
+    }
+
+    const spacingInNormalDirection = getSpacingInNormalDirection(
+      imageVolume,
+      viewPlaneNormal
+    );
+
+    // Allow for EPSILON part larger requirement to prefer earlier volumes
+    // when the spacing is within a factor of EPSILON.  Use a factor because
+    // that deals with very small or very large volumes effectively.
+    if (
+      spacingInNormalDirection * EPSILON_PART <
+      smallest.spacingInNormalDirection
+    ) {
+      smallest.spacingInNormalDirection = spacingInNormalDirection;
+      smallest.imageVolume = imageVolume;
+      smallest.actorUID = volumeActors[i].uid;
+    }
+  }
+
+  return smallest;
+}