@realsee/dnalogel 3.81.21 → 3.81.23

package/libs/MeasurePluginV2/PointOverlay.js

@@ -0,0 +1,160 @@
+import * as L from "three";
+const p = {
+  /** M1-2 X 轴颜色 */
+  axisXColor: "#EC4A4E",
+  /** M1-2 Y 轴颜色 */
+  axisYColor: "#1677FF",
+  /** M1-2 Z 轴颜色 */
+  axisZColor: "#065C08",
+  /** M1-5 线条宽度 */
+  axisLineWidth: 1.5,
+  /** 轴线不透明度 */
+  axisOpacity: 0.9,
+  /** M1-4 轴线长度 = 放大镜半径 × 0.9 */
+  axisLengthRadiusScale: 0.9,
+  /** Z 轴端点（朝外的一端）绿色圆点半径 = 放大镜半径 × 该系数 */
+  axisTipDotRadiusScale: 0.03,
+  /** M2 平面框边框颜色 */
+  planeBorderColor: "#FF4D4F",
+  /** M2-3 边框宽度 */
+  planeBorderWidth: 1.5,
+  /** M2-3 边框不透明度 */
+  planeBorderOpacity: 0.9,
+  /** M2-2 轴对齐面框边长 = 放大镜半径 × 1.2 */
+  planeSideRadiusScale: 1.2,
+  /** M2 轴对齐判定：表面法线与最近世界轴的夹角小于该值即视为墙 / 地 / 顶 */
+  axisSnapAngle: 15
+}, C = [new L.Vector3(1, 0, 0), new L.Vector3(0, 1, 0), new L.Vector3(0, 0, 1)], D = [p.axisXColor, p.axisYColor, p.axisZColor];
+function f(o, n) {
+  const e = o.clone().project(n.camera), t = (e.x + 1) / 2 * n.renderSize.x, i = (e.y + 1) / 2 * n.renderSize.y;
+  return {
+    x: (t - n.readLeft) * n.pixelRadio,
+    // 读出来的像素做过 Y 翻转（canvas 与渲染目标 Y 轴相反），所以要从读取区域的底边往回收
+    y: (n.readTop + n.readPixelsHeight - i) * n.pixelRadio
+  };
+}
+function N(o) {
+  const n = o.face;
+  if (!(n != null && n.normal))
+    return null;
+  const e = n.normal.clone();
+  return e.lengthSq() < 1e-12 ? null : e.normalize();
+}
+function O(o) {
+  const n = o.clone().normalize();
+  let e = 0, t = 0;
+  C.forEach((h, r) => {
+    const c = Math.abs(n.dot(h));
+    c > t && (t = c, e = r);
+  });
+  const i = Math.cos(L.MathUtils.degToRad(p.axisSnapAngle));
+  if (t < i)
+    return { normal: n, alignedAxisIndex: -1 };
+  const x = C[e], s = n.dot(x) >= 0 ? 1 : -1;
+  return { normal: x.clone().multiplyScalar(s), alignedAxisIndex: e };
+}
+function W(o) {
+  const n = O(o), e = n.normal, t = e.clone().multiplyScalar(e.dot(C[1]));
+  let i = C[1].clone().sub(t);
+  i.lengthSq() < 1e-8 && (i = C[2].clone().sub(e.clone().multiplyScalar(e.dot(C[2])))), i.normalize();
+  const x = new L.Vector3().crossVectors(i, e).normalize();
+  return { normal: e, xAxis: x, yAxis: i, alignedAxisIndex: n.alignedAxisIndex };
+}
+function E(o, n) {
+  return Math.max(1e-4, n.position.distanceTo(o) * 0.01);
+}
+function I(o, n) {
+  const e = f(o.point, o.viewport), t = f(o.point.clone().addScaledVector(n, o.probeLength), o.viewport);
+  return { x: t.x - e.x, y: t.y - e.y };
+}
+const M = 0.8, V = 3;
+function F(o, n, e) {
+  const { point: t, viewport: i } = o, x = f(t, i), s = (b) => {
+    const a = f(t.clone().addScaledVector(n, b), i);
+    return Math.hypot(a.x - x.x, a.y - x.y);
+  }, h = i.camera.matrixWorldInverse, r = -t.clone().applyMatrix4(h).z;
+  if (!(r > 0))
+    return 0;
+  const c = -t.clone().add(n).applyMatrix4(h).z - r;
+  let m = 1 / 0;
+  c < -1e-9 ? m = r * M / -c : c > 1e-9 && (m = r * V / c);
+  let d = m;
+  if (!Number.isFinite(d))
+    for (d = o.probeLength; s(d) < e && d < r * V; )
+      d *= 2;
+  if (!(s(d) > e))
+    return Number.isFinite(s(d)) ? d : 0;
+  let A = 0;
+  for (let b = 0; b < 24; b += 1) {
+    const a = (A + d) / 2;
+    s(a) < e ? A = a : d = a;
+  }
+  return (A + d) / 2;
+}
+function w([o, n, e, t]) {
+  const i = (s, h, r) => (h.x - s.x) * (r.y - s.y) - (h.y - s.y) * (r.x - s.x), x = (s, h, r, c) => i(r, c, s) * i(r, c, h) < 0 && i(s, h, r) * i(s, h, c) < 0;
+  return x(o, n, e, t) || x(n, e, t, o);
+}
+function _(o, n) {
+  var R;
+  const { context: e, viewport: t, point: i } = o, s = Math.min(t.canvasWidth, t.canvasHeight) / 2 * p.planeSideRadiusScale / 2, h = n.xAxis.clone().negate(), r = n.yAxis.clone().negate(), c = F(o, n.xAxis, s), m = F(o, h, s), d = F(o, n.yAxis, s), A = F(o, r, s);
+  if (!(c > 0) || !(m > 0) || !(d > 0) || !(A > 0))
+    return;
+  const b = t.camera.matrixWorldInverse, a = (u) => -u.clone().applyMatrix4(b).z, l = a(i), y = l * (1 - M), S = (u) => {
+    const v = a(u);
+    if (v >= y)
+      return u;
+    const T = (l - y) / (l - v);
+    return i.clone().lerp(u, T);
+  }, g = [
+    i.clone().addScaledVector(n.xAxis, c).addScaledVector(n.yAxis, d),
+    i.clone().addScaledVector(n.xAxis, -m).addScaledVector(n.yAxis, d),
+    i.clone().addScaledVector(n.xAxis, -m).addScaledVector(n.yAxis, -A),
+    i.clone().addScaledVector(n.xAxis, c).addScaledVector(n.yAxis, -A)
+  ].map((u) => f(S(u), t));
+  g.some((u) => !Number.isFinite(u.x) || !Number.isFinite(u.y)) || w(g) || (e.save(), e.beginPath(), g.forEach((u, v) => {
+    v === 0 ? e.moveTo(u.x, u.y) : e.lineTo(u.x, u.y);
+  }), e.closePath(), e.strokeStyle = p.planeBorderColor, e.globalAlpha = p.planeBorderOpacity, e.lineWidth = p.planeBorderWidth * ((R = t.lineScale) != null ? R : 1), e.stroke(), e.restore());
+}
+function P(o, n) {
+  const { context: e, viewport: t, point: i } = o, x = Math.min(t.canvasWidth, t.canvasHeight) / 2, s = x * p.axisLengthRadiusScale, h = x * p.axisTipDotRadiusScale, r = f(i, t);
+  if (!Number.isFinite(r.x) || !Number.isFinite(r.y))
+    return;
+  const c = (a) => {
+    const l = I(o, a), y = Math.hypot(l.x, l.y);
+    return !Number.isFinite(y) || y < 1e-3 ? null : { x: l.x / y, y: l.y / y };
+  }, m = (a) => F(o, a, s), d = (a, l, y) => {
+    var S;
+    [a.x, a.y, l.x, l.y].every((g) => Number.isFinite(g)) && (e.strokeStyle = y, e.globalAlpha = p.axisOpacity, e.lineWidth = p.axisLineWidth * ((S = t.lineScale) != null ? S : 1), e.beginPath(), e.moveTo(a.x, a.y), e.lineTo(l.x, l.y), e.stroke());
+  }, A = (a, l) => {
+    if (!c(a))
+      return;
+    const y = a.clone().negate(), S = F(o, a, s), g = F(o, y, s);
+    if (!(S > 0) || !(g > 0))
+      return;
+    const R = f(i.clone().addScaledVector(y, g), t), u = f(i.clone().addScaledVector(a, S), t);
+    d(R, u, l);
+  }, b = (a, l, y) => {
+    if (!c(a))
+      return;
+    const S = m(a);
+    if (!(S > 0))
+      return;
+    const g = f(i.clone().addScaledVector(a, S), t);
+    d(r, g, l), y && (!Number.isFinite(g.x) || !Number.isFinite(g.y) || (e.fillStyle = l, e.globalAlpha = p.axisOpacity, e.beginPath(), e.arc(g.x, g.y, h, 0, Math.PI * 2), e.fill()));
+  };
+  e.save(), e.lineCap = "round", n ? (A(n.xAxis, p.axisXColor), A(n.yAxis, p.axisYColor), b(n.normal, p.axisZColor, !0)) : C.forEach((a, l) => A(a, D[l])), e.restore();
+}
+function X(o, n, e) {
+  const t = e.point;
+  if (!t || !Number.isFinite(t.x) || !Number.isFinite(t.y) || !Number.isFinite(t.z))
+    return;
+  const i = { context: o, viewport: n, point: t, probeLength: E(t, n.camera) }, x = N(e), s = x ? W(x) : null;
+  s && _(i, s), P(i, s);
+}
+export {
+  p as OVERLAY_STYLE,
+  W as buildPlaneFrame,
+  X as drawMeasureOverlay,
+  N as getWorldNormal
+};

package/libs/MeasurePluginV2/PointSelector.d.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+import { PointSelector, type PointIntersection } from '../shared-utils/three/PointSelector';
+/** V2 snapping only. The original PointSelector keeps its existing algorithm. */
+export declare class MeasurePointSelector extends PointSelector {
+    /**
+     * @description 动态吸附线提供器：每次选点更新、吸附计算前调用，返回本次参与吸附的线段，不会写回 adhereLine。
+     * 适合按光标位置实时从模型提取的边线。返回的线按有限线段处理（clampToLine），
+     * 与 adhereLine 里的无限轴线（如量尺的 XYZ 轴）区分开。
+     */
+    adhereLineProvider: ((params: {
+        intersection: PointIntersection;
+        pointSelector: PointSelector;
+    }) => THREE.Line3[]) | null;
+    /**
+     * @description 动态吸附线的屏幕吸附半径（像素）
+     * 动态线按「光标到线段投影的屏幕距离」取最近的一条，而不是按 3D 距离排序后让远边覆盖近边
+     */
+    dynamicAdhereScreenRadius: number;
+    /**
+     * @description 已吸附后保持吸附的屏幕半径（像素），略大于进入半径，避免在阈值边界来回跳动
+     */
+    dynamicAdhereKeepScreenRadius: number;
+    /**
+     * @description 动态吸附线允许的最大 3D 距离（米），用于排除画面深处或明显不在落点附近的边
+     */
+    dynamicAdhereMaxDistance: number;
+    /**
+     * 上一次吸住的动态线。候选线集合会随查询球心移动而变化，
+     * 把吸住的边单独留住，光标在保持半径内时优先继续用它，避免在相邻边之间来回跳。
+     */
+    private dynamicAdhereLine;
+    protected get mouseNdcPosition(): {
+        x: number;
+        y: number;
+    };
+    refresh(): void;
+    private readonly onFocusLost;
+    enable(): void;
+    disable(): void;
+    clearDynamicAdhereLine(): void;
+    protected updatePointSelectorHelperIntersect: (intersect?: PointIntersection | null) => void;
+    /**
+     * @description 计算一条静态吸附线的吸附结果（3D 距离优先，其次屏幕距离）
+     */
+    private getLineAdhereResult;
+    /**
+     * @description 在动态吸附线（模型边）中选出屏幕上离光标最近的一条。
+     *
+     * 三个要点：
+     * 1. 用射线与线段的最近点求落点，避免透视投影下屏幕比例回推 3D 点造成的偏差；
+     * 2. 光标贴着已吸住的边时直接锁定，不让相邻边参与评分，消除来回跳；
+     * 3. 需要换边时按「屏幕距离 + 深度惩罚」择优，避免吸到屏幕上重叠、但实际更远的边。
+     */
+    private getBestDynamicAdhereResult;
+}

package/libs/MeasurePluginV2/PointSelector.js

@@ -0,0 +1,239 @@
+var H = Object.defineProperty;
+var j = Object.getOwnPropertySymbols;
+var F = Object.prototype.hasOwnProperty, k = Object.prototype.propertyIsEnumerable;
+var N = (p, s, e) => s in p ? H(p, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : p[s] = e, C = (p, s) => {
+  for (var e in s || (s = {}))
+    F.call(s, e) && N(p, e, s[e]);
+  if (j)
+    for (var e of j(s))
+      k.call(s, e) && N(p, e, s[e]);
+  return p;
+};
+var R = (p, s, e) => (N(p, typeof s != "symbol" ? s + "" : s, e), e);
+import { CURSOR_NOT_ALLOW_URL as U } from "../shared-utils/three/PointSelector/utils/contents.js";
+import * as n from "three";
+import { PointSelector as B } from "../shared-utils/three/PointSelector/index.js";
+import { getRaycasterByNdcPosition as Y } from "../shared-utils/five/getRaycasterByNdcPosition.js";
+const T = new n.Vector3(), I = new n.Vector3(), E = new n.Vector3(), v = new n.Vector3(), K = 4, W = 0.6, q = 60;
+function O(p) {
+  const { rayOrigin: s, rayDirection: e, line: t, clampToLine: y } = p;
+  T.subVectors(t.end, t.start);
+  const d = T.lengthSq();
+  if (d < 1e-12)
+    return 0;
+  I.subVectors(s, t.start);
+  const a = e.dot(T), m = e.dot(I), f = T.dot(I), b = d - a * a;
+  let h;
+  if (b < 1e-9) {
+    const P = new n.Vector3().subVectors(t.start, s).cross(e).length(), c = new n.Vector3().subVectors(t.end, s).cross(e).length();
+    h = P <= c ? 0 : 1;
+  } else
+    h = (f - a * m) / b;
+  return y ? Math.min(1, Math.max(0, h)) : h;
+}
+class Z extends B {
+  constructor() {
+    super(...arguments);
+    /**
+     * @description 动态吸附线提供器：每次选点更新、吸附计算前调用，返回本次参与吸附的线段，不会写回 adhereLine。
+     * 适合按光标位置实时从模型提取的边线。返回的线按有限线段处理（clampToLine），
+     * 与 adhereLine 里的无限轴线（如量尺的 XYZ 轴）区分开。
+     */
+    R(this, "adhereLineProvider", null);
+    /**
+     * @description 动态吸附线的屏幕吸附半径（像素）
+     * 动态线按「光标到线段投影的屏幕距离」取最近的一条，而不是按 3D 距离排序后让远边覆盖近边
+     */
+    R(this, "dynamicAdhereScreenRadius", 10);
+    /**
+     * @description 已吸附后保持吸附的屏幕半径（像素），略大于进入半径，避免在阈值边界来回跳动
+     */
+    R(this, "dynamicAdhereKeepScreenRadius", 14);
+    /**
+     * @description 动态吸附线允许的最大 3D 距离（米），用于排除画面深处或明显不在落点附近的边
+     */
+    R(this, "dynamicAdhereMaxDistance", 0.45);
+    /**
+     * 上一次吸住的动态线。候选线集合会随查询球心移动而变化，
+     * 把吸住的边单独留住，光标在保持半径内时优先继续用它，避免在相邻边之间来回跳。
+     */
+    R(this, "dynamicAdhereLine", null);
+    R(this, "onFocusLost", () => {
+      this.adhereEnabled = !0, this.clearDynamicAdhereLine();
+    });
+    R(this, "updatePointSelectorHelperIntersect", (e) => {
+      var y, d, a, m, f, b, h, P;
+      if (!e) {
+        this.dynamicAdhereLine = null, this.pointSelectorHelper.hide(), this.pointSelectorHelper.position = e, this.emit("intersectionUpdate", e), this.five.getElement().style.cursor = U;
+        return;
+      }
+      this.onEnter(), this.cursorError || (this.five.getElement().style.cursor = "");
+      const t = C({}, e);
+      if (this.adhereEnabled && this.mouseNdcPosition && this.five.renderer && typeof this.adhereRadius == "number") {
+        const c = {
+          x: this.mouseNdcPosition.x,
+          y: 1 - this.mouseNdcPosition.y
+        }, w = this.five.renderer.getSize(new n.Vector2()), g = (d = (y = this.adhereLineProvider) == null ? void 0 : y.call(this, { intersection: e, pointSelector: this })) != null ? d : [];
+        if (typeof this.adherePoints == "function" || this.adherePlane.length > 0 || this.adhereLine.length > 0 || g.length > 0 || this.dynamicAdhereLine !== null) {
+          for (const i of this.adherePlane) {
+            const o = i.distanceToPoint(e.point);
+            let L = i.projectPoint(e.point, new n.Vector3());
+            (!this.plane || this.plane.distanceToPoint(L) < 0.01) && (L = (m = (a = this.plane) == null ? void 0 : a.projectPoint(L, new n.Vector3())) != null ? m : L, o < this.adhereRadius && (t.point = L.clone(), t.adherePoint = L.clone(), this.plane || (t.face = new n.Face3(0, 0, 0, i.normal.clone())), t.isAdsorbed = !0));
+          }
+          for (const i of this.adhereLine) {
+            const o = this.getLineAdhereResult({
+              adhereLine: i,
+              point: e.point,
+              clampToLine: !1,
+              mouseNdcPosition: c,
+              size: w
+            });
+            o && (t.point = o.point, t.adhereLine = i.clone(), t.isAdsorbed = !0);
+          }
+          const A = this.getBestDynamicAdhereResult({
+            lines: g,
+            point: e.point,
+            mouseNdcPosition: c,
+            size: w
+          });
+          A && (t.point = A.point, t.adhereLine = A.line.clone(), t.isAdsorbed = !0);
+          for (const i of (b = (f = this.adherePoints) == null ? void 0 : f.call(this, { intersection: e, pointSelectorInstance: this })) != null ? b : []) {
+            const o = i instanceof n.Face3 ? new n.Vector3(i.a, i.b, i.c) : i;
+            if (o.IsAlwaysVisible = i.IsAlwaysVisible, this.plane && this.plane.distanceToPoint(o) > 0.01)
+              continue;
+            if (o.distanceTo(e.point) < this.adhereRadius) {
+              t.point = (P = (h = this.plane) == null ? void 0 : h.projectPoint(o, new n.Vector3())) != null ? P : o.clone(), !this.plane && i instanceof n.Face3 && (t.face = i), t.isAdsorbed = !0;
+              break;
+            } else {
+              const r = o.clone().project(this.five.camera);
+              if (r.z > 1)
+                continue;
+              const u = this.five.renderer.getSize(new n.Vector2()), D = {
+                x: (r.x + 1) / 2,
+                y: (1 - r.y) / 2
+              }, V = {
+                x: Math.abs(D.x - c.x) * u.width,
+                y: Math.abs(D.y - c.y) * u.height
+              };
+              if (V.x < 10 && V.y < 10) {
+                let S = !1;
+                if (o.IsAlwaysVisible)
+                  S = !0;
+                else {
+                  const M = new n.Raycaster();
+                  M.setFromCamera(o.clone(), this.five.camera);
+                  const x = this.five.model.intersectRaycaster(M)[0], _ = 0.1, z = this.five.camera.position.distanceTo(o);
+                  x && x.distance < z + _ && (S = !0);
+                }
+                if (S) {
+                  t.point = o.clone(), !this.plane && i instanceof n.Face3 && (t.face = i), t.isAdsorbed = !0;
+                  break;
+                }
+              }
+            }
+          }
+        }
+      } else
+        this.dynamicAdhereLine = null;
+      this.pointSelectorHelper.updateWithIntersect(t, { emitEvent: !1 }), this.emit("intersectionUpdate", t);
+    });
+  }
+  get mouseNdcPosition() {
+    return this.mode === "fixed" ? { x: 0.5, y: 0.5 } : super.mouseNdcPosition;
+  }
+  refresh() {
+    const e = this.mouseNdcPosition;
+    this.enabled && e && this.updateByNdcPosition(e);
+  }
+  enable() {
+    super.enable(), window.addEventListener("blur", this.onFocusLost);
+  }
+  disable() {
+    window.removeEventListener("blur", this.onFocusLost), this.clearDynamicAdhereLine(), super.disable(), this.adhereEnabled = !0;
+  }
+  clearDynamicAdhereLine() {
+    this.dynamicAdhereLine = null;
+  }
+  /**
+   * @description 计算一条静态吸附线的吸附结果（3D 距离优先，其次屏幕距离）
+   */
+  getLineAdhereResult(e) {
+    var w, g, l, A;
+    const { adhereLine: t, point: y, clampToLine: d, mouseNdcPosition: a, size: m } = e, f = t.closestPointToPoint(y, d, new n.Vector3());
+    if (f.distanceTo(y) < this.adhereRadius)
+      return this.plane && Math.abs(this.plane.distanceToPoint(f)) > 0.01 ? null : { point: (g = (w = this.plane) == null ? void 0 : w.projectPoint(f, new n.Vector3())) != null ? g : f };
+    const b = y.clone().sub(this.five.camera.position).normalize(), h = new n.Vector3().lerpVectors(
+      t.start,
+      t.end,
+      O({
+        rayOrigin: this.five.camera.position,
+        rayDirection: b,
+        line: t,
+        clampToLine: d
+      })
+    ), P = h.clone().project(this.five.camera);
+    if (P.z > 1)
+      return null;
+    const c = {
+      x: Math.abs((P.x + 1) / 2 - a.x) * m.width,
+      y: Math.abs((1 - P.y) / 2 - a.y) * m.height
+    };
+    return c.x >= 10 || c.y >= 10 || this.plane && Math.abs(this.plane.distanceToPoint(h)) > 0.01 ? null : { point: (A = (l = this.plane) == null ? void 0 : l.projectPoint(h, new n.Vector3())) != null ? A : h };
+  }
+  /**
+   * @description 在动态吸附线（模型边）中选出屏幕上离光标最近的一条。
+   *
+   * 三个要点：
+   * 1. 用射线与线段的最近点求落点，避免透视投影下屏幕比例回推 3D 点造成的偏差；
+   * 2. 光标贴着已吸住的边时直接锁定，不让相邻边参与评分，消除来回跳；
+   * 3. 需要换边时按「屏幕距离 + 深度惩罚」择优，避免吸到屏幕上重叠、但实际更远的边。
+   */
+  getBestDynamicAdhereResult(e) {
+    var o, L;
+    const { lines: t, point: y, mouseNdcPosition: d, size: a } = e;
+    if (t.length === 0 && !this.dynamicAdhereLine)
+      return this.dynamicAdhereLine = null, null;
+    const m = Y(this.five, { x: d.x, y: 1 - d.y }), f = m.ray.origin, b = m.ray.direction, h = d.x * a.width, P = d.y * a.height, c = [], w = (r, u) => {
+      const D = O({ rayOrigin: f, rayDirection: b, line: r, clampToLine: !0 });
+      E.lerpVectors(r.start, r.end, D);
+      const V = E.distanceTo(y);
+      if (V > this.dynamicAdhereMaxDistance || this.plane && Math.abs(this.plane.distanceToPoint(E)) > 0.01 || (v.copy(E).project(this.five.camera), v.z > 1))
+        return null;
+      const S = Math.hypot(
+        (v.x + 1) / 2 * a.width - h,
+        (1 - v.y) / 2 * a.height - P
+      ), x = 1 - 0.6 * (this.dynamicAdhereMaxDistance > 0 ? Math.min(1, V / this.dynamicAdhereMaxDistance) : 0), _ = (u ? this.dynamicAdhereKeepScreenRadius : this.dynamicAdhereScreenRadius) * x;
+      return S > _ ? null : { line: r, t: D, screenDistance: S, depthDistance: V, isSticky: u };
+    }, g = this.dynamicAdhereLine;
+    if (g) {
+      const r = w(g, !0);
+      r && c.push(r);
+    }
+    for (const r of t) {
+      const u = w(r, !1);
+      u && c.push(u);
+    }
+    if (c.length === 0)
+      return this.dynamicAdhereLine = null, null;
+    let l = null;
+    const A = c.find((r) => r.isSticky);
+    if (A && A.screenDistance <= this.dynamicAdhereScreenRadius * W && (l = A), !l) {
+      let r = 1 / 0;
+      for (const u of c) {
+        const D = u.screenDistance + u.depthDistance * q - (u.isSticky ? K : 0);
+        D < r && (r = D, l = u);
+      }
+    }
+    if (!l)
+      return this.dynamicAdhereLine = null, null;
+    this.dynamicAdhereLine = l.line.clone();
+    const i = new n.Vector3().lerpVectors(l.line.start, l.line.end, l.t);
+    return {
+      line: l.line,
+      point: (L = (o = this.plane) == null ? void 0 : o.projectPoint(i, new n.Vector3())) != null ? L : i
+    };
+  }
+}
+export {
+  Z as MeasurePointSelector
+};

package/libs/MeasurePluginV2/closeupView.d.ts

@@ -0,0 +1,69 @@
+import * as THREE from 'three';
+/**
+ * 放大镜近景视角的取向计算。
+ *
+ * 目标（与 MP 的观感一致）：放大镜不是主视图的简单放大。落点所在表面没有正对相机时，
+ * 视角会朝表面法线偏一点，让斜面 / 侧面在放大镜里以更接近正面的角度呈现；
+ * 同时要保证它始终是「主视图那台相机绕落点转了一点」——不换机位、不翻滚、偏转角有上限。
+ *
+ * 这里只做纯数学，相机怎么临时改、怎么还原由调用方负责。
+ */
+/** 近景相机到落点的距离（米） */
+export declare const CLOSEUP_DISTANCE = 0.6;
+/** 朝表面转正的比例：把「主视线到正对表面」的夹角消掉这么多 */
+export declare const CLOSEUP_NORMAL_BLEND = 0.5;
+/** 近景视角相对主视图的最大偏转角（弧度）。超过就封顶，避免侧视时像换了个机位 */
+export declare const CLOSEUP_MAX_DEVIATION: number;
+/** 判定法线朝向时的滞回区间（点积）：视线接近贴着表面时沿用上一帧朝向，避免来回翻 */
+export declare const CLOSEUP_FLIP_EPSILON = 0.05;
+/** 跨帧状态：目前只用于法线朝向的滞回 */
+export interface CloseupViewState {
+    /** 本帧的视线方向（单位向量） */
+    direction: THREE.Vector3;
+    /** 本帧的落点 */
+    point: THREE.Vector3;
+    /** 本帧法线的朝向：1 = 与传入的法线同向，-1 = 反向，null = 没有法线 */
+    normalSign: 1 | -1 | null;
+}
+export interface CloseupViewOptions {
+    /** 落点（世界坐标） */
+    point: THREE.Vector3;
+    /** 落点所在表面的法线（世界坐标，方向不限）；拿不到时传 null，只推近不偏转 */
+    normal: THREE.Vector3 | null;
+    /** 主相机位置 */
+    cameraPosition: THREE.Vector3;
+    /** 主相机世界四元数；近景姿态由它绕落点做最小旋转得到，因此不会翻滚 */
+    cameraQuaternion: THREE.Quaternion;
+    /** 近景距离，默认 CLOSEUP_DISTANCE；主相机比这更近时保持原距离。translate=false 时忽略 */
+    distance?: number;
+    /**
+     * 是否把相机沿最终视线移动到落点附近。
+     * true = 旧行为（推到 0.6m）；false = 只旋转、不平移，放大镜与主视图共用同一机位，
+     * 不会产生视差，也不会让全景球心偏移导致画面扭曲。
+     */
+    translate?: boolean;
+    /** 朝法线偏转的比例，默认 CLOSEUP_NORMAL_BLEND */
+    blend?: number;
+    /** 最大偏转角（弧度），默认 CLOSEUP_MAX_DEVIATION */
+    maxDeviation?: number;
+    /** 上一帧的状态，只用于法线朝向的滞回；第一帧传 null */
+    previous?: CloseupViewState | null;
+}
+export interface CloseupView {
+    /** 近景相机位置 */
+    position: THREE.Vector3;
+    /** 近景相机视线方向（单位向量） */
+    direction: THREE.Vector3;
+    /** 近景相机世界四元数（视线方向与 direction 一致，roll 由主相机继承） */
+    quaternion: THREE.Quaternion;
+    /** 供下一次调用使用的状态 */
+    state: CloseupViewState;
+}
+/**
+ * 计算近景相机的位姿：
+ * 1. translate=true 时相机落在「落点后方 distance 处、朝向落点」这条线上，落点因此仍在画面正中；
+ *    translate=false 时保持原机位，只改变朝向（放大镜与主视图共用视点，不产生视差）；
+ * 2. 姿态 = 主相机姿态先把视线校正到落点，再朝「正对表面」的方向转一小段（有上限）；
+ * 3. 因为是绕相机的旋转，画面不会翻滚，观感就是「同一台相机微微转了个角度」。
+ */
+export declare function resolveCloseupView(options: CloseupViewOptions): CloseupView | null;

package/libs/MeasurePluginV2/closeupView.js

@@ -0,0 +1,52 @@
+import * as c from "three";
+const z = 0.6, I = 0.5, _ = Math.PI / 6, A = 0.05;
+function Q(n) {
+  var F, b, S, h, D;
+  const { point: e, cameraPosition: t, cameraQuaternion: i } = n;
+  if (!f(e) || !f(t) || !U(i))
+    return null;
+  const s = e.clone().sub(t), a = s.length();
+  if (!Number.isFinite(a) || a < 1e-4)
+    return null;
+  const o = s.clone().divideScalar(a), x = new c.Vector3(0, 0, -1).applyQuaternion(i).normalize(), N = new c.Quaternion().setFromUnitVectors(x, o).multiply(i);
+  N.normalize();
+  const m = (F = n.previous) != null ? F : null;
+  let u = null, r = o.clone();
+  const l = n.normal;
+  if (l && f(l) && l.lengthSq() > 1e-12) {
+    const E = l.clone().normalize();
+    u = C(E, s, (b = m == null ? void 0 : m.normalSign) != null ? b : null);
+    const P = E.clone().multiplyScalar(-u), M = o.angleTo(P), w = p((S = n.blend) != null ? S : I, 0, 1), y = p((h = n.maxDeviation) != null ? h : _, 0, Math.PI), V = Math.min(M * w, y);
+    if (V > 1e-6 && M > 1e-6) {
+      const g = new c.Vector3().crossVectors(o, P);
+      g.lengthSq() > 1e-12 && (r = o.clone().applyAxisAngle(g.normalize(), V));
+    }
+  }
+  const d = new c.Quaternion().setFromUnitVectors(o, r).multiply(N);
+  d.normalize();
+  const L = n.translate !== !1, O = Math.min((D = n.distance) != null ? D : z, a);
+  return {
+    // 只旋转时保持原机位：全景 / 模型都按主视图的同一视点采样，不引入视差
+    position: L ? e.clone().addScaledVector(r, -O) : t.clone(),
+    direction: r,
+    quaternion: d,
+    state: { direction: r.clone(), point: e.clone(), normalSign: u }
+  };
+}
+function C(n, e, t) {
+  const i = n.dot(e);
+  return Math.abs(i) < A && t !== null ? t : i > 0 ? -1 : 1;
+}
+function p(n, e, t) {
+  return Math.min(t, Math.max(e, n));
+}
+function f(n) {
+  return Number.isFinite(n.x) && Number.isFinite(n.y) && Number.isFinite(n.z);
+}
+function U(n) {
+  return Number.isFinite(n.x) && Number.isFinite(n.y) && Number.isFinite(n.z) && Number.isFinite(n.w);
+}
+export {
+  _ as CLOSEUP_MAX_DEVIATION,
+  Q as resolveCloseupView
+};

package/libs/MeasurePluginV2/edgeSnap.d.ts

@@ -0,0 +1,53 @@
+import * as THREE from 'three';
+/**
+ * 模型边缘吸附（试验能力）。
+ *
+ * 选点器本身已经支持吸附到 `THREE.Line3`，five 的 Model 也提供了 `getEdgesBySphere()`，
+ * 这里只做两件事：
+ * 1. 把光标附近的模型边界线取出来、按离落点的距离排序并限量；
+ * 2. 缓存查询结果，避免每次 mousemove 都重走一遍 BVH。
+ *
+ * 取出来的线交给 `PointSelector.adhereLineProvider`，由选点器完成真正的吸附。
+ */
+export interface EdgeSnapOptions {
+    /** 是否启用，默认 true */
+    enabled?: boolean;
+    /** 查询球半径（米），只在这个范围内找模型边线，默认 0.3 */
+    radius?: number;
+    /** 面片夹角阈值（度），越小越只保留硬边，默认 30 */
+    threshold?: number;
+    /** 单次最多参与吸附的边数，默认 240 */
+    maxEdges?: number;
+    /** 光标移动超过该距离（米）才重新查询，默认 0.12 */
+    cacheStep?: number;
+}
+export interface ResolvedEdgeSnapOptions extends Required<EdgeSnapOptions> {
+}
+export declare const DEFAULT_EDGE_SNAP_OPTIONS: ResolvedEdgeSnapOptions;
+export declare function resolveEdgeSnapOptions(options?: boolean | EdgeSnapOptions): ResolvedEdgeSnapOptions;
+/** 只依赖 getEdgesBySphere，避免把 dnalogel 绑死在某个 five 版本上 */
+type EdgeSource = {
+    getEdgesBySphere?: (sphere: THREE.Sphere, threshold?: number) => THREE.Line3[];
+};
+/**
+ * 取落点附近的模型边界线，按离落点从近到远排序，最多 maxEdges 条。
+ * five 的 getEdgesBySphere 返回的是世界坐标线段，可以直接交给 PointSelector。
+ *
+ * 注意：getEdgesBySphere 是按「三角形与球相交」筛选的，大三角形的边可能落在球外很远，
+ * 所以这里再按「点到线段」的真实距离过滤一次，避免把远处的边也当成候选。
+ */
+export declare function collectNearbyEdges(model: EdgeSource | null | undefined, point: THREE.Vector3, options: ResolvedEdgeSnapOptions): THREE.Line3[];
+/**
+ * `getEdgesBySphere` 每次都要遍历可见瓦片、合几何、重建邻接关系，开销不低；
+ * 光标在 cacheStep 范围内移动时复用上一次结果，足够贴近“附近有哪些边”的事实。
+ */
+export declare class EdgeSnapCache {
+    private center;
+    private edges;
+    private valid;
+    query(model: EdgeSource | null | undefined, point: THREE.Vector3, options: ResolvedEdgeSnapOptions): THREE.Line3[];
+    clear(): void;
+    /** 最近一次查询到的边数，调试 / 示例页展示用 */
+    get size(): number;
+}
+export {};