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

package/dist/esm/utilities/cacheUtils.js

@@ -21,41 +21,41 @@ export function performCacheOptimizationForVolume(volume) {
     if (!(volume instanceof ImageVolume)) {
         return;
     }
+    if (!volume.imageIds?.length) {
+        console.warn(`Volume with ID ${volume.volumeId} does not have any images to optimize.`);
+        return;
+    }
     const scalarData = volume.getScalarData();
-    volume.imageCacheOffsetMap.size > 0
-        ? _processImageCacheOffsetMap(volume, scalarData)
-        : _processVolumeImages(volume, scalarData);
-}
-function _processImageCacheOffsetMap(volume, scalarData) {
-    volume.imageCacheOffsetMap.forEach(({ offset }, imageId) => {
-        const image = cache.getImage(imageId);
-        if (!image) {
+    volume.imageIds.forEach((imageId, imageIdIndex) => {
+        let image = cache.getImage(imageId);
+        if (image) {
+            if (image.bufferView) {
+                return;
+            }
+            const offset = _calculateOffset(volume, imageId, imageIdIndex);
+            _updateImageWithScalarDataView(image, scalarData, offset);
+            cache.decrementImageCacheSize(image.sizeInBytes);
             return;
         }
-        _updateImageWithScalarDataView(image, scalarData, offset);
-        cache.decrementImageCacheSize(image.sizeInBytes);
-    });
-}
-function _processVolumeImages(volume, scalarData) {
-    let compatibleScalarData = scalarData;
-    const sampleImageIdWithImage = volume.imageIds.find((imageId) => {
-        const image = cache.getImage(imageId);
-        return image;
-    });
-    if (!sampleImageIdWithImage) {
-        return;
-    }
-    const sampleImage = cache.getImage(sampleImageIdWithImage);
-    const samplePixelData = sampleImage.imageFrame?.pixelData || sampleImage.getPixelData();
-    if (scalarData.constructor !== samplePixelData.constructor) {
-        compatibleScalarData = new samplePixelData.constructor(scalarData.length);
-        compatibleScalarData.set(scalarData);
-    }
-    volume.imageIds.forEach((imageId) => {
-        const image = cache.getImage(imageId);
-        if (!image) {
+        const inOffSetMap = volume.imageCacheOffsetMap.has(imageId) &&
+            volume.imageCacheOffsetMap.get(imageId).offset;
+        if (inOffSetMap) {
+            const image = cache.getImage(imageId);
+            const offset = volume.imageCacheOffsetMap.get(imageId).offset;
+            _updateImageWithScalarDataView(image, scalarData, offset);
+            cache.decrementImageCacheSize(image.sizeInBytes);
             return;
         }
+        image = volume.getCornerstoneImage(imageId, imageIdIndex);
+        if (!cache.getImageLoadObject(imageId)) {
+            cache.putImageSync(imageId, image);
+        }
+        let compatibleScalarData = scalarData;
+        const samplePixelData = image.imageFrame?.pixelData || image.getPixelData();
+        if (scalarData.constructor !== samplePixelData.constructor) {
+            compatibleScalarData = new samplePixelData.constructor(scalarData.length);
+            compatibleScalarData.set(scalarData);
+        }
         const index = volume.getImageIdIndex(imageId);
         const offset = index * image.getPixelData().byteLength;
         _updateImageWithScalarDataView(image, compatibleScalarData, offset);
@@ -76,3 +76,11 @@ function _updateImageWithScalarDataView(image, scalarData, offset) {
         offset,
     };
 }
+function _calculateOffset(volume, imageId, imageIdIndex) {
+    if (volume.imageCacheOffsetMap.has(imageId)) {
+        return volume.imageCacheOffsetMap.get(imageId).offset;
+    }
+    const image = volume.getCornerstoneImage(imageId, imageIdIndex);
+    const index = volume.getImageIdIndex(imageId);
+    return index * image.getPixelData().byteLength;
+}

package/dist/esm/utilities/convertStackToVolumeViewport.js

@@ -11,7 +11,7 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
     const { id, element } = viewport;
     const viewportId = options.viewportId || id;
     const imageIds = viewport.getImageIds();
-    const prevCamera = viewport.getCamera();
+    const prevView = viewport.getViewReference();
     renderingEngine.enableElement({
         viewportId,
         type: ViewportType.ORTHOGRAPHIC,
@@ -32,11 +32,7 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
         },
     ], [viewportId]);
     const volumeViewportNewVolumeHandler = () => {
-        if (!options.orientation) {
-            volumeViewport.setCamera({
-                ...prevCamera,
-            });
-        }
+        volumeViewport.setViewReference(prevView);
         volumeViewport.render();
         element.removeEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
     };

package/dist/esm/utilities/convertVolumeToStackViewport.js

@@ -4,7 +4,6 @@ async function convertVolumeToStackViewport({ viewport, options, }) {
     const volumeViewport = viewport;
     const { id, element } = volumeViewport;
     const renderingEngine = viewport.getRenderingEngine();
-    const imageIdIndex = viewport.getCurrentImageIdIndex();
     const { background } = options;
     const viewportId = options.viewportId || id;
     const actorEntry = volumeViewport.getDefaultActor();
@@ -21,36 +20,11 @@ async function convertVolumeToStackViewport({ viewport, options, }) {
             background,
         },
     };
+    const prevView = volumeViewport.getViewReference();
     renderingEngine.enableElement(viewportInput);
     const stackViewport = (renderingEngine.getViewport(viewportId));
-    const hasCachedImages = volume.imageCacheOffsetMap.size > 0;
-    let isAllImagesCached = false;
-    if (hasCachedImages) {
-        isAllImagesCached = volume.imageIds.every((imageId) => cache.getImage(imageId));
-    }
-    const volumeUsedInOtherViewports = renderingEngine
-        .getVolumeViewports()
-        .find((vp) => vp.hasVolumeId(volumeId));
-    volume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
-    const stack = [...volume.imageIds].reverse();
-    let imageIdIndexToJump = Math.max(volume.imageIds.length - imageIdIndex - 1, 0);
-    const imageToJump = cache.getImage(stack[imageIdIndexToJump]);
-    if (!imageToJump) {
-        let minDistance = Infinity;
-        let minDistanceIndex = null;
-        stack.forEach((imageId, index) => {
-            const image = cache.getImage(imageId);
-            if (image) {
-                const distance = Math.abs(imageIdIndexToJump - index);
-                if (distance < minDistance) {
-                    minDistance = distance;
-                    minDistanceIndex = index;
-                }
-            }
-        });
-        imageIdIndexToJump = minDistanceIndex;
-    }
-    await stackViewport.setStack(stack, imageIdIndexToJump ?? 0);
+    await stackViewport.setStack(volume.imageIds);
+    stackViewport.setViewReference(prevView);
     stackViewport.render();
     return stackViewport;
 }