@cornerstonejs/ai 3.7.17 → 3.8.1

package/dist/esm/ONNXSegmentationController.d.ts

@@ -60,6 +60,8 @@ export default class ONNXSegmentationController {
     private points;
     private labels;
     private worldPoints;
+    private randomPoints;
+    private _searchBreadth;
     private loadingAI;
     protected viewport: any;
     protected excludeTool: string;
@@ -81,6 +83,10 @@ export default class ONNXSegmentationController {
     protected maskImageData: any;
     protected promptAnnotationTypes: string[];
     protected _cachedPromptAnnotations: any;
+    protected _enabled: boolean;
+    protected _autoSegmentMode: boolean;
+    protected imageIdsRunAgainst: Map<any, any>;
+    protected numRandomPoints: number;
     protected islandFillOptions: {
         maxInternalRemove: number;
         fillInternalEdge: boolean;
@@ -93,7 +99,15 @@ export default class ONNXSegmentationController {
         models: any;
         modelName: any;
         islandFillOptions: any;
+        autoSegmentMode: boolean;
+        numRandomPoints: number;
+        searchBreadth: number;
     });
+    set enabled(enabled: boolean);
+    get enabled(): boolean;
+    set autoSegmentMode(enabled: boolean);
+    get autoSegmentMode(): boolean;
+    set numSamplePoints(num: number);
     initModel(): Promise<unknown>;
     setPCutoff(cutoff: number): void;
     initViewport(viewport: any): void;

package/dist/esm/ONNXSegmentationController.js

@@ -1,4 +1,4 @@
-import { utilities, eventTarget, Enums, triggerEvent, } from '@cornerstonejs/core';
+import { utilities, eventTarget, Enums, triggerEvent, cache, } from '@cornerstonejs/core';
 import * as cornerstoneTools from '@cornerstonejs/tools';
 import { segmentation as cstSegmentation, LabelmapBaseTool, } from '@cornerstonejs/tools';
 const { strategies } = cstSegmentation;
@@ -116,6 +116,9 @@ export default class ONNXSegmentationController {
         models: null,
         modelName: null,
         islandFillOptions: undefined,
+        autoSegmentMode: false,
+        numRandomPoints: 2,
+        searchBreadth: 3,
     }) {
         this.maxWidth = 1024;
         this.maxHeight = 1024;
@@ -127,6 +130,7 @@ export default class ONNXSegmentationController {
         this.points = [];
         this.labels = [];
         this.worldPoints = new Array();
+        this._searchBreadth = 3;
         this.excludeTool = ONNXSegmentationController.MarkerExclude;
         this.listeners = [console.log];
         this.desiredImage = {
@@ -145,6 +149,10 @@ export default class ONNXSegmentationController {
             ONNXSegmentationController.MarkerExclude,
             ONNXSegmentationController.BoxPrompt,
         ];
+        this._enabled = false;
+        this._autoSegmentMode = false;
+        this.imageIdsRunAgainst = new Map();
+        this.numRandomPoints = 25;
         this.islandFillOptions = {
             maxInternalRemove: 16,
             fillInternalEdge: true,
@@ -176,6 +184,73 @@ export default class ONNXSegmentationController {
             if (desiredImage.imageId === currentImage?.imageId) {
                 return;
             }
+            if (this._enabled && this._autoSegmentMode) {
+                if ('isInAcquisitionPlane' in viewport &&
+                    !viewport.isInAcquisitionPlane()) {
+                    console.warn('Non acquisition plane viewports and auto segment mode is not yet supported');
+                    return;
+                }
+                const segmentation = cornerstoneTools.segmentation.activeSegmentation.getActiveSegmentation(viewport.id);
+                const segmentIndex = cornerstoneTools.segmentation.segmentIndex.getActiveSegmentIndex(segmentation.segmentationId);
+                const imageIds = viewport.getImageIds();
+                const currentImageIdIndex = viewport.getCurrentImageIdIndex();
+                const pointLists = [];
+                let foundPrevious = false;
+                let foundNext = false;
+                for (let offset = 1; offset <= this._searchBreadth; offset++) {
+                    if (!foundPrevious) {
+                        const previousImageIdIndex = currentImageIdIndex - offset;
+                        if (previousImageIdIndex >= 0) {
+                            const previousImageId = imageIds[previousImageIdIndex];
+                            const previousLabelmapImage = cache.getImageByReferencedImageId(previousImageId);
+                            const previousLabelmapVoxelManager = previousLabelmapImage?.voxelManager;
+                            if (previousLabelmapVoxelManager) {
+                                let foundInThisSlice = false;
+                                previousLabelmapVoxelManager.forEach(({ value, pointIJK }) => {
+                                    if (value === segmentIndex) {
+                                        const worldCoords = utilities.imageToWorldCoords(previousLabelmapImage.imageId, [pointIJK[0], pointIJK[1]]);
+                                        pointLists.push(worldCoords);
+                                        foundInThisSlice = true;
+                                    }
+                                });
+                                if (foundInThisSlice) {
+                                    foundPrevious = true;
+                                }
+                            }
+                        }
+                    }
+                    if (!foundNext) {
+                        const nextImageIdIndex = currentImageIdIndex + offset;
+                        if (nextImageIdIndex < imageIds.length) {
+                            const nextImageId = imageIds[nextImageIdIndex];
+                            const nextLabelmapImage = cache.getImageByReferencedImageId(nextImageId);
+                            const nextLabelmapVoxelManager = nextLabelmapImage?.voxelManager;
+                            if (nextLabelmapVoxelManager) {
+                                let foundInThisSlice = false;
+                                nextLabelmapVoxelManager.forEach(({ value, pointIJK }) => {
+                                    if (value === segmentIndex) {
+                                        const worldCoords = utilities.imageToWorldCoords(nextLabelmapImage.imageId, [pointIJK[0], pointIJK[1]]);
+                                        pointLists.push(worldCoords);
+                                        foundInThisSlice = true;
+                                    }
+                                });
+                                if (foundInThisSlice) {
+                                    foundNext = true;
+                                }
+                            }
+                        }
+                    }
+                    if (foundPrevious && foundNext) {
+                        break;
+                    }
+                }
+                this.randomPoints =
+                    pointLists.length > 0
+                        ? pointLists
+                            .sort(() => Math.random() - 0.5)
+                            .slice(0, Math.min(pointLists.length, this.numRandomPoints))
+                        : [];
+            }
             const { canvasMask } = this;
             const ctxMask = canvasMask.getContext('2d');
             ctxMask.clearRect(0, 0, canvasMask.width, canvasMask.height);
@@ -203,6 +278,27 @@ export default class ONNXSegmentationController {
         this.config = this.getConfig(options.modelName);
         this.islandFillOptions =
             options.islandFillOptions ?? this.islandFillOptions;
+        this._autoSegmentMode = options.autoSegmentMode || false;
+        this.numRandomPoints = options.numRandomPoints || this.numRandomPoints;
+        this._searchBreadth = options.searchBreadth || this._searchBreadth;
+    }
+    set enabled(enabled) {
+        this._enabled = enabled;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set autoSegmentMode(enabled) {
+        this._autoSegmentMode = enabled;
+        if (enabled) {
+            this._enabled = true;
+        }
+    }
+    get autoSegmentMode() {
+        return this._autoSegmentMode;
+    }
+    set numSamplePoints(num) {
+        this.numRandomPoints = num;
     }
     initModel() {
         if (!this.loadingAI) {
@@ -521,33 +617,31 @@ export default class ONNXSegmentationController {
             if (this.currentImage !== session) {
                 this.currentImage = session;
             }
-            this.updateAnnotations();
+            if (this._enabled && this._autoSegmentMode) {
+                this.points = [];
+                this.labels = [];
+                if (this.randomPoints?.length) {
+                    this.randomPoints.forEach((point) => {
+                        const mappedPoint = this.mapAnnotationPoint(point, this.currentImage.canvasPosition);
+                        this.points.push(...mappedPoint);
+                        this.labels.push(1);
+                    });
+                    this.runDecode();
+                }
+            }
+            else {
+                this.updateAnnotations();
+            }
             return;
         }
         this.handleImage(desiredImage, session);
     }
     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);
-        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];
+        const { origin, downVector, rightVector } = canvasPosition;
+        const deltaOrigin = vec3.sub([0, 0, 0], worldPoint, origin);
+        const x = Math.round(vec3.dot(deltaOrigin, rightVector) / vec3.sqrLen(rightVector));
+        const y = Math.round(vec3.dot(deltaOrigin, downVector) / vec3.sqrLen(downVector));
+        return [x, y];
     }
     updateAnnotations(useSession = this.currentImage) {
         if (this.isGpuInUse ||
@@ -647,22 +741,18 @@ export default class ONNXSegmentationController {
     createLabelmap(mask, canvasPosition, _points, _labels) {
         const { canvas, viewport } = this;
         const preview = this.tool.addPreview(viewport.element);
-        const { previewSegmentIndex, memo, segmentationId, segmentIndex } = preview;
-        const previewVoxelManager = memo?.voxelManager || preview.previewVoxelManager;
+        const { previewSegmentIndex, memo, segmentationId, segmentIndex, segmentationVoxelManager, } = preview;
+        const previewVoxelManager = memo?.voxelManager;
         const { dimensions } = previewVoxelManager;
         const { data } = mask;
-        const { origin, topRight, bottomLeft } = canvasPosition;
-        const downVec = vec3.subtract(vec3.create(), bottomLeft, origin);
-        const rightVec = vec3.subtract(vec3.create(), topRight, origin);
-        vec3.scale(downVec, downVec, 1 / canvas.height);
-        vec3.scale(rightVec, rightVec, 1 / canvas.width);
+        const { origin, rightVector, downVector } = canvasPosition;
         const worldPointJ = vec3.create();
         const worldPoint = vec3.create();
         const imageData = viewport.getDefaultImageData();
         for (let j = 0; j < canvas.height; j++) {
-            vec3.scaleAndAdd(worldPointJ, origin, downVec, j);
+            vec3.scaleAndAdd(worldPointJ, origin, downVector, j);
             for (let i = 0; i < canvas.width; i++) {
-                vec3.scaleAndAdd(worldPoint, worldPointJ, rightVec, i);
+                vec3.scaleAndAdd(worldPoint, worldPointJ, rightVector, i);
                 const ijkPoint = imageData.worldToIndex(worldPoint).map(Math.round);
                 if (ijkPoint.findIndex((v, index) => v < 0 || v >= dimensions[index]) !==
                     -1) {
@@ -670,6 +760,10 @@ export default class ONNXSegmentationController {
                 }
                 const maskIndex = 4 * (i + j * this.maxWidth);
                 const v = data[maskIndex];
+                const segmentValue = segmentationVoxelManager.getAtIJKPoint(ijkPoint);
+                if (segmentValue !== 0) {
+                    continue;
+                }
                 if (v > this.pCutoff) {
                     previewVoxelManager.setAtIJKPoint(ijkPoint, previewSegmentIndex);
                 }
@@ -678,6 +772,8 @@ export default class ONNXSegmentationController {
                 }
             }
         }
+        this.tool.doneEditMemo();
+        this.tool._previewData.isDrag = true;
         const voxelManager = previewVoxelManager.sourceVoxelManager || previewVoxelManager;
         if (this.islandFillOptions) {
             const islandRemoval = new IslandRemoval(this.islandFillOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/ai",
-  "version": "3.7.17",
+  "version": "3.8.1",
   "description": "AI and ML Interfaces for Cornerstone3D",
   "files": [
     "dist"
@@ -56,8 +56,8 @@
     "onnxruntime-web": "1.17.1"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.7.17",
-    "@cornerstonejs/tools": "^3.7.17"
+    "@cornerstonejs/core": "^3.8.1",
+    "@cornerstonejs/tools": "^3.8.1"
   },
-  "gitHead": "9a5dc66176f5172fd3bb11ebcf37f9b8667ab3c4"
+  "gitHead": "1f45d352ecb6e239cb418f085cdabeca2a4520a9"
 }