@cornerstonejs/tools 4.18.3 → 4.18.5

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

@@ -55,9 +55,10 @@ import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThre
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
+import OrientationControllerTool from './OrientationControllerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

package/dist/esm/tools/index.js

@@ -55,9 +55,10 @@ import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThre
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
+import OrientationControllerTool from './OrientationControllerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

package/dist/esm/utilities/draw3D/addLine3DBetweenPoints.d.ts

@@ -0,0 +1,7 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import type { Types } from '@cornerstonejs/core';
+export declare function addLine3DBetweenPoints(viewport: Types.IVolumeViewport, point1: Types.Point3, point2: Types.Point3, color?: [number, number, number], uid?: string, showHandles?: boolean): {
+    actor: vtkActor | null;
+    source: vtkPolyData | null;
+};

package/dist/esm/utilities/draw3D/addLine3DBetweenPoints.js

@@ -0,0 +1,34 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+export function addLine3DBetweenPoints(viewport, point1, point2, color = [0.7, 0.7, 0.7], uid = '', showHandles = true) {
+    if (point1[0] === point2[0] &&
+        point1[1] === point2[1] &&
+        point1[2] === point2[2]) {
+        return { actor: null, source: null };
+    }
+    const points = vtkPoints.newInstance();
+    points.setNumberOfPoints(2);
+    points.setPoint(0, point1[0], point1[1], point1[2]);
+    points.setPoint(1, point2[0], point2[1], point2[2]);
+    const lines = vtkCellArray.newInstance({ values: [2, 0, 1] });
+    const polyData = vtkPolyData.newInstance();
+    polyData.setPoints(points);
+    polyData.setLines(lines);
+    const mapper = vtkMapper.newInstance();
+    mapper.setInputData(polyData);
+    const actor = vtkActor.newInstance();
+    actor.setMapper(mapper);
+    actor.getProperty().setColor(...color);
+    actor.getProperty().setLineWidth(0.5);
+    actor.getProperty().setOpacity(1.0);
+    actor.getProperty().setInterpolationToFlat();
+    actor.getProperty().setAmbient(1.0);
+    actor.getProperty().setDiffuse(0.0);
+    actor.getProperty().setSpecular(0.0);
+    actor.setVisibility(showHandles);
+    viewport.addActor({ actor, uid });
+    return { actor, source: polyData };
+}

package/dist/esm/utilities/draw3D/calculateAdaptiveSphereRadius.d.ts

@@ -0,0 +1,6 @@
+export declare function calculateAdaptiveSphereRadius(diagonal: number, config: {
+    sphereRadius?: number;
+    sphereRadiusScale?: number;
+    minSphereRadius?: number;
+    maxSphereRadius?: number;
+}): number;

package/dist/esm/utilities/draw3D/calculateAdaptiveSphereRadius.js

@@ -0,0 +1,7 @@
+export function calculateAdaptiveSphereRadius(diagonal, config) {
+    const scaleFactor = config.sphereRadiusScale || 0.01;
+    const adaptiveRadius = diagonal * scaleFactor;
+    const minRadius = config.minSphereRadius || 2;
+    const maxRadius = config.maxSphereRadius || 50;
+    return Math.max(minRadius, Math.min(maxRadius, adaptiveRadius));
+}

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

@@ -0,0 +1,2 @@
+export { addLine3DBetweenPoints } from './addLine3DBetweenPoints';
+export { calculateAdaptiveSphereRadius } from './calculateAdaptiveSphereRadius';

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

@@ -0,0 +1,2 @@
+export { addLine3DBetweenPoints } from './addLine3DBetweenPoints';
+export { calculateAdaptiveSphereRadius } from './calculateAdaptiveSphereRadius';

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

@@ -22,6 +22,7 @@ import * as viewportFilters from './viewportFilters';
 import * as orientation from './orientation';
 import * as cine from './cine';
 import * as boundingBox from './boundingBox';
+import * as draw3D from './draw3D';
 import * as planarFreehandROITool from './planarFreehandROITool';
 import * as rectangleROITool from './rectangleROITool';
 import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
@@ -42,4 +43,4 @@ import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import { safeStructuredClone } from './safeStructuredClone';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };

package/dist/esm/utilities/index.js

@@ -22,6 +22,7 @@ import * as viewportFilters from './viewportFilters';
 import * as orientation from './orientation';
 import * as cine from './cine';
 import * as boundingBox from './boundingBox';
+import * as draw3D from './draw3D';
 import * as planarFreehandROITool from './planarFreehandROITool';
 import * as rectangleROITool from './rectangleROITool';
 import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
@@ -42,4 +43,4 @@ import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import { safeStructuredClone } from './safeStructuredClone';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };

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;