@cornerstonejs/core 1.53.0 → 1.54.1

package/src/loaders/volumeLoader.ts

@@ -45,12 +45,19 @@ interface DerivedVolumeOptions {
   };
 }
 interface LocalVolumeOptions {
-  scalarData: PixelDataTypedArray;
   metadata: Metadata;
   dimensions: Point3;
   spacing: Point3;
   origin: Point3;
   direction: Mat3;
+  scalarData?: PixelDataTypedArray;
+  imageIds?: Array<string>;
+  referencedImageIds?: Array<string>;
+  referencedVolumeId?: string;
+  targetBuffer?: {
+    type: PixelDataTypedArrayString;
+    sharedArrayBuffer?: boolean;
+  };
 }
 
 /**
@@ -295,32 +302,11 @@ export async function createAndCacheDerivedVolume(
   const scalarData = referencedVolume.getScalarData();
   const scalarLength = scalarData.length;
 
-  const { useNorm16Texture } = getConfiguration().rendering;
-
-  // If target buffer is provided
-  const { TypedArrayConstructor, numBytes } = getBufferConfiguration(
-    targetBuffer?.type,
-    scalarLength,
-    {
-      use16BitTexture: useNorm16Texture,
-      isVolumeBuffer: true,
-    }
+  const { volumeScalarData, numBytes } = generateVolumeScalarData(
+    targetBuffer,
+    scalarLength
   );
 
-  // check if there is enough space in unallocated + image Cache
-  const isCacheable = cache.isCacheable(numBytes);
-  if (!isCacheable) {
-    throw new Error(Events.CACHE_SIZE_EXCEEDED);
-  }
-
-  let volumeScalarData;
-  if (targetBuffer?.sharedArrayBuffer) {
-    const buffer = new SharedArrayBuffer(numBytes);
-    volumeScalarData = new TypedArrayConstructor(buffer);
-  } else {
-    volumeScalarData = new TypedArrayConstructor(scalarLength);
-  }
-
   // Todo: handle more than one component for segmentation (RGB)
   const scalarArray = vtkDataArray.newInstance({
     name: 'Pixels',
@@ -346,7 +332,6 @@ export async function createAndCacheDerivedVolume(
     imageData: derivedImageData,
     scalarData: volumeScalarData,
     sizeInBytes: numBytes,
-    referencedVolumeId,
     imageIds: [],
   });
 
@@ -374,21 +359,35 @@ export function createLocalVolume(
   volumeId: string,
   preventCache = false
 ): IImageVolume {
-  const { scalarData, metadata, dimensions, spacing, origin, direction } =
+  const { metadata, dimensions, spacing, origin, direction, targetBuffer } =
     options;
 
-  if (
-    !scalarData ||
-    !(
-      scalarData instanceof Uint8Array ||
-      scalarData instanceof Float32Array ||
-      scalarData instanceof Uint16Array ||
-      scalarData instanceof Int16Array
-    )
-  ) {
-    throw new Error(
-      'To use createLocalVolume you should pass scalarData of type Uint8Array, Uint16Array, Int16Array or Float32Array'
-    );
+  let { scalarData } = options;
+
+  // Define the valid data types for scalarData
+  const validDataTypes = [
+    'Uint8Array',
+    'Float32Array',
+    'Uint16Array',
+    'Int16Array',
+  ];
+
+  const scalarLength = dimensions[0] * dimensions[1] * dimensions[2];
+
+  // Check if scalarData is provided and is of a valid type
+  if (!scalarData || !validDataTypes.includes(scalarData.constructor.name)) {
+    // Check if targetBuffer is provided and has a valid type
+    if (!targetBuffer?.type || !validDataTypes.includes(targetBuffer.type)) {
+      throw new Error(
+        'createLocalVolume: parameter scalarData must be provided and must be either Uint8Array, Float32Array, Uint16Array or Int16Array'
+      );
+    }
+
+    // Generate volume scalar data if scalarData is not provided or invalid
+    ({ volumeScalarData: scalarData } = generateVolumeScalarData(
+      targetBuffer,
+      scalarLength
+    ));
   }
 
   // Todo: handle default values for spacing, origin, direction if not provided
@@ -402,8 +401,6 @@ export function createLocalVolume(
     return cachedVolume as IImageVolume;
   }
 
-  const scalarLength = dimensions[0] * dimensions[1] * dimensions[2];
-
   const numBytes = scalarData ? scalarData.buffer.byteLength : scalarLength * 4;
 
   // check if there is enough space in unallocated + image Cache
@@ -436,7 +433,9 @@ export function createLocalVolume(
     imageData: imageData,
     scalarData,
     sizeInBytes: numBytes,
-    imageIds: [],
+    referencedImageIds: options.referencedImageIds || [],
+    referencedVolumeId: options.referencedVolumeId,
+    imageIds: options.imageIds || [],
   });
 
   if (preventCache) {
@@ -573,7 +572,7 @@ export function getUnknownVolumeLoaderSchema(): string {
  */
 export async function createAndCacheDerivedSegmentationVolume(
   referencedVolumeId: string,
-  options: DerivedVolumeOptions
+  options = {} as DerivedVolumeOptions
 ): Promise<IImageVolume> {
   return createAndCacheDerivedVolume(referencedVolumeId, {
     ...options,
@@ -582,3 +581,70 @@ export async function createAndCacheDerivedSegmentationVolume(
     },
   });
 }
+
+/**
+ * Creates a local segmentation volume.
+ *
+ * @param options - The options for creating the volume.
+ * @param volumeId - The ID of the volume.
+ * @param preventCache - Whether to prevent caching the volume.
+ * @returns A promise that resolves to the created image volume.
+ */
+export async function createLocalSegmentationVolume(
+  options: LocalVolumeOptions,
+  volumeId: string,
+  preventCache = false
+): Promise<IImageVolume> {
+  if (!options.scalarData) {
+    options.scalarData = new Uint8Array(
+      options.dimensions[0] * options.dimensions[1] * options.dimensions[2]
+    );
+  }
+
+  return createLocalVolume(options, volumeId, preventCache);
+}
+
+/**
+ * This function generates volume scalar data based on the provided target buffer and scalar length.
+ * It checks if the cache can accommodate the data size and throws an error if it exceeds the cache size.
+ * If a shared array buffer is available in the target buffer, it uses that to create the typed array.
+ * Otherwise, it creates a typed array based on the scalar length.
+ *
+ * @param targetBuffer - The target buffer object which may contain a type and a shared array buffer.
+ * @param scalarLength - The scalar length for creating the typed array.
+ * @param useNorm16Texture - A flag to specify whether to use a 16-bit texture or not.
+ * @returns The volume scalar data as a typed array.
+ */
+function generateVolumeScalarData(
+  targetBuffer: {
+    type: PixelDataTypedArrayString;
+    sharedArrayBuffer?: boolean;
+  },
+  scalarLength: number
+) {
+  const { useNorm16Texture } = getConfiguration().rendering;
+
+  const { TypedArrayConstructor, numBytes } = getBufferConfiguration(
+    targetBuffer?.type,
+    scalarLength,
+    {
+      use16BitTexture: useNorm16Texture,
+      isVolumeBuffer: true,
+    }
+  );
+
+  const isCacheable = cache.isCacheable(numBytes);
+  if (!isCacheable) {
+    throw new Error(Events.CACHE_SIZE_EXCEEDED);
+  }
+
+  let volumeScalarData;
+  if (targetBuffer?.sharedArrayBuffer) {
+    const buffer = new SharedArrayBuffer(numBytes);
+    volumeScalarData = new TypedArrayConstructor(buffer);
+  } else {
+    volumeScalarData = new TypedArrayConstructor(scalarLength);
+  }
+
+  return { volumeScalarData, numBytes };
+}

package/src/requestPool/requestPoolManager.ts

@@ -120,7 +120,13 @@ class RequestPoolManager {
       interaction: 6,
       thumbnail: 6,
       prefetch: 5,
-      compute: 15,
+      // 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. For this reason
+      // I'm setting the limit to 1000 for now.
+      compute: 1000,
     };
   }
 

package/src/types/IGeometry.ts

@@ -1,12 +1,12 @@
-import { Surface } from '../cache/classes/Surface';
 import { GeometryType } from '../enums';
 import { IContourSet } from './IContourSet';
+import { ISurface } from './ISurface';
 
 // interface IGeometry can be array of IContourSet
 interface IGeometry {
   id: string;
   type: GeometryType;
-  data: IContourSet | Surface;
+  data: IContourSet | ISurface;
   sizeInBytes: number;
 }
 

package/src/types/IImageVolume.ts

@@ -81,10 +81,18 @@ interface IImageVolume {
   destroy(): void;
 
   /** decache */
-  decache?: () => void;
+  decache?: (completelyRemove?: boolean) => void;
 
   /** */
   get imageCacheOffsetMap(): Map<string, any>;
+
+  /**
+   * Mark the volume as having had the pixel data changed externally
+   * which in background will re-configure the volume to use the new
+   * pixel data.
+   *
+   */
+  modified(): void;
 }
 
 export default IImageVolume;

package/src/types/ISurface.ts

@@ -0,0 +1,14 @@
+import Point3 from './Point3';
+
+export interface ISurface {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  readonly frameOfReferenceUID: string;
+  getColor(): Point3;
+  setColor(color: Point3): void;
+  getPoints(): number[];
+  getPolys(): number[];
+  getSizeInBytes(): number;
+  setPoints(points: number[]): void;
+  setPolys(polys: number[]): void;
+}

package/src/types/index.ts

@@ -110,6 +110,7 @@ import type {
   InternalVideoCamera,
   VideoViewportInput,
 } from './VideoViewportTypes';
+import { ISurface } from './ISurface';
 import type BoundsIJK from './BoundsIJK';
 import type { ImageVolumeProps } from './ImageVolumeProps';
 import type { VolumeProps } from './VolumeProps';
@@ -213,6 +214,7 @@ export type {
   // Surface
   PublicSurfaceData,
   SurfaceData,
+  ISurface,
   // Color
   RGB,
   ColormapPublic,

package/src/utilities/VoxelManager.ts

@@ -104,7 +104,7 @@ export default class VoxelManager<T> {
    * Records the z index modified.
    * Will record the index value if the VoxelManager is backed by a map.
    */
-  public setAtIJKPoint = ([i, j, k], v) => this.setAtIJK(i, j, k, v);
+  public setAtIJKPoint = ([i, j, k]: Point3, v) => this.setAtIJK(i, j, k, v);
 
   /**
    * Gets the value at the given index.
@@ -241,6 +241,12 @@ export default class VoxelManager<T> {
     dimensions: Point3,
     scalarData
   ): VoxelManager<number> {
+    if (dimensions.length !== 3) {
+      throw new Error(
+        'Dimensions must be provided as [number, number, number] for [width, height, depth]'
+      );
+    }
+
     const voxels = new VoxelManager(
       dimensions,
       (index) => scalarData[index],

package/src/utilities/cacheUtils.ts

@@ -83,6 +83,30 @@ function _processImageCacheOffsetMap(volume, scalarData) {
  * @param scalarData - The scalar data to use for the volume.
  */
 function _processVolumeImages(volume, scalarData) {
+  let compatibleScalarData = scalarData;
+
+  const sampleImageIdWithImage = volume.imageIds.find((imageId) => {
+    const image = cache.getImage(imageId);
+    return image;
+  });
+
+  if (!sampleImageIdWithImage) {
+    return;
+  }
+
+  const sampleImage = cache.getImage(sampleImageIdWithImage);
+  const samplePixelData =
+    sampleImage.imageFrame?.pixelData || sampleImage.getPixelData();
+
+  // Check if the types of scalarData and pixelData are different.
+  if (scalarData.constructor !== samplePixelData.constructor) {
+    // If so, create a new typed array of the same type as pixelData and copy the values from scalarData.
+    compatibleScalarData = new samplePixelData.constructor(scalarData.length);
+
+    // Copy values from scalarData to compatibleScalarData.
+    compatibleScalarData.set(scalarData);
+  }
+
   volume.imageIds.forEach((imageId) => {
     const image = cache.getImage(imageId);
     if (!image) {
@@ -92,7 +116,7 @@ function _processVolumeImages(volume, scalarData) {
     const index = volume.getImageIdIndex(imageId);
     const offset = index * image.getPixelData().byteLength;
 
-    _updateImageWithScalarDataView(image, scalarData, offset);
+    _updateImageWithScalarDataView(image, compatibleScalarData, offset);
     cache.decrementImageCacheSize(image.sizeInBytes);
   });
 }

package/src/utilities/convertVolumeToStackViewport.ts

@@ -114,7 +114,7 @@ async function convertVolumeToStackViewport({
     imageIdIndexToJump = minDistanceIndex;
   }
 
-  await stackViewport.setStack(stack, imageIdIndexToJump);
+  await stackViewport.setStack(stack, imageIdIndexToJump ?? 0);
 
   // Render the image
   stackViewport.render();

package/src/utilities/generateVolumePropsFromImageIds.ts

@@ -19,10 +19,9 @@ function generateVolumePropsFromImageIds(
     getConfiguration().rendering;
 
   const use16BitDataType = useNorm16Texture || preferSizeOverAccuracy;
-
   const volumeMetadata = makeVolumeMetadata(imageIds);
 
-  // For a streaming volume, the data type cannot rely on cswil to load
+  // For a streaming volume, the data type cannot rely on CSWIL to load
   // the proper array buffer type. This is because the target buffer container
   // must be decided ahead of time.
   // TODO: move this logic into CSWIL to avoid logic duplication.

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/index.ts

@@ -68,6 +68,7 @@ import { convertVolumeToStackViewport } from './convertVolumeToStackViewport';
 import VoxelManager from './VoxelManager';
 import roundNumber, { roundToPrecision } from './roundNumber';
 import convertToGrayscale from './convertToGrayscale';
+import getViewportImageIds from './getViewportImageIds';
 
 // name spaces
 import * as planar from './planar';
@@ -154,4 +155,5 @@ export {
   cacheUtils,
   roundNumber,
   roundToPrecision,
+  getViewportImageIds,
 };

package/src/webWorkerManager/webWorkerManager.js

@@ -6,11 +6,6 @@ class CentralizedWorkerManager {
   constructor() {
     this.workerRegistry = {};
     this.workerPoolManager = new RequestPoolManager('webworker');
-    this.checkIntervalForIdleWorkers = 1000;
-  }
-
-  setCheckIntervalForIdleWorkers(value) {
-    this.checkIntervalForIdleWorkers = value;
   }
 
   /**
@@ -29,7 +24,10 @@ class CentralizedWorkerManager {
     const {
       maxWorkerInstances = 1,
       overwrite = false,
-      autoTerminateOnIdle = false,
+      autoTerminateOnIdle = {
+        enabled: false,
+        idleTimeThreshold: 3000, // 3 seconds
+      },
     } = options;
 
     if (this.workerRegistry[workerName] && !overwrite) {
@@ -43,25 +41,17 @@ class CentralizedWorkerManager {
 
     const workerProperties = {
       workerFn: null,
-      idleCheckIntervalId: null,
       instances: [],
       loadCounters: [],
       lastActiveTime: [],
       // used for termination
       nativeWorkers: [],
+      // auto termination
+      autoTerminateOnIdle: autoTerminateOnIdle.enabled,
+      idleCheckIntervalId: null,
+      idleTimeThreshold: autoTerminateOnIdle.idleTimeThreshold,
     };
 
-    if (
-      (autoTerminateOnIdle && !workerProperties.idleCheckIntervalId) ||
-      overwrite
-    ) {
-      const idleCheckIntervalId = setInterval(() => {
-        this.terminateIdleWorkers(workerName, autoTerminateOnIdle);
-      }, this.checkIntervalForIdleWorkers);
-
-      workerProperties.idleCheckIntervalId = idleCheckIntervalId;
-    }
-
     workerProperties.loadCounters = Array(maxWorkerInstances).fill(0);
     workerProperties.lastActiveTime = Array(maxWorkerInstances).fill(null);
 
@@ -90,7 +80,6 @@ class CentralizedWorkerManager {
 
     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) {
@@ -121,7 +110,10 @@ class CentralizedWorkerManager {
    *
    * @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 empty object.
+   * @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.
@@ -133,7 +125,12 @@ class CentralizedWorkerManager {
     workerName,
     methodName,
     args = {},
-    { requestType = RequestType.Compute, priority = 0, options = {} } = {}
+    {
+      requestType = RequestType.Compute,
+      priority = 0,
+      options = {},
+      callbacks = [],
+    } = {}
   ) {
     return new Promise((resolve, reject) => {
       const requestFn = async () => {
@@ -148,11 +145,34 @@ class CentralizedWorkerManager {
         }
 
         try {
-          const results = await api[methodName](args);
-
+          // 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];
+
+          const results = await api[methodName](args, ...finalCallbacks);
+
           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(
@@ -165,6 +185,11 @@ class CentralizedWorkerManager {
         }
       };
 
+      // 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,
@@ -176,24 +201,16 @@ class CentralizedWorkerManager {
 
   terminateIdleWorkers(workerName, idleTimeThreshold) {
     const workerProperties = this.workerRegistry[workerName];
-
     const now = Date.now();
 
-    workerProperties.instances.forEach((workerInstance, index) => {
-      // If the worker has not yet executed any task, skip this iteration
-      if (workerProperties.lastActiveTime[index] == null) {
-        return;
-      }
-
-      const idleTime = now - workerProperties.lastActiveTime[index];
+    workerProperties.instances.forEach((_, index) => {
+      const lastActiveTime = workerProperties.lastActiveTime[index];
+      const isWorkerActive =
+        lastActiveTime !== null && workerProperties.loadCounters[index] > 0;
+      const idleTime = now - lastActiveTime;
 
-      // If the worker has been idle for longer than the threshold and it exists
-      if (idleTime > idleTimeThreshold && workerInstance !== null) {
-        workerInstance[Comlink.releaseProxy]();
-        workerProperties.nativeWorkers[index].terminate();
-
-        workerProperties.instances[index] = null;
-        workerProperties.lastActiveTime[index] = null;
+      if (!isWorkerActive && idleTime > idleTimeThreshold) {
+        this.terminateWorkerInstance(workerName, index);
       }
     });
   }
@@ -205,13 +222,24 @@ class CentralizedWorkerManager {
       return;
     }
 
-    workerProperties.instances.forEach((workerInstance) => {
-      workerInstance[Comlink.releaseProxy]();
+    workerProperties.instances.forEach((_, index) => {
+      this.terminateWorkerInstance(workerName, index);
     });
+  }
 
-    workerProperties.nativeWorkers.forEach((worker) => {
-      worker.terminate();
-    });
+  // 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;
+    }
   }
 }