@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

package/src/utilities/getSpacingInNormalDirection.ts

@@ -1,44 +0,0 @@
-import { mat3, 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 | { direction: mat3; spacing: Point3 },
-  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

@@ -1,150 +0,0 @@
-import cache from '../cache/cache';
-import { EPSILON } from '../constants';
-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;
-
-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 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 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,
-  targetId?: string,
-  useSlabThickness = false
-): {
-  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 (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 = getSpacingInNormal(
-      imageVolume,
-      viewPlaneNormal,
-      viewport,
-      useSlabThickness
-    );
-
-    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 = getSpacingInNormal(
-      imageVolume,
-      viewPlaneNormal,
-      viewport
-    );
-
-    // 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;
-}
-
-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

@@ -1,109 +0,0 @@
-import {
-  IImageData,
-  IStackViewport,
-  IVolumeViewport,
-  Point2,
-  Point3,
-} from '../types';
-
-/**
- * Given a viewport, return the corners of the image in the viewport in world coordinates.
- * Note that this is different than the corners of the canvas in world coordinates since
- * an image can be zoomed out and the canvas can be larger than the image; hence, the
- * corners of the canvas in world coordinates will be outside the image.
- *
- * @param viewport - The viewport to get the corners of.
- * @returns The corners of the image in the viewport in world coordinates.
- */
-export default function getViewportImageCornersInWorld(
-  viewport: IStackViewport | IVolumeViewport
-): Point3[] {
-  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 / 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);
-  const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
-  const bottomLeftWorld = viewport.canvasToWorld(bottomLeftCanvas);
-
-  const topLeftImage = imageData.worldToIndex(topLeftWorld);
-  const topRightImage = imageData.worldToIndex(topRightWorld);
-  const bottomRightImage = imageData.worldToIndex(bottomRightWorld);
-  const bottomLeftImage = imageData.worldToIndex(bottomLeftWorld);
-
-  return _getStackViewportImageCorners({
-    dimensions,
-    imageData,
-    topLeftImage,
-    topRightImage,
-    bottomRightImage,
-    bottomLeftImage,
-    topLeftWorld,
-    topRightWorld,
-    bottomRightWorld,
-    bottomLeftWorld,
-  });
-}
-
-function _getStackViewportImageCorners({
-  dimensions,
-  imageData,
-  topLeftImage,
-  topRightImage,
-  bottomRightImage,
-  bottomLeftImage,
-  topLeftWorld,
-  topRightWorld,
-  bottomRightWorld,
-  bottomLeftWorld,
-}) {
-  const topLeftImageWorld = _isInBounds(topLeftImage, dimensions)
-    ? topLeftWorld
-    : (imageData.indexToWorld([0, 0, 0]) as Point3);
-
-  const topRightImageWorld = _isInBounds(topRightImage, dimensions)
-    ? topRightWorld
-    : (imageData.indexToWorld([dimensions[0] - 1, 0, 0]) as Point3);
-
-  const bottomRightImageWorld = _isInBounds(bottomRightImage, dimensions)
-    ? bottomRightWorld
-    : (imageData.indexToWorld([
-        dimensions[0] - 1,
-        dimensions[1] - 1,
-        0,
-      ]) as Point3);
-
-  const bottomLeftImageWorld = _isInBounds(bottomLeftImage, dimensions)
-    ? bottomLeftWorld
-    : (imageData.indexToWorld([0, dimensions[1] - 1, 0]) as Point3);
-
-  return [
-    topLeftImageWorld,
-    topRightImageWorld,
-    bottomLeftImageWorld,
-    bottomRightImageWorld,
-  ];
-}
-
-function _isInBounds(imageCoord, dimensions) {
-  return (
-    imageCoord[0] > 0 ||
-    imageCoord[0] < dimensions[0] - 1 ||
-    imageCoord[1] > 0 ||
-    imageCoord[1] < dimensions[1] - 1 ||
-    imageCoord[2] > 0 ||
-    imageCoord[2] < dimensions[2] - 1
-  );
-}

package/src/utilities/getViewportImageIds.ts

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

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

@@ -1,39 +0,0 @@
-import { getRenderingEngine } from '../RenderingEngine';
-import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
-import { IStackViewport, IVolumeViewport } from '../types';
-
-type Viewport = IStackViewport | IVolumeViewport;
-
-/**
- * Get the viewport that is rendering the image with the given imageURI (imageId without
- * the loader schema), this can be a stackViewport or a volumeViewport.
- *
- * @param renderingEngine - The rendering engine that is rendering the viewports
- * @param imageURI - The imageURI of the image that is requested
- * @returns A Viewport
- */
-export default function getViewportsWithImageURI(
-  imageURI: string,
-  renderingEngineId?: string
-): Array<Viewport> {
-  // If rendering engine is not provided, use all rendering engines
-  let renderingEngines;
-  if (renderingEngineId) {
-    renderingEngines = [getRenderingEngine(renderingEngineId)];
-  } else {
-    renderingEngines = getRenderingEngines();
-  }
-
-  const viewports = [];
-  renderingEngines.forEach((renderingEngine) => {
-    const viewportsForRenderingEngine = renderingEngine.getViewports();
-
-    viewportsForRenderingEngine.forEach((viewport) => {
-      if (viewport.hasImageURI(imageURI)) {
-        viewports.push(viewport);
-      }
-    });
-  });
-
-  return viewports;
-}

package/src/utilities/getViewportsWithVolumeId.ts

@@ -1,38 +0,0 @@
-import { IVolumeViewport } from '../types';
-import {
-  getRenderingEngines,
-  getRenderingEngine,
-} from '../RenderingEngine/getRenderingEngine';
-
-/**
- * Similar to {@link getVolumeViewportsContainingSameVolumes}, but uses the volumeId
- * to filter viewports that contain the same volume.
- *
- * @returns VolumeViewport viewports array
- */
-function getViewportsWithVolumeId(
-  volumeId: string,
-  renderingEngineId?: string
-): Array<IVolumeViewport> {
-  // If rendering engine is not provided, use all rendering engines
-  let renderingEngines;
-  if (renderingEngineId) {
-    renderingEngines = [getRenderingEngine(renderingEngineId)];
-  } else {
-    renderingEngines = getRenderingEngines();
-  }
-
-  const targetViewports = [];
-
-  renderingEngines.forEach((renderingEngine) => {
-    const viewports = renderingEngine.getVolumeViewports();
-    const filteredViewports = viewports.filter((vp) =>
-      vp.hasVolumeId(volumeId)
-    );
-    targetViewports.push(...filteredViewports);
-  });
-
-  return targetViewports;
-}
-
-export default getViewportsWithVolumeId;

package/src/utilities/getVoiFromSigmoidRGBTransferFunction.ts

@@ -1,23 +0,0 @@
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-
-export default function getVoiFromSigmoidRGBTransferFunction(
-  cfun: vtkColorTransferFunction
-): [number, number] {
-  let cfunRange = [];
-  // @ts-ignore: vtk d ts problem
-  const [lower, upper] = cfun.getRange();
-  cfun.getTable(lower, upper, 1024, cfunRange);
-  cfunRange = cfunRange.filter((v, k) => k % 3 === 0);
-  const cfunDomain = [...Array(1024).keys()].map((v, k) => {
-    return lower + ((upper - lower) / (1024 - 1)) * k;
-  });
-  const y1 = cfunRange[256];
-  const logy1 = Math.log((1 - y1) / y1);
-  const x1 = cfunDomain[256];
-  const y2 = cfunRange[256 * 3];
-  const logy2 = Math.log((1 - y2) / y2);
-  const x2 = cfunDomain[256 * 3];
-  const ww = Math.round((4 * (x2 - x1)) / (logy1 - logy2));
-  const wc = Math.round(x1 + (ww * logy1) / 4);
-  return [Math.round(wc - ww / 2), Math.round(wc + ww / 2)];
-}

package/src/utilities/getVolumeActorCorners.ts

@@ -1,24 +0,0 @@
-import { Point3 } from '../types';
-
-/**
- * Converts `vtkVolumeActor` bounds to corners in world space.
- *
- * @param volumeActor - The `vtkVolumeActor`.
- *
- * @returns An array of the corners of the `volumeActor` in world space.
- */
-export default function getVolumeActorCorners(volumeActor): Array<Point3> {
-  const imageData = volumeActor.getMapper().getInputData();
-  const bounds = imageData.extentToBounds(imageData.getExtent());
-
-  return [
-    [bounds[0], bounds[2], bounds[4]],
-    [bounds[0], bounds[2], bounds[5]],
-    [bounds[0], bounds[3], bounds[4]],
-    [bounds[0], bounds[3], bounds[5]],
-    [bounds[1], bounds[2], bounds[4]],
-    [bounds[1], bounds[2], bounds[5]],
-    [bounds[1], bounds[3], bounds[4]],
-    [bounds[1], bounds[3], bounds[5]],
-  ];
-}

package/src/utilities/getVolumeId.ts

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

@@ -1,60 +0,0 @@
-import getSliceRange from './getSliceRange';
-import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
-import {
-  ActorSliceRange,
-  IVolumeViewport,
-  ICamera,
-  VolumeActor,
-} from '../types';
-
-/**
- * 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,
-  useSlabThickness = false
-): {
-  sliceRange: ActorSliceRange;
-  spacingInNormalDirection: number;
-  camera: ICamera;
-} {
-  const camera = viewport.getCamera();
-  const { focalPoint, viewPlaneNormal } = camera;
-  const { spacingInNormalDirection, actorUID } =
-    getTargetVolumeAndSpacingInNormalDir(
-      viewport,
-      camera,
-      volumeId,
-      useSlabThickness
-    );
-
-  if (!actorUID) {
-    throw new Error(
-      `Could not find image volume with id ${volumeId} in the viewport`
-    );
-  }
-
-  const actorEntry = viewport.getActor(actorUID);
-
-  if (!actorEntry) {
-    console.warn('No actor found for with actorUID of', actorUID);
-    return null;
-  }
-
-  const volumeActor = actorEntry.actor as VolumeActor;
-  const sliceRange = getSliceRange(volumeActor, viewPlaneNormal, focalPoint);
-
-  return {
-    sliceRange,
-    spacingInNormalDirection,
-    camera,
-  };
-}
-
-export default getVolumeSliceRangeInfo;

package/src/utilities/getVolumeViewportScrollInfo.ts

@@ -1,41 +0,0 @@
-import { IVolumeViewport } from '../types';
-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,
-  useSlabThickness = false
-) {
-  const { sliceRange, spacingInNormalDirection, camera } =
-    getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness);
-
-  const { min, max, current } = sliceRange;
-
-  // Now we can see how many steps there are in this direction
-  const numScrollSteps = Math.round((max - min) / spacingInNormalDirection);
-
-  // Find out current frameIndex
-  const fraction = (current - min) / (max - min);
-  const floatingStepNumber = fraction * numScrollSteps;
-  const currentStepIndex = Math.round(floatingStepNumber);
-
-  return {
-    numScrollSteps,
-    currentStepIndex,
-    sliceRangeInfo: {
-      sliceRange,
-      spacingInNormalDirection,
-      camera,
-    },
-  };
-}
-
-export default getVolumeViewportScrollInfo;

package/src/utilities/getVolumeViewportsContainingSameVolumes.ts

@@ -1,58 +0,0 @@
-import { IVolumeViewport } from '../types';
-import {
-  getRenderingEngines,
-  getRenderingEngine,
-} from '../RenderingEngine/getRenderingEngine';
-
-/**
- * Returns the viewports containing the same volume actors (all actors) the same
- * as the target viewport. If renderingEngineId is provided, it will only return
- * viewports that are associated with the renderingEngineId; otherwise, it will
- * return search in all rendering engines.
- *
- * This method is useful for finding viewports that are associated with the same
- * volume (e.g., for tools that share state between viewports).
- *
- * @param viewport - target viewport
- * @returns array of viewports that have the same volume actor as the target viewport
- */
-function getVolumeViewportsContainingSameVolumes(
-  targetViewport: IVolumeViewport,
-  renderingEngineId?: string
-): Array<IVolumeViewport> {
-  // If rendering engine is not provided, use all rendering engines
-  let renderingEngines;
-  if (renderingEngineId) {
-    renderingEngines = [getRenderingEngine(renderingEngineId)];
-  } else {
-    renderingEngines = getRenderingEngines();
-  }
-
-  const sameVolumesViewports = [];
-
-  renderingEngines.forEach((renderingEngine) => {
-    const targetActors = targetViewport.getActors();
-    const viewports = renderingEngine.getVolumeViewports();
-
-    for (const vp of viewports) {
-      const vpActors = vp.getActors();
-
-      if (vpActors.length !== targetActors.length) {
-        continue;
-      }
-
-      // every targetActors should be in the vpActors
-      const sameVolumes = targetActors.every(({ uid }) =>
-        vpActors.find((vpActor) => uid === vpActor.uid)
-      );
-
-      if (sameVolumes) {
-        sameVolumesViewports.push(vp);
-      }
-    }
-  });
-
-  return sameVolumesViewports;
-}
-
-export default getVolumeViewportsContainingSameVolumes;

package/src/utilities/hasFloatScalingParameters.ts

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

@@ -1,12 +0,0 @@
-/**
- * A function that checks if there is a value in the array that is NaN.
- * or if the input is a number it just checks if it is NaN.
- * @param input - The input to check if it is NaN.
- * @returns - True if the input is NaN, false otherwise.
- */
-export default function hasNaNValues(input: number[] | number): boolean {
-  if (Array.isArray(input)) {
-    return input.some((value) => Number.isNaN(value));
-  }
-  return Number.isNaN(input);
-}