@cornerstonejs/tools 2.0.0-beta.21 → 2.0.0-beta.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.0.0-beta.21",
+  "version": "2.0.0-beta.23",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -25,16 +25,17 @@
     "build:umd": "cross-env NODE_ENV=production webpack --config .webpack/webpack.prod.js",
     "build:all": "yarn run build:umd && yarn run build:esm",
     "build": "yarn run build:all",
-    "api-check": "api-extractor --debug run",
     "clean": "rm -rf node_modules/.cache/storybook && shx rm -rf dist",
     "clean:deep": "yarn run clean && shx rm -rf node_modules",
     "dev": "tsc --project ./tsconfig.esm.json --watch",
     "build:update-api": "yarn run build:esm && api-extractor run --local",
+    "format-check": "npx eslint ./src --quiet",
+    "api-check": "api-extractor --debug run ",
     "prepublishOnly": "yarn run build",
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^2.0.0-beta.21",
+    "@cornerstonejs/core": "^2.0.0-beta.23",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
     "lodash.get": "^4.4.2"
@@ -61,5 +62,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "de2d08d4edbae4ca48831cc44a57737717b10b22"
+  "gitHead": "59acc619e43b3c8f748b6ba8dd5d964355b2c68b"
 }

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

@@ -1,17 +0,0 @@
-declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
-    imageIds: string[];
-    options?: {
-        volumeId?: string;
-    };
-}): Promise<{
-    volumeId: string;
-}>;
-declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
-    segmentationId: string;
-    options?: {
-        viewportId: string;
-        volumeId?: string;
-        removeOriginal?: boolean;
-    };
-}): Promise<void>;
-export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack };

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

@@ -1,50 +0,0 @@
-import { volumeLoader, utilities as csUtils, eventTarget, cache, } from '@cornerstonejs/core';
-import { Events, SegmentationRepresentations } from '../../enums';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
-import { triggerSegmentationRender } from '../../utilities/segmentation';
-import { getSegmentation } from './segmentationState';
-import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
-async function computeVolumeSegmentationFromStack({ imageIds, options, }) {
-    const segmentationImageIds = imageIds;
-    const volumeId = options?.volumeId ?? csUtils.uuidv4();
-    await volumeLoader.createAndCacheVolumeFromImages(volumeId, segmentationImageIds);
-    return { volumeId };
-}
-async function convertStackToVolumeSegmentation({ segmentationId, options, }) {
-    const segmentation = getSegmentation(segmentationId);
-    const data = segmentation.representationData
-        .LABELMAP;
-    const { volumeId } = await computeVolumeSegmentationFromStack({
-        imageIds: data.imageIds,
-        options,
-    });
-    await updateSegmentationState({
-        segmentationId,
-        viewportId: options.viewportId,
-        options,
-        volumeId,
-    });
-}
-async function updateSegmentationState({ segmentationId, viewportId, volumeId, options, }) {
-    const segmentation = getSegmentation(segmentationId);
-    if (options?.removeOriginal) {
-        const data = segmentation.representationData
-            .LABELMAP;
-        const { imageIds } = data;
-        imageIds.forEach((imageId) => {
-            cache.removeImageLoadObject(imageId);
-        });
-        segmentation.representationData.LABELMAP = {
-            volumeId,
-        };
-    }
-    else {
-        segmentation.representationData.LABELMAP = {
-            ...segmentation.representationData.LABELMAP,
-            volumeId,
-        };
-    }
-    triggerSegmentationRender(viewportId);
-    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
-}
-export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack };

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationRepresentationRenderingConfig.d.ts

@@ -1,2 +0,0 @@
-import type { RepresentationPublicInput } from '../../../types';
-export declare function getSegmentationRepresentationRenderingConfig(representationInput: RepresentationPublicInput): {};

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationRepresentationRenderingConfig.js

@@ -1,11 +0,0 @@
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { getSegmentationRepresentationRenderingConfig as getLabelmapRenderingConfig } from '../../../tools/displayTools/Labelmap/labelmapDisplay';
-export function getSegmentationRepresentationRenderingConfig(representationInput) {
-    const { type } = representationInput;
-    if (type === SegmentationRepresentations.Labelmap) {
-        return getLabelmapRenderingConfig();
-    }
-    else {
-        return {};
-    }
-}

package/dist/esm/tools/AdvancedMagnifyViewport.d.ts

@@ -1,76 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-export type AutoPanCallbackData = {
-    points: {
-        currentPosition: {
-            canvas: Types.Point2;
-            world: Types.Point3;
-        };
-        newPosition: {
-            canvas: Types.Point2;
-            world: Types.Point3;
-        };
-    };
-    delta: {
-        canvas: Types.Point2;
-        world: Types.Point3;
-    };
-};
-export type AutoPanCallback = (data: AutoPanCallbackData) => void;
-declare class AdvancedMagnifyViewport {
-    private _viewportId;
-    private _sourceEnabledElement;
-    private _enabledElement;
-    private _sourceToolGroup;
-    private _magnifyToolGroup;
-    private _isViewportReady;
-    private _radius;
-    private _resized;
-    private _resizeViewportAsync;
-    private _canAutoPan;
-    private _autoPan;
-    position: Types.Point2;
-    zoomFactor: number;
-    visible: boolean;
-    constructor({ magnifyViewportId, sourceEnabledElement, radius, position, zoomFactor, autoPan, }: {
-        magnifyViewportId?: string;
-        sourceEnabledElement: Types.IEnabledElement;
-        radius?: number;
-        position?: Types.Point2;
-        zoomFactor: number;
-        autoPan: {
-            enabled: boolean;
-            padding: number;
-            callback: AutoPanCallback;
-        };
-    });
-    get sourceEnabledElement(): Types.IEnabledElement;
-    get viewportId(): string;
-    get radius(): number;
-    set radius(radius: number);
-    update(): void;
-    dispose(): void;
-    private _handleToolModeChanged;
-    private _inheritBorderRadius;
-    private _createViewportNode;
-    private _convertZoomFactorToParallelScale;
-    private _isStackViewport;
-    private _isVolumeViewport;
-    private _cloneToolGroups;
-    private _cloneStack;
-    private _cloneVolumes;
-    private _cloneViewport;
-    private _cancelMouseEventCallback;
-    private _browserMouseUpCallback;
-    private _browserMouseDownCallback;
-    private _mouseDragCallback;
-    private _addBrowserEventListeners;
-    private _removeBrowserEventListeners;
-    private _addEventListeners;
-    private _removeEventListeners;
-    private _initialize;
-    private _syncViewportsCameras;
-    private _syncStackViewports;
-    private _syncViewports;
-    private _resizeViewport;
-}
-export { AdvancedMagnifyViewport as default, AdvancedMagnifyViewport };

package/dist/esm/tools/AdvancedMagnifyViewport.js

@@ -1,351 +0,0 @@
-import { vec2, vec3 } from 'gl-matrix';
-import { getEnabledElement, eventTarget, utilities as csUtils, } from '@cornerstonejs/core';
-import { SegmentationRepresentations, ToolModes, Events as cstEvents, } from '../enums';
-import { ToolGroupManager, state } from '../store';
-import { debounce } from '../utilities';
-import { segmentation } from '..';
-import { AnnotationTool, AdvancedMagnifyTool } from './';
-import { distanceToPoint } from '../utilities/math/point';
-const MAGNIFY_CLASSNAME = 'advancedMagnifyTool';
-const MAGNIFY_VIEWPORT_INITIAL_RADIUS = 125;
-const isSegmentation = (actor) => actor.uid !== actor.referencedId;
-class AdvancedMagnifyViewport {
-    constructor({ magnifyViewportId, sourceEnabledElement, radius = MAGNIFY_VIEWPORT_INITIAL_RADIUS, position = [0, 0], zoomFactor, autoPan, }) {
-        this._enabledElement = null;
-        this._sourceToolGroup = null;
-        this._magnifyToolGroup = null;
-        this._isViewportReady = false;
-        this._radius = 0;
-        this._resized = false;
-        this._canAutoPan = false;
-        this._viewportId = magnifyViewportId ?? csUtils.uuidv4();
-        this._sourceEnabledElement = sourceEnabledElement;
-        this._autoPan = autoPan;
-        this.radius = radius;
-        this.position = position;
-        this.zoomFactor = zoomFactor;
-        this.visible = true;
-        this._browserMouseDownCallback = this._browserMouseDownCallback.bind(this);
-        this._browserMouseUpCallback = this._browserMouseUpCallback.bind(this);
-        this._handleToolModeChanged = this._handleToolModeChanged.bind(this);
-        this._mouseDragCallback = this._mouseDragCallback.bind(this);
-        this._resizeViewportAsync = (debounce(this._resizeViewport.bind(this), 1));
-        this._initialize();
-    }
-    get sourceEnabledElement() {
-        return this._sourceEnabledElement;
-    }
-    get viewportId() {
-        return this._viewportId;
-    }
-    get radius() {
-        return this._radius;
-    }
-    set radius(radius) {
-        if (Math.abs(this._radius - radius) > 0.00001) {
-            this._radius = radius;
-            this._resized = true;
-        }
-    }
-    update() {
-        const { radius, position, visible } = this;
-        const { viewport } = this._enabledElement;
-        const { element } = viewport;
-        const size = 2 * radius;
-        const [x, y] = position;
-        if (this._resized) {
-            this._resizeViewportAsync();
-            this._resized = false;
-        }
-        Object.assign(element.style, {
-            display: visible ? 'block' : 'hidden',
-            width: `${size}px`,
-            height: `${size}px`,
-            left: `${-radius}px`,
-            top: `${-radius}px`,
-            transform: `translate(${x}px, ${y}px)`,
-        });
-        if (this._isViewportReady) {
-            this._syncViewports();
-            viewport.render();
-        }
-    }
-    dispose() {
-        const { viewport } = this._enabledElement;
-        const { element } = viewport;
-        const renderingEngine = viewport.getRenderingEngine();
-        this._removeEventListeners(element);
-        renderingEngine.disableElement(viewport.id);
-        if (element.parentNode) {
-            element.parentNode.removeChild(element);
-        }
-    }
-    _handleToolModeChanged(evt) {
-        const { _magnifyToolGroup: magnifyToolGroup } = this;
-        const { toolGroupId, toolName, mode, toolBindingsOptions } = evt.detail;
-        if (this._sourceToolGroup?.id !== toolGroupId) {
-            return;
-        }
-        switch (mode) {
-            case ToolModes.Active:
-                magnifyToolGroup.setToolActive(toolName, toolBindingsOptions);
-                break;
-            case ToolModes.Passive:
-                magnifyToolGroup.setToolPassive(toolName);
-                break;
-            case ToolModes.Enabled:
-                magnifyToolGroup.setToolEnabled(toolName);
-                break;
-            case ToolModes.Disabled:
-                magnifyToolGroup.setToolDisabled(toolName);
-                break;
-            default:
-                throw new Error(`Unknow tool mode (${mode})`);
-        }
-    }
-    _inheritBorderRadius(magnifyElement) {
-        const viewport = magnifyElement.querySelector('.viewport-element');
-        const canvas = magnifyElement.querySelector('.cornerstone-canvas');
-        viewport.style.borderRadius = 'inherit';
-        canvas.style.borderRadius = 'inherit';
-    }
-    _createViewportNode() {
-        const magnifyElement = document.createElement('div');
-        const { radius } = this;
-        const size = radius * 2;
-        magnifyElement.classList.add(MAGNIFY_CLASSNAME);
-        Object.assign(magnifyElement.style, {
-            display: 'block',
-            width: `${size}px`,
-            height: `${size}px`,
-            position: 'absolute',
-            overflow: 'hidden',
-            borderRadius: '50%',
-            boxSizing: 'border-box',
-            left: `${-radius}px`,
-            top: `${-radius}px`,
-            transform: `translate(-1000px, -1000px)`,
-        });
-        return magnifyElement;
-    }
-    _convertZoomFactorToParallelScale(viewport, magnifyViewport, zoomFactor) {
-        const { parallelScale } = viewport.getCamera();
-        const canvasRatio = magnifyViewport.canvas.offsetWidth / viewport.canvas.offsetWidth;
-        return parallelScale * (1 / zoomFactor) * canvasRatio;
-    }
-    _isStackViewport(viewport) {
-        return 'setStack' in viewport;
-    }
-    _isVolumeViewport(viewport) {
-        return 'addVolumes' in viewport;
-    }
-    _cloneToolGroups(sourceViewport, magnifyViewport) {
-        const sourceActors = sourceViewport.getActors();
-        const magnifyToolGroupId = `${magnifyViewport.id}-toolGroup`;
-        const sourceToolGroup = ToolGroupManager.getToolGroupForViewport(sourceViewport.id, sourceViewport.renderingEngineId);
-        const magnifyToolGroup = sourceToolGroup.clone(magnifyToolGroupId, (toolName) => {
-            const toolInstance = sourceToolGroup.getToolInstance(toolName);
-            const isAnnotationTool = toolInstance instanceof AnnotationTool &&
-                !(toolInstance instanceof AdvancedMagnifyTool);
-            return isAnnotationTool;
-        });
-        magnifyToolGroup.addViewport(magnifyViewport.id, magnifyViewport.renderingEngineId);
-        sourceActors.filter(isSegmentation).forEach((actor) => {
-            segmentation.addSegmentationRepresentations(this.viewportId, [
-                {
-                    segmentationId: actor.referencedId,
-                    type: SegmentationRepresentations.Labelmap,
-                },
-            ]);
-        });
-        return { sourceToolGroup, magnifyToolGroup };
-    }
-    _cloneStack(sourceViewport, magnifyViewport) {
-        const imageIds = sourceViewport.getImageIds();
-        magnifyViewport.setStack(imageIds).then(() => {
-            this._isViewportReady = true;
-            this.update();
-        });
-    }
-    _cloneVolumes(sourceViewport, magnifyViewport) {
-        const actors = sourceViewport.getActors();
-        const volumeInputArray = actors
-            .filter((actor) => !isSegmentation(actor))
-            .map((actor) => ({ volumeId: actor.uid }));
-        magnifyViewport.setVolumes(volumeInputArray).then(() => {
-            this._isViewportReady = true;
-            this.update();
-        });
-        return magnifyViewport;
-    }
-    _cloneViewport(sourceViewport, magnifyElement) {
-        const { viewportId: magnifyViewportId } = this;
-        const renderingEngine = sourceViewport.getRenderingEngine();
-        const { options: sourceViewportOptions } = sourceViewport;
-        const viewportInput = {
-            element: magnifyElement,
-            viewportId: magnifyViewportId,
-            type: sourceViewport.type,
-            defaultOptions: { ...sourceViewportOptions },
-        };
-        renderingEngine.enableElement(viewportInput);
-        const magnifyViewport = (renderingEngine.getViewport(magnifyViewportId));
-        if (this._isStackViewport(sourceViewport)) {
-            this._cloneStack(sourceViewport, magnifyViewport);
-        }
-        else if (this._isVolumeViewport(sourceViewport)) {
-            this._cloneVolumes(sourceViewport, magnifyViewport);
-        }
-        this._inheritBorderRadius(magnifyElement);
-        const toolGroups = this._cloneToolGroups(sourceViewport, magnifyViewport);
-        this._sourceToolGroup = toolGroups.sourceToolGroup;
-        this._magnifyToolGroup = toolGroups.magnifyToolGroup;
-    }
-    _cancelMouseEventCallback(evt) {
-        evt.stopPropagation();
-        evt.preventDefault();
-    }
-    _browserMouseUpCallback(evt) {
-        const { element } = this._enabledElement.viewport;
-        document.removeEventListener('mouseup', this._browserMouseUpCallback);
-        element.addEventListener('mouseup', this._cancelMouseEventCallback);
-        element.addEventListener('mousemove', this._cancelMouseEventCallback);
-    }
-    _browserMouseDownCallback(evt) {
-        const { element } = this._enabledElement.viewport;
-        this._canAutoPan = !!evt.target?.closest('.advancedMagnifyTool');
-        document.addEventListener('mouseup', this._browserMouseUpCallback);
-        element.removeEventListener('mouseup', this._cancelMouseEventCallback);
-        element.removeEventListener('mousemove', this._cancelMouseEventCallback);
-    }
-    _mouseDragCallback(evt) {
-        if (!state.isInteractingWithTool) {
-            return;
-        }
-        const { _autoPan: autoPan } = this;
-        if (!autoPan.enabled || !this._canAutoPan) {
-            return;
-        }
-        const { currentPoints } = evt.detail;
-        const { viewport } = this._enabledElement;
-        const { canvasToWorld } = viewport;
-        const { canvas: canvasCurrent } = currentPoints;
-        const { radius: magnifyRadius } = this;
-        const canvasCenter = [magnifyRadius, magnifyRadius];
-        const dist = distanceToPoint(canvasCenter, canvasCurrent);
-        const maxDist = magnifyRadius - autoPan.padding;
-        if (dist <= maxDist) {
-            return;
-        }
-        const panDist = dist - maxDist;
-        const canvasDeltaPos = vec2.sub(vec2.create(), canvasCurrent, canvasCenter);
-        vec2.normalize(canvasDeltaPos, canvasDeltaPos);
-        vec2.scale(canvasDeltaPos, canvasDeltaPos, panDist);
-        const newCanvasPosition = vec2.add(vec2.create(), this.position, canvasDeltaPos);
-        const currentWorldPos = canvasToWorld(this.position);
-        const newWorldPos = canvasToWorld(newCanvasPosition);
-        const worldDeltaPos = vec3.sub(vec3.create(), newWorldPos, currentWorldPos);
-        const autoPanCallbackData = {
-            points: {
-                currentPosition: {
-                    canvas: this.position,
-                    world: currentWorldPos,
-                },
-                newPosition: {
-                    canvas: newCanvasPosition,
-                    world: newWorldPos,
-                },
-            },
-            delta: {
-                canvas: canvasDeltaPos,
-                world: worldDeltaPos,
-            },
-        };
-        autoPan.callback(autoPanCallbackData);
-    }
-    _addBrowserEventListeners(element) {
-        document.addEventListener('mousedown', this._browserMouseDownCallback, true);
-        element.addEventListener('mousedown', this._cancelMouseEventCallback);
-        element.addEventListener('mouseup', this._cancelMouseEventCallback);
-        element.addEventListener('mousemove', this._cancelMouseEventCallback);
-        element.addEventListener('dblclick', this._cancelMouseEventCallback);
-    }
-    _removeBrowserEventListeners(element) {
-        document.removeEventListener('mousedown', this._browserMouseDownCallback, true);
-        document.removeEventListener('mouseup', this._browserMouseUpCallback);
-        element.removeEventListener('mousedown', this._cancelMouseEventCallback);
-        element.removeEventListener('mouseup', this._cancelMouseEventCallback);
-        element.removeEventListener('mousemove', this._cancelMouseEventCallback);
-        element.removeEventListener('dblclick', this._cancelMouseEventCallback);
-    }
-    _addEventListeners(element) {
-        eventTarget.addEventListener(cstEvents.TOOL_MODE_CHANGED, this._handleToolModeChanged);
-        element.addEventListener(cstEvents.MOUSE_MOVE, this._mouseDragCallback);
-        element.addEventListener(cstEvents.MOUSE_DRAG, this._mouseDragCallback);
-        this._addBrowserEventListeners(element);
-    }
-    _removeEventListeners(element) {
-        eventTarget.removeEventListener(cstEvents.TOOL_MODE_CHANGED, this._handleToolModeChanged);
-        element.addEventListener(cstEvents.MOUSE_MOVE, this._mouseDragCallback);
-        element.addEventListener(cstEvents.MOUSE_DRAG, this._mouseDragCallback);
-        this._removeBrowserEventListeners(element);
-    }
-    _initialize() {
-        const { _sourceEnabledElement: sourceEnabledElement } = this;
-        const { viewport: sourceViewport } = sourceEnabledElement;
-        const { canvas: sourceCanvas } = sourceViewport;
-        const magnifyElement = this._createViewportNode();
-        sourceCanvas.parentNode.appendChild(magnifyElement);
-        this._addEventListeners(magnifyElement);
-        this._cloneViewport(sourceViewport, magnifyElement);
-        this._enabledElement = getEnabledElement(magnifyElement);
-    }
-    _syncViewportsCameras(sourceViewport, magnifyViewport) {
-        const worldPos = sourceViewport.canvasToWorld(this.position);
-        const parallelScale = this._convertZoomFactorToParallelScale(sourceViewport, magnifyViewport, this.zoomFactor);
-        const { focalPoint, position, viewPlaneNormal } = magnifyViewport.getCamera();
-        const distance = Math.sqrt(Math.pow(focalPoint[0] - position[0], 2) +
-            Math.pow(focalPoint[1] - position[1], 2) +
-            Math.pow(focalPoint[2] - position[2], 2));
-        const updatedFocalPoint = [
-            worldPos[0],
-            worldPos[1],
-            worldPos[2],
-        ];
-        const updatedPosition = [
-            updatedFocalPoint[0] + distance * viewPlaneNormal[0],
-            updatedFocalPoint[1] + distance * viewPlaneNormal[1],
-            updatedFocalPoint[2] + distance * viewPlaneNormal[2],
-        ];
-        magnifyViewport.setCamera({
-            parallelScale,
-            focalPoint: updatedFocalPoint,
-            position: updatedPosition,
-        });
-    }
-    _syncStackViewports(sourceViewport, magnifyViewport) {
-        magnifyViewport.setImageIdIndex(sourceViewport.getCurrentImageIdIndex());
-    }
-    _syncViewports() {
-        const { viewport: sourceViewport } = this._sourceEnabledElement;
-        const { viewport: magnifyViewport } = this._enabledElement;
-        const sourceProperties = sourceViewport.getProperties();
-        const imageData = magnifyViewport.getImageData();
-        if (!imageData) {
-            return;
-        }
-        magnifyViewport.setProperties(sourceProperties);
-        this._syncViewportsCameras(sourceViewport, magnifyViewport);
-        if (this._isStackViewport(sourceViewport)) {
-            this._syncStackViewports(sourceViewport, magnifyViewport);
-        }
-        this._syncViewportsCameras(sourceViewport, magnifyViewport);
-        magnifyViewport.render();
-    }
-    _resizeViewport() {
-        const { viewport } = this._enabledElement;
-        const renderingEngine = viewport.getRenderingEngine();
-        renderingEngine.resize();
-    }
-}
-export { AdvancedMagnifyViewport as default, AdvancedMagnifyViewport };

package/dist/esm/tools/AdvancedMagnifyViewportManager.d.ts

@@ -1,38 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import type { AutoPanCallback } from './AdvancedMagnifyViewport';
-import { AdvancedMagnifyViewport } from './AdvancedMagnifyViewport';
-import type { AdvancedMagnifyAnnotation } from '../types/ToolSpecificAnnotationTypes';
-export type MagnifyViewportInfo = {
-    magnifyViewportId?: string;
-    sourceEnabledElement: Types.IEnabledElement;
-    position: Types.Point2;
-    radius: number;
-    zoomFactor: number;
-    autoPan: {
-        enabled: boolean;
-        padding: number;
-        callback: AutoPanCallback;
-    };
-};
-declare class AdvancedMagnifyViewportManager {
-    private static _singleton;
-    private _magnifyViewportsMap;
-    constructor();
-    static getInstance(): AdvancedMagnifyViewportManager;
-    createViewport: (annotation: AdvancedMagnifyAnnotation, viewportInfo: MagnifyViewportInfo) => AdvancedMagnifyViewport;
-    getViewport(magnifyViewportId: string): AdvancedMagnifyViewport;
-    dispose(): void;
-    destroyViewport(magnifyViewportId: string): void;
-    private _destroyViewports;
-    private _annotationRemovedCallback;
-    private _getMagnifyViewportsMapEntriesBySourceViewportId;
-    private _newStackImageCallback;
-    private _newVolumeImageCallback;
-    private _reset;
-    private _addEventListeners;
-    private _removeEventListeners;
-    private _addSourceElementEventListener;
-    private _removeSourceElementEventListener;
-    private _initialize;
-}
-export { AdvancedMagnifyViewportManager as default, AdvancedMagnifyViewportManager, };