@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/utilities/stackPrefetch/stackPrefetch.js

@@ -0,0 +1,150 @@
+import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, getConfiguration as getCoreConfiguration, } from '@cornerstonejs/core';
+import { addToolState, getToolState } from './state';
+import { getStackData, requestType, priority, getPromiseRemovedHandler, nearestIndex, range, } from './stackPrefetchUtils';
+let configuration = {
+    maxImagesToPrefetch: Infinity,
+    preserveExistingPool: true,
+};
+let resetPrefetchTimeout;
+const resetPrefetchDelay = 10;
+function prefetch(element) {
+    const stackPrefetchData = getToolState(element);
+    if (!stackPrefetchData) {
+        return;
+    }
+    const stackPrefetch = (stackPrefetchData || {});
+    const stack = getStackData(element);
+    if (!stack?.imageIds?.length) {
+        console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
+        return;
+    }
+    const { currentImageIdIndex } = stack;
+    stackPrefetch.enabled =
+        stackPrefetch.enabled && (stackPrefetch.indicesToRequest?.length ?? 0) > 0;
+    if (stackPrefetch.enabled === false) {
+        return;
+    }
+    function removeFromList(imageIdIndex) {
+        const index = stackPrefetch.indicesToRequest.indexOf(imageIdIndex);
+        if (index > -1) {
+            stackPrefetch.indicesToRequest.splice(index, 1);
+        }
+    }
+    stackPrefetchData.indicesToRequest.sort((a, b) => a - b);
+    const indicesToRequestCopy = stackPrefetch.indicesToRequest.slice();
+    indicesToRequestCopy.forEach(function (imageIdIndex) {
+        const imageId = stack.imageIds[imageIdIndex];
+        if (!imageId) {
+            return;
+        }
+        const distance = Math.abs(currentImageIdIndex - imageIdIndex);
+        const imageCached = distance < 6
+            ? cache.getImageLoadObject(imageId)
+            : cache.isLoaded(imageId);
+        if (imageCached) {
+            removeFromList(imageIdIndex);
+        }
+    });
+    if (!stackPrefetch.indicesToRequest.length) {
+        return;
+    }
+    if (!configuration.preserveExistingPool) {
+        imageLoadPoolManager.clearRequestStack(requestType);
+    }
+    const nearest = nearestIndex(stackPrefetch.indicesToRequest, stack.currentImageIdIndex);
+    let imageId;
+    let nextImageIdIndex;
+    const preventCache = false;
+    function doneCallback(image) {
+        console.log('prefetch done: %s', image.imageId);
+        const imageIdIndex = stack.imageIds.indexOf(image.imageId);
+        removeFromList(imageIdIndex);
+    }
+    let lowerIndex = nearest.low;
+    let higherIndex = nearest.high;
+    const imageIdsToPrefetch = [];
+    while (lowerIndex >= 0 ||
+        higherIndex < stackPrefetch.indicesToRequest.length) {
+        const currentIndex = stack.currentImageIdIndex;
+        const shouldSkipLower = currentIndex - stackPrefetch.indicesToRequest[lowerIndex] >
+            configuration.maxImagesToPrefetch;
+        const shouldSkipHigher = stackPrefetch.indicesToRequest[higherIndex] - currentIndex >
+            configuration.maxImagesToPrefetch;
+        const shouldLoadLower = !shouldSkipLower && lowerIndex >= 0;
+        const shouldLoadHigher = !shouldSkipHigher && higherIndex < stackPrefetch.indicesToRequest.length;
+        if (!shouldLoadHigher && !shouldLoadLower) {
+            break;
+        }
+        if (shouldLoadLower) {
+            nextImageIdIndex = stackPrefetch.indicesToRequest[lowerIndex--];
+            imageId = stack.imageIds[nextImageIdIndex];
+            imageIdsToPrefetch.push(imageId);
+        }
+        if (shouldLoadHigher) {
+            nextImageIdIndex = stackPrefetch.indicesToRequest[higherIndex++];
+            imageId = stack.imageIds[nextImageIdIndex];
+            imageIdsToPrefetch.push(imageId);
+        }
+    }
+    const requestFn = (imageId, options) => imageLoader.loadAndCacheImage(imageId, options);
+    imageIdsToPrefetch.forEach((imageId) => {
+        const options = {
+            requestType,
+        };
+        imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {
+            imageId,
+        }, priority);
+    });
+}
+function onImageUpdated(e) {
+    clearTimeout(resetPrefetchTimeout);
+    resetPrefetchTimeout = setTimeout(function () {
+        const element = e.target;
+        try {
+            prefetch(element);
+        }
+        catch (error) {
+            return;
+        }
+    }, resetPrefetchDelay);
+}
+function enable(element) {
+    const stack = getStackData(element);
+    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+        console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
+        return;
+    }
+    const stackPrefetchData = {
+        indicesToRequest: range(0, stack.imageIds.length - 1),
+        enabled: true,
+        direction: 1,
+    };
+    const indexOfCurrentImage = stackPrefetchData.indicesToRequest.indexOf(stack.currentImageIdIndex);
+    stackPrefetchData.indicesToRequest.splice(indexOfCurrentImage, 1);
+    addToolState(element, stackPrefetchData);
+    prefetch(element);
+    element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, onImageUpdated);
+    element.addEventListener(Enums.Events.STACK_NEW_IMAGE, onImageUpdated);
+    const promiseRemovedHandler = getPromiseRemovedHandler(element);
+    eventTarget.removeEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
+    eventTarget.addEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
+}
+function disable(element) {
+    clearTimeout(resetPrefetchTimeout);
+    element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, onImageUpdated);
+    const promiseRemovedHandler = getPromiseRemovedHandler(element);
+    eventTarget.removeEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
+    const stackPrefetchData = getToolState(element);
+    if (stackPrefetchData && stackPrefetchData.indicesToRequest.length) {
+        stackPrefetchData.enabled = false;
+        imageLoadPoolManager.clearRequestStack(requestType);
+    }
+}
+function getConfiguration() {
+    return configuration;
+}
+function setConfiguration(config) {
+    configuration = config;
+}
+const stackPrefetch = { enable, disable, getConfiguration, setConfiguration };
+export default stackPrefetch;

package/dist/esm/utilities/stackPrefetch/stackPrefetchUtils.d.ts

@@ -0,0 +1,14 @@
+import { Enums } from '@cornerstonejs/core';
+export declare const requestType = Enums.RequestType.Prefetch;
+export declare const priority = 0;
+export declare function range(lowEnd: any, highEnd: any): any[];
+export declare function nearestIndex(arr: any, x: any): {
+    low: number;
+    high: number;
+};
+export declare function getStackData(element: any): {
+    currentImageIdIndex: number;
+    imageIds: string[];
+};
+export declare function getPromiseRemovedHandler(element: any): (e: any) => void;
+export declare const clearFromImageIds: (stack: any) => (requestDetails: any) => boolean;

package/dist/esm/utilities/stackPrefetch/stackPrefetchUtils.js

@@ -0,0 +1,76 @@
+import { getEnabledElement, StackViewport, Enums } from '@cornerstonejs/core';
+import { getToolState } from './state';
+export const requestType = Enums.RequestType.Prefetch;
+export const priority = 0;
+export function range(lowEnd, highEnd) {
+    lowEnd = Math.round(lowEnd) || 0;
+    highEnd = Math.round(highEnd) || 0;
+    const arr = [];
+    let c = highEnd - lowEnd + 1;
+    if (c <= 0) {
+        return arr;
+    }
+    while (c--) {
+        arr[c] = highEnd--;
+    }
+    return arr;
+}
+export function nearestIndex(arr, x) {
+    let low = 0;
+    let high = arr.length - 1;
+    arr.forEach((v, idx) => {
+        if (v < x) {
+            low = Math.max(idx, low);
+        }
+        else if (v > x) {
+            high = Math.min(idx, high);
+        }
+    });
+    return { low, high };
+}
+export function getStackData(element) {
+    const enabledElement = getEnabledElement(element);
+    if (!enabledElement) {
+        return null;
+    }
+    const { viewport } = enabledElement;
+    if (!(viewport instanceof StackViewport)) {
+        return null;
+    }
+    return {
+        currentImageIdIndex: viewport.getCurrentImageIdIndex(),
+        imageIds: viewport.getImageIds(),
+    };
+}
+export function getPromiseRemovedHandler(element) {
+    return function (e) {
+        const eventData = e.detail;
+        let stackData;
+        try {
+            stackData = getStackData(element);
+        }
+        catch (error) {
+            return;
+        }
+        if (!stackData || !stackData.imageIds || stackData.imageIds.length === 0) {
+            return;
+        }
+        const stack = stackData;
+        const imageIdIndex = stack.imageIds.indexOf(eventData.imageId);
+        if (imageIdIndex < 0) {
+            return;
+        }
+        const stackPrefetchData = getToolState(element);
+        if (!stackPrefetchData ||
+            !stackPrefetchData.indicesToRequest ||
+            !stackPrefetchData.indicesToRequest.length) {
+            return;
+        }
+        stackPrefetchData.indicesToRequest.push(imageIdIndex);
+    };
+}
+export const clearFromImageIds = (stack) => {
+    const imageIdSet = new Set(stack.imageIds);
+    return (requestDetails) => requestDetails.type !== requestType ||
+        !imageIdSet.has(requestDetails.additionalDetails.imageId);
+};

package/dist/esm/utilities/stackPrefetch/state.d.ts

@@ -0,0 +1,22 @@
+export interface StackPrefetchData {
+    indicesToRequest: number[];
+    currentImageIdIndex: number;
+    stackCount: number;
+    enabled: boolean;
+    direction: number;
+    cacheFill?: boolean;
+    stats: {
+        start: number;
+        imageIds: Map<string, number>;
+        decodeTimeInMS: number;
+        loadTimeInMS: number;
+        totalBytes: number;
+        initialTime?: number;
+        initialSize?: number;
+        fillTime?: number;
+        fillSize?: number;
+    };
+}
+declare function addToolState(element: HTMLDivElement, data: any): void;
+declare function getToolState(element: HTMLDivElement): StackPrefetchData;
+export { addToolState, getToolState };

package/dist/esm/utilities/stackPrefetch/state.js

@@ -0,0 +1,13 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+const state = {};
+function addToolState(element, data) {
+    const enabledElement = getEnabledElement(element);
+    const { viewportId } = enabledElement;
+    state[viewportId] = data;
+}
+function getToolState(element) {
+    const enabledElement = getEnabledElement(element);
+    const { viewportId } = enabledElement;
+    return state[viewportId];
+}
+export { addToolState, getToolState };

package/dist/esm/utilities/throttle.d.ts

@@ -0,0 +1,5 @@
+export default throttle;
+declare function throttle(func: Function, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): Function;

package/dist/esm/utilities/throttle.js

@@ -0,0 +1,19 @@
+import debounce from './debounce';
+import isObject from './isObject';
+function throttle(func, wait, options) {
+    let leading = true;
+    let trailing = true;
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    if (isObject(options)) {
+        leading = 'leading' in options ? Boolean(options.leading) : leading;
+        trailing = 'trailing' in options ? Boolean(options.trailing) : trailing;
+    }
+    return debounce(func, wait, {
+        leading,
+        trailing,
+        maxWait: wait,
+    });
+}
+export default throttle;

package/dist/esm/utilities/touch/index.d.ts

@@ -0,0 +1,10 @@
+import type { IDistance, IPoints, ITouchPoints } from '../../types';
+declare function getDeltaPoints(currentPoints: IPoints[], lastPoints: IPoints[]): IPoints;
+declare function getDeltaDistance(currentPoints: IPoints[], lastPoints: IPoints[]): IDistance;
+declare function getDeltaRotation(currentPoints: ITouchPoints[], lastPoints: ITouchPoints[]): void;
+declare function getDeltaDistanceBetweenIPoints(currentPoints: IPoints[], lastPoints: IPoints[]): IDistance;
+declare function copyPointsList(points: ITouchPoints[]): ITouchPoints[];
+declare function copyPoints(points: ITouchPoints): ITouchPoints;
+declare function getMeanPoints(points: IPoints[]): IPoints;
+declare function getMeanTouchPoints(points: ITouchPoints[]): ITouchPoints;
+export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, };

package/dist/esm/utilities/touch/index.js

@@ -0,0 +1,152 @@
+function getDeltaPoints(currentPoints, lastPoints) {
+    const curr = getMeanPoints(currentPoints);
+    const last = getMeanPoints(lastPoints);
+    return {
+        page: _subtractPoints2D(curr.page, last.page),
+        client: _subtractPoints2D(curr.client, last.client),
+        canvas: _subtractPoints2D(curr.canvas, last.canvas),
+        world: _subtractPoints3D(curr.world, last.world),
+    };
+}
+function getDeltaDistance(currentPoints, lastPoints) {
+    const curr = getMeanPoints(currentPoints);
+    const last = getMeanPoints(lastPoints);
+    return {
+        page: _getDistance2D(curr.page, last.page),
+        client: _getDistance2D(curr.client, last.client),
+        canvas: _getDistance2D(curr.canvas, last.canvas),
+        world: _getDistance3D(curr.world, last.world),
+    };
+}
+function getDeltaRotation(currentPoints, lastPoints) {
+}
+function getDeltaDistanceBetweenIPoints(currentPoints, lastPoints) {
+    const currentDistance = _getMeanDistanceBetweenAllIPoints(currentPoints);
+    const lastDistance = _getMeanDistanceBetweenAllIPoints(lastPoints);
+    const deltaDistance = {
+        page: currentDistance.page - lastDistance.page,
+        client: currentDistance.client - lastDistance.client,
+        canvas: currentDistance.canvas - lastDistance.canvas,
+        world: currentDistance.world - lastDistance.world,
+    };
+    return deltaDistance;
+}
+function copyPointsList(points) {
+    return JSON.parse(JSON.stringify(points));
+}
+function copyPoints(points) {
+    return JSON.parse(JSON.stringify(points));
+}
+function getMeanPoints(points) {
+    return points.reduce((prev, curr) => {
+        return {
+            page: [
+                prev.page[0] + curr.page[0] / points.length,
+                prev.page[1] + curr.page[1] / points.length,
+            ],
+            client: [
+                prev.client[0] + curr.client[0] / points.length,
+                prev.client[1] + curr.client[1] / points.length,
+            ],
+            canvas: [
+                prev.canvas[0] + curr.canvas[0] / points.length,
+                prev.canvas[1] + curr.canvas[1] / points.length,
+            ],
+            world: [
+                prev.world[0] + curr.world[0] / points.length,
+                prev.world[1] + curr.world[1] / points.length,
+                prev.world[2] + curr.world[2] / points.length,
+            ],
+        };
+    }, {
+        page: [0, 0],
+        client: [0, 0],
+        canvas: [0, 0],
+        world: [0, 0, 0],
+    });
+}
+function getMeanTouchPoints(points) {
+    return points.reduce((prev, curr) => {
+        return {
+            page: [
+                prev.page[0] + curr.page[0] / points.length,
+                prev.page[1] + curr.page[1] / points.length,
+            ],
+            client: [
+                prev.client[0] + curr.client[0] / points.length,
+                prev.client[1] + curr.client[1] / points.length,
+            ],
+            canvas: [
+                prev.canvas[0] + curr.canvas[0] / points.length,
+                prev.canvas[1] + curr.canvas[1] / points.length,
+            ],
+            world: [
+                prev.world[0] + curr.world[0] / points.length,
+                prev.world[1] + curr.world[1] / points.length,
+                prev.world[2] + curr.world[2] / points.length,
+            ],
+            touch: {
+                identifier: null,
+                radiusX: prev.touch.radiusX + curr.touch.radiusX / points.length,
+                radiusY: prev.touch.radiusY + curr.touch.radiusY / points.length,
+                force: prev.touch.force + curr.touch.force / points.length,
+                rotationAngle: prev.touch.rotationAngle + curr.touch.rotationAngle / points.length,
+            },
+        };
+    }, {
+        page: [0, 0],
+        client: [0, 0],
+        canvas: [0, 0],
+        world: [0, 0, 0],
+        touch: {
+            identifier: null,
+            radiusX: 0,
+            radiusY: 0,
+            force: 0,
+            rotationAngle: 0,
+        },
+    });
+}
+function _subtractPoints2D(point0, point1) {
+    return [point0[0] - point1[0], point0[1] - point1[1]];
+}
+function _subtractPoints3D(point0, point1) {
+    return [point0[0] - point1[0], point0[1] - point1[1], point0[2] - point1[2]];
+}
+function _getMeanDistanceBetweenAllIPoints(points) {
+    const pairedDistance = [];
+    for (let i = 0; i < points.length; i++) {
+        for (let j = 0; j < points.length; j++) {
+            if (i < j) {
+                pairedDistance.push({
+                    page: _getDistance2D(points[i].page, points[j].page),
+                    client: _getDistance2D(points[i].client, points[j].client),
+                    canvas: _getDistance2D(points[i].canvas, points[j].canvas),
+                    world: _getDistance3D(points[i].world, points[j].world),
+                });
+            }
+        }
+    }
+    return pairedDistance.reduce((prev, curr) => {
+        return {
+            page: prev.page + curr.page / pairedDistance.length,
+            client: prev.client + curr.client / pairedDistance.length,
+            canvas: prev.canvas + curr.canvas / pairedDistance.length,
+            world: prev.world + curr.world / pairedDistance.length,
+        };
+    }, {
+        page: 0,
+        client: 0,
+        canvas: 0,
+        world: 0,
+    });
+}
+function _getDistance2D(point0, point1) {
+    return Math.sqrt(Math.pow(point0[0] - point1[0], 2) + Math.pow(point0[1] - point1[1], 2));
+}
+function _getDistance3D(point0, point1) {
+    return Math.sqrt(Math.pow(point0[0] - point1[0], 2) +
+        Math.pow(point0[1] - point1[1], 2) +
+        Math.pow(point0[2] - point1[2], 2));
+}
+export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, };

package/dist/esm/utilities/triggerAnnotationRender.d.ts

@@ -0,0 +1,2 @@
+declare function triggerAnnotationRender(element: HTMLDivElement): void;
+export default triggerAnnotationRender;

package/dist/esm/utilities/triggerAnnotationRender.js

@@ -0,0 +1,5 @@
+import { annotationRenderingEngine } from '../stateManagement/annotation/AnnotationRenderingEngine';
+function triggerAnnotationRender(element) {
+    annotationRenderingEngine.renderViewport(element);
+}
+export default triggerAnnotationRender;

package/dist/esm/utilities/triggerAnnotationRenderForToolGroupIds.d.ts

@@ -0,0 +1,2 @@
+export declare function triggerAnnotationRenderForToolGroupIds(toolGroupIds: string[]): void;
+export default triggerAnnotationRenderForToolGroupIds;

package/dist/esm/utilities/triggerAnnotationRenderForToolGroupIds.js

@@ -0,0 +1,24 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+import triggerAnnotationRender from './triggerAnnotationRender';
+import { getToolGroup } from '../store/ToolGroupManager';
+export function triggerAnnotationRenderForToolGroupIds(toolGroupIds) {
+    toolGroupIds.forEach((toolGroupId) => {
+        const toolGroup = getToolGroup(toolGroupId);
+        if (!toolGroup) {
+            console.warn(`ToolGroup not available for ${toolGroupId}`);
+            return;
+        }
+        const viewportsInfo = toolGroup.getViewportsInfo();
+        viewportsInfo.forEach((viewportInfo) => {
+            const { renderingEngineId, viewportId } = viewportInfo;
+            const renderingEngine = getRenderingEngine(renderingEngineId);
+            if (!renderingEngine) {
+                console.warn(`RenderingEngine not available for ${renderingEngineId}`);
+                return;
+            }
+            const viewport = renderingEngine.getViewport(viewportId);
+            triggerAnnotationRender(viewport.element);
+        });
+    });
+}
+export default triggerAnnotationRenderForToolGroupIds;

package/dist/esm/utilities/triggerAnnotationRenderForViewportIds.d.ts

@@ -0,0 +1,2 @@
+export declare function triggerAnnotationRenderForViewportIds(viewportIdsToRender: string[]): void;
+export default triggerAnnotationRenderForViewportIds;

package/dist/esm/utilities/triggerAnnotationRenderForViewportIds.js

@@ -0,0 +1,22 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import triggerAnnotationRender from './triggerAnnotationRender';
+export function triggerAnnotationRenderForViewportIds(viewportIdsToRender) {
+    if (!viewportIdsToRender.length) {
+        return;
+    }
+    viewportIdsToRender.forEach((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.element;
+        triggerAnnotationRender(element);
+    });
+}
+export default triggerAnnotationRenderForViewportIds;

package/dist/esm/utilities/viewport/index.d.ts

@@ -0,0 +1,2 @@
+import { isViewportPreScaled } from './isViewportPreScaled';
+export { isViewportPreScaled };

package/dist/esm/utilities/viewport/index.js

@@ -0,0 +1,2 @@
+import { isViewportPreScaled } from './isViewportPreScaled';
+export { isViewportPreScaled };

package/dist/esm/utilities/viewport/isViewportPreScaled.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function isViewportPreScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string): boolean;
+export { isViewportPreScaled };

package/dist/esm/utilities/viewport/isViewportPreScaled.js

@@ -0,0 +1,16 @@
+import { cache, StackViewport, BaseVolumeViewport, utilities, } from '@cornerstonejs/core';
+function isViewportPreScaled(viewport, targetId) {
+    if (viewport instanceof BaseVolumeViewport) {
+        const volumeId = utilities.getVolumeId(targetId);
+        const volume = cache.getVolume(volumeId);
+        return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
+    }
+    else if (viewport instanceof StackViewport) {
+        const { preScale } = viewport.getImageData() || {};
+        return !!preScale?.scaled;
+    }
+    else {
+        return false;
+    }
+}
+export { isViewportPreScaled };

package/dist/esm/utilities/viewportFilters/filterViewportsWithFrameOfReferenceUID.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function filterViewportsWithFrameOfReferenceUID(viewports: Array<Types.IViewport>, FrameOfReferenceUID: string): Array<Types.IStackViewport | Types.IVolumeViewport>;

package/dist/esm/utilities/viewportFilters/filterViewportsWithFrameOfReferenceUID.js

@@ -0,0 +1,11 @@
+export default function filterViewportsWithFrameOfReferenceUID(viewports, FrameOfReferenceUID) {
+    const numViewports = viewports.length;
+    const viewportsWithFrameOfReferenceUID = [];
+    for (let vp = 0; vp < numViewports; vp++) {
+        const viewport = viewports[vp];
+        if (viewport.getFrameOfReferenceUID() === FrameOfReferenceUID) {
+            viewportsWithFrameOfReferenceUID.push(viewport);
+        }
+    }
+    return viewportsWithFrameOfReferenceUID;
+}

package/dist/esm/utilities/viewportFilters/filterViewportsWithParallelNormals.d.ts

@@ -0,0 +1,2 @@
+export declare function filterViewportsWithParallelNormals(viewports: any, camera: any, EPS?: number): any;
+export default filterViewportsWithParallelNormals;

package/dist/esm/utilities/viewportFilters/filterViewportsWithParallelNormals.js

@@ -0,0 +1,10 @@
+import { vec3 } from 'gl-matrix';
+export function filterViewportsWithParallelNormals(viewports, camera, EPS = 0.999) {
+    return viewports.filter((viewport) => {
+        const vpCamera = viewport.getCamera();
+        const isParallel = Math.abs(vec3.dot(vpCamera.viewPlaneNormal, camera.viewPlaneNormal)) >
+            EPS;
+        return isParallel;
+    });
+}
+export default filterViewportsWithParallelNormals;

package/dist/esm/utilities/viewportFilters/filterViewportsWithSameOrientation.d.ts

@@ -0,0 +1,2 @@
+export declare function filterViewportsWithSameOrientation(viewports: any, camera: any): any;
+export default filterViewportsWithSameOrientation;

package/dist/esm/utilities/viewportFilters/filterViewportsWithSameOrientation.js

@@ -0,0 +1,9 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+export function filterViewportsWithSameOrientation(viewports, camera) {
+    return viewports.filter((viewport) => {
+        const vpCamera = viewport.getCamera();
+        return (csUtils.isEqual(vpCamera.viewPlaneNormal, camera.viewPlaneNormal) &&
+            csUtils.isEqual(vpCamera.viewUp, camera.viewUp));
+    });
+}
+export default filterViewportsWithSameOrientation;

package/dist/esm/utilities/viewportFilters/filterViewportsWithToolEnabled.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function filterViewportsWithToolEnabled(viewports: Array<Types.IViewport>, toolName: string): Array<Types.IStackViewport | Types.IVolumeViewport>;

package/dist/esm/utilities/viewportFilters/filterViewportsWithToolEnabled.js

@@ -0,0 +1,28 @@
+import { ToolModes } from '../../enums';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+const { Active, Passive, Enabled } = ToolModes;
+export default function filterViewportsWithToolEnabled(viewports, toolName) {
+    const numViewports = viewports.length;
+    const viewportsWithToolEnabled = [];
+    for (let vp = 0; vp < numViewports; vp++) {
+        const viewport = viewports[vp];
+        const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
+        if (!toolGroup) {
+            continue;
+        }
+        const hasTool = _toolGroupHasActiveEnabledOrPassiveTool(toolGroup, toolName);
+        if (hasTool) {
+            viewportsWithToolEnabled.push(viewport);
+        }
+    }
+    return viewportsWithToolEnabled;
+}
+function _toolGroupHasActiveEnabledOrPassiveTool(toolGroup, toolName) {
+    const { toolOptions } = toolGroup;
+    const tool = toolOptions[toolName];
+    if (!tool) {
+        return false;
+    }
+    const toolMode = tool.mode;
+    return toolMode === Active || toolMode === Passive || toolMode === Enabled;
+}

package/dist/esm/utilities/viewportFilters/getViewportIdsWithToolToRender.d.ts

@@ -0,0 +1 @@
+export default function getViewportIdsWithToolToRender(element: HTMLDivElement, toolName: string, requireParallelNormals?: boolean): string[];