@reekon-tools/boldr-utils 1.15.1 → 1.15.3

package/dist/annotation/canvas/planeGeometry.js

@@ -0,0 +1,507 @@
+// Pure geometry for plane calibrations (AnnotationCanvasState.planes): the
+// homography that maps a marked quadrilateral onto its real-world rectangle,
+// plus the derived measurement and calibration-grid helpers. Skia-free and
+// dependency-free so it's safe in tools, hit-tests, and unit tests.
+//
+// Terminology guard: "calibration"/"scale" elsewhere in this package mean TILE
+// SIZING (stampLayout.ts). Everything here is plane calibration — mapping
+// DOC-space geometry to physical lengths in micrometers.
+//
+// v1 keeps all of this on the JS thread (values recompute on commit, not
+// per-frame), so there are no worklet twins of these functions yet. If live
+// drag readouts are ever needed, the twin goes next to the existing geometry
+// twins in AnnotationCanvasInner.native.tsx.
+import { lineLength } from './measurementGeometry.js';
+// Degeneracy guards are scaled to the quad's own extent — doc coordinates are
+// arbitrary (a photo canvas is typically ~1000 units across), so a fixed
+// epsilon would misfire on very small or very large documents.
+const relativeEps = (corners) => {
+    let span = 1;
+    for (const p of corners) {
+        span = Math.max(span, Math.abs(p.x), Math.abs(p.y));
+    }
+    return span * 1e-9;
+};
+// Heckbert's closed-form homography for the four correspondences
+// (0,0)→TL, (1,0)→TR, (1,1)→BR, (0,1)→BL. Returns null for a degenerate quad
+// (collinear/coincident corners). Corners must already be in TL,TR,BR,BL order
+// (see normalizeQuadOrder).
+export const homographyFromQuad = (corners) => {
+    const [p0, p1, p2, p3] = corners;
+    const eps = relativeEps(corners);
+    const sx = p0.x - p1.x + p2.x - p3.x;
+    const sy = p0.y - p1.y + p2.y - p3.y;
+    if (Math.abs(sx) < eps && Math.abs(sy) < eps) {
+        // Parallelogram → affine (the camera was normal to the plane).
+        const h = {
+            a: p1.x - p0.x,
+            b: p3.x - p0.x,
+            c: p0.x,
+            d: p1.y - p0.y,
+            e: p3.y - p0.y,
+            f: p0.y,
+            g: 0,
+            h: 0,
+        };
+        // Still reject collinear corners: an affine map with ~zero area.
+        return Math.abs(h.a * h.e - h.b * h.d) < eps * eps ? null : h;
+    }
+    const dx1 = p1.x - p2.x;
+    const dx2 = p3.x - p2.x;
+    const dy1 = p1.y - p2.y;
+    const dy2 = p3.y - p2.y;
+    const den = dx1 * dy2 - dy1 * dx2;
+    if (Math.abs(den) < eps * eps)
+        return null;
+    const g = (sx * dy2 - sy * dx2) / den;
+    const h = (dx1 * sy - dy1 * sx) / den;
+    return {
+        a: p1.x - p0.x + g * p1.x,
+        b: p3.x - p0.x + h * p3.x,
+        c: p0.x,
+        d: p1.y - p0.y + g * p1.y,
+        e: p3.y - p0.y + h * p3.y,
+        f: p0.y,
+        g,
+        h,
+    };
+};
+// A homography is scale-invariant, so its adjugate IS its inverse up to scale;
+// re-normalizing the bottom-right entry to 1 restores the Homography shape.
+// Returns null when that entry (a·e − b·d) is ~zero — the inverse would put
+// the whole doc plane on the vanishing line.
+export const invertHomography = (m) => {
+    const norm = m.a * m.e - m.b * m.d;
+    if (Math.abs(norm) < 1e-12)
+        return null;
+    return {
+        a: (m.e - m.f * m.h) / norm,
+        b: (m.c * m.h - m.b) / norm,
+        c: (m.b * m.f - m.c * m.e) / norm,
+        d: (m.f * m.g - m.d) / norm,
+        e: (m.a - m.c * m.g) / norm,
+        f: (m.c * m.d - m.a * m.f) / norm,
+        g: (m.d * m.h - m.e * m.g) / norm,
+        h: (m.b * m.g - m.a * m.h) / norm,
+    };
+};
+// Apply a homography to a point. Null when the point sits (numerically) on the
+// vanishing line — the plane there is at infinity.
+export const applyHomography = (m, p) => {
+    const w = m.g * p.x + m.h * p.y + 1;
+    if (Math.abs(w) < 1e-12)
+        return null;
+    return {
+        x: (m.a * p.x + m.b * p.y + m.c) / w,
+        y: (m.d * p.x + m.e * p.y + m.f) / w,
+    };
+};
+const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+// Strictly convex, non-self-intersecting, no ~zero edges: the cross products
+// of consecutive edges all carry the same sign. This is what makes a marked
+// quad usable as a plane (a bowtie or collinear set has no interior).
+export const isQuadConvexNonDegenerate = (corners) => {
+    const eps = relativeEps(corners);
+    let sign = 0;
+    for (let i = 0; i < 4; i++) {
+        const o = corners[i];
+        const a = corners[(i + 1) % 4];
+        const b = corners[(i + 2) % 4];
+        if (lineLength({ a: o, b: a }) < eps)
+            return false;
+        const c = cross(o, a, b);
+        if (Math.abs(c) < eps * eps)
+            return false;
+        const s = c > 0 ? 1 : -1;
+        if (sign === 0)
+            sign = s;
+        else if (s !== sign)
+            return false;
+    }
+    return true;
+};
+// Order four tapped points into the TL,TR,BR,BL contract homographyFromQuad
+// expects: sort by angle around the centroid (screen coords, y down — an
+// ascending atan2 sort walks the hull clockwise on screen), then rotate the
+// cycle so the corner nearest the top-left (min x+y) leads. Null when the
+// points don't form a convex quad in ANY order (three collinear, a repeat...).
+export const normalizeQuadOrder = (pts) => {
+    if (pts.length !== 4)
+        return null;
+    const cx = (pts[0].x + pts[1].x + pts[2].x + pts[3].x) / 4;
+    const cy = (pts[0].y + pts[1].y + pts[2].y + pts[3].y) / 4;
+    const sorted = [...pts].sort((p, q) => Math.atan2(p.y - cy, p.x - cx) - Math.atan2(q.y - cy, q.x - cx));
+    let lead = 0;
+    for (let i = 1; i < 4; i++) {
+        if (sorted[i].x + sorted[i].y < sorted[lead].x + sorted[lead].y) {
+            lead = i;
+        }
+    }
+    const ordered = [
+        sorted[lead],
+        sorted[(lead + 1) % 4],
+        sorted[(lead + 2) % 4],
+        sorted[(lead + 3) % 4],
+    ];
+    return isQuadConvexNonDegenerate(ordered) ? ordered : null;
+};
+// The dimensions a calibration has been given so far. Null until the user has
+// entered them all (through the plane's dimension tiles) — an incomplete
+// calibration renders its geometry but computes nothing.
+const perspectiveDims = (cal) => cal.widthUm != null &&
+    cal.widthUm > 0 &&
+    cal.heightUm != null &&
+    cal.heightUm > 0
+    ? { widthUm: cal.widthUm, heightUm: cal.heightUm }
+    : null;
+// Doc-space point → plane coordinates in micrometers (x across the rectangle's
+// width, y down its height; the TL corner is the origin). Null when the
+// calibration's quad is degenerate, its dimensions aren't entered yet, or the
+// point is on the vanishing line.
+export const docToPlaneUm = (cal, p) => {
+    const dims = perspectiveDims(cal);
+    if (!dims)
+        return null;
+    const h = homographyFromQuad(cal.corners);
+    if (!h)
+        return null;
+    const inv = invertHomography(h);
+    if (!inv)
+        return null;
+    const uv = applyHomography(inv, p);
+    if (!uv)
+        return null;
+    return { x: uv.x * dims.widthUm, y: uv.y * dims.heightUm };
+};
+// Real-world distance between two doc-space points under a calibration,
+// micrometers. Scale mode is a single ratio; perspective mode measures on the
+// rectified plane. Null when the calibration can't produce a finite answer
+// (dimensions not entered yet, zero-length reference line, degenerate quad,
+// point at the vanishing line).
+export const planeDistanceUm = (cal, a, b) => {
+    if (cal.mode === 'scale') {
+        const refDoc = lineLength(cal.refLine);
+        const lengthUm = cal.lengthUm ?? 0;
+        if (!(refDoc > 0) || !(lengthUm > 0))
+            return null;
+        return (lineLength({ a, b }) * lengthUm) / refDoc;
+    }
+    const pa = docToPlaneUm(cal, a);
+    const pb = docToPlaneUm(cal, b);
+    if (!pa || !pb)
+        return null;
+    const dx = pb.x - pa.x;
+    const dy = pb.y - pa.y;
+    const d = Math.sqrt(dx * dx + dy * dy);
+    return Number.isFinite(d) ? d : null;
+};
+// ---------------------------------------------------------------------------
+// Plane edges and dimension slots (the entry tiles the plane tool places).
+// ---------------------------------------------------------------------------
+// The doc-space line of one plane edge — the geometry a dimension tile is
+// magnetized to. Null when the edge doesn't exist on the calibration's mode
+// ('ref' is scale-only, the four edges are perspective-only).
+export const planeEdgeLine = (cal, edge) => {
+    if (cal.mode === 'scale') {
+        return edge === 'ref' ? { a: cal.refLine.a, b: cal.refLine.b } : null;
+    }
+    const [tl, tr, br, bl] = cal.corners;
+    switch (edge) {
+        case 'top':
+            return { a: tl, b: tr };
+        case 'right':
+            return { a: tr, b: br };
+        case 'bottom':
+            return { a: bl, b: br };
+        case 'left':
+            return { a: tl, b: bl };
+        case 'ref':
+            return null;
+    }
+};
+// The real-world dimension (micrometers) an edge's tile displays, or null
+// while it hasn't been entered. Opposite edges share a slot (top ≡ bottom →
+// widthUm, left ≡ right → heightUm) — entering either sets both.
+export const planeDimensionValueUm = (cal, edge) => {
+    if (cal.mode === 'scale') {
+        return edge === 'ref' && cal.lengthUm != null && cal.lengthUm > 0
+            ? cal.lengthUm
+            : null;
+    }
+    if (edge === 'top' || edge === 'bottom') {
+        return cal.widthUm != null && cal.widthUm > 0 ? cal.widthUm : null;
+    }
+    if (edge === 'left' || edge === 'right') {
+        return cal.heightUm != null && cal.heightUm > 0 ? cal.heightUm : null;
+    }
+    return null;
+};
+// The calibration with one edge's dimension set — what a host commits
+// (setPlane) when a value lands in a dimension tile. Ignores nonsensical
+// input (edge/mode mismatch, non-positive value) by returning the calibration
+// unchanged.
+export const withPlaneDimensionUm = (cal, edge, um) => {
+    if (!(um > 0) || !Number.isFinite(um))
+        return cal;
+    if (cal.mode === 'scale') {
+        return edge === 'ref' ? { ...cal, lengthUm: um } : cal;
+    }
+    if (edge === 'top' || edge === 'bottom')
+        return { ...cal, widthUm: um };
+    if (edge === 'left' || edge === 'right')
+        return { ...cal, heightUm: um };
+    return cal;
+};
+// The computed value (micrometers) a plane-sourced line tile should display,
+// or null when it shouldn't (not plane-sourced, no line, no/broken
+// calibration → the host falls back to its usual empty-tile rendering).
+// v1 resolves against the document's single calibration, planes[0].
+export const planeLengthForPlaced = (planes, placed) => {
+    if (placed.valueSource !== 'plane')
+        return null;
+    if (placed.placement !== 'line' || !placed.line)
+        return null;
+    const cal = planes?.[0];
+    if (!cal)
+        return null;
+    return planeDistanceUm(cal, placed.line.a, placed.line.b);
+};
+const MM_UM = 1000;
+const IN_UM = 25400;
+// Minimum cell count the auto spacing targets along the calibrated extent's
+// long axis (the chosen rung is the largest that still yields this many).
+const GRID_MIN_CELLS = 8;
+// Cap on grid lines per direction. A user-entered spacing that's tiny relative
+// to the photo would otherwise emit thousands of segments; the generators
+// double the spacing until they fit, keeping the overlay drawable.
+const GRID_MAX_LINES = 160;
+// The largest "nice" spacing that divides `extentUm` into at least
+// GRID_MIN_CELLS cells: metric walks {1,2,5}×10ⁿ mm; imperial walks
+// {1/8, 1/4, 1/2, 1, 2, 3, 6, 12, 24, 48} in, then keeps doubling (4ft, 8ft…).
+export const nicePlaneGridSpacingUm = (extentUm, system) => {
+    const max = extentUm / GRID_MIN_CELLS;
+    if (system === 'imperial') {
+        const rungs = [0.125, 0.25, 0.5, 1, 2, 3, 6, 12, 24, 48];
+        let best = rungs[0] * IN_UM;
+        for (const r of rungs) {
+            if (r * IN_UM <= max)
+                best = r * IN_UM;
+        }
+        let doubled = 48 * IN_UM * 2;
+        while (doubled <= max) {
+            best = doubled;
+            doubled *= 2;
+        }
+        return best;
+    }
+    let best = 0.1 * MM_UM;
+    for (let pow = 0.1 * MM_UM; pow <= max; pow *= 10) {
+        for (const m of [1, 2, 5]) {
+            if (pow * m <= max)
+                best = pow * m;
+        }
+    }
+    return best;
+};
+// Grid spacing a calibration should render at: the stored override, else the
+// auto spacing for its extent. Null while the calibration's dimensions
+// haven't been entered (nothing meaningful to grid). Scale mode has no
+// intrinsic extent — its grid covers the photo — so callers pass the covered
+// doc rect and the extent is that rect converted to micrometers.
+export const resolvePlaneGridSpacingUm = (cal, system, scaleBounds) => {
+    if (cal.gridSpacingUm && cal.gridSpacingUm > 0)
+        return cal.gridSpacingUm;
+    if (cal.mode === 'perspective') {
+        const dims = perspectiveDims(cal);
+        if (!dims)
+            return null;
+        return nicePlaneGridSpacingUm(Math.max(dims.widthUm, dims.heightUm), system);
+    }
+    const refDoc = lineLength(cal.refLine);
+    const lengthUm = cal.lengthUm ?? 0;
+    if (!scaleBounds || !(refDoc > 0) || !(lengthUm > 0))
+        return null;
+    const umPerDoc = lengthUm / refDoc;
+    const extentUm = Math.max(scaleBounds.width, scaleBounds.height) * umPerDoc;
+    return extentUm > 0 ? nicePlaneGridSpacingUm(extentUm, system) : null;
+};
+// How far past the marked quad the grid extends, as a multiple of the quad's
+// own plane-space size, when the photo's plane-space footprint can't be
+// derived (its corner sits at/behind the vanishing line). Also the hard cap
+// on how far it ever extends — a photo grazing the horizon would otherwise
+// ask for a near-infinite plane extent.
+const GRID_EXTENT_CAP = 12;
+// Liang–Barsky segment/rect clip, DOC space. Null when fully outside.
+const clipSegmentToRect = (a, b, rect) => {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    let t0 = 0;
+    let t1 = 1;
+    const edges = [
+        [-dx, a.x - rect.x],
+        [dx, rect.x + rect.width - a.x],
+        [-dy, a.y - rect.y],
+        [dy, rect.y + rect.height - a.y],
+    ];
+    for (const [p, q] of edges) {
+        if (p === 0) {
+            if (q < 0)
+                return null;
+            continue;
+        }
+        const r = q / p;
+        if (p < 0) {
+            if (r > t1)
+                return null;
+            if (r > t0)
+                t0 = r;
+        }
+        else {
+            if (r < t0)
+                return null;
+            if (r < t1)
+                t1 = r;
+        }
+    }
+    if (t0 >= t1)
+        return null;
+    return {
+        a: { x: a.x + t0 * dx, y: a.y + t0 * dy },
+        b: { x: a.x + t1 * dx, y: a.y + t1 * dy },
+    };
+};
+// Grid lines of a perspective calibration, DOC space, spanning the whole
+// photo (`bounds` — the first background layer's doc rect, or the document
+// rect): the plane's grid continues past the marked quad across everything
+// coplanar with it. Straight lines stay straight under a homography, so each
+// line is two endpoints mapped and then clipped to the photo.
+//
+// The plane-space region to grid comes from pulling the photo's corners back
+// through the inverse homography. Near the plane's horizon (the vanishing
+// line) plane coordinates diverge, so the region is clamped to
+// GRID_EXTENT_CAP× the quad's size — and when a photo corner sits at/behind
+// the horizon (its pullback fails or lands behind the camera, w ≤ 0), the
+// full clamped region is used instead. Lines whose endpoints stray onto the
+// far side of the horizon are dropped (w stays positive across a segment
+// only when it's positive at both ends — w is affine on the plane).
+export const planeGridSegments = (cal, spacingUm, bounds) => {
+    const dims = perspectiveDims(cal);
+    const h = homographyFromQuad(cal.corners);
+    if (!dims ||
+        !h ||
+        !(spacingUm > 0) ||
+        !(bounds.width > 0) ||
+        !(bounds.height > 0)) {
+        return [];
+    }
+    const inv = invertHomography(h);
+    if (!inv)
+        return [];
+    // Plane-space (unit-quad uv) region covering the photo, clamped.
+    let minU = -GRID_EXTENT_CAP;
+    let maxU = 1 + GRID_EXTENT_CAP;
+    let minV = -GRID_EXTENT_CAP;
+    let maxV = 1 + GRID_EXTENT_CAP;
+    const photoCorners = [
+        { x: bounds.x, y: bounds.y },
+        { x: bounds.x + bounds.width, y: bounds.y },
+        { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+        { x: bounds.x, y: bounds.y + bounds.height },
+    ];
+    let u0 = Infinity;
+    let u1 = -Infinity;
+    let v0 = Infinity;
+    let v1 = -Infinity;
+    let allMapped = true;
+    for (const c of photoCorners) {
+        const uv = applyHomography(inv, c);
+        // Reject pullbacks behind the camera: the corner maps to a plane point
+        // whose FORWARD image (w) is non-positive — the far side of the horizon.
+        if (!uv || h.g * uv.x + h.h * uv.y + 1 <= 1e-9) {
+            allMapped = false;
+            break;
+        }
+        u0 = Math.min(u0, uv.x);
+        u1 = Math.max(u1, uv.x);
+        v0 = Math.min(v0, uv.y);
+        v1 = Math.max(v1, uv.y);
+    }
+    if (allMapped) {
+        minU = Math.max(minU, u0);
+        maxU = Math.min(maxU, u1);
+        minV = Math.max(minV, v0);
+        maxV = Math.min(maxV, v1);
+    }
+    // Always cover at least the quad itself.
+    minU = Math.min(minU, 0);
+    maxU = Math.max(maxU, 1);
+    minV = Math.min(minV, 0);
+    maxV = Math.max(maxV, 1);
+    // Spacing in uv units per axis; doubled until the line count fits the cap.
+    let s = spacingUm;
+    const lineCount = (step) => (maxU - minU) / (step / dims.widthUm) +
+        (maxV - minV) / (step / dims.heightUm);
+    while (lineCount(s) > 2 * GRID_MAX_LINES && Number.isFinite(s)) {
+        s *= 2;
+    }
+    const segments = [];
+    const pushLine = (uvA, uvB) => {
+        // Both endpoints must sit on the camera side of the horizon (w > 0);
+        // w is affine over the plane, so the whole segment then is too.
+        if (h.g * uvA.x + h.h * uvA.y + 1 <= 1e-9)
+            return;
+        if (h.g * uvB.x + h.h * uvB.y + 1 <= 1e-9)
+            return;
+        const a = applyHomography(h, uvA);
+        const b = applyHomography(h, uvB);
+        if (!a || !b)
+            return;
+        const clipped = clipSegmentToRect(a, b, bounds);
+        if (clipped)
+            segments.push(clipped);
+    };
+    const stepU = s / dims.widthUm;
+    const stepV = s / dims.heightUm;
+    for (let k = Math.ceil(minU / stepU); k * stepU <= maxU; k++) {
+        const u = k * stepU;
+        pushLine({ x: u, y: minV }, { x: u, y: maxV });
+    }
+    for (let k = Math.ceil(minV / stepV); k * stepV <= maxV; k++) {
+        const v = k * stepV;
+        pushLine({ x: minU, y: v }, { x: maxU, y: v });
+    }
+    return segments;
+};
+// Axis-aligned grid of a scale calibration across `bounds` (the photo's doc
+// rect, or the document rect when there's no background), DOC space. Lines
+// anchor at the bounds origin.
+export const planeGridSegmentsForScale = (cal, spacingUm, bounds) => {
+    const refDoc = lineLength(cal.refLine);
+    const lengthUm = cal.lengthUm ?? 0;
+    if (!(refDoc > 0) ||
+        !(lengthUm > 0) ||
+        !(spacingUm > 0) ||
+        !(bounds.width > 0) ||
+        !(bounds.height > 0)) {
+        return [];
+    }
+    let spacingDoc = (spacingUm * refDoc) / lengthUm;
+    while (Math.max(bounds.width, bounds.height) / spacingDoc > GRID_MAX_LINES &&
+        Number.isFinite(spacingDoc)) {
+        spacingDoc *= 2;
+    }
+    const segments = [];
+    for (let x = bounds.x + spacingDoc; x < bounds.x + bounds.width; x += spacingDoc) {
+        segments.push({
+            a: { x, y: bounds.y },
+            b: { x, y: bounds.y + bounds.height },
+        });
+    }
+    for (let y = bounds.y + spacingDoc; y < bounds.y + bounds.height; y += spacingDoc) {
+        segments.push({
+            a: { x: bounds.x, y },
+            b: { x: bounds.x + bounds.width, y },
+        });
+    }
+    return segments;
+};

package/dist/annotation/canvas/tools/measurementTool.d.ts

@@ -11,6 +11,7 @@ export interface MeasurementToolOptions {
     selectToolId?: string;
     onAutoSwitch?: (toToolId: string) => void;
     onPlaced?: (measurement: PlacedMeasurementRef) => void;
+    planeComputedValues?: boolean;
     color?: string;
     width?: number;
     cap?: StrokeCap;

package/dist/annotation/canvas/tools/measurementTool.js

@@ -38,6 +38,9 @@ const buildMeasurement = (opts) => {
         showValue: true,
         createdAt: Date.now(),
         ...lineStyleFields(placement, style),
+        ...(opts.valueSource !== undefined && placement === 'line'
+            ? { valueSource: opts.valueSource }
+            : {}),
     };
     if (placement === 'rectangle') {
         const rect = { a, b };
@@ -81,6 +84,14 @@ export const createMeasurementTool = (options = {}) => {
         startCap: options.startCap,
         dash: options.dash,
     };
+    // 'plane' when this line should display a calibration-computed value:
+    // opted in via planeComputedValues AND the live document actually carries a
+    // calibration at draw time.
+    const valueSourceFor = (ctx) => options.planeComputedValues &&
+        placement === 'line' &&
+        (ctx.document.planes?.length ?? 0) > 0
+        ? 'plane'
+        : undefined;
     const place = (ctx, measurement) => {
         ctx.commit({ ops: [{ op: 'addMeasurement', measurement }] });
         options.onPlaced?.(measurement);
@@ -140,6 +151,7 @@ export const createMeasurementTool = (options = {}) => {
                 a: s.startWorld,
                 b: event.world,
                 style,
+                valueSource: valueSourceFor(ctx),
             });
             ctx.preview({ ops: [{ op: 'addMeasurement', measurement }] });
             return { ...s, moved: true };
@@ -163,6 +175,7 @@ export const createMeasurementTool = (options = {}) => {
                 a: s.startWorld,
                 b: event.world,
                 style,
+                valueSource: valueSourceFor(ctx),
             }));
         },
         onCancel(_state, ctx) {

package/dist/annotation/canvas/tools/planeTool.d.ts

@@ -0,0 +1,13 @@
+import type { PlacedMeasurementRef, PlaneCalibration, PlaneCalibrationMode } from '../../../types/annotation.js';
+import type { Tool } from '../Tool.js';
+export interface PlaneToolOptions {
+    id?: string;
+    label?: string;
+    mode: PlaneCalibrationMode;
+    onPlaced?(plane: PlaneCalibration): void;
+    onInvalidQuad?(): void;
+    onExistingPlane?(): void;
+    onDimensionTileTap?(tile: PlacedMeasurementRef): void;
+    minDragPx?: number;
+}
+export declare const createPlaneTool: (options: PlaneToolOptions) => Tool;