@realsee/dnalogel 3.81.20 → 3.81.22

package/libs/MeasurePluginV2/Magnifier.js

@@ -0,0 +1,96 @@
+var m = Object.defineProperty;
+var u = (a, t, e) => t in a ? m(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var n = (a, t, e) => (u(a, typeof t != "symbol" ? t + "" : t, e), e);
+import * as f from "three";
+import "../shared-utils/tag.js";
+import { Magnifier as g } 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 { drawMeasureOverlay as p } from "./PointOverlay.js";
+class T extends g {
+  constructor(e, r) {
+    super(e, r != null ? r : {});
+    /** 父类把 five 存成了 private，这里自己留一份，叠加层投影时要用 */
+    n(this, "overlayFive");
+    /** 父类把 context 存成了 private；getContext('2d') 拿到的是同一个实例 */
+    n(this, "overlayContext", null);
+    /** 由 PointSelector 的 intersectionUpdate 事件注入 */
+    n(this, "overlayIntersection", null);
+    n(this, "overlayEnabled");
+    this.overlayFive = e, this.overlayEnabled = (r == null ? void 0 : r.overlayEnabled) !== !1;
+  }
+  /** 每次交点更新时调用；传 null 表示当前没有命中任何模型 */
+  setIntersection(e) {
+    this.overlayIntersection = e;
+  }
+  /** 开关叠加层，用于灰度 / 排查问题 */
+  setOverlayEnabled(e) {
+    this.overlayEnabled = e;
+  }
+  render() {
+    super.render();
+    try {
+      this.renderOverlay();
+    } catch (e) {
+      console.warn("MeasureMagnifier: 叠加层绘制失败", e);
+    }
+  }
+  renderOverlay() {
+    if (!this.overlayEnabled || !this.state.enabled)
+      return;
+    const e = this.overlayIntersection;
+    if (!e || e.isVirtual || !e.point)
+      return;
+    const r = this.getOverlayViewport();
+    if (!r)
+      return;
+    const i = this.getOverlayContext();
+    i && p(i, r, e);
+  }
+  getOverlayContext() {
+    return this.overlayContext || (this.overlayContext = this.canvas.getContext("2d")), this.overlayContext;
+  }
+  /**
+   * 还原 Magnifier.render() 内部的取值，用来把世界坐标映射到放大镜 canvas 坐标。
+   * 这些换算必须和父类保持一致，父类改动时需要同步。
+   */
+  getOverlayViewport() {
+    const e = this.overlayFive;
+    if (!e.renderer || !e.camera)
+      return null;
+    const r = this.getRenderCenter(), i = e.renderer.getSize(new f.Vector2()), [h, y] = (() => {
+      if (r.isVector3) {
+        const v = r.clone().project(e.camera);
+        return [(v.x + 1) / 2 * i.x, (v.y + 1) / 2 * i.y];
+      }
+      return [r.x, i.y - r.y];
+    })(), o = 1, { width: s, height: l } = this, c = s / this.getMagnifierScale(), d = l / this.getMagnifierScale();
+    return {
+      camera: e.camera,
+      renderSize: i,
+      readLeft: h - c / 2,
+      // 父类纵向也是用 readPixelsWidth 减的，这里保持一致，否则叠加层会和放大的画面错位
+      readTop: y - c / 2,
+      readPixelsHeight: d,
+      pixelRadio: o * this.getMagnifierScale(),
+      canvasWidth: s * o,
+      canvasHeight: l * o
+    };
+  }
+  /** 父类的 scale 是 private，只能这样读；它是真值来源，避免自己再维护一份副本 */
+  getMagnifierScale() {
+    return this.scale;
+  }
+}
+export {
+  T 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,88 @@
+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;
+}
+/**
+ * 求交点的世界坐标系法线。
+ * 点云等拿不到 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;

package/libs/MeasurePluginV2/PointOverlay.js

@@ -0,0 +1,138 @@
+import * as m from "three";
+const l = {
+  /** 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
+}, f = [new m.Vector3(1, 0, 0), new m.Vector3(0, 1, 0), new m.Vector3(0, 0, 1)], v = [l.axisXColor, l.axisYColor, l.axisZColor];
+function y(n, e) {
+  const t = n.clone().project(e.camera), o = (t.x + 1) / 2 * e.renderSize.x, i = (t.y + 1) / 2 * e.renderSize.y;
+  return {
+    x: (o - e.readLeft) * e.pixelRadio,
+    // 读出来的像素做过 Y 翻转（canvas 与渲染目标 Y 轴相反），所以要从读取区域的底边往回收
+    y: (e.readTop + e.readPixelsHeight - i) * e.pixelRadio
+  };
+}
+function R(n) {
+  const e = n.face;
+  if (!(e != null && e.normal))
+    return null;
+  const t = e.normal.clone();
+  return t.lengthSq() < 1e-12 ? null : t.normalize();
+}
+function T(n) {
+  const e = n.clone().normalize();
+  let t = 0, o = 0;
+  f.forEach((x, d) => {
+    const u = Math.abs(e.dot(x));
+    u > o && (o = u, t = d);
+  });
+  const i = Math.cos(m.MathUtils.degToRad(l.axisSnapAngle));
+  if (o < i)
+    return { normal: e, alignedAxisIndex: -1 };
+  const c = f[t], r = e.dot(c) >= 0 ? 1 : -1;
+  return { normal: c.clone().multiplyScalar(r), alignedAxisIndex: t };
+}
+function M(n) {
+  const e = T(n), t = e.normal, o = t.clone().multiplyScalar(t.dot(f[1]));
+  let i = f[1].clone().sub(o);
+  i.lengthSq() < 1e-8 && (i = f[2].clone().sub(t.clone().multiplyScalar(t.dot(f[2])))), i.normalize();
+  const c = new m.Vector3().crossVectors(i, t).normalize();
+  return { normal: t, xAxis: c, yAxis: i, alignedAxisIndex: e.alignedAxisIndex };
+}
+function W(n, e) {
+  return Math.max(1e-4, e.position.distanceTo(n) * 0.01);
+}
+function L(n, e) {
+  const t = y(n.point, n.viewport), o = y(n.point.clone().addScaledVector(e, n.probeLength), n.viewport);
+  return { x: o.x - t.x, y: o.y - t.y };
+}
+function A(n, e, t) {
+  const o = L(n, e), i = Math.hypot(o.x, o.y);
+  if (!Number.isFinite(i) || i < 1e-6)
+    return 0;
+  const c = y(n.point, n.viewport);
+  let r = t / i * n.probeLength;
+  for (let x = 0; x < 2; x += 1) {
+    const d = y(n.point.clone().addScaledVector(e, r), n.viewport), u = Math.hypot(d.x - c.x, d.y - c.y);
+    if (!Number.isFinite(u) || u < 1e-6)
+      break;
+    r *= t / u;
+  }
+  return r;
+}
+function E(n, e) {
+  const { context: t, viewport: o, point: i } = n, r = Math.min(o.canvasWidth, o.canvasHeight) / 2 * l.planeSideRadiusScale / 2, x = A(n, e.xAxis, r), d = A(n, e.yAxis, r);
+  if (!(x > 0) || !(d > 0))
+    return;
+  const u = [
+    i.clone().addScaledVector(e.xAxis, x).addScaledVector(e.yAxis, d),
+    i.clone().addScaledVector(e.xAxis, -x).addScaledVector(e.yAxis, d),
+    i.clone().addScaledVector(e.xAxis, -x).addScaledVector(e.yAxis, -d),
+    i.clone().addScaledVector(e.xAxis, x).addScaledVector(e.yAxis, -d)
+  ].map((p) => y(p, o));
+  u.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y)) || (t.save(), t.beginPath(), u.forEach((p, b) => {
+    b === 0 ? t.moveTo(p.x, p.y) : t.lineTo(p.x, p.y);
+  }), t.closePath(), t.strokeStyle = l.planeBorderColor, t.globalAlpha = l.planeBorderOpacity, t.lineWidth = l.planeBorderWidth, t.stroke(), t.restore());
+}
+function O(n, e) {
+  const { context: t, viewport: o, point: i } = n, c = Math.min(o.canvasWidth, o.canvasHeight) / 2, r = c * l.axisLengthRadiusScale, x = c * l.axisTipDotRadiusScale, d = y(i, o);
+  if (!Number.isFinite(d.x) || !Number.isFinite(d.y))
+    return;
+  const u = (a) => {
+    const s = L(n, a), h = Math.hypot(s.x, s.y);
+    return !Number.isFinite(h) || h < 1e-3 ? null : { x: s.x / h, y: s.y / h };
+  }, p = (a) => A(n, a, r), b = (a, s, h) => {
+    [a.x, a.y, s.x, s.y].every((S) => Number.isFinite(S)) && (t.strokeStyle = h, t.globalAlpha = l.axisOpacity, t.lineWidth = l.axisLineWidth, t.beginPath(), t.moveTo(a.x, a.y), t.lineTo(s.x, s.y), t.stroke());
+  }, F = (a, s) => {
+    if (!u(a))
+      return;
+    const h = a.clone().negate(), S = A(n, a, r), g = A(n, h, r);
+    if (!(S > 0) || !(g > 0))
+      return;
+    const C = y(i.clone().addScaledVector(h, g), o), N = y(i.clone().addScaledVector(a, S), o);
+    b(C, N, s);
+  }, V = (a, s, h) => {
+    if (!u(a))
+      return;
+    const S = p(a);
+    if (!(S > 0))
+      return;
+    const g = y(i.clone().addScaledVector(a, S), o);
+    b(d, g, s), h && (!Number.isFinite(g.x) || !Number.isFinite(g.y) || (t.fillStyle = s, t.globalAlpha = l.axisOpacity, t.beginPath(), t.arc(g.x, g.y, x, 0, Math.PI * 2), t.fill()));
+  };
+  t.save(), t.lineCap = "round", e ? (F(e.xAxis, l.axisXColor), F(e.yAxis, l.axisYColor), V(e.normal, l.axisZColor, !0)) : f.forEach((a, s) => F(a, v[s])), t.restore();
+}
+function w(n, e, t) {
+  const o = t.point;
+  if (!o || !Number.isFinite(o.x) || !Number.isFinite(o.y) || !Number.isFinite(o.z))
+    return;
+  const i = { context: n, viewport: e, point: o, probeLength: W(o, e.camera) }, c = R(t), r = c ? M(c) : null;
+  r && E(i, r), O(i, r);
+}
+export {
+  l as OVERLAY_STYLE,
+  M as buildPlaneFrame,
+  w as drawMeasureOverlay,
+  R 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;
+}