@cornerstonejs/core 4.15.18 → 4.15.20

package/dist/esm/RenderingEngine/Viewport.js

@@ -15,6 +15,7 @@ import { RENDERING_DEFAULTS } from '../constants';
 import { InterpolationType } from '../enums';
 import { deepClone } from '../utilities/deepClone';
 import { updatePlaneRestriction } from '../utilities/updatePlaneRestriction';
+import { getCubeSizeInView } from '../utilities/getPlaneCubeIntersectionDimensions';
 import { getConfiguration } from '../init';
 class Viewport {
     static { this.CameraViewPresentation = {
@@ -526,16 +527,13 @@ class Viewport {
             const idx = [middleIJK[0], middleIJK[1], middleIJK[2]];
             imageData.indexToWorld(idx, focalPoint);
         }
-        let { widthWorld, heightWorld } = this._getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal);
+        let { widthWorld, heightWorld } = imageData
+            ? getCubeSizeInView(imageData, viewPlaneNormal, viewUp)
+            : this._getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal);
         if (imageData) {
             const spacing = imageData.getSpacing();
             widthWorld = Math.max(spacing[0], widthWorld - spacing[0]);
             heightWorld = Math.max(spacing[1], heightWorld - spacing[1]);
-            const extent = imageData.getExtent();
-            const widthWorld2 = (extent[1] - extent[0]) * spacing[0];
-            const heightWorld2 = (extent[3] - extent[2]) * spacing[1];
-            console.warn('extent=', extent, spacing);
-            console.log('New method would produce:', this.id, widthWorld2, heightWorld2, widthWorld, heightWorld, widthWorld2 - widthWorld, heightWorld2 - heightWorld);
         }
         const canvasSize = [this.sWidth, this.sHeight];
         const boundsAspectRatio = widthWorld / heightWorld;

package/dist/esm/utilities/getPlaneCubeIntersectionDimensions.d.ts

@@ -0,0 +1,7 @@
+import type { Point3 } from '../types';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+export declare function getCubeSizeInView(imageData: vtkImageData, viewPlaneNormal: Point3, viewUp: Point3): {
+    widthWorld: number;
+    heightWorld: number;
+    depthWorld: number;
+};

package/dist/esm/utilities/getPlaneCubeIntersectionDimensions.js

@@ -0,0 +1,28 @@
+import { rotateToViewCoordinates } from './rotateToViewCoordinates';
+function findMinCornerIndex(viewCorners, dimension) {
+    let minIndex = 0;
+    let minValue = viewCorners[0][dimension];
+    for (let i = 1; i < viewCorners.length; i++) {
+        if (viewCorners[i][dimension] < minValue) {
+            minValue = viewCorners[i][dimension];
+            minIndex = i;
+        }
+    }
+    return minIndex;
+}
+function calculateSize(viewCorners, dimension) {
+    const minIndex = findMinCornerIndex(viewCorners, dimension);
+    const maxIndex = minIndex ^ 7;
+    return viewCorners[maxIndex][dimension] - viewCorners[minIndex][dimension];
+}
+export function getCubeSizeInView(imageData, viewPlaneNormal, viewUp) {
+    const viewCorners = rotateToViewCoordinates(imageData, viewPlaneNormal, viewUp);
+    const maxWidth = calculateSize(viewCorners, 0);
+    const maxHeight = calculateSize(viewCorners, 1);
+    const maxDepth = calculateSize(viewCorners, 2);
+    return {
+        widthWorld: maxWidth,
+        heightWorld: maxHeight,
+        depthWorld: maxDepth,
+    };
+}

package/dist/esm/utilities/index.d.ts

@@ -93,6 +93,8 @@ import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
 export * from './getPixelSpacingInformation';
+export * from './getPlaneCubeIntersectionDimensions';
+export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;

package/dist/esm/utilities/index.js

@@ -94,6 +94,8 @@ import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
 export * from './getPixelSpacingInformation';
+export * from './getPlaneCubeIntersectionDimensions';
+export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);

package/dist/esm/utilities/rotateToViewCoordinates.d.ts

@@ -0,0 +1,3 @@
+import type { Point3 } from '../types';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+export declare function rotateToViewCoordinates(imageData: vtkImageData, viewPlaneNormal: Point3, viewUp: Point3): Point3[];

package/dist/esm/utilities/rotateToViewCoordinates.js

@@ -0,0 +1,33 @@
+import { vec3 } from 'gl-matrix';
+export function rotateToViewCoordinates(imageData, viewPlaneNormal, viewUp) {
+    const viewRight = vec3.cross(vec3.create(), viewPlaneNormal, viewUp);
+    vec3.normalize(viewRight, viewRight);
+    const extent = imageData.getExtent();
+    const xMin = extent[0];
+    const xMax = extent[1] + 1;
+    const yMin = extent[2];
+    const yMax = extent[3] + 1;
+    const zMin = extent[4];
+    const zMax = extent[5] + 1;
+    const corners = [
+        [xMin, yMin, zMin],
+        [xMax, yMin, zMin],
+        [xMin, yMax, zMin],
+        [xMax, yMax, zMin],
+        [xMin, yMin, zMax],
+        [xMax, yMin, zMax],
+        [xMin, yMax, zMax],
+        [xMax, yMax, zMax],
+    ];
+    const viewCorners = corners.map((corner) => {
+        const worldPoint = [0, 0, 0];
+        imageData.indexToWorld(corner, worldPoint);
+        const viewPoint = [
+            vec3.dot(worldPoint, viewRight),
+            vec3.dot(worldPoint, viewUp),
+            vec3.dot(worldPoint, viewPlaneNormal),
+        ];
+        return viewPoint;
+    });
+    return viewCorners;
+}

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -1,4 +1,5 @@
 import * as metaData from '../metaData';
+import { toFiniteNumber } from './toNumber';
 function generateFrameImageId(baseImageId, frameNumber) {
     const framePattern = /\/frames\/\d+/;
     if (!framePattern.test(baseImageId)) {
@@ -67,6 +68,78 @@ function handleMultiframe4D(imageIds) {
         splittingTag: 'TimeSlotVector',
     };
 }
+function handleCardiac4D(imageIds) {
+    if (!imageIds || imageIds.length === 0) {
+        return null;
+    }
+    const cardiacNumberOfImages = getFiniteValue(imageIds[0], 'CardiacNumberOfImages');
+    if (cardiacNumberOfImages === undefined) {
+        return null;
+    }
+    const stacks = new Map();
+    for (const imageId of imageIds) {
+        const stackId = metaData.get('StackID', imageId);
+        const inStackPositionNumber = getFiniteValue(imageId, 'InStackPositionNumber');
+        const triggerTime = getFiniteValue(imageId, 'TriggerTime');
+        if (stackId === undefined ||
+            inStackPositionNumber === undefined ||
+            triggerTime === undefined) {
+            return null;
+        }
+        const stackKey = String(stackId);
+        if (!stacks.has(stackKey)) {
+            stacks.set(stackKey, new Map());
+        }
+        const positions = stacks.get(stackKey);
+        if (!positions.has(inStackPositionNumber)) {
+            positions.set(inStackPositionNumber, []);
+        }
+        positions.get(inStackPositionNumber).push({ imageId, triggerTime });
+    }
+    const sortedStackIds = Array.from(stacks.keys()).sort((a, b) => Number(a) - Number(b));
+    if (sortedStackIds.length === 0) {
+        return null;
+    }
+    const preparedStacks = [];
+    let timeCount;
+    for (const stackId of sortedStackIds) {
+        const positions = stacks.get(stackId);
+        const sortedPositions = Array.from(positions.keys()).sort((a, b) => a - b);
+        for (const position of sortedPositions) {
+            const frames = positions.get(position);
+            frames.sort((a, b) => a.triggerTime - b.triggerTime);
+            if (timeCount === undefined) {
+                timeCount = frames.length;
+            }
+            else if (frames.length !== timeCount) {
+                return null;
+            }
+        }
+        preparedStacks.push({
+            stackId,
+            positions: sortedPositions,
+            framesByPosition: positions,
+        });
+    }
+    if (!timeCount) {
+        return null;
+    }
+    const imageIdGroups = [];
+    for (let timeIndex = 0; timeIndex < timeCount; timeIndex++) {
+        const group = [];
+        for (const stack of preparedStacks) {
+            for (const position of stack.positions) {
+                const frames = stack.framesByPosition.get(position);
+                group.push(frames[timeIndex].imageId);
+            }
+        }
+        imageIdGroups.push(group);
+    }
+    return {
+        imageIdGroups,
+        splittingTag: 'CardiacTriggerTime',
+    };
+}
 const groupBy = (array, key) => {
     return array.reduce((rv, x) => {
         (rv[x[key]] = rv[x[key]] || []).push(x);
@@ -127,6 +200,9 @@ function getTagValue(imageId, tag) {
         return undefined;
     }
 }
+function getFiniteValue(imageId, tag) {
+    return toFiniteNumber(getTagValue(imageId, tag));
+}
 function getPhilipsPrivateBValue(imageId) {
     const value = metaData.get('20011003', imageId);
     try {
@@ -192,6 +268,10 @@ function splitImageIdsBy4DTags(imageIds) {
     if (multiframeResult) {
         return multiframeResult;
     }
+    const cardiacResult = handleCardiac4D(imageIds);
+    if (cardiacResult) {
+        return cardiacResult;
+    }
     const positionGroups = getIPPGroups(imageIds);
     if (!positionGroups) {
         return { imageIdGroups: [imageIds], splittingTag: null };

package/dist/esm/utilities/toNumber.d.ts

@@ -0,0 +1 @@
+export declare function toFiniteNumber(value: number | undefined): number | undefined;

package/dist/esm/utilities/toNumber.js

@@ -0,0 +1,3 @@
+export function toFiniteNumber(value) {
+    return Number.isFinite(value) ? value : undefined;
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.15.18";
+export declare const version = "4.15.20";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.15.18';
+export const version = '4.15.20';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.15.18",
+  "version": "4.15.20",
   "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": "2198d2e21481dd9f7e77148f98693ef0c2e5bdbc"
+  "gitHead": "35cc5f2d8ba3cb1c15abd8cf81231bf13ffaefb0"
 }