@cornerstonejs/core 3.0.0-beta.2 → 3.0.0-beta.3

package/dist/esm/cache/cache.d.ts

@@ -3,10 +3,13 @@ import { ImageQualityStatus } from '../enums';
 declare class Cache {
     private readonly _imageCache;
     private readonly _volumeCache;
+    private readonly _imageIdsToVolumeIdCache;
     private readonly _geometryCache;
     private _imageCacheSize;
     private _maxCacheSize;
     private _geometryCacheSize;
+    generateVolumeId(imageIds: string[]): string;
+    getImageIdsForVolumeId(volumeId: string): string[];
     setMaxCacheSize: (newMaxCacheSize: number) => void;
     isCacheable: (byteLength: any) => boolean;
     getMaxCacheSize: () => number;

package/dist/esm/cache/cache.js

@@ -3,11 +3,13 @@ import imageIdToURI from '../utilities/imageIdToURI';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
 import { ImageQualityStatus } from '../enums';
+import fnv1aHash from '../utilities/fnv1aHash';
 const ONE_GB = 1073741824;
 class Cache {
     constructor() {
         this._imageCache = new Map();
         this._volumeCache = new Map();
+        this._imageIdsToVolumeIdCache = new Map();
         this._geometryCache = new Map();
         this._imageCacheSize = 0;
         this._maxCacheSize = 3 * ONE_GB;
@@ -284,6 +286,28 @@ class Cache {
             return cachedGeometry.geometryLoadObject;
         };
     }
+    generateVolumeId(imageIds) {
+        const imageURIs = imageIds.map(imageIdToURI).sort();
+        let combinedHash = 0x811c9dc5;
+        for (const id of imageURIs) {
+            const idHash = fnv1aHash(id);
+            for (let i = 0; i < idHash.length; i++) {
+                combinedHash ^= idHash.charCodeAt(i);
+                combinedHash +=
+                    (combinedHash << 1) +
+                        (combinedHash << 4) +
+                        (combinedHash << 7) +
+                        (combinedHash << 8) +
+                        (combinedHash << 24);
+            }
+        }
+        return `volume-${(combinedHash >>> 0).toString(36)}`;
+    }
+    getImageIdsForVolumeId(volumeId) {
+        return Array.from(this._imageIdsToVolumeIdCache.entries())
+            .filter(([_, id]) => id === volumeId)
+            .map(([key]) => key);
+    }
     getBytesAvailable() {
         return this.getMaxCacheSize() - this.getCacheSize();
     }

package/dist/esm/utilities/VoxelManager.js

@@ -1,4 +1,3 @@
-import { vec3 } from 'gl-matrix';
 import cache from '../cache/cache';
 import RLEVoxelMap from './RLEVoxelMap';
 import isEqual from './isEqual';
@@ -521,7 +520,15 @@ export default class VoxelManager {
                     const sliceEnd = sliceStart + sliceSize;
                     const sliceData = new SliceDataConstructor(sliceSize);
                     sliceData.set(scalarData.subarray(sliceStart, sliceEnd));
-                    imageVoxelManager.scalarData = sliceData;
+                    if (imageVoxelManager.scalarData) {
+                        imageVoxelManager.scalarData.set(sliceData);
+                        imageVoxelManager.modifiedSlices.add(sliceIndex);
+                    }
+                    else {
+                        for (let i = 0; i < sliceSize; i++) {
+                            imageVoxelManager.setAtIndex(i, sliceData[i]);
+                        }
+                    }
                     for (let i = 0; i < sliceData.length; i++) {
                         const value = sliceData[i];
                         minValue = Math.min(minValue, value);
@@ -546,7 +553,7 @@ export default class VoxelManager {
         };
         return voxelManager;
     }
-    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents = 1, }) {
+    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents, }) {
         if (dimensions.length !== 3) {
             throw new Error('Dimensions must be provided as [number, number, number] for [width, height, depth]');
         }

package/dist/esm/utilities/calculateSpacingBetweenImageIds.d.ts

@@ -0,0 +1 @@
+export default function calculateSpacingBetweenImageIds(imageIds: string[]): number;

package/dist/esm/utilities/calculateSpacingBetweenImageIds.js

@@ -0,0 +1,71 @@
+import { vec3 } from 'gl-matrix';
+import * as metaData from '../metaData';
+import { getConfiguration } from '../init';
+export default function calculateSpacingBetweenImageIds(imageIds) {
+    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get('imagePlaneModule', imageIds[0]);
+    const rowCosineVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+    const colCosineVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    const refIppVec = vec3.fromValues(referenceImagePositionPatient[0], referenceImagePositionPatient[1], referenceImagePositionPatient[2]);
+    const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
+    let spacing;
+    function getDistance(imageId) {
+        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+        const positionVector = vec3.create();
+        const ippVec = vec3.fromValues(imagePositionPatient[0], imagePositionPatient[1], imagePositionPatient[2]);
+        vec3.sub(positionVector, refIppVec, ippVec);
+        return vec3.dot(positionVector, scanAxisNormal);
+    }
+    if (!usingWadoUri) {
+        const distanceImagePairs = imageIds.map((imageId) => {
+            const distance = getDistance(imageId);
+            return {
+                distance,
+                imageId,
+            };
+        });
+        distanceImagePairs.sort((a, b) => b.distance - a.distance);
+        const numImages = distanceImagePairs.length;
+        spacing =
+            Math.abs(distanceImagePairs[numImages - 1].distance -
+                distanceImagePairs[0].distance) /
+                (numImages - 1);
+    }
+    else {
+        const prefetchedImageIds = [
+            imageIds[0],
+            imageIds[Math.floor(imageIds.length / 2)],
+        ];
+        const firstImageDistance = getDistance(prefetchedImageIds[0]);
+        const middleImageDistance = getDistance(prefetchedImageIds[1]);
+        const metadataForMiddleImage = metaData.get('imagePlaneModule', prefetchedImageIds[1]);
+        if (!metadataForMiddleImage) {
+            throw new Error('Incomplete metadata required for volume construction.');
+        }
+        const positionVector = vec3.create();
+        const middleIppVec = vec3.fromValues(metadataForMiddleImage.imagePositionPatient[0], metadataForMiddleImage.imagePositionPatient[1], metadataForMiddleImage.imagePositionPatient[2]);
+        vec3.sub(positionVector, refIppVec, middleIppVec);
+        const distanceBetweenFirstAndMiddleImages = vec3.dot(positionVector, scanAxisNormal);
+        spacing =
+            Math.abs(distanceBetweenFirstAndMiddleImages) /
+                Math.floor(imageIds.length / 2);
+    }
+    const { sliceThickness, spacingBetweenSlices } = metaData.get('imagePlaneModule', imageIds[0]);
+    const { strictZSpacingForVolumeViewport } = getConfiguration().rendering;
+    if (spacing === 0 && !strictZSpacingForVolumeViewport) {
+        if (spacingBetweenSlices) {
+            console.debug('Could not calculate spacing. Using spacingBetweenSlices');
+            spacing = spacingBetweenSlices;
+        }
+        else if (sliceThickness) {
+            console.debug('Could not calculate spacing and no spacingBetweenSlices. Using sliceThickness');
+            spacing = sliceThickness;
+        }
+        else {
+            console.debug('Could not calculate spacing. The VolumeViewport visualization is compromised. Setting spacing to 1 to render');
+            spacing = 1;
+        }
+    }
+    return spacing;
+}

package/dist/esm/utilities/fnv1aHash.d.ts

@@ -0,0 +1 @@
+export default function fnv1aHash(str: string): string;

package/dist/esm/utilities/fnv1aHash.js

@@ -0,0 +1,9 @@
+export default function fnv1aHash(str) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash +=
+            (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    return (hash >>> 0).toString(36);
+}

package/dist/esm/utilities/index.d.ts

@@ -77,6 +77,7 @@ import * as color from './color';
 import { deepEqual } from './deepEqual';
 import type { IViewport } from '../types/IViewport';
 import FrameRange from './FrameRange';
+import fnv1aHash from './fnv1aHash';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
 import scaleArray from './scaleArray';
@@ -87,5 +88,6 @@ import scroll from './scroll';
 import clip from './clip';
 import createSubVolume from './createSubVolume';
 import getVolumeDirectionVectors from './getVolumeDirectionVectors';
+import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, };

package/dist/esm/utilities/index.js

@@ -76,6 +76,7 @@ import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
 import { deepEqual } from './deepEqual';
 import FrameRange from './FrameRange';
+import fnv1aHash from './fnv1aHash';
 import { _getViewportModality } from './getViewportModality';
 import cache from '../cache/cache';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
@@ -88,5 +89,6 @@ import scroll from './scroll';
 import clip from './clip';
 import createSubVolume from './createSubVolume';
 import getVolumeDirectionVectors from './getVolumeDirectionVectors';
+import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, };

package/dist/esm/utilities/pointInShapeCallback.js

@@ -6,10 +6,16 @@ export function pointInShapeCallback(imageData, options) {
         scalarData = imageData.getScalarData();
     }
     else {
-        scalarData = imageData
-            .getPointData()
-            .getScalars()
-            .getData();
+        const scalars = imageData.getPointData().getScalars();
+        if (scalars) {
+            scalarData = scalars.getData();
+        }
+        else {
+            const { voxelManager } = imageData.get('voxelManager') || {};
+            if (voxelManager) {
+                scalarData = voxelManager.getCompleteScalarDataArray();
+            }
+        }
     }
     const dimensions = imageData.getDimensions();
     const defaultBoundsIJK = [

package/dist/esm/utilities/sortImageIdsAndGetSpacing.js

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import * as metaData from '../metaData';
-import { getConfiguration } from '../init';
+import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
     const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get('imagePlaneModule', imageIds[0]);
     if (!scanAxisNormal) {
@@ -9,11 +9,9 @@ export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
         scanAxisNormal = vec3.create();
         vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
     }
-    const refIppVec = vec3.create();
     const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
-    vec3.set(refIppVec, referenceImagePositionPatient[0], referenceImagePositionPatient[1], referenceImagePositionPatient[2]);
+    const zSpacing = calculateSpacingBetweenImageIds(imageIds);
     let sortedImageIds;
-    let zSpacing;
     function getDistance(imageId) {
         const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
         const positionVector = vec3.create();
@@ -30,11 +28,6 @@ export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
         });
         distanceImagePairs.sort((a, b) => b.distance - a.distance);
         sortedImageIds = distanceImagePairs.map((a) => a.imageId);
-        const numImages = distanceImagePairs.length;
-        zSpacing =
-            Math.abs(distanceImagePairs[numImages - 1].distance -
-                distanceImagePairs[0].distance) /
-                (numImages - 1);
     }
     else {
         const prefetchedImageIds = [
@@ -47,33 +40,8 @@ export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
         if (firstImageDistance - middleImageDistance < 0) {
             sortedImageIds.reverse();
         }
-        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;
-    if (zSpacing === 0 && !strictZSpacingForVolumeViewport) {
-        if (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 { imagePositionPatient: origin } = metaData.get('imagePlaneModule', sortedImageIds[0]);
     const result = {
         zSpacing,
         origin,

package/dist/esm/webWorkerManager/webWorkerManager.js

@@ -27,6 +27,7 @@ class CentralizedWorkerManager {
             autoTerminateOnIdle: autoTerminateOnIdle.enabled,
             idleCheckIntervalId: null,
             idleTimeThreshold: autoTerminateOnIdle.idleTimeThreshold,
+            options: options,
         };
         workerProperties.loadCounters = Array(maxWorkerInstances).fill(0);
         workerProperties.lastActiveTime = Array(maxWorkerInstances).fill(null);
@@ -84,6 +85,7 @@ class CentralizedWorkerManager {
                     }
                     const workerProperties = this.workerRegistry[workerName];
                     workerProperties.processing = true;
+                    args = { ...args, ...workerProperties.options };
                     const results = await api[methodName](args, ...finalCallbacks);
                     workerProperties.processing = false;
                     workerProperties.lastActiveTime[index] = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.3",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -82,5 +82,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "0e36ef232d9195cbecdf99982dedf6b73cd9d1ee"
+  "gitHead": "d2b29db96b3ecf98c9e9f0591978423dc9f6cb3f"
 }