@realsee/dnalogel 3.81.22 → 3.81.23

package/libs/MeasurePluginV2/Controller.js

@@ -1,91 +1,125 @@
-var l = Object.defineProperty, g = Object.defineProperties;
-var c = Object.getOwnPropertyDescriptors;
-var h = Object.getOwnPropertySymbols;
-var u = Object.prototype.hasOwnProperty, m = Object.prototype.propertyIsEnumerable;
-var s = (r, a, e) => a in r ? l(r, a, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[a] = e, o = (r, a) => {
-  for (var e in a || (a = {}))
-    u.call(a, e) && s(r, e, a[e]);
-  if (h)
-    for (var e of h(a))
-      m.call(a, e) && s(r, e, a[e]);
+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;
-}, d = (r, a) => g(r, c(a));
-var n = (r, a, e) => (s(r, typeof a != "symbol" ? a + "" : a, e), e);
-import { MeasurePointSelector as S } from "./PointSelector.js";
-import { MeasureController as v } from "../MeasurePlugin/Controller.js";
-import { isTouchDevice as f } from "../shared-utils/isTouchDevice.js";
+}, 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 C } from "./PointHelper.js";
-import { EdgeSnapCache as M, resolveEdgeSnapOptions as P } from "./edgeSnap.js";
-class A extends v {
-  constructor(e, t) {
-    super(e, t);
+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);
     /** 最近一次查询到的候选边数量，示例页 / 调试用 */
-    n(this, "lastEdgeSnapEdgeCount", 0);
-    n(this, "v2Five");
-    n(this, "v2Magnifier");
-    n(this, "v2Attached", !1);
-    n(this, "edgeSnapOptions");
-    n(this, "edgeSnapCache", new M());
-    this.v2Five = e, this.edgeSnapOptions = P(t == null ? void 0 : t.edgeSnap);
+    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 = () => {
-      this.edgeSnapCache.clear(), this.lastEdgeSnapEdgeCount = 0, this.pointSelector.clearDynamicAdhereLine(), i();
+      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(e) {
-    this.edgeSnapOptions.enabled = e, this.edgeSnapCache.clear(), this.lastEdgeSnapEdgeCount = 0, this.pointSelector.clearDynamicAdhereLine(), this.pointSelector.refresh(), this.v2Five.needsRender = !0;
+  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 S(this.v2Five, { mode: "cursor", helper: o({ pointHelper: "highlight" }, f ? { magnifierParams: { width: 150, height: 150, dragEnabled: !1, autoFixPCPosition: !1, initialPosition: { left: "12px", top: "12px" } } } : {}), skipPanorama: !0 });
+    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 e = super.pointSelector;
-    return this.v2Attached || (this.v2Attached = !0, this.attachOverlayRenderers(e)), e;
+    const t = super.pointSelector;
+    return this.v2Attached || (this.v2Attached = !0, this.attachOverlayRenderers(t)), t;
   }
-  attachOverlayRenderers(e) {
-    const t = e.pointSelectorHelper;
-    this.attachMagnifier(t), this.attachPointHelper(t), this.attachEdgeSnap(e), e.on("intersectionUpdate", (i) => {
-      var p;
-      (p = this.v2Magnifier) == null || p.setIntersection(i != null ? i : null);
+  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(e) {
-    const t = e.magnifier;
-    if (!t)
+  attachMagnifier(t) {
+    const e = t.magnifier;
+    if (!e)
       return;
-    const i = new E(this.v2Five, d(o({}, t.config), {
-      width: t.width,
-      height: t.height,
-      scale: t.scale
+    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
     }));
-    t.containerDom && i.appendTo(t.containerDom), t.state.enabled && i.enable(), e.magnifier = i, t.dispose(), this.v2Magnifier = i;
+    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);
   }
-  attachPointHelper(e) {
-    const t = e.pointHelper, i = new C(this.v2Five);
-    e.pointHelper = i, t == null || t.dispose(), t != null && t.parent && t.parent.remove(t);
+  /** 双击快速测量：只在测量过程中生效，选点链路仍由原 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(e) {
-    e.adhereLineProvider = ({ intersection: t }) => {
-      if (!(t != null && t.point))
+  attachEdgeSnap(t) {
+    t.adhereLineProvider = ({ intersection: e }) => {
+      if (!(e != null && e.point))
         return [];
-      const i = this.edgeSnapCache.query(this.v2Five.model, t.point, this.edgeSnapOptions);
+      const i = this.edgeSnapCache.query(this.v2Five.model, e.point, this.edgeSnapOptions);
       return this.lastEdgeSnapEdgeCount = i.length, i;
     };
   }
 }
 export {
-  A as MeasureControllerV2
+  D as MeasureControllerV2
 };

package/libs/MeasurePluginV2/Magnifier.d.ts

@@ -1,8 +1,22 @@
 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 用的放大镜。
@@ -18,19 +32,43 @@ export declare class MeasureMagnifier extends Magnifier {
     /** 由 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;
-    /** 父类的 scale 是 private，只能这样读；它是真值来源，避免自己再维护一份副本 */
-    private getMagnifierScale;
 }

package/libs/MeasurePluginV2/Magnifier.js

@@ -1,9 +1,9 @@
 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";
+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 g } from "../shared-utils/three/Magnifier.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";
@@ -15,18 +15,30 @@ 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 : {});
+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，这里自己留一份，叠加层投影时要用 */
-    n(this, "overlayFive");
+    a(this, "overlayFive");
     /** 父类把 context 存成了 private；getContext('2d') 拿到的是同一个实例 */
-    n(this, "overlayContext", null);
+    a(this, "overlayContext", null);
     /** 由 PointSelector 的 intersectionUpdate 事件注入 */
-    n(this, "overlayIntersection", null);
-    n(this, "overlayEnabled");
-    this.overlayFive = e, this.overlayEnabled = (r == null ? void 0 : r.overlayEnabled) !== !1;
+    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) {
@@ -36,12 +48,28 @@ class T extends g {
   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() {
-    super.render();
+    const e = this.moveCameraCloseup();
+    try {
+      super.render(), this.snapshotOverlayCamera();
+    } finally {
+      e == null || e();
+    }
     try {
       this.renderOverlay();
-    } catch (e) {
-      console.warn("MeasureMagnifier: 叠加层绘制失败", e);
+    } catch (t) {
+      console.warn("MeasureMagnifier: 叠加层绘制失败", t);
     }
   }
   renderOverlay() {
@@ -50,11 +78,63 @@ class T extends g {
     const e = this.overlayIntersection;
     if (!e || e.isVirtual || !e.point)
       return;
-    const r = this.getOverlayViewport();
-    if (!r)
+    const t = this.getOverlayViewport();
+    if (!t)
       return;
-    const i = this.getOverlayContext();
-    i && p(i, r, e);
+    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;
@@ -64,33 +144,32 @@ class T extends g {
    * 这些换算必须和父类保持一致，父类改动时需要同步。
    */
   getOverlayViewport() {
+    var n;
     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];
+    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 [r.x, i.y - r.y];
-    })(), o = 1, { width: s, height: l } = this, c = s / this.getMagnifierScale(), d = l / this.getMagnifierScale();
+      return [t.x, r.y - t.y];
+    })(), o = this.getReadWindowInfo();
     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
+      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
     };
   }
-  /** 父类的 scale 是 private，只能这样读；它是真值来源，避免自己再维护一份副本 */
-  getMagnifierScale() {
-    return this.scale;
-  }
 }
 export {
-  T as MeasureMagnifier
+  U as MeasureMagnifier
 };

package/libs/MeasurePluginV2/PointOverlay.d.ts

@@ -53,6 +53,11 @@ export interface MagnifierViewport {
     /** 放大镜 canvas 的宽高（设备像素） */
     canvasWidth: number;
     canvasHeight: number;
+    /**
+     * 叠加层线宽缩放：canvas 设备像素 / CSS 像素。
+     * 高清读回时 canvas 变大，固定线宽需要同步放大，否则轴线和平面框会变细。
+     */
+    lineScale?: number;
 }
 /**
  * 求交点的世界坐标系法线。