@cornerstonejs/core 2.0.0-beta.6 → 2.0.0-beta.8

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/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

@@ -20,10 +20,7 @@ const imageRetrieveMetadataProvider = {
     retrieveConfigurationState.set(key, payload);
   },
 
-  get: (type: string, queriesOrQuery: string | string[]) => {
-    const queries = Array.isArray(queriesOrQuery)
-      ? queriesOrQuery
-      : [queriesOrQuery];
+  get: (type: string, ...queries: string[]) => {
     if (type === IMAGE_RETRIEVE_CONFIGURATION) {
       return queries
         .map((query) => retrieveConfigurationState.get(query))

package/src/utilities/index.ts

@@ -1,3 +1,4 @@
+import * as eventListener from './eventListener';
 import csUtils from './invertRgbTransferFunction';
 import createSigmoidRGBTransferFunction from './createSigmoidRGBTransferFunction';
 import getVoiFromSigmoidRGBTransferFunction from './getVoiFromSigmoidRGBTransferFunction';
@@ -9,12 +10,14 @@ import getMinMax from './getMinMax';
 import getRuntimeId from './getRuntimeId';
 import imageIdToURI from './imageIdToURI';
 import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
-import isEqual from './isEqual';
+import clamp from './clamp';
+import { isEqual, isEqualAbs, isEqualNegative } from './isEqual';
 import isOpposite from './isOpposite';
 import createUint8SharedArray from './createUint8SharedArray';
 import createFloat32SharedArray from './createFloat32SharedArray';
 import createUint16SharedArray from './createUInt16SharedArray';
 import createInt16SharedArray from './createInt16SharedArray';
+import getViewportModality from './getViewportModality';
 import getClosestImageId from './getClosestImageId';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
@@ -23,6 +26,7 @@ import indexWithinDimensions from './indexWithinDimensions';
 import getVolumeViewportsContainingSameVolumes from './getVolumeViewportsContainingSameVolumes';
 import getViewportsWithVolumeId from './getViewportsWithVolumeId';
 import transformWorldToIndex from './transformWorldToIndex';
+import transformIndexToWorld from './transformIndexToWorld';
 import loadImageToCanvas from './loadImageToCanvas';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import renderToCanvasGPU from './renderToCanvasGPU';
@@ -36,26 +40,50 @@ import getImageSliceDataForVolumeViewport from './getImageSliceDataForVolumeView
 import { isImageActor, actorIsA } from './actorCheck';
 import getViewportsWithImageURI from './getViewportsWithImageURI';
 import getClosestStackImageIndexForPoint from './getClosestStackImageIndexForPoint';
+import getCurrentVolumeViewportSlice from './getCurrentVolumeViewportSlice';
 import calculateViewportsSpatialRegistration from './calculateViewportsSpatialRegistration';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
 import getViewportImageCornersInWorld from './getViewportImageCornersInWorld';
 import hasNaNValues from './hasNaNValues';
 import applyPreset from './applyPreset';
+import PointsManager from './PointsManager';
 import deepMerge from './deepMerge';
 import getScalingParameters from './getScalingParameters';
 import getScalarDataType from './getScalarDataType';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
 import getImageLegacy from './getImageLegacy';
+import sortImageIdsAndGetSpacing from './sortImageIdsAndGetSpacing';
+import makeVolumeMetadata from './makeVolumeMetadata';
+import genericMetadataProvider from './genericMetadataProvider';
+import { isValidVolume } from './isValidVolume';
+import { updateVTKImageDataWithCornerstoneImage } from './updateVTKImageDataWithCornerstoneImage';
 import ProgressiveIterator from './ProgressiveIterator';
 import decimate from './decimate';
 import imageRetrieveMetadataProvider from './imageRetrieveMetadataProvider';
+import isVideoTransferSyntax from './isVideoTransferSyntax';
+import { getBufferConfiguration } from './getBufferConfiguration';
+import { generateVolumePropsFromImageIds } from './generateVolumePropsFromImageIds';
+import { convertStackToVolumeViewport } from './convertStackToVolumeViewport';
+import { convertVolumeToStackViewport } from './convertVolumeToStackViewport';
+import VoxelManager from './VoxelManager';
+import RLEVoxelMap from './RLEVoxelMap';
+import roundNumber, { roundToPrecision } from './roundNumber';
+import convertToGrayscale from './convertToGrayscale';
+import getViewportImageIds from './getViewportImageIds';
+import { getRandomSampleFromArray } from './getRandomSampleFromArray';
+import { getVolumeId } from './getVolumeId';
+import { hasFloatScalingParameters } from './hasFloatScalingParameters';
 
 // name spaces
 import * as planar from './planar';
 import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
+import * as transferFunctionUtils from './transferFunctionUtils';
+import * as cacheUtils from './cacheUtils';
+import * as color from './color';
 
 export {
+  eventListener,
   csUtils as invertRgbTransferFunction,
   createSigmoidRGBTransferFunction,
   getVoiFromSigmoidRGBTransferFunction,
@@ -64,17 +92,22 @@ export {
   triggerEvent,
   imageIdToURI,
   calibratedPixelSpacingMetadataProvider,
+  clamp,
   uuidv4,
   planar,
   getMinMax,
   getRuntimeId,
   isEqual,
+  isEqualAbs,
+  isEqualNegative,
   isOpposite,
   createFloat32SharedArray,
   createUint8SharedArray,
   createUint16SharedArray,
   createInt16SharedArray,
+  getViewportModality,
   windowLevel,
+  convertToGrayscale,
   getClosestImageId,
   getSpacingInNormalDirection,
   getTargetVolumeAndSpacingInNormalDir,
@@ -83,6 +116,7 @@ export {
   getVolumeViewportsContainingSameVolumes,
   getViewportsWithVolumeId,
   transformWorldToIndex,
+  transformIndexToWorld,
   loadImageToCanvas,
   renderToCanvasCPU,
   renderToCanvasGPU,
@@ -98,12 +132,14 @@ export {
   actorIsA,
   getViewportsWithImageURI,
   getClosestStackImageIndexForPoint,
+  getCurrentVolumeViewportSlice,
   calculateViewportsSpatialRegistration,
   spatialRegistrationMetadataProvider,
   getViewportImageCornersInWorld,
   hasNaNValues,
   applyPreset,
   deepMerge,
+  PointsManager,
   getScalingParameters,
   getScalarDataType,
   colormap,
@@ -111,4 +147,25 @@ export {
   ProgressiveIterator,
   decimate,
   imageRetrieveMetadataProvider,
+  transferFunctionUtils,
+  updateVTKImageDataWithCornerstoneImage,
+  sortImageIdsAndGetSpacing,
+  makeVolumeMetadata,
+  isValidVolume,
+  genericMetadataProvider,
+  isVideoTransferSyntax,
+  generateVolumePropsFromImageIds,
+  getBufferConfiguration,
+  VoxelManager,
+  RLEVoxelMap,
+  convertStackToVolumeViewport,
+  convertVolumeToStackViewport,
+  cacheUtils,
+  roundNumber,
+  roundToPrecision,
+  getViewportImageIds,
+  getRandomSampleFromArray,
+  getVolumeId,
+  color,
+  hasFloatScalingParameters,
 };