@cornerstonejs/core 2.0.0-beta.1 → 2.0.0-beta.10

package/src/utilities/getCurrentVolumeViewportSlice.ts

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

@@ -0,0 +1,30 @@
+/**
+ * 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

@@ -46,7 +46,9 @@ function getNextRuntimeId(
       n = n + 1;
     } else {
       n = 0;
-      if (i + 1 === idComponents.length) idComponents.push(0);
+      if (i + 1 === idComponents.length) {
+        idComponents.push(0);
+      }
     }
     idComponents[i] = n;
   }

package/src/utilities/getScalingParameters.ts

@@ -17,8 +17,8 @@ export default function getScalingParameters(
   const { modality } = generalSeriesModule;
 
   const scalingParameters = {
-    rescaleSlope: modalityLutModule.rescaleSlope,
-    rescaleIntercept: modalityLutModule.rescaleIntercept,
+    rescaleSlope: modalityLutModule.rescaleSlope || 1,
+    rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
     modality,
   };
 

package/src/utilities/getSpacingInNormalDirection.ts

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import { mat3, vec3 } from 'gl-matrix';
 import { IImageVolume, Point3 } from '../types';
 
 /**
@@ -13,7 +13,7 @@ import { IImageVolume, Point3 } from '../types';
  * @returns
  */
 export default function getSpacingInNormalDirection(
-  imageVolume: IImageVolume,
+  imageVolume: IImageVolume | { direction: mat3; spacing: Point3 },
   viewPlaneNormal: Point3
 ): number {
   const { direction, spacing } = imageVolume;

package/src/utilities/getTargetVolumeAndSpacingInNormalDir.ts

@@ -1,9 +1,9 @@
 import cache from '../cache/cache';
 import { EPSILON } from '../constants';
-// import type { VolumeViewport } from '../RenderingEngine'
-import { ICamera, IImageVolume, IVolumeViewport } from '../types';
+import { ICamera, IImageVolume, IVolumeViewport, Point3 } from '../types';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import { getVolumeLoaderSchemes } from '../loaders/volumeLoader';
+import { getVolumeId } from './getVolumeId';
 
 // One EPSILON part larger multiplier
 const EPSILON_PART = 1 + EPSILON;
@@ -21,23 +21,24 @@ const isPrimaryVolume = (volume): boolean =>
 
 /**
  * Given a volume viewport and camera, find the target volume.
- * The imageVolume is retrieved from cache for the specified targetVolumeId or
+ * The imageVolume is retrieved from cache for the specified targetId 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.
- *
+ * @param targetId - If a targetId is forced to be used.
+ * @param useSlabThickness - If true, the number of steps will be calculated
+ * based on the slab thickness instead of the spacing in the normal direction
  * @returns An object containing the imageVolume and spacingInNormalDirection.
  *
  */
 export default function getTargetVolumeAndSpacingInNormalDir(
   viewport: IVolumeViewport,
   camera: ICamera,
-  targetVolumeId?: string
+  targetId?: string,
+  useSlabThickness = false
 ): {
   imageVolume: IImageVolume;
   spacingInNormalDirection: number;
@@ -64,16 +65,20 @@ export default function getTargetVolumeAndSpacingInNormalDir(
     .filter((iv) => !!iv);
 
   // If a volumeId is defined, set that volume as the target
-  if (targetVolumeId) {
-    const imageVolumeIndex = imageVolumes.findIndex(
-      (iv) => iv.volumeId === targetVolumeId
+  if (targetId) {
+    const targetVolumeId = getVolumeId(targetId);
+    const imageVolumeIndex = imageVolumes.findIndex((iv) =>
+      targetVolumeId.includes(iv.volumeId)
     );
 
     const imageVolume = imageVolumes[imageVolumeIndex];
     const { uid: actorUID } = volumeActors[imageVolumeIndex];
-    const spacingInNormalDirection = getSpacingInNormalDirection(
+
+    const spacingInNormalDirection = getSpacingInNormal(
       imageVolume,
-      viewPlaneNormal
+      viewPlaneNormal,
+      viewport,
+      useSlabThickness
     );
 
     return { imageVolume, spacingInNormalDirection, actorUID };
@@ -104,9 +109,10 @@ export default function getTargetVolumeAndSpacingInNormalDir(
       continue;
     }
 
-    const spacingInNormalDirection = getSpacingInNormalDirection(
+    const spacingInNormalDirection = getSpacingInNormal(
       imageVolume,
-      viewPlaneNormal
+      viewPlaneNormal,
+      viewport
     );
 
     // Allow for EPSILON part larger requirement to prefer earlier volumes
@@ -124,3 +130,21 @@ export default function getTargetVolumeAndSpacingInNormalDir(
 
   return smallest;
 }
+
+function getSpacingInNormal(
+  imageVolume: IImageVolume,
+  viewPlaneNormal: Point3,
+  viewport: IVolumeViewport,
+  useSlabThickness = false
+): number {
+  const { slabThickness } = viewport.getProperties();
+  let spacingInNormalDirection = slabThickness;
+  if (!slabThickness || useSlabThickness === false) {
+    spacingInNormalDirection = getSpacingInNormalDirection(
+      imageVolume,
+      viewPlaneNormal
+    );
+  }
+
+  return spacingInNormalDirection;
+}

package/src/utilities/getViewportImageCornersInWorld.ts

@@ -21,10 +21,17 @@ export default function getViewportImageCornersInWorld(
   const { imageData, dimensions } = viewport.getImageData() as IImageData;
   const { canvas } = viewport;
 
+  // we should consider the device pixel ratio since we are
+  // working with canvas coordinates
+  const ratio = window.devicePixelRatio;
+
   const topLeftCanvas: Point2 = [0, 0];
-  const topRightCanvas: Point2 = [canvas.width, 0];
-  const bottomRightCanvas: Point2 = [canvas.width, canvas.height];
-  const bottomLeftCanvas: Point2 = [0, canvas.height];
+  const topRightCanvas: Point2 = [canvas.width / ratio, 0];
+  const bottomRightCanvas: Point2 = [
+    canvas.width / ratio,
+    canvas.height / ratio,
+  ];
+  const bottomLeftCanvas: Point2 = [0, canvas.height / ratio];
 
   const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
   const topRightWorld = viewport.canvasToWorld(topRightCanvas);

package/src/utilities/getViewportImageIds.ts

@@ -0,0 +1,22 @@
+import { VolumeViewport } from '../RenderingEngine';
+import cache from '../cache';
+import { IViewport, IStackViewport } from '../types';
+
+/**
+ * Retrieves the image IDs from the given viewport.
+ *
+ * @param viewport - The viewport to retrieve the image IDs from.
+ * @returns An array of image IDs.
+ */
+function getViewportImageIds(viewport: IViewport) {
+  if (viewport instanceof VolumeViewport) {
+    const defaultActor = viewport.getDefaultActor();
+    const volumeId = defaultActor.uid;
+    const volume = cache.getVolume(volumeId);
+    return volume.imageIds;
+  } else if ((viewport as IStackViewport).getImageIds) {
+    return (viewport as IStackViewport).getImageIds();
+  }
+}
+
+export default getViewportImageIds;

package/src/utilities/getViewportModality.ts

@@ -0,0 +1,22 @@
+import type { IViewport, IStackViewport, IVolumeViewport } from '../types';
+import cache from '../cache';
+
+function getViewportModality(viewport: IViewport, volumeId?: string): string {
+  if ((viewport as IStackViewport).modality) {
+    return (viewport as IStackViewport).modality;
+  }
+
+  if ((viewport as IVolumeViewport).setVolumes) {
+    volumeId = volumeId ?? viewport.getDefaultActor()?.uid;
+
+    if (!volumeId) {
+      return;
+    }
+
+    return cache.getVolume(volumeId)?.metadata.Modality;
+  }
+
+  throw new Error('Invalid viewport type');
+}
+
+export { getViewportModality as default, getViewportModality };

package/src/utilities/getViewportsWithImageURI.ts

@@ -26,20 +26,13 @@ export default function getViewportsWithImageURI(
 
   const viewports = [];
   renderingEngines.forEach((renderingEngine) => {
-    const stackViewports = renderingEngine.getStackViewports();
+    const viewportsForRenderingEngine = renderingEngine.getViewports();
 
-    const filteredStackViewports = stackViewports.filter((viewport) =>
-      viewport.hasImageURI(imageURI)
-    );
-
-    // If no stack viewport found but a volumeViewport is rendering the same data
-    const volumeViewports = renderingEngine.getVolumeViewports();
-
-    const filteredVolumeViewports = volumeViewports.filter((viewport) =>
-      viewport.hasImageURI(imageURI)
-    );
-
-    viewports.push(...filteredStackViewports, ...filteredVolumeViewports);
+    viewportsForRenderingEngine.forEach((viewport) => {
+      if (viewport.hasImageURI(imageURI)) {
+        viewports.push(viewport);
+      }
+    });
   });
 
   return viewports;

package/src/utilities/getVolumeId.ts

@@ -0,0 +1,16 @@
+/**
+ * Retrieves the volume ID from a target ID. Target Id is not only
+ * volumeId but might include other information, but it starts with volumeId.
+ *
+ * @param targetId - The target ID from which to extract the volume ID.
+ * @returns The volume ID extracted from the target ID.
+ */
+export const getVolumeId = (targetId: string) => {
+  const prefix = 'volumeId:';
+  const str = targetId.includes(prefix)
+    ? targetId.substring(prefix.length)
+    : targetId;
+
+  const index = str.indexOf('?');
+  return index === -1 ? str : str.substring(0, index);
+};

package/src/utilities/getVolumeSliceRangeInfo.ts

@@ -11,11 +11,14 @@ import {
  * Calculates the slice range for the given volume based on its orientation
  * @param viewport - Volume viewport
  * @param volumeId - Id of one of the volumes loaded on the given viewport
+ * @param useSlabThickness - If true, the slice range will be calculated
+ * based on the slab thickness instead of the spacing in the normal direction
  * @returns slice range information
  */
 function getVolumeSliceRangeInfo(
   viewport: IVolumeViewport,
-  volumeId: string
+  volumeId: string,
+  useSlabThickness = false
 ): {
   sliceRange: ActorSliceRange;
   spacingInNormalDirection: number;
@@ -24,7 +27,12 @@ function getVolumeSliceRangeInfo(
   const camera = viewport.getCamera();
   const { focalPoint, viewPlaneNormal } = camera;
   const { spacingInNormalDirection, actorUID } =
-    getTargetVolumeAndSpacingInNormalDir(viewport, camera, volumeId);
+    getTargetVolumeAndSpacingInNormalDir(
+      viewport,
+      camera,
+      volumeId,
+      useSlabThickness
+    );
 
   if (!actorUID) {
     throw new Error(

package/src/utilities/getVolumeViewportScrollInfo.ts

@@ -5,14 +5,17 @@ import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo';
  * Calculates the number os steps the volume can scroll based on its orientation
  * @param viewport - Volume viewport
  * @param volumeId - Id of one of the volumes loaded on the given viewport
+ * @param useSlabThickness - If true, the number of steps will be calculated
+ * based on the slab thickness instead of the spacing in the normal direction
  * @returns number of steps the volume can scroll and its current position
  */
 function getVolumeViewportScrollInfo(
   viewport: IVolumeViewport,
-  volumeId: string
+  volumeId: string,
+  useSlabThickness = false
 ) {
   const { sliceRange, spacingInNormalDirection, camera } =
-    getVolumeSliceRangeInfo(viewport, volumeId);
+    getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness);
 
   const { min, max, current } = sliceRange;
 

package/src/utilities/hasFloatScalingParameters.ts

@@ -0,0 +1,15 @@
+import { ScalingParameters } from '../types';
+
+/**
+ * Checks if the scaling parameters contain a float rescale value.
+ * @param scalingParameters - The scaling parameters to check.
+ * @returns True if the scaling parameters contain a float rescale value, false otherwise.
+ */
+export const hasFloatScalingParameters = (
+  scalingParameters: ScalingParameters
+): boolean => {
+  const hasFloatRescale = Object.values(scalingParameters).some(
+    (value) => typeof value === 'number' && !Number.isInteger(value)
+  );
+  return hasFloatRescale;
+};

package/src/utilities/imageRetrieveMetadataProvider.ts

@@ -0,0 +1,36 @@
+import { addProvider } from '../metaData';
+
+const retrieveConfigurationState = new Map<string, any>();
+
+const IMAGE_RETRIEVE_CONFIGURATION = 'imageRetrieveConfiguration';
+
+/**
+ * Simple metadataProvider object to store metadata for the image retrieval.
+ */
+const imageRetrieveMetadataProvider = {
+  IMAGE_RETRIEVE_CONFIGURATION,
+
+  /** Empty the metadata state */
+  clear: () => {
+    retrieveConfigurationState.clear();
+  },
+
+  /* Adding a new entry to the state object. */
+  add: (key: string, payload): void => {
+    retrieveConfigurationState.set(key, payload);
+  },
+
+  get: (type: string, ...queries: string[]) => {
+    if (type === IMAGE_RETRIEVE_CONFIGURATION) {
+      return queries
+        .map((query) => retrieveConfigurationState.get(query))
+        .find((it) => it !== undefined);
+    }
+  },
+};
+
+addProvider(
+  imageRetrieveMetadataProvider.get.bind(imageRetrieveMetadataProvider)
+);
+
+export default imageRetrieveMetadataProvider;