@cornerstonejs/tools 2.0.0-beta.27 → 2.0.0-beta.29

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

@@ -1,7 +1,7 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
 import Representations from '../../enums/SegmentationRepresentations';
-import { getSegmentationRepresentations } from './getSegmentationRepresentations';
+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';
@@ -50,15 +50,15 @@ class SegmentationRenderingEngine {
         const viewportIds = [];
         for (const viewport of viewports) {
             const viewportId = viewport.id;
-            const segmentationRepresentations = getSegmentationRepresentations(viewportId);
             if (segmentationId) {
-                const hasSegmentationRepresentation = segmentationRepresentations.some((representation) => representation.segmentationId === segmentationId);
-                if (hasSegmentationRepresentation) {
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
+                if (segmentationRepresentations?.length > 0) {
                     viewportIds.push(viewportId);
                 }
             }
             else {
-                if (segmentationRepresentations.length > 0) {
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId);
+                if (segmentationRepresentations?.length > 0) {
                     viewportIds.push(viewportId);
                 }
             }
@@ -87,7 +87,10 @@ class SegmentationRenderingEngine {
         if (!segmentationRepresentations?.length) {
             return;
         }
-        const { viewport } = getEnabledElementByViewportId(viewportId);
+        const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+        if (!viewport) {
+            return;
+        }
         const viewportRenderList = [];
         const segmentationRenderList = segmentationRepresentations.map((representation) => {
             if (representation.type === SegmentationRepresentations.Contour) {
@@ -101,19 +104,29 @@ class SegmentationRenderingEngine {
             catch (error) {
                 console.error(error);
             }
-            return Promise.resolve();
-        });
-        function onSegmentationRender(evt) {
-            const { element, viewportId } = evt.detail;
-            element.removeEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
-            const eventDetail = {
-                viewportId,
-            };
-            triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
-                ...eventDetail,
+            return Promise.resolve({
+                segmentationId: representation.segmentationId,
+                type: representation.type,
             });
-        }
-        Promise.allSettled(segmentationRenderList).then(() => {
+        });
+        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();
@@ -138,4 +151,3 @@ function triggerSegmentationRenderBySegmentationId(segmentationId) {
 }
 const segmentationRenderingEngine = new SegmentationRenderingEngine();
 export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };
-//# sourceMappingURL=SegmentationRenderingEngine.js.map

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

@@ -1,47 +1,66 @@
 import type { Types } from '@cornerstonejs/core';
-import type { GlobalConfig, RepresentationConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
+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;
+    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;
     removeSegmentation(segmentationId: string): void;
-    getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-    addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
-    addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
-    _updateLabelmapSegmentationReferences(segmentationId: any, stackViewport: any, labelmapImageIds: any, updateCallback: any): string;
+    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[];
-    getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
-    removeRepresentation(segmentationRepresentationUID: string): void;
-    setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
-    getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
-    getGlobalConfig(): GlobalConfig;
-    setGlobalConfig(config: GlobalConfig): void;
-    _getRepresentationConfig(segmentationRepresentationUID: string): {
-        allSegments?: RepresentationConfig;
-        perSegment?: RepresentationConfig;
-    };
-    getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    getPerSegmentConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-    setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+    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;
     _getStackIdForImageIds(imageIds: string[]): string;
+    getAllViewportSegmentationRepresentations(): Array<{
+        viewportId: string;
+        representations: SegmentationRepresentation[];
+    }>;
 }
-declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
+declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
     imageIds: string[];
     options?: {
         volumeId?: string;
@@ -49,7 +68,7 @@ declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
 }): Promise<{
     volumeId: string;
 }>;
-declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
+declare function internalConvertStackToVolumeLabelmap({ segmentationId, options, }: {
     segmentationId: string;
     options?: {
         viewportId: string;
@@ -58,4 +77,4 @@ declare function convertStackToVolumeSegmentation({ segmentationId, options, }:
     };
 }): Promise<void>;
 declare const defaultSegmentationStateManager: SegmentationStateManager;
-export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };
+export { internalConvertStackToVolumeLabelmap, internalComputeVolumeLabelmapFromStack, defaultSegmentationStateManager, };