@realsee/dnalogel 3.81.21 → 3.81.23

package/libs/MeasurePluginV2/Controller.js

@@ -0,0 +1,125 @@
+var l = Object.defineProperty, c = Object.defineProperties;
+var g = Object.getOwnPropertyDescriptors;
+var d = Object.getOwnPropertySymbols;
+var m = Object.prototype.hasOwnProperty, M = Object.prototype.propertyIsEnumerable;
+var o = (r, a, t) => a in r ? l(r, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[a] = t, u = (r, a) => {
+  for (var t in a || (a = {}))
+    m.call(a, t) && o(r, t, a[t]);
+  if (d)
+    for (var t of d(a))
+      M.call(a, t) && o(r, t, a[t]);
+  return r;
+}, p = (r, a) => c(r, g(a));
+var s = (r, a, t) => (o(r, typeof a != "symbol" ? a + "" : a, t), t);
+import { MeasurePointSelector as v } from "./PointSelector.js";
+import { MeasureController as f } from "../MeasurePlugin/Controller.js";
+import { isTouchDevice as S } from "../shared-utils/isTouchDevice.js";
+import { MeasureMagnifier as E } from "./Magnifier.js";
+import { MeasurePointHelperV2 as P } from "./PointHelper.js";
+import { EdgeSnapCache as k, resolveEdgeSnapOptions as w } from "./edgeSnap.js";
+import { QuickNormalMeasure as C } from "./normalMeasure.js";
+function F() {
+  return typeof window == "undefined" ? 1 : Math.min(2, Math.max(1, Math.ceil(window.devicePixelRatio || 1)));
+}
+class D extends f {
+  constructor(t, e) {
+    super(t, e);
+    /** 最近一次查询到的候选边数量，示例页 / 调试用 */
+    s(this, "lastEdgeSnapEdgeCount", 0);
+    s(this, "v2Five");
+    s(this, "v2Magnifier");
+    s(this, "v2Attached", !1);
+    s(this, "edgeSnapOptions");
+    s(this, "edgeSnapCache", new k());
+    s(this, "quickMeasureEnabled");
+    s(this, "quickMeasure");
+    this.v2Five = t, this.edgeSnapOptions = w(e == null ? void 0 : e.edgeSnap), this.quickMeasureEnabled = (e == null ? void 0 : e.quickMeasure) !== !1;
+    const i = this.measure;
+    this.measure = () => {
+      var h;
+      this.edgeSnapCache.clear(), this.lastEdgeSnapEdgeCount = 0, this.pointSelector.clearDynamicAdhereLine(), (h = this.quickMeasure) == null || h.reset(), i();
+    };
+    const n = this.dispose;
+    this.dispose = () => {
+      var h;
+      this.v2Attached && ((h = this.quickMeasure) == null || h.detach(this.pointSelector)), this.quickMeasure = void 0, n();
+    };
+  }
+  get edgeSnapEnabled() {
+    return this.edgeSnapOptions.enabled;
+  }
+  /** 运行时开关模型边缘吸附（不需要重开测量） */
+  setEdgeSnapEnabled(t) {
+    this.edgeSnapOptions.enabled = t, this.edgeSnapCache.clear(), this.lastEdgeSnapEdgeCount = 0, this.pointSelector.clearDynamicAdhereLine(), this.pointSelector.refresh(), this.v2Five.needsRender = !0;
+  }
+  /** V2 的放大镜实例；需要临时关掉叠加层做对比时，可以 magnifier.setOverlayEnabled(false) */
+  get magnifier() {
+    return this.v2Magnifier;
+  }
+  createPointSelector() {
+    return new v(this.v2Five, { mode: "cursor", helper: u({ pointHelper: "highlight" }, S ? { magnifierParams: { width: 150, height: 150, dragEnabled: !1, autoFixPCPosition: !1, initialPosition: { left: "12px", top: "12px" } } } : {}), skipPanorama: !1 });
+  }
+  get pointSelector() {
+    const t = super.pointSelector;
+    return this.v2Attached || (this.v2Attached = !0, this.attachOverlayRenderers(t)), t;
+  }
+  attachOverlayRenderers(t) {
+    const e = t.pointSelectorHelper;
+    this.attachMagnifier(e), this.attachPointHelper(e), this.attachEdgeSnap(t), this.attachQuickMeasure(t), t.on("intersectionUpdate", (i) => {
+      var n;
+      (n = this.v2Magnifier) == null || n.setIntersection(i != null ? i : null);
+    });
+  }
+  attachMagnifier(t) {
+    const e = t.magnifier;
+    if (!e)
+      return;
+    const i = new E(this.v2Five, p(u({}, e.config), {
+      width: e.width,
+      height: e.height,
+      scale: e.scale,
+      // 这两项是 V2 的新默认：按设备像素读回 + 只旋转的近景视角
+      readPixelsPixelRatio: F(),
+      closeupMode: "rotate",
+      // 远点自动提高光学倍率，放大镜里看到的物体大小基本恒定
+      adaptiveReadWindow: !0
+    }));
+    e.containerDom && i.appendTo(e.containerDom), e.state.enabled && i.enable(), t.magnifier = i, e.dispose(), this.v2Magnifier = i;
+  }
+  attachPointHelper(t) {
+    const e = t.pointHelper, i = new P(this.v2Five);
+    t.pointHelper = i, e == null || e.dispose(), e != null && e.parent && e.parent.remove(e);
+  }
+  /** 双击快速测量：只在测量过程中生效，选点链路仍由原 MeasureController 负责 */
+  attachQuickMeasure(t) {
+    this.quickMeasureEnabled && (this.quickMeasure = new C({
+      getCamera: () => this.v2Five.camera,
+      getElement: () => this.v2Five.getElement(),
+      raycast: (e) => this.v2Five.model.intersectRaycaster(e),
+      getMeasuringPoints: () => {
+        var e, i;
+        return (i = (e = this.currentMeasureMesh) == null ? void 0 : e.points) != null ? i : null;
+      },
+      finish: (e, i) => {
+        const n = this.currentMeasureMesh;
+        return n ? (n.setPoints([e, i]), this.continueMeasureFrom ? (this.continueMeasureFrom(i), !0) : (this.endMeasure(), !1)) : !1;
+      },
+      cancelStart: () => this.undo()
+    }), this.quickMeasure.attach(t));
+  }
+  /**
+   * 模型边缘吸附：每次选点器计算吸附前，按当前落点取附近的模型边界线。
+   * 真正的吸附判断（3D 距离 / 屏幕距离）仍在 PointSelector 里，这里只负责供线。
+   */
+  attachEdgeSnap(t) {
+    t.adhereLineProvider = ({ intersection: e }) => {
+      if (!(e != null && e.point))
+        return [];
+      const i = this.edgeSnapCache.query(this.v2Five.model, e.point, this.edgeSnapOptions);
+      return this.lastEdgeSnapEdgeCount = i.length, i;
+    };
+  }
+}
+export {
+  D as MeasureControllerV2
+};

package/libs/MeasurePluginV2/Magnifier.d.ts

@@ -0,0 +1,74 @@
+import type { Five } from '@realsee/five';
+import * as THREE from 'three';
+import { Magnifier, type MagnifierParameter, type PointIntersection } from '../shared-utils';
+export { CLOSEUP_DISTANCE } from './closeupView';
+/** 近景取景方式 */
+export type MeasureCloseupMode = 
+/** 只旋转、不平移：与主视图共用机位，无新增视差；默认 */
+'rotate'
+/** 旧行为：把相机推到落点附近 0.6m，再朝法线偏转；放大倍率高，但会产生视差 */
+ | 'push'
+/** 完全沿用主相机，只放大局部像素 */
+ | 'off';
+export interface MeasureMagnifierOptions extends MagnifierParameter {
+    /** 是否绘制坐标轴 / 平面框叠加层，默认 true（关掉后行为与现状 Magnifier 完全一致） */
+    overlayEnabled?: boolean;
+    /** 兼容旧参数：false 等价于 closeupMode='off' */
+    closeupEnabled?: boolean;
+    /** 近景取景方式，默认 'rotate' */
+    closeupMode?: MeasureCloseupMode;
+}
+/**
+ * 量尺 V2 用的放大镜。
+ *
+ * 完全复用 Magnifier 的「读像素 + 放大」逻辑（直接 super.render()），
+ * 只是在其之后往同一个 2D canvas 上叠加坐标轴与落点平面框。
+ */
+export declare class MeasureMagnifier extends Magnifier {
+    /** 父类把 five 存成了 private，这里自己留一份，叠加层投影时要用 */
+    private overlayFive;
+    /** 父类把 context 存成了 private；getContext('2d') 拿到的是同一个实例 */
+    private overlayContext;
+    /** 由 PointSelector 的 intersectionUpdate 事件注入 */
+    private overlayIntersection;
+    private overlayEnabled;
+    private closeupMode;
+    /** 本次渲染实际使用的相机（推近后的副本），叠加层投影必须和它一致 */
+    private overlayCamera;
+    /** 本次放大镜渲染的落点；相机取向以它为准，避免和交点数据错帧 */
+    private renderPoint;
+    /** 近景视角的平滑状态 */
+    private closeupState;
+    constructor(five: Five, options?: MeasureMagnifierOptions);
+    renderWithPoint(point: THREE.Vector3): void;
+    /** 每次交点更新时调用；传 null 表示当前没有命中任何模型 */
+    setIntersection(intersection: PointIntersection | null): void;
+    /** 开关叠加层，用于灰度 / 排查问题 */
+    setOverlayEnabled(enabled: boolean): void;
+    /** 开关近景 3D 视角，用于灰度 / 对比；开启时使用默认的 rotate 模式 */
+    setCloseupEnabled(enabled: boolean): void;
+    /** 切换近景取景方式，用于三种模式的对比 */
+    setCloseupMode(mode: MeasureCloseupMode): void;
+    getCloseupMode(): MeasureCloseupMode;
+    render(): void;
+    private renderOverlay;
+    /**
+     * 近景 3D 视角：读像素前调整相机取向，让视线朝落点所在表面的法线偏一点
+     * （斜向 / 侧向的表面在放大镜里以更接近正面的角度呈现），读完立即还原。
+     *
+     * 两种模式：
+     * - rotate（默认）：只旋转、不平移。与主视图共用同一机位，不产生视差，全景 / 模型都按同一视点采样；
+     * - push（旧行为）：把相机推到落点附近 0.6m，放大倍率更高，但会产生视差和近距透视形变。
+     *
+     * 姿态由主相机绕落点做最小旋转得到：偏转角有上限、画面不翻滚。
+     */
+    private moveCameraCloseup;
+    /** 只记录投影要用的矩阵；Five 的相机 clone() 开销大，也不保证可用 */
+    private snapshotOverlayCamera;
+    private getOverlayContext;
+    /**
+     * 还原 Magnifier.render() 内部的取值，用来把世界坐标映射到放大镜 canvas 坐标。
+     * 这些换算必须和父类保持一致，父类改动时需要同步。
+     */
+    private getOverlayViewport;
+}

package/libs/MeasurePluginV2/Magnifier.js

@@ -0,0 +1,175 @@
+var m = Object.defineProperty;
+var v = (s, i, e) => i in s ? m(s, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[i] = e;
+var a = (s, i, e) => (v(s, typeof i != "symbol" ? i + "" : i, e), e);
+import * as d from "three";
+import "../shared-utils/tag.js";
+import { Magnifier as y } from "../shared-utils/three/Magnifier.js";
+import "../shared-utils/three/PointSelector/index.js";
+import "../shared-utils/three/CSS3DRenderer/index.js";
+import "../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import "@realsee/five/line";
+import "../shared-utils/three/core/Five_LineMaterial2.js";
+import "../shared-utils/three/core/Sphere.js";
+import "../shared-utils/three/blink.js";
+import "../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../vendor/earcut/src/earcut.js";
+import "../shared-utils/five/FivePuppet.js";
+import { CLOSEUP_MAX_DEVIATION as f, resolveCloseupView as x } from "./closeupView.js";
+import { drawMeasureOverlay as M, getWorldNormal as g } from "./PointOverlay.js";
+class U extends y {
+  constructor(e, t) {
+    var r;
+    super(e, t != null ? t : {});
+    /** 父类把 five 存成了 private，这里自己留一份，叠加层投影时要用 */
+    a(this, "overlayFive");
+    /** 父类把 context 存成了 private；getContext('2d') 拿到的是同一个实例 */
+    a(this, "overlayContext", null);
+    /** 由 PointSelector 的 intersectionUpdate 事件注入 */
+    a(this, "overlayIntersection", null);
+    a(this, "overlayEnabled");
+    a(this, "closeupMode");
+    /** 本次渲染实际使用的相机（推近后的副本），叠加层投影必须和它一致 */
+    a(this, "overlayCamera", null);
+    /** 本次放大镜渲染的落点；相机取向以它为准，避免和交点数据错帧 */
+    a(this, "renderPoint", null);
+    /** 近景视角的平滑状态 */
+    a(this, "closeupState", null);
+    this.overlayFive = e, this.overlayEnabled = (t == null ? void 0 : t.overlayEnabled) !== !1, this.closeupMode = (r = t == null ? void 0 : t.closeupMode) != null ? r : (t == null ? void 0 : t.closeupEnabled) === !1 ? "off" : "rotate";
+  }
+  renderWithPoint(e) {
+    this.renderPoint = e.clone(), super.renderWithPoint(e);
+  }
+  /** 每次交点更新时调用；传 null 表示当前没有命中任何模型 */
+  setIntersection(e) {
+    this.overlayIntersection = e;
+  }
+  /** 开关叠加层，用于灰度 / 排查问题 */
+  setOverlayEnabled(e) {
+    this.overlayEnabled = e;
+  }
+  /** 开关近景 3D 视角，用于灰度 / 对比；开启时使用默认的 rotate 模式 */
+  setCloseupEnabled(e) {
+    this.setCloseupMode(e ? "rotate" : "off");
+  }
+  /** 切换近景取景方式，用于三种模式的对比 */
+  setCloseupMode(e) {
+    this.closeupMode = e, e === "off" && (this.closeupState = null);
+  }
+  getCloseupMode() {
+    return this.closeupMode;
+  }
+  render() {
+    const e = this.moveCameraCloseup();
+    try {
+      super.render(), this.snapshotOverlayCamera();
+    } finally {
+      e == null || e();
+    }
+    try {
+      this.renderOverlay();
+    } catch (t) {
+      console.warn("MeasureMagnifier: 叠加层绘制失败", t);
+    }
+  }
+  renderOverlay() {
+    if (!this.overlayEnabled || !this.state.enabled)
+      return;
+    const e = this.overlayIntersection;
+    if (!e || e.isVirtual || !e.point)
+      return;
+    const t = this.getOverlayViewport();
+    if (!t)
+      return;
+    const r = this.getOverlayContext();
+    r && M(r, t, e);
+  }
+  /**
+   * 近景 3D 视角：读像素前调整相机取向，让视线朝落点所在表面的法线偏一点
+   * （斜向 / 侧向的表面在放大镜里以更接近正面的角度呈现），读完立即还原。
+   *
+   * 两种模式：
+   * - rotate（默认）：只旋转、不平移。与主视图共用同一机位，不产生视差，全景 / 模型都按同一视点采样；
+   * - push（旧行为）：把相机推到落点附近 0.6m，放大倍率更高，但会产生视差和近距透视形变。
+   *
+   * 姿态由主相机绕落点做最小旋转得到：偏转角有上限、画面不翻滚。
+   */
+  moveCameraCloseup() {
+    var p;
+    if (this.closeupMode === "off" || !this.state.enabled) {
+      this.closeupState = null;
+      return;
+    }
+    const e = this.overlayIntersection, t = (p = this.renderPoint) != null ? p : e == null ? void 0 : e.point;
+    if (!e || e.isVirtual || !t) {
+      this.closeupState = null;
+      return;
+    }
+    const r = this.overlayFive.camera;
+    if (!r || r.isOrthographicCamera)
+      return;
+    const h = e.point && e.point.distanceTo(t) < 1e-4 ? g(e) : null;
+    r.updateMatrixWorld();
+    const l = this.closeupMode === "rotate", o = l ? Math.max(0, Math.min(f, d.MathUtils.degToRad(r.fov || 60) / 2 - d.MathUtils.degToRad(4))) : void 0, n = x({
+      point: t,
+      normal: h,
+      cameraPosition: r.position,
+      cameraQuaternion: r.quaternion,
+      previous: this.closeupState,
+      translate: !l,
+      maxDeviation: o
+    });
+    if (!n)
+      return;
+    this.closeupState = n.state;
+    const c = r.position.clone(), u = r.quaternion.clone();
+    return r.position.copy(n.position), r.quaternion.copy(n.quaternion), r.updateMatrixWorld(!0), () => {
+      r.position.copy(c), r.quaternion.copy(u), r.updateMatrixWorld(!0);
+    };
+  }
+  /** 只记录投影要用的矩阵；Five 的相机 clone() 开销大，也不保证可用 */
+  snapshotOverlayCamera() {
+    var r;
+    const e = this.overlayFive.camera;
+    if (!e)
+      return;
+    const t = (r = this.overlayCamera) != null ? r : this.overlayCamera = new d.Camera();
+    t.matrixWorld.copy(e.matrixWorld), t.matrixWorldInverse.copy(e.matrixWorldInverse), t.projectionMatrix.copy(e.projectionMatrix), t.projectionMatrixInverse.copy(e.projectionMatrixInverse), t.position.copy(e.position);
+  }
+  getOverlayContext() {
+    return this.overlayContext || (this.overlayContext = this.canvas.getContext("2d")), this.overlayContext;
+  }
+  /**
+   * 还原 Magnifier.render() 内部的取值，用来把世界坐标映射到放大镜 canvas 坐标。
+   * 这些换算必须和父类保持一致，父类改动时需要同步。
+   */
+  getOverlayViewport() {
+    var n;
+    const e = this.overlayFive;
+    if (!e.renderer || !e.camera)
+      return null;
+    const t = this.getRenderCenter(), r = e.renderer.getSize(new d.Vector2()), [h, l] = (() => {
+      var c;
+      if (t.isVector3) {
+        const u = t.clone().project((c = this.overlayCamera) != null ? c : e.camera);
+        return [(u.x + 1) / 2 * r.x, (u.y + 1) / 2 * r.y];
+      }
+      return [t.x, r.y - t.y];
+    })(), o = this.getReadWindowInfo();
+    return {
+      camera: (n = this.overlayCamera) != null ? n : e.camera,
+      renderSize: r,
+      readLeft: h - o.readWidth / 2,
+      readTop: l - o.readHeight / 2,
+      readPixelsHeight: o.readHeight,
+      pixelRadio: o.radio,
+      canvasWidth: o.imageWidth,
+      canvasHeight: o.imageHeight,
+      // 高清读回时 canvas 变大，线宽按 backing / CSS 的比例放大，保持和旧版一致的观感
+      lineScale: o.imageWidth / this.width
+    };
+  }
+}
+export {
+  U as MeasureMagnifier
+};

package/libs/MeasurePluginV2/PointHelper.d.ts

@@ -0,0 +1,22 @@
+import type { Five } from '@realsee/five';
+import type { Intersection } from '../typings/typings';
+import { PointHelper2 } from '../shared-utils/three/PointSelector/utils/PointHelper2';
+/**
+ * 场景里的小光标（选点处那团白圈 + 法线管）的 V2 版本。
+ *
+ * 完全继承 PointHelper2，只做两件事：
+ * 1. 把那根浅蓝色的法线管换成绿色（PRD 里绿色 = Z 轴）；
+ * 2. 按和放大镜同一套平面坐标系（buildPlaneFrame）补上红色 X、蓝色 Y 和红色截面框。
+ *
+ * 选点算法（射线、吸附、打点）全都在 PointSelector 里，这里只负责画，不参与任何选点判断。
+ */
+export declare class MeasurePointHelperV2 extends PointHelper2 {
+    /** 只放 V2 新增的红 / 蓝轴和截面框，拿不到法线时整体隐藏 */
+    private readonly overlayGroup;
+    constructor(five: Five);
+    updateWithIntersect(intersect: Intersection): void;
+    /** 不挂载 cssBallMesh，避免蓝色小球盖住绿色 Z 轴端点 */
+    show(): void;
+    hide(): void;
+    private paintAxisMesh;
+}

package/libs/MeasurePluginV2/PointHelper.js

@@ -0,0 +1,63 @@
+var x = Object.defineProperty;
+var M = (o, r, s) => r in o ? x(o, r, { enumerable: !0, configurable: !0, writable: !0, value: s }) : o[r] = s;
+var d = (o, r, s) => (M(o, typeof r != "symbol" ? r + "" : r, s), s);
+import * as t from "three";
+import { PointHelper2 as w } from "../shared-utils/three/PointSelector/utils/PointHelper2.js";
+import { OVERLAY_STYLE as a, getWorldNormal as v, buildPlaneFrame as b } from "./PointOverlay.js";
+const f = 3e-3;
+function u(o, r, s) {
+  const i = new t.CurvePath();
+  i.add(new t.LineCurve3(o, r));
+  const e = new t.TubeGeometry(i, 4, f, 8), n = new t.MeshBasicMaterial({
+    color: s,
+    depthTest: !1,
+    transparent: !0
+    // 与 PointHelper2 的管一致，要参与透明排序
+  }), l = new t.Mesh(e, n);
+  return l.disableGetPixel = !0, l;
+}
+class G extends w {
+  constructor(s) {
+    super(s);
+    /** 只放 V2 新增的红 / 蓝轴和截面框，拿不到法线时整体隐藏 */
+    d(this, "overlayGroup", new t.Group());
+    this.remove(this.cssBallMesh), this.paintAxisMesh(this.lineMesh, a.axisZColor), this.paintAxisMesh(this.ballMesh, a.axisZColor);
+    const i = this.ballMesh.position.z || 0.18, e = i * a.planeSideRadiusScale / (2 * a.axisLengthRadiusScale), n = u(new t.Vector3(-i, 0, 0), new t.Vector3(i, 0, 0), a.axisXColor), l = u(new t.Vector3(0, -i, 0), new t.Vector3(0, i, 0), a.axisYColor);
+    n.renderOrder = 3, l.renderOrder = 3, this.overlayGroup.add(n, l);
+    const h = [
+      new t.Vector3(-e, -e, 0),
+      new t.Vector3(e, -e, 0),
+      new t.Vector3(e, e, 0),
+      new t.Vector3(-e, e, 0)
+    ];
+    h.forEach((p, m) => {
+      const c = u(p, h[(m + 1) % h.length], a.planeBorderColor);
+      c.renderOrder = 2, this.overlayGroup.add(c);
+    }), this.add(this.overlayGroup), this.hide();
+  }
+  updateWithIntersect(s) {
+    const i = s == null ? void 0 : s.point;
+    if (!i)
+      return;
+    this.position.copy(i);
+    const e = s.isVirtual ? null : v(s);
+    if (this.overlayGroup.visible = e !== null, this.lineMesh.visible = e !== null, this.ballMesh.visible = e !== null, this.planeMesh.visible = e !== null, this.ringMesh.visible = e !== null, !e)
+      return;
+    const n = b(e);
+    this.quaternion.setFromRotationMatrix(new t.Matrix4().makeBasis(n.xAxis, n.yAxis, n.normal));
+  }
+  /** 不挂载 cssBallMesh，避免蓝色小球盖住绿色 Z 轴端点 */
+  show() {
+    this.visible = !0;
+  }
+  hide() {
+    this.visible = !1;
+  }
+  paintAxisMesh(s, i) {
+    const e = s.material;
+    e.color.set(i), e.needsUpdate = !0;
+  }
+}
+export {
+  G as MeasurePointHelperV2
+};

package/libs/MeasurePluginV2/PointOverlay.d.ts

@@ -0,0 +1,93 @@
+import * as THREE from 'three';
+import type { PointIntersection } from '../shared-utils';
+/**
+ * 放大镜内的叠加绘制：坐标轴（PRD M1）+ 落点平面框（PRD M2）
+ *
+ * 为什么画在 2D canvas 上而不是往场景里加 THREE 物体：
+ * 放大镜并不是「再渲染一遍场景」，而是用 five.getPixels() 读一小块像素，翻转后 putImageData 到 2D canvas 上。
+ * 所以场景里加什么物体都不会出现在放大镜里，只有 putImageData 之后在 2D context 上画的才会出现。
+ */
+/** PRD 五、视觉与设计规范 */
+export declare const OVERLAY_STYLE: {
+    /** M1-2 X 轴颜色 */
+    readonly axisXColor: "#EC4A4E";
+    /** M1-2 Y 轴颜色 */
+    readonly axisYColor: "#1677FF";
+    /** M1-2 Z 轴颜色 */
+    readonly axisZColor: "#065C08";
+    /** M1-5 线条宽度 */
+    readonly axisLineWidth: 1.5;
+    /** 轴线不透明度 */
+    readonly axisOpacity: 0.9;
+    /** M1-4 轴线长度 = 放大镜半径 × 0.9 */
+    readonly axisLengthRadiusScale: 0.9;
+    /** Z 轴端点（朝外的一端）绿色圆点半径 = 放大镜半径 × 该系数 */
+    readonly axisTipDotRadiusScale: 0.03;
+    /** M2 平面框边框颜色 */
+    readonly planeBorderColor: "#FF4D4F";
+    /** M2-3 边框宽度 */
+    readonly planeBorderWidth: 1.5;
+    /** M2-3 边框不透明度 */
+    readonly planeBorderOpacity: 0.9;
+    /** M2-2 轴对齐面框边长 = 放大镜半径 × 1.2 */
+    readonly planeSideRadiusScale: 1.2;
+    /** M2 轴对齐判定：表面法线与最近世界轴的夹角小于该值即视为墙 / 地 / 顶 */
+    readonly axisSnapAngle: 15;
+};
+/**
+ * 放大镜把渲染目标上的一块矩形区域拉伸到了 canvas 上，这里描述这块区域以及映射关系。
+ * 字段取值与 Magnifier.render() 内部完全一致，父类改动时需要同步。
+ */
+export interface MagnifierViewport {
+    camera: THREE.Camera;
+    /** 渲染目标尺寸，与 Magnifier.render() 里 getSize() 的结果一致 */
+    renderSize: THREE.Vector2;
+    /** 读取区域左边缘在渲染目标像素坐标系中的横坐标 */
+    readLeft: number;
+    /** 读取区域下边缘的纵坐标（渲染目标像素坐标系 y 轴向上，与 Magnifier.render() 里的同名量一致） */
+    readTop: number;
+    /** 读取区域的高度（渲染目标像素） */
+    readPixelsHeight: number;
+    /** 一个渲染像素在放大镜 canvas 上重复的倍数 */
+    pixelRadio: number;
+    /** 放大镜 canvas 的宽高（设备像素） */
+    canvasWidth: number;
+    canvasHeight: number;
+    /**
+     * 叠加层线宽缩放：canvas 设备像素 / CSS 像素。
+     * 高清读回时 canvas 变大，固定线宽需要同步放大，否则轴线和平面框会变细。
+     */
+    lineScale?: number;
+}
+/**
+ * 求交点的世界坐标系法线。
+ * 点云等拿不到 face 的情况返回 null（此时只画坐标轴，不画平面框）。
+ *
+ * 注意：这里不能再乘模型的法线矩阵。THREE.Mesh.raycast 在生成相交结果时已经把面法线
+ * 用 normalMatrix 变换到世界坐标系了；PointSelector 吸附到平面时合成的 Face3 更是直接写入
+ * 世界坐标系的平面法线。再乘一次会让法线偏离真实表面法线，红色平面框也就不再贴合选点所在面。
+ */
+export declare function getWorldNormal(intersection: PointIntersection): THREE.Vector3 | null;
+export interface PlaneFrame {
+    /** 平面法线，也就是绿色 Z 轴的方向（朝表面外侧） */
+    normal: THREE.Vector3;
+    /** 平面内的水平方向 = 红色 X 轴 */
+    xAxis: THREE.Vector3;
+    /** 平面内最接近竖直的方向 = 蓝色 Y 轴 */
+    yAxis: THREE.Vector3;
+    /** 轴对齐面吸附到的世界轴下标（0=X / 1=Y / 2=Z），斜面为 -1 */
+    alignedAxisIndex: number;
+}
+/**
+ * 由表面法线构造落点所在平面的坐标系。
+ * 绿色 Z 轴 = 法线；蓝色 Y 轴取平面内最接近「世界向上」的方向；红色 X 轴 = 剩下的那条平面内方向。
+ * 平面接近水平（地板 / 天花板）时平面内没有竖直方向，退化为用世界 Z 当蓝色轴。
+ *
+ * 放大镜里的叠加层和场景里的小光标共用这一份坐标系，保证两处看到的红 / 绿 / 蓝完全一致。
+ */
+export declare function buildPlaneFrame(normal: THREE.Vector3): PlaneFrame;
+/**
+ * 绘制落点叠加层。
+ * 调用时机：Magnifier.render() 里 putImageData 之后。
+ */
+export declare function drawMeasureOverlay(context: CanvasRenderingContext2D, viewport: MagnifierViewport, intersection: PointIntersection): void;