@cornerstonejs/core 5.4.15 → 5.4.16

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewReferenceController.d.ts

@@ -62,7 +62,8 @@ declare class PlanarViewReferenceController {
     private normalizeVolumeViewReference;
     private deriveOrientationFromPlaneRestriction;
     private isPlaneRestrictionCompatibleWithNormal;
-    private resolveVolumeReferenceImageIdIndex;
+    private resolveVolumeReferenceSliceTarget;
+    private toVolumeSliceTarget;
     private getImageIdsForReferenceContext;
     private findImageIdIndexByReference;
     private getCurrentPlanarRendering;

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewReferenceController.js

@@ -4,6 +4,7 @@ import getClosestImageId from '../../../utilities/getClosestImageId.js';
 import imageIdToURI from '../../../utilities/imageIdToURI.js';
 import isEqual from '../../../utilities/isEqual.js';
 import { getDimensionGroupReferenceContext, } from '../genericViewportReferenceCompatibility.js';
+import { getVolumeImageIdIndexWorldPoint } from './planarSliceBasis.js';
 import { getPlanarReferencedImageId, getPlanarViewReference, getPlanarViewReferenceId, isPlanarPlaneViewable, } from './planarViewReference.js';
 import { resolvePlanarViewportView } from './PlanarResolvedView.js';
 class PlanarViewReferenceController {
@@ -254,7 +255,7 @@ class PlanarViewReferenceController {
         const effectiveViewPlaneNormal = refViewPlaneNormal ?? currentViewPlaneNormal;
         const isOppositeNormal = !shouldReorient &&
             this.areNormalsOpposite(currentViewPlaneNormal, effectiveViewPlaneNormal);
-        const nextImageIdIndex = this.resolveVolumeReferenceImageIdIndex(referenceContext, normalizedViewRef, effectiveViewPlaneNormal, isOppositeNormal);
+        const sliceTarget = this.resolveVolumeReferenceSliceTarget(referenceContext, normalizedViewRef, effectiveViewPlaneNormal, isOppositeNormal);
         const viewStatePatch = {};
         if (shouldReorient && refViewPlaneNormal) {
             viewStatePatch.orientation = {
@@ -267,8 +268,9 @@ class PlanarViewReferenceController {
             };
         }
         const sliceWorldPoint = normalizedViewRef.cameraFocalPoint ??
-            (typeof nextImageIdIndex === 'number'
-                ? this.host.getVolumeSliceWorldPointForImageIdIndex(nextImageIdIndex)
+            sliceTarget?.sliceWorldPoint ??
+            (typeof sliceTarget?.imageIdIndex === 'number'
+                ? this.host.getVolumeSliceWorldPointForImageIdIndex(sliceTarget.imageIdIndex)
                 : undefined);
         if (sliceWorldPoint) {
             viewStatePatch.slice = {
@@ -346,7 +348,7 @@ class PlanarViewReferenceController {
             (!planeRestriction.inPlaneVector2 ||
                 isEqual(0, vec3.dot(viewPlaneNormal, planeRestriction.inPlaneVector2))));
     }
-    resolveVolumeReferenceImageIdIndex(referenceContext, viewRef, effectiveViewPlaneNormal, isOppositeNormal) {
+    resolveVolumeReferenceSliceTarget(referenceContext, viewRef, effectiveViewPlaneNormal, isOppositeNormal) {
         const { rendering } = referenceContext;
         if (rendering.renderMode !== ActorRenderMode.CPU_VOLUME &&
             rendering.renderMode !== ActorRenderMode.VTK_VOLUME_SLICE) {
@@ -360,21 +362,35 @@ class PlanarViewReferenceController {
             const targetSliceIndex = isOppositeNormal
                 ? maxImageIdIndex - viewRef.sliceIndex
                 : viewRef.sliceIndex;
-            return Math.min(Math.max(0, targetSliceIndex), maxImageIdIndex);
+            return {
+                imageIdIndex: Math.min(Math.max(0, targetSliceIndex), maxImageIdIndex),
+            };
         }
         const referencedImageIndex = this.findImageIdIndexByReference(imageIds, viewRef.referencedImageId, viewRef.referencedImageURI);
         if (typeof referencedImageIndex === 'number') {
-            return referencedImageIndex;
+            return this.toVolumeSliceTarget(rendering.imageVolume, referencedImageIndex);
         }
         const targetPoint = viewRef.cameraFocalPoint ?? viewRef.planeRestriction?.point;
         if (targetPoint) {
             const referencedImageId = getClosestImageId(rendering.imageVolume, targetPoint, effectiveViewPlaneNormal);
-            return this.findImageIdIndexByReference(imageIds, referencedImageId);
+            const closestImageIndex = this.findImageIdIndexByReference(imageIds, referencedImageId);
+            if (typeof closestImageIndex === 'number') {
+                return this.toVolumeSliceTarget(rendering.imageVolume, closestImageIndex);
+            }
+            return;
         }
         if (typeof viewRef.sliceIndex === 'number') {
-            return Math.min(Math.max(0, viewRef.sliceIndex), maxImageIdIndex);
+            return {
+                imageIdIndex: Math.min(Math.max(0, viewRef.sliceIndex), maxImageIdIndex),
+            };
         }
     }
+    toVolumeSliceTarget(imageVolume, imageIdListIndex) {
+        const sliceWorldPoint = getVolumeImageIdIndexWorldPoint(imageVolume, imageIdListIndex);
+        return sliceWorldPoint
+            ? { sliceWorldPoint }
+            : { imageIdIndex: imageIdListIndex };
+    }
     getImageIdsForReferenceContext(referenceContext) {
         return (referenceContext.data.imageVolume?.imageIds ||
             referenceContext.data.imageIds);

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewport.js

@@ -24,7 +24,7 @@ import { cloneDisplayArea, createDefaultPlanarViewState, normalizePlanarViewStat
 import { normalizePlanarScale, } from './planarCameraScale.js';
 import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, } from './planarProjectionAdapter.js';
 import { getPlanarViewStateCanvasDimensions, resolvePlanarViewportView, } from './PlanarResolvedView.js';
-import { createPlanarCpuVolumeSliceBasis, createPlanarVolumeSliceBasis, } from './planarSliceBasis.js';
+import { createPlanarCpuVolumeSliceBasis, createPlanarVolumeSliceBasis, getVolumeImageIdIndexWorldPoint, } from './planarSliceBasis.js';
 import PlanarMountedData from './PlanarMountedData.js';
 import PlanarViewReferenceController from './PlanarViewReferenceController.js';
 class PlanarViewport extends GenericViewport {
@@ -1069,6 +1069,15 @@ class PlanarViewport extends GenericViewport {
         const initialImageIdIndex = orientation === OrientationAxis.ACQUISITION
             ? planarData.initialImageIdIndex
             : undefined;
+        if (typeof initialImageIdIndex === 'number') {
+            const sliceWorldPoint = getVolumeImageIdIndexWorldPoint(planarData.imageVolume, initialImageIdIndex);
+            if (sliceWorldPoint) {
+                return {
+                    kind: 'volumePoint',
+                    sliceWorldPoint,
+                };
+            }
+        }
         const { sliceBasis } = createSliceBasis({
             canvasHeight: height,
             canvasWidth: width,

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarSliceBasis.d.ts

@@ -20,6 +20,7 @@ export declare function createPlanarCpuImageSliceBasis(args: {
     canvasWidth: number;
     canvasHeight: number;
 }): PlanarSliceBasis;
+export declare function getVolumeImageIdIndexWorldPoint(imageVolume: IImageVolume | undefined, imageIdIndex: number): Point3 | undefined;
 export declare function resolvePlanarVolumeImageIdIndex(args: {
     viewState?: PlanarViewState;
     fallbackImageIdIndex?: number;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarSliceBasis.js

@@ -139,6 +139,19 @@ function getGeometricImageVolumeCenter(imageVolume, viewPlaneNormal) {
     }
     return vec3.scale(center, center, 1 / corners.length);
 }
+export function getVolumeImageIdIndexWorldPoint(imageVolume, imageIdIndex) {
+    const imageData = imageVolume?.imageData;
+    if (!imageData) {
+        return;
+    }
+    const dimensions = imageData.getDimensions();
+    const k = Math.min(Math.max(0, imageIdIndex), dimensions[2] - 1);
+    return imageData.indexToWorld([
+        (dimensions[0] - 1) / 2,
+        (dimensions[1] - 1) / 2,
+        k,
+    ]);
+}
 function getSliceMetrics(args) {
     const { imageVolume, viewPlaneNormal } = args;
     const corners = buildImageVolumeCorners(imageVolume);

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.4.15";
+export declare const version = "5.4.16";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.4.15';
+export const version = '5.4.16';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "5.4.15",
+  "version": "5.4.16",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -85,18 +85,18 @@
     "prepublishOnly": "pnpm run build"
   },
   "dependencies": {
-    "@cornerstonejs/utils": "5.4.15",
+    "@cornerstonejs/utils": "5.4.16",
     "@kitware/vtk.js": "35.5.3",
     "comlink": "4.4.2",
     "gl-matrix": "3.4.3",
     "loglevel": "1.9.2"
   },
   "devDependencies": {
-    "@cornerstonejs/metadata": "5.4.15"
+    "@cornerstonejs/metadata": "5.4.16"
   },
   "peerDependencies": {
-    "@cornerstonejs/metadata": "5.4.15",
-    "@cornerstonejs/utils": "5.4.15"
+    "@cornerstonejs/metadata": "5.4.16",
+    "@cornerstonejs/utils": "5.4.16"
   },
   "contributors": [
     {
@@ -109,5 +109,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "642314b8d345265edfff3fb7c18c2d2b8b53f88a"
+  "gitHead": "6d2d80bfa445c91deafe0d7e4a02b8de1a4a4da8"
 }