@cornerstonejs/core 2.0.0-beta.27 → 2.0.0-beta.28

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -7,6 +7,8 @@ import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
 import CanvasActor from './CanvasActor';
 import cache from '../cache/cache';
+import uuidv4 from '../utilities/uuidv4';
+import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 class VideoViewport extends Viewport {
     static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
     constructor(props) {
@@ -110,12 +112,14 @@ class VideoViewport extends Viewport {
             this.renderFrame();
         };
         this.renderFrame = () => {
+            const dpr = window.devicePixelRatio || 1;
             const transform = this.getTransform();
             const transformationMatrix = transform.getMatrix();
             const ctx = this.canvasContext;
             ctx.resetTransform();
-            ctx.transform(transformationMatrix[0], transformationMatrix[1], transformationMatrix[2], transformationMatrix[3], transformationMatrix[4], transformationMatrix[5]);
-            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth || 1024, this.videoHeight || 1024);
+            ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+            ctx.transform(transformationMatrix[0] / dpr, transformationMatrix[1] / dpr, transformationMatrix[2] / dpr, transformationMatrix[3] / dpr, transformationMatrix[4] / dpr, transformationMatrix[5] / dpr);
+            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth, this.videoHeight);
             for (const actor of this.getActors()) {
                 actor.actor.render(this, this.canvasContext);
             }
@@ -138,7 +142,7 @@ class VideoViewport extends Viewport {
                 time: this.videoElement.currentTime,
                 duration: this.videoElement.duration,
             });
-            this.initialRender();
+            this.initialRender?.();
             const frame = this.getFrameNumber();
             if (this.isPlaying) {
                 if (frame < this.frameRange[0]) {
@@ -225,7 +229,7 @@ class VideoViewport extends Viewport {
         };
     }
     setDataIds(imageIds, options) {
-        this.setVideo(imageIds[0], (options.viewReference.sliceIndex || 0) + 1);
+        this.setVideo(imageIds[0], (options.viewReference?.sliceIndex || 0) + 1);
     }
     setVideo(imageId, frameNumber) {
         this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
@@ -423,15 +427,24 @@ class VideoViewport extends Viewport {
         });
     }
     getScalarData() {
-        if (this.scalarData.frameNumber === this.getFrameNumber()) {
+        if (this.scalarData?.frameNumber === this.getFrameNumber()) {
             return this.scalarData;
         }
+        if (!this.videoElement ||
+            !this.videoElement.videoWidth ||
+            !this.videoElement.videoHeight) {
+            console.debug('Video not ready yet, returning empty scalar data');
+            const emptyData = new Uint8ClampedArray();
+            emptyData.getRange = () => [0, 255];
+            emptyData.frameNumber = -1;
+            return emptyData;
+        }
         const canvas = document.createElement('canvas');
-        canvas.width = this.videoWidth;
-        canvas.height = this.videoHeight;
+        canvas.width = this.videoElement.videoWidth;
+        canvas.height = this.videoElement.videoHeight;
         const context = canvas.getContext('2d');
         context.drawImage(this.videoElement, 0, 0);
-        const canvasData = context.getImageData(0, 0, this.videoWidth, this.videoHeight);
+        const canvasData = context.getImageData(0, 0, canvas.width, canvas.height);
         const scalarData = canvasData.data;
         scalarData.getRange = () => [0, 255];
         scalarData.frameNumber = this.getFrameNumber();
@@ -442,6 +455,22 @@ class VideoViewport extends Viewport {
         const { metadata } = this;
         const spacing = metadata.spacing;
         const imageData = {
+            getDirection: () => metadata.direction,
+            getDimensions: () => metadata.dimensions,
+            getRange: () => [0, 255],
+            getScalarData: () => this.getScalarData(),
+            getSpacing: () => metadata.spacing,
+            worldToIndex: (point) => {
+                const canvasPoint = this.worldToCanvas(point);
+                const pixelCoord = this.canvasToIndex(canvasPoint);
+                return [pixelCoord[0], pixelCoord[1], 0];
+            },
+            indexToWorld: (point, destPoint) => {
+                const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                return this.canvasToWorld(canvasPoint, destPoint);
+            },
+        };
+        const imageDataForReturn = {
             dimensions: metadata.dimensions,
             spacing,
             origin: metadata.origin,
@@ -452,20 +481,15 @@ class VideoViewport extends Viewport {
             },
             getScalarData: () => this.getScalarData(),
             scalarData: this.getScalarData(),
-            imageData: {
-                getDirection: () => metadata.direction,
-                getDimensions: () => metadata.dimensions,
-                getRange: () => [0, 255],
-                getScalarData: () => this.getScalarData(),
-                getSpacing: () => metadata.spacing,
-                worldToIndex: (point) => {
-                    const canvasPoint = this.worldToCanvas(point);
-                    const pixelCoord = this.canvasToIndex(canvasPoint);
-                    return [pixelCoord[0], pixelCoord[1], 0];
-                },
-                indexToWorld: (point, destPoint) => {
-                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
-                    return this.canvasToWorld(canvasPoint, destPoint);
+            imageData,
+            voxelManager: {
+                forEach: (callback, options) => {
+                    return pointInShapeCallback(options.imageData, {
+                        pointInShapeFn: options.isInObject ?? (() => true),
+                        callback: callback,
+                        boundsIJK: options.boundsIJK,
+                        returnPoints: options.returnPoints ?? false,
+                    });
                 },
             },
             hasPixelSpacing: this.hasPixelSpacing,
@@ -478,7 +502,7 @@ class VideoViewport extends Viewport {
             get: () => this.getScalarData(),
             enumerable: true,
         });
-        return imageData;
+        return imageDataForReturn;
     }
     hasImageURI(imageURI) {
         const framesMatch = imageURI.match(VideoViewport.frameRangeExtractor);
@@ -612,7 +636,7 @@ class VideoViewport extends Viewport {
         }
     }
     getViewReference(viewRefSpecifier) {
-        let sliceIndex = viewRefSpecifier.sliceIndex;
+        let sliceIndex = viewRefSpecifier?.sliceIndex ?? this.getSliceIndex();
         if (!sliceIndex) {
             sliceIndex = this.isPlaying
                 ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
@@ -704,8 +728,9 @@ class VideoViewport extends Viewport {
         stackInputs.forEach((stackInput) => {
             const image = cache.getImage(stackInput.imageId);
             const imageActor = this.createActorMapper(image);
+            const uid = stackInput.actorUID ?? uuidv4();
             if (imageActor) {
-                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                actors.push({ uid, actor: imageActor });
                 if (stackInput.callback) {
                     stackInput.callback({
                         imageActor: imageActor,
@@ -721,4 +746,3 @@ class VideoViewport extends Viewport {
     }
 }
 export default VideoViewport;
-//# sourceMappingURL=VideoViewport.js.map

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

@@ -77,7 +77,9 @@ declare class Viewport {
     setActors(actors: ActorEntry[]): void;
     _removeActor(actorUID: string): void;
     removeActors(actorUIDs: string[]): void;
-    addActors(actors: ActorEntry[], resetCameraPanAndZoom?: boolean): void;
+    addActors(actors: ActorEntry[], options?: {
+        resetCamera?: boolean;
+    }): void;
     addActor(actorEntry: ActorEntry): void;
     removeAllActors(): void;
     protected resetCameraNoEvent(): void;

package/dist/esm/RenderingEngine/Viewport.js

@@ -199,8 +199,7 @@ class Viewport {
     }
     setActors(actors) {
         this.removeAllActors();
-        const resetCameraPanAndZoom = true;
-        this.addActors(actors, resetCameraPanAndZoom);
+        this.addActors(actors, { resetCamera: true });
     }
     _removeActor(actorUID) {
         const actorEntry = this.getActor(actorUID);
@@ -217,7 +216,8 @@ class Viewport {
             this._removeActor(actorUID);
         });
     }
-    addActors(actors, resetCameraPanAndZoom = false) {
+    addActors(actors, options = {}) {
+        const { resetCamera = false } = options;
         const renderingEngine = this.getRenderingEngine();
         if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
             console.warn('Viewport::addActors::Rendering engine has not been initialized or has been destroyed');
@@ -226,10 +226,13 @@ class Viewport {
         actors.forEach((actor) => {
             this.addActor(actor);
         });
-        this.resetCamera({
-            resetPan: resetCameraPanAndZoom,
-            resetZoom: resetCameraPanAndZoom,
-        });
+        const prevViewPresentation = this.getViewPresentation();
+        const prevViewRef = this.getViewReference();
+        this.resetCamera();
+        if (!resetCamera) {
+            this.setViewReference(prevViewRef);
+            this.setViewPresentation(prevViewPresentation);
+        }
     }
     addActor(actorEntry) {
         const { uid: actorUID, actor } = actorEntry;
@@ -498,6 +501,9 @@ class Viewport {
         this.fitToCanvasCamera = camera;
     }
     getPan(initialCamera = this.initialCamera) {
+        if (!initialCamera) {
+            return [0, 0];
+        }
         const activeCamera = this.getVtkActiveCamera();
         const focalPoint = activeCamera.getFocalPoint();
         const zero3 = this.canvasToWorld([0, 0]);
@@ -664,7 +670,7 @@ class Viewport {
             }
             if (cameraModifiedOutOfPlane || viewUpHasChanged) {
                 const actorEntry = this.getDefaultActor();
-                if (!actorEntry.actor) {
+                if (!actorEntry?.actor) {
                     return;
                 }
                 if (!actorIsA(actorEntry, 'vtkActor')) {
@@ -939,4 +945,3 @@ class Viewport {
     }
 }
 export default Viewport;
-//# sourceMappingURL=Viewport.js.map

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

@@ -11,6 +11,7 @@ declare class VolumeViewport extends BaseVolumeViewport {
     getNumberOfSlices: () => number;
     addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
+    protected setCameraClippingRange(): void;
     private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;
@@ -33,7 +34,6 @@ declare class VolumeViewport extends BaseVolumeViewport {
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     resetProperties(volumeId?: string): void;
     private _resetProperties;
-    private setCameraClippingRange;
     getSlicesClippingPlanes(): {
         sliceIndex: number;
         planes: {

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -54,8 +54,7 @@ class VolumeViewport extends BaseVolumeViewport {
             if (!actorEntry || !actorIsA(actorEntry, 'vtkVolume')) {
                 return;
             }
-            const { uid } = actorEntry;
-            const volume = cache.getVolume(uid);
+            const volume = cache.getVolume(this.getVolumeId());
             if (!volume) {
                 return;
             }
@@ -68,7 +67,7 @@ class VolumeViewport extends BaseVolumeViewport {
                 console.warn('No image data found for calculating vtkPlanes.');
                 return [];
             }
-            const volumeId = actorEntry.uid;
+            const volumeId = this.getVolumeId();
             const imageVolume = cache.getVolume(volumeId);
             const camera = this.getCamera();
             const { focalPoint, position, viewPlaneNormal } = camera;
@@ -140,12 +139,21 @@ class VolumeViewport extends BaseVolumeViewport {
             this.render();
         }
     }
+    setCameraClippingRange() {
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(activeCamera.getDistance(), activeCamera.getDistance() + this.getSlabThickness());
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+    }
     _getAcquisitionPlaneOrientation() {
         const actorEntry = this.getDefaultActor();
         if (!actorEntry) {
             return;
         }
-        const volumeId = actorEntry.uid;
+        const volumeId = this.getVolumeId();
         const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
             throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
@@ -199,7 +207,6 @@ class VolumeViewport extends BaseVolumeViewport {
         }
         super.resetCamera({ resetPan, resetZoom, resetToCenter });
         const activeCamera = this.getVtkActiveCamera();
-        this.setCameraClippingRange();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const focalPoint = activeCamera.getFocalPoint();
         const actorEntries = this.getActors();
@@ -258,7 +265,6 @@ class VolumeViewport extends BaseVolumeViewport {
         });
         const currentCamera = this.getCamera();
         this.updateClippingPlanesForActors(currentCamera);
-        this.setCameraClippingRange();
         this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
         this.viewportProperties.slabThickness = slabThickness;
     }
@@ -366,9 +372,10 @@ class VolumeViewport extends BaseVolumeViewport {
             this.viewportProperties.slabThickness = undefined;
             this.updateClippingPlanesForActors(this.getCamera());
         }
-        const imageVolume = cache.getVolume(volumeActor.uid);
+        volumeId ||= this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
         setDefaultVolumeVOI(volumeActor.actor, imageVolume);
         if (isImageActor(volumeActor)) {
@@ -392,15 +399,6 @@ class VolumeViewport extends BaseVolumeViewport {
         });
         triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
     }
-    setCameraClippingRange() {
-        const activeCamera = this.getVtkActiveCamera();
-        if (activeCamera.getParallelProjection()) {
-            activeCamera.setClippingRange(activeCamera.getDistance(), activeCamera.getDistance() + this.getSlabThickness());
-        }
-        else {
-            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
-        }
-    }
     getSlicesClippingPlanes() {
         const focalPoints = this.getSlicePlaneCoordinates();
         const { viewPlaneNormal } = this.getCamera();
@@ -419,4 +417,3 @@ class VolumeViewport extends BaseVolumeViewport {
     }
 }
 export default VolumeViewport;
-//# sourceMappingURL=VolumeViewport.js.map

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

@@ -14,6 +14,9 @@ declare class VolumeViewport3D extends BaseVolumeViewport {
     setSlabThickness(slabThickness: number, filterActorUIDs?: string[]): void;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
     resetProperties(volumeId?: string): void;
+    resetCameraForResize: () => boolean;
+    getSliceIndex(): number;
+    protected setCameraClippingRange(): void;
     resetSlabThickness(): void;
 }
 export default VolumeViewport3D;

package/dist/esm/RenderingEngine/VolumeViewport3D.js

@@ -16,6 +16,13 @@ class VolumeViewport3D extends BaseVolumeViewport {
         this.getCurrentImageId = () => {
             return null;
         };
+        this.resetCameraForResize = () => {
+            return this.resetCamera({
+                resetPan: true,
+                resetZoom: true,
+                resetToCenter: true,
+            });
+        };
         const { parallelProjection, orientation } = this.options;
         const activeCamera = this.getVtkActiveCamera();
         if (parallelProjection != null) {
@@ -54,9 +61,10 @@ class VolumeViewport3D extends BaseVolumeViewport {
             this.viewportProperties.slabThickness = undefined;
             this.updateClippingPlanesForActors(this.getCamera());
         }
-        const imageVolume = cache.getVolume(volumeActor.uid);
+        volumeId ||= this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
         setDefaultVolumeVOI(volumeActor.actor, imageVolume);
         if (isImageActor(volumeActor)) {
@@ -68,9 +76,20 @@ class VolumeViewport3D extends BaseVolumeViewport {
         this.setCamera(this.initialCamera);
         triggerEvent(this.element, Events.VOI_MODIFIED, super.getVOIModifiedEventDetail(volumeId));
     }
+    getSliceIndex() {
+        return null;
+    }
+    setCameraClippingRange() {
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+    }
     resetSlabThickness() {
         return null;
     }
 }
 export default VolumeViewport3D;
-//# sourceMappingURL=VolumeViewport3D.js.map

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

@@ -52,7 +52,7 @@ declare class WSIViewport extends Viewport {
     getZoom(): any;
     setZoom(zoom: number): void;
     protected getTransform(): Transform;
-    getReferenceId(): string;
+    getViewReferenceId(): string;
     getCurrentImageIdIndex(): number;
 }
 export default WSIViewport;

package/dist/esm/RenderingEngine/WSIViewport.js

@@ -8,6 +8,7 @@ import { getOrCreateCanvas } from './helpers';
 import { EPSILON } from '../constants';
 import triggerEvent from '../utilities/triggerEvent';
 import { peerImport } from '../init';
+import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 const _map = Symbol.for('map');
 const EVENT_POSTRENDER = 'postrender';
 class WSIViewport extends Viewport {
@@ -186,7 +187,23 @@ class WSIViewport extends Viewport {
             return null;
         }
         const { spacing } = metadata;
-        return {
+        const imageData = {
+            getDirection: () => metadata.direction,
+            getDimensions: () => metadata.dimensions,
+            getRange: () => [0, 255],
+            getScalarData: () => this.getScalarData(),
+            getSpacing: () => metadata.spacing,
+            worldToIndex: (point) => {
+                const canvasPoint = this.worldToCanvas(point);
+                const pixelCoord = this.canvasToIndex(canvasPoint);
+                return [pixelCoord[0], pixelCoord[1], 0];
+            },
+            indexToWorld: (point) => {
+                const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                return this.canvasToWorld(canvasPoint);
+            },
+        };
+        const imageDataReturn = {
             dimensions: metadata.dimensions,
             spacing,
             numberOfComponents: 3,
@@ -196,29 +213,25 @@ class WSIViewport extends Viewport {
                 Modality: this.modality,
                 FrameOfReferenceUID: this.frameOfReferenceUID,
             },
-            imageData: {
-                getDirection: () => metadata.direction,
-                getDimensions: () => metadata.dimensions,
-                getRange: () => [0, 255],
-                getScalarData: () => this.getScalarData(),
-                getSpacing: () => metadata.spacing,
-                worldToIndex: (point) => {
-                    const canvasPoint = this.worldToCanvas(point);
-                    const pixelCoord = this.canvasToIndex(canvasPoint);
-                    return [pixelCoord[0], pixelCoord[1], 0];
-                },
-                indexToWorld: (point) => {
-                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
-                    return this.canvasToWorld(canvasPoint);
-                },
-            },
             hasPixelSpacing: this.hasPixelSpacing,
             calibration: this.calibration,
             preScale: {
                 scaled: false,
             },
             scalarData: this.getScalarData(),
+            imageData,
+            voxelManager: {
+                forEach: (callback, options) => {
+                    return pointInShapeCallback(options.imageData, {
+                        pointInShapeFn: options.isInObject ?? (() => true),
+                        callback: callback,
+                        boundsIJK: options.boundsIJK,
+                        returnPoints: options.returnPoints ?? false,
+                    });
+                },
+            },
         };
+        return imageDataReturn;
     }
     hasImageURI(imageURI) {
         return true;
@@ -404,7 +417,7 @@ class WSIViewport extends Viewport {
         transform.translate(-center[0], -center[1]);
         return transform;
     }
-    getReferenceId() {
+    getViewReferenceId() {
         return `imageId:${this.getCurrentImageId()}`;
     }
     getCurrentImageIdIndex() {
@@ -412,4 +425,3 @@ class WSIViewport extends Viewport {
     }
 }
 export default WSIViewport;
-//# sourceMappingURL=WSIViewport.js.map

package/dist/esm/RenderingEngine/getRenderingEngine.js

@@ -6,4 +6,3 @@ export function getRenderingEngines() {
     return renderingEngineCache.getAll();
 }
 export default getRenderingEngine;
-//# sourceMappingURL=getRenderingEngine.js.map

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

@@ -16,4 +16,3 @@ async function addImageSlicesToViewports(renderingEngine, stackInputs, viewportI
     await Promise.all(addStackPromises);
 }
 export default addImageSlicesToViewports;
-//# sourceMappingURL=addImageSlicesToViewports.js.map

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

@@ -18,4 +18,3 @@ async function addVolumesToViewports(renderingEngine, volumeInputs, viewportIds,
     return;
 }
 export default addVolumesToViewports;
-//# sourceMappingURL=addVolumesToViewports.js.map

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/colormap.js

@@ -192,4 +192,3 @@ export function getColormap(id, colormapData) {
     };
     return cpuFallbackColormap;
 }
-//# sourceMappingURL=colormap.js.map

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/index.js

@@ -1,4 +1,3 @@
 import { getColormap, getColormapsList } from './colormap';
 import LookupTable from './lookupTable';
 export { getColormap, getColormapsList, LookupTable };
-//# sourceMappingURL=index.js.map

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/lookupTable.js

@@ -254,4 +254,3 @@ class LookupTable {
     }
 }
 export default LookupTable;
-//# sourceMappingURL=lookupTable.js.map

package/dist/esm/RenderingEngine/helpers/cpuFallback/drawImageSync.js

@@ -35,4 +35,3 @@ export default function (enabledElement, invalidated) {
     enabledElement.invalid = false;
     enabledElement.needsRedraw = false;
 }
-//# sourceMappingURL=drawImageSync.js.map

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

@@ -71,4 +71,3 @@ export default function (enabledElement, scale) {
     transform.translate(-width / 2, -height / 2);
     return transform;
 }
-//# sourceMappingURL=calculateTransform.js.map

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

@@ -4,4 +4,3 @@ export default function (enabledElement, pt) {
     transform.invert();
     return transform.transformPoint(pt);
 }
-//# sourceMappingURL=canvasToPixel.js.map

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

@@ -23,4 +23,3 @@ function hasVoi(viewport) {
         (viewport.voi.windowWidth !== undefined &&
             viewport.voi.windowCenter !== undefined));
 }
-//# sourceMappingURL=computeAutoVoi.js.map

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

@@ -13,4 +13,3 @@ export default function (shift, viewportOrientation) {
     }
     return shift;
 }
-//# sourceMappingURL=correctShift.js.map

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

@@ -39,4 +39,3 @@ export default function createViewport() {
     };
     return Object.assign({}, initialDefaultViewport, state.viewport);
 }
-//# sourceMappingURL=createViewport.js.map

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

@@ -15,4 +15,3 @@ export default function doesImageNeedToBeRendered(enabledElement, image) {
         lastRenderedViewport.voiLUT !== enabledElement.viewport.voiLUT ||
         lastRenderedViewport.colormap !== enabledElement.viewport.colormap);
 }
-//# sourceMappingURL=doesImageNeedToBeRendered.js.map

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

@@ -5,4 +5,3 @@ export default function (enabledElement) {
     enabledElement.viewport.translation.x = 0;
     enabledElement.viewport.translation.y = 0;
 }
-//# sourceMappingURL=fitToWindow.js.map

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

@@ -22,4 +22,3 @@ export default function generateColorLUT(image, windowWidth, windowCenter, inver
     }
     return lut;
 }
-//# sourceMappingURL=generateColorLUT.js.map

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

@@ -38,4 +38,3 @@ export default function (image, windowWidth, windowCenter, invert, modalityLUT,
     }
     return lut;
 }
-//# sourceMappingURL=generateLut.js.map

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

@@ -57,4 +57,3 @@ export default function (canvas, image, modality, colormap) {
         },
     };
 }
-//# sourceMappingURL=getDefaultViewport.js.map

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

@@ -22,4 +22,3 @@ export default function (canvas, image, rotation = null) {
         scaleFactor: Math.min(horizontalScale, verticalScale),
     };
 }
-//# sourceMappingURL=getImageFitScale.js.map

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

@@ -20,4 +20,3 @@ export default function (image, rotation = null) {
         height: image.height,
     };
 }
-//# sourceMappingURL=getImageSize.js.map

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

@@ -20,4 +20,3 @@ export default function (image, viewport, invalidated) {
     image.cachedLut.modalityLUT = viewport.modalityLUT;
     return image.cachedLut.lutArray;
 }
-//# sourceMappingURL=getLut.js.map

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

@@ -21,4 +21,3 @@ export default function (slope, intercept, modalityLUT) {
     }
     return generateLinearModalityLUT(slope, intercept);
 }
-//# sourceMappingURL=getModalityLut.js.map

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

@@ -2,4 +2,3 @@ import calculateTransform from './calculateTransform';
 export default function (enabledElement) {
     return calculateTransform(enabledElement);
 }
-//# sourceMappingURL=getTransform.js.map

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

@@ -27,4 +27,3 @@ export default function (windowWidth, windowCenter, voiLUT) {
     }
     return generateLinearVOILUT(windowWidth, windowCenter);
 }
-//# sourceMappingURL=getVOILut.js.map

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

@@ -9,4 +9,3 @@ export default function (enabledElement, image) {
     enabledElement.renderingTools.renderCanvasContext = canvasContext;
     enabledElement.renderingTools.renderCanvasData = renderCanvasData;
 }
-//# sourceMappingURL=initializeRenderCanvas.js.map

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

@@ -7,4 +7,3 @@ export default function lutMatches(a, b) {
     }
     return a.id === b.id;
 }
-//# sourceMappingURL=lutMatches.js.map