@cornerstonejs/ai 3.8.1 → 3.8.2

package/README.md

@@ -9,6 +9,25 @@ This package provides AI interfaces for use with Cornerstone in client-side appl
 
 ## Getting Started
 
+### WASM Files
+
+The ONNX Runtime Web requires WASM files to run in the browser. These files need to be copied to your application's public directory. The files should be placed in an `/ort/` directory in your public folder.
+
+In Webpack you can add the WASM files to the public folder like this:
+
+```js
+new CopyPlugin({
+  patterns: [
+    {
+      from: '../../../node_modules/onnxruntime-web/dist',
+      to: '${destPath.replace(/\\/g, '/')}/ort',
+    },
+  ],
+}),
+```
+
+This will copy all the necessary WASM files from the ONNX Runtime Web package to your application's public directory. Make sure your build system is configured to handle WASM files and that the `asyncWebAssembly` experiment is enabled in your build configuration.
+
 ### Running the Example
 
 To see the package in action with the Segment Anything Model, use the following command:
@@ -37,7 +56,6 @@ Huge model (vit_h) - 2.38 GB compressed
 
 For the examples we are using the model url and fetch it from the web. If you see in example code we have:
 
-
 #### URL to the model files
 
 ```js

package/dist/esm/LabelmapSlicePropagationTool.d.ts

@@ -0,0 +1,34 @@
+import { LabelmapBaseTool } from '@cornerstonejs/tools';
+declare class LabelmapSlicePropagationTool extends LabelmapBaseTool {
+    static toolName: string;
+    private segmentAI;
+    private _initialized;
+    private _modelInitialized;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+        configuration: {
+            sourceViewportId: string;
+            autoSegmentMode: boolean;
+            modelName: string;
+            enabled: boolean;
+            models: {
+                sam_b: {
+                    name: string;
+                    url: string;
+                    size: number;
+                    key: string;
+                }[];
+            };
+            numRandomPoints: number;
+            searchBreadth: number;
+        };
+    });
+    _init: () => Promise<void>;
+    onSetToolConfiguration: () => void;
+    onSetToolEnabled: () => Promise<void>;
+    onSetToolDisabled: () => void;
+    onSetToolPassive: () => void;
+    acceptPreview: () => void;
+    rejectPreview: () => void;
+}
+export default LabelmapSlicePropagationTool;

package/dist/esm/LabelmapSlicePropagationTool.js

@@ -0,0 +1,106 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { LabelmapBaseTool } from '@cornerstonejs/tools';
+import ONNXSegmentationController from './ONNXSegmentationController';
+class LabelmapSlicePropagationTool extends LabelmapBaseTool {
+    static { this.toolName = 'LabelmapSlicePropagation'; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            sourceViewportId: '',
+            autoSegmentMode: true,
+            modelName: 'sam_b',
+            enabled: false,
+            models: {
+                sam_b: [
+                    {
+                        name: 'sam-b-encoder',
+                        url: 'https://huggingface.co/schmuell/sam-b-fp16/resolve/main/sam_vit_b_01ec64.encoder-fp16.onnx',
+                        size: 180,
+                        key: 'encoder',
+                    },
+                    {
+                        name: 'sam-b-decoder',
+                        url: 'https://huggingface.co/schmuell/sam-b-fp16/resolve/main/sam_vit_b_01ec64.decoder.onnx',
+                        size: 17,
+                        key: 'decoder',
+                    },
+                ],
+            },
+            numRandomPoints: 5,
+            searchBreadth: 10,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._initialized = false;
+        this._modelInitialized = false;
+        this._init = async () => {
+            const { configuration } = this;
+            if (!configuration.enabled || !configuration.sourceViewportId) {
+                return;
+            }
+            if (!this.segmentAI) {
+                this.segmentAI = new ONNXSegmentationController({
+                    autoSegmentMode: configuration.autoSegmentMode,
+                    models: configuration.models,
+                    modelName: configuration.modelName,
+                    numRandomPoints: configuration.numRandomPoints,
+                    searchBreadth: configuration.searchBreadth,
+                });
+            }
+            this.segmentAI.enabled = true;
+            if (!this._modelInitialized) {
+                await this.segmentAI.initModel();
+                this._modelInitialized = true;
+            }
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                console.debug('No enabled element found for viewportId:', sourceViewportId);
+                return;
+            }
+            const { viewport } = enabledElement;
+            this.segmentAI.initViewport(viewport);
+            this._initialized = true;
+        };
+        this.onSetToolConfiguration = () => {
+            this._init();
+        };
+        this.onSetToolEnabled = async () => {
+            this.configuration.enabled = true;
+            if (this.segmentAI) {
+                this.segmentAI.enabled = true;
+            }
+            this._init();
+        };
+        this.onSetToolDisabled = () => {
+            this.configuration.enabled = false;
+            if (this.segmentAI) {
+                this.segmentAI.enabled = false;
+            }
+        };
+        this.onSetToolPassive = () => {
+            this.configuration.enabled = false;
+            if (this.segmentAI) {
+                this.segmentAI.enabled = false;
+            }
+        };
+        this.acceptPreview = () => {
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                return;
+            }
+            const { viewport } = enabledElement;
+            this.segmentAI.tool.acceptPreview(viewport.element);
+        };
+        this.rejectPreview = () => {
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                return;
+            }
+            this.segmentAI.rejectPreview(enabledElement.viewport.element);
+        };
+    }
+}
+export default LabelmapSlicePropagationTool;

package/dist/esm/MarkerLabelmapTool.d.ts

@@ -0,0 +1,39 @@
+import { LabelmapBaseTool } from '@cornerstonejs/tools';
+declare class MarkerLabelmapTool extends LabelmapBaseTool {
+    static toolName: string;
+    private segmentAI;
+    private _initialized;
+    private _modelInitialized;
+    private _toolsAdded;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+        configuration: {
+            sourceViewportId: string;
+            modelName: string;
+            enabled: boolean;
+            models: {
+                sam_b: {
+                    name: string;
+                    url: string;
+                    size: number;
+                    key: string;
+                }[];
+            };
+            numRandomPoints: number;
+            searchBreadth: number;
+        };
+    });
+    _init: () => Promise<void>;
+    _getToolGroupId: () => import("packages/tools/dist/esm/types").IToolGroup;
+    _addToolInstances: () => void;
+    onSetToolConfiguration: () => void;
+    onSetToolEnabled: () => Promise<void>;
+    onSetToolActive: () => void;
+    interpolateScroll: () => void;
+    onSetToolDisabled: () => void;
+    clearMarkers: () => void;
+    removePromptAnnotations: () => void;
+    acceptPreview: () => void;
+    rejectPreview: () => void;
+}
+export default MarkerLabelmapTool;

package/dist/esm/MarkerLabelmapTool.js

@@ -0,0 +1,176 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { LabelmapBaseTool, ToolGroupManager, Enums, annotation, ProbeTool, RectangleROITool, addTool, } from '@cornerstonejs/tools';
+import ONNXSegmentationController from './ONNXSegmentationController';
+class MarkerLabelmapTool extends LabelmapBaseTool {
+    static { this.toolName = 'MarkerLabelmap'; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            sourceViewportId: '',
+            modelName: 'sam_b',
+            enabled: false,
+            models: {
+                sam_b: [
+                    {
+                        name: 'sam-b-encoder',
+                        url: 'https://huggingface.co/schmuell/sam-b-fp16/resolve/main/sam_vit_b_01ec64.encoder-fp16.onnx',
+                        size: 180,
+                        key: 'encoder',
+                    },
+                    {
+                        name: 'sam-b-decoder',
+                        url: 'https://huggingface.co/schmuell/sam-b-fp16/resolve/main/sam_vit_b_01ec64.decoder.onnx',
+                        size: 17,
+                        key: 'decoder',
+                    },
+                ],
+            },
+            numRandomPoints: 5,
+            searchBreadth: 10,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._initialized = false;
+        this._modelInitialized = false;
+        this._toolsAdded = false;
+        this._init = async () => {
+            const { configuration } = this;
+            if (!configuration.enabled || !configuration.sourceViewportId) {
+                return;
+            }
+            if (!this.segmentAI) {
+                this.segmentAI = new ONNXSegmentationController({
+                    models: configuration.models,
+                    modelName: configuration.modelName,
+                });
+            }
+            if (!this._toolsAdded) {
+                this._addToolInstances();
+            }
+            this.segmentAI.enabled = true;
+            if (!this._modelInitialized) {
+                await this.segmentAI.initModel();
+                this._modelInitialized = true;
+            }
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                console.debug('No enabled element found for viewportId:', sourceViewportId);
+                return;
+            }
+            const { viewport } = enabledElement;
+            this.segmentAI.initViewport(viewport);
+            this._initialized = true;
+        };
+        this._getToolGroupId = () => {
+            return ToolGroupManager.getToolGroupForViewport(this.configuration.sourceViewportId);
+        };
+        this._addToolInstances = () => {
+            const toolGroup = this._getToolGroupId();
+            if (!toolGroup) {
+                console.debug(`Tool group not found`);
+                return;
+            }
+            addTool(ProbeTool);
+            const MarkerIncludeToolName = ONNXSegmentationController.MarkerInclude;
+            const MarkerExcludeToolName = ONNXSegmentationController.MarkerExclude;
+            const BoxPromptToolName = ONNXSegmentationController.BoxPrompt;
+            toolGroup.addToolInstance(MarkerIncludeToolName, ProbeTool.toolName, {
+                getTextLines: () => null,
+            });
+            toolGroup.addToolInstance(MarkerExcludeToolName, ProbeTool.toolName, {
+                getTextLines: () => null,
+            });
+            annotation.config.style.setToolGroupToolStyles(toolGroup.id, {
+                [MarkerIncludeToolName]: {
+                    color: 'rgb(0, 255, 0)',
+                    colorHighlighted: 'rgb(0, 255, 0)',
+                    colorSelected: 'rgb(0, 255, 0)',
+                },
+                [MarkerExcludeToolName]: {
+                    color: 'rgb(255, 0, 0)',
+                    colorHighlighted: 'rgb(255, 0, 0)',
+                    colorSelected: 'rgb(255, 0, 0)',
+                },
+            });
+            this._toolsAdded = true;
+        };
+        this.onSetToolConfiguration = () => {
+            this._init();
+        };
+        this.onSetToolEnabled = async () => {
+            this.configuration.enabled = true;
+            if (this.segmentAI) {
+                this.segmentAI.enabled = true;
+            }
+            if (!this._initialized) {
+                await this._init();
+            }
+        };
+        this.onSetToolActive = () => {
+            this.configuration.enabled = true;
+            if (this.segmentAI) {
+                this.segmentAI.enabled = true;
+            }
+            if (!this._initialized) {
+                this._init();
+            }
+        };
+        this.interpolateScroll = () => {
+            this.segmentAI.interpolateScroll();
+        };
+        this.onSetToolDisabled = () => {
+            this.configuration.enabled = false;
+            if (this.segmentAI) {
+                this.segmentAI.enabled = false;
+            }
+        };
+        this.clearMarkers = () => {
+            if (!this.segmentAI) {
+                return;
+            }
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                return;
+            }
+            const { viewport } = enabledElement;
+            this.segmentAI.clear(viewport);
+            viewport.render();
+        };
+        this.removePromptAnnotations = () => {
+            if (!this.segmentAI) {
+                return;
+            }
+            const { viewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(viewportId);
+            if (!enabledElement) {
+                return;
+            }
+            this.segmentAI.removePromptAnnotationsWithCache(enabledElement.viewport);
+        };
+        this.acceptPreview = () => {
+            if (!this.segmentAI) {
+                return;
+            }
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                return;
+            }
+            this.segmentAI.acceptPreview(enabledElement.viewport.element);
+        };
+        this.rejectPreview = () => {
+            if (!this.segmentAI) {
+                return;
+            }
+            const { sourceViewportId } = this.configuration;
+            const enabledElement = getEnabledElementByViewportId(sourceViewportId);
+            if (!enabledElement) {
+                return;
+            }
+            this.segmentAI.rejectPreview(enabledElement.viewport.element);
+        };
+    }
+}
+export default MarkerLabelmapTool;

package/dist/esm/ONNXSegmentationController.d.ts

@@ -93,15 +93,18 @@ export default class ONNXSegmentationController {
     };
     protected pCutoff: number;
     constructor(options?: {
-        listeners: any;
-        getPromptAnnotations: any;
-        promptAnnotationTypes: any;
-        models: any;
-        modelName: any;
-        islandFillOptions: any;
-        autoSegmentMode: boolean;
-        numRandomPoints: number;
-        searchBreadth: number;
+        listeners?: Array<(message: string) => void>;
+        getPromptAnnotations?: (viewport?: Types.IViewport) => cornerstoneTools.Types.Annotation[];
+        promptAnnotationTypes?: string[];
+        models?: Record<string, ModelType[]>;
+        modelName?: string;
+        islandFillOptions?: {
+            maxInternalRemove?: number;
+            fillInternalEdge?: boolean;
+        };
+        autoSegmentMode?: boolean;
+        numRandomPoints?: number;
+        searchBreadth?: number;
     });
     set enabled(enabled: boolean);
     get enabled(): boolean;

package/dist/esm/ONNXSegmentationController.js

@@ -115,7 +115,10 @@ export default class ONNXSegmentationController {
         promptAnnotationTypes: null,
         models: null,
         modelName: null,
-        islandFillOptions: undefined,
+        islandFillOptions: {
+            maxInternalRemove: 16,
+            fillInternalEdge: true,
+        },
         autoSegmentMode: false,
         numRandomPoints: 2,
         searchBreadth: 3,
@@ -276,8 +279,14 @@ export default class ONNXSegmentationController {
             Object.assign(ONNXSegmentationController.MODELS, options.models);
         }
         this.config = this.getConfig(options.modelName);
-        this.islandFillOptions =
-            options.islandFillOptions ?? this.islandFillOptions;
+        if (options.islandFillOptions) {
+            this.islandFillOptions = {
+                maxInternalRemove: options.islandFillOptions.maxInternalRemove ??
+                    this.islandFillOptions.maxInternalRemove,
+                fillInternalEdge: options.islandFillOptions.fillInternalEdge ??
+                    this.islandFillOptions.fillInternalEdge,
+            };
+        }
         this._autoSegmentMode = options.autoSegmentMode || false;
         this.numRandomPoints = options.numRandomPoints || this.numRandomPoints;
         this._searchBreadth = options.searchBreadth || this._searchBreadth;
@@ -470,7 +479,9 @@ export default class ONNXSegmentationController {
         this.points = [];
         this.labels = [];
         this.getPromptAnnotations(viewport).forEach((annotation) => annotationState.removeAnnotation(annotation.annotationUID));
-        this.tool.rejectPreview(this.viewport.element);
+        if (this.tool) {
+            this.tool.rejectPreview(this.viewport.element);
+        }
     }
     async cacheImageEncodings(current = this.viewport.getCurrentImageIdIndex(), offset = 0, length = 1000_000) {
         const { viewport, imageEncodings } = this;
@@ -504,7 +515,7 @@ export default class ONNXSegmentationController {
         });
     }
     async handleImage({ imageId, sampleImageId }, imageSession) {
-        if (imageId === imageSession.imageId || this.isGpuInUse) {
+        if (imageId === imageSession.imageId || this.isGpuInUse || !this.enabled) {
             return;
         }
         const { viewport, desiredImage } = this;
@@ -613,7 +624,7 @@ export default class ONNXSegmentationController {
             this.currentImage = null;
         }
         const [session] = this.sessions;
-        if (session.imageId === desiredImage.imageId) {
+        if (session?.imageId === desiredImage.imageId) {
             if (this.currentImage !== session) {
                 this.currentImage = session;
             }
@@ -761,7 +772,7 @@ export default class ONNXSegmentationController {
                 const maskIndex = 4 * (i + j * this.maxWidth);
                 const v = data[maskIndex];
                 const segmentValue = segmentationVoxelManager.getAtIJKPoint(ijkPoint);
-                if (segmentValue !== 0) {
+                if (segmentValue !== 0 && segmentValue !== 255) {
                     continue;
                 }
                 if (v > this.pCutoff) {
@@ -772,7 +783,9 @@ export default class ONNXSegmentationController {
                 }
             }
         }
-        this.tool.doneEditMemo();
+        if (this._autoSegmentMode) {
+            this.tool.doneEditMemo();
+        }
         this.tool._previewData.isDrag = true;
         const voxelManager = previewVoxelManager.sourceVoxelManager || previewVoxelManager;
         if (this.islandFillOptions) {
@@ -995,7 +1008,7 @@ export default class ONNXSegmentationController {
         }
         config.threads = parseInt(String(config.threads));
         config.local = parseInt(config.local);
-        ort.env.wasm.wasmPaths = 'dist/';
+        ort.env.wasm.wasmPaths = 'ort/';
         ort.env.wasm.numThreads = config.threads;
         ort.env.wasm.proxy = config.provider == 'wasm';
         this.config = config;

package/dist/esm/index.d.ts

@@ -1,2 +1,4 @@
 import ONNXSegmentationController from './ONNXSegmentationController';
-export { ONNXSegmentationController };
+import LabelmapSlicePropagationTool from './LabelmapSlicePropagationTool';
+import MarkerLabelmapTool from './MarkerLabelmapTool';
+export { ONNXSegmentationController, LabelmapSlicePropagationTool, MarkerLabelmapTool, };

package/dist/esm/index.js

@@ -1,2 +1,4 @@
 import ONNXSegmentationController from './ONNXSegmentationController';
-export { ONNXSegmentationController };
+import LabelmapSlicePropagationTool from './LabelmapSlicePropagationTool';
+import MarkerLabelmapTool from './MarkerLabelmapTool';
+export { ONNXSegmentationController, LabelmapSlicePropagationTool, MarkerLabelmapTool, };

package/package.json

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