@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,15 +1,18 @@
-import FrameOfReferenceSpecificAnnotationManager from "./annotation/FrameOfReferenceSpecificAnnotationManager";
-import { defaultFrameOfReferenceSpecificAnnotationManager } from "./annotation/FrameOfReferenceSpecificAnnotationManager";
-import * as annotationLocking from "./annotation/annotationLocking";
-import * as annotationSelection from "./annotation/annotationSelection";
-import { getAnnotations } from "./annotation/annotationState";
-import { addAnnotation } from "./annotation/annotationState";
-import { getNumberOfAnnotations } from "./annotation/annotationState";
-import { removeAnnotation } from "./annotation/annotationState";
-import { getAnnotation } from "./annotation/annotationState";
-import { setAnnotationManager } from "./annotation/annotationState";
-import { getAnnotationManager } from "./annotation/annotationState";
-import { resetAnnotationManager } from "./annotation/annotationState";
-import { addSegmentationRepresentations } from "./segmentation";
-import { removeSegmentationsFromToolGroup } from "./segmentation";
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, addSegmentationRepresentations, removeSegmentationsFromToolGroup };
+import FrameOfReferenceSpecificAnnotationManager from './annotation/FrameOfReferenceSpecificAnnotationManager';
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './annotation/FrameOfReferenceSpecificAnnotationManager';
+import * as annotationLocking from './annotation/annotationLocking';
+import * as annotationSelection from './annotation/annotationSelection';
+import { getAnnotations } from './annotation/annotationState';
+import { addAnnotation } from './annotation/annotationState';
+import { getNumberOfAnnotations } from './annotation/annotationState';
+import { removeAnnotation } from './annotation/annotationState';
+import { getAnnotation } from './annotation/annotationState';
+import { getParentAnnotation } from './annotation/annotationState';
+import { getChildAnnotations } from './annotation/annotationState';
+import { clearParentAnnotation } from './annotation/annotationState';
+import { addChildAnnotation } from './annotation/annotationState';
+import { setAnnotationManager } from './annotation/annotationState';
+import { getAnnotationManager } from './annotation/annotationState';
+import { resetAnnotationManager } from './annotation/annotationState';
+import { invalidateAnnotation } from './annotation/annotationState';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation };

package/dist/esm/stateManagement/index.js

@@ -1,7 +1,5 @@
 import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpecificAnnotationManager, } from './annotation/FrameOfReferenceSpecificAnnotationManager';
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
-import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, } from './annotation/annotationState';
-import { addSegmentationRepresentations, removeSegmentationsFromToolGroup, } from './segmentation';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, addSegmentationRepresentations, removeSegmentationsFromToolGroup, };
-//# sourceMappingURL=index.js.map
+import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.d.ts

@@ -0,0 +1,20 @@
+declare class SegmentationRenderingEngine {
+    private _needsRender;
+    private _animationFrameSet;
+    private _animationFrameHandle;
+    hasBeenDestroyed: boolean;
+    renderSegmentationsForViewport(viewportId?: string): void;
+    renderSegmentation(segmentationId: string): void;
+    _getAllViewports: () => import("@cornerstonejs/core").Viewport[];
+    _getViewportIdsForSegmentation(segmentationId?: string): string[];
+    private _throwIfDestroyed;
+    private _setViewportsToBeRenderedNextFrame;
+    private _render;
+    private _renderFlaggedSegmentations;
+    _triggerRender(viewportId?: string): void;
+    _addPlanarFreeHandToolIfAbsent(viewport: any): void;
+}
+declare function triggerSegmentationRender(viewportId?: string): void;
+declare function triggerSegmentationRenderBySegmentationId(segmentationId?: string): void;
+declare const segmentationRenderingEngine: SegmentationRenderingEngine;
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.js

@@ -0,0 +1,153 @@
+import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
+import Representations from '../../enums/SegmentationRepresentations';
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
+import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
+import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
+import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
+import { addTool } from '../../store/addTool';
+import { state } from '../../store/state';
+import PlanarFreehandContourSegmentationTool from '../../tools/annotation/PlanarFreehandContourSegmentationTool';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+const renderers = {
+    [Representations.Labelmap]: labelmapDisplay,
+    [Representations.Contour]: contourDisplay,
+    [Representations.Surface]: surfaceDisplay,
+};
+const planarContourToolName = PlanarFreehandContourSegmentationTool.toolName;
+class SegmentationRenderingEngine {
+    constructor() {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._getAllViewports = () => {
+            const renderingEngine = getRenderingEngines();
+            return renderingEngine.flatMap((renderingEngine) => renderingEngine.getViewports());
+        };
+        this._renderFlaggedSegmentations = () => {
+            this._throwIfDestroyed();
+            const viewportIds = Array.from(this._needsRender);
+            viewportIds.forEach((viewportId) => {
+                this._triggerRender(viewportId);
+            });
+            this._needsRender.clear();
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+        };
+    }
+    renderSegmentationsForViewport(viewportId) {
+        const viewportIds = viewportId
+            ? [viewportId]
+            : this._getViewportIdsForSegmentation();
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    renderSegmentation(segmentationId) {
+        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    _getViewportIdsForSegmentation(segmentationId) {
+        const viewports = this._getAllViewports();
+        const viewportIds = [];
+        for (const viewport of viewports) {
+            const viewportId = viewport.id;
+            if (segmentationId) {
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
+                if (segmentationRepresentations?.length > 0) {
+                    viewportIds.push(viewportId);
+                }
+            }
+            else {
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId);
+                if (segmentationRepresentations?.length > 0) {
+                    viewportIds.push(viewportId);
+                }
+            }
+        }
+        return viewportIds;
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+    _setViewportsToBeRenderedNextFrame(viewportIds) {
+        viewportIds.forEach((viewportId) => {
+            this._needsRender.add(viewportId);
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedSegmentations);
+            this._animationFrameSet = true;
+        }
+    }
+    _triggerRender(viewportId) {
+        const segmentationRepresentations = getSegmentationRepresentations(viewportId);
+        if (!segmentationRepresentations?.length) {
+            return;
+        }
+        const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+        if (!viewport) {
+            return;
+        }
+        const viewportRenderList = [];
+        const segmentationRenderList = segmentationRepresentations.map((representation) => {
+            if (representation.type === SegmentationRepresentations.Contour) {
+                this._addPlanarFreeHandToolIfAbsent(viewport);
+            }
+            const display = renderers[representation.type];
+            try {
+                const viewportId = display.render(viewport, representation);
+                viewportRenderList.push(viewportId);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return Promise.resolve({
+                segmentationId: representation.segmentationId,
+                type: representation.type,
+            });
+        });
+        Promise.allSettled(segmentationRenderList).then((results) => {
+            const segmentationDetails = results
+                .filter((r) => r.status === 'fulfilled')
+                .map((r) => r.value);
+            function onSegmentationRender(evt) {
+                const { element, viewportId } = evt.detail;
+                element.removeEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+                segmentationDetails.forEach((detail) => {
+                    const eventDetail = {
+                        viewportId,
+                        segmentationId: detail.segmentationId,
+                        type: detail.type,
+                    };
+                    triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
+                        ...eventDetail,
+                    });
+                });
+            }
+            const element = viewport.element;
+            element.addEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+            viewport.render();
+        });
+    }
+    _addPlanarFreeHandToolIfAbsent(viewport) {
+        if (!(planarContourToolName in state.tools)) {
+            addTool(PlanarFreehandContourSegmentationTool);
+        }
+        const toolGroup = getToolGroupForViewport(viewport.id);
+        if (!toolGroup.hasTool(planarContourToolName)) {
+            toolGroup.addTool(planarContourToolName);
+            toolGroup.setToolPassive(planarContourToolName);
+        }
+    }
+}
+function triggerSegmentationRender(viewportId) {
+    segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+}
+function triggerSegmentationRenderBySegmentationId(segmentationId) {
+    segmentationRenderingEngine.renderSegmentation(segmentationId);
+}
+const segmentationRenderingEngine = new SegmentationRenderingEngine();
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };

package/dist/esm/stateManagement/segmentation/SegmentationStateManager.d.ts

@@ -1,33 +1,80 @@
-import type { ColorLUT, RepresentationConfig, Segmentation, SegmentationRepresentationConfig, SegmentationState, SegmentSpecificRepresentationConfig, ToolGroupSpecificRepresentation, ToolGroupSpecificRepresentations } from '../../types/SegmentationStateTypes';
+import type { Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import type { RenderingConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
+    private _stackLabelmapImageIdReferenceMap;
     constructor(uid?: string);
-    getState(): SegmentationState;
-    getToolGroups(): string[];
-    getColorLUT(lutIndex: number): ColorLUT | undefined;
+    getState(): Readonly<SegmentationState>;
+    private updateState;
+    getColorLUT(lutIndex: number): Types.ColorLUT | undefined;
+    getNextColorLUTIndex(): number;
     resetState(): void;
     getSegmentation(segmentationId: string): Segmentation | undefined;
+    updateSegmentation(segmentationId: string, payload: Partial<Segmentation>): void;
     addSegmentation(segmentation: Segmentation): void;
-    getSegmentationRepresentations(toolGroupId: string): ToolGroupSpecificRepresentations | undefined;
-    getAllSegmentationRepresentations(): Record<string, ToolGroupSpecificRepresentation[]>;
-    addSegmentationRepresentation(toolGroupId: string, segmentationRepresentation: ToolGroupSpecificRepresentation): void;
-    getGlobalConfig(): SegmentationRepresentationConfig;
-    setGlobalConfig(config: SegmentationRepresentationConfig): void;
-    getSegmentationRepresentationByUID(toolGroupId: string, segmentationRepresentationUID: string): ToolGroupSpecificRepresentation | undefined;
     removeSegmentation(segmentationId: string): void;
-    removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-    setActiveSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-    getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig | undefined;
-    getSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string): RepresentationConfig;
-    setSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    getSegmentSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-    setSegmentSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: SegmentSpecificRepresentationConfig): void;
-    setSegmentationRepresentationConfig(toolGroupId: string, config: SegmentationRepresentationConfig): void;
-    addColorLUT(colorLUT: ColorLUT, lutIndex: number): void;
+    addSegmentationRepresentation(viewportId: string, segmentationId: string, type: SegmentationRepresentations, renderingConfig: RenderingConfig): void;
+    private addDefaultSegmentationRepresentation;
+    addLabelmapRepresentation(state: SegmentationState, viewportId: string, segmentationId: string, renderingConfig?: RenderingConfig): void;
+    processLabelmapRepresentationAddition(viewportId: string, segmentationId: string): void;
+    _updateLabelmapSegmentationReferences(segmentationId: any, viewport: any, labelmapImageIds: any, updateCallback: any): string;
+    updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
+    _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
+    private getLabelmapImageIds;
+    getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
+    getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
+    removeSegmentationRepresentations(viewportId: string, specifier?: {
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+    }): void;
+    removeSegmentationRepresentation(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): void;
+    _setActiveSegmentation(state: SegmentationState, viewportId: string, segmentationId: string): void;
+    setActiveSegmentation(viewportId: string, segmentationId: string): void;
+    getActiveSegmentation(viewportId: string): Segmentation | undefined;
+    getSegmentationRepresentations(viewportId: string, specifier?: {
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+    }): SegmentationRepresentation[];
+    getSegmentationRepresentation(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): SegmentationRepresentation | undefined;
+    getSegmentationRepresentationVisibility(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): boolean;
+    setSegmentationRepresentationVisibility(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }, visible: boolean): void;
+    addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
-    _handleActiveSegmentation(toolGroupId: string, recentlyAddedOrRemovedSegmentationRepresentation: ToolGroupSpecificRepresentation): void;
-    _initDefaultColorLUTIfNecessary(): void;
+    _getStackIdForImageIds(imageIds: string[]): string;
+    getAllViewportSegmentationRepresentations(): Array<{
+        viewportId: string;
+        representations: SegmentationRepresentation[];
+    }>;
 }
+declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
+    imageIds: string[];
+    options?: {
+        volumeId?: string;
+    };
+}): Promise<{
+    volumeId: string;
+}>;
+declare function internalConvertStackToVolumeLabelmap({ segmentationId, options, }: {
+    segmentationId: string;
+    options?: {
+        viewportId: string;
+        volumeId?: string;
+        removeOriginal?: boolean;
+    };
+}): Promise<void>;
 declare const defaultSegmentationStateManager: SegmentationStateManager;
-export { defaultSegmentationStateManager };
+export { internalConvertStackToVolumeLabelmap, internalComputeVolumeLabelmapFromStack, defaultSegmentationStateManager, };