@cornerstonejs/core 3.16.0 → 3.16.1

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

@@ -1,3 +1,4 @@
+import { mat4 } from 'gl-matrix';
 import type { WSIViewportProperties, Point3, Point2, ICamera, CPUIImageData, ViewportInput } from '../types';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import Viewport from './Viewport';
@@ -26,6 +27,10 @@ declare class WSIViewport extends Viewport {
     getProperties: () => WSIViewportProperties;
     resetProperties(): void;
     protected getScalarData(): any;
+    computeTransforms(): {
+        indexToWorld: mat4;
+        worldToIndex: mat4;
+    };
     getImageData(): CPUIImageData;
     hasImageURI(imageURI: string): boolean;
     setCamera(camera: ICamera): void;
@@ -37,6 +42,10 @@ declare class WSIViewport extends Viewport {
     static getDicomMicroscopyViewer: () => Promise<any>;
     getFrameOfReferenceUID: () => string;
     resize: () => void;
+    worldToIndexWSI(point: Point3): Point2;
+    indexToWorldWSI(point: Point2): Point3;
+    worldToIndex(point: Point3): Point3;
+    indexToWorld(point: Point3): Point3;
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
     setDataIds(imageIds: string[], options?: DataSetOptions & {
@@ -47,8 +56,8 @@ declare class WSIViewport extends Viewport {
     postrender: () => void;
     scroll(delta: number): void;
     getRotation: () => number;
-    protected canvasToIndex: (canvasPos: Point2) => Point2;
-    protected indexToCanvas: (indexPos: Point2) => Point2;
+    protected canvasToIndex: (canvasPos: Point2) => Point3;
+    protected indexToCanvas: (indexPos: Point3) => Point2;
     getSliceIndex(): number;
     getView(): any;
     private refreshRenderValues;

package/dist/esm/RenderingEngine/WSIViewport.js

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import { vec3, mat4 } from 'gl-matrix';
 import { Events as EVENTS, MetadataModules } from '../enums';
 import uuidv4 from '../utilities/uuidv4';
 import * as metaData from '../metaData';
@@ -10,7 +10,9 @@ import triggerEvent from '../utilities/triggerEvent';
 import { peerImport } from '../init';
 import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 import microscopyViewportCss from '../constants/microscopyViewportCss';
+let WSIUtilFunctions = null;
 const _map = Symbol.for('map');
+const affineSymbol = Symbol.for('affine');
 const EVENT_POSTRENDER = 'postrender';
 class WSIViewport extends Viewport {
     constructor(props) {
@@ -56,28 +58,17 @@ class WSIViewport extends Viewport {
             if (!this.metadata) {
                 return;
             }
-            const [px, py] = this.canvasToIndex(canvasPos);
-            const { origin, spacing, direction } = this.getImageData();
-            const worldPos = vec3.fromValues(0, 0, 0);
-            const iVector = direction.slice(0, 3);
-            const jVector = direction.slice(3, 6);
-            vec3.scaleAndAdd(worldPos, origin, iVector, px * spacing[0]);
-            vec3.scaleAndAdd(worldPos, worldPos, jVector, py * spacing[1]);
-            return [worldPos[0], worldPos[1], worldPos[2]];
+            const indexPoint = this.canvasToIndex(canvasPos);
+            indexPoint[1] = -indexPoint[1];
+            return this.indexToWorld(indexPoint);
         };
         this.worldToCanvas = (worldPos) => {
             if (!this.metadata) {
                 return;
             }
-            const { spacing, direction, origin } = this.metadata;
-            const iVector = direction.slice(0, 3);
-            const jVector = direction.slice(3, 6);
-            const diff = vec3.subtract([0, 0, 0], worldPos, origin);
-            const indexPoint = [
-                vec3.dot(diff, iVector) / spacing[0],
-                vec3.dot(diff, jVector) / spacing[1],
-            ];
-            const canvasPoint = this.indexToCanvas(indexPoint);
+            const indexPoint = this.worldToIndex(worldPos);
+            indexPoint[1] = -indexPoint[1];
+            const canvasPoint = this.indexToCanvas([indexPoint[0], indexPoint[1], 0]);
             return canvasPoint;
         };
         this.postrender = () => {
@@ -93,12 +84,13 @@ class WSIViewport extends Viewport {
         this.canvasToIndex = (canvasPos) => {
             const transform = this.getTransform();
             transform.invert();
-            return transform.transformPoint(canvasPos.map((it) => it * devicePixelRatio));
+            const indexPoint = transform.transformPoint(canvasPos.map((it) => it * devicePixelRatio));
+            return [indexPoint[0], indexPoint[1], 0];
         };
         this.indexToCanvas = (indexPos) => {
             const transform = this.getTransform();
             return transform
-                .transformPoint(indexPos)
+                .transformPoint([indexPos[0], indexPos[1]])
                 .map((it) => it / devicePixelRatio);
         };
         this.customRenderViewportToCanvas = () => {
@@ -199,6 +191,23 @@ class WSIViewport extends Viewport {
     getScalarData() {
         return null;
     }
+    computeTransforms() {
+        const indexToWorld = mat4.create();
+        const worldToIndex = mat4.create();
+        mat4.fromTranslation(indexToWorld, this.metadata.origin);
+        indexToWorld[0] = this.metadata.direction[0];
+        indexToWorld[1] = this.metadata.direction[1];
+        indexToWorld[2] = this.metadata.direction[2];
+        indexToWorld[4] = this.metadata.direction[3];
+        indexToWorld[5] = this.metadata.direction[4];
+        indexToWorld[6] = this.metadata.direction[5];
+        indexToWorld[8] = this.metadata.direction[6];
+        indexToWorld[9] = this.metadata.direction[7];
+        indexToWorld[10] = this.metadata.direction[8];
+        mat4.scale(indexToWorld, indexToWorld, this.metadata.spacing);
+        mat4.invert(worldToIndex, indexToWorld);
+        return { indexToWorld, worldToIndex };
+    }
     getImageData() {
         const { metadata } = this;
         if (!metadata) {
@@ -212,13 +221,10 @@ class WSIViewport extends Viewport {
             getScalarData: () => this.getScalarData(),
             getSpacing: () => metadata.spacing,
             worldToIndex: (point) => {
-                const canvasPoint = this.worldToCanvas(point);
-                const pixelCoord = this.canvasToIndex(canvasPoint);
-                return [pixelCoord[0], pixelCoord[1], 0];
+                return this.worldToIndex(point);
             },
             indexToWorld: (point) => {
-                const canvasPoint = this.indexToCanvas([point[0], point[1]]);
-                return this.canvasToWorld(canvasPoint);
+                return this.indexToWorld(point);
             },
         };
         const imageDataReturn = {
@@ -282,7 +288,11 @@ class WSIViewport extends Viewport {
         this.refreshRenderValues();
         const { resolution, xSpacing, centerIndex } = this.internalCamera;
         const canvasToWorldRatio = resolution * xSpacing;
-        const canvasCenter = this.indexToCanvas(centerIndex.slice(0, 2));
+        const canvasCenter = this.indexToCanvas([
+            centerIndex[0],
+            centerIndex[1],
+            0,
+        ]);
         const focalPoint = this.canvasToWorld(canvasCenter);
         return {
             parallelProjection: true,
@@ -296,6 +306,40 @@ class WSIViewport extends Viewport {
     static { this.getDicomMicroscopyViewer = async () => {
         return peerImport('dicom-microscopy-viewer');
     }; }
+    worldToIndexWSI(point) {
+        if (!WSIUtilFunctions) {
+            return;
+        }
+        const affine = this.viewer[affineSymbol];
+        const pixelCoords = WSIUtilFunctions.applyInverseTransform({
+            coordinate: [point[0], point[1]],
+            affine,
+        });
+        return [pixelCoords[0], pixelCoords[1]];
+    }
+    indexToWorldWSI(point) {
+        if (!WSIUtilFunctions) {
+            return;
+        }
+        const sliceCoords = WSIUtilFunctions.applyTransform({
+            coordinate: [point[0], point[1]],
+            affine: this.viewer[affineSymbol],
+        });
+        return [sliceCoords[0], sliceCoords[1], 0];
+    }
+    worldToIndex(point) {
+        const { worldToIndex: worldToIndexMatrix } = this.computeTransforms();
+        const imageCoord = vec3.create();
+        vec3.transformMat4(imageCoord, point, worldToIndexMatrix);
+        return imageCoord;
+    }
+    indexToWorld(point) {
+        const { indexToWorld: indexToWorldMatrix } = this.computeTransforms();
+        const worldPos = vec3.create();
+        const point3D = vec3.fromValues(...point);
+        vec3.transformMat4(worldPos, point3D, indexToWorldMatrix);
+        return [worldPos[0], worldPos[1], worldPos[2]];
+    }
     setDataIds(imageIds, options) {
         if (options?.miniNavigationOverlay !== false) {
             WSIViewport.addMiniNavigationOverlayCss();
@@ -312,6 +356,7 @@ class WSIViewport extends Viewport {
         this.microscopyElement.innerText = 'Loading';
         this.imageIds = imageIds;
         const DicomMicroscopyViewer = await WSIViewport.getDicomMicroscopyViewer();
+        WSIUtilFunctions ||= DicomMicroscopyViewer.utils;
         this.frameOfReferenceUID = null;
         const metadataDicomweb = this.imageIds.map((imageId) => {
             const imageMetadata = client.getDICOMwebMetadata(imageId);

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.16.0";
+export declare const version = "3.16.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.16.0';
+export const version = '3.16.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.16.0",
+  "version": "3.16.1",
   "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": "16136620b12d12a19fe62f8b8a2ddbc468c4543b"
+  "gitHead": "50d792050fd2cab62160c80568daf2949c3fa868"
 }