@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/tools/AdvancedMagnifyViewportManager.js

@@ -1,161 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { eventTarget, Enums, getRenderingEngine, CONSTANTS, getEnabledElementByViewportId, } from '@cornerstonejs/core';
-import { Events as cstEvents } from '../enums';
-import { AdvancedMagnifyViewport, } from './AdvancedMagnifyViewport';
-const ADVANCED_MAGNIFY_TOOL_NAME = 'AdvancedMagnify';
-const PARALLEL_THRESHOLD = 1 - CONSTANTS.EPSILON;
-const { Events } = Enums;
-class AdvancedMagnifyViewportManager {
-    constructor() {
-        this.createViewport = (annotation, viewportInfo) => {
-            const { magnifyViewportId, sourceEnabledElement, position, radius, zoomFactor, autoPan, } = viewportInfo;
-            const { viewport: sourceViewport } = sourceEnabledElement;
-            const { element: sourceElement } = sourceViewport;
-            const magnifyViewport = new AdvancedMagnifyViewport({
-                magnifyViewportId,
-                sourceEnabledElement,
-                radius,
-                position,
-                zoomFactor,
-                autoPan,
-            });
-            this._addSourceElementEventListener(sourceElement);
-            this._magnifyViewportsMap.set(magnifyViewport.viewportId, {
-                annotation,
-                magnifyViewport,
-                magnifyViewportInfo: viewportInfo,
-            });
-            return magnifyViewport;
-        };
-        this._annotationRemovedCallback = (evt) => {
-            const { annotation } = evt.detail;
-            if (annotation.metadata.toolName !== ADVANCED_MAGNIFY_TOOL_NAME) {
-                return;
-            }
-            this.destroyViewport(annotation.data.magnifyViewportId);
-        };
-        this._newStackImageCallback = (evt) => {
-            const { viewportId: sourceViewportId, imageId } = evt.detail;
-            const magnifyViewportsMapEntries = this._getMagnifyViewportsMapEntriesBySourceViewportId(sourceViewportId);
-            const { viewport } = getEnabledElementByViewportId(sourceViewportId);
-            if (viewport.stackActorReInitialized) {
-                this._reset(sourceViewportId);
-            }
-            magnifyViewportsMapEntries.forEach(({ annotation }) => {
-                annotation.metadata.referencedImageId = imageId;
-                annotation.invalidated = true;
-            });
-        };
-        this._newVolumeImageCallback = (evt) => {
-            const { renderingEngineId, viewportId: sourceViewportId } = evt.detail;
-            const renderingEngine = getRenderingEngine(renderingEngineId);
-            const sourceViewport = renderingEngine.getViewport(sourceViewportId);
-            const { viewPlaneNormal: currentViewPlaneNormal } = sourceViewport.getCamera();
-            const magnifyViewportsMapEntries = this._getMagnifyViewportsMapEntriesBySourceViewportId(sourceViewportId);
-            magnifyViewportsMapEntries.forEach(({ annotation }) => {
-                const { viewPlaneNormal } = annotation.metadata;
-                const isParallel = Math.abs(vec3.dot(viewPlaneNormal, currentViewPlaneNormal)) >
-                    PARALLEL_THRESHOLD;
-                if (!isParallel) {
-                    return;
-                }
-                const { handles } = annotation.data;
-                const worldImagePlanePoint = sourceViewport.canvasToWorld([0, 0]);
-                const vecHandleToImagePlane = vec3.sub(vec3.create(), worldImagePlanePoint, handles.points[0]);
-                const worldDist = vec3.dot(vecHandleToImagePlane, currentViewPlaneNormal);
-                const worldDelta = vec3.scale(vec3.create(), currentViewPlaneNormal, worldDist);
-                for (let i = 0, len = handles.points.length; i < len; i++) {
-                    const point = handles.points[i];
-                    point[0] += worldDelta[0];
-                    point[1] += worldDelta[1];
-                    point[2] += worldDelta[2];
-                }
-                annotation.invalidated = true;
-            });
-        };
-        this._magnifyViewportsMap = new Map();
-        this._initialize();
-    }
-    static getInstance() {
-        AdvancedMagnifyViewportManager._singleton =
-            AdvancedMagnifyViewportManager._singleton ??
-                new AdvancedMagnifyViewportManager();
-        return AdvancedMagnifyViewportManager._singleton;
-    }
-    getViewport(magnifyViewportId) {
-        return this._magnifyViewportsMap.get(magnifyViewportId)?.magnifyViewport;
-    }
-    dispose() {
-        this._removeEventListeners();
-        this._destroyViewports();
-    }
-    destroyViewport(magnifyViewportId) {
-        const magnifyViewportMapEntry = this._magnifyViewportsMap.get(magnifyViewportId);
-        if (magnifyViewportMapEntry) {
-            const { magnifyViewport } = magnifyViewportMapEntry;
-            const { viewport: sourceViewport } = magnifyViewport.sourceEnabledElement;
-            const { element: sourceElement } = sourceViewport;
-            this._removeSourceElementEventListener(sourceElement);
-            magnifyViewport.dispose();
-            this._magnifyViewportsMap.delete(magnifyViewportId);
-        }
-    }
-    _destroyViewports() {
-        const magnifyViewportIds = Array.from(this._magnifyViewportsMap.keys());
-        magnifyViewportIds.forEach((magnifyViewportId) => this.destroyViewport(magnifyViewportId));
-    }
-    _getMagnifyViewportsMapEntriesBySourceViewportId(sourceViewportId) {
-        const magnifyViewportsMapEntries = Array.from(this._magnifyViewportsMap.values());
-        return magnifyViewportsMapEntries.filter(({ magnifyViewport }) => {
-            const { viewport } = magnifyViewport.sourceEnabledElement;
-            return viewport.id === sourceViewportId;
-        });
-    }
-    _reset(sourceViewportId) {
-        const magnifyViewports = this._getMagnifyViewportsMapEntriesBySourceViewportId(sourceViewportId);
-        magnifyViewports.forEach(({ magnifyViewport, annotation, magnifyViewportInfo }) => {
-            this.destroyViewport(magnifyViewport.viewportId);
-            const newEnabledElement = getEnabledElementByViewportId(sourceViewportId);
-            this.createViewport(annotation, {
-                ...magnifyViewportInfo,
-                sourceEnabledElement: {
-                    ...newEnabledElement,
-                },
-            });
-        });
-    }
-    _addEventListeners() {
-        eventTarget.addEventListener(cstEvents.ANNOTATION_REMOVED, this._annotationRemovedCallback);
-    }
-    _removeEventListeners() {
-        eventTarget.removeEventListener(cstEvents.ANNOTATION_REMOVED, this._annotationRemovedCallback);
-    }
-    _addSourceElementEventListener(element) {
-        element.addEventListener(Events.STACK_NEW_IMAGE, this._newStackImageCallback);
-        const newStackHandler = (evt) => {
-            const { viewportId: sourceViewportId } = evt.detail;
-            this._reset(sourceViewportId);
-        };
-        element.addEventListener(Events.STACK_VIEWPORT_NEW_STACK, newStackHandler);
-        const newVolumeHandler = (evt) => {
-            const { viewportId: sourceViewportId } = evt.detail;
-            this._reset(sourceViewportId);
-        };
-        element.addEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, newVolumeHandler);
-        element.addEventListener(Events.VOLUME_NEW_IMAGE, this._newVolumeImageCallback);
-        element.newStackHandler = newStackHandler;
-        element.newVolumeHandler = newVolumeHandler;
-    }
-    _removeSourceElementEventListener(element) {
-        element.removeEventListener(Events.STACK_NEW_IMAGE, this._newStackImageCallback);
-        element.removeEventListener(Events.VOLUME_NEW_IMAGE, this._newVolumeImageCallback);
-        element.removeEventListener(Events.STACK_VIEWPORT_NEW_STACK, element.newStackHandler);
-        element.removeEventListener(Events.VOLUME_VIEWPORT_NEW_VOLUME, element.newVolumeHandler);
-        delete element.newStackHandler;
-        delete element.newVolumeHandler;
-    }
-    _initialize() {
-        this._addEventListeners();
-    }
-}
-export { AdvancedMagnifyViewportManager as default, AdvancedMagnifyViewportManager, };

package/dist/esm/utilities/contours/interpolation/index.d.ts

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

package/dist/esm/utilities/contours/interpolation/index.js

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

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

@@ -1,18 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import type { Types } from '@cornerstonejs/core';
-import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
-import BoundsIJK from '../types/BoundsIJK';
-export type PointInShape = {
-    value: number;
-    index: number;
-    pointIJK: vec3;
-    pointLPS: vec3 | number[];
-};
-export type PointInShapeCallback = ({ value, index, pointIJK, pointLPS, }: {
-    value: number;
-    index: number;
-    pointIJK: vec3;
-    pointLPS: vec3;
-}) => void;
-export type ShapeFnCriteria = (pointLPS: vec3, pointIJK: vec3) => boolean;
-export default function pointInShapeCallback(imageData: vtkImageData | Types.CPUImageData, pointInShapeFn: ShapeFnCriteria, callback?: PointInShapeCallback, boundsIJK?: BoundsIJK): Array<PointInShape>;

package/dist/esm/utilities/pointInShapeCallback.js

@@ -1,82 +0,0 @@
-import { vec3 } from 'gl-matrix';
-export default function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
-    let iMin, iMax, jMin, jMax, kMin, kMax;
-    let scalarData;
-    const { numComps } = imageData;
-    if (imageData.getScalarData) {
-        scalarData = imageData.getScalarData();
-    }
-    else {
-        scalarData = imageData
-            .getPointData()
-            .getScalars()
-            .getData();
-    }
-    const dimensions = imageData.getDimensions();
-    if (!boundsIJK) {
-        iMin = 0;
-        iMax = dimensions[0];
-        jMin = 0;
-        jMax = dimensions[1];
-        kMin = 0;
-        kMax = dimensions[2];
-    }
-    else {
-        [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = boundsIJK;
-    }
-    const start = vec3.fromValues(iMin, jMin, kMin);
-    const direction = imageData.getDirection();
-    const rowCosines = direction.slice(0, 3);
-    const columnCosines = direction.slice(3, 6);
-    const scanAxisNormal = direction.slice(6, 9);
-    const spacing = imageData.getSpacing();
-    const [rowSpacing, columnSpacing, scanAxisSpacing] = spacing;
-    const worldPosStart = imageData.indexToWorld(start);
-    const rowStep = vec3.fromValues(rowCosines[0] * rowSpacing, rowCosines[1] * rowSpacing, rowCosines[2] * rowSpacing);
-    const columnStep = vec3.fromValues(columnCosines[0] * columnSpacing, columnCosines[1] * columnSpacing, columnCosines[2] * columnSpacing);
-    const scanAxisStep = vec3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
-    const xMultiple = numComps ||
-        scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
-    const yMultiple = dimensions[0] * xMultiple;
-    const zMultiple = dimensions[1] * yMultiple;
-    const pointsInShape = [];
-    const currentPos = vec3.clone(worldPosStart);
-    for (let k = kMin; k <= kMax; k++) {
-        const startPosJ = vec3.clone(currentPos);
-        for (let j = jMin; j <= jMax; j++) {
-            const startPosI = vec3.clone(currentPos);
-            for (let i = iMin; i <= iMax; i++) {
-                const pointIJK = [i, j, k];
-                if (pointInShapeFn(currentPos, pointIJK)) {
-                    const index = k * zMultiple + j * yMultiple + i * xMultiple;
-                    let value;
-                    if (xMultiple > 2) {
-                        value = [
-                            scalarData[index],
-                            scalarData[index + 1],
-                            scalarData[index + 2],
-                        ];
-                    }
-                    else {
-                        value = scalarData[index];
-                    }
-                    pointsInShape.push({
-                        value,
-                        index,
-                        pointIJK,
-                        pointLPS: currentPos.slice(),
-                    });
-                    if (callback) {
-                        callback({ value, index, pointIJK, pointLPS: currentPos });
-                    }
-                }
-                vec3.add(currentPos, currentPos, rowStep);
-            }
-            vec3.copy(currentPos, startPosI);
-            vec3.add(currentPos, currentPos, columnStep);
-        }
-        vec3.copy(currentPos, startPosJ);
-        vec3.add(currentPos, currentPos, scanAxisStep);
-    }
-    return pointsInShape;
-}

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

@@ -1,4 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { PointInShapeCallback } from './pointInShapeCallback';
-export default function pointInSurroundingSphereCallback(imageData: vtkImageData, circlePoints: [Types.Point3, Types.Point3], callback: PointInShapeCallback, viewport?: Types.IVolumeViewport): void;

package/dist/esm/utilities/pointInSurroundingSphereCallback.js

@@ -1,63 +0,0 @@
-import { utilities as csUtils } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
-import { pointInSphere } from './math/sphere';
-import pointInShapeCallback from './pointInShapeCallback';
-import { getBoundingBoxAroundShape } from './boundingBox';
-const { transformWorldToIndex } = csUtils;
-export default function pointInSurroundingSphereCallback(imageData, circlePoints, callback, viewport) {
-    const { boundsIJK, centerWorld, radiusWorld } = _getBounds(circlePoints, imageData, viewport);
-    const sphereObj = {
-        center: centerWorld,
-        radius: radiusWorld,
-    };
-    pointInShapeCallback(imageData, (pointLPS) => pointInSphere(sphereObj, pointLPS), callback, boundsIJK);
-}
-function _getBounds(circlePoints, imageData, viewport) {
-    const [bottom, top] = circlePoints;
-    const centerWorld = vec3.fromValues((bottom[0] + top[0]) / 2, (bottom[1] + top[1]) / 2, (bottom[2] + top[2]) / 2);
-    const radiusWorld = vec3.distance(bottom, top) / 2;
-    let boundsIJK;
-    if (!viewport) {
-        const centerIJK = transformWorldToIndex(imageData, centerWorld);
-        const spacings = imageData.getSpacing();
-        const minSpacing = Math.min(...spacings);
-        const maxRadiusIJK = Math.ceil(radiusWorld / minSpacing);
-        boundsIJK = [
-            [centerIJK[0] - maxRadiusIJK, centerIJK[0] + maxRadiusIJK],
-            [centerIJK[1] - maxRadiusIJK, centerIJK[1] + maxRadiusIJK],
-            [centerIJK[2] - maxRadiusIJK, centerIJK[2] + maxRadiusIJK],
-        ];
-        return {
-            boundsIJK,
-            centerWorld: centerWorld,
-            radiusWorld,
-        };
-    }
-    boundsIJK = _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld);
-    return {
-        boundsIJK,
-        centerWorld: centerWorld,
-        radiusWorld,
-    };
-}
-function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld) {
-    const [bottom, top] = circlePoints;
-    const dimensions = imageData.getDimensions();
-    const camera = viewport.getCamera();
-    const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
-    const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
-    const viewRight = vec3.create();
-    vec3.cross(viewRight, viewUp, viewPlaneNormal);
-    const topLeftWorld = vec3.create();
-    const bottomRightWorld = vec3.create();
-    vec3.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
-    vec3.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
-    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
-    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
-    const sphereCornersIJK = [
-        transformWorldToIndex(imageData, topLeftWorld),
-        (transformWorldToIndex(imageData, bottomRightWorld)),
-    ];
-    const boundsIJK = getBoundingBoxAroundShape(sphereCornersIJK, dimensions);
-    return boundsIJK;
-}

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

@@ -1,3 +0,0 @@
-declare function triggerSegmentationRender(segmentationId?: string): void;
-export { triggerSegmentationRender };
-export default triggerSegmentationRender;

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

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

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

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

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

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