@cornerstonejs/core 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/init.js

@@ -1,14 +1,9 @@
-import { getGPUTier } from 'detect-gpu';
-import { SharedArrayBufferModes } from './enums';
 import { getRenderingEngines } from './RenderingEngine/getRenderingEngine';
 let csRenderInitialized = false;
-let useSharedArrayBuffer = true;
-let sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
-import { deepMerge } from './utilities';
+import deepMerge from './utilities/deepMerge';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
 const defaultConfig = {
-    gpuTier: undefined,
-    detectGPUConfig: {},
+    gpuTier: { tier: 2 },
     isMobile: false,
     rendering: {
         useCPURendering: false,
@@ -16,19 +11,11 @@ const defaultConfig = {
         useNorm16Texture: false,
         strictZSpacingForVolumeViewport: true,
     },
-    enableCacheOptimization: true,
+    peerImport: (moduleId) => null,
 };
 let config = {
-    gpuTier: undefined,
-    detectGPUConfig: {},
-    isMobile: false,
-    rendering: {
-        useCPURendering: false,
-        preferSizeOverAccuracy: false,
-        useNorm16Texture: false,
-        strictZSpacingForVolumeViewport: true,
-    },
-    enableCacheOptimization: true,
+    ...defaultConfig,
+    rendering: { ...defaultConfig.rendering },
 };
 let webWorkerManager = null;
 function _getGLContext() {
@@ -42,19 +29,6 @@ function _hasActiveWebGLContext() {
     const gl = _getGLContext();
     return (gl instanceof WebGLRenderingContext || gl instanceof WebGL2RenderingContext);
 }
-function hasSharedArrayBuffer() {
-    try {
-        if (new SharedArrayBuffer(0)) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    catch {
-        return false;
-    }
-}
 function _hasNorm16TextureSupport() {
     const gl = _getGLContext();
     if (gl) {
@@ -72,10 +46,10 @@ function isIOS() {
     else {
         return (navigator.maxTouchPoints &&
             navigator.maxTouchPoints > 2 &&
-            /MacIntel/.test(navigator.platform));
+            navigator.platform.includes('MacIntel'));
     }
 }
-async function init(configuration = config) {
+function init(configuration = config) {
     if (csRenderInitialized) {
         return csRenderInitialized;
     }
@@ -83,7 +57,7 @@ async function init(configuration = config) {
     if (isIOS()) {
         config.rendering.useNorm16Texture = _hasNorm16TextureSupport();
         if (!config.rendering.useNorm16Texture) {
-            if (configuration.rendering?.preferSizeOverAccuracy) {
+            if (configuration.rendering.preferSizeOverAccuracy) {
                 config.rendering.preferSizeOverAccuracy = true;
             }
             else {
@@ -97,28 +71,20 @@ async function init(configuration = config) {
         config.rendering.useCPURendering = true;
     }
     else {
-        config.gpuTier =
-            config.gpuTier || (await getGPUTier(config.detectGPUConfig));
-        console.log('CornerstoneRender: Using detect-gpu to get the GPU benchmark:', config.gpuTier);
-        if (config.gpuTier?.tier < 1) {
-            console.log('CornerstoneRender: GPU is not powerful enough, using CPU rendering');
-            config.rendering.useCPURendering = true;
-        }
-        else {
-            console.log('CornerstoneRender: using GPU rendering');
-        }
+        console.log('CornerstoneRender: using GPU rendering');
     }
-    setUseSharedArrayBuffer(sharedArrayBufferMode);
     csRenderInitialized = true;
     if (!webWorkerManager) {
         webWorkerManager = new CentralizedWebWorkerManager();
     }
     return csRenderInitialized;
 }
-function setUseCPURendering(status) {
+function setUseCPURendering(status, updateViewports = true) {
     config.rendering.useCPURendering = status;
     csRenderInitialized = true;
-    _updateRenderingPipelinesForAllViewports();
+    if (updateViewports) {
+        _updateRenderingPipelinesForAllViewports();
+    }
 }
 function setPreferSizeOverAccuracy(status) {
     config.rendering.preferSizeOverAccuracy = status;
@@ -138,38 +104,6 @@ function resetUseCPURendering() {
 function getShouldUseCPURendering() {
     return config.rendering.useCPURendering;
 }
-function setUseSharedArrayBuffer(mode) {
-    if (mode == SharedArrayBufferModes.AUTO) {
-        sharedArrayBufferMode = SharedArrayBufferModes.AUTO;
-        const hasSharedBuffer = hasSharedArrayBuffer();
-        if (!hasSharedBuffer) {
-            useSharedArrayBuffer = false;
-            console.warn(`CornerstoneRender: SharedArray Buffer not allowed, performance may be slower.
-        Try ensuring page is cross-origin isolated to enable SharedArrayBuffer.`);
-        }
-        else {
-            useSharedArrayBuffer = true;
-            console.log('CornerstoneRender: using SharedArrayBuffer');
-        }
-        return;
-    }
-    if (mode == SharedArrayBufferModes.TRUE || mode == true) {
-        sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
-        useSharedArrayBuffer = true;
-        return;
-    }
-    if (mode == SharedArrayBufferModes.FALSE || mode == false) {
-        sharedArrayBufferMode = SharedArrayBufferModes.FALSE;
-        useSharedArrayBuffer = false;
-        return;
-    }
-}
-function resetUseSharedArrayBuffer() {
-    setUseSharedArrayBuffer(sharedArrayBufferMode);
-}
-function getShouldUseSharedArrayBuffer() {
-    return useSharedArrayBuffer;
-}
 function isCornerstoneInitialized() {
     return csRenderInitialized;
 }
@@ -181,9 +115,11 @@ function setConfiguration(c) {
     _updateRenderingPipelinesForAllViewports();
 }
 function _updateRenderingPipelinesForAllViewports() {
-    getRenderingEngines().forEach((engine) => engine
-        .getViewports()
-        .forEach((viewport) => viewport.updateRenderingPipeline?.()));
+    getRenderingEngines().forEach((engine) => {
+        engine.getViewports().forEach((viewport) => {
+            viewport.updateRenderingPipeline();
+        });
+    });
 }
 function getWebWorkerManager() {
     if (!webWorkerManager) {
@@ -191,4 +127,7 @@ function getWebWorkerManager() {
     }
     return webWorkerManager;
 }
-export { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setUseSharedArrayBuffer, setPreferSizeOverAccuracy, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, };
+function peerImport(moduleId) {
+    return config.peerImport(moduleId);
+}
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, };

package/dist/esm/loaders/ProgressiveRetrieveImages.d.ts

@@ -1,20 +1,20 @@
-import { IRetrieveConfiguration, IImagesLoader, RetrieveStage, ImageLoadListener, RetrieveOptions } from '../types';
+import type { IRetrieveConfiguration, IImagesLoader, RetrieveStage, ImageLoadListener, RetrieveOptions } from '../types';
 import singleRetrieveStages from './configuration/singleRetrieve';
 import sequentialRetrieveStages from './configuration/sequentialRetrieve';
 import interleavedRetrieveStages from './configuration/interleavedRetrieve';
 import { ImageQualityStatus } from '../enums';
 export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
-export type NearbyRequest = {
+export interface NearbyRequest {
     itemId: string;
     linearId?: string;
     imageQualityStatus: ImageQualityStatus;
-};
-export type ProgressiveRequest = {
+}
+export interface ProgressiveRequest {
     imageId: string;
     stage: RetrieveStage;
     next?: ProgressiveRequest;
     nearbyRequests?: NearbyRequest[];
-};
+}
 export declare class ProgressiveRetrieveImages implements IImagesLoader, IRetrieveConfiguration {
     static createProgressive: typeof createProgressive;
     static interleavedRetrieveStages: {

package/dist/esm/loaders/ProgressiveRetrieveImages.js

@@ -2,10 +2,12 @@ import singleRetrieveStages from './configuration/singleRetrieve';
 import sequentialRetrieveStages from './configuration/sequentialRetrieve';
 import interleavedRetrieveStages from './configuration/interleavedRetrieve';
 import { loadAndCacheImage } from './imageLoader';
-import { triggerEvent, ProgressiveIterator, decimate } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
+import ProgressiveIterator from '../utilities/ProgressiveIterator';
+import decimate from '../utilities/decimate';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import { ImageQualityStatus, RequestType, Events } from '../enums';
-import cache from '../cache';
+import cache from '../cache/cache';
 import eventTarget from '../eventTarget';
 import { fillNearbyFrames } from './fillNearbyFrames';
 export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
@@ -186,7 +188,9 @@ class ProgressiveRetrieveImagesInstance {
         for (const stage of this.stages) {
             const indices = stage.positions ||
                 decimate(this.imageIds, stage.decimate || 1, stage.offset ?? 0);
-            indices.forEach((index) => addStageInstance(stage, index));
+            indices.forEach((index) => {
+                addStageInstance(stage, index);
+            });
         }
         return interleaved;
     }

package/dist/esm/loaders/configuration/interleavedRetrieve.d.ts

@@ -1,3 +1,3 @@
-import { RetrieveStage } from '../../types';
+import type { RetrieveStage } from '../../types';
 declare const interleavedRetrieveConfiguration: RetrieveStage[];
 export default interleavedRetrieveConfiguration;

package/dist/esm/loaders/fillNearbyFrames.d.ts

@@ -1,3 +1,3 @@
-import { ImageLoadListener } from '../types';
-import { ImageQualityStatus } from '../enums';
+import type { ImageLoadListener } from '../types';
+import type { ImageQualityStatus } from '../enums';
 export declare function fillNearbyFrames(listener: ImageLoadListener, imageQualityStatusMap: Map<string, ImageQualityStatus>, request: any, image: any, options: any): void;

package/dist/esm/loaders/geometryLoader.d.ts

@@ -1,9 +1,9 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
 import { GeometryType } from '../enums';
-import { IGeometry, PublicContourSetData, PublicSurfaceData } from '../types';
-type GeometryOptions = {
+import type { IGeometry, PublicContourSetData, PublicSurfaceData } from '../types';
+interface GeometryOptions {
     type: GeometryType;
     geometryData: PublicContourSetData | PublicSurfaceData;
-};
+}
 declare function createAndCacheGeometry(geometryId: string, options: GeometryOptions): Promise<IGeometry>;
 export { createAndCacheGeometry };

package/dist/esm/loaders/geometryLoader.js

@@ -1,5 +1,5 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { GeometryType } from '../enums';
 import { createContourSet } from './utils/contourSet/createContourSet';
 import { createSurface } from './utils/surface/createSurface';

package/dist/esm/loaders/imageLoader.d.ts

@@ -1,43 +1,38 @@
-import { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
+import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
 export interface ImageLoaderOptions {
     priority: number;
     requestType: string;
     additionalDetails?: Record<string, unknown>;
     ignoreCache?: boolean;
 }
-interface DerivedImages {
-    imageIds: Array<string>;
-    promises: Array<Promise<IImage>>;
-}
-type LocalImageOptions = {
+interface LocalImageOptions {
     scalarData?: PixelDataTypedArray;
     targetBufferType?: PixelDataTypedArrayString;
     dimensions?: Point2;
-    spacing?: Point3;
+    spacing?: Point2;
     origin?: Point3;
     direction?: Mat3;
     skipCreateBuffer?: boolean;
     onCacheAdd?: (image: IImage) => void;
-};
+}
 type DerivedImageOptions = LocalImageOptions & {
     imageId?: string;
-    targetBufferType?: PixelDataTypedArrayString;
 };
 export declare function loadImage(imageId: string, options?: ImageLoaderOptions): Promise<IImage>;
 export declare function loadAndCacheImage(imageId: string, options?: ImageLoaderOptions): Promise<IImage>;
-export declare function loadAndCacheImages(imageIds: Array<string>, options?: ImageLoaderOptions): Promise<IImage>[];
-export declare function createAndCacheDerivedImage(referencedImageId: string, options?: DerivedImageOptions, preventCache?: boolean): Promise<IImage>;
-export declare function createAndCacheDerivedImages(referencedImageIds: Array<string>, options?: DerivedImageOptions & {
+export declare function loadAndCacheImages(imageIds: string[], options?: ImageLoaderOptions): Promise<IImage>[];
+export declare function createAndCacheDerivedImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
+export declare function createAndCacheDerivedImages(referencedImageIds: string[], options?: DerivedImageOptions & {
     getDerivedImageId?: (referencedImageId: string) => string;
     targetBufferType?: PixelDataTypedArrayString;
-}): DerivedImages;
-export declare function createAndCacheLocalImage(options: LocalImageOptions, imageId: string, preventCache?: boolean): IImage;
+}): IImage[];
+export declare function createAndCacheLocalImage(imageId: string, options: LocalImageOptions): IImage;
 export declare function cancelLoadImage(imageId: string): void;
-export declare function cancelLoadImages(imageIds: Array<string>): void;
+export declare function cancelLoadImages(imageIds: string[]): void;
 export declare function cancelLoadAll(): void;
 export declare function registerImageLoader(scheme: string, imageLoader: ImageLoaderFn): void;
 export declare function registerUnknownImageLoader(imageLoader: ImageLoaderFn): ImageLoaderFn;
 export declare function unregisterAllImageLoaders(): void;
-export declare function createAndCacheDerivedSegmentationImages(referencedImageIds: Array<string>, options?: DerivedImageOptions): DerivedImages;
-export declare function createAndCacheDerivedSegmentationImage(referencedImageId: string, options?: DerivedImageOptions): Promise<IImage>;
+export declare function createAndCacheDerivedSegmentationImages(referencedImageIds: string[], options?: DerivedImageOptions): IImage[];
+export declare function createAndCacheDerivedSegmentationImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
 export {};