@cornerstonejs/core 1.30.0 → 1.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.30.0",
+  "version": "1.31.0",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@kitware/vtk.js": "27.3.1",
+    "comlink": "^4.4.1",
     "detect-gpu": "^5.0.22",
     "gl-matrix": "^3.4.3",
     "lodash.clonedeep": "4.5.0"
@@ -46,5 +47,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "9098e604b0099ed3e779d85faa6a1d0e2a4cc4c7"
+  "gitHead": "280c27226cb94a0b422f28656e69dbc059f95323"
 }

package/src/RenderingEngine/StackViewport.ts

@@ -1936,6 +1936,7 @@ class StackViewport extends Viewport implements IStackViewport, IImagesLoader {
           enabled: true,
         },
         useRGBA: true,
+        requestType,
       };
 
       const eventDetail: EventTypes.PreStackNewImageEventDetail = {

package/src/RenderingEngine/Viewport.ts

@@ -1113,7 +1113,7 @@ class Viewport implements IViewport {
       }
 
       if (viewUp) {
-        viewUpHasChanged = isEqual(currentViewUp, prevViewUp);
+        viewUpHasChanged = !isEqual(currentViewUp, prevViewUp);
       }
 
       // only modify the clipping planes if the camera is modified out of plane

package/src/enums/RequestType.ts

@@ -6,8 +6,10 @@ enum RequestType {
   Interaction = 'interaction',
   /** Second highest priority for loading*/
   Thumbnail = 'thumbnail',
-  /** Lowest priority for loading*/
+  /** Third highest priority for loading, usually used for image loading in the background*/
   Prefetch = 'prefetch',
+  /** Lower priority, often used for background computations in the worker */
+  Compute = 'compute',
 }
 
 export default RequestType;

package/src/index.ts

@@ -40,6 +40,7 @@ import {
   resetUseSharedArrayBuffer,
   getConfiguration,
   setConfiguration,
+  getWebWorkerManager,
 } from './init';
 
 // Classes
@@ -85,6 +86,7 @@ export {
   // configs
   getConfiguration,
   setConfiguration,
+  getWebWorkerManager,
   // enums
   Enums,
   CONSTANTS,

package/src/init.ts

@@ -6,6 +6,8 @@ let useSharedArrayBuffer = true;
 let sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
 import { deepMerge } from './utilities';
 import { Cornerstone3DConfig } from './types';
+import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
+
 // TODO: move sharedArrayBuffer into config.
 // TODO: change config into a class with methods to better control get/set
 const defaultConfig: Cornerstone3DConfig = {
@@ -36,6 +38,8 @@ let config: Cornerstone3DConfig = {
   // ...
 };
 
+let webWorkerManager = null;
+
 function _getGLContext(): RenderingContext {
   // Create canvas element. The canvas is not added to the
   // document itself, so it is never displayed in the
@@ -133,6 +137,11 @@ async function init(configuration = config): Promise<boolean> {
   setUseSharedArrayBuffer(sharedArrayBufferMode);
 
   csRenderInitialized = true;
+
+  if (!webWorkerManager) {
+    webWorkerManager = new CentralizedWebWorkerManager();
+  }
+
   return csRenderInitialized;
 }
 
@@ -256,6 +265,14 @@ function _updateRenderingPipelinesForAllViewports(): void {
   );
 }
 
+function getWebWorkerManager() {
+  if (!webWorkerManager) {
+    webWorkerManager = new CentralizedWebWorkerManager();
+  }
+
+  return webWorkerManager;
+}
+
 export {
   init,
   getShouldUseCPURendering,
@@ -268,4 +285,5 @@ export {
   resetUseSharedArrayBuffer,
   getConfiguration,
   setConfiguration,
+  getWebWorkerManager,
 };

package/src/requestPool/requestPoolManager.ts

@@ -78,12 +78,14 @@ class RequestPoolManager {
     interaction: 0,
     thumbnail: 0,
     prefetch: 0,
+    compute: 0,
   };
   /* maximum number of requests of each type. */
   public maxNumRequests: {
     interaction: number;
     thumbnail: number;
     prefetch: number;
+    compute: number;
   };
   /* A public property that is used to set the delay between requests. */
   public grabDelay: number;
@@ -101,6 +103,7 @@ class RequestPoolManager {
       interaction: { 0: [] },
       thumbnail: { 0: [] },
       prefetch: { 0: [] },
+      compute: { 0: [] },
     };
 
     this.grabDelay = 5;
@@ -110,12 +113,14 @@ class RequestPoolManager {
       interaction: 0,
       thumbnail: 0,
       prefetch: 0,
+      compute: 0,
     };
 
     this.maxNumRequests = {
       interaction: 6,
       thumbnail: 6,
       prefetch: 5,
+      compute: 15,
     };
   }
 
@@ -185,15 +190,7 @@ class RequestPoolManager {
     // Adding the request to the correct priority group of the request type
     this.requestPool[type][priority].push(requestDetails);
 
-    // Wake up
-    if (!this.awake) {
-      this.awake = true;
-      this.startGrabbing();
-    } else if (type === RequestType.Interaction) {
-      // Todo: this is a hack for interaction right now, we should separate
-      // the grabbing from the adding requests
-      this.startGrabbing();
-    }
+    this.startGrabbing();
   }
 
   /**
@@ -273,11 +270,13 @@ class RequestPoolManager {
     const hasRemainingPrefetchRequests = this.sendRequests(
       RequestType.Prefetch
     );
+    const hasRemainingComputeRequests = this.sendRequests(RequestType.Compute);
 
     if (
       !hasRemainingInteractionRequests &&
       !hasRemainingThumbnailRequests &&
-      !hasRemainingPrefetchRequests
+      !hasRemainingPrefetchRequests &&
+      !hasRemainingComputeRequests
     ) {
       this.awake = false;
     }
@@ -323,7 +322,4 @@ class RequestPoolManager {
   }
 }
 
-const requestPoolManager = new RequestPoolManager();
-
 export { RequestPoolManager };
-export default requestPoolManager;

package/src/webWorkerManager/webWorkerManager.js

@@ -0,0 +1,218 @@
+import * as Comlink from 'comlink';
+import { RequestType } from '../enums/';
+import { RequestPoolManager } from '../requestPool/requestPoolManager';
+
+class CentralizedWorkerManager {
+  constructor() {
+    this.workerRegistry = {};
+    this.workerPoolManager = new RequestPoolManager('webworker');
+    this.checkIntervalForIdleWorkers = 1000;
+  }
+
+  setCheckIntervalForIdleWorkers(value) {
+    this.checkIntervalForIdleWorkers = value;
+  }
+
+  /**
+   * 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 = false,
+    } = 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,
+      idleCheckIntervalId: null,
+      instances: [],
+      loadCounters: [],
+      lastActiveTime: [],
+      // used for termination
+      nativeWorkers: [],
+    };
+
+    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);
+
+    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 empty object.
+   * @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 = {} } = {}
+  ) {
+    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 {
+          const results = await api[methodName](args);
+
+          const workerProperties = this.workerRegistry[workerName];
+          workerProperties.lastActiveTime[index] = Date.now();
+
+          resolve(results);
+        } catch (err) {
+          console.error(
+            `Error executing method '${methodName}' on worker '${workerName}':`,
+            err
+          );
+          reject(err);
+        } finally {
+          this.workerRegistry[workerName].loadCounters[index]--;
+        }
+      };
+
+      this.workerPoolManager.addRequest(
+        requestFn,
+        requestType,
+        options,
+        priority
+      );
+    });
+  }
+
+  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];
+
+      // 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;
+      }
+    });
+  }
+
+  terminate(workerName) {
+    const workerProperties = this.workerRegistry[workerName];
+    if (!workerProperties) {
+      console.error(`Worker type '${workerName}' is not registered.`);
+      return;
+    }
+
+    workerProperties.instances.forEach((workerInstance) => {
+      workerInstance[Comlink.releaseProxy]();
+    });
+
+    workerProperties.nativeWorkers.forEach((worker) => {
+      worker.terminate();
+    });
+  }
+}
+
+export default CentralizedWorkerManager;

package/dist/umd/index.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */