@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

package/src/utilities/scaleRgbTransferFunction.ts

@@ -1,37 +0,0 @@
-/**
- * A utility that can be used to scale (in place) an RgbTransferFunction. We
- * often use this to scale the transfer function based on a PET calculation.
- *
- * @example
- * Grabbing a reference to the RGB Transfer function from the viewport:
- * ```
- * const rgbTransferFunction = viewport
- *   .getActor()
- *   .getProperty()
- *   .getRGBTransferFunction(0);
- *
- * scaleRgbTransferFunction(rgbTransferFunction, 2);
- * ```
- *
- * @see {@link https://kitware.github.io/vtk-js/api/Rendering_Core_ColorTransferFunction.html|VTK.js: ColorTransferFunction}
- * @param rgbTransferFunction
- * @param scalingFactor
- */
-export default function scaleRGBTransferFunction(
-  rgbTransferFunction: any,
-  scalingFactor: number
-): void {
-  const size = rgbTransferFunction.getSize();
-
-  for (let index = 0; index < size; index++) {
-    const nodeValue1 = [];
-
-    rgbTransferFunction.getNodeValue(index, nodeValue1);
-
-    nodeValue1[1] = nodeValue1[1] * scalingFactor;
-    nodeValue1[2] = nodeValue1[2] * scalingFactor;
-    nodeValue1[3] = nodeValue1[3] * scalingFactor;
-
-    rgbTransferFunction.setNodeValue(index, nodeValue1);
-  }
-}

package/src/utilities/snapFocalPointToSlice.ts

@@ -1,78 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { ActorSliceRange, Point3 } from '../types';
-
-/**
- * Given a number of frames, `deltaFrames`,
- * move the `focalPoint` and camera `position` so that it moves forward/backwards
- * `deltaFrames` in the camera's normal direction, and snaps to the nearest frame.
- *
- * @param focalPoint - The focal point to move.
- * @param position - The camera position to move.
- * @param sliceRange - The scroll range used to find the current
- * position in the stack, as well as prevent scrolling past the extent of the volume.
- * @param viewPlaneNormal - The normal direction of the camera.
- * @param spacingInNormalDirection - The spacing of frames the normal direction of the camera.
- * @param deltaFrames - The number of frames to jump.
- *
- * @returns The `newFocalPoint` and `newPosition` of the camera.
- */
-export default function snapFocalPointToSlice(
-  focalPoint: Point3,
-  position: Point3,
-  sliceRange: ActorSliceRange,
-  viewPlaneNormal: Point3,
-  spacingInNormalDirection: number,
-  deltaFrames: number
-): { newFocalPoint: Point3; newPosition: Point3 } {
-  const { min, max, current } = sliceRange;
-
-  // Get the current offset off the camera position so we can add it on at the end.
-  const posDiffFromFocalPoint = vec3.create();
-
-  vec3.sub(posDiffFromFocalPoint, <vec3>position, <vec3>focalPoint);
-
-  // Now we can see how many steps there are in this direction
-  const steps = Math.round((max - min) / spacingInNormalDirection);
-
-  // Find out current frameIndex
-  const fraction = (current - min) / (max - min);
-  const floatingStepNumber = fraction * steps;
-  let frameIndex = Math.round(floatingStepNumber);
-
-  // Dolly the focal point back to min slice focal point.
-  let newFocalPoint = <Point3>[
-    focalPoint[0] -
-      viewPlaneNormal[0] * floatingStepNumber * spacingInNormalDirection,
-    focalPoint[1] -
-      viewPlaneNormal[1] * floatingStepNumber * spacingInNormalDirection,
-    focalPoint[2] -
-      viewPlaneNormal[2] * floatingStepNumber * spacingInNormalDirection,
-  ];
-
-  // Increment the slice number by deltaFrames.
-  frameIndex += deltaFrames;
-
-  // Clamp sliceNumber to volume.
-  if (frameIndex > steps) {
-    frameIndex = steps;
-  } else if (frameIndex < 0) {
-    frameIndex = 0;
-  }
-
-  // Dolly the focal towards to the correct frame focal point.
-  const newSlicePosFromMin = frameIndex * spacingInNormalDirection;
-
-  newFocalPoint = <Point3>[
-    newFocalPoint[0] + viewPlaneNormal[0] * newSlicePosFromMin,
-    newFocalPoint[1] + viewPlaneNormal[1] * newSlicePosFromMin,
-    newFocalPoint[2] + viewPlaneNormal[2] * newSlicePosFromMin,
-  ];
-
-  const newPosition = <Point3>[
-    newFocalPoint[0] + posDiffFromFocalPoint[0],
-    newFocalPoint[1] + posDiffFromFocalPoint[1],
-    newFocalPoint[2] + posDiffFromFocalPoint[2],
-  ];
-
-  return { newFocalPoint, newPosition };
-}

package/src/utilities/sortImageIdsAndGetSpacing.ts

@@ -1,180 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { metaData, getConfiguration } from '../';
-import { Point3 } from '../types';
-
-type SortedImageIdsItem = {
-  zSpacing: number;
-  origin: Point3;
-  sortedImageIds: Array<string>;
-};
-/**
- * Given an array of imageIds, sort them based on their imagePositionPatient, and
- * also returns the spacing between images and the origin of the reference image
- *
- * @param imageIds - array of imageIds
- * @param scanAxisNormal - [x, y, z] array or gl-matrix vec3
- *
- * @returns The sortedImageIds, zSpacing, and origin of the first image in the series.
- */
-export default function sortImageIdsAndGetSpacing(
-  imageIds: Array<string>,
-  scanAxisNormal?: vec3
-): SortedImageIdsItem {
-  const {
-    imagePositionPatient: referenceImagePositionPatient,
-    imageOrientationPatient,
-  } = metaData.get('imagePlaneModule', imageIds[0]);
-
-  if (!scanAxisNormal) {
-    const rowCosineVec = vec3.fromValues(
-      imageOrientationPatient[0],
-      imageOrientationPatient[1],
-      imageOrientationPatient[2]
-    );
-    const colCosineVec = vec3.fromValues(
-      imageOrientationPatient[3],
-      imageOrientationPatient[4],
-      imageOrientationPatient[5]
-    );
-
-    scanAxisNormal = vec3.create();
-    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
-  }
-
-  const refIppVec = vec3.create();
-
-  // Check if we are using wadouri scheme
-  const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
-
-  vec3.set(
-    refIppVec,
-    referenceImagePositionPatient[0],
-    referenceImagePositionPatient[1],
-    referenceImagePositionPatient[2]
-  );
-
-  let sortedImageIds: string[];
-  let zSpacing: number;
-
-  function getDistance(imageId: string) {
-    const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
-
-    const positionVector = vec3.create();
-
-    vec3.sub(
-      positionVector,
-      referenceImagePositionPatient,
-      imagePositionPatient
-    );
-
-    return vec3.dot(positionVector, scanAxisNormal);
-  }
-
-  /**
-   * If we are using wadors and so have all image metadata cached ahead of time,
-   * then sort by image position in 3D space, and calculate average slice
-   * spacing from the entire volume. If not, then use the sampled images (1st
-   * and middle) to calculate slice spacing, and use the provided imageId order.
-   * Correct sorting must be done ahead of time.
-   */
-  if (!usingWadoUri) {
-    const distanceImagePairs = imageIds.map((imageId) => {
-      const distance = getDistance(imageId);
-
-      return {
-        distance,
-        imageId,
-      };
-    });
-
-    distanceImagePairs.sort((a, b) => b.distance - a.distance);
-
-    sortedImageIds = distanceImagePairs.map((a) => a.imageId);
-    const numImages = distanceImagePairs.length;
-
-    // Calculated average spacing.
-    // We would need to resample if these are not similar.
-    // It should be up to the host app to do this if it needed to.
-    zSpacing =
-      Math.abs(
-        distanceImagePairs[numImages - 1].distance -
-          distanceImagePairs[0].distance
-      ) /
-      (numImages - 1);
-  } else {
-    // Using wadouri, so we have only prefetched the first, middle, and last
-    // images for metadata. Assume initial imageId array order is pre-sorted,
-    // but check orientation.
-    const prefetchedImageIds = [
-      imageIds[0],
-      imageIds[Math.floor(imageIds.length / 2)],
-    ];
-    sortedImageIds = imageIds;
-    const firstImageDistance = getDistance(prefetchedImageIds[0]);
-    const middleImageDistance = getDistance(prefetchedImageIds[1]);
-    if (firstImageDistance - middleImageDistance < 0) {
-      sortedImageIds.reverse();
-    }
-
-    // Calculate average spacing between the first and middle prefetched images,
-    // otherwise fall back to DICOM `spacingBetweenSlices`
-    const metadataForMiddleImage = metaData.get(
-      'imagePlaneModule',
-      prefetchedImageIds[1]
-    );
-    if (!metadataForMiddleImage) {
-      throw new Error('Incomplete metadata required for volume construction.');
-    }
-
-    const positionVector = vec3.create();
-
-    vec3.sub(
-      positionVector,
-      referenceImagePositionPatient,
-      metadataForMiddleImage.imagePositionPatient
-    );
-    const distanceBetweenFirstAndMiddleImages = vec3.dot(
-      positionVector,
-      scanAxisNormal
-    );
-    zSpacing =
-      Math.abs(distanceBetweenFirstAndMiddleImages) /
-      Math.floor(imageIds.length / 2);
-  }
-
-  const {
-    imagePositionPatient: origin,
-    sliceThickness,
-    spacingBetweenSlices,
-  } = metaData.get('imagePlaneModule', sortedImageIds[0]);
-
-  const { strictZSpacingForVolumeViewport } = getConfiguration().rendering;
-
-  // We implemented these lines for multiframe dicom files that does not have
-  // position for each frame, leading to incorrect calculation of zSpacing = 0
-  // If possible, we use the sliceThickness, but we warn about this dicom file
-  // weirdness. If sliceThickness is not available, we set to 1 just to render
-  if (zSpacing === 0 && !strictZSpacingForVolumeViewport) {
-    if (sliceThickness && spacingBetweenSlices) {
-      console.log('Could not calculate zSpacing. Using spacingBetweenSlices');
-      zSpacing = spacingBetweenSlices;
-    } else if (sliceThickness) {
-      console.log(
-        'Could not calculate zSpacing and no spacingBetweenSlices. Using sliceThickness'
-      );
-      zSpacing = sliceThickness;
-    } else {
-      console.log(
-        'Could not calculate zSpacing. The VolumeViewport visualization is compromised. Setting zSpacing to 1 to render'
-      );
-      zSpacing = 1;
-    }
-  }
-  const result: SortedImageIdsItem = {
-    zSpacing,
-    origin,
-    sortedImageIds,
-  };
-
-  return result;
-}

package/src/utilities/spatialRegistrationMetadataProvider.ts

@@ -1,48 +0,0 @@
-import { mat4 } from 'gl-matrix';
-import { addProvider } from '../metaData';
-
-const state = {};
-
-/**
- * Simple metadataProvider object to store metadata for spatial registration module.
- */
-const spatialRegistrationMetadataProvider = {
-  /* Adding a new entry to the state object. */
-  add: (query: string[], payload: mat4): void => {
-    const [viewportId1, viewportId2] = query;
-    const entryId = `${viewportId1}_${viewportId2}`;
-
-    if (!state[entryId]) {
-      state[entryId] = {};
-    }
-
-    state[entryId] = payload;
-  },
-
-  get: (type: string, viewportId1: string, viewportId2: string): mat4 => {
-    if (type !== 'spatialRegistrationModule') {
-      return;
-    }
-
-    // check both ways
-    const entryId = `${viewportId1}_${viewportId2}`;
-
-    if (state[entryId]) {
-      return state[entryId];
-    }
-
-    const entryIdReverse = `${viewportId2}_${viewportId1}`;
-
-    if (state[entryIdReverse]) {
-      return mat4.invert(mat4.create(), state[entryIdReverse]);
-    }
-  },
-};
-
-addProvider(
-  spatialRegistrationMetadataProvider.get.bind(
-    spatialRegistrationMetadataProvider
-  )
-);
-
-export default spatialRegistrationMetadataProvider;

package/src/utilities/transferFunctionUtils.ts

@@ -1,27 +0,0 @@
-function getTransferFunctionNodes(transferFunction) {
-  const size = transferFunction.getSize();
-  const values = [];
-  for (let index = 0; index < size; index++) {
-    const nodeValue1 = [];
-
-    transferFunction.getNodeValue(index, nodeValue1);
-
-    values.push(nodeValue1);
-  }
-
-  return values;
-}
-
-function setTransferFunctionNodes(transferFunction, nodes) {
-  if (!nodes?.length) {
-    return;
-  }
-
-  transferFunction.removeAllPoints();
-
-  nodes.forEach((node) => {
-    transferFunction.addRGBPoint(...node);
-  });
-}
-
-export { getTransferFunctionNodes, setTransferFunctionNodes };

package/src/utilities/transformCanvasToIJK.ts

@@ -1,18 +0,0 @@
-import { IStackViewport, IVolumeViewport, Point2 } from '../types';
-import transformWorldToIndex from './transformWorldToIndex';
-
-/**
- * Convert coordinates from canvas to index (volume) space
- * @param viewport - Stack or Volume viewport
- * @param ijkPoint - 2D point in canvas space
- * @returns 3D point in index (volume) space
- */
-export function transformCanvasToIJK(
-  viewport: IVolumeViewport | IStackViewport,
-  canvasPoint: Point2
-) {
-  const { imageData: vtkImageData } = viewport.getImageData();
-  const worldPoint = viewport.canvasToWorld(canvasPoint);
-
-  return transformWorldToIndex(vtkImageData, worldPoint);
-}

package/src/utilities/transformIJKToCanvas.ts

@@ -1,18 +0,0 @@
-import { IStackViewport, IVolumeViewport, Point3 } from '../types';
-import transformIndexToWorld from './transformIndexToWorld';
-
-/**
- * Convert coordinates from index (volume) to canvas space
- * @param viewport - Stack or Volume viewport
- * @param ijkPoint - 3D point in index (volume) space
- * @returns 2D point in canvas space
- */
-export function transformIJKToCanvas(
-  viewport: IVolumeViewport | IStackViewport,
-  ijkPoint: Point3
-) {
-  const { imageData: vtkImageData } = viewport.getImageData();
-  const worldPoint = transformIndexToWorld(vtkImageData, ijkPoint);
-
-  return viewport.worldToCanvas(worldPoint);
-}

package/src/utilities/transformIndexToWorld.ts

@@ -1,14 +0,0 @@
-import type Point3 from '../types/Point3';
-
-/**
- * Given an imageData object and a position in voxel space, return a point
- * in world space.
- *
- * @param imageData - The image data object.
- * @param voxelPos - Point in voxel space
- * index space.
- * @returns A point in world space.
- */
-export default function transformIndexToWorld(imageData, voxelPos: Point3) {
-  return imageData.indexToWorld(voxelPos);
-}

package/src/utilities/transformWorldToIndex.ts

@@ -1,16 +0,0 @@
-import type Point3 from '../types/Point3';
-
-/**
- * Given an imageData object and a point in physical space, return the index of the
- * voxel that contains the point. TODO: this should be pushed to vtk upstream.
- * @param imageData - The image data object.
- * @param physicalPoint - The point in physical space that you want to transform to
- * index space.
- * @returns An array of integers.
- */
-export default function transformWorldToIndex(imageData, worldPos: Point3) {
-  const continuousIndex = imageData.worldToIndex(worldPos);
-  const index = continuousIndex.map(Math.round);
-
-  return index;
-}

package/src/utilities/triggerEvent.ts

@@ -1,38 +0,0 @@
-import eventTarget from '../eventTarget';
-
-/**
- * Small utility to trigger a custom event for a given EventTarget.
- *
- * @example
- *
- * ```javascript
- * triggerEvent(element, Events.IMAGE_RENDERED, { element })
- * ```
- * or it can trigger event on the eventTarget itself
- *
- * ```javascript
- * triggerEvent(eventTarget, CSTOOLS_EVENTS.ANNOTATION_MODIFIED, { viewportId, annotationUID })
- * ```
- *
- * @param el - The element or EventTarget to trigger the event upon
- * @param type - The event type name
- * @param detail - The event detail to be sent
- * @returns false if event is cancelable and at least one of the event handlers
- * which received event called Event.preventDefault(). Otherwise it returns true.
- */
-export default function triggerEvent(
-  el: EventTarget = eventTarget,
-  type: string,
-  detail: unknown = null
-): boolean {
-  if (!type) {
-    throw new Error('Event type was not defined');
-  }
-
-  const event = new CustomEvent(type, {
-    detail,
-    cancelable: true,
-  });
-
-  return el.dispatchEvent(event);
-}

package/src/utilities/updateVTKImageDataWithCornerstoneImage.ts

@@ -1,42 +0,0 @@
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { IImage, PixelDataTypedArray } from '../types';
-
-function updateVTKImageDataWithCornerstoneImage(
-  sourceImageData: vtkImageData,
-  image: IImage
-) {
-  const pixelData = image.getPixelData();
-  if (!sourceImageData.getPointData) {
-    // This happens for a CanvasActor, that doesn't have the getPointData
-    return;
-  }
-  const scalarData = sourceImageData
-    .getPointData()
-    .getScalars()
-    .getData() as PixelDataTypedArray;
-
-  // if the color image is loaded with CPU previously, it loads it
-  // with RGBA, and here we need to remove the A channel from the
-  // pixel data.
-  if (image.color && image.rgba) {
-    const newPixelData = new Uint8Array(image.columns * image.rows * 3);
-    for (let i = 0; i < image.columns * image.rows; i++) {
-      newPixelData[i * 3] = pixelData[i * 4];
-      newPixelData[i * 3 + 1] = pixelData[i * 4 + 1];
-      newPixelData[i * 3 + 2] = pixelData[i * 4 + 2];
-    }
-    // modify the image object to have the correct pixel data for later
-    // use.
-    image.rgba = false;
-    image.getPixelData = () => newPixelData;
-    scalarData.set(newPixelData);
-  } else {
-    scalarData.set(pixelData);
-  }
-
-  // Trigger modified on the VTK Object so the texture is updated
-  // TODO: evaluate directly changing things with texSubImage3D later
-  sourceImageData.modified();
-}
-
-export { updateVTKImageDataWithCornerstoneImage };

package/src/utilities/uuidv4.ts

@@ -1,13 +0,0 @@
-// prettier-ignore
-// @ts-nocheck
-/**
- * Generates a unique id that has limited chance of collision
- *
- * @see {@link https://stackoverflow.com/a/2117523/1867984|StackOverflow: Source}
- * @returns a v4 compliant GUID
- */
-export default function uuidv4(): string {
-  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
-    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
-  );
-}

package/src/utilities/windowLevel.ts

@@ -1,48 +0,0 @@
-/**
- * Given a low and high window level, return the window width and window center
- * Formulas from note 4 in
- * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
- * extended to allow for low/high swapping
- * @param low - The low window level.
- * @param high - The high window level.
- * @returns a JavaScript object with two properties: windowWidth and windowCenter.
- */
-function toWindowLevel(
-  low: number,
-  high: number
-): {
-  windowWidth: number;
-  windowCenter: number;
-} {
-  // Allow for swapping high/low
-  const windowWidth = Math.abs(high - low) + 1;
-  const windowCenter = (low + high + 1) / 2;
-
-  return { windowWidth, windowCenter };
-}
-
-/**
- * Given a window width and center, return the lower and upper bounds of the window
- * The formulas for the calculation are specified in
- * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
- * if (x <= c - 0.5 - (w-1) /2), then y = ymin
- * else if (x > c - 0.5 + (w-1) /2), then y = ymax
- * else y = ((x - (c - 0.5)) / (w-1) + 0.5) * (ymax- ymin) + ymin
- * @param windowWidth - the width of the window in HU
- * @param windowCenter - The center of the window.
- * @returns a JavaScript object with two properties: lower and upper.
- */
-function toLowHighRange(
-  windowWidth: number,
-  windowCenter: number
-): {
-  lower: number;
-  upper: number;
-} {
-  const lower = windowCenter - 0.5 - (windowWidth - 1) / 2;
-  const upper = windowCenter - 0.5 + (windowWidth - 1) / 2;
-
-  return { lower, upper };
-}
-
-export { toWindowLevel, toLowHighRange };

package/src/utilities/worldToImageCoords.ts

@@ -1,65 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { metaData } from '..';
-import { Point2, Point3 } from '../types';
-
-/**
- * Given the imageId, and 3d coordinates on the world space, it returns the continuos
- * image coordinates (IJ) on the image space. The image space is
- * defined with [0,0] being on the top left corner of the top left pixel,
- * the [1,1] being on the bottom right corner of the top left pixel.
- * @param imageId - The image id
- * @param worldCoords - The 3d coordinates on the world.
- * @returns The 2d coordinates on the image.
- *
- */
-function worldToImageCoords(
-  imageId: string,
-  worldCoords: Point3
-): Point2 | undefined {
-  const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-
-  if (!imagePlaneModule) {
-    throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
-  }
-
-  // For the image coordinates we need to calculate the transformation matrix
-  // from the world coordinates to the image coordinates.
-
-  const {
-    columnCosines,
-    rowCosines,
-    imagePositionPatient: origin,
-  } = imagePlaneModule;
-
-  let { columnPixelSpacing, rowPixelSpacing } = imagePlaneModule;
-  // Use ||= to convert null and 0 as well as undefined to 1
-  columnPixelSpacing ||= 1;
-  rowPixelSpacing ||= 1;
-
-  // The origin is the image position patient, but since image coordinates start
-  // from [0,0] for the top left hand of the first pixel, and the origin is at the
-  // center of the first pixel, we need to account for this.
-  const newOrigin = vec3.create();
-
-  vec3.scaleAndAdd(newOrigin, origin, columnCosines, -columnPixelSpacing / 2);
-  vec3.scaleAndAdd(newOrigin, newOrigin, rowCosines, -rowPixelSpacing / 2);
-
-  // Get the subtraction vector from the origin to the world coordinates
-  const sub = vec3.create();
-  vec3.sub(sub, worldCoords, newOrigin);
-
-  // Projected distance of the sub vector onto the rowCosines
-  const rowDistance = vec3.dot(sub, rowCosines);
-
-  // Projected distance of the sub vector onto the columnCosines
-  const columnDistance = vec3.dot(sub, columnCosines);
-
-  const imageCoords = [
-    rowDistance / rowPixelSpacing,
-    columnDistance / columnPixelSpacing,
-  ];
-
-  return imageCoords as Point2;
-}
-
-export default worldToImageCoords;