@cornerstonejs/tools 4.17.0 → 4.17.2

package/dist/esm/utilities/drawing/getTextBoxCoordsCanvas.js

@@ -1,16 +1,116 @@
-export default function getTextBoxCoordsCanvas(annotationCanvasPoints) {
+import { getRegisteredTextBoxes, } from './textBoxOverlapRegistry';
+import intersectAABB from '../math/aabb/intersectAABB';
+const VIEWPORT_ELEMENT = 'viewport-element';
+const TEXT_BOX_GAP = 6;
+export default function getTextBoxCoordsCanvas(annotationCanvasPoints, element, textLines = []) {
+    if (!annotationCanvasPoints?.length || !annotationCanvasPoints[0]) {
+        return [0, 0];
+    }
     const corners = _determineCorners(annotationCanvasPoints);
     const centerY = (corners.top[1] + corners.bottom[1]) / 2;
-    const textBoxCanvas = [corners.right[0], centerY];
-    return textBoxCanvas;
+    const defaultTextBoxCanvas = [corners.right[0], centerY];
+    if (!element) {
+        return defaultTextBoxCanvas;
+    }
+    const { width: textBoxWidth, height: textBoxHeight } = _estimateTextBoxSize(textLines);
+    const margin = 4;
+    const maxX = element.clientWidth - margin;
+    const maxY = element.clientHeight - margin;
+    let x = corners.right[0];
+    let y = centerY - textBoxHeight / 2;
+    if (x + textBoxWidth > maxX) {
+        x = corners.left[0] - textBoxWidth;
+    }
+    x = Math.max(margin, Math.min(x, maxX - textBoxWidth));
+    y = Math.max(margin, Math.min(y, maxY - textBoxHeight));
+    const svgLayer = _findSvgLayer(element);
+    if (svgLayer) {
+        const existingBoxes = getRegisteredTextBoxes(svgLayer);
+        if (existingBoxes.length > 0) {
+            const resolved = _resolveOverlap(x, y, textBoxWidth, textBoxHeight, existingBoxes, margin, maxX, maxY);
+            x = resolved[0];
+            y = resolved[1];
+        }
+    }
+    return [x, y];
+}
+function _resolveOverlap(x, y, width, height, existingBoxes, margin, maxX, maxY) {
+    if (!_overlapsAny(x, y, width, height, existingBoxes)) {
+        return [x, y];
+    }
+    let candidateY = y;
+    for (let i = 0; i < 30; i++) {
+        const blocker = _findFirstOverlap(x, candidateY, width, height, existingBoxes);
+        if (!blocker) {
+            break;
+        }
+        candidateY = blocker.y + blocker.height + TEXT_BOX_GAP;
+        if (candidateY + height > maxY) {
+            candidateY = Infinity;
+            break;
+        }
+    }
+    if (candidateY !== Infinity &&
+        !_overlapsAny(x, candidateY, width, height, existingBoxes)) {
+        return [
+            x,
+            Math.max(margin, Math.min(candidateY, maxY - height)),
+        ];
+    }
+    candidateY = y;
+    for (let i = 0; i < 30; i++) {
+        const blocker = _findFirstOverlap(x, candidateY, width, height, existingBoxes);
+        if (!blocker) {
+            break;
+        }
+        candidateY = blocker.y - height - TEXT_BOX_GAP;
+        if (candidateY < margin) {
+            candidateY = -Infinity;
+            break;
+        }
+    }
+    if (candidateY !== -Infinity &&
+        !_overlapsAny(x, candidateY, width, height, existingBoxes)) {
+        return [
+            x,
+            Math.max(margin, Math.min(candidateY, maxY - height)),
+        ];
+    }
+    return [x, y];
+}
+function _overlapsAny(x, y, w, h, boxes) {
+    const candidate = _toTextBoxAABB({ x, y, width: w, height: h });
+    return boxes.some((box) => intersectAABB(candidate, _toTextBoxAABB(box, TEXT_BOX_GAP / 2)));
+}
+function _findFirstOverlap(x, y, w, h, boxes) {
+    const candidate = _toTextBoxAABB({ x, y, width: w, height: h });
+    return boxes.find((box) => intersectAABB(candidate, _toTextBoxAABB(box, TEXT_BOX_GAP / 2)));
+}
+function _toTextBoxAABB(rect, inflate = 0) {
+    return {
+        minX: rect.x - inflate,
+        minY: rect.y - inflate,
+        maxX: rect.x + rect.width + inflate,
+        maxY: rect.y + rect.height + inflate,
+    };
+}
+function _findSvgLayer(element) {
+    const internalDiv = element.querySelector(`.${VIEWPORT_ELEMENT}`);
+    return internalDiv?.querySelector(':scope > .svg-layer') || null;
 }
 function _determineCorners(canvasPoints) {
+    const p0 = canvasPoints[0];
+    if (!p0 || canvasPoints.length < 2) {
+        return { left: p0, right: p0, top: p0, bottom: p0 };
+    }
     const handlesLeftToRight = [canvasPoints[0], canvasPoints[1]].sort(_compareX);
     const handlesTopToBottom = [canvasPoints[0], canvasPoints[1]].sort(_compareY);
+    const left = handlesLeftToRight[0];
     const right = handlesLeftToRight[handlesLeftToRight.length - 1];
     const top = handlesTopToBottom[0];
     const bottom = handlesTopToBottom[handlesTopToBottom.length - 1];
     return {
+        left,
         top,
         bottom,
         right,
@@ -22,3 +122,13 @@ function _determineCorners(canvasPoints) {
         return a[1] < b[1] ? -1 : 1;
     }
 }
+function _estimateTextBoxSize(textLines) {
+    const estimatedPadding = 25;
+    const estimatedCharWidth = 8;
+    const estimatedLineHeight = 17;
+    const longestLineLength = textLines.reduce((max, line) => Math.max(max, line?.length ?? 0), 0);
+    const lineCount = Math.max(textLines.length, 1);
+    const width = longestLineLength * estimatedCharWidth + estimatedPadding * 2;
+    const height = lineCount * estimatedLineHeight + estimatedPadding * 2;
+    return { width, height };
+}

package/dist/esm/utilities/drawing/textBoxOverlapRegistry.d.ts

@@ -0,0 +1,9 @@
+export interface TextBoxRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function clearTextBoxRegistry(svgLayerElement: Element): void;
+export declare function registerTextBox(svgLayerElement: Element, rect: TextBoxRect): void;
+export declare function getRegisteredTextBoxes(svgLayerElement: Element): TextBoxRect[];

package/dist/esm/utilities/drawing/textBoxOverlapRegistry.js

@@ -0,0 +1,20 @@
+const registry = new WeakMap();
+export function clearTextBoxRegistry(svgLayerElement) {
+    registry.set(svgLayerElement, []);
+}
+export function registerTextBox(svgLayerElement, rect) {
+    let boxes = registry.get(svgLayerElement);
+    if (!boxes) {
+        boxes = [];
+        registry.set(svgLayerElement, boxes);
+    }
+    boxes.push({
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+    });
+}
+export function getRegisteredTextBoxes(svgLayerElement) {
+    return registry.get(svgLayerElement) || [];
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.17.0";
+export declare const version = "4.17.2";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.17.0';
+export const version = '4.17.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.17.0",
+  "version": "4.17.2",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.17.0",
+    "@cornerstonejs/core": "4.17.2",
     "@kitware/vtk.js": "34.15.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f5a86e32f08c55617ab0c6213607ce341bb7b02c"
+  "gitHead": "1bf66a49411068a5351010e818f5a4ea3916434a"
 }

package/dist/esm/tools/segmentation/strategies/__tests__/fillCircle.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/tools/segmentation/strategies/__tests__/fillCircle.spec.js

@@ -1,27 +0,0 @@
-import { createPointInEllipse } from '../fillCircle';
-describe('createPointInEllipse', () => {
-    const corners = [
-        [-1, 1, 0],
-        [1, -1, 0],
-        [-1, -1, 0],
-        [1, 1, 0],
-    ];
-    it('detects points inside the base circle', () => {
-        const predicate = createPointInEllipse(corners);
-        expect(predicate([0, 0, 0])).toBe(true);
-        expect(predicate([0.5, 0.5, 0])).toBe(true);
-        expect(predicate([1.2, 0, 0])).toBe(false);
-    });
-    it('covers interpolated stroke segments', () => {
-        const predicate = createPointInEllipse(corners, {
-            strokePointsWorld: [
-                [-2, 0, 0],
-                [2, 0, 0],
-            ],
-            radius: 1,
-        });
-        expect(predicate([0, 0, 0])).toBe(true);
-        expect(predicate([1.5, 0, 0])).toBe(true);
-        expect(predicate([3.2, 0, 0])).toBe(false);
-    });
-});