@cornerstonejs/ai 3.7.1 → 3.7.3

package/dist/esm/ONNXSegmentationController.d.ts

@@ -80,6 +80,7 @@ export default class ONNXSegmentationController {
     protected annotationsNeedUpdating: boolean;
     protected maskImageData: any;
     protected promptAnnotationTypes: string[];
+    protected _cachedPromptAnnotations: any;
     protected islandFillOptions: {
         maxInternalRemove: number;
         fillInternalEdge: boolean;
@@ -98,11 +99,13 @@ export default class ONNXSegmentationController {
     initViewport(viewport: any): void;
     acceptPreview(element: any): void;
     rejectPreview(element: any): void;
+    restoreCachedPromptAnnotations(viewport: Types.IViewport): any[];
+    removePromptAnnotationsWithCache(viewport: Types.IViewport): void;
     interpolateScroll(viewport?: any, dir?: number): Promise<void>;
     protected log(logger: Loggers, ...args: any[]): void;
     protected getPromptAnnotations: (viewport?: any) => cornerstoneTools.Types.Annotations;
     protected viewportRenderedListener: (_event: any) => void;
-    protected annotationModifiedListener: (_event?: any) => void;
+    protected annotationModifiedListener: Function;
     disconnectViewport(viewport: any): void;
     protected load(): Promise<void>;
     clear(viewport: any): void;
@@ -115,8 +118,8 @@ export default class ONNXSegmentationController {
     tryLoad(options?: {
         resetImage: boolean;
     }): void;
-    mapAnnotationPoint(worldPoint: any): number[];
-    updateAnnotations(): void;
+    mapAnnotationPoint(worldPoint: any, canvasPosition: any): number[];
+    updateAnnotations(useSession?: any): void;
     restoreImageEncoding(session: any, imageId: any): Promise<any>;
     loadStorageImageEncoding(session: any, imageId: any, index?: any): Promise<any>;
     storeImageEncoding(session: any, imageId: any, data: any): Promise<void>;

package/dist/esm/ONNXSegmentationController.js

@@ -1,4 +1,4 @@
-import { utilities, eventTarget, Enums } from '@cornerstonejs/core';
+import { utilities, eventTarget, Enums, triggerEvent, } from '@cornerstonejs/core';
 import * as cornerstoneTools from '@cornerstonejs/tools';
 import { segmentation as cstSegmentation, LabelmapBaseTool, } from '@cornerstonejs/tools';
 const { strategies } = cstSegmentation;
@@ -13,6 +13,11 @@ const { segmentation } = cornerstoneTools;
 const { filterAnnotationsForDisplay } = cornerstoneTools.utilities.planar;
 const { IslandRemoval } = cornerstoneTools.utilities;
 const { triggerSegmentationDataModified } = segmentation.triggerSegmentationEvents;
+const ONNX_EVENTS = {
+    MODEL_LOADING_STARTED: 'ONNX_MODEL_LOADING_STARTED',
+    MODEL_LOADING_COMPLETED: 'ONNX_MODEL_LOADING_COMPLETED',
+    MODEL_COMPONENT_LOADED: 'ONNX_MODEL_COMPONENT_LOADED',
+};
 function cloneTensor(t) {
     return new ort.Tensor(t.type, Float32Array.from(t.data), t.dims);
 }
@@ -176,14 +181,14 @@ export default class ONNXSegmentationController {
             ctxMask.clearRect(0, 0, canvasMask.width, canvasMask.height);
             this.tryLoad({ resetImage: true });
         };
-        this.annotationModifiedListener = (_event) => {
+        this.annotationModifiedListener = cornerstoneTools.utilities.debounce((_event) => {
             const currentAnnotations = this.getPromptAnnotations();
             if (!currentAnnotations.length) {
                 return;
             }
             this.annotationsNeedUpdating = true;
             this.tryLoad();
-        };
+        }, 300);
         if (options.listeners) {
             this.listeners = [...options.listeners];
         }
@@ -225,11 +230,6 @@ export default class ONNXSegmentationController {
                 activeStrategy: 'FILL_INSIDE_CIRCLE',
                 preview: {
                     enabled: true,
-                    previewColors: {
-                        0: [255, 255, 255, 128],
-                        1: [0, 255, 255, 192],
-                        2: [255, 0, 255, 255],
-                    },
                 },
             },
         });
@@ -257,15 +257,56 @@ export default class ONNXSegmentationController {
     rejectPreview(element) {
         this.tool.rejectPreview(element);
     }
+    restoreCachedPromptAnnotations(viewport) {
+        if (!this._cachedPromptAnnotations) {
+            return [];
+        }
+        const annotations = [];
+        const { include, exclude } = this._cachedPromptAnnotations;
+        if (include) {
+            const newInclude = cornerstoneTools.utilities.moveAnnotationToViewPlane(include, viewport);
+            annotations.push(newInclude);
+        }
+        if (exclude) {
+            const newExclude = cornerstoneTools.utilities.moveAnnotationToViewPlane(exclude, viewport);
+            annotations.push(newExclude);
+        }
+        return annotations;
+    }
+    removePromptAnnotationsWithCache(viewport) {
+        const toolNames = [
+            ONNXSegmentationController.MarkerInclude,
+            ONNXSegmentationController.MarkerExclude,
+            ONNXSegmentationController.BoxPrompt,
+        ];
+        let cachedInclude = null;
+        let cachedExclude = null;
+        const allAnnotations = cornerstoneTools.annotation.state.getAllAnnotations();
+        for (const annotation of allAnnotations) {
+            const toolName = annotation.metadata.toolName;
+            if (toolNames.includes(toolName)) {
+                if (toolName === ONNXSegmentationController.MarkerInclude &&
+                    !cachedInclude) {
+                    cachedInclude = annotation;
+                }
+                else if (toolName === ONNXSegmentationController.MarkerExclude &&
+                    !cachedExclude) {
+                    cachedExclude = annotation;
+                }
+                cornerstoneTools.annotation.state.removeAnnotation(annotation.annotationUID);
+            }
+        }
+        this._cachedPromptAnnotations = {
+            include: cachedInclude,
+            exclude: cachedExclude,
+        };
+        viewport.render();
+    }
     async interpolateScroll(viewport = this.viewport, dir = 1) {
         const { element } = viewport;
         this.tool.acceptPreview(element);
         const promptAnnotations = this.getPromptAnnotations(viewport);
-        if (!promptAnnotations.length) {
-            return;
-        }
         const currentSliceIndex = viewport.getCurrentImageIdIndex();
-        const { focalPoint } = viewport.getCamera();
         const viewRef = viewport.getViewReference({
             sliceIndex: currentSliceIndex + dir,
         });
@@ -275,22 +316,21 @@ export default class ONNXSegmentationController {
         }
         viewport.scroll(dir);
         await new Promise((resolve) => window.setTimeout(resolve, 250));
-        const nextAnnotations = this.getPromptAnnotations(viewport);
-        if (nextAnnotations.length > 0) {
-            return;
+        let annotations = [];
+        if (!promptAnnotations.length) {
+            annotations = this.restoreCachedPromptAnnotations(viewport);
         }
-        const { focalPoint: newFocal } = viewport.getCamera();
-        const newDelta = vec3.sub(vec3.create(), newFocal, focalPoint);
-        for (const annotation of promptAnnotations) {
-            annotation.interpolationUID ||= crypto.randomUUID();
-            const newAnnotation = structuredClone(annotation);
-            newAnnotation.annotationUID = undefined;
-            Object.assign(newAnnotation.metadata, viewRef);
-            newAnnotation.cachedStats = {};
-            for (const handle of newAnnotation.data.handles.points) {
-                vec3.add(handle, handle, newDelta);
+        else {
+            for (const annotation of promptAnnotations) {
+                const newAnnotation = structuredClone(annotation);
+                cornerstoneTools.annotation.state.removeAnnotation(annotation.annotationUID);
+                Object.assign(newAnnotation.metadata, viewRef);
+                cornerstoneTools.utilities.moveAnnotationToViewPlane(newAnnotation, viewport);
+                annotations.push(newAnnotation);
             }
-            annotationState.addAnnotation(newAnnotation, viewport.element);
+        }
+        for (const annotation of annotations) {
+            annotationState.addAnnotation(annotation, viewport.element);
         }
         viewport.render();
     }
@@ -486,16 +526,30 @@ export default class ONNXSegmentationController {
         }
         this.handleImage(desiredImage, session);
     }
-    mapAnnotationPoint(worldPoint) {
+    mapAnnotationPoint(worldPoint, canvasPosition) {
         const { viewport } = this;
         const canvasPoint = viewport.worldToCanvas(worldPoint);
         const { width, height } = viewport.canvas;
         const { width: destWidth, height: destHeight } = this.canvas;
         const x = Math.trunc((canvasPoint[0] * destWidth * devicePixelRatio) / width);
         const y = Math.trunc((canvasPoint[1] * destHeight * devicePixelRatio) / height);
-        return [x, y];
+        const { bottomLeft, topRight, origin } = canvasPosition;
+        const yVector = vec3.sub([0, 0, 0], origin, bottomLeft);
+        const xVector = vec3.sub([0, 0, 0], origin, topRight);
+        const xLen = vec3.length(xVector);
+        const yLen = vec3.length(yVector);
+        vec3.scale(xVector, xVector, 1 / xLen);
+        vec3.scale(yVector, yVector, 1 / yLen);
+        const xDot = vec3.dot(worldPoint, xVector);
+        const yDot = vec3.dot(worldPoint, yVector);
+        const centerX = vec3.dot(origin, xVector);
+        const centerY = vec3.dot(origin, yVector);
+        const newX = Math.round(((centerX - xDot) * destWidth) / xLen);
+        const newY = Math.round(((centerY - yDot) * destHeight) / yLen);
+        console.log('Old/new X,Y', x, y, newX, newY, x - newX, y - newY);
+        return [newX, newY];
     }
-    updateAnnotations() {
+    updateAnnotations(useSession = this.currentImage) {
         if (this.isGpuInUse ||
             !this.annotationsNeedUpdating ||
             !this.currentImage) {
@@ -506,16 +560,16 @@ export default class ONNXSegmentationController {
         this.points = [];
         this.labels = [];
         this.worldPoints = [];
-        if (!promptAnnotations?.length) {
+        if (!promptAnnotations?.length || !useSession?.canvasPosition) {
             return;
         }
         for (const annotation of promptAnnotations) {
             const handle = annotation.data.handles.points[0];
-            const point = this.mapAnnotationPoint(handle);
+            const point = this.mapAnnotationPoint(handle, useSession.canvasPosition);
             this.points.push(...point);
             if (annotation.metadata.toolName === ONNXSegmentationController.BoxPrompt) {
                 this.labels.push(2, 3);
-                this.points.push(...this.mapAnnotationPoint(annotation.data.handles.points[3]));
+                this.points.push(...this.mapAnnotationPoint(annotation.data.handles.points[3], useSession.canvasPosition));
             }
             else {
                 const label = annotation.metadata.toolName === this.excludeTool ? 0 : 1;
@@ -698,11 +752,23 @@ export default class ONNXSegmentationController {
             const cache = await caches.open('onnx');
             let cachedResponse = await cache.match(url);
             if (cachedResponse == undefined) {
+                triggerEvent(eventTarget, ONNX_EVENTS.MODEL_COMPONENT_LOADED, {
+                    name,
+                    url,
+                    status: 'loading',
+                    source: 'network',
+                });
                 await cache.add(url);
                 cachedResponse = await cache.match(url);
                 this.log(Loggers.Log, `${name} (network)`);
             }
             else {
+                triggerEvent(eventTarget, ONNX_EVENTS.MODEL_COMPONENT_LOADED, {
+                    name,
+                    url,
+                    status: 'loaded',
+                    source: 'cache',
+                });
                 this.log(Loggers.Log, `${name} (cached)`);
             }
             const data = await cachedResponse.arrayBuffer();
@@ -710,6 +776,12 @@ export default class ONNXSegmentationController {
         }
         catch (error) {
             this.log(Loggers.Log, `${name} (network)`);
+            triggerEvent(eventTarget, ONNX_EVENTS.MODEL_COMPONENT_LOADED, {
+                name,
+                url,
+                status: 'error',
+                error,
+            });
             return await fetch(url).then((response) => response.arrayBuffer());
         }
     }
@@ -724,6 +796,11 @@ export default class ONNXSegmentationController {
             }
             urls.push(model.url);
         }
+        triggerEvent(eventTarget, ONNX_EVENTS.MODEL_LOADING_STARTED, {
+            modelConfig: this.config.model,
+            totalSize: missing,
+            urls,
+        });
         if (missing > 0) {
             this.log(Loggers.Log, `downloading ${missing} MB from network ... it might take a while`);
         }
@@ -754,7 +831,13 @@ export default class ONNXSegmentationController {
             imageSession[model.key] = await ort.InferenceSession.create(model_bytes, sessionOptions);
         }
         const stop = performance.now();
-        this.log(Loggers.Log, `ready, ${(stop - start).toFixed(1)}ms`, urls.join(', '));
+        const loadTime = stop - start;
+        triggerEvent(eventTarget, ONNX_EVENTS.MODEL_LOADING_COMPLETED, {
+            modelConfig: this.config.model,
+            loadTimeMs: loadTime,
+            urls,
+        });
+        this.log(Loggers.Log, `ready, ${loadTime.toFixed(1)}ms`, urls.join(', '));
     }
     async getDirectoryForImageId(session, imageId) {
         if (imageId.indexOf('/studies/') === -1 ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/ai",
-  "version": "3.7.1",
+  "version": "3.7.3",
   "description": "AI and ML Interfaces for Cornerstone3D",
   "files": [
     "dist"
@@ -56,8 +56,8 @@
     "onnxruntime-web": "1.17.1"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.7.1",
-    "@cornerstonejs/tools": "^3.7.1"
+    "@cornerstonejs/core": "^3.7.3",
+    "@cornerstonejs/tools": "^3.7.3"
   },
-  "gitHead": "a4fe414ad0c938b9f842127dea4b0d12e334ac25"
+  "gitHead": "319a7741f4757201093d6b234a92dc6278d26f66"
 }