@cornerstonejs/tools 2.0.0-beta.16 → 2.0.0-beta.18

package/dist/esm/utilities/segmentation/triggerSegmentationRender.d.ts

@@ -1,18 +1,3 @@
-declare class SegmentationRenderingEngine {
-    private _needsRender;
-    private _animationFrameSet;
-    private _animationFrameHandle;
-    hasBeenDestroyed: boolean;
-    removeToolGroup(toolGroupId: any): void;
-    renderToolGroupSegmentations(toolGroupId: any): void;
-    private _throwIfDestroyed;
-    private _setToolGroupSegmentationToBeRenderedNextFrame;
-    private _render;
-    private _renderFlaggedToolGroups;
-    _triggerRender(toolGroupId: any): void;
-    private _reset;
-}
-declare const segmentationRenderingEngine: SegmentationRenderingEngine;
-declare function triggerSegmentationRender(toolGroupId: string): void;
-export { segmentationRenderingEngine, triggerSegmentationRender };
+declare function triggerSegmentationRender(segmentationId?: string): void;
+export { triggerSegmentationRender };
 export default triggerSegmentationRender;

package/dist/esm/utilities/segmentation/triggerSegmentationRender.js

@@ -1,108 +1,6 @@
-import { triggerEvent, eventTarget, getRenderingEngine, Enums, } from '@cornerstonejs/core';
-import { Events as csToolsEvents } from '../../enums';
-import { getToolGroup, getToolGroupForViewport, } from '../../store/ToolGroupManager';
-import { SegmentationDisplayTool } from '../../tools';
-class SegmentationRenderingEngine {
-    constructor() {
-        this._needsRender = new Set();
-        this._animationFrameSet = false;
-        this._animationFrameHandle = null;
-        this._renderFlaggedToolGroups = () => {
-            this._throwIfDestroyed();
-            const toolGroupIds = Array.from(this._needsRender.values());
-            for (const toolGroupId of toolGroupIds) {
-                this._triggerRender(toolGroupId);
-                this._needsRender.delete(toolGroupId);
-                if (this._needsRender.size === 0) {
-                    this._animationFrameSet = false;
-                    this._animationFrameHandle = null;
-                    return;
-                }
-            }
-        };
-    }
-    removeToolGroup(toolGroupId) {
-        this._needsRender.delete(toolGroupId);
-        if (this._needsRender.size === 0) {
-            this._reset();
-        }
-    }
-    renderToolGroupSegmentations(toolGroupId) {
-        this._setToolGroupSegmentationToBeRenderedNextFrame([toolGroupId]);
-    }
-    _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.');
-        }
-    }
-    _setToolGroupSegmentationToBeRenderedNextFrame(toolGroupIds) {
-        toolGroupIds.forEach((toolGroupId) => {
-            this._needsRender.add(toolGroupId);
-        });
-        this._render();
-    }
-    _render() {
-        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
-            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedToolGroups);
-            this._animationFrameSet = true;
-        }
-    }
-    _triggerRender(toolGroupId) {
-        const toolGroup = getToolGroup(toolGroupId);
-        if (!toolGroup) {
-            console.warn(`No tool group found with toolGroupId: ${toolGroupId}`);
-            return;
-        }
-        const { viewportsInfo } = toolGroup;
-        const viewports = viewportsInfo
-            .map(({ viewportId, renderingEngineId }) => {
-            const renderingEngine = getRenderingEngine(renderingEngineId);
-            if (!renderingEngine) {
-                console.warn('rendering Engine has been destroyed');
-                return;
-            }
-            const viewport = renderingEngine.getViewport(viewportId);
-            if (viewport) {
-                return viewport;
-            }
-        })
-            .filter(Boolean);
-        const segmentationDisplayToolInstance = toolGroup.getToolInstance(SegmentationDisplayTool.toolName);
-        if (!segmentationDisplayToolInstance) {
-            console.warn('No segmentation tool found inside', toolGroupId);
-            return;
-        }
-        function onSegmentationRender(evt) {
-            const { element, viewportId, renderingEngineId } = evt.detail;
-            element.removeEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
-            const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
-            if (!toolGroup) {
-                console.warn('toolGroup has been destroyed');
-                return;
-            }
-            const eventDetail = {
-                toolGroupId: toolGroup.id,
-                viewportId,
-            };
-            triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
-                ...eventDetail,
-            });
-        }
-        viewports.forEach(({ element }) => {
-            element.addEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
-        });
-        segmentationDisplayToolInstance.renderSegmentation(toolGroupId);
-    }
-    _reset() {
-        window.cancelAnimationFrame(this._animationFrameHandle);
-        this._needsRender.clear();
-        this._animationFrameSet = false;
-        this._animationFrameHandle = null;
-    }
+import { segmentationRenderingEngine } from '../../tools/displayTools/SegmentationRenderingEngine';
+function triggerSegmentationRender(segmentationId) {
+    segmentationRenderingEngine.renderSegmentations(segmentationId);
 }
-const segmentationRenderingEngine = new SegmentationRenderingEngine();
-function triggerSegmentationRender(toolGroupId) {
-    segmentationRenderingEngine.renderToolGroupSegmentations(toolGroupId);
-}
-export { segmentationRenderingEngine, triggerSegmentationRender };
+export { triggerSegmentationRender };
 export default triggerSegmentationRender;

package/dist/esm/utilities/segmentation/triggerSegmentationRenderForViewports.d.ts

@@ -0,0 +1,3 @@
+declare function triggerSegmentationRenderForViewports(viewportIds?: string[]): void;
+export { triggerSegmentationRenderForViewports };
+export default triggerSegmentationRenderForViewports;

package/dist/esm/utilities/segmentation/triggerSegmentationRenderForViewports.js

@@ -0,0 +1,6 @@
+import { segmentationRenderingEngine } from '../../tools/displayTools/SegmentationRenderingEngine';
+function triggerSegmentationRenderForViewports(viewportIds) {
+    segmentationRenderingEngine.renderSegmentationsForViewports(viewportIds);
+}
+export { triggerSegmentationRenderForViewports };
+export default triggerSegmentationRenderForViewports;

package/dist/esm/utilities/triggerAnnotationRenderForViewportIds.js

@@ -5,12 +5,17 @@ export function triggerAnnotationRenderForViewportIds(viewportIdsToRender) {
         return;
     }
     viewportIdsToRender.forEach((viewportId) => {
-        const { viewport } = getEnabledElementByViewportId(viewportId);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            console.warn(`Viewport not available for ${viewportId}`);
+            return;
+        }
+        const { viewport } = enabledElement;
         if (!viewport) {
             console.warn(`Viewport not available for ${viewportId}`);
             return;
         }
-        const { element } = viewport;
+        const element = viewport.element;
         triggerAnnotationRender(element);
     });
 }