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

package/src/utilities/roundNumber.ts

@@ -0,0 +1,57 @@
+import { EPSILON } from '../constants';
+
+/**
+ * Truncates decimal points to that there is at least 1+precision significant
+ * digits.
+ *
+ * For example, with the default precision 2 (3 significant digits)
+ * * Values larger than 100 show no information after the decimal point
+ * * Values between 10 and 99 show 1 decimal point
+ * * Values between 1 and 9 show 2 decimal points
+ *
+ * @param value - to return a fixed measurement value from
+ * @param precision - defining how many digits after 1..9 are desired
+ */
+function roundNumber(
+  value: string | number | (string | number)[],
+  precision = 2
+): string {
+  if (Array.isArray(value)) {
+    return value.map((v) => roundNumber(v, precision)).join(', ');
+  }
+  if (value === undefined || value === null || value === '') {
+    return 'NaN';
+  }
+  value = Number(value);
+  const absValue = Math.abs(value);
+  if (absValue < 0.0001) {
+    return `${value}`;
+  }
+  const fixedPrecision =
+    absValue >= 100
+      ? precision - 2
+      : absValue >= 10
+      ? precision - 1
+      : absValue >= 1
+      ? precision
+      : absValue >= 0.1
+      ? precision + 1
+      : absValue >= 0.01
+      ? precision + 2
+      : absValue >= 0.001
+      ? precision + 3
+      : precision + 4;
+  return value.toFixed(fixedPrecision);
+}
+
+/**
+ * Rounds a number to the nearest multiple of EPSILON.
+ * @param value - The number to round.
+ * @returns The rounded number.
+ */
+function roundToPrecision(value) {
+  return Math.round(value / EPSILON) * EPSILON;
+}
+
+export { roundToPrecision };
+export default roundNumber;

package/src/utilities/sortImageIdsAndGetSpacing.ts

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

@@ -19,13 +19,11 @@ const spatialRegistrationMetadataProvider = {
     state[entryId] = payload;
   },
 
-  get: (type: string, query: string[]): mat4 => {
+  get: (type: string, viewportId1: string, viewportId2: string): mat4 => {
     if (type !== 'spatialRegistrationModule') {
       return;
     }
 
-    const [viewportId1, viewportId2] = query;
-
     // check both ways
     const entryId = `${viewportId1}_${viewportId2}`;
 

package/src/utilities/transferFunctionUtils.ts

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

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

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

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

@@ -0,0 +1,42 @@
+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/webWorkerManager/webWorkerManager.js

@@ -0,0 +1,254 @@
+import * as Comlink from 'comlink';
+import { RequestType } from '../enums/';
+import { RequestPoolManager } from '../requestPool/requestPoolManager';
+
+class CentralizedWorkerManager {
+  constructor() {
+    this.workerRegistry = {};
+    this.workerPoolManager = new RequestPoolManager('webworker');
+  }
+
+  /**
+   * Registers a new worker, it doesn't mean that the function will get executed.
+   *
+   * @param workerName - The name of the worker.
+   * @param workerFn - The function that creates a new instance of the worker.
+   * @param options - Optional parameters.
+   * @param options.maxWorkerInstances - The maximum number of instances of this worker that can be created.
+   * For instance if you create a worker with maxWorkerInstances = 2, then only 2 instances of this worker will be created
+   * and in case there are 10 tasks that need to be executed, each will get assigned 5 tasks.
+   * @param options.overwrite - Whether to overwrite the worker if it's already registered.
+   * @param options.autoTerminateOnIdle - Whether to automatically terminate idle workers.
+   */
+  registerWorker(workerName, workerFn, options = {}) {
+    const {
+      maxWorkerInstances = 1,
+      overwrite = false,
+      autoTerminateOnIdle = {
+        enabled: false,
+        idleTimeThreshold: 3000, // 3 seconds
+      },
+    } = options;
+
+    if (this.workerRegistry[workerName] && !overwrite) {
+      console.warn(`Worker type '${workerName}' is already registered...`);
+      return;
+    }
+
+    if (overwrite && this.workerRegistry[workerName]?.idleCheckIntervalId) {
+      clearInterval(this.workerRegistry[workerName].idleCheckIntervalId);
+    }
+
+    const workerProperties = {
+      workerFn: null,
+      instances: [],
+      loadCounters: [],
+      lastActiveTime: [],
+      // used for termination
+      nativeWorkers: [],
+      // auto termination
+      autoTerminateOnIdle: autoTerminateOnIdle.enabled,
+      idleCheckIntervalId: null,
+      idleTimeThreshold: autoTerminateOnIdle.idleTimeThreshold,
+    };
+
+    workerProperties.loadCounters = Array(maxWorkerInstances).fill(0);
+    workerProperties.lastActiveTime = Array(maxWorkerInstances).fill(null);
+
+    for (let i = 0; i < maxWorkerInstances; i++) {
+      const worker = workerFn();
+      workerProperties.instances.push(Comlink.wrap(worker));
+      workerProperties.nativeWorkers.push(worker);
+      workerProperties.workerFn = workerFn;
+    }
+
+    this.workerRegistry[workerName] = workerProperties;
+  }
+
+  getNextWorkerAPI(workerName) {
+    const workerProperties = this.workerRegistry[workerName];
+
+    if (!workerProperties) {
+      console.error(`Worker type '${workerName}' is not registered.`);
+      return null;
+    }
+
+    // Find the worker with the minimum load.
+    const workerInstances = workerProperties.instances.filter(
+      (instance) => instance !== null
+    );
+
+    let minLoadIndex = 0;
+    let minLoadValue = workerProperties.loadCounters[0] || 0;
+    for (let i = 1; i < workerInstances.length; i++) {
+      const currentLoadValue = workerProperties.loadCounters[i] || 0;
+      if (currentLoadValue < minLoadValue) {
+        minLoadIndex = i;
+        minLoadValue = currentLoadValue;
+      }
+    }
+
+    // Check and recreate the worker if it was terminated.
+    if (workerProperties.instances[minLoadIndex] === null) {
+      const worker = workerProperties.workerFn();
+      workerProperties.instances[minLoadIndex] = Comlink.wrap(worker);
+      workerProperties.nativeWorkers[minLoadIndex] = worker;
+    }
+
+    // Update the load counter.
+    workerProperties.loadCounters[minLoadIndex] += 1;
+
+    // return the worker that has the minimum load.
+    return {
+      api: workerProperties.instances[minLoadIndex],
+      index: minLoadIndex,
+    };
+  }
+
+  /**
+   * Executes a task on a worker.
+   *
+   * @param workerName - The name of the worker to execute the task on.
+   * @param methodName - The name of the method to execute on the worker.
+   * @param args - The arguments to pass to the method. Default is an array
+   * You should put your transferable objects in the first argument as object
+   * and from the second argument you can put your non-transferable objects such
+   * as functions, classes, etc.
+   * @param options - An object containing options for the request. Default is an empty object.
+   * @param options.requestType - The type of the request. Default is RequestType.Compute.
+   * @param options.priority - The priority of the request. Default is 0.
+   * @param options.options - Additional options for the request. Default is an empty object.
+   *
+   * @returns A promise that resolves with the result of the task.
+   */
+  executeTask(
+    workerName,
+    methodName,
+    args = {},
+    {
+      requestType = RequestType.Compute,
+      priority = 0,
+      options = {},
+      callbacks = [],
+    } = {}
+  ) {
+    return new Promise((resolve, reject) => {
+      const requestFn = async () => {
+        const { api, index } = this.getNextWorkerAPI(workerName);
+        if (!api) {
+          const error = new Error(
+            `No available worker instance for '${workerName}'`
+          );
+          console.error(error);
+          reject(error);
+          return;
+        }
+
+        try {
+          // fix if any of the args keys are a function then we need to proxy it
+          // for the worker to be able to call it
+          let finalCallbacks = [];
+          if (callbacks.length) {
+            finalCallbacks = callbacks.map((cb) => {
+              return Comlink.proxy(cb);
+            });
+          }
+          const workerProperties = this.workerRegistry[workerName];
+
+          workerProperties.processing = true;
+
+          const results = await api[methodName](args, ...finalCallbacks);
+
+          workerProperties.processing = false;
+          workerProperties.lastActiveTime[index] = Date.now();
+
+          // If auto termination is enabled and the interval is not set, set it.
+          if (
+            workerProperties.autoTerminateOnIdle &&
+            !workerProperties.idleCheckIntervalId &&
+            workerProperties.idleTimeThreshold
+          ) {
+            workerProperties.idleCheckIntervalId = setInterval(() => {
+              this.terminateIdleWorkers(
+                workerName,
+                workerProperties.idleTimeThreshold
+              );
+            }, workerProperties.idleTimeThreshold);
+          }
+
+          resolve(results);
+        } catch (err) {
+          console.error(
+            `Error executing method '${methodName}' on worker '${workerName}':`,
+            err
+          );
+          reject(err);
+        } finally {
+          this.workerRegistry[workerName].loadCounters[index]--;
+        }
+      };
+
+      // I believe there is a bug right now, where if there are two workers
+      // and one wants to run a compute job 6 times and the limit is just 5, then
+      // the other worker will never get a chance to run its compute job.
+      // we should probably have a separate limit for compute jobs per worker
+      // context as there is another layer of parallelism there.
+      this.workerPoolManager.addRequest(
+        requestFn,
+        requestType,
+        options,
+        priority
+      );
+    });
+  }
+
+  terminateIdleWorkers(workerName, idleTimeThreshold) {
+    const workerProperties = this.workerRegistry[workerName];
+
+    if (workerProperties.processing) {
+      return;
+    }
+
+    const now = Date.now();
+
+    workerProperties.instances.forEach((_, index) => {
+      const lastActiveTime = workerProperties.lastActiveTime[index];
+      const isWorkerActive =
+        lastActiveTime !== null && workerProperties.loadCounters[index] > 0;
+      const idleTime = now - lastActiveTime;
+
+      if (!isWorkerActive && idleTime > idleTimeThreshold) {
+        this.terminateWorkerInstance(workerName, index);
+      }
+    });
+  }
+
+  terminate(workerName) {
+    const workerProperties = this.workerRegistry[workerName];
+    if (!workerProperties) {
+      console.error(`Worker type '${workerName}' is not registered.`);
+      return;
+    }
+
+    workerProperties.instances.forEach((_, index) => {
+      this.terminateWorkerInstance(workerName, index);
+    });
+  }
+
+  // New method to handle individual worker termination
+  terminateWorkerInstance(workerName, index) {
+    const workerProperties = this.workerRegistry[workerName];
+    const workerInstance = workerProperties.instances[index];
+
+    if (workerInstance !== null) {
+      workerInstance[Comlink.releaseProxy]();
+      workerProperties.nativeWorkers[index].terminate();
+
+      // Set the worker instance to null after termination
+      workerProperties.instances[index] = null;
+      workerProperties.lastActiveTime[index] = null;
+    }
+  }
+}
+
+export default CentralizedWorkerManager;

package/dist/cjs/RenderingEngine/BaseVolumeViewport.d.ts

@@ -1,52 +0,0 @@
-import { BlendModes, OrientationAxis } from '../enums';
-import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties } from '../types';
-import type { ViewportInput } from '../types/IViewport';
-import type IVolumeViewport from '../types/IVolumeViewport';
-import Viewport from './Viewport';
-declare abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
-    useCPURendering: boolean;
-    use16BitTexture: boolean;
-    private _FrameOfReferenceUID;
-    private inverted;
-    private VOILUTFunction;
-    constructor(props: ViewportInput);
-    static get useCustomRenderingPipeline(): boolean;
-    protected applyViewOrientation(orientation: OrientationAxis | OrientationVectors): void;
-    private initializeVolumeNewImageEventDispatcher;
-    protected resetVolumeViewportClippingRange(): void;
-    private setVOILUTFunction;
-    private setColormap;
-    private setOpacity;
-    private setInvert;
-    private _getOrCreateColorTransferFunction;
-    private setInterpolationType;
-    private setVOI;
-    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, }?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
-    private setPreset;
-    getProperties: () => VolumeViewportProperties;
-    setVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    removeVolumeActors(actorUIDs: Array<string>, immediate?: boolean): void;
-    setOrientation(orientation: OrientationAxis, immediate?: boolean): void;
-    private _getApplicableVolumeActor;
-    private _isValidVolumeInputArray;
-    getBounds(): number[];
-    flip(flipDirection: FlipDirection): void;
-    getFrameOfReferenceUID: () => string;
-    hasVolumeId(volumeId: string): boolean;
-    getImageData(volumeId?: string): IImageData | undefined;
-    private _setVolumeActors;
-    canvasToWorld: (canvasPos: Point2) => Point3;
-    worldToCanvas: (worldPos: Point3) => Point2;
-    hasImageURI: (imageURI: string) => boolean;
-    protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
-    getSlabThickness(): number;
-    getIntensityFromWorld(point: Point3): number;
-    getImageIds: (volumeId?: string) => Array<string>;
-    abstract getCurrentImageIdIndex(): number;
-    abstract getCurrentImageId(): string;
-    abstract setBlendMode(blendMode: BlendModes, filterActorUIDs?: Array<string>, immediate?: boolean): void;
-    abstract setSlabThickness(slabThickness: number, filterActorUIDs?: Array<string>): void;
-    abstract resetProperties(volumeId?: string): void;
-}
-export default BaseVolumeViewport;