@cornerstonejs/core 2.0.0-beta.21 → 2.0.0-beta.23

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

@@ -3,8 +3,8 @@ import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
 import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, IVolumeViewport } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
-import Viewport from './Viewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
+import Viewport from './Viewport';
 declare abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     useCPURendering: boolean;
     private _FrameOfReferenceUID;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -2,20 +2,30 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import { vec2, vec3 } from 'gl-matrix';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS, VIEWPORT_PRESETS, } from '../constants';
 import { Events, ViewportStatus, VOILUTFunctionType } from '../enums';
 import ViewportType from '../enums/ViewportType';
 import eventTarget from '../eventTarget';
 import { getShouldUseCPURendering } from '../init';
-import { actorIsA, applyPreset, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, imageIdToURI, invertRgbTransferFunction, triggerEvent, colormap as colormapUtils, isEqualNegative, getVolumeViewportScrollInfo, snapFocalPointToSlice, isEqual, } from '../utilities';
-import { createVolumeActor } from './helpers';
-import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './helpers/volumeNewImageEventDispatcher';
-import Viewport from './Viewport';
-import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
+import triggerEvent from '../utilities/triggerEvent';
+import * as colormapUtils from '../utilities/colormap';
+import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
+import createSigmoidRGBTransferFunction from '../utilities/createSigmoidRGBTransferFunction';
 import transformWorldToIndex from '../utilities/transformWorldToIndex';
 import { findMatchingColormap } from '../utilities/colormap';
 import { getTransferFunctionNodes } from '../utilities/transferFunctionUtils';
+import createVolumeActor from './helpers/createVolumeActor';
+import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './helpers/volumeNewImageEventDispatcher';
+import Viewport from './Viewport';
+import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
+import getVolumeViewportScrollInfo from '../utilities/getVolumeViewportScrollInfo';
+import { actorIsA } from '../utilities/actorCheck';
+import snapFocalPointToSlice from '../utilities/snapFocalPointToSlice';
+import getVoiFromSigmoidRGBTransferFunction from '../utilities/getVoiFromSigmoidRGBTransferFunction';
+import isEqual, { isEqualNegative } from '../utilities/isEqual';
+import applyPreset from '../utilities/applyPreset';
+import imageIdToURI from '../utilities/imageIdToURI';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);

package/dist/esm/RenderingEngine/RenderingEngine.d.ts

@@ -1,8 +1,7 @@
 import type IStackViewport from '../types/IStackViewport';
 import type IRenderingEngine from '../types/IRenderingEngine';
 import type IVolumeViewport from '../types/IVolumeViewport';
-import type { IViewport } from '../types/IViewport';
-import type { PublicViewportInput } from '../types/IViewport';
+import type { PublicViewportInput, IViewport } from '../types/IViewport';
 declare class RenderingEngine implements IRenderingEngine {
     readonly id: string;
     hasBeenDestroyed: boolean;

package/dist/esm/RenderingEngine/RenderingEngine.js

@@ -1,7 +1,8 @@
 import Events from '../enums/Events';
 import renderingEngineCache from './renderingEngineCache';
 import eventTarget from '../eventTarget';
-import { triggerEvent, uuidv4 } from '../utilities';
+import uuidv4 from '../utilities/uuidv4';
+import triggerEvent from '../utilities/triggerEvent';
 import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
 import ViewportType from '../enums/ViewportType';
 import VolumeViewport from './VolumeViewport';

package/dist/esm/RenderingEngine/StackViewport.d.ts

@@ -1,10 +1,8 @@
 import type { vtkImageData as vtkImageDataType } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { mat4 } from 'gl-matrix';
-import type { ActorEntry, CPUIImageData, ICamera, IImage, IImageData, IImagesLoader, IStackInput, IStackViewport, ImageLoadListener, Mat3, Point2, Point3, Scaling, StackViewportProperties, ViewReference } from '../types';
-import type { ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewportInput } from '../types/IViewport';
+import type { ActorEntry, CPUIImageData, ICamera, IImage, IImageData, IImagesLoader, IStackInput, IStackViewport, ImageLoadListener, Mat3, Point2, Point3, Scaling, StackViewportProperties, ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewportInput, ImagePixelModule, ImagePlaneModule } from '../types';
 import Viewport from './Viewport';
 import { InterpolationType, RequestType, ViewportStatus } from '../enums';
-import type { ImagePixelModule, ImagePlaneModule } from '../types';
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 export interface ImageDataMetaData {
     bitsAllocated: number;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -8,9 +8,19 @@ import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import { mat4, vec2, vec3 } from 'gl-matrix';
 import eventTarget from '../eventTarget';
 import * as metaData from '../metaData';
-import { actorIsA, colormap as colormapUtils, createSigmoidRGBTransferFunction, imageIdToURI, imageRetrieveMetadataProvider, invertRgbTransferFunction, isEqual, isImageActor, triggerEvent, updateVTKImageDataWithCornerstoneImage, windowLevel as windowLevelUtil, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import * as colormapUtils from '../utilities/colormap';
+import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
+import * as windowLevelUtil from '../utilities/windowLevel';
+import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
+import createSigmoidRGBTransferFunction from '../utilities/createSigmoidRGBTransferFunction';
+import { updateVTKImageDataWithCornerstoneImage } from '../utilities/updateVTKImageDataWithCornerstoneImage';
+import triggerEvent from '../utilities/triggerEvent';
+import { isEqual } from '../utilities/isEqual';
+import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
+import imageRetrieveMetadataProvider from '../utilities/imageRetrieveMetadataProvider';
+import imageIdToURI from '../utilities/imageIdToURI';
 import Viewport from './Viewport';
-import { getColormap } from './helpers/cpuFallback/colors/index';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
 import { Events, InterpolationType, MetadataModules, RequestType, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import { loadAndCacheImage } from '../loaders/imageLoader';
@@ -20,15 +30,12 @@ import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
 import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import resize from './helpers/cpuFallback/rendering/resize';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { getConfiguration, getShouldUseCPURendering } from '../init';
 import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
-import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
-import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
-import { findMatchingColormap } from '../utilities/colormap';
 const EPSILON = 1;
 class StackViewport extends Viewport {
     constructor(props) {
@@ -627,7 +634,7 @@ class StackViewport extends Viewport {
             return acc;
         }, []);
         const defaultActor = this.getDefaultActor();
-        const matchedColormap = findMatchingColormap(RGBPoints, defaultActor.actor);
+        const matchedColormap = colormapUtils.findMatchingColormap(RGBPoints, defaultActor.actor);
         this.setColormap(matchedColormap);
     }
     resetToDefaultProperties() {
@@ -1772,7 +1779,7 @@ class StackViewport extends Viewport {
     }
     setColormapCPU(colormapData) {
         this.colormap = colormapData;
-        const colormap = getColormap(colormapData.name, colormapData);
+        const colormap = colormapUtils.getColormap(colormapData.name);
         this._cpuFallbackEnabledElement.viewport.colormap = colormap;
         this._cpuFallbackEnabledElement.renderingTools = {};
         this.fillWithBackgroundColor();

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -2,11 +2,11 @@ import { vec3 } from 'gl-matrix';
 import { Events as EVENTS, VideoEnums as VideoViewportEnum, MetadataModules, } from '../enums';
 import * as metaData from '../metaData';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
-import { triggerEvent } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
 import CanvasActor from './CanvasActor';
-import cache from '../cache';
+import cache from '../cache/cache';
 class VideoViewport extends Viewport {
     static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
     constructor(props) {

package/dist/esm/RenderingEngine/Viewport.js

@@ -6,7 +6,10 @@ import Events from '../enums/Events';
 import ViewportStatus from '../enums/ViewportStatus';
 import ViewportType from '../enums/ViewportType';
 import renderingEngineCache from './renderingEngineCache';
-import { triggerEvent, planar, isImageActor, actorIsA, isEqual, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import triggerEvent from '../utilities/triggerEvent';
+import * as planar from '../utilities/planar';
+import isEqual from '../utilities/isEqual';
 import hasNaNValues from '../utilities/hasNaNValues';
 import { RENDERING_DEFAULTS } from '../constants';
 import { InterpolationType } from '../enums';

package/dist/esm/RenderingEngine/VolumeViewport.d.ts

@@ -1,9 +1,9 @@
+import { mat4 } from 'gl-matrix';
 import type { BlendModes } from '../enums';
 import { OrientationAxis } from '../enums';
 import type { IVolumeInput, OrientationVectors, Point3, ViewReference, ViewReferenceSpecifier } from '../types';
 import type { ViewportInput } from '../types/IViewport';
 import BaseVolumeViewport from './BaseVolumeViewport';
-import { mat4 } from 'gl-matrix';
 declare class VolumeViewport extends BaseVolumeViewport {
     private _useAcquisitionPlaneForViewPlane;
     constructor(props: ViewportInput);

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -1,13 +1,18 @@
+import { mat4, vec3 } from 'gl-matrix';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { EPSILON, MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
 import { OrientationAxis, Events } from '../enums';
-import { actorIsA, getClosestImageId, getSliceRange, getSpacingInNormalDirection, isImageActor, snapFocalPointToSlice, triggerEvent, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import getClosestImageId from '../utilities/getClosestImageId';
+import getSliceRange from '../utilities/getSliceRange';
+import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirection';
+import snapFocalPointToSlice from '../utilities/snapFocalPointToSlice';
+import triggerEvent from '../utilities/triggerEvent';
 import BaseVolumeViewport from './BaseVolumeViewport';
 import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
 import { setTransferFunctionNodes } from '../utilities/transferFunctionUtils';
 import getImageSliceDataForVolumeViewport from '../utilities/getImageSliceDataForVolumeViewport';
-import { mat4, vec3 } from 'gl-matrix';
 import { transformCanvasToIJK } from '../utilities/transformCanvasToIJK';
 import { transformIJKToCanvas } from '../utilities/transformIJKToCanvas';
 class VolumeViewport extends BaseVolumeViewport {

package/dist/esm/RenderingEngine/WSIViewport.js

@@ -6,7 +6,7 @@ import { Transform } from './helpers/cpuFallback/rendering/transform';
 import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
 import { EPSILON } from '../constants';
-import { triggerEvent } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
 import { peerImport } from '../init';
 const _map = Symbol.for('map');
 const EVENT_POSTRENDER = 'postrender';

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderPseudoColorImage.js

@@ -7,7 +7,7 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered';
 import storedPixelDataToCanvasImageDataPseudocolorLUT from './storedPixelDataToCanvasImageDataPseudocolorLUT';
 import storedPixelDataToCanvasImageDataPseudocolorLUTPET from './storedPixelDataToCanvasImageDataPseudocolorLUTPET';
 import * as colors from '../colors/index';
-import { clamp } from '../../../../utilities';
+import { clamp } from '../../../../utilities/clamp';
 function getRenderCanvas(enabledElement, image, invalidated) {
     if (!enabledElement.renderingTools.renderCanvas) {
         enabledElement.renderingTools.renderCanvas =

package/dist/esm/RenderingEngine/helpers/createVolumeActor.js

@@ -1,7 +1,7 @@
 import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
 import { loadVolume } from '../../loaders/volumeLoader';
 import createVolumeMapper from './createVolumeMapper';
-import { triggerEvent } from '../../utilities';
+import triggerEvent from '../../utilities/triggerEvent';
 import { Events } from '../../enums';
 import setDefaultVolumeVOI from './setDefaultVolumeVOI';
 async function createVolumeActor(props, element, viewportId, suppressEvents = false) {

package/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.js

@@ -1,8 +1,9 @@
 import { loadAndCacheImage } from '../../loaders/imageLoader';
 import * as metaData from '../../metaData';
-import { getMinMax, windowLevel } from '../../utilities';
+import getMinMax from '../../utilities/getMinMax';
+import * as windowLevel from '../../utilities/windowLevel';
 import { RequestType } from '../../enums';
-import cache from '../../cache';
+import cache from '../../cache/cache';
 const PRIORITY = 0;
 const REQUEST_TYPE = RequestType.Prefetch;
 async function setDefaultVolumeVOI(volumeActor, imageVolume) {

package/dist/esm/RenderingEngine/helpers/volumeNewImageEventDispatcher.js

@@ -1,7 +1,7 @@
-import { getImageSliceDataForVolumeViewport, triggerEvent, } from '../../utilities';
+import getImageSliceDataForVolumeViewport from '../../utilities/getImageSliceDataForVolumeViewport';
+import triggerEvent from '../../utilities/triggerEvent';
 import { Events } from '../../enums';
 import { getRenderingEngine } from '../getRenderingEngine';
-import BaseVolumeViewport from '../BaseVolumeViewport';
 const state = {};
 export function resetVolumeNewImageState(viewportId) {
     if (state[viewportId] !== undefined) {
@@ -12,8 +12,8 @@ function volumeNewImageEventDispatcher(cameraEvent) {
     const { renderingEngineId, viewportId } = cameraEvent.detail;
     const renderingEngine = getRenderingEngine(renderingEngineId);
     const viewport = renderingEngine.getViewport(viewportId);
-    if (!(viewport instanceof BaseVolumeViewport)) {
-        throw new Error(`volumeNewImageEventDispatcher: viewport is not a BaseVolumeViewport`);
+    if (!('setVolumes' in viewport)) {
+        throw new Error(`volumeNewImageEventDispatcher: viewport does not have setVolumes method`);
     }
     if (state[viewport.id] === undefined) {
         state[viewport.id] = 0;

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -1,6 +1,6 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
-import cache from '../../cache';
+import cache from '../../cache/cache';
 function vtkStreamingOpenGLTexture(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLTexture');
     model.updatedFrames = [];

package/dist/esm/cache/cache.js

@@ -1,4 +1,5 @@
-import { triggerEvent, imageIdToURI } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
+import imageIdToURI from '../utilities/imageIdToURI';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
 const ONE_GB = 1073741824;

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

@@ -0,0 +1,85 @@
+import { ImageQualityStatus, RequestType } from '../../enums';
+import type { IImagesLoader, ImageLoadRequests, ImageVolumeProps, IStreamingVolumeProperties, PixelDataTypedArrayString, ScalingParameters } from '../../types';
+import ImageVolume from './ImageVolume';
+export default class BaseStreamingImageVolume extends ImageVolume implements IImagesLoader {
+    private framesLoaded;
+    private framesProcessed;
+    private framesUpdated;
+    protected autoRenderOnLoad: boolean;
+    protected cachedFrames: any[];
+    protected reRenderTarget: number;
+    protected reRenderFraction: number;
+    dataType: PixelDataTypedArrayString;
+    loadStatus: {
+        loaded: boolean;
+        loading: boolean;
+        cancelled: boolean;
+        callbacks: Array<(...args: unknown[]) => void>;
+    };
+    imagesLoader: IImagesLoader;
+    constructor(imageVolumeProperties: ImageVolumeProps, streamingProperties: IStreamingVolumeProperties);
+    protected invalidateVolume(immediate: boolean): void;
+    cancelLoading: () => void;
+    clearLoadCallbacks(): void;
+    protected callLoadStatusCallback(evt: any): void;
+    protected updateTextureAndTriggerEvents(imageIdIndex: any, imageId: any, imageQualityStatus?: ImageQualityStatus): void;
+    successCallback(imageId: string, image: any): void;
+    errorCallback(imageId: any, permanent: any, error: any): void;
+    load: (callback: (...args: unknown[]) => void) => void;
+    getLoaderImageOptions(imageId: string): {
+        targetBuffer: {
+            type: PixelDataTypedArrayString;
+            rows: any;
+            columns: any;
+        };
+        allowFloatRendering: boolean;
+        preScale: {
+            enabled: boolean;
+            scalingParameters: ScalingParameters;
+        };
+        transferPixelData: boolean;
+        requestType: RequestType;
+        transferSyntaxUID: any;
+        additionalDetails: {
+            imageId: string;
+            imageIdIndex: number;
+            volumeId: string;
+        };
+    };
+    callLoadImage(imageId: any, imageIdIndex: any, options: any): any;
+    protected getImageIdsRequests(imageIds: string[], priorityDefault: number): {
+        callLoadImage: (imageId: any, imageIdIndex: any, options: any) => any;
+        imageId: string;
+        imageIdIndex: number;
+        options: {
+            targetBuffer: {
+                type: PixelDataTypedArrayString;
+                rows: any;
+                columns: any;
+            };
+            allowFloatRendering: boolean;
+            preScale: {
+                enabled: boolean;
+                scalingParameters: ScalingParameters;
+            };
+            transferPixelData: boolean;
+            requestType: RequestType;
+            transferSyntaxUID: any;
+            additionalDetails: {
+                imageId: string;
+                imageIdIndex: number;
+                volumeId: string;
+            };
+        };
+        priority: number;
+        requestType: RequestType;
+        additionalDetails: {
+            volumeId: string;
+        };
+    }[];
+    getImageLoadRequests(priority: number): ImageLoadRequests[];
+    getImageIdsToLoad(): string[];
+    loadImages(): Promise<boolean>;
+    private _prefetchImageIds;
+    private _addScalingToVolume;
+}