@realsee/dnalogel 3.81.15 → 3.81.16-dev.2

package/libs/MeasurePlugin/index.d.ts

@@ -12,6 +12,6 @@ export type MeasurePluginConfig = {
      */
     precision?: number;
 };
-export type { MeasureEndReason, MeasurePluginEventMap, MeasureInteractionState } from './Controller';
+export type { MeasureEndReason, MeasurePluginEventMap } from './Controller';
 export { validatePolygon } from './utils/validatePolygon';
 export declare const MeasurePlugin: (five: Five, config?: MeasurePluginConfig) => MeasureController;

package/libs/MeasurePluginV2/Controller.d.ts

@@ -0,0 +1,20 @@
+import type { Five } from '@realsee/five';
+import { PointSelector } from '../shared-utils';
+import { MeasureController } from '../MeasurePlugin/Controller';
+import type { MeasurePluginConfig } from '../MeasurePlugin';
+import { MeasureMagnifier } from './Magnifier';
+/**
+ * 量尺插件 V2：把放大镜换成带「坐标轴 + 落点平面框」的版本。
+ *
+ * 放大镜是在 PointSelector 的 helper 里创建的，所以这里只覆盖 pointSelector 这个 getter，
+ * 其余选点 / 吸附 / 打点 / 撤销 / 重定位逻辑全部沿用 MeasureController，不改动原插件的任何代码。
+ */
+export declare class MeasureControllerV2 extends MeasureController {
+    private v2Five;
+    private v2PointSelector?;
+    private v2Magnifier?;
+    constructor(five: Five, config?: MeasurePluginConfig);
+    /** V2 的放大镜实例；需要临时关掉叠加层做对比时，可以 magnifier.setOverlayEnabled(false) */
+    get magnifier(): MeasureMagnifier;
+    get pointSelector(): PointSelector;
+}

package/libs/MeasurePluginV2/Controller.js

@@ -0,0 +1,51 @@
+var p = Object.defineProperty;
+var m = (e, t, r) => t in e ? p(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var o = (e, t, r) => (m(e, typeof t != "symbol" ? t + "" : t, r), r);
+import "../shared-utils/tag.js";
+import "three";
+import "../vendor/hammerjs/hammer.js";
+import { PointSelector as s } from "../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 { MeasureController as a } from "../MeasurePlugin/Controller.js";
+import { MeasureMagnifier as l } from "./Magnifier.js";
+class H extends a {
+  constructor(r, i) {
+    super(r, i);
+    o(this, "v2Five");
+    o(this, "v2PointSelector");
+    o(this, "v2Magnifier");
+    this.v2Five = r;
+  }
+  /** V2 的放大镜实例；需要临时关掉叠加层做对比时，可以 magnifier.setOverlayEnabled(false) */
+  get magnifier() {
+    return this.v2Magnifier;
+  }
+  get pointSelector() {
+    if (this.v2PointSelector)
+      return this.v2PointSelector;
+    const r = new l(this.v2Five, {
+      dragEnabled: !0,
+      autoFixPCPosition: !0,
+      skipPanorama: !0
+    }), i = new s(this.v2Five, {
+      mode: "cursor",
+      helper: { pointHelper: "highlight", magnifier: r },
+      skipPanorama: !0
+    });
+    return i.on("intersectionUpdate", (n) => {
+      r.setIntersection(n != null ? n : null);
+    }), this.v2Magnifier = r, this.v2PointSelector = i, i;
+  }
+}
+export {
+  H as MeasureControllerV2
+};

package/libs/MeasurePluginV2/Magnifier.d.ts

@@ -0,0 +1,36 @@
+import type { Five } from '@realsee/five';
+import { Magnifier, type MagnifierParameter, type PointIntersection } from '../shared-utils';
+export interface MeasureMagnifierOptions extends MagnifierParameter {
+    /** 是否绘制坐标轴 / 平面框叠加层，默认 true（关掉后行为与现状 Magnifier 完全一致） */
+    overlayEnabled?: boolean;
+}
+/**
+ * 量尺 V2 用的放大镜。
+ *
+ * 完全复用 Magnifier 的「读像素 + 放大」逻辑（直接 super.render()），
+ * 只是在其之后往同一个 2D canvas 上叠加坐标轴与落点平面框。
+ */
+export declare class MeasureMagnifier extends Magnifier {
+    /** 父类把 five 存成了 private，这里自己留一份，叠加层投影时要用 */
+    private overlayFive;
+    /** 父类把 context 存成了 private；getContext('2d') 拿到的是同一个实例 */
+    private overlayContext;
+    /** 由 PointSelector 的 intersectionUpdate 事件注入 */
+    private overlayIntersection;
+    private overlayEnabled;
+    constructor(five: Five, options?: MeasureMagnifierOptions);
+    /** 每次交点更新时调用；传 null 表示当前没有命中任何模型 */
+    setIntersection(intersection: PointIntersection | null): void;
+    /** 开关叠加层，用于灰度 / 排查问题 */
+    setOverlayEnabled(enabled: boolean): void;
+    render(): void;
+    private renderOverlay;
+    private getOverlayContext;
+    /**
+     * 还原 Magnifier.render() 内部的取值，用来把世界坐标映射到放大镜 canvas 坐标。
+     * 这些换算必须和父类保持一致，父类改动时需要同步。
+     */
+    private getOverlayViewport;
+    /** 父类的 scale 是 private，只能这样读；它是真值来源，避免自己再维护一份副本 */
+    private getMagnifierScale;
+}

package/libs/MeasurePluginV2/Magnifier.js

@@ -0,0 +1,91 @@
+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(), this.renderOverlay();
+  }
+  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()), [d, h] = (() => {
+      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(), y = l / this.getMagnifierScale();
+    return {
+      camera: e.camera,
+      renderSize: i,
+      readLeft: d - c / 2,
+      // 父类纵向也是用 readPixelsWidth 减的，这里保持一致，否则叠加层会和放大的画面错位
+      readTop: h - c / 2,
+      readPixelsHeight: y,
+      pixelRadio: o * this.getMagnifierScale(),
+      canvasWidth: s * o,
+      canvasHeight: l * o
+    };
+  }
+  /** 父类的 scale 是 private，只能这样读；它是真值来源，避免自己再维护一份副本 */
+  getMagnifierScale() {
+    return this.scale;
+  }
+}
+export {
+  T as MeasureMagnifier
+};

package/libs/MeasurePluginV2/PointOverlay.d.ts

@@ -0,0 +1,66 @@
+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（此时只画坐标轴，不画平面框）。
+ */
+export declare function getWorldNormal(intersection: PointIntersection): THREE.Vector3 | null;
+/**
+ * 绘制落点叠加层。
+ * 调用时机：Magnifier.render() 里 putImageData 之后。
+ */
+export declare function drawMeasureOverlay(context: CanvasRenderingContext2D, viewport: MagnifierViewport, intersection: PointIntersection): void;

package/libs/MeasurePluginV2/PointOverlay.js

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

package/libs/MeasurePluginV2/index.d.ts

@@ -0,0 +1,25 @@
+import type { Five } from '@realsee/five';
+import { MeasureControllerV2 } from './Controller';
+/**
+ * 量尺插件 V2 —— 点位选择可视化（对应 PRD《量尺点位选择器优化》）
+ *
+ * 与 MeasurePlugin 的关系：V2 是试点 fork，完全继承 MeasurePlugin 的控制器，
+ * 只在放大镜里多画「坐标轴（M1）+ 落点平面高亮（M2）」，不改动原插件的任何代码、不影响线上既有行为。
+ *
+ * 使用方式（Console / 编辑器等接入方）：
+ * ```ts
+ * import { MeasureV2 } from '@realsee/dnalogel'
+ * const measure = MeasureV2.MeasurePluginV2(five, { unit: 'm' })
+ * ```
+ */
+export { MeasureControllerV2 } from './Controller';
+export { MeasureMagnifier } from './Magnifier';
+export type { MeasureMagnifierOptions } from './Magnifier';
+export { drawMeasureOverlay, getWorldNormal, OVERLAY_STYLE } from './PointOverlay';
+export type { MagnifierViewport } from './PointOverlay';
+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,34 @@
+import { MeasureControllerV2 as o } from "./Controller.js";
+import { MeasureMagnifier as i } from "./Magnifier.js";
+import { OVERLAY_STYLE as m, drawMeasureOverlay as p, getWorldNormal as l } from "./PointOverlay.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 a } from "../MeasurePlugin/utils/validatePolygon.js";
+import "../vendor/hotkeys-js/dist/hotkeys.esm.js";
+const r = (t, e) => new o(t, e), L = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MeasureControllerV2: o,
+  MeasureMagnifier: i,
+  MeasurePluginV2: r,
+  OVERLAY_STYLE: m,
+  default: r,
+  drawMeasureOverlay: p,
+  getWorldNormal: l,
+  validatePolygon: a
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  L as index
+};

package/libs/base/BasePlugin.js

@@ -23,7 +23,7 @@ let I = class {
     /**
      * @realsee/dnalogel 版本号
      */
-    r(this, "VERSION", "3.81.15");
+    r(this, "VERSION", "3.81.16-dev.1");
     r(this, "NAME");
     r(this, "five");
     r(this, "workUtil");

package/libs/index.d.ts

@@ -12,6 +12,7 @@ export * from './PanoRulerProPlugin';
 export * from './PanoCompassPlugin';
 export * from './PanoMeasurePlugin';
 export * from './MeasurePlugin';
+export * as MeasureV2 from './MeasurePluginV2';
 export * from './PanoSpatialTagPlugin';
 export * from './ModelItemLabelPlugin';
 export * from './ModelTVVideoPlugin';