@cornerstonejs/core 4.15.32 → 4.16.0

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

@@ -1,5 +1,6 @@
 import type { mat4 } from 'gl-matrix';
-import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
+import type { BlendModes, InterpolationType } from '../enums';
+import { OrientationAxis } from '../enums';
 import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, ICamera } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { PlaneRestriction, ViewportInput } from '../types/IViewport';

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -4,7 +4,7 @@ import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunc
 import { vec2, vec3 } from 'gl-matrix';
 import cache from '../cache/cache';
 import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS, VIEWPORT_PRESETS, } from '../constants';
-import { Events, MetadataModules, ViewportStatus, VOILUTFunctionType, } from '../enums';
+import { Events, MetadataModules, OrientationAxis, ViewportStatus, VOILUTFunctionType, } from '../enums';
 import ViewportType from '../enums/ViewportType';
 import eventTarget from '../eventTarget';
 import { getShouldUseCPURendering } from '../init';
@@ -1116,21 +1116,38 @@ class BaseVolumeViewport extends Viewport {
             }
         }
         else if (typeof orientation === 'string') {
-            if (orientation === 'acquisition') {
+            if (orientation === OrientationAxis.ACQUISITION) {
                 return this._getAcquisitionPlaneOrientation();
             }
-            else if (orientation === 'reformat' ||
-                orientation.includes('_reformat')) {
+            else if (orientation === OrientationAxis.REFORMAT) {
                 return getCameraVectors(this, {
                     useViewportNormal: true,
                 });
             }
+            else if (orientation === OrientationAxis.AXIAL_REFORMAT ||
+                orientation === OrientationAxis.SAGITTAL_REFORMAT ||
+                orientation === OrientationAxis.CORONAL_REFORMAT) {
+                let baseOrientation;
+                if (orientation === OrientationAxis.AXIAL_REFORMAT) {
+                    baseOrientation = OrientationAxis.AXIAL;
+                }
+                else if (orientation === OrientationAxis.SAGITTAL_REFORMAT) {
+                    baseOrientation = OrientationAxis.SAGITTAL;
+                }
+                else {
+                    baseOrientation = OrientationAxis.CORONAL;
+                }
+                return getCameraVectors(this, {
+                    useViewportNormal: true,
+                    orientation: baseOrientation,
+                });
+            }
             else if (MPR_CAMERA_VALUES[orientation]) {
                 this.viewportProperties.orientation = orientation;
                 return MPR_CAMERA_VALUES[orientation];
             }
         }
-        throw new Error(`Invalid orientation: ${orientation}. Valid orientations are: ${Object.keys(MPR_CAMERA_VALUES).join(', ')}`);
+        throw new Error(`Invalid orientation: ${orientation}. Valid orientations are: ${Object.keys(MPR_CAMERA_VALUES).join(', ')}, ${OrientationAxis.ACQUISITION}, ${OrientationAxis.REFORMAT}, ${OrientationAxis.AXIAL_REFORMAT}, ${OrientationAxis.SAGITTAL_REFORMAT}, ${OrientationAxis.CORONAL_REFORMAT}`);
     }
     _getAcquisitionPlaneOrientation() {
         const actorEntry = this.getDefaultActor();

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -161,12 +161,29 @@ class VolumeViewport extends BaseVolumeViewport {
             if (orientation === OrientationAxis.ACQUISITION) {
                 ({ viewPlaneNormal, viewUp } = super._getAcquisitionPlaneOrientation());
             }
-            else if (orientation === OrientationAxis.REFORMAT ||
-                orientation.includes('_reformat')) {
+            else if (orientation === OrientationAxis.REFORMAT) {
                 ({ viewPlaneNormal, viewUp } = getCameraVectors(this, {
                     useViewportNormal: true,
                 }));
             }
+            else if (orientation === OrientationAxis.AXIAL_REFORMAT ||
+                orientation === OrientationAxis.SAGITTAL_REFORMAT ||
+                orientation === OrientationAxis.CORONAL_REFORMAT) {
+                let baseOrientation;
+                if (orientation === OrientationAxis.AXIAL_REFORMAT) {
+                    baseOrientation = OrientationAxis.AXIAL;
+                }
+                else if (orientation === OrientationAxis.SAGITTAL_REFORMAT) {
+                    baseOrientation = OrientationAxis.SAGITTAL;
+                }
+                else {
+                    baseOrientation = OrientationAxis.CORONAL;
+                }
+                ({ viewPlaneNormal, viewUp } = getCameraVectors(this, {
+                    useViewportNormal: true,
+                    orientation: baseOrientation,
+                }));
+            }
             else if (MPR_CAMERA_VALUES[orientation]) {
                 ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
             }
@@ -178,7 +195,7 @@ class VolumeViewport extends BaseVolumeViewport {
                 viewUp,
             });
             this.viewportProperties.orientation = orientation;
-            this.resetCamera();
+            this.resetCamera({ suppressEvents: true });
         }
         else {
             ({ viewPlaneNormal, viewUp } = orientation);

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

@@ -1,5 +1,6 @@
 import * as Enums from '../../enums';
 import type * as Types from '../../types';
+import type OrientationVectors from '../../types/OrientationVectors';
 import { vec3 } from 'gl-matrix';
 export interface CameraPositionConfig {
     orientation?: Enums.OrientationAxis;
@@ -16,3 +17,4 @@ export declare function getCameraVectors(viewport: Types.IBaseVolumeViewport, co
     viewRight: [number, number, number];
 };
 export declare function getOrientationFromScanAxisNormal(scanAxisNormal: vec3): Enums.OrientationAxis;
+export declare function getAcquisitionPlaneReformatOrientation(imageOrientationPatient: number[]): OrientationVectors | null;

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

@@ -19,6 +19,22 @@ export function calculateCameraPosition(rowCosineVec, colCosineVec, scanAxisNorm
         case OrientationAxis.CORONAL_REFORMAT:
             referenceCameraValues = MPR_CAMERA_VALUES.coronal;
             break;
+        case OrientationAxis.REFORMAT:
+            const autoDetected = getOrientationFromScanAxisNormal(scanAxisNormal);
+            switch (autoDetected) {
+                case OrientationAxis.AXIAL:
+                    referenceCameraValues = MPR_CAMERA_VALUES.axial;
+                    break;
+                case OrientationAxis.SAGITTAL:
+                    referenceCameraValues = MPR_CAMERA_VALUES.sagittal;
+                    break;
+                case OrientationAxis.CORONAL:
+                    referenceCameraValues = MPR_CAMERA_VALUES.coronal;
+                    break;
+                default:
+                    referenceCameraValues = MPR_CAMERA_VALUES.axial;
+            }
+            break;
         default:
             referenceCameraValues = MPR_CAMERA_VALUES.axial;
             break;
@@ -97,7 +113,7 @@ export function getCameraVectors(viewport, config) {
     if (useViewportNormal) {
         normalPlaneForOrientation = viewport.getCamera().viewPlaneNormal;
     }
-    if (!orientation) {
+    if (!orientation || orientation === OrientationAxis.REFORMAT) {
         orientation = getOrientationFromScanAxisNormal(normalPlaneForOrientation);
     }
     return calculateCameraPosition(rowCosineVec, colCosineVec, scanAxisNormal, orientation);
@@ -120,3 +136,100 @@ export function getOrientationFromScanAxisNormal(scanAxisNormal) {
         return OrientationAxis.CORONAL;
     }
 }
+export function getAcquisitionPlaneReformatOrientation(imageOrientationPatient) {
+    if (!imageOrientationPatient || imageOrientationPatient.length !== 6) {
+        return null;
+    }
+    const rowVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+    const colVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowVec, colVec);
+    vec3.normalize(rowVec, rowVec);
+    vec3.normalize(colVec, colVec);
+    vec3.normalize(scanAxisNormal, scanAxisNormal);
+    const negRowVec = vec3.create();
+    vec3.negate(negRowVec, rowVec);
+    const negColVec = vec3.create();
+    vec3.negate(negColVec, colVec);
+    const negScanAxisNormal = vec3.create();
+    vec3.negate(negScanAxisNormal, scanAxisNormal);
+    const acquisitionVectors = [
+        { vec: rowVec, name: 'row' },
+        { vec: colVec, name: 'col' },
+        { vec: scanAxisNormal, name: 'scanAxis' },
+        { vec: negRowVec, name: '-row' },
+        { vec: negColVec, name: '-col' },
+        { vec: negScanAxisNormal, name: '-scanAxis' },
+    ];
+    const standardViews = [
+        {
+            name: 'axial',
+            viewPlaneNormal: vec3.fromValues(MPR_CAMERA_VALUES.axial.viewPlaneNormal[0], MPR_CAMERA_VALUES.axial.viewPlaneNormal[1], MPR_CAMERA_VALUES.axial.viewPlaneNormal[2]),
+            viewUp: vec3.fromValues(MPR_CAMERA_VALUES.axial.viewUp[0], MPR_CAMERA_VALUES.axial.viewUp[1], MPR_CAMERA_VALUES.axial.viewUp[2]),
+        },
+        {
+            name: 'sagittal',
+            viewPlaneNormal: vec3.fromValues(MPR_CAMERA_VALUES.sagittal.viewPlaneNormal[0], MPR_CAMERA_VALUES.sagittal.viewPlaneNormal[1], MPR_CAMERA_VALUES.sagittal.viewPlaneNormal[2]),
+            viewUp: vec3.fromValues(MPR_CAMERA_VALUES.sagittal.viewUp[0], MPR_CAMERA_VALUES.sagittal.viewUp[1], MPR_CAMERA_VALUES.sagittal.viewUp[2]),
+        },
+        {
+            name: 'coronal',
+            viewPlaneNormal: vec3.fromValues(MPR_CAMERA_VALUES.coronal.viewPlaneNormal[0], MPR_CAMERA_VALUES.coronal.viewPlaneNormal[1], MPR_CAMERA_VALUES.coronal.viewPlaneNormal[2]),
+            viewUp: vec3.fromValues(MPR_CAMERA_VALUES.coronal.viewUp[0], MPR_CAMERA_VALUES.coronal.viewUp[1], MPR_CAMERA_VALUES.coronal.viewUp[2]),
+        },
+    ];
+    let bestAlignment = -Infinity;
+    let bestViewPlaneNormal = null;
+    let bestViewUp = null;
+    for (const standardView of standardViews) {
+        let bestPairScore = -Infinity;
+        let bestPairViewPlaneNormal = null;
+        let bestPairViewUp = null;
+        for (let i = 0; i < acquisitionVectors.length; i++) {
+            for (let j = 0; j < acquisitionVectors.length; j++) {
+                if (i === j)
+                    continue;
+                const v1 = acquisitionVectors[i].vec;
+                const v2 = acquisitionVectors[j].vec;
+                const dotProduct = Math.abs(vec3.dot(v1, v2));
+                if (dotProduct > 0.1)
+                    continue;
+                const score1 = Math.abs(vec3.dot(v1, standardView.viewPlaneNormal));
+                const score2 = Math.abs(vec3.dot(v2, standardView.viewUp));
+                const totalScore = score1 + score2;
+                const score1Swapped = Math.abs(vec3.dot(v2, standardView.viewPlaneNormal));
+                const score2Swapped = Math.abs(vec3.dot(v1, standardView.viewUp));
+                const totalScoreSwapped = score1Swapped + score2Swapped;
+                if (totalScoreSwapped > totalScore &&
+                    totalScoreSwapped > bestPairScore) {
+                    bestPairScore = totalScoreSwapped;
+                    bestPairViewPlaneNormal = v2;
+                    bestPairViewUp = v1;
+                }
+                else if (totalScore > bestPairScore) {
+                    bestPairScore = totalScore;
+                    bestPairViewPlaneNormal = v1;
+                    bestPairViewUp = v2;
+                }
+            }
+        }
+        if (bestPairScore > bestAlignment &&
+            bestPairViewPlaneNormal &&
+            bestPairViewUp) {
+            bestAlignment = bestPairScore;
+            bestViewPlaneNormal = bestPairViewPlaneNormal;
+            bestViewUp = bestPairViewUp;
+        }
+    }
+    if (!bestViewPlaneNormal || !bestViewUp) {
+        return null;
+    }
+    return {
+        viewPlaneNormal: [
+            bestViewPlaneNormal[0],
+            bestViewPlaneNormal[1],
+            bestViewPlaneNormal[2],
+        ],
+        viewUp: [bestViewUp[0], bestViewUp[1], bestViewUp[2]],
+    };
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.15.32";
+export declare const version = "4.16.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.15.32';
+export const version = '4.16.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.15.32",
+  "version": "4.16.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "05646c9490e54ad3841b1d6891d8cbdf73a2fd19"
+  "gitHead": "894fe3bebbbaae27c5aa58b758616988ba173ee3"
 }