@realsee/dnalogel 3.81.20 → 3.81.22

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/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 {};

package/libs/MeasurePluginV2/edgeSnap.js

@@ -0,0 +1,67 @@
+var E = Object.defineProperty, q = Object.defineProperties;
+var y = Object.getOwnPropertyDescriptors;
+var h = Object.getOwnPropertySymbols;
+var T = Object.prototype.hasOwnProperty, v = Object.prototype.propertyIsEnumerable;
+var u = (r, e, t) => e in r ? E(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, c = (r, e) => {
+  for (var t in e || (e = {}))
+    T.call(e, t) && u(r, t, e[t]);
+  if (h)
+    for (var t of h(e))
+      v.call(e, t) && u(r, t, e[t]);
+  return r;
+}, S = (r, e) => q(r, y(e));
+var d = (r, e, t) => (u(r, typeof e != "symbol" ? e + "" : e, t), t);
+import * as n from "three";
+const l = {
+  enabled: !0,
+  radius: 0.3,
+  threshold: 30,
+  maxEdges: 240,
+  cacheStep: 0.12
+};
+function x(r) {
+  return r === !1 ? S(c({}, l), { enabled: !1 }) : r === !0 || r === void 0 ? c({}, l) : c(c({}, l), r);
+}
+const f = new n.Vector3();
+function b(r, e) {
+  return e.closestPointToPoint(r, !0, f), f.distanceToSquared(r);
+}
+function m(r, e, t) {
+  if (!t.enabled)
+    return [];
+  if (!r || typeof r.getEdgesBySphere != "function")
+    return [];
+  if (![e.x, e.y, e.z].every((s) => Number.isFinite(s)))
+    return [];
+  const a = r.getEdgesBySphere(new n.Sphere(e.clone(), t.radius), n.MathUtils.degToRad(t.threshold));
+  if (!(a != null && a.length))
+    return [];
+  const i = t.radius * t.radius;
+  return a.map((s) => ({ line: s, distanceSq: b(e, s) })).filter((s) => s.distanceSq <= i).sort((s, g) => s.distanceSq - g.distanceSq).slice(0, t.maxEdges).map((s) => s.line);
+}
+class N {
+  constructor() {
+    d(this, "center", new n.Vector3());
+    d(this, "edges", []);
+    d(this, "valid", !1);
+  }
+  query(e, t, a) {
+    if (!a.enabled)
+      return this.clear(), [];
+    const i = a.cacheStep * a.cacheStep;
+    return this.valid && this.center.distanceToSquared(t) <= i ? this.edges : (this.center.copy(t), this.edges = m(e, t, a), this.valid = !0, this.edges);
+  }
+  clear() {
+    this.valid = !1, this.edges = [];
+  }
+  /** 最近一次查询到的边数，调试 / 示例页展示用 */
+  get size() {
+    return this.edges.length;
+  }
+}
+export {
+  l as DEFAULT_EDGE_SNAP_OPTIONS,
+  N as EdgeSnapCache,
+  m as collectNearbyEdges,
+  x as resolveEdgeSnapOptions
+};

package/libs/MeasurePluginV2/index.d.ts

@@ -0,0 +1,28 @@
+import type { Five } from '@realsee/five';
+import { MeasureControllerV2 } from './Controller';
+/**
+ * 量尺插件 V2 —— 点位选择可视化（对应 PRD《量尺点位选择器优化》）
+ *
+ * 与 MeasurePlugin 的关系：V2 是试点 fork，完全继承 MeasurePlugin 的控制器，
+ * 新吸附算法、放大镜叠加层和场景光标仅在 V2 中生效，原插件继续使用原选点器。
+ *
+ * 使用方式（Console / 编辑器等接入方）：
+ * ```ts
+ * import { MeasureV2 } from '@realsee/dnalogel'
+ * const measure = MeasureV2.MeasurePluginV2(five, { unit: 'm' })
+ * ```
+ */
+export { MeasureControllerV2 } from './Controller';
+export type { MeasurePluginV2Config } from './Controller';
+export { MeasureMagnifier } from './Magnifier';
+export type { MeasureMagnifierOptions } from './Magnifier';
+export { drawMeasureOverlay, getWorldNormal, OVERLAY_STYLE } from './PointOverlay';
+export type { MagnifierViewport } from './PointOverlay';
+export { collectNearbyEdges, EdgeSnapCache, DEFAULT_EDGE_SNAP_OPTIONS } from './edgeSnap';
+export type { EdgeSnapOptions, ResolvedEdgeSnapOptions } from './edgeSnap';
+export { validatePolygon } from '../MeasurePlugin';
+export type { MeasureEndReason, MeasurePluginConfig, MeasurePluginEventMap } from '../MeasurePlugin';
+export type MeasureControllerV2Interface = InstanceType<typeof MeasureControllerV2>;
+export type MeasurePluginV2ParamsInterface = ConstructorParameters<typeof MeasureControllerV2>[1];
+export declare const MeasurePluginV2: (five: Five, config?: MeasurePluginV2ParamsInterface) => MeasureControllerV2;
+export default MeasurePluginV2;

package/libs/MeasurePluginV2/index.js

@@ -0,0 +1,38 @@
+import { MeasureControllerV2 as o } from "./Controller.js";
+import { MeasureMagnifier as i } from "./Magnifier.js";
+import { OVERLAY_STYLE as m, drawMeasureOverlay as p, getWorldNormal as a } from "./PointOverlay.js";
+import { DEFAULT_EDGE_SNAP_OPTIONS as l, EdgeSnapCache as n, collectNearbyEdges as u } from "./edgeSnap.js";
+import "three";
+import "../shared-utils/tag.js";
+import "../vendor/hammerjs/hammer.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 "../Sculpt/Meshes/Polygon.js";
+import { validatePolygon as d } from "../MeasurePlugin/utils/validatePolygon.js";
+import "../vendor/hotkeys-js/dist/hotkeys.esm.js";
+const r = (t, e) => new o(t, e), C = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DEFAULT_EDGE_SNAP_OPTIONS: l,
+  EdgeSnapCache: n,
+  MeasureControllerV2: o,
+  MeasureMagnifier: i,
+  MeasurePluginV2: r,
+  OVERLAY_STYLE: m,
+  collectNearbyEdges: u,
+  default: r,
+  drawMeasureOverlay: p,
+  getWorldNormal: a,
+  validatePolygon: d
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  C as index
+};

package/libs/PanoMeasurePlugin/Controller/EditController.d.ts

@@ -3,6 +3,7 @@ import BaseController from './BaseController';
 import type { ControllerParams } from './BaseController';
 import { Polyline } from '../Model/polyline';
 import Area from '../Model/area';
+import { PointSelector } from '../../shared-utils/three/PointSelector';
 export default class EditController extends BaseController {
     type: string;
     polyline: Polyline;
@@ -11,11 +12,13 @@ export default class EditController extends BaseController {
     private fiveElement?;
     /** 上一个端点位置 */
     private lastPoint;
-    private pointSelector;
+    protected pointSelector: PointSelector;
     private deleteDom;
     /** 根据 intersection 更新放大镜和吸附点 */
     private onIntersectionUpdate;
     constructor(params: ControllerParams);
+    protected createPointSelector(_params: ControllerParams): PointSelector;
+    protected disposeMagnifier(): void;
     dispose(): void;
     getEditingLines(): Line[];
     /** 撤销编辑 */
@@ -44,7 +47,7 @@ export default class EditController extends BaseController {
     /** 移动全景时更新 distanceItem 在屏幕上的位置 */
     private onCameraUpdate;
     /** 更新虚线 */
-    private updateDashed;
+    protected updateDashed: () => void;
     private wantsTapGesture;
     private chooseLine;
     private chooseArea;

package/libs/PanoMeasurePlugin/Controller/EditController.js

@@ -23,14 +23,14 @@ import N from "../Modules/DeleteDom/index.js";
 import * as f from "three";
 import { Vector2 as T } from "three";
 import b from "../utils/isNDCPointInScreen.js";
-import { closestPointOnLine as Q } from "../utils/math.js";
-import { getFiveModel as X } from "../../shared-utils/five/getFiveModel.js";
+import { closestPointOnLine as _ } from "../utils/math.js";
+import { getFiveModel as Q } from "../../shared-utils/five/getFiveModel.js";
 import "../../shared-utils/tag.js";
 import "../../vendor/hammerjs/hammer.js";
 import "../../shared-utils/three/CSS3DRenderer/index.js";
 import "../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
 import "@realsee/five/line";
-import { notNil as Y } from "../../shared-utils/isNil.js";
+import { notNil as X } from "../../shared-utils/isNil.js";
 import "../../shared-utils/three/core/Five_LineMaterial2.js";
 import "../../shared-utils/three/core/Sphere.js";
 import "../../shared-utils/three/blink.js";
@@ -198,16 +198,16 @@ class Wt extends z {
           return [];
         const { intersection: h, pointSelectorInstance: L } = s, g = L.pointSelectorHelper.pointHelper, m = new f.Vector3(0, 0, 1).applyQuaternion(g.quaternion);
         if (m.x > 0.9999 || m.y > 0.9999 || m.z > 0.9999 || m.x < -0.9999 || m.y < -0.9999 || m.z < -0.9999) {
-          const A = h.point, v = this.lastPoint.position.clone().sub(A);
+          const S = h.point, P = this.lastPoint.position.clone().sub(S);
           L.pointSelectorHelper.updateWithIntersect(h, { emitEvent: !1 });
           const r = new f.Line3(
-            g.localToWorld(new f.Vector3(1, 0, 0)).add(v),
-            g.localToWorld(new f.Vector3(-1, 0, 0)).add(v)
+            g.localToWorld(new f.Vector3(1, 0, 0)).add(P),
+            g.localToWorld(new f.Vector3(-1, 0, 0)).add(P)
           ), p = new f.Line3(
-            g.localToWorld(new f.Vector3(0, 1, 0)).add(v),
-            g.localToWorld(new f.Vector3(0, -1, 0)).add(v)
-          ), S = r.closestPointToPoint(A, !1, new f.Vector3()), P = p.closestPointToPoint(A, !1, new f.Vector3());
-          return [S, P];
+            g.localToWorld(new f.Vector3(0, 1, 0)).add(P),
+            g.localToWorld(new f.Vector3(0, -1, 0)).add(P)
+          ), A = r.closestPointToPoint(S, !1, new f.Vector3()), v = p.closestPointToPoint(S, !1, new f.Vector3());
+          return [A, v];
         }
         return [];
       };
@@ -225,7 +225,7 @@ class Wt extends z {
         }
         this.area.points.length >= 3 && this.pointSelector.setAdherePoints((...h) => {
           var L;
-          return [this.area.points[0], ...(L = n(...h)) != null ? L : []].filter(Y);
+          return [this.area.points[0], ...(L = n(...h)) != null ? L : []].filter(X);
         });
         const s = (y = (u = this.editParams) == null ? void 0 : u.autoEndConfig) == null ? void 0 : y.area;
         typeof s == "number" && (this.area.points.length >= s ? this.complete() : this.area.points.length === s - 1 && this.hook.emit("readyComplete")), this.hook.emit("pointsChange", this.area.points);
@@ -275,31 +275,31 @@ class Wt extends z {
     // ====================================================================================================================================
     // 下面一堆高亮相关
     o(this, "wantsTapGesture", (e) => {
-      var A, v;
+      var S, P;
       if (this.editParams.pointSelectorMode === "cursor" || this.lastPoint)
         return !1;
-      const t = this.model.areas.map((r) => e.intersectObject(r.polygon, !0)[0]).sort((r, p) => r.distance - p.distance), i = (v = (A = t[0]) == null ? void 0 : A.object) == null ? void 0 : v.parent;
+      const t = this.model.areas.map((r) => e.intersectObject(r.polygon, !0)[0]).sort((r, p) => r.distance - p.distance), i = (P = (S = t[0]) == null ? void 0 : S.object) == null ? void 0 : P.parent;
       if (i != null && i.isPolygonMesh) {
         const r = this.model.areas.find((p) => p.polygon === i);
         if (r) {
-          const { x: p, y: S } = t[0].point.clone().project(this.five.camera), P = `${(p + 1) / 2 * 100}%`, C = `${(-S + 1) / 2 * 100}%`;
-          return this.chooseArea(r, { left: P, top: C }), !1;
+          const { x: p, y: A } = t[0].point.clone().project(this.five.camera), v = `${(p + 1) / 2 * 100}%`, C = `${(-A + 1) / 2 * 100}%`;
+          return this.chooseArea(r, { left: v, top: C }), !1;
         }
       }
-      const [n] = X(this.five).intersectRaycaster(e);
+      const [n] = Q(this.five).intersectRaycaster(e);
       if (!n)
         return;
       const l = this.five.camera, c = n.point.clone().project(l), u = this.container.clientWidth, y = this.container.clientHeight, s = new T(c.x * u, c.y * y), h = this.model.getAllLines().map((r) => {
-        const [p, S] = r.points, P = p.position.clone().project(l), C = S.position.clone().project(l);
-        if (!b(P) && !b(C))
+        const [p, A] = r.points, v = p.position.clone().project(l), C = A.position.clone().project(l);
+        if (!b(v) && !b(C))
           return null;
-        const V = new T(P.x * u, P.y * y), W = new T(C.x * u, C.y * y);
+        const V = new T(v.x * u, v.y * y), W = new T(C.x * u, C.y * y);
         return { id: r.id, points: [V, W] };
       }).filter((r) => !!r);
       if (h.length === 0)
         return;
       const g = h.map((r) => {
-        const p = Q(s, r.points);
+        const p = _(s, r.points);
         return { id: r.id, distance: p.distanceTo(s) };
       }).sort((r, p) => r.distance - p.distance)[0];
       if (g.distance > 20)
@@ -335,10 +335,7 @@ class Wt extends z {
         const i = t.type === "area", n = Array.isArray(t) && ((l = t[0]) == null ? void 0 : l.type) === "line";
         i && this.unHighlightArea(t), n && this.unHighlightLines(t);
       }
-    }).appendTo(this.container), this.pointSelector = new F(this.five, M(k({}, this.pointSelectorConfig), {
-      mode: this.editParams.pointSelectorMode,
-      helper: k({ magnifierParams: this.magnifierParams, container: this.container }, this.pointSelectorConfig.helper)
-    })), this.pointSelector.enable(), this.polyline = new E({ model: this.model }), this.area = new R(void 0, {
+    }).appendTo(this.container), this.pointSelector = this.createPointSelector(e), this.pointSelector.enable(), this.polyline = new E({ model: this.model }), this.area = new R(void 0, {
       five: this.five,
       model: this.model,
       meshContainer: this.group,
@@ -351,10 +348,19 @@ class Wt extends z {
       });
     }), this.five.on("cameraUpdate", this.onCameraUpdate), this.five.on("wantsTapGesture", this.wantsTapGesture), this.five.on("wantsMoveToPano", this.wantsMoveToPano), this.five.on("wantsChangeMode", U), this.pointSelector.on("intersectionUpdate", this.onIntersectionUpdate), this.pointSelector.on("intersectionUpdate", this.checkMouseLeave), this.pointSelector.on("select", this.onSelect), this.pointSelector.on("wantsSelect", this.onWantsSelect), this.polyline.hook.on("lineAdded", this.onLineChanged), this.polyline.hook.on("lineRemoved", this.onLineChanged), this.five.helperVisible = !1, this.hook.emit("anchorChange", null), this.hook.emit("editedDashedLineChange", null), this.five.refresh();
   }
+  createPointSelector(e) {
+    return new F(this.five, M(k({}, this.pointSelectorConfig), {
+      mode: this.editParams.pointSelectorMode,
+      helper: k({ magnifierParams: this.magnifierParams, container: this.container }, this.pointSelectorConfig.helper)
+    }));
+  }
+  disposeMagnifier() {
+    this.magnifier.dispose();
+  }
   dispose() {
     super.dispose(), this.model.areas.forEach((e) => {
       (e.points.length < 2 || e.polygon.isBlank) && this.model.removeArea(e);
-    }), this.five.helperVisible = !0, this.pointSelector.disable(), this.dashed.remove(), this.perpendicularDashed.remove(), this.five.off("cameraUpdate", this.onCameraUpdate), this.five.off("wantsTapGesture", this.wantsTapGesture), this.five.off("wantsMoveToPano", this.wantsMoveToPano), this.five.off("wantsChangeMode", U), this.pointSelector.off("intersectionUpdate", this.onIntersectionUpdate), this.pointSelector.off("intersectionUpdate", this.checkMouseLeave), this.pointSelector.off("select", this.onSelect), this.pointSelector.off("wantsSelect", this.onWantsSelect), this.polyline.hook.off("lineAdded", this.onLineChanged), this.polyline.hook.off("lineRemoved", this.onLineChanged), this.magnifier.dispose(), this.deleteDom.dispose(), this.dashed.distanceItem.remove(), this.five.needsRender = !0;
+    }), this.five.helperVisible = !0, this.pointSelector.disable(), this.dashed.remove(), this.perpendicularDashed.remove(), this.five.off("cameraUpdate", this.onCameraUpdate), this.five.off("wantsTapGesture", this.wantsTapGesture), this.five.off("wantsMoveToPano", this.wantsMoveToPano), this.five.off("wantsChangeMode", U), this.pointSelector.off("intersectionUpdate", this.onIntersectionUpdate), this.pointSelector.off("intersectionUpdate", this.checkMouseLeave), this.pointSelector.off("select", this.onSelect), this.pointSelector.off("wantsSelect", this.onWantsSelect), this.polyline.hook.off("lineAdded", this.onLineChanged), this.polyline.hook.off("lineRemoved", this.onLineChanged), this.disposeMagnifier(), this.deleteDom.dispose(), this.dashed.distanceItem.remove(), this.five.needsRender = !0;
   }
   getEditingLines() {
     return this.polyline.lines;

package/libs/PanoMeasurePlugin/Controller/MixedController.d.ts

@@ -2,6 +2,7 @@ import type { ControllerParams } from './BaseController';
 import Line from '../Model/line';
 import BaseController from './BaseController';
 import { Polyline } from '../Model/polyline';
+import RangePieceController from '../Modules/rangePiece';
 export type State = 'watching' | 'editing';
 export default class MixedController extends BaseController {
     state: State;
@@ -11,9 +12,10 @@ export default class MixedController extends BaseController {
     private mobileNowPoint;
     private highlightedLines;
     private deleteDom;
-    private rangePieceController;
+    protected rangePieceController: RangePieceController;
     private disposers;
     constructor(params: ControllerParams);
+    protected createRangePieceController(params: ControllerParams): RangePieceController;
     dispose(): void;
     highlightLine(line: Line): void;
     clearHighlightLines(): void;