@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,16 @@
+import type { Types } from '@cornerstonejs/core';
+export type ImageSliceViewport = Types.IViewport & {
+    getCurrentImageId(): string | undefined;
+    getCurrentImageIdIndex(): number;
+    getImageIds(): string[];
+    hasImageURI(imageURI: string): boolean;
+};
+export type StackCompatibilityViewport = ImageSliceViewport & {
+    setStack(imageIds: string[], currentImageIdIndex?: number): Promise<string> | string;
+};
+export type StackCalibrationViewport = ImageSliceViewport & {
+    calibrateSpacing(imageId: string): void;
+};
+export declare function viewportSupportsImageSlices(viewport: unknown): viewport is ImageSliceViewport;
+export declare function viewportSupportsStackCompatibility(viewport: unknown): viewport is StackCompatibilityViewport;
+export declare function viewportSupportsStackCalibration(viewport: unknown): viewport is StackCalibrationViewport;

package/dist/esm/utilities/viewportCapabilities.js

@@ -0,0 +1,18 @@
+function viewportHasMethod(viewport, method) {
+    return (typeof viewport?.[method] ===
+        'function');
+}
+export function viewportSupportsImageSlices(viewport) {
+    return (viewportHasMethod(viewport, 'getCurrentImageId') &&
+        viewportHasMethod(viewport, 'getCurrentImageIdIndex') &&
+        viewportHasMethod(viewport, 'getImageIds') &&
+        viewportHasMethod(viewport, 'hasImageURI'));
+}
+export function viewportSupportsStackCompatibility(viewport) {
+    return (viewportSupportsImageSlices(viewport) &&
+        viewportHasMethod(viewport, 'setStack'));
+}
+export function viewportSupportsStackCalibration(viewport) {
+    return (viewportSupportsImageSlices(viewport) &&
+        viewportHasMethod(viewport, 'calibrateSpacing'));
+}

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

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

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

@@ -1,9 +1,17 @@
 import { vec3 } from 'gl-matrix';
-export function filterViewportsWithParallelNormals(viewports, camera, EPS = 0.999) {
+import getViewportICamera from '../getViewportICamera';
+export function filterViewportsWithParallelNormals(viewports, referenceViewport, EPS = 0.999) {
+    const referenceCamera = getViewportICamera(referenceViewport);
+    const referenceNormal = referenceCamera.viewPlaneNormal;
+    if (!referenceNormal) {
+        return [];
+    }
     return viewports.filter((viewport) => {
-        const vpCamera = viewport.getCamera();
-        const isParallel = Math.abs(vec3.dot(vpCamera.viewPlaneNormal, camera.viewPlaneNormal)) >
-            EPS;
+        const vpCamera = getViewportICamera(viewport);
+        if (!vpCamera.viewPlaneNormal) {
+            return false;
+        }
+        const isParallel = Math.abs(vec3.dot(vpCamera.viewPlaneNormal, referenceNormal)) > EPS;
         return isParallel;
     });
 }

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

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

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

@@ -1,9 +1,16 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
-export function filterViewportsWithSameOrientation(viewports, camera) {
+import getViewportICamera from '../getViewportICamera';
+export function filterViewportsWithSameOrientation(viewports, referenceViewport) {
+    const referenceCamera = getViewportICamera(referenceViewport);
+    if (!referenceCamera.viewPlaneNormal || !referenceCamera.viewUp) {
+        return [];
+    }
     return viewports.filter((viewport) => {
-        const vpCamera = viewport.getCamera();
-        return (csUtils.isEqual(vpCamera.viewPlaneNormal, camera.viewPlaneNormal) &&
-            csUtils.isEqual(vpCamera.viewUp, camera.viewUp));
+        const vpCamera = getViewportICamera(viewport);
+        if (!vpCamera.viewPlaneNormal || !vpCamera.viewUp) {
+            return false;
+        }
+        return (csUtils.isEqual(vpCamera.viewPlaneNormal, referenceCamera.viewPlaneNormal) && csUtils.isEqual(vpCamera.viewUp, referenceCamera.viewUp));
     });
 }
 export default filterViewportsWithSameOrientation;

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

@@ -10,7 +10,7 @@ export default function getViewportIdsWithToolToRender(element, toolName, requir
     viewports = filterViewportsWithToolEnabled(viewports, toolName);
     const viewport = renderingEngine.getViewport(enabledElement.viewportId);
     if (requireParallelNormals) {
-        viewports = filterViewportsWithParallelNormals(viewports, viewport.getCamera());
+        viewports = filterViewportsWithParallelNormals(viewports, viewport);
     }
     const viewportIds = viewports.map((vp) => vp.id);
     return viewportIds;

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

@@ -0,0 +1,3 @@
+import { type Types } from '@cornerstonejs/core';
+export declare function getViewportPresentation(viewport: unknown, selector?: Types.ViewPresentationSelector): unknown;
+export declare function applyViewportPresentation(viewport: unknown, presentation: unknown): boolean;

package/dist/esm/utilities/viewportPresentation.js

@@ -0,0 +1,26 @@
+import { viewportProjection } from '@cornerstonejs/core';
+export function getViewportPresentation(viewport, selector) {
+    const projectionPresentation = viewportProjection.getPresentation(viewport, {
+        selector,
+    });
+    if (projectionPresentation) {
+        return projectionPresentation;
+    }
+    return viewport.getViewPresentation?.(selector);
+}
+export function applyViewportPresentation(viewport, presentation) {
+    if (!presentation) {
+        return false;
+    }
+    const target = viewport;
+    const nextViewState = viewportProjection.withPresentation(viewport, presentation);
+    if (nextViewState && typeof target.setViewState === 'function') {
+        target.setViewState(nextViewState);
+        return true;
+    }
+    if (typeof target.setViewPresentation === 'function') {
+        target.setViewPresentation(presentation);
+        return true;
+    }
+    return false;
+}

package/dist/esm/utilities/volumeCropping/computePlanePlaneIntersection.d.ts

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ClippingPlane } from './types';
+export declare function computePlanePlaneIntersection(clippingPlane: ClippingPlane, viewPlaneNormal: Types.Point3, viewPlanePoint: Types.Point3): {
+    direction: Types.Point3;
+    point: Types.Point3;
+} | null;

package/dist/esm/utilities/volumeCropping/computePlanePlaneIntersection.js

@@ -0,0 +1,37 @@
+import { vec3 } from 'gl-matrix';
+import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import { PARALLEL_PLANE_TOLERANCE } from './constants';
+export function computePlanePlaneIntersection(clippingPlane, viewPlaneNormal, viewPlanePoint) {
+    const n1 = clippingPlane.normal;
+    const p1 = clippingPlane.origin;
+    const n2 = viewPlaneNormal;
+    const p2 = viewPlanePoint;
+    const dir = vec3.create();
+    vec3.cross(dir, n1, n2);
+    const dirLenSq = vec3.squaredLength(dir);
+    if (dirLenSq < PARALLEL_PLANE_TOLERANCE) {
+        return null;
+    }
+    const d1 = vtkMath.dot(n1, p1);
+    const d2 = vtkMath.dot(n2, p2);
+    const term1 = vec3.create();
+    const term2 = vec3.create();
+    vec3.cross(term1, n2, dir);
+    vec3.scale(term1, term1, d1);
+    vec3.cross(term2, dir, n1);
+    vec3.scale(term2, term2, d2);
+    const point = vec3.create();
+    vec3.add(point, term1, term2);
+    vec3.scale(point, point, 1 / dirLenSq);
+    if (!Number.isFinite(point[0]) ||
+        !Number.isFinite(point[1]) ||
+        !Number.isFinite(point[2])) {
+        return null;
+    }
+    const direction = vec3.create();
+    vec3.scale(direction, dir, 1 / Math.sqrt(dirLenSq));
+    return {
+        direction: direction,
+        point: point,
+    };
+}

package/dist/esm/utilities/volumeCropping/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const PLANEINDEX: {
+    XMIN: number;
+    XMAX: number;
+    YMIN: number;
+    YMAX: number;
+    ZMIN: number;
+    ZMAX: number;
+};
+export declare const SPHEREINDEX: {
+    XMIN: number;
+    XMAX: number;
+    YMIN: number;
+    YMAX: number;
+    ZMIN: number;
+    ZMAX: number;
+    XMIN_YMIN_ZMIN: number;
+    XMIN_YMIN_ZMAX: number;
+    XMIN_YMAX_ZMIN: number;
+    XMIN_YMAX_ZMAX: number;
+    XMAX_YMIN_ZMIN: number;
+    XMAX_YMIN_ZMAX: number;
+    XMAX_YMAX_ZMIN: number;
+    XMAX_YMAX_ZMAX: number;
+};
+export declare const NUM_CLIPPING_PLANES = 6;
+export declare const ORIENTATION_TOLERANCE = 0.01;
+export declare const PARALLEL_PLANE_TOLERANCE = 1e-10;
+export declare const LINE_INTERSECTION_TOLERANCE = 1e-8;
+export declare const LINE_EXTENSION_DISTANCE = 100000;
+export declare const MIN_LINE_LENGTH_PIXELS = 1;
+export declare const POINT_PROXIMITY_THRESHOLD_PIXELS = 6;

package/dist/esm/utilities/volumeCropping/constants.js

@@ -0,0 +1,31 @@
+export const PLANEINDEX = {
+    XMIN: 0,
+    XMAX: 1,
+    YMIN: 2,
+    YMAX: 3,
+    ZMIN: 4,
+    ZMAX: 5,
+};
+export const SPHEREINDEX = {
+    XMIN: 0,
+    XMAX: 1,
+    YMIN: 2,
+    YMAX: 3,
+    ZMIN: 4,
+    ZMAX: 5,
+    XMIN_YMIN_ZMIN: 6,
+    XMIN_YMIN_ZMAX: 7,
+    XMIN_YMAX_ZMIN: 8,
+    XMIN_YMAX_ZMAX: 9,
+    XMAX_YMIN_ZMIN: 10,
+    XMAX_YMIN_ZMAX: 11,
+    XMAX_YMAX_ZMIN: 12,
+    XMAX_YMAX_ZMAX: 13,
+};
+export const NUM_CLIPPING_PLANES = 6;
+export const ORIENTATION_TOLERANCE = 1e-2;
+export const PARALLEL_PLANE_TOLERANCE = 1e-10;
+export const LINE_INTERSECTION_TOLERANCE = 1e-8;
+export const LINE_EXTENSION_DISTANCE = 100000;
+export const MIN_LINE_LENGTH_PIXELS = 1;
+export const POINT_PROXIMITY_THRESHOLD_PIXELS = 6;

package/dist/esm/utilities/volumeCropping/copyClippingPlanes.d.ts

@@ -0,0 +1,2 @@
+import type { ClippingPlane } from './types';
+export declare function copyClippingPlanes(planes: ClippingPlane[]): ClippingPlane[];

package/dist/esm/utilities/volumeCropping/copyClippingPlanes.js

@@ -0,0 +1,6 @@
+export function copyClippingPlanes(planes) {
+    return planes.map((plane) => ({
+        origin: [...plane.origin],
+        normal: [...plane.normal],
+    }));
+}

package/dist/esm/utilities/volumeCropping/extractVolumeDirectionVectors.d.ts

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+export interface ImageDataWithDirection {
+    getDirection(): number[];
+}
+export declare function extractVolumeDirectionVectors(imageData: ImageDataWithDirection): {
+    xDir: Types.Point3;
+    yDir: Types.Point3;
+    zDir: Types.Point3;
+};

package/dist/esm/utilities/volumeCropping/extractVolumeDirectionVectors.js

@@ -0,0 +1,9 @@
+import { vec3 } from 'gl-matrix';
+export function extractVolumeDirectionVectors(imageData) {
+    const direction = imageData.getDirection();
+    return {
+        xDir: vec3.normalize([0, 0, 0], direction.slice(0, 3)),
+        yDir: vec3.normalize([0, 0, 0], direction.slice(3, 6)),
+        zDir: vec3.normalize([0, 0, 0], direction.slice(6, 9)),
+    };
+}

package/dist/esm/utilities/volumeCropping/findLineBoundsIntersection.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function findLineBoundsIntersection(linePoint: Types.Point3, lineDirection: Types.Point3, viewport: Types.IViewport): {
+    start: Types.Point2;
+    end: Types.Point2;
+} | null;

package/dist/esm/utilities/volumeCropping/findLineBoundsIntersection.js

@@ -0,0 +1,50 @@
+import { vec2, vec3 } from 'gl-matrix';
+import liangBarksyClip from '../math/vec2/liangBarksyClip';
+import { LINE_EXTENSION_DISTANCE, MIN_LINE_LENGTH_PIXELS } from './constants';
+export function findLineBoundsIntersection(linePoint, lineDirection, viewport) {
+    const lineLength = LINE_EXTENSION_DISTANCE;
+    const lineStart = vec3.scaleAndAdd([0, 0, 0], linePoint, lineDirection, -lineLength);
+    const lineEnd = vec3.scaleAndAdd([0, 0, 0], linePoint, lineDirection, lineLength);
+    const canvasStart = viewport.worldToCanvas(lineStart);
+    const canvasEnd = viewport.worldToCanvas(lineEnd);
+    const { clientWidth, clientHeight } = viewport.canvas;
+    const canvasBox = [0, 0, clientWidth, clientHeight];
+    const clippedStart = vec2.clone(canvasStart);
+    const clippedEnd = vec2.clone(canvasEnd);
+    const startValid = !isNaN(clippedStart[0]) && !isNaN(clippedStart[1]);
+    const endValid = !isNaN(clippedEnd[0]) && !isNaN(clippedEnd[1]);
+    if (!startValid || !endValid) {
+        return null;
+    }
+    const clipResult = liangBarksyClip(clippedStart, clippedEnd, canvasBox);
+    if (clipResult === 0) {
+        return null;
+    }
+    const clippedStartValid = !isNaN(clippedStart[0]) && !isNaN(clippedStart[1]);
+    const clippedEndValid = !isNaN(clippedEnd[0]) && !isNaN(clippedEnd[1]);
+    if (!clippedStartValid || !clippedEndValid) {
+        return null;
+    }
+    const [xMin, yMin, xMax, yMax] = canvasBox;
+    const startInBounds = clippedStart[0] >= xMin - 1 &&
+        clippedStart[0] <= xMax + 1 &&
+        clippedStart[1] >= yMin - 1 &&
+        clippedStart[1] <= yMax + 1;
+    const endInBounds = clippedEnd[0] >= xMin - 1 &&
+        clippedEnd[0] <= xMax + 1 &&
+        clippedEnd[1] >= yMin - 1 &&
+        clippedEnd[1] <= yMax + 1;
+    if (!startInBounds || !endInBounds) {
+        return null;
+    }
+    const dx = clippedEnd[0] - clippedStart[0];
+    const dy = clippedEnd[1] - clippedStart[1];
+    const length = Math.sqrt(dx * dx + dy * dy);
+    if (length < MIN_LINE_LENGTH_PIXELS) {
+        return null;
+    }
+    return {
+        start: clippedStart,
+        end: clippedEnd,
+    };
+}

package/dist/esm/utilities/volumeCropping/getColorKeyForPlaneIndex.d.ts

@@ -0,0 +1 @@
+export declare function getColorKeyForPlaneIndex(planeIndex: number): 'SAGITTAL' | 'CORONAL' | 'AXIAL' | null;

package/dist/esm/utilities/volumeCropping/getColorKeyForPlaneIndex.js

@@ -0,0 +1,13 @@
+import { PLANEINDEX } from './constants';
+export function getColorKeyForPlaneIndex(planeIndex) {
+    if (planeIndex === PLANEINDEX.XMIN || planeIndex === PLANEINDEX.XMAX) {
+        return 'SAGITTAL';
+    }
+    else if (planeIndex === PLANEINDEX.YMIN || planeIndex === PLANEINDEX.YMAX) {
+        return 'CORONAL';
+    }
+    else if (planeIndex === PLANEINDEX.ZMIN || planeIndex === PLANEINDEX.ZMAX) {
+        return 'AXIAL';
+    }
+    return null;
+}

package/dist/esm/utilities/volumeCropping/getOrientationFromNormal.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function getOrientationFromNormal(normal: Types.Point3): 'AXIAL' | 'CORONAL' | 'SAGITTAL' | null;

package/dist/esm/utilities/volumeCropping/getOrientationFromNormal.js

@@ -0,0 +1,19 @@
+import { vec3 } from 'gl-matrix';
+import { utilities } from '@cornerstonejs/core';
+import { ORIENTATION_TOLERANCE } from './constants';
+export function getOrientationFromNormal(normal) {
+    if (!normal) {
+        return null;
+    }
+    const canonical = {
+        AXIAL: [0, 0, 1],
+        CORONAL: [0, 1, 0],
+        SAGITTAL: [1, 0, 0],
+    };
+    for (const [key, value] of Object.entries(canonical)) {
+        if (utilities.isEqualAbs(1, vec3.dot(value, normal), ORIENTATION_TOLERANCE)) {
+            return key;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,9 @@
+export * from './constants';
+export * from './types';
+export * from './extractVolumeDirectionVectors';
+export * from './parseCornerKey';
+export * from './copyClippingPlanes';
+export * from './getColorKeyForPlaneIndex';
+export * from './getOrientationFromNormal';
+export * from './computePlanePlaneIntersection';
+export * from './findLineBoundsIntersection';

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

@@ -0,0 +1,9 @@
+export * from './constants';
+export * from './types';
+export * from './extractVolumeDirectionVectors';
+export * from './parseCornerKey';
+export * from './copyClippingPlanes';
+export * from './getColorKeyForPlaneIndex';
+export * from './getOrientationFromNormal';
+export * from './computePlanePlaneIntersection';
+export * from './findLineBoundsIntersection';

package/dist/esm/utilities/volumeCropping/parseCornerKey.d.ts

@@ -0,0 +1,8 @@
+export declare function parseCornerKey(uid: string): {
+    isXMin: boolean;
+    isXMax: boolean;
+    isYMin: boolean;
+    isYMax: boolean;
+    isZMin: boolean;
+    isZMax: boolean;
+};

package/dist/esm/utilities/volumeCropping/parseCornerKey.js

@@ -0,0 +1,11 @@
+export function parseCornerKey(uid) {
+    const cornerKey = uid.replace('corner_', '');
+    return {
+        isXMin: cornerKey.includes('XMIN'),
+        isXMax: cornerKey.includes('XMAX'),
+        isYMin: cornerKey.includes('YMIN'),
+        isYMax: cornerKey.includes('YMAX'),
+        isZMin: cornerKey.includes('ZMIN'),
+        isZMax: cornerKey.includes('ZMAX'),
+    };
+}

package/dist/esm/utilities/volumeCropping/types.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export type ClippingPlane = {
+    origin: Types.Point3;
+    normal: Types.Point3;
+};

package/dist/esm/utilities/vtkjs/AnnotatedRhombicuboctahedronActor/index.d.ts

@@ -0,0 +1,31 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export namespace DEFAULT_VALUES {
+    namespace defaultStyle {
+        let text: string;
+        let faceColor: string;
+        let faceRotation: number;
+        let fontFamily: string;
+        let fontColor: string;
+        let fontStyle: string;
+        function fontSizeScale(resolution: any): number;
+        let edgeThickness: number;
+        let edgeColor: string;
+        let resolution: number;
+    }
+    let xPlusFaceProperty: {};
+    let xMinusFaceProperty: {};
+    let yPlusFaceProperty: {};
+    let yMinusFaceProperty: {};
+    let zPlusFaceProperty: {};
+    let zMinusFaceProperty: {};
+    let showMainFaces: boolean;
+    let showEdgeFaces: boolean;
+    let showCornerFaces: boolean;
+    let scale: number;
+}
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;