@cornerstonejs/core 3.22.4 → 3.23.0

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -28,6 +28,7 @@ import applyPreset from '../utilities/applyPreset';
 import imageIdToURI from '../utilities/imageIdToURI';
 import uuidv4 from '../utilities/uuidv4';
 import * as metaData from '../metaData';
+import { getCameraVectors } from './helpers/getCameraVectors';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);
@@ -252,7 +253,10 @@ class BaseVolumeViewport extends Viewport {
         throw new Error('Method not implemented.');
     }
     applyViewOrientation(orientation, resetCamera = true) {
-        const { viewPlaneNormal, viewUp } = this._getOrientationVectors(orientation);
+        const { viewPlaneNormal, viewUp } = this._getOrientationVectors(orientation) || {};
+        if (!viewPlaneNormal || !viewUp) {
+            return;
+        }
         const camera = this.getVtkActiveCamera();
         camera.setDirectionOfProjection(-viewPlaneNormal[0], -viewPlaneNormal[1], -viewPlaneNormal[2]);
         camera.setViewUpFrom(viewUp);
@@ -895,6 +899,12 @@ class BaseVolumeViewport extends Viewport {
             if (orientation === 'acquisition') {
                 return this._getAcquisitionPlaneOrientation();
             }
+            else if (orientation === 'reformat' ||
+                orientation.includes('_reformat')) {
+                return getCameraVectors(this, {
+                    useViewportNormal: true,
+                });
+            }
             else if (MPR_CAMERA_VALUES[orientation]) {
                 this.viewportProperties.orientation = orientation;
                 return MPR_CAMERA_VALUES[orientation];

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

@@ -13,6 +13,7 @@ declare class VolumeViewport extends BaseVolumeViewport {
     jumpToWorld(worldPos: Point3): boolean;
     setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
     protected setCameraClippingRange(): void;
+    private _setViewPlaneToReformatOrientation;
     private _setViewPlaneToAcquisitionPlane;
     getBlendMode(filterActorUIDs?: string[]): BlendModes;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -16,6 +16,7 @@ import getImageSliceDataForVolumeViewport from '../utilities/getImageSliceDataFo
 import { transformCanvasToIJK } from '../utilities/transformCanvasToIJK';
 import { transformIJKToCanvas } from '../utilities/transformIJKToCanvas';
 import getVolumeViewportScrollInfo from '../utilities/getVolumeViewportScrollInfo';
+import { calculateCameraPosition, getCameraVectors, } from './helpers/getCameraVectors';
 class VolumeViewport extends BaseVolumeViewport {
     constructor(props) {
         super(props);
@@ -87,7 +88,13 @@ class VolumeViewport extends BaseVolumeViewport {
         if (!firstImageVolume) {
             throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
         }
-        if (this._useAcquisitionPlaneForViewPlane) {
+        if (this.options.orientation &&
+            typeof this.options.orientation === 'string') {
+            if (this.options.orientation.includes('_reformat')) {
+                this._setViewPlaneToReformatOrientation(this.options.orientation, firstImageVolume);
+            }
+        }
+        else if (this._useAcquisitionPlaneForViewPlane) {
             this._setViewPlaneToAcquisitionPlane(firstImageVolume);
             this._useAcquisitionPlaneForViewPlane = false;
         }
@@ -98,7 +105,13 @@ class VolumeViewport extends BaseVolumeViewport {
         if (!firstImageVolume) {
             throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
         }
-        if (this._useAcquisitionPlaneForViewPlane) {
+        if (this.options.orientation &&
+            typeof this.options.orientation === 'string') {
+            if (this.options.orientation.includes('_reformat')) {
+                this._setViewPlaneToReformatOrientation(this.options.orientation, firstImageVolume);
+            }
+        }
+        else if (this._useAcquisitionPlaneForViewPlane) {
             this._setViewPlaneToAcquisitionPlane(firstImageVolume);
             this._useAcquisitionPlaneForViewPlane = false;
         }
@@ -134,6 +147,12 @@ class VolumeViewport extends BaseVolumeViewport {
             if (orientation === OrientationAxis.ACQUISITION) {
                 ({ viewPlaneNormal, viewUp } = super._getAcquisitionPlaneOrientation());
             }
+            else if (orientation === OrientationAxis.REFORMAT ||
+                orientation.includes('_reformat')) {
+                ({ viewPlaneNormal, viewUp } = getCameraVectors(this, {
+                    useViewportNormal: true,
+                }));
+            }
             else if (MPR_CAMERA_VALUES[orientation]) {
                 ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
             }
@@ -168,6 +187,22 @@ class VolumeViewport extends BaseVolumeViewport {
             activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
         }
     }
+    _setViewPlaneToReformatOrientation(orientation, imageVolume) {
+        let viewPlaneNormal, viewUp;
+        if (imageVolume) {
+            const { direction } = imageVolume;
+            ({ viewPlaneNormal, viewUp } = calculateCameraPosition(direction.slice(0, 3), direction.slice(3, 6), direction.slice(6, 9), orientation));
+        }
+        else {
+            ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+        }
+        this.setCamera({
+            viewPlaneNormal,
+            viewUp,
+        });
+        this.initialViewUp = viewUp;
+        this.resetCamera();
+    }
     _setViewPlaneToAcquisitionPlane(imageVolume) {
         let viewPlaneNormal, viewUp;
         if (imageVolume) {

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

@@ -0,0 +1,18 @@
+import * as Enums from '../../enums';
+import type * as Types from '../../types';
+import { vec3 } from 'gl-matrix';
+export interface CameraPositionConfig {
+    orientation?: Enums.OrientationAxis;
+    useViewportNormal?: boolean;
+}
+export declare function calculateCameraPosition(rowCosineVec: vec3, colCosineVec: vec3, scanAxisNormal: vec3, orientation: Enums.OrientationAxis): {
+    viewPlaneNormal: [number, number, number];
+    viewUp: [number, number, number];
+    viewRight: [number, number, number];
+};
+export declare function getCameraVectors(viewport: Types.IBaseVolumeViewport, config?: CameraPositionConfig): {
+    viewPlaneNormal: [number, number, number];
+    viewUp: [number, number, number];
+    viewRight: [number, number, number];
+};
+export declare function getOrientationFromScanAxisNormal(scanAxisNormal: vec3): Enums.OrientationAxis;

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

@@ -0,0 +1,122 @@
+import * as metaData from '../../metaData';
+import * as CONSTANTS from '../../constants';
+import * as Enums from '../../enums';
+import { vec3 } from 'gl-matrix';
+const { MPR_CAMERA_VALUES } = CONSTANTS;
+const { OrientationAxis } = Enums;
+export function calculateCameraPosition(rowCosineVec, colCosineVec, scanAxisNormal, orientation) {
+    let referenceCameraValues;
+    switch (orientation) {
+        case OrientationAxis.AXIAL:
+        case OrientationAxis.AXIAL_REFORMAT:
+            referenceCameraValues = MPR_CAMERA_VALUES.axial;
+            break;
+        case OrientationAxis.SAGITTAL:
+        case OrientationAxis.SAGITTAL_REFORMAT:
+            referenceCameraValues = MPR_CAMERA_VALUES.sagittal;
+            break;
+        case OrientationAxis.CORONAL:
+        case OrientationAxis.CORONAL_REFORMAT:
+            referenceCameraValues = MPR_CAMERA_VALUES.coronal;
+            break;
+        default:
+            referenceCameraValues = MPR_CAMERA_VALUES.axial;
+            break;
+    }
+    const normalizedRowCosine = vec3.normalize(vec3.create(), rowCosineVec);
+    const normalizedColCosine = vec3.normalize(vec3.create(), colCosineVec);
+    const normalizedScanAxis = vec3.normalize(vec3.create(), scanAxisNormal);
+    const inputVectors = [
+        normalizedRowCosine,
+        normalizedColCosine,
+        normalizedScanAxis,
+    ];
+    const referenceVectors = [
+        vec3.fromValues(referenceCameraValues.viewRight[0], referenceCameraValues.viewRight[1], referenceCameraValues.viewRight[2]),
+        vec3.fromValues(referenceCameraValues.viewUp[0], referenceCameraValues.viewUp[1], referenceCameraValues.viewUp[2]),
+        vec3.fromValues(referenceCameraValues.viewPlaneNormal[0], referenceCameraValues.viewPlaneNormal[1], referenceCameraValues.viewPlaneNormal[2]),
+    ];
+    const usedInputIndices = new Set();
+    const findBestMatch = (refVector) => {
+        let bestMatch = 0;
+        let bestDot = -2;
+        let shouldInvert = false;
+        inputVectors.forEach((inputVec, index) => {
+            if (usedInputIndices.has(index)) {
+                return;
+            }
+            const dot = vec3.dot(refVector, inputVec);
+            const absDot = Math.abs(dot);
+            if (absDot > bestDot) {
+                bestDot = absDot;
+                bestMatch = index;
+                shouldInvert = dot < 0;
+            }
+        });
+        usedInputIndices.add(bestMatch);
+        const matchedVector = vec3.clone(inputVectors[bestMatch]);
+        if (shouldInvert) {
+            vec3.negate(matchedVector, matchedVector);
+        }
+        return matchedVector;
+    };
+    const viewRight = findBestMatch(referenceVectors[0]);
+    const viewUp = findBestMatch(referenceVectors[1]);
+    const viewPlaneNormal = findBestMatch(referenceVectors[2]);
+    return {
+        viewPlaneNormal: [
+            viewPlaneNormal[0],
+            viewPlaneNormal[1],
+            viewPlaneNormal[2],
+        ],
+        viewUp: [viewUp[0], viewUp[1], viewUp[2]],
+        viewRight: [viewRight[0], viewRight[1], viewRight[2]],
+    };
+}
+export function getCameraVectors(viewport, config) {
+    if (!viewport.getActors()?.length) {
+        return;
+    }
+    if (viewport.type !== Enums.ViewportType.ORTHOGRAPHIC) {
+        console.warn('Viewport should be a volume viewport');
+    }
+    let imageId = viewport.getCurrentImageId();
+    if (!imageId) {
+        imageId = viewport.getImageIds()?.[0];
+    }
+    if (!imageId) {
+        return;
+    }
+    const { imageOrientationPatient } = metaData.get('imagePlaneModule', imageId);
+    const rowCosineVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+    const colCosineVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+    const scanAxisNormal = vec3.cross(vec3.create(), rowCosineVec, colCosineVec);
+    let { orientation } = config || {};
+    const { useViewportNormal } = config || {};
+    let normalPlaneForOrientation = scanAxisNormal;
+    if (useViewportNormal) {
+        normalPlaneForOrientation = viewport.getCamera().viewPlaneNormal;
+    }
+    if (!orientation) {
+        orientation = getOrientationFromScanAxisNormal(normalPlaneForOrientation);
+    }
+    return calculateCameraPosition(rowCosineVec, colCosineVec, scanAxisNormal, orientation);
+}
+export function getOrientationFromScanAxisNormal(scanAxisNormal) {
+    const normalizedScanAxis = vec3.normalize(vec3.create(), scanAxisNormal);
+    const axialNormal = vec3.fromValues(MPR_CAMERA_VALUES.axial.viewPlaneNormal[0], MPR_CAMERA_VALUES.axial.viewPlaneNormal[1], MPR_CAMERA_VALUES.axial.viewPlaneNormal[2]);
+    const sagittalNormal = vec3.fromValues(MPR_CAMERA_VALUES.sagittal.viewPlaneNormal[0], MPR_CAMERA_VALUES.sagittal.viewPlaneNormal[1], MPR_CAMERA_VALUES.sagittal.viewPlaneNormal[2]);
+    const coronalNormal = vec3.fromValues(MPR_CAMERA_VALUES.coronal.viewPlaneNormal[0], MPR_CAMERA_VALUES.coronal.viewPlaneNormal[1], MPR_CAMERA_VALUES.coronal.viewPlaneNormal[2]);
+    const axialDot = Math.abs(vec3.dot(normalizedScanAxis, axialNormal));
+    const sagittalDot = Math.abs(vec3.dot(normalizedScanAxis, sagittalNormal));
+    const coronalDot = Math.abs(vec3.dot(normalizedScanAxis, coronalNormal));
+    if (axialDot >= sagittalDot && axialDot >= coronalDot) {
+        return OrientationAxis.AXIAL;
+    }
+    else if (sagittalDot >= coronalDot) {
+        return OrientationAxis.SAGITTAL;
+    }
+    else {
+        return OrientationAxis.CORONAL;
+    }
+}

package/dist/esm/enums/OrientationAxis.d.ts

@@ -2,6 +2,10 @@ declare enum OrientationAxis {
     AXIAL = "axial",
     CORONAL = "coronal",
     SAGITTAL = "sagittal",
-    ACQUISITION = "acquisition"
+    ACQUISITION = "acquisition",
+    AXIAL_REFORMAT = "axial_reformat",
+    CORONAL_REFORMAT = "coronal_reformat",
+    SAGITTAL_REFORMAT = "sagittal_reformat",
+    REFORMAT = "reformat"
 }
 export default OrientationAxis;

package/dist/esm/enums/OrientationAxis.js

@@ -4,5 +4,9 @@ var OrientationAxis;
     OrientationAxis["CORONAL"] = "coronal";
     OrientationAxis["SAGITTAL"] = "sagittal";
     OrientationAxis["ACQUISITION"] = "acquisition";
+    OrientationAxis["AXIAL_REFORMAT"] = "axial_reformat";
+    OrientationAxis["CORONAL_REFORMAT"] = "coronal_reformat";
+    OrientationAxis["SAGITTAL_REFORMAT"] = "sagittal_reformat";
+    OrientationAxis["REFORMAT"] = "reformat";
 })(OrientationAxis || (OrientationAxis = {}));
 export default OrientationAxis;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.22.4";
+export declare const version = "3.23.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.22.4';
+export const version = '3.23.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.22.4",
+  "version": "3.23.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": "572327cda5bafbb57a1d965f37d1bcce1868d88b"
+  "gitHead": "85796c96f904126c372f8e5bc6bea3db1c955aa8"
 }