@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

package/dist/esm/tools/CrosshairsTool.js

@@ -52,6 +52,10 @@ class CrosshairsTool extends AnnotationTool {
             enableHDPIHandles: false,
             referenceLinesCenterGapRadius: 20,
             referenceLinesCenterGapRatio: null,
+            minimal: {
+                enabled: false,
+                lineLengthInPx: 40,
+            },
             filterActorUIDsToSetSlabThickness: [],
             slabThicknessBlendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
             centerPoint: {
@@ -380,15 +384,15 @@ class CrosshairsTool extends AnnotationTool {
                 vec2.normalize(canvasUnitVectorFromCenter, canvasUnitVectorFromCenter);
                 const canvasVectorFromCenterLong = vec2.create();
                 vec2.scale(canvasVectorFromCenterLong, canvasUnitVectorFromCenter, canvasDiagonalLength * 100);
-                const canvasVectorFromCenterMid = vec2.create();
-                vec2.scale(canvasVectorFromCenterMid, canvasUnitVectorFromCenter, canvasMinDimensionLength * 0.4);
                 const canvasVectorFromCenterShort = vec2.create();
                 vec2.scale(canvasVectorFromCenterShort, canvasUnitVectorFromCenter, canvasMinDimensionLength * 0.2);
                 const canvasVectorFromCenterStart = vec2.create();
                 const mobileConfig = this.configuration.mobile;
-                const { referenceLinesCenterGapRatio } = mobileConfig?.enabled
+                const activeConfiguration = mobileConfig?.enabled
                     ? mobileConfig
                     : this.configuration;
+                const { referenceLinesCenterGapRatio } = activeConfiguration;
+                const minimalCrosshairConfig = getMinimalCrosshairConfig(this.configuration);
                 const centerGap = referenceLinesCenterGapRatio > 0
                     ? canvasMinDimensionLength * referenceLinesCenterGapRatio
                     : this.configuration.referenceLinesCenterGapRadius;
@@ -407,10 +411,18 @@ class CrosshairsTool extends AnnotationTool {
                 vec2.subtract(refLinePointFour, refLinesCenter, canvasVectorFromCenterLong);
                 liangBarksyClip(refLinePointOne, refLinePointTwo, canvasBox);
                 liangBarksyClip(refLinePointThree, refLinePointFour, canvasBox);
-                const rotHandleOne = vec2.create();
-                vec2.subtract(rotHandleOne, crosshairCenterCanvas, canvasVectorFromCenterMid);
-                const rotHandleTwo = vec2.create();
-                vec2.add(rotHandleTwo, crosshairCenterCanvas, canvasVectorFromCenterMid);
+                if (minimalCrosshairConfig.enabled) {
+                    const minimalCanvasVectorFromCenterLong = vec2.create();
+                    vec2.scale(minimalCanvasVectorFromCenterLong, canvasUnitVectorFromCenter, minimalCrosshairConfig.lineLengthInPx);
+                    vec2.add(refLinePointOne, refLinesCenter, canvasVectorFromCenterStart);
+                    vec2.add(refLinePointTwo, refLinePointOne, minimalCanvasVectorFromCenterLong);
+                    vec2.subtract(refLinePointThree, refLinesCenter, canvasVectorFromCenterStart);
+                    vec2.subtract(refLinePointFour, refLinePointThree, minimalCanvasVectorFromCenterLong);
+                    liangBarksyClip(refLinePointOne, refLinePointTwo, canvasBox);
+                    liangBarksyClip(refLinePointThree, refLinePointFour, canvasBox);
+                }
+                const rotHandleOne = getSegmentMidpoint(refLinePointOne, refLinePointTwo);
+                const rotHandleTwo = getSegmentMidpoint(refLinePointThree, refLinePointFour);
                 let stHandlesCenterCanvas = vec2.clone(crosshairCenterCanvas);
                 if (!otherViewportDraggableRotatable &&
                     otherViewportSlabThicknessControlsOn) {
@@ -490,12 +502,15 @@ class CrosshairsTool extends AnnotationTool {
             const color = viewportColor !== undefined ? viewportColor : 'rgb(200, 200, 200)';
             referenceLines.forEach((line, lineIndex) => {
                 const otherViewport = line[0];
+                const minimalCrosshairConfig = getMinimalCrosshairConfig(this.configuration);
                 const viewportColor = this._getReferenceLineColor(otherViewport.id);
                 const viewportControllable = this._getReferenceLineControllable(otherViewport.id);
-                const viewportDraggableRotatable = this._getReferenceLineDraggableRotatable(otherViewport.id) ||
-                    this.configuration.mobile?.enabled;
-                const viewportSlabThicknessControlsOn = this._getReferenceLineSlabThicknessControlsOn(otherViewport.id) ||
-                    this.configuration.mobile?.enabled;
+                const viewportDraggableRotatable = !minimalCrosshairConfig.enabled &&
+                    (this._getReferenceLineDraggableRotatable(otherViewport.id) ||
+                        this.configuration.mobile?.enabled);
+                const viewportSlabThicknessControlsOn = !minimalCrosshairConfig.enabled &&
+                    (this._getReferenceLineSlabThicknessControlsOn(otherViewport.id) ||
+                        this.configuration.mobile?.enabled);
                 const selectedViewportId = data.activeViewportIds.find((id) => id === otherViewport.id);
                 let color = viewportColor !== undefined ? viewportColor : 'rgb(200, 200, 200)';
                 let lineWidth = 1;
@@ -506,7 +521,8 @@ class CrosshairsTool extends AnnotationTool {
                     lineWidth = 2.5;
                 }
                 let lineUID = `${lineIndex}`;
-                if (viewportControllable && viewportDraggableRotatable) {
+                if (viewportControllable &&
+                    (viewportDraggableRotatable || minimalCrosshairConfig.enabled)) {
                     lineUID = `${lineIndex}One`;
                     drawLineSvg(svgDrawingHelper, annotationUID, lineUID, line[1], line[2], {
                         color,
@@ -544,31 +560,33 @@ class CrosshairsTool extends AnnotationTool {
                     newRtpoints.push(rotHandleWorldOne, rotHandleWorldTwo);
                     const slabThicknessHandlesActive = data.handles.activeOperation === OPERATION.SLAB;
                     const slabThicknessHandles = [line[11], line[12], line[13], line[14]];
-                    const slabThicknessHandleWorldOne = [
-                        viewport.canvasToWorld(line[11]),
-                        otherViewport,
-                        line[5],
-                        line[6],
-                    ];
-                    const slabThicknessHandleWorldTwo = [
-                        viewport.canvasToWorld(line[12]),
-                        otherViewport,
-                        line[5],
-                        line[6],
-                    ];
-                    const slabThicknessHandleWorldThree = [
-                        viewport.canvasToWorld(line[13]),
-                        otherViewport,
-                        line[7],
-                        line[8],
-                    ];
-                    const slabThicknessHandleWorldFour = [
-                        viewport.canvasToWorld(line[14]),
-                        otherViewport,
-                        line[7],
-                        line[8],
-                    ];
-                    newStpoints.push(slabThicknessHandleWorldOne, slabThicknessHandleWorldTwo, slabThicknessHandleWorldThree, slabThicknessHandleWorldFour);
+                    if (!minimalCrosshairConfig.enabled) {
+                        const slabThicknessHandleWorldOne = [
+                            viewport.canvasToWorld(line[11]),
+                            otherViewport,
+                            line[5],
+                            line[6],
+                        ];
+                        const slabThicknessHandleWorldTwo = [
+                            viewport.canvasToWorld(line[12]),
+                            otherViewport,
+                            line[5],
+                            line[6],
+                        ];
+                        const slabThicknessHandleWorldThree = [
+                            viewport.canvasToWorld(line[13]),
+                            otherViewport,
+                            line[7],
+                            line[8],
+                        ];
+                        const slabThicknessHandleWorldFour = [
+                            viewport.canvasToWorld(line[14]),
+                            otherViewport,
+                            line[7],
+                            line[8],
+                        ];
+                        newStpoints.push(slabThicknessHandleWorldOne, slabThicknessHandleWorldTwo, slabThicknessHandleWorldThree, slabThicknessHandleWorldFour);
+                    }
                     let handleRadius = this.configuration.handleRadius *
                         (this.configuration.enableHDPIHandles ? window.devicePixelRatio : 1);
                     let opacity = 1;
@@ -905,6 +923,7 @@ class CrosshairsTool extends AnnotationTool {
                 emitEvent: true,
                 updateViewportCameras: false,
             });
+            viewport.render();
             state.isInteractingWithTool = false;
             return true;
         };
@@ -1581,6 +1600,7 @@ class CrosshairsTool extends AnnotationTool {
         }
     }
     _getRotationHandleNearImagePoint(viewport, annotation, canvasCoords, proximity) {
+        const minimalCrosshairConfig = getMinimalCrosshairConfig(this.configuration);
         const { data } = annotation;
         const { rotationPoints } = data.handles;
         for (let i = 0; i < rotationPoints.length; i++) {
@@ -1590,7 +1610,8 @@ class CrosshairsTool extends AnnotationTool {
             if (!viewportControllable) {
                 continue;
             }
-            const viewportDraggableRotatable = this._getReferenceLineDraggableRotatable(otherViewport.id);
+            const viewportDraggableRotatable = !minimalCrosshairConfig.enabled &&
+                this._getReferenceLineDraggableRotatable(otherViewport.id);
             if (!viewportDraggableRotatable) {
                 continue;
             }
@@ -1606,6 +1627,7 @@ class CrosshairsTool extends AnnotationTool {
         return null;
     }
     _getSlabThicknessHandleNearImagePoint(viewport, annotation, canvasCoords, proximity) {
+        const minimalCrosshairConfig = getMinimalCrosshairConfig(this.configuration);
         const { data } = annotation;
         const { slabThicknessPoints } = data.handles;
         for (let i = 0; i < slabThicknessPoints.length; i++) {
@@ -1615,7 +1637,8 @@ class CrosshairsTool extends AnnotationTool {
             if (!viewportControllable) {
                 continue;
             }
-            const viewportSlabThicknessControlsOn = this._getReferenceLineSlabThicknessControlsOn(otherViewport.id);
+            const viewportSlabThicknessControlsOn = !minimalCrosshairConfig.enabled &&
+                this._getReferenceLineSlabThicknessControlsOn(otherViewport.id);
             if (!viewportSlabThicknessControlsOn) {
                 continue;
             }
@@ -1632,6 +1655,7 @@ class CrosshairsTool extends AnnotationTool {
         return null;
     }
     _pointNearTool(element, annotation, canvasCoords, proximity) {
+        const minimalCrosshairConfig = getMinimalCrosshairConfig(this.configuration);
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
         const { clientWidth, clientHeight } = viewport.canvas;
@@ -1644,7 +1668,8 @@ class CrosshairsTool extends AnnotationTool {
             const otherViewport = rotationPoints[i][1];
             const viewportControllable = this._getReferenceLineControllable(otherViewport.id);
             const viewportDraggableRotatable = this._getReferenceLineDraggableRotatable(otherViewport.id);
-            if (!viewportControllable || !viewportDraggableRotatable) {
+            if (!viewportControllable ||
+                (!viewportDraggableRotatable && !minimalCrosshairConfig.enabled)) {
                 continue;
             }
             const lineSegment1 = {
@@ -1681,7 +1706,8 @@ class CrosshairsTool extends AnnotationTool {
                 continue;
             }
             const viewportControllable = this._getReferenceLineControllable(otherViewport.id);
-            const viewportSlabThicknessControlsOn = this._getReferenceLineSlabThicknessControlsOn(otherViewport.id);
+            const viewportSlabThicknessControlsOn = !minimalCrosshairConfig.enabled &&
+                this._getReferenceLineSlabThicknessControlsOn(otherViewport.id);
             if (!viewportControllable || !viewportSlabThicknessControlsOn) {
                 continue;
             }
@@ -1734,5 +1760,33 @@ class CrosshairsTool extends AnnotationTool {
         return data.handles.activeOperation === OPERATION.DRAG ? true : false;
     }
 }
+CrosshairsTool.minimalModeExamples = new Map([
+    ['Default', { enabled: false, lineLengthInPx: 40 }],
+    ['Minimal 40px', { enabled: true, lineLengthInPx: 40 }],
+    ['Minimal 80px', { enabled: true, lineLengthInPx: 80 }],
+]);
+function getMinimalCrosshairConfig(configuration) {
+    const minimal = configuration?.minimal;
+    if (!minimal?.enabled) {
+        return {
+            enabled: false,
+            lineLengthInPx: 0,
+        };
+    }
+    const lineLengthInPx = typeof minimal.lineLengthInPx === 'number' &&
+        Number.isFinite(minimal.lineLengthInPx)
+        ? minimal.lineLengthInPx
+        : 40;
+    return {
+        enabled: true,
+        lineLengthInPx: Math.max(0, lineLengthInPx),
+    };
+}
+function getSegmentMidpoint(start, end) {
+    const midpoint = vec2.create();
+    vec2.add(midpoint, start, end);
+    vec2.scale(midpoint, midpoint, 0.5);
+    return midpoint;
+}
 CrosshairsTool.toolName = 'Crosshairs';
 export default CrosshairsTool;

package/dist/esm/tools/MagnifyTool.js

@@ -52,7 +52,7 @@ class MagnifyTool extends BaseTool {
             const { viewport } = enabledElement;
             const { element } = viewport;
             const viewportProperties = viewport.getProperties();
-            const { rotation: originalViewportRotation } = viewport.getViewPresentation();
+            const { rotation: originalViewportRotation, flipHorizontal: originalViewportFlipHorizontal, flipVertical: originalViewportFlipVertical, } = viewport.getViewPresentation();
             const { canvas: canvasPos, world: worldPos } = currentPoints;
             let magnifyToolElement;
             magnifyToolElement = element.querySelector('.magnifyTool');
@@ -83,6 +83,8 @@ class MagnifyTool extends BaseTool {
                 magnifyViewport.setProperties(viewportProperties);
                 magnifyViewport.setViewPresentation({
                     rotation: originalViewportRotation,
+                    flipHorizontal: originalViewportFlipHorizontal,
+                    flipVertical: originalViewportFlipVertical,
                 });
                 const { parallelScale } = viewport.getCamera();
                 const { focalPoint, position, viewPlaneNormal } = magnifyViewport.getCamera();

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

@@ -0,0 +1,45 @@
+import { BaseTool } from './base';
+declare class OrientationControllerTool extends BaseTool {
+    static toolName: string;
+    private widget;
+    private resizeObservers;
+    private cameraHandlers;
+    private animationFrameHandles;
+    private animationTokens;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+        configuration: {
+            enabled: boolean;
+            opacity: number;
+            size: number;
+            position: string;
+            colorScheme: string;
+            letterColorScheme: string;
+            showEdgeFaces: boolean;
+            showCornerFaces: boolean;
+            keepOrientationUp: boolean;
+            highlightColor: number[];
+            edgeColor: number[];
+            cornerColor: number[];
+            restingAmbient: number;
+            hoverAmbient: number;
+        };
+    });
+    private _getViewportsInfo;
+    private getPositionConfig;
+    private getFaceColors;
+    private getLetterColors;
+    onSetToolEnabled(): void;
+    onSetToolDisabled(): void;
+    onSetToolConfiguration: () => void;
+    private onViewportAdded;
+    private onViewportRemoved;
+    private removeMarkers;
+    private addMarkers;
+    private createAnnotatedRhombActor;
+    private addMarkerToViewport;
+    private onCameraModified;
+    private updateMarkerPosition;
+    private animateCameraToOrientation;
+}
+export default OrientationControllerTool;