@realsee/dnalogel 3.81.21 → 3.81.23

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/MeasurePluginV2/normalMeasure.d.ts

@@ -0,0 +1,116 @@
+import * as THREE from 'three';
+/**
+ * 双击快速测量：从落点沿所在平面的法线发一条射线，取第一个打到的模型表面作为终点。
+ * 典型场景是双击墙面直接得到墙到对面墙的垂直距离。
+ */
+/** 射线起点离开表面的距离（米），避免射线一出发就打中落点所在的面 */
+export declare const NORMAL_RAY_START_OFFSET = 0.01;
+/** 终点离起点太近（米）视为无效，例如打中了落点旁边的小凸起 */
+export declare const NORMAL_RAY_MIN_DISTANCE = 0.02;
+/** 射线最远距离（米），超过视为没打到 */
+export declare const NORMAL_RAY_MAX_DISTANCE = 100;
+/** 双击判定：两次抬起的最大间隔（毫秒） */
+export declare const DOUBLE_CLICK_INTERVAL = 350;
+/** 双击判定：两次抬起的最大屏幕距离（像素） */
+export declare const DOUBLE_CLICK_MAX_MOVE = 6;
+export interface RaycastHit {
+    point: THREE.Vector3;
+    distance: number;
+    /** 命中面；THREE.Intersection 的 face.normal 已经是世界坐标系法线 */
+    face?: {
+        normal?: THREE.Vector3 | null;
+    } | null;
+}
+/** 法线快速测量的命中结果 */
+export interface NormalMeasureHit {
+    /** 终点 */
+    point: THREE.Vector3;
+    /** 终点所在表面的世界坐标系法线；拿不到时为 null */
+    normal: THREE.Vector3 | null;
+}
+/** 对模型做射线检测，返回按距离排序的命中结果 */
+export type ModelRaycast = (raycaster: THREE.Raycaster) => RaycastHit[];
+/**
+ * 沿法线求快速测量的命中点。
+ * @param point - 起点（双击的落点）
+ * @param normal - 起点所在平面的法线（世界坐标，朝向表面外侧，即朝向相机这一侧）
+ * @returns 命中点及其表面法线；法线无效或没打到模型时返回 null
+ */
+export declare function findNormalMeasureHit(point: THREE.Vector3, normal: THREE.Vector3, raycast: ModelRaycast): NormalMeasureHit | null;
+/** 只要终点时用这个 */
+export declare function findNormalMeasureEnd(point: THREE.Vector3, normal: THREE.Vector3, raycast: ModelRaycast): THREE.Vector3 | null;
+/**
+ * 识别「第二下点在刚打下的点上」的双击。
+ * 只记录上一次抬起的时间和屏幕位置；时间和位置都足够近才算双击，命中后清空，三连击不会触发两次。
+ */
+export declare class DoubleClickDetector {
+    private readonly interval;
+    private readonly maxMove;
+    private last;
+    constructor(interval?: number, maxMove?: number);
+    /** 每次单击抬起时调用；返回 true 表示与上一次构成双击 */
+    hit(x: number, y: number, time: number): boolean;
+    reset(): void;
+}
+/** 双击时第二下离起点的最大屏幕距离（像素）。起点可能被吸附偏离光标几像素，所以比双击判定宽一些 */
+export declare const START_POINT_HIT_RADIUS = 16;
+interface QuickMeasureCamera {
+    position: THREE.Vector3;
+}
+export interface QuickNormalMeasureOptions {
+    /** 当前相机；朝向判断和屏幕投影都用它 */
+    getCamera: () => THREE.Camera & QuickMeasureCamera;
+    /** five 画布，用来把世界坐标换算成屏幕坐标 */
+    getElement: () => HTMLElement | null | undefined;
+    /** 对模型做射线检测 */
+    raycast: ModelRaycast;
+    /** 正在测量的点；不在测量中返回 null */
+    getMeasuringPoints: () => THREE.Vector3[] | null;
+    /**
+     * 打到对面：用起点和终点生成测量。
+     * 返回 true 表示测量会话继续（控制器以终点作为下一段的起点），此时命中面的法线会留作下一段的起始法线。
+     */
+    finish: (start: THREE.Vector3, end: THREE.Vector3) => boolean | void;
+    /** 没打到：撤掉起点，回到未打点状态 */
+    cancelStart: () => void;
+}
+/** 由 PointSelector 的 wantsSelect 事件驱动，返回 false 表示取消这次选点 */
+type WantsSelectHandler = (intersection?: {
+    point?: THREE.Vector3;
+    face?: {
+        normal?: THREE.Vector3 | null;
+    } | null;
+} | null) => boolean | void;
+/**
+ * 双击快速测量（只处理鼠标，触屏不触发）。
+ *
+ * 规则与 MP 一致：
+ * - 第一下单击照常打下起点 A，不延迟；第二下在双击时间内又点在 A 上，就从 A 沿法线测到对面，直接完成这条测量；
+ * - A 已经打下一段时间后，再双击 A 也会快速测量：落在 A 上的单击不会再打一个重合的点；
+ * - 已经开始连线（两个点及以上）时双击按普通单击处理；法线没打到模型时撤掉 A，不生成测量；
+ * - 快速测量完成后不退出选点：控制器以命中点为新一段的起点（finish 返回 true），继续选择下一个点位。
+ */
+export declare class QuickNormalMeasure {
+    private readonly options;
+    private readonly detector;
+    private lastMouseUp;
+    /** 起点 A 所在平面的法线，在打下 A 的那次选点里记下 */
+    private startNormal;
+    private attached;
+    constructor(options: QuickNormalMeasureOptions);
+    attach(pointSelector: {
+        on: (name: 'wantsSelect', callback: WantsSelectHandler) => unknown;
+    }): void;
+    detach(pointSelector: {
+        off: (name: 'wantsSelect', callback: WantsSelectHandler) => unknown;
+    }): void;
+    reset(): void;
+    private onMouseUp;
+    private onWantsSelect;
+    /** 只认刚刚发生的鼠标抬起，用完即清，避免触屏选点误用上一次鼠标的位置 */
+    private consumeMouseUp;
+    private isOnStartPoint;
+    /** 面法线可能朝向表面内侧；射线要往相机这一侧（空的一侧）发 */
+    private orientTowardCamera;
+}
+export {};

package/libs/MeasurePluginV2/normalMeasure.js

@@ -0,0 +1,110 @@
+var f = Object.defineProperty;
+var m = (n, t, e) => t in n ? f(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var a = (n, t, e) => (m(n, typeof t != "symbol" ? t + "" : t, e), e);
+import * as d from "three";
+const p = 0.01, M = 0.02, h = 100, N = 350, S = 6;
+function _(n, t, e) {
+  var l;
+  if (![n.x, n.y, n.z, t.x, t.y, t.z].every(Number.isFinite) || t.lengthSq() < 1e-12)
+    return null;
+  const s = t.clone().normalize(), r = n.clone().addScaledVector(s, p), i = new d.Raycaster(r, s, 0, h);
+  for (const o of e(i)) {
+    if (!(o != null && o.point) || !Number.isFinite(o.distance))
+      continue;
+    if (o.distance > h)
+      break;
+    const c = o.point.clone();
+    if (c.distanceTo(n) < M)
+      continue;
+    const u = (l = o.face) == null ? void 0 : l.normal;
+    return {
+      point: c,
+      normal: u && u.lengthSq() > 1e-12 ? u.clone().normalize() : null
+    };
+  }
+  return null;
+}
+class g {
+  constructor(t = N, e = S) {
+    a(this, "last", null);
+    this.interval = t, this.maxMove = e;
+  }
+  /** 每次单击抬起时调用；返回 true 表示与上一次构成双击 */
+  hit(t, e, s) {
+    const r = this.last;
+    return r && s - r.time <= this.interval && Math.hypot(t - r.x, e - r.y) <= this.maxMove ? (this.last = null, !0) : (this.last = { time: s, x: t, y: e }, !1);
+  }
+  reset() {
+    this.last = null;
+  }
+}
+const C = 16, E = 100;
+class A {
+  constructor(t) {
+    a(this, "detector", new g());
+    a(this, "lastMouseUp", null);
+    /** 起点 A 所在平面的法线，在打下 A 的那次选点里记下 */
+    a(this, "startNormal", null);
+    a(this, "attached", !1);
+    a(this, "onMouseUp", (t) => {
+      t.button === 0 && (this.lastMouseUp = { x: t.clientX, y: t.clientY, time: performance.now() });
+    });
+    a(this, "onWantsSelect", (t) => {
+      const e = this.options.getMeasuringPoints();
+      if (!e)
+        return;
+      const s = this.consumeMouseUp(), r = s ? this.detector.hit(s.x, s.y, s.time) : !1;
+      if (e.length === 0) {
+        this.startNormal = T(t);
+        return;
+      }
+      if (e.length !== 1 || !s)
+        return;
+      const i = e[0];
+      if (!this.isOnStartPoint(i, s))
+        return;
+      if (!r)
+        return !1;
+      const l = this.startNormal ? this.orientTowardCamera(this.startNormal, i) : null, o = l ? _(i, l, this.options.raycast) : null;
+      return this.startNormal = null, o ? (this.options.finish(i, o.point) === !0 && o.normal && (this.startNormal = this.orientTowardCamera(o.normal, o.point)), !1) : (this.options.cancelStart(), !1);
+    });
+    this.options = t;
+  }
+  attach(t) {
+    this.attached || (this.attached = !0, document.addEventListener("mouseup", this.onMouseUp, !0), t.on("wantsSelect", this.onWantsSelect));
+  }
+  detach(t) {
+    this.attached && (this.attached = !1, document.removeEventListener("mouseup", this.onMouseUp, !0), t.off("wantsSelect", this.onWantsSelect), this.reset());
+  }
+  reset() {
+    this.detector.reset(), this.lastMouseUp = null, this.startNormal = null;
+  }
+  /** 只认刚刚发生的鼠标抬起，用完即清，避免触屏选点误用上一次鼠标的位置 */
+  consumeMouseUp() {
+    const t = this.lastMouseUp;
+    return this.lastMouseUp = null, !t || performance.now() - t.time > E ? null : t;
+  }
+  isOnStartPoint(t, e) {
+    const s = this.options.getElement();
+    if (!s)
+      return !1;
+    const r = s.getBoundingClientRect(), i = t.clone().project(this.options.getCamera());
+    if (!Number.isFinite(i.x) || !Number.isFinite(i.y) || i.z > 1)
+      return !1;
+    const l = r.left + (i.x + 1) / 2 * r.width, o = r.top + (1 - i.y) / 2 * r.height;
+    return Math.hypot(l - e.x, o - e.y) <= C;
+  }
+  /** 面法线可能朝向表面内侧；射线要往相机这一侧（空的一侧）发 */
+  orientTowardCamera(t, e) {
+    const s = this.options.getCamera().position.clone().sub(e);
+    return t.dot(s) < 0 ? t.clone().negate() : t.clone();
+  }
+}
+function T(n) {
+  var e;
+  const t = (e = n == null ? void 0 : n.face) == null ? void 0 : e.normal;
+  return !t || t.lengthSq() < 1e-12 ? null : t.clone().normalize();
+}
+export {
+  A as QuickNormalMeasure
+};

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;

package/libs/PanoMeasurePlugin/Controller/MixedController.js

@@ -4,13 +4,13 @@ var t = (n, s, e) => (D(n, typeof s != "symbol" ? s + "" : s, e), e);
 import { Model as S } from "../Model/index.js";
 import T from "../Model/line.js";
 import M from "./BaseController.js";
-import G from "../Modules/DeleteDom/index.js";
+import R from "../Modules/DeleteDom/index.js";
 import { Vector2 as p } from "three";
-import L from "../utils/isNDCPointInScreen.js";
-import { closestPointOnLine as W } from "../utils/math.js";
-import { Polyline as C } from "../Model/polyline.js";
-import E from "../Modules/rangePiece/index.js";
-import { getFiveModel as N } from "../../shared-utils/five/getFiveModel.js";
+import C from "../utils/isNDCPointInScreen.js";
+import { closestPointOnLine as G } from "../utils/math.js";
+import { Polyline as L } from "../Model/polyline.js";
+import W from "../Modules/rangePiece/index.js";
+import { getFiveModel as E } from "../../shared-utils/five/getFiveModel.js";
 import "../../shared-utils/Subscribe.js";
 import "../../shared-utils/uuid.js";
 import "../utils/line.js";
@@ -47,12 +47,12 @@ class me extends M {
     t(this, "onWantsTapGesture", (e) => {
       if (this.state === "editing")
         return !1;
-      const i = N(this.five), [r] = i.intersectRaycaster(e);
+      const i = E(this.five), [r] = i.intersectRaycaster(e);
       if (!r)
         return;
       const a = this.five.camera, g = r.point.clone().project(a), l = this.container.clientWidth, d = this.container.clientHeight, f = new p(g.x * l, g.y * d), u = this.model.getAllLines().map((o) => {
         const [h, w] = o.points, c = h.position.clone().project(a), m = w.position.clone().project(a);
-        if (!L(c) && !L(m))
+        if (!C(c) && !C(m))
           return null;
         const k = new p(c.x * l, c.y * d), b = new p(m.x * l, m.y * d);
         return { id: o.id, points: [k, b] };
@@ -60,7 +60,7 @@ class me extends M {
       if (u.length === 0)
         return;
       const P = u.map((o) => {
-        const h = W(f, o.points);
+        const h = G(f, o.points);
         return { id: o.id, distance: h.distanceTo(f) };
       }).sort((o, h) => o.distance - h.distance)[0];
       if (P.distance > 20)
@@ -84,7 +84,7 @@ class me extends M {
       this.magnifier.containerDom !== this.container && this.magnifier.appendTo(this.container), this.magnifier.state.enabled || this.magnifier.enable(), requestAnimationFrame(() => this.magnifier.renderWithPoint(e.position)), this.five.needsRender = !0;
     });
     t(this, "onGetStartPoint", (e) => {
-      this.mobileStartPoint = e, this.polyline = new C({ model: this.model }), this.polyline.hook.on("lineAdded", () => this.hook.emit("editedPolylineChange", this.polyline)), this.polyline.hook.on("lineRemoved", () => this.hook.emit("editedPolylineChange", this.polyline));
+      this.mobileStartPoint = e, this.polyline = new L({ model: this.model }), this.polyline.hook.on("lineAdded", () => this.hook.emit("editedPolylineChange", this.polyline)), this.polyline.hook.on("lineRemoved", () => this.hook.emit("editedPolylineChange", this.polyline));
     });
     t(this, "onGetEndPoint", () => {
       const e = this.mobileNowPoint;
@@ -121,12 +121,15 @@ class me extends M {
     t(this, "cancelDeleteClickCallback", () => {
       this.clearHighlightLines();
     });
-    this.model = new S(this.config), this.polyline = new C({ model: this.model }), this.rangePieceController = new E(e), this.deleteDom = new G(this.five, {
+    this.model = new S(this.config), this.polyline = new L({ model: this.model }), this.rangePieceController = this.createRangePieceController(e), this.deleteDom = new R(this.five, {
       i18n: this.config.i18n,
       onClick: this.deleteDomClickCallback,
       cancel: this.cancelDeleteClickCallback
     }).appendTo(this.container), this.five.on("cameraUpdate", this.onCameraUpdate), this.five.on("wantsTapGesture", this.onWantsTapGesture), this.five.on("wantsToMoveToPano", this.onWantsToMoveToPano), this.five.helperVisible = !1, this.hook.emit("editedDashedLineChange", null), this.hook.on("getStartPoint", this.onGetStartPoint), this.hook.on("getEndPoint", this.onGetEndPoint), this.hook.on("nowPointChange", this.onNowPointChange), this.hook.on("willChangeState", this.onWillChangeState), this.five.refresh();
   }
+  createRangePieceController(e) {
+    return new W(e);
+  }
   dispose() {
     super.dispose(), this.disposers.forEach((e) => e()), this.five.helperVisible = !0, this.rangePieceController.dispose(), this.group.remove(this.mouseGroup), this.dashed.remove(), this.perpendicularDashed.remove(), this.five.off("cameraUpdate", this.onCameraUpdate), this.five.off("wantsTapGesture", this.onWantsTapGesture), this.five.off("wantsToMoveToPano", this.onWantsToMoveToPano), this.hook.off("getStartPoint", this.onGetStartPoint), this.hook.off("getEndPoint", this.onGetEndPoint), this.hook.off("nowPointChange", this.onNowPointChange), this.hook.off("willChangeState", this.onWillChangeState), this.hook.emit("selectedChange", []), this.five.needsRender = !0;
   }

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

@@ -1,5 +1,7 @@
 import type Line from '../Model/line';
+import type { Intersection } from '@realsee/five';
 import BaseController, { type ControllerParams } from './BaseController';
+import { Vector2 } from 'three';
 export default class WatchController extends BaseController {
     type: string;
     private deleteDom;
@@ -19,6 +21,8 @@ export default class WatchController extends BaseController {
     private unHighlightLines;
     private onPanStart;
     private onPanEnd;
+    protected onPointEditEnd(): void;
+    protected resolveIntersection(intersection: Intersection, _mouse: Vector2): Intersection;
     private onPan;
     private onIntersectionUpdate;
     private wantsPanGesture;