build-dxf 0.1.6 → 0.1.7

package/src/build.js

@@ -1,11 +1,11 @@
 import * as THREE from "three";
-import { EventDispatcher as EventDispatcher$1, Group as Group$1, Vector3, Box3, Layers, Plane, Line3, Sphere, Triangle } from "three";
+import { EventDispatcher as EventDispatcher$1, Group as Group$1 } from "three";
 import ClipperLib from "clipper-lib";
 import Drawing from "dxf-writer";
 import { OBJExporter } from "three/examples/jsm/exporters/OBJExporter.js";
+import { Brush, Evaluator, SUBTRACTION } from "three-bvh-csg";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { GLTFExporter } from "three/addons/exporters/GLTFExporter.js";
-import { Brush, Evaluator, SUBTRACTION } from "three-bvh-csg";
 const VITE_OSS_BASEURL = "https://image.cnyang.cn/common-assets/".endsWith("/") ? "https://image.cnyang.cn/common-assets/" : "https://image.cnyang.cn/common-assets//";
 const DEFAULT_WALL_WIDTH = 0.12;
 const DEFAULT_DOOR_HEIGHT = 2.1;
@@ -1309,6 +1309,38 @@ class UnionFindSet {
     return sets;
   }
 }
+class LineIndexGenerator {
+  index = 0;
+  get size() {
+    return this.index;
+  }
+  constructor(lines = []) {
+    lines.forEach((key) => {
+      const id = this.next();
+      this.map.set(key, id);
+      this.lineMap.set(id, key);
+    });
+  }
+  next() {
+    return this.index++;
+  }
+  reset() {
+    this.index = 0;
+  }
+  map = /* @__PURE__ */ new Map();
+  lineMap = /* @__PURE__ */ new Map();
+  getIndex(key) {
+    if (!this.map.has(key)) {
+      const id = this.next();
+      this.map.set(key, id);
+      this.lineMap.set(id, key);
+    }
+    return this.map.get(key);
+  }
+  getLine(index2) {
+    return this.lineMap.get(index2);
+  }
+}
 const set = /* @__PURE__ */ new Set();
 function addLengthAsyncClear(line) {
   if (set.size === 0) queueMicrotask(() => {
@@ -1485,7 +1517,7 @@ class LineSegment {
    * @returns 线段的长度
    */
   getLength() {
-    return this.points[0].distance(this.points[1]);
+    return this.points[0].distance(this.points[1], false);
   }
   /**
    * 获取方向
@@ -1526,8 +1558,7 @@ class LineSegment {
     const [q1, q2] = this.points;
     const dir = new Point(q2.x - q1.x, q2.y - q1.y);
     if (dir.x === 0 && dir.y === 0) {
-      console.error("投影目标线段的两个点不能重合");
-      return new LineSegment();
+      throw new Error("投影目标线段的两个点不能重合");
     }
     const projectPoint = (point) => {
       const pq = new Point(point.x - q1.x, point.y - q1.y);
@@ -1842,12 +1873,12 @@ class LineSegment {
   /** 克隆
    * @returns 
    */
-  clone() {
+  clone(userData = true) {
     const line = new LineSegment(
       this.points[0].clone(),
       this.points[1].clone()
     );
-    line.userData = cloneUserData(this.userData);
+    if (userData) line.userData = cloneUserData(this.userData);
     return line;
   }
   /**
@@ -1947,6 +1978,21 @@ class LineSegment {
     }
     return groups;
   }
+  /** 分组，通过点
+   * @param lines 
+   * @returns 
+   */
+  static groupByPoint(lines) {
+    const unionFindSet = new UnionFindSet(lines.length), map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lines.length; i++) {
+      lines[i].points.forEach((point) => {
+        const id = point.hashCode();
+        if (map.has(id)) unionFindSet.union(map.get(id), i);
+        map.set(id, i);
+      });
+    }
+    return unionFindSet.getAllSets().valueArray.map((list) => list.map((i) => lines[i]));
+  }
   /** 通过最大叶子路径，给线段分组，每条路径没有分叉
    * @param lines 
    * @returns 
@@ -1992,21 +2038,6 @@ class LineSegment {
     }
     return paths;
   }
-  /** 分组，通过点
-   * @param lines 
-   * @returns 
-   */
-  static groupByPoint(lines) {
-    const unionFindSet = new UnionFindSet(lines.length), map = /* @__PURE__ */ new Map();
-    for (let i = 0; i < lines.length; i++) {
-      lines[i].points.forEach((point) => {
-        const id = point.hashCode();
-        if (map.has(id)) unionFindSet.union(map.get(id), i);
-        map.set(id, i);
-      });
-    }
-    return unionFindSet.getAllSets().valueArray.map((list) => list.map((i) => lines[i]));
-  }
   /** 分组，通过方向
    * @param lines 
    */
@@ -2019,6 +2050,92 @@ class LineSegment {
     }
     return [parallelLines, verticalLines];
   }
+  /** 通过轴，对线段进行分组
+   * @param lines 
+   * @param axisLine 
+   * @param errAngle 
+   * @returns 
+   */
+  static groupByAxis(lines, axisLine, errAngle = 1e-9) {
+    const parallelLines = [], otherLines = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (axisLine.isParallel(line, errAngle)) parallelLines.push(line);
+      else otherLines.push(line);
+    }
+    return [parallelLines, otherLines];
+  }
+  /** 交叉轴分组
+   * @description 通过交叉轴分组, 前提是使用groupByAxis对线段进行过轴分组，确保所有线段近乎平行
+   * @param lines 需要分组的线段集合
+   * @param crossAxis 交叉轴线段
+   * @param distanceThreshold 交叉轴阈值
+   * @returns 
+   */
+  static groupByCrossAxis(lines, crossAxis, distanceThreshold) {
+    const center = crossAxis.center, normal = crossAxis.normal(), principalAxis = new LineSegment(
+      center.clone().add(normal.clone().multiplyScalar(-1e3)),
+      center.clone().add(normal.clone().multiplyScalar(1e3))
+    ), crossAxisMap = /* @__PURE__ */ new Map(), crossValueList = [], principalAxisStartMap = /* @__PURE__ */ new Map(), principalAxisEndMap = /* @__PURE__ */ new Map();
+    lines.forEach((line) => {
+      const value = crossAxis.projectValue(line.start);
+      const point = crossAxis.projectPoint(line.start, false);
+      const opt = { value, line, point, index: -1 };
+      crossAxisMap.set(line, opt);
+      crossValueList.push(opt);
+      line.points.forEach((p, i) => {
+        const value2 = principalAxis.projectValue(p);
+        if (i === 0) principalAxisStartMap.set(line, value2);
+        else principalAxisEndMap.set(line, value2);
+      });
+    });
+    crossValueList.sort((a, b) => b.value - a.value).forEach((item, i) => item.index = i);
+    const unionFindSet = new UnionFindSet(lines.length), lineIndexGenerator = new LineIndexGenerator(lines);
+    function approach(preCrossOpt, crossOpt) {
+      return preCrossOpt.point.distance(crossOpt.point) <= distanceThreshold;
+    }
+    function coincide(preCrossOpt, minPrinValue, maxPrinValue) {
+      const prePrinStartV = principalAxisStartMap.get(preCrossOpt.line), prePrinEndV = principalAxisEndMap.get(preCrossOpt.line), minPrePrinValue = prePrinStartV < prePrinEndV ? prePrinStartV : prePrinEndV, maxPrePrinValue = prePrinStartV > prePrinEndV ? prePrinStartV : prePrinEndV;
+      return minPrePrinValue >= minPrinValue && minPrePrinValue <= maxPrinValue || maxPrePrinValue >= minPrinValue && maxPrePrinValue <= maxPrinValue || minPrinValue >= minPrePrinValue && minPrinValue <= maxPrePrinValue || maxPrinValue >= minPrePrinValue && maxPrinValue <= maxPrePrinValue;
+    }
+    for (let i = 0; i < crossValueList.length; i++) {
+      const crossOpt = crossValueList[i], { line } = crossOpt, prinStartV = principalAxisStartMap.get(line), prinEndV = principalAxisEndMap.get(line), minPrinValue = prinStartV < prinEndV ? prinStartV : prinEndV, maxPrinValue = prinStartV > prinEndV ? prinStartV : prinEndV;
+      for (let j = i - 1; j >= 0; j--) {
+        const pre = crossValueList[j];
+        if (approach(pre, crossOpt)) {
+          if (coincide(pre, minPrinValue, maxPrinValue)) {
+            unionFindSet.union(lineIndexGenerator.getIndex(line), lineIndexGenerator.getIndex(pre.line));
+            break;
+          }
+        } else break;
+      }
+    }
+    let groups = unionFindSet.getAllSets().valueArray.map((group2) => group2.map((index2) => lineIndexGenerator.getLine(index2)));
+    groups = groups.map((group2) => {
+      if (group2.length <= 2) return [group2];
+      const list = group2.map((line) => crossAxisMap.get(line)).sort((a, b) => a.value - b.value), start = list[0], end = list[list.length - 1];
+      if (start.point.distance(end.point) < distanceThreshold) return [group2];
+      const maxList = [...list].sort((a, b) => b.line.length() - a.line.length()), first = maxList[0], second = maxList[1], firstLength = first.line.length(), secondLength = second.line.length(), projLine = first.line.projectLineSegment(second.line), projLineLength = projLine.length();
+      if (first.point.distance(second.point) > distanceThreshold || secondLength / firstLength > 0.5 && projLineLength / secondLength < 0.5) {
+        const group1 = [first.line], group22 = [second.line];
+        for (let i = 0; i < list.length; i++) {
+          const opt = list[i];
+          if (opt === first || opt === second) continue;
+          const currentProjectLine = second.line.projectLineSegment(opt.line), len = currentProjectLine.length();
+          if (second.point.distance(opt.point) <= distanceThreshold && len / secondLength > 0) group22.push(opt.line);
+          else group1.push(opt.line);
+        }
+        return [group1, group22];
+      }
+      let index2 = 1;
+      for (; index2 < list.length; index2++) {
+        const { point } = list[index2];
+        if (list[0].point.distance(point) > distanceThreshold) break;
+      }
+      return [list.slice(0, index2).map((o) => o.line), list.slice(index2).map((o) => o.line)];
+    }).flat(1);
+    return groups;
+  }
   /** 合并线段到最长线段
    * @param lines
    * @returns 
@@ -3119,38 +3236,6 @@ class DoubleWallHelper {
     return lines;
   }
 }
-class LineIndexGenerator {
-  index = 0;
-  get size() {
-    return this.index;
-  }
-  constructor(lines = []) {
-    lines.forEach((key) => {
-      const id = this.next();
-      this.map.set(key, id);
-      this.lineMap.set(id, key);
-    });
-  }
-  next() {
-    return this.index++;
-  }
-  reset() {
-    this.index = 0;
-  }
-  map = /* @__PURE__ */ new Map();
-  lineMap = /* @__PURE__ */ new Map();
-  getIndex(key) {
-    if (!this.map.has(key)) {
-      const id = this.next();
-      this.map.set(key, id);
-      this.lineMap.set(id, key);
-    }
-    return this.map.get(key);
-  }
-  getLine(index2) {
-    return this.lineMap.get(index2);
-  }
-}
 function createPointVirtualGrid(lines) {
   const grid = new PointVirtualGrid();
   for (const seg of lines) {
@@ -5928,8 +6013,7 @@ class Dxf extends Component {
     this.scale = scale;
     this.shortLine = width * 0.4;
   }
-  /**
-   * 预处理数据
+  /** 预处理数据
    * @param data 
    */
   preprocessing(data) {
@@ -7754,437 +7838,91 @@ function drawText$1(text, point, style, offset = 1e-3) {
     }
   }
 }
-class Lines extends THREE.LineSegments {
-  geometry = new THREE.BufferGeometry();
-  points = [];
-  pointsObject3D;
-  constructor(points = [], color = 16777215) {
-    super();
-    this.geometry = this.geometry;
-    this.addPoint(...points);
-    this.frustumCulled = false;
-    this.pointsObject3D = new THREE.Points(this.geometry, new THREE.PointsMaterial({
-      sizeAttenuation: false,
-      size: 10
-    }));
-    this.material = new THREE.LineBasicMaterial({ color });
-  }
-  addPoint(...points) {
-    this.points.push(...points);
-    this.updateGeometry();
+if (typeof globalThis !== "undefined" && typeof ProgressEvent === "undefined") {
+  globalThis.ProgressEvent = class ProgressEvent extends EventTarget {
+    type;
+    lengthComputable;
+    loaded;
+    total;
+    bubbles;
+    cancelable;
+    defaultPrevented;
+    eventPhase;
+    timeStamp;
+    isTrusted;
+    constructor(type, options = {}) {
+      super();
+      this.type = type;
+      this.lengthComputable = options.lengthComputable || false;
+      this.loaded = options.loaded || 0;
+      this.total = options.total || 0;
+      this.bubbles = false;
+      this.cancelable = false;
+      this.defaultPrevented = false;
+      this.eventPhase = 0;
+      this.timeStamp = Date.now();
+      this.isTrusted = true;
+    }
+    preventDefault() {
+    }
+    stopPropagation() {
+    }
+    stopImmediatePropagation() {
+    }
+  };
+}
+let gltfLoader = GLTFExporter;
+let gltfExporter = GLTFLoader;
+let promise;
+function GltfInit() {
+  if (promise) return promise;
+  promise = new Promise(async (resolve) => {
+    try {
+      const { GLTFLoader: GLTFLoader2 } = await (typeof window !== "undefined" ? import("three/addons/loaders/GLTFLoader.js") : include("node-three-gltf", false));
+      gltfLoader = GLTFLoader2;
+      const { GLTFExporter: GLTFExporter2 } = await (typeof window !== "undefined" ? import("three/addons/exporters/GLTFExporter.js") : include("node-three-gltf", false));
+      gltfExporter = GLTFExporter2;
+    } catch (error) {
+      console.error(error);
+    }
+    resolve(true);
+  });
+  return promise;
+}
+const gltf = {
+  get GLTFLoader() {
+    return gltfLoader;
+  },
+  get GLTFExporter() {
+    return gltfExporter;
   }
-  setPoint(...points) {
-    this.points.length = 0;
-    this.addPoint(...points);
+};
+let loader;
+class LoadModel {
+  static _cache = /* @__PURE__ */ new Map();
+  static _nameMap = /* @__PURE__ */ new Map();
+  static addNameMap(mapName, name) {
+    this._nameMap.set(mapName, name);
   }
-  _timer = null;
-  updateGeometry() {
-    if (this._timer) clearTimeout(this._timer);
-    this._timer = setTimeout(() => {
-      const array = this.points.flatMap((p, i) => {
-        if (i === 0) return [];
-        else {
-          const p0 = this.points[i - 1];
-          return [p0.x, p0.y, p0.z, p.x, p.y, p.z];
-        }
+  // 获取模型
+  static loadGlb(name) {
+    if (this._nameMap.has(name)) name = this._nameMap.get(name);
+    if (this._cache.has(name)) return this._cache.get(name);
+    if (!loader) loader = new gltf.GLTFLoader();
+    const promise2 = new Promise(async (resolve) => {
+      const response = await fetch(`${VITE_OSS_BASEURL}models/${name}.glb`);
+      if (!response.ok) {
+        resolve(null);
+        return;
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const gltf2 = await new Promise((resolve2, reject) => {
+        loader.parse(arrayBuffer, "", resolve2, reject);
       });
-      const position = new THREE.BufferAttribute(new Float32Array(array), 3);
-      this.geometry.setAttribute("position", position);
-      this._timer = null;
+      resolve(gltf2.scene);
     });
-  }
-}
-function selectLocalFileFun() {
-  return new Promise((resolve) => {
-    const input = document.createElement("input");
-    input.type = "file";
-    input.accept = "application/json";
-    input.click();
-    input.onchange = () => {
-      if (input.files?.length) resolve(input.files[0]);
-      else resolve(null);
-    };
-  });
-}
-const SelectLocalFile = Object.assign(selectLocalFileFun, {
-  arrayBuffer() {
-    return new Promise(async (resolve) => {
-      const file = await selectLocalFileFun();
-      if (file instanceof File) {
-        const fileReader = new FileReader();
-        fileReader.onload = () => {
-          resolve(fileReader.result);
-        };
-        fileReader.readAsArrayBuffer(file);
-      } else resolve(null);
-    });
-  },
-  text() {
-    return new Promise(async (resolve) => {
-      const file = await selectLocalFileFun();
-      if (file instanceof File) {
-        const fileReader = new FileReader();
-        fileReader.onload = () => {
-          resolve(fileReader.result);
-        };
-        fileReader.readAsText(file, "utf-8");
-      } else resolve(null);
-    });
-  },
-  async json() {
-    const text = await this.text();
-    if (text) return JSON.parse(text);
-  }
-});
-class CommandFlow extends EventDispatcher {
-  list = [];
-  rollbacklist = [];
-  revokeRollbacklist = [];
-  // 是否写入操作记录
-  writeOperationList = true;
-  loop = false;
-  setLoop(loop) {
-    this.loop = loop;
-    return this;
-  }
-  /**
-   * 
-   * @param operation 
-   * @returns 
-   */
-  add(operation) {
-    this.list.push(operation);
-    return this;
-  }
-  /** 添加回滚回调列表
-   * @param callBack 
-   */
-  addRollback(callBack) {
-    this.rollbacklist.push(callBack);
-    return this;
-  }
-  /** 添加撤回回滚回调列表
-   * @param callBack 
-   * @returns 
-   */
-  addRevokeRollback(callBack) {
-    this.revokeRollbacklist.push(callBack);
-    return this;
-  }
-}
-class CommandManager extends EventDispatcher {
-  commandFlowMap = /* @__PURE__ */ new Map();
-  lock = false;
-  abortController = null;
-  resolve = null;
-  currentName = null;
-  _disabled = false;
-  set disabled(disabled) {
-    this._disabled = disabled;
-    if (this._disabled) this.cancel();
-  }
-  get disabled() {
-    return this._disabled;
-  }
-  /**
-   * 操作记录
-   */
-  operationList = [];
-  rollbackList = [];
-  constructor() {
-    super();
-  }
-  /** 添加命令流
-   * @param name 
-   * @returns 
-   */
-  addCommandFlow(name) {
-    if (this.commandFlowMap.has(name)) throw new Error(`${name} 命令已经存在`);
-    const commandFlow = new CommandFlow();
-    this.commandFlowMap.set(name, commandFlow);
-    return commandFlow;
-  }
-  executionPromise = null;
-  executionResolve = null;
-  /** 执行控制流
-   * @param name 
-   * @returns 
-   */
-  async start(name, data = null, step = 0) {
-    if (this.disabled) throw new Error("命令管理器已禁用，无法启动新的命令流");
-    this.dispatchEvent({
-      type: "startedBefore",
-      name,
-      currentName: this.currentName
-    });
-    this.executionPromise && await this.executionPromise;
-    this.executionPromise = null;
-    if (this.lock) {
-      throw new Error("命令管理器已被 " + this.currentName + " 命令锁定，无法启动新的命令流，请退出或等待命令执行结束");
-    }
-    const commandFlow = this.commandFlowMap.get(name);
-    if (!commandFlow) {
-      throw new Error(`命令流 ${name} 不存在`);
-    }
-    this.lock = true;
-    this.abortController = new AbortController();
-    this.currentName = name;
-    commandFlow.dispatchEvent({ type: "started" });
-    this.dispatchEvent({ type: "started", name });
-    try {
-      for (let i = step; i < commandFlow.list.length; i++) {
-        const operation = commandFlow.list[i];
-        commandFlow.dispatchEvent({ type: "executing", index: i });
-        this.dispatchEvent({ type: "executing", name, index: i });
-        data = await new Promise((resolve) => {
-          this.resolve = resolve;
-          operation(resolve, data);
-        });
-        if (this.abortController.signal.aborted) {
-          commandFlow.dispatchEvent({ type: "executionInterrupt", index: i });
-          this.dispatchEvent({ type: "executionInterrupt", name, index: i });
-          this.dispatchEvent({ type: "cancel", name });
-          break;
-        } else {
-          commandFlow.dispatchEvent({ type: "executionCompleted", index: i, data });
-          this.dispatchEvent({ type: "executionCompleted", name, index: i, data });
-        }
-      }
-    } catch (error) {
-      console.error(error);
-    } finally {
-      this.lock = false;
-      this.currentName = null;
-      if (this.abortController && !this.abortController.signal.aborted) {
-        commandFlow.dispatchEvent({ type: "completed", data });
-        this.dispatchEvent({ type: "completed", name, data });
-        if (commandFlow.writeOperationList) {
-          this.operationList.push({ name, data });
-          this.rollbackList.length = 0;
-        }
-        if (commandFlow.loop) queueMicrotask(() => this.start(name));
-      }
-      this.abortController = null;
-      commandFlow.dispatchEvent({ type: "finally" });
-      this.dispatchEvent({ type: "finally", name });
-      if (this.executionResolve) {
-        this.executionResolve(null);
-        this.executionResolve = null;
-      }
-    }
-    return data;
-  }
-  /** 取消当前命令
-   */
-  cancel() {
-    if (this.abortController) {
-      this.abortController.abort();
-      if (this.resolve) this.resolve();
-      this.executionPromise = new Promise((resolve) => this.executionResolve = resolve);
-    }
-  }
-  /**
-   * 回滚
-   */
-  rollback() {
-    try {
-      const operation = this.operationList.pop();
-      if (!operation) return false;
-      const commandFlow = this.commandFlowMap.get(operation.name);
-      if (!commandFlow) return false;
-      const data = commandFlow.rollbacklist.reduce((data2, callBack) => callBack(data2), operation.data);
-      this.dispatchEvent({ type: "rollback", name: operation.name });
-      this.rollbackList.push({
-        data,
-        name: operation.name
-      });
-      return true;
-    } catch (error) {
-      throw new Error(`回滚失败：${error}`);
-    }
-  }
-  /**
-   * 撤销回滚
-   */
-  revokeRollback() {
-    try {
-      const operation = this.rollbackList.pop();
-      if (!operation) return false;
-      const commandFlow = this.commandFlowMap.get(operation.name);
-      if (!commandFlow) return false;
-      const data = commandFlow.revokeRollbacklist.reduce((data2, callBack) => callBack(data2), operation.data);
-      this.dispatchEvent({ type: "revokeRollback", name: operation.name });
-      this.operationList.push({ name: operation.name, data });
-      return true;
-    } catch (error) {
-      throw new Error(`撤回回滚失败：${error}`);
-    }
-  }
-  destroy() {
-    this.cancel();
-    this.addEventListener("cancel", () => {
-      this.commandFlowMap.clear();
-      this.lock = false;
-      this.abortController = null;
-      this.resolve = null;
-      this.executionResolve = null;
-      this.executionPromise = null;
-      this.currentName = null;
-      this.operationList.length = 0;
-      this.rollbackList.length = 0;
-    }, { once: true });
-  }
-}
-if (typeof globalThis !== "undefined" && typeof ProgressEvent === "undefined") {
-  globalThis.ProgressEvent = class ProgressEvent extends EventTarget {
-    type;
-    lengthComputable;
-    loaded;
-    total;
-    bubbles;
-    cancelable;
-    defaultPrevented;
-    eventPhase;
-    timeStamp;
-    isTrusted;
-    constructor(type, options = {}) {
-      super();
-      this.type = type;
-      this.lengthComputable = options.lengthComputable || false;
-      this.loaded = options.loaded || 0;
-      this.total = options.total || 0;
-      this.bubbles = false;
-      this.cancelable = false;
-      this.defaultPrevented = false;
-      this.eventPhase = 0;
-      this.timeStamp = Date.now();
-      this.isTrusted = true;
-    }
-    preventDefault() {
-    }
-    stopPropagation() {
-    }
-    stopImmediatePropagation() {
-    }
-  };
-}
-let gltfLoader = GLTFExporter;
-let gltfExporter = GLTFLoader;
-let promise;
-function GltfInit() {
-  if (promise) return promise;
-  promise = new Promise(async (resolve) => {
-    try {
-      const { GLTFLoader: GLTFLoader2 } = await (typeof window !== "undefined" ? import("three/addons/loaders/GLTFLoader.js") : include("node-three-gltf", false));
-      gltfLoader = GLTFLoader2;
-      const { GLTFExporter: GLTFExporter2 } = await (typeof window !== "undefined" ? import("three/addons/exporters/GLTFExporter.js") : include("node-three-gltf", false));
-      gltfExporter = GLTFExporter2;
-    } catch (error) {
-      console.error(error);
-    }
-    resolve(true);
-  });
-  return promise;
-}
-const gltf = {
-  get GLTFLoader() {
-    return gltfLoader;
-  },
-  get GLTFExporter() {
-    return gltfExporter;
-  }
-};
-const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  ArrayMap,
-  AxisAlignCorr,
-  BoundExt,
-  Box2,
-  CommandFlow,
-  CommandManager,
-  Component,
-  ComponentManager,
-  CountMap,
-  DoubleWallHelper,
-  DxfSystem,
-  EventDispatcher,
-  GltfInit,
-  LineGroupType,
-  LineIndexGenerator,
-  LineSegment,
-  LineSegmentUndirectedGraph,
-  Lines,
-  MapEnhance,
-  Point,
-  PointVirtualGrid,
-  Polygon,
-  PvgList,
-  Quadtree,
-  Rectangle,
-  SceneAutoGenerat,
-  SelectLocalFile,
-  SetMap,
-  UndirectedGraph,
-  UnionFindSet,
-  buildBayWindowGroup,
-  buildDoubleWallGroup,
-  clippingDoubleWall,
-  clippingLineUserData,
-  cloneUserData,
-  closedPathArea,
-  components,
-  createPointVirtualGrid,
-  createQuadtree,
-  findCircleEdges,
-  findClosedPolygons,
-  findDiscretePoint,
-  findDiscretePointLine,
-  findDiscretePointLine2,
-  findLargestCircle,
-  findRingEdges,
-  findVerticalReference,
-  gltf,
-  lineDataToOriginalData,
-  lineDataToThreeVJiaJson,
-  lineSegmentClipping,
-  mergeLineUserData,
-  mergeSmallestCircle,
-  mergeWindow,
-  originalDataToLineData,
-  recomputedWindow,
-  recomputedWindowCenter,
-  ringsDeduplication: ringsDeduplication$1,
-  smallestCircle,
-  toOriginalDataItem,
-  tools,
-  uuid
-}, Symbol.toStringTag, { value: "Module" }));
-let loader;
-class LoadModel {
-  static _cache = /* @__PURE__ */ new Map();
-  static _nameMap = /* @__PURE__ */ new Map();
-  static addNameMap(mapName, name) {
-    this._nameMap.set(mapName, name);
-  }
-  // 获取模型
-  static loadGlb(name) {
-    if (this._nameMap.has(name)) name = this._nameMap.get(name);
-    if (this._cache.has(name)) return this._cache.get(name);
-    if (!loader) loader = new gltf.GLTFLoader();
-    const promise2 = new Promise(async (resolve) => {
-      const response = await fetch(`${VITE_OSS_BASEURL}models/${name}.glb`);
-      if (!response.ok) {
-        resolve(null);
-        return;
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const gltf2 = await new Promise((resolve2, reject) => {
-        loader.parse(arrayBuffer, "", resolve2, reject);
-      });
-      resolve(gltf2.scene);
-    });
-    this._cache.set(name, promise2);
-    return promise2;
+    this._cache.set(name, promise2);
+    return promise2;
   }
 }
 LoadModel.addNameMap("water cooler", "饮水机1");
@@ -8669,10 +8407,10 @@ class Scenario {
     let menModel = this.windowModely.clone();
     if (data.center && distance) {
       menModel.position.set(data.center.x, data.center.y, 0);
-      const box3 = new THREE.Box3();
-      box3.setFromObject(menModel);
+      const box32 = new THREE.Box3();
+      box32.setFromObject(menModel);
       let size = new THREE.Vector3();
-      box3.getSize(size);
+      box32.getSize(size);
       menModel.rotation.x = Math.PI / 2;
       menModel.rotation.y = angleRad;
       menModel.scale.set(distance / size.x, height / size.y, wallWidth / size.z);
@@ -8686,10 +8424,10 @@ class Scenario {
   installCabinet() {
     let cabinetModel = this.CabinetModel.clone();
     cabinetModel.position.set(5, 5, 0);
-    const box3 = new THREE.Box3();
-    box3.setFromObject(cabinetModel);
+    const box32 = new THREE.Box3();
+    box32.setFromObject(cabinetModel);
     let size = new THREE.Vector3();
-    box3.getSize(size);
+    box32.getSize(size);
     cabinetModel.rotation.x = Math.PI / 2;
     console.log("卡农看:", cabinetModel.geometry);
     cabinetModel.scale.set(0.7 / size.x, 0.7 / size.y, 0.3 / size.z);
@@ -8699,10 +8437,10 @@ class Scenario {
   installTable() {
     let tableModel = this.tableModel.clone();
     tableModel.position.set(5, 4, 0);
-    const box3 = new THREE.Box3();
-    box3.setFromObject(tableModel);
+    const box32 = new THREE.Box3();
+    box32.setFromObject(tableModel);
     let size = new THREE.Vector3();
-    box3.getSize(size);
+    box32.getSize(size);
     tableModel.rotation.x = Math.PI / 2;
     tableModel.scale.set(0.7 / size.x, 0.75 / size.y, 1.3 / size.z);
     this.group.add(tableModel);
@@ -8711,10 +8449,10 @@ class Scenario {
   installchair() {
     let tableModel = this.tableModel.clone();
     tableModel.position.set(5, 4, 0);
-    const box3 = new THREE.Box3();
-    box3.setFromObject(tableModel);
+    const box32 = new THREE.Box3();
+    box32.setFromObject(tableModel);
     let size = new THREE.Vector3();
-    box3.getSize(size);
+    box32.getSize(size);
     tableModel.rotation.x = Math.PI / 2;
     tableModel.scale.set(0.7 / size.x, 0.75 / size.y, 1.3 / size.z);
     this.group.add(tableModel);
@@ -8813,10 +8551,10 @@ class Scenario {
     let menModel = this.doorModely.clone();
     if (center && distance) {
       menModel.position.set(center.x, center.y, groundHeight);
-      const box3 = new THREE.Box3();
-      box3.setFromObject(menModel);
+      const box32 = new THREE.Box3();
+      box32.setFromObject(menModel);
       let size = new THREE.Vector3();
-      box3.getSize(size);
+      box32.getSize(size);
       menModel.rotation.x = Math.PI / 2;
       menModel.rotation.y = angleRad;
       menModel.scale.set(distance / size.x, (Height ? Height : this.doorHeight) / size.y, DEFAULT_WALL_WIDTH / size.z);
@@ -9009,7 +8747,6 @@ class Scenario {
     this.group.add(plane);
   }
 }
-const planeSrc = "data:image/jpeg;base64,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";
 function Rr(t, e, n = 0, r = t.length - 1, i = Mu) {
   for (; r > n; ) {
     if (r - n > 600) {
@@ -16050,514 +15787,13 @@ const { matrix: zr, transpose: ka, multiply: Ne } = ki({
   return [
     Ne([D, h], g),
     Ne([M, h], g),
-    Ne([M, w], g),
-    Ne([D, w], g),
-    Ne([D, h], g)
-  ];
-};
-class Capsule {
-  /**
-   * Constructs a new capsule.
-   *
-   * @param {Vector3} [start] - The start vector.
-   * @param {Vector3} [end] - The end vector.
-   * @param {number} [radius=1] - The capsule's radius.
-   */
-  constructor(start = new Vector3(0, 0, 0), end = new Vector3(0, 1, 0), radius = 1) {
-    this.start = start;
-    this.end = end;
-    this.radius = radius;
-  }
-  /**
-   * Returns a new capsule with copied values from this instance.
-   *
-   * @return {Capsule} A clone of this instance.
-   */
-  clone() {
-    return new this.constructor().copy(this);
-  }
-  /**
-   * Sets the capsule components to the given values.
-   * Please note that this method only copies the values from the given objects.
-   *
-   * @param {Vector3} start - The start vector.
-   * @param {Vector3} end - The end vector
-   * @param {number} radius - The capsule's radius.
-   * @return {Capsule} A reference to this capsule.
-   */
-  set(start, end, radius) {
-    this.start.copy(start);
-    this.end.copy(end);
-    this.radius = radius;
-    return this;
-  }
-  /**
-   * Copies the values of the given capsule to this instance.
-   *
-   * @param {Capsule} capsule - The capsule to copy.
-   * @return {Capsule} A reference to this capsule.
-   */
-  copy(capsule) {
-    this.start.copy(capsule.start);
-    this.end.copy(capsule.end);
-    this.radius = capsule.radius;
-    return this;
-  }
-  /**
-   * Returns the center point of this capsule.
-   *
-   * @param {Vector3} target - The target vector that is used to store the method's result.
-   * @return {Vector3} The center point.
-   */
-  getCenter(target) {
-    return target.copy(this.end).add(this.start).multiplyScalar(0.5);
-  }
-  /**
-   * Adds the given offset to this capsule, effectively moving it in 3D space.
-   *
-   * @param {Vector3} v - The offset that should be used to translate the capsule.
-   * @return {Capsule} A reference to this capsule.
-   */
-  translate(v) {
-    this.start.add(v);
-    this.end.add(v);
-    return this;
-  }
-  /**
-   * Returns `true` if the given bounding box intersects with this capsule.
-   *
-   * @param {Box3} box - The bounding box to test.
-   * @return {boolean} Whether the given bounding box intersects with this capsule.
-   */
-  intersectsBox(box) {
-    return checkAABBAxis(
-      this.start.x,
-      this.start.y,
-      this.end.x,
-      this.end.y,
-      box.min.x,
-      box.max.x,
-      box.min.y,
-      box.max.y,
-      this.radius
-    ) && checkAABBAxis(
-      this.start.x,
-      this.start.z,
-      this.end.x,
-      this.end.z,
-      box.min.x,
-      box.max.x,
-      box.min.z,
-      box.max.z,
-      this.radius
-    ) && checkAABBAxis(
-      this.start.y,
-      this.start.z,
-      this.end.y,
-      this.end.z,
-      box.min.y,
-      box.max.y,
-      box.min.z,
-      box.max.z,
-      this.radius
-    );
-  }
-}
-function checkAABBAxis(p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius) {
-  return (minx - p1x < radius || minx - p2x < radius) && (p1x - maxx < radius || p2x - maxx < radius) && (miny - p1y < radius || miny - p2y < radius) && (p1y - maxy < radius || p2y - maxy < radius);
-}
-const _v1 = new Vector3();
-const _v2 = new Vector3();
-const _point1 = new Vector3();
-const _point2 = new Vector3();
-const _plane = new Plane();
-const _line1 = new Line3();
-const _line2 = new Line3();
-const _sphere = new Sphere();
-const _capsule = new Capsule();
-const _temp1 = new Vector3();
-const _temp2 = new Vector3();
-const _temp3 = new Vector3();
-const EPS = 1e-10;
-function lineToLineClosestPoints(line1, line2, target1 = null, target2 = null) {
-  const r = _temp1.copy(line1.end).sub(line1.start);
-  const s = _temp2.copy(line2.end).sub(line2.start);
-  const w = _temp3.copy(line2.start).sub(line1.start);
-  const a = r.dot(s), b = r.dot(r), c = s.dot(s), d = s.dot(w), e = r.dot(w);
-  let t1, t2;
-  const divisor = b * c - a * a;
-  if (Math.abs(divisor) < EPS) {
-    const d1 = -d / c;
-    const d2 = (a - d) / c;
-    if (Math.abs(d1 - 0.5) < Math.abs(d2 - 0.5)) {
-      t1 = 0;
-      t2 = d1;
-    } else {
-      t1 = 1;
-      t2 = d2;
-    }
-  } else {
-    t1 = (d * a + e * c) / divisor;
-    t2 = (t1 * a - d) / c;
-  }
-  t2 = Math.max(0, Math.min(1, t2));
-  t1 = Math.max(0, Math.min(1, t1));
-  if (target1) {
-    target1.copy(r).multiplyScalar(t1).add(line1.start);
-  }
-  if (target2) {
-    target2.copy(s).multiplyScalar(t2).add(line2.start);
-  }
-}
-class Octree {
-  /**
-   * Constructs a new Octree.
-   *
-   * @param {Box3} [box] - The base box with enclose the entire Octree.
-   */
-  constructor(box) {
-    this.box = box;
-    this.bounds = new Box3();
-    this.layers = new Layers();
-    this.trianglesPerLeaf = 8;
-    this.maxLevel = 16;
-    this.subTrees = [];
-    this.triangles = [];
-  }
-  /**
-   * Adds the given triangle to the Octree. The triangle vertices are clamped if they exceed
-   * the bounds of the Octree.
-   *
-   * @param {Triangle} triangle - The triangle to add.
-   * @return {Octree} A reference to this Octree.
-   */
-  addTriangle(triangle) {
-    this.bounds.min.x = Math.min(this.bounds.min.x, triangle.a.x, triangle.b.x, triangle.c.x);
-    this.bounds.min.y = Math.min(this.bounds.min.y, triangle.a.y, triangle.b.y, triangle.c.y);
-    this.bounds.min.z = Math.min(this.bounds.min.z, triangle.a.z, triangle.b.z, triangle.c.z);
-    this.bounds.max.x = Math.max(this.bounds.max.x, triangle.a.x, triangle.b.x, triangle.c.x);
-    this.bounds.max.y = Math.max(this.bounds.max.y, triangle.a.y, triangle.b.y, triangle.c.y);
-    this.bounds.max.z = Math.max(this.bounds.max.z, triangle.a.z, triangle.b.z, triangle.c.z);
-    this.triangles.push(triangle);
-    return this;
-  }
-  /**
-   * Prepares {@link Octree#box} for the build.
-   *
-   * @return {Octree} A reference to this Octree.
-   */
-  calcBox() {
-    this.box = this.bounds.clone();
-    this.box.min.x -= 0.01;
-    this.box.min.y -= 0.01;
-    this.box.min.z -= 0.01;
-    return this;
-  }
-  /**
-   * Splits the Octree. This method is used recursively when
-   * building the Octree.
-   *
-   * @param {number} level - The current level.
-   * @return {Octree} A reference to this Octree.
-   */
-  split(level) {
-    if (!this.box) return;
-    const subTrees = [];
-    const halfsize = _v2.copy(this.box.max).sub(this.box.min).multiplyScalar(0.5);
-    for (let x = 0; x < 2; x++) {
-      for (let y = 0; y < 2; y++) {
-        for (let z = 0; z < 2; z++) {
-          const box = new Box3();
-          const v = _v1.set(x, y, z);
-          box.min.copy(this.box.min).add(v.multiply(halfsize));
-          box.max.copy(box.min).add(halfsize);
-          subTrees.push(new Octree(box));
-        }
-      }
-    }
-    let triangle;
-    while (triangle = this.triangles.pop()) {
-      for (let i = 0; i < subTrees.length; i++) {
-        if (subTrees[i].box.intersectsTriangle(triangle)) {
-          subTrees[i].triangles.push(triangle);
-        }
-      }
-    }
-    for (let i = 0; i < subTrees.length; i++) {
-      const len = subTrees[i].triangles.length;
-      if (len > this.trianglesPerLeaf && level < this.maxLevel) {
-        subTrees[i].split(level + 1);
-      }
-      if (len !== 0) {
-        this.subTrees.push(subTrees[i]);
-      }
-    }
-    return this;
-  }
-  /**
-   * Builds the Octree.
-   *
-   * @return {Octree} A reference to this Octree.
-   */
-  build() {
-    this.calcBox();
-    this.split(0);
-    return this;
-  }
-  /**
-   * Computes the triangles that potentially intersect with the given ray.
-   *
-   * @param {Ray} ray - The ray to test.
-   * @param {Array<Triangle>} triangles - The target array that holds the triangles.
-   */
-  getRayTriangles(ray, triangles) {
-    for (let i = 0; i < this.subTrees.length; i++) {
-      const subTree = this.subTrees[i];
-      if (!ray.intersectsBox(subTree.box)) continue;
-      if (subTree.triangles.length > 0) {
-        for (let j = 0; j < subTree.triangles.length; j++) {
-          if (triangles.indexOf(subTree.triangles[j]) === -1) triangles.push(subTree.triangles[j]);
-        }
-      } else {
-        subTree.getRayTriangles(ray, triangles);
-      }
-    }
-  }
-  /**
-   * Computes the intersection between the given capsule and triangle.
-   *
-   * @param {Capsule} capsule - The capsule to test.
-   * @param {Triangle} triangle - The triangle to test.
-   * @return {Object|false} The intersection object. If no intersection
-   * is detected, the method returns `false`.
-   */
-  triangleCapsuleIntersect(capsule, triangle) {
-    triangle.getPlane(_plane);
-    const d1 = _plane.distanceToPoint(capsule.start) - capsule.radius;
-    const d2 = _plane.distanceToPoint(capsule.end) - capsule.radius;
-    if (d1 > 0 && d2 > 0 || d1 < -capsule.radius && d2 < -capsule.radius) {
-      return false;
-    }
-    const delta = Math.abs(d1 / (Math.abs(d1) + Math.abs(d2)));
-    const intersectPoint = _v1.copy(capsule.start).lerp(capsule.end, delta);
-    if (triangle.containsPoint(intersectPoint)) {
-      return { normal: _plane.normal.clone(), point: intersectPoint.clone(), depth: Math.abs(Math.min(d1, d2)) };
-    }
-    const r2 = capsule.radius * capsule.radius;
-    const line1 = _line1.set(capsule.start, capsule.end);
-    const lines = [
-      [triangle.a, triangle.b],
-      [triangle.b, triangle.c],
-      [triangle.c, triangle.a]
-    ];
-    for (let i = 0; i < lines.length; i++) {
-      const line2 = _line2.set(lines[i][0], lines[i][1]);
-      lineToLineClosestPoints(line1, line2, _point1, _point2);
-      if (_point1.distanceToSquared(_point2) < r2) {
-        return {
-          normal: _point1.clone().sub(_point2).normalize(),
-          point: _point2.clone(),
-          depth: capsule.radius - _point1.distanceTo(_point2)
-        };
-      }
-    }
-    return false;
-  }
-  /**
-   * Computes the intersection between the given sphere and triangle.
-   *
-   * @param {Sphere} sphere - The sphere to test.
-   * @param {Triangle} triangle - The triangle to test.
-   * @return {Object|false} The intersection object. If no intersection
-   * is detected, the method returns `false`.
-   */
-  triangleSphereIntersect(sphere, triangle) {
-    triangle.getPlane(_plane);
-    if (!sphere.intersectsPlane(_plane)) return false;
-    const depth = Math.abs(_plane.distanceToSphere(sphere));
-    const r2 = sphere.radius * sphere.radius - depth * depth;
-    const plainPoint = _plane.projectPoint(sphere.center, _v1);
-    if (triangle.containsPoint(sphere.center)) {
-      return { normal: _plane.normal.clone(), point: plainPoint.clone(), depth: Math.abs(_plane.distanceToSphere(sphere)) };
-    }
-    const lines = [
-      [triangle.a, triangle.b],
-      [triangle.b, triangle.c],
-      [triangle.c, triangle.a]
-    ];
-    for (let i = 0; i < lines.length; i++) {
-      _line1.set(lines[i][0], lines[i][1]);
-      _line1.closestPointToPoint(plainPoint, true, _v2);
-      const d = _v2.distanceToSquared(sphere.center);
-      if (d < r2) {
-        return { normal: sphere.center.clone().sub(_v2).normalize(), point: _v2.clone(), depth: sphere.radius - Math.sqrt(d) };
-      }
-    }
-    return false;
-  }
-  /**
-   * Computes the triangles that potentially intersect with the given bounding sphere.
-   *
-   * @param {Sphere} sphere - The sphere to test.
-   * @param {Array<Triangle>} triangles - The target array that holds the triangles.
-   */
-  getSphereTriangles(sphere, triangles) {
-    for (let i = 0; i < this.subTrees.length; i++) {
-      const subTree = this.subTrees[i];
-      if (!sphere.intersectsBox(subTree.box)) continue;
-      if (subTree.triangles.length > 0) {
-        for (let j = 0; j < subTree.triangles.length; j++) {
-          if (triangles.indexOf(subTree.triangles[j]) === -1) triangles.push(subTree.triangles[j]);
-        }
-      } else {
-        subTree.getSphereTriangles(sphere, triangles);
-      }
-    }
-  }
-  /**
-   * Computes the triangles that potentially intersect with the given capsule.
-   *
-   * @param {Capsule} capsule - The capsule to test.
-   * @param {Array<Triangle>} triangles - The target array that holds the triangles.
-   */
-  getCapsuleTriangles(capsule, triangles) {
-    for (let i = 0; i < this.subTrees.length; i++) {
-      const subTree = this.subTrees[i];
-      if (!capsule.intersectsBox(subTree.box)) continue;
-      if (subTree.triangles.length > 0) {
-        for (let j = 0; j < subTree.triangles.length; j++) {
-          if (triangles.indexOf(subTree.triangles[j]) === -1) triangles.push(subTree.triangles[j]);
-        }
-      } else {
-        subTree.getCapsuleTriangles(capsule, triangles);
-      }
-    }
-  }
-  /**
-   * Performs a bounding sphere intersection test with this Octree.
-   *
-   * @param {Sphere} sphere - The bounding sphere to test.
-   * @return {Object|boolean} The intersection object. If no intersection
-   * is detected, the method returns `false`.
-   */
-  sphereIntersect(sphere) {
-    _sphere.copy(sphere);
-    const triangles = [];
-    let result, hit = false;
-    this.getSphereTriangles(sphere, triangles);
-    for (let i = 0; i < triangles.length; i++) {
-      if (result = this.triangleSphereIntersect(_sphere, triangles[i])) {
-        hit = true;
-        _sphere.center.add(result.normal.multiplyScalar(result.depth));
-      }
-    }
-    if (hit) {
-      const collisionVector = _sphere.center.clone().sub(sphere.center);
-      const depth = collisionVector.length();
-      return { normal: collisionVector.normalize(), depth };
-    }
-    return false;
-  }
-  /**
-   * Performs a capsule intersection test with this Octree.
-   *
-   * @param {Capsule} capsule - The capsule to test.
-   * @return {Object|boolean} The intersection object. If no intersection
-   * is detected, the method returns `false`.
-   */
-  capsuleIntersect(capsule) {
-    _capsule.copy(capsule);
-    const triangles = [];
-    let result, hit = false;
-    this.getCapsuleTriangles(_capsule, triangles);
-    for (let i = 0; i < triangles.length; i++) {
-      if (result = this.triangleCapsuleIntersect(_capsule, triangles[i])) {
-        hit = true;
-        _capsule.translate(result.normal.multiplyScalar(result.depth));
-      }
-    }
-    if (hit) {
-      const collisionVector = _capsule.getCenter(new Vector3()).sub(capsule.getCenter(_v1));
-      const depth = collisionVector.length();
-      return { normal: collisionVector.normalize(), depth };
-    }
-    return false;
-  }
-  /**
-   * Performs a ray intersection test with this Octree.
-   *
-   * @param {Ray} ray - The ray to test.
-   * @return {Object|boolean} The nearest intersection object. If no intersection
-   * is detected, the method returns `false`.
-   */
-  rayIntersect(ray) {
-    const triangles = [];
-    let triangle, position, distance = 1e100;
-    this.getRayTriangles(ray, triangles);
-    for (let i = 0; i < triangles.length; i++) {
-      const result = ray.intersectTriangle(triangles[i].a, triangles[i].b, triangles[i].c, true, _v1);
-      if (result) {
-        const newdistance = result.sub(ray.origin).length();
-        if (distance > newdistance) {
-          position = result.clone().add(ray.origin);
-          distance = newdistance;
-          triangle = triangles[i];
-        }
-      }
-    }
-    return distance < 1e100 ? { distance, triangle, position } : false;
-  }
-  /**
-   * Constructs the Octree from the given 3D object.
-   *
-   * @param {Object3D} group - The scene graph node.
-   * @return {Octree} A reference to this Octree.
-   */
-  fromGraphNode(group2) {
-    group2.updateWorldMatrix(true, true);
-    group2.traverse((obj) => {
-      if (obj.isMesh === true) {
-        if (this.layers.test(obj.layers)) {
-          let geometry, isTemp = false;
-          if (obj.geometry.index !== null) {
-            isTemp = true;
-            geometry = obj.geometry.toNonIndexed();
-          } else {
-            geometry = obj.geometry;
-          }
-          const positionAttribute = geometry.getAttribute("position");
-          for (let i = 0; i < positionAttribute.count; i += 3) {
-            const v1 = new Vector3().fromBufferAttribute(positionAttribute, i);
-            const v2 = new Vector3().fromBufferAttribute(positionAttribute, i + 1);
-            const v3 = new Vector3().fromBufferAttribute(positionAttribute, i + 2);
-            v1.applyMatrix4(obj.matrixWorld);
-            v2.applyMatrix4(obj.matrixWorld);
-            v3.applyMatrix4(obj.matrixWorld);
-            this.addTriangle(new Triangle(v1, v2, v3));
-          }
-          if (isTemp) {
-            geometry.dispose();
-          }
-        }
-      }
-    });
-    this.build();
-    return this;
-  }
-  /**
-   * Clears the Octree by making it empty.
-   *
-   * @return {Octree} A reference to this Octree.
-   */
-  clear() {
-    this.box = null;
-    this.bounds.makeEmpty();
-    this.subTrees.length = 0;
-    this.triangles.length = 0;
-    return this;
-  }
-}
+    Ne([M, w], g),
+    Ne([D, w], g),
+    Ne([D, h], g)
+  ];
+};
 let globalScenario;
+const box3 = new THREE.Box3();
 class SceneAutoGenerat {
   lines;
   itemList;
@@ -16579,30 +15815,6 @@ class SceneAutoGenerat {
     await this.buildItem();
     globalScenario.scene.add(this.scene);
   }
-  /**
-   * 获取包围矩形
-   */
-  getSurroundRect(path, angle = this.angle) {
-    const points = path.map((p) => Point.from(p)), box2 = Box2.fromByPoints(...points), center = box2.center;
-    drawLines(points);
-    points.forEach((p) => p.rotate(center, angle));
-    const rectangle = Box2.fromByPoints(...points).points;
-    rectangle.forEach((p) => p.rotate(center, -angle));
-    return new Polygon(rectangle);
-  }
-  /** 构建平面
-   */
-  buildPlane() {
-    const texture = new THREE.TextureLoader().load(planeSrc);
-    texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
-    texture.repeat.set(10, 10);
-    const plane = new THREE.Mesh(new THREE.BoxGeometry(50, 50, 1e-3), new THREE.MeshBasicMaterial({
-      color: 13421772,
-      map: texture
-    }));
-    plane.position.z = this.z;
-    this.scene.add(plane);
-  }
   wallGroup = null;
   /** 构建墙壁
    */
@@ -16610,37 +15822,13 @@ class SceneAutoGenerat {
     this.wallGroup = await globalScenario.drawGraphics(this.lines, this.z, this.trajectory);
     this.scene.add(this.wallGroup);
   }
-  /** 吸附
-   * @param walls 
-   * @param group 
-   * @param proximityThreshold 
-   */
-  adsorption(octree, rectangle, height, proximityThreshold = 0.05) {
-    const shape = new THREE.Shape();
-    rectangle.forEach((p, i) => {
-      if (i === 0) shape.moveTo(p.x, p.y);
-      else shape.lineTo(p.x, p.y);
-      if (i === rectangle.length - 1) shape.lineTo(rectangle[0].x, rectangle[0].y);
-    });
-    const geometry = new THREE.ExtrudeGeometry(shape, {
-      depth: height,
-      bevelEnabled: false
-    });
-    const material = new THREE.MeshBasicMaterial({ color: THREE.MathUtils.randInt(0, 16777215), opacity: 1, transparent: true });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.position.z = this.z;
-    this.scene.add(mesh);
-  }
   /** 获取模型
    * @param item 
    * @param walls 
    */
-  async getModel(item, octree) {
+  async getModel(item) {
     let model = await LoadModel.loadGlb(item.category);
     if (!model) return;
-    const contour = Point.fromByList(item.contour), rectangle = new Polygon(Qa(contour.map((p) => [p.x, p.y])).map((p) => Point.from(p)));
-    rectangle.pop();
-    const max = rectangle.getMaxLengthInfo(), min = rectangle.getMinLengthInfo(), center = rectangle.getCenter(), direction = max.start.y < max.end.y ? max.start.direction(max.end) : max.end.direction(max.start), height = Math.abs(item.box.max.z - this.z);
     model = model.clone(true);
     model.rotateX(Math.PI * 0.5);
     model.traverse((mesh) => {
@@ -16650,388 +15838,759 @@ class SceneAutoGenerat {
         material.vertexColors = false;
         material.color = new THREE.Color(16777215);
       }
-    });
-    const group2 = new THREE.Group();
-    group2.position.set(center.x, center.y, this.z);
-    group2.add(model);
-    this.scene.add(group2);
-    const box3 = new THREE.Box3();
-    box3.setFromObject(group2);
-    const size = box3.getSize(new THREE.Vector3()), maxKey = size.x > size.y ? "x" : "y", mimKey = size.x < size.y ? "x" : "y", maxS = max.length / size[maxKey], minS = min.length / size[mimKey], scale = height / size.z;
-    group2.scale[maxKey] *= maxS;
-    group2.scale[mimKey] *= minS;
-    group2.scale.z *= scale;
-    box3.setFromObject(group2);
-    box3.getSize(size);
-    const point1 = new Point(), point2 = new Point();
-    if (size.x > size.y) {
-      point1.set(box3.min.x, box3.min.y);
-      point2.set(box3.max.x, box3.min.y);
-    } else {
-      point1.set(box3.min.x, box3.min.y);
-      point2.set(box3.min.x, box3.max.y);
+    });
+    const contour = Point.fromByList(item.contour ?? []), rectangle = new Polygon(Qa(contour.map((p) => [p.x, p.y])).map((p) => Point.from(p)));
+    rectangle.pop();
+    const max = rectangle.getMaxLengthInfo(), min = rectangle.getMinLengthInfo(), center = rectangle.getCenter(), direction = max.start.y < max.end.y ? max.start.direction(max.end) : max.end.direction(max.start), height = Math.abs(item.box.max.z - this.z);
+    const group2 = new THREE.Group();
+    group2.position.set(center.x, center.y, this.z);
+    group2.add(model);
+    this.scene.add(group2);
+    const box32 = new THREE.Box3();
+    box32.setFromObject(group2);
+    const size = box32.getSize(new THREE.Vector3()), maxKey = size.x > size.y ? "x" : "y", mimKey = size.x < size.y ? "x" : "y", maxS = max.length / size[maxKey], minS = min.length / size[mimKey], scale = height / size.z;
+    group2.scale[maxKey] *= maxS;
+    group2.scale[mimKey] *= minS;
+    group2.scale.z *= scale;
+    box32.setFromObject(group2);
+    box32.getSize(size);
+    const point1 = new Point(), point2 = new Point();
+    if (size.x > size.y) {
+      point1.set(box32.min.x, box32.min.y);
+      point2.set(box32.max.x, box32.min.y);
+    } else {
+      point1.set(box32.min.x, box32.min.y);
+      point2.set(box32.min.x, box32.max.y);
+    }
+    const direction2 = point1.y < point2.y ? point1.direction(point2) : point2.direction(point1);
+    group2.rotateZ(direction2.angleBetween2(direction));
+    this.scene.add(
+      SceneAutoGenerat.itemParse(item, this.z).box
+    );
+  }
+  /** 构建物品模型
+   */
+  async buildItem() {
+    await Promise.all(this.itemList.map(async (item) => await this.getModel(item)));
+  }
+  static itemParse(item, z) {
+    const contour = Point.fromByList(item.contour), rectangle = new Polygon(Qa(contour.map((p) => [p.x, p.y])).map((p) => Point.from(p)));
+    rectangle.pop();
+    const height = Math.abs(item.box.max.z - z), max = rectangle.getMaxLengthInfo(), direction = max.start.y < max.end.y ? max.start.direction(max.end) : max.end.direction(max.start), shape = new THREE.Shape();
+    rectangle.forEach((p, i) => {
+      if (i === 0) shape.moveTo(p.x, p.y);
+      else shape.lineTo(p.x, p.y);
+      if (i === rectangle.length - 1) shape.lineTo(rectangle[0].x, rectangle[0].y);
+    });
+    const geometry = new THREE.ExtrudeGeometry(shape, {
+      depth: height,
+      bevelEnabled: false
+    }), edges = new THREE.EdgesGeometry(geometry), lineSegments = new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 16776960 }));
+    lineSegments.position.z = z;
+    box3.setFromObject(lineSegments);
+    const center = box3.getCenter(new THREE.Vector3());
+    return {
+      box: lineSegments,
+      center,
+      category: item.category,
+      angle: direction.angleBetween(new Point(0, 1), "angle", "360") * (Math.PI / 180) + Math.PI * 0.5
+    };
+  }
+}
+const exporter = new OBJExporter();
+let glbExporter;
+function lineSqueezing(p1, p2, width = 0.1) {
+  const normal = p2.normal(p1);
+  const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
+  const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
+  const offsetX = normal.x * width * 0.5;
+  const offsetY = normal.y * width * 0.5;
+  return {
+    points: [
+      // 第一条线
+      new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
+      new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
+      // 第二条线
+      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
+      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
+    ],
+    indices: [0, 1, 1, 3, 3, 2, 2, 0],
+    rectIndices: [0, 1, 3, 2, 0]
+  };
+}
+class WhiteModel extends Component {
+  static name = "WhiteModel";
+  Dxf = null;
+  Variable = null;
+  // dxf数据白模
+  whiteModelGroup = new THREE.Group();
+  // dxf数据白模边缘线
+  whiteModelLineGroup = new THREE.Group();
+  // 原始数据白模
+  originalWhiteMode = new THREE.Group();
+  material = new THREE.MeshStandardMaterial({ color: 16777215, transparent: true, opacity: 0.8, side: THREE.DoubleSide });
+  itemList = [];
+  promise;
+  /** 设置物品列表
+   * @param itemList 
+   */
+  setItemList(itemList) {
+    if (Array.isArray(itemList)) this.itemList = itemList;
+    else if ("itemInfo" in itemList) this.itemList = itemList.itemInfo;
+  }
+  onAddFromParent(parent) {
+    this.Dxf = parent.findComponentByName("Dxf");
+    this.Variable = parent.findComponentByName("Variable");
+    this.originalWhiteMode.visible = false;
+    this.Dxf?.addEventListener("lineOffset", () => {
+      this.promise = this.updateModel();
+    });
+  }
+  async updateModel() {
+    const dxfSystem = this.parent;
+    this.Variable?.set("whiteModelVisible", false);
+    const dxf = this.Dxf;
+    this.originalWhiteMode.clear();
+    this.whiteModelGroup.clear();
+    this.whiteModelLineGroup.clear();
+    this.whiteModelGroup.add(this.whiteModelLineGroup);
+    this.whiteModelGroup.position.z = dxf.originalZAverage;
+    this.originalWhiteMode.position.z = dxf.originalZAverage;
+    const lines = dxfSystem.Dxf.getLineSegments(true);
+    const sceneAutoGenerat = new SceneAutoGenerat(lines, this.itemList, dxfSystem.Dxf.originalZAverage, dxfSystem.CorrectionDxf.trajectory);
+    await sceneAutoGenerat.init();
+    const group2 = sceneAutoGenerat.scene;
+    if (group2) {
+      this.whiteModelLineGroup.add(group2.clone(true));
+    }
+    const walls = dxf.originalData.map(({ start, end, insetionArr }) => {
+      const startVec3 = new Point(start.x, start.y).mutiplyScalar(dxf.scale), endVec3 = new Point(end.x, end.y).mutiplyScalar(dxf.scale), { points, indices, rectIndices } = lineSqueezing(startVec3, endVec3, dxf.width);
+      return {
+        points,
+        indices,
+        rectIndices,
+        insetions: (insetionArr ?? []).map((insetion) => insetion.index)
+      };
+    });
+    walls.forEach((wall) => {
+      const shape = new THREE.Shape();
+      wall.rectIndices.forEach((index2, i) => {
+        const p = wall.points[index2];
+        if (i === 0) shape.moveTo(p.x, p.y);
+        else shape.lineTo(p.x, p.y);
+      });
+      const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth: 2.8,
+        bevelSize: 0
+      });
+      if (geometry.attributes.position.array.filter((num) => Number.isNaN(num)).length) return;
+      const mesh = new THREE.Mesh(geometry);
+      this.originalWhiteMode?.add(mesh);
+    });
+    this.dispatchEvent({
+      type: "updateModel",
+      originalWhiteMode: this.originalWhiteMode,
+      whiteModelGroup: this.whiteModelGroup
+    });
+    return this.whiteModelLineGroup;
+  }
+  /**
+   * 转为obj
+   * @returns 
+   */
+  toOBJ() {
+    return new Promise(async (resolve) => {
+      await this.promise;
+      this.material.opacity = 1;
+      this.material.needsUpdate = true;
+      setTimeout(() => {
+        resolve(exporter.parse(this.whiteModelGroup));
+        this.material.opacity = 0.8;
+        this.material.transparent = true;
+      }, 20);
+    });
+  }
+  /**
+   * 转为 glb
+   * @param binary 
+   * @returns 
+   */
+  toGltf(binary = true) {
+    if (!glbExporter) glbExporter = new gltf.GLTFExporter();
+    return new Promise(async (resolve) => {
+      await this.promise;
+      this.material.opacity = 1;
+      this.material.needsUpdate = true;
+      setTimeout(async () => {
+        glbExporter.parse(this.whiteModelGroup.children, (gltf2) => {
+          resolve(gltf2);
+          this.material.opacity = 0.8;
+          this.material.transparent = true;
+        }, () => {
+          resolve(void 0);
+        }, {
+          binary
+        });
+      }, 20);
+    });
+  }
+  /**
+   * 转为 OBJBlob
+   * @returns 
+   */
+  async toOBJBlob() {
+    const buffer = await this.toOBJ();
+    if (buffer) {
+      return new Blob([buffer], { type: "application/octet-stream" });
+    }
+  }
+  /**
+   * 转为 GltfBlob
+   * @returns 
+   */
+  async toGltfBlob(binary = true) {
+    const buffer = await this.toGltf(binary);
+    if (buffer) {
+      if (binary) return new Blob([buffer], { type: "application/octet-stream" });
+      else return new Blob([JSON.stringify(buffer)], { type: "application/json" });
+    }
+  }
+  /**
+   * 下载 OBJ
+   * @param filename 
+   * @returns 
+   */
+  async downloadOBJ(filename) {
+    if (typeof window !== "undefined") {
+      const blob = await this.toOBJBlob();
+      if (!blob) return;
+      const a = document.createElement("a");
+      a.href = URL.createObjectURL(blob);
+      a.download = filename;
+      a.click();
+    } else if (typeof global !== "undefined") {
+      const buffer = await this.toOBJ();
+      if (buffer) {
+        const fs2 = await include("fs", false);
+        fs2.writeFileSync(filename, buffer);
+      }
+    }
+  }
+  /**
+   * 下载 Gltf
+   * @param filename 
+   * @returns 
+   */
+  async downloadGltf(filename, binary = true) {
+    if (typeof window !== "undefined") {
+      const blob = await this.toGltfBlob(binary);
+      if (!blob) return;
+      const a = document.createElement("a");
+      a.href = URL.createObjectURL(blob);
+      a.download = filename;
+      a.click();
+    } else if (typeof global !== "undefined") {
+      const buffer = await this.toGltf(binary);
+      if (buffer) {
+        const fs2 = await include("fs", false);
+        fs2.writeFileSync(filename, binary ? Buffer.from(buffer) : JSON.stringify(buffer));
+      }
     }
-    const direction2 = point1.y < point2.y ? point1.direction(point2) : point2.direction(point1);
-    group2.rotateZ(direction2.angleBetween2(direction));
-  }
-  /** 构建物品模型
-   */
-  async buildItem() {
-    const octree = new Octree();
-    octree.fromGraphNode(this.wallGroup);
-    await Promise.all(this.itemList.map(async (item) => await this.getModel(item, octree)));
   }
 }
-const exporter = new OBJExporter();
-let glbExporter;
-function lineSqueezing(p1, p2, width = 0.1) {
-  const normal = p2.normal(p1);
-  const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
-  const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
-  const offsetX = normal.x * width * 0.5;
-  const offsetY = normal.y * width * 0.5;
-  return {
-    points: [
-      // 第一条线
-      new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
-      new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
-      // 第二条线
-      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
-      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
-    ],
-    indices: [0, 1, 1, 3, 3, 2, 2, 0],
-    rectIndices: [0, 1, 3, 2, 0]
-  };
-}
-class WhiteModel extends Component {
-  static name = "WhiteModel";
+class DetailsPoint extends Component {
+  static name = "DetailsPoint";
   Dxf = null;
+  WhiteModel = null;
   Variable = null;
-  // dxf数据白模
-  whiteModelGroup = new THREE.Group();
-  // dxf数据白模边缘线
-  whiteModelLineGroup = new THREE.Group();
-  // 原始数据白模
-  originalWhiteMode = new THREE.Group();
-  material = new THREE.MeshStandardMaterial({ color: 16777215, transparent: true, opacity: 0.8, side: THREE.DoubleSide });
-  itemList = [];
-  promise;
-  /** 设置物品列表
-   * @param itemList 
-   */
-  setItemList(itemList) {
-    if (Array.isArray(itemList)) this.itemList = itemList;
-    else if ("itemInfo" in itemList) this.itemList = itemList.itemInfo;
-  }
+  desPoints = [];
+  raylines = [];
+  data = [];
   onAddFromParent(parent) {
     this.Dxf = parent.findComponentByName("Dxf");
     this.Variable = parent.findComponentByName("Variable");
-    this.originalWhiteMode.visible = false;
-    this.Dxf?.addEventListener("lineOffset", () => {
-      this.promise = this.updateModel();
+    this.Dxf?.addEventListener("setDta", () => {
+      this.updateModel();
     });
   }
-  async updateModel() {
-    const dxfSystem = this.parent;
-    this.Variable?.set("whiteModelVisible", false);
-    const dxf = this.Dxf;
-    this.originalWhiteMode.clear();
-    this.whiteModelGroup.clear();
-    this.whiteModelLineGroup.clear();
-    this.whiteModelGroup.add(this.whiteModelLineGroup);
-    this.whiteModelGroup.position.z = dxf.originalZAverage;
-    this.originalWhiteMode.position.z = dxf.originalZAverage;
-    const lines = dxfSystem.Dxf.getLineSegments(true);
-    const sceneAutoGenerat = new SceneAutoGenerat(lines, this.itemList, dxfSystem.Dxf.originalZAverage, dxfSystem.CorrectionDxf.trajectory);
-    await sceneAutoGenerat.init();
-    const group2 = sceneAutoGenerat.scene;
-    if (group2) {
-      this.whiteModelLineGroup.add(group2.clone(true));
+  /**
+   * 设置值
+   * @param data 
+   */
+  async set(data) {
+    if (typeof data === "string") {
+      if (typeof global !== "undefined") {
+        const packageName = "fs";
+        const { default: fs2 } = await import(
+          /* @vite-ignore */
+          packageName
+        );
+        const buffer = fs2.readFileSync(data);
+        const json = JSON.parse(buffer.toString("utf-8"));
+        this.set(json);
+        return;
+      } else {
+        throw new Error("非node环境不允许使用路径");
+      }
     }
-    const walls = dxf.originalData.map(({ start, end, insetionArr }) => {
-      const startVec3 = new Point(start.x, start.y).mutiplyScalar(dxf.scale), endVec3 = new Point(end.x, end.y).mutiplyScalar(dxf.scale), { points, indices, rectIndices } = lineSqueezing(startVec3, endVec3, dxf.width);
-      return {
-        points,
-        indices,
-        rectIndices,
-        insetions: (insetionArr ?? []).map((insetion) => insetion.index)
-      };
-    });
-    walls.forEach((wall) => {
-      const shape = new THREE.Shape();
-      wall.rectIndices.forEach((index2, i) => {
-        const p = wall.points[index2];
-        if (i === 0) shape.moveTo(p.x, p.y);
-        else shape.lineTo(p.x, p.y);
+    this.data = data;
+    this.updateModel();
+  }
+  /**
+   * 设置射线辅助
+   */
+  racasterHelper(position, direction, far) {
+    this.raylines.push([
+      position.clone(),
+      position.clone().add(direction.clone().multiplyScalar(far))
+    ]);
+    direction.z = 0;
+    this.raylines.push([
+      position.clone(),
+      position.clone().add(direction.clone().multiplyScalar(far))
+    ]);
+  }
+  _timer = null;
+  /**
+   * 更新模型
+   */
+  updateModel() {
+    if (this._timer) clearTimeout(this._timer);
+    this._timer = setTimeout(() => {
+      this._timer = null;
+      const whiteModel = this.parent?.findComponentByName("WhiteModel");
+      this.raylines.length = 0;
+      this.desPoints.length = 0;
+      this.data.forEach((item) => {
+        const position = new THREE.Vector3(
+          item.position.x,
+          item.position.y,
+          item.position.z
+        );
+        const direction = new THREE.Vector3(
+          item.direction.x,
+          item.direction.y,
+          item.direction.z
+        );
+        const far = 100;
+        this.racasterHelper(position, direction, far);
+        direction.z = 0;
+        const raycaster = new THREE.Raycaster(position, direction, 0, far);
+        const list = raycaster.intersectObject(whiteModel.originalWhiteMode);
+        if (list.length) {
+          const { point } = list[0];
+          this.desPoints.push({
+            message: item.desc,
+            position,
+            intersection: point
+          });
+        }
       });
-      const geometry = new THREE.ExtrudeGeometry(shape, {
-        depth: 2.8,
-        bevelSize: 0
+      this.dispatchEvent({
+        type: "handleSuccess",
+        desPoints: this.desPoints
+      });
+    }, 50);
+  }
+}
+class DxfLineModel extends Component {
+  static name = "DxfLineModel";
+  dxfLineModel = new THREE.LineSegments();
+  dxfDoorsLineModel = new THREE.LineSegments();
+  dxfModelGroup = new THREE.Group();
+  onAddFromParent(parent) {
+    const dxf = parent.findComponentByName("Dxf");
+    this.dxfModelGroup.add(this.dxfLineModel);
+    this.dxfModelGroup.add(this.dxfDoorsLineModel);
+    this.dxfDoorsLineModel.material = new THREE.LineBasicMaterial({ color: 16776960, vertexColors: true });
+    dxf?.addEventListener("lineOffset", () => this.updateMode());
+  }
+  updateMode() {
+    const dxf = this.parent?.findComponentByName("Dxf");
+    this.dxfLineModel.clear();
+    const dxfArray = dxf.to3DArray(1 / dxf.scale, 0);
+    this.dxfLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(dxfArray, 3, true));
+    const doorsArray = new Float32Array(
+      dxf.doorLineSegment.flatMap(({ start, end }) => [start.x, start.y, 0, end.x, end.y, 0])
+    ).map((n) => n / dxf.scale);
+    const doorsColorArray = new Float32Array(dxf.doorLineSegment.flatMap(() => [1, 0, 0, 0, 1, 0]));
+    this.dxfDoorsLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(doorsArray, 3, true)).setAttribute("color", new THREE.BufferAttribute(doorsColorArray, 3));
+    this.dxfModelGroup.position.z = dxf.originalZAverage;
+    this.dispatchEvent({
+      type: "modelUpdate",
+      model: this.dxfModelGroup
+    });
+  }
+}
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DetailsPoint,
+  DxfLineModel,
+  WhiteModel
+}, Symbol.toStringTag, { value: "Module" }));
+function ModelDataPlugin_(dxfSystem, option = {}) {
+  const {
+    detailsPoint = true,
+    whiteModel = true,
+    dxfLineModel = true
+  } = option;
+  dxfLineModel && dxfSystem.addComponent(new DxfLineModel());
+  whiteModel && dxfSystem.addComponent(new WhiteModel());
+  detailsPoint && dxfSystem.addComponent(new DetailsPoint());
+}
+const ModelDataPlugin = Object.assign(ModelDataPlugin_, {
+  create(option = {}) {
+    return (dxfSystem) => ModelDataPlugin_(dxfSystem, option);
+  }
+});
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ModelDataPlugin,
+  components: index$2
+}, Symbol.toStringTag, { value: "Module" }));
+class Lines extends THREE.LineSegments {
+  geometry = new THREE.BufferGeometry();
+  points = [];
+  pointsObject3D;
+  constructor(points = [], color = 16777215) {
+    super();
+    this.geometry = this.geometry;
+    this.addPoint(...points);
+    this.frustumCulled = false;
+    this.pointsObject3D = new THREE.Points(this.geometry, new THREE.PointsMaterial({
+      sizeAttenuation: false,
+      size: 10
+    }));
+    this.material = new THREE.LineBasicMaterial({ color });
+  }
+  addPoint(...points) {
+    this.points.push(...points);
+    this.updateGeometry();
+  }
+  setPoint(...points) {
+    this.points.length = 0;
+    this.addPoint(...points);
+  }
+  _timer = null;
+  updateGeometry() {
+    if (this._timer) clearTimeout(this._timer);
+    this._timer = setTimeout(() => {
+      const array = this.points.flatMap((p, i) => {
+        if (i === 0) return [];
+        else {
+          const p0 = this.points[i - 1];
+          return [p0.x, p0.y, p0.z, p.x, p.y, p.z];
+        }
       });
-      if (geometry.attributes.position.array.filter((num) => Number.isNaN(num)).length) return;
-      const mesh = new THREE.Mesh(geometry);
-      this.originalWhiteMode?.add(mesh);
-    });
-    this.dispatchEvent({
-      type: "updateModel",
-      originalWhiteMode: this.originalWhiteMode,
-      whiteModelGroup: this.whiteModelGroup
+      const position = new THREE.BufferAttribute(new Float32Array(array), 3);
+      this.geometry.setAttribute("position", position);
+      this._timer = null;
     });
-    return this.whiteModelLineGroup;
   }
-  /**
-   * 转为obj
-   * @returns 
-   */
-  toOBJ() {
+}
+function selectLocalFileFun() {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = "application/json";
+    input.click();
+    input.onchange = () => {
+      if (input.files?.length) resolve(input.files[0]);
+      else resolve(null);
+    };
+  });
+}
+const SelectLocalFile = Object.assign(selectLocalFileFun, {
+  arrayBuffer() {
     return new Promise(async (resolve) => {
-      await this.promise;
-      this.material.opacity = 1;
-      this.material.needsUpdate = true;
-      setTimeout(() => {
-        resolve(exporter.parse(this.whiteModelGroup));
-        this.material.opacity = 0.8;
-        this.material.transparent = true;
-      }, 20);
+      const file = await selectLocalFileFun();
+      if (file instanceof File) {
+        const fileReader = new FileReader();
+        fileReader.onload = () => {
+          resolve(fileReader.result);
+        };
+        fileReader.readAsArrayBuffer(file);
+      } else resolve(null);
     });
-  }
-  /**
-   * 转为 glb
-   * @param binary 
-   * @returns 
-   */
-  toGltf(binary = true) {
-    if (!glbExporter) glbExporter = new gltf.GLTFExporter();
+  },
+  text() {
     return new Promise(async (resolve) => {
-      await this.promise;
-      this.material.opacity = 1;
-      this.material.needsUpdate = true;
-      setTimeout(async () => {
-        glbExporter.parse(this.whiteModelGroup.children, (gltf2) => {
-          resolve(gltf2);
-          this.material.opacity = 0.8;
-          this.material.transparent = true;
-        }, () => {
-          resolve(void 0);
-        }, {
-          binary
-        });
-      }, 20);
+      const file = await selectLocalFileFun();
+      if (file instanceof File) {
+        const fileReader = new FileReader();
+        fileReader.onload = () => {
+          resolve(fileReader.result);
+        };
+        fileReader.readAsText(file, "utf-8");
+      } else resolve(null);
     });
+  },
+  async json() {
+    const text = await this.text();
+    if (text) return JSON.parse(text);
+  }
+});
+class CommandFlow extends EventDispatcher {
+  list = [];
+  rollbacklist = [];
+  revokeRollbacklist = [];
+  // 是否写入操作记录
+  writeOperationList = true;
+  loop = false;
+  setLoop(loop) {
+    this.loop = loop;
+    return this;
   }
   /**
-   * 转为 OBJBlob
+   * 
+   * @param operation 
    * @returns 
    */
-  async toOBJBlob() {
-    const buffer = await this.toOBJ();
-    if (buffer) {
-      return new Blob([buffer], { type: "application/octet-stream" });
-    }
+  add(operation) {
+    this.list.push(operation);
+    return this;
   }
-  /**
-   * 转为 GltfBlob
+  /** 添加回滚回调列表
+   * @param callBack 
+   */
+  addRollback(callBack) {
+    this.rollbacklist.push(callBack);
+    return this;
+  }
+  /** 添加撤回回滚回调列表
+   * @param callBack 
    * @returns 
    */
-  async toGltfBlob(binary = true) {
-    const buffer = await this.toGltf(binary);
-    if (buffer) {
-      if (binary) return new Blob([buffer], { type: "application/octet-stream" });
-      else return new Blob([JSON.stringify(buffer)], { type: "application/json" });
-    }
+  addRevokeRollback(callBack) {
+    this.revokeRollbacklist.push(callBack);
+    return this;
+  }
+}
+class CommandManager extends EventDispatcher {
+  commandFlowMap = /* @__PURE__ */ new Map();
+  lock = false;
+  abortController = null;
+  resolve = null;
+  currentName = null;
+  _disabled = false;
+  set disabled(disabled) {
+    this._disabled = disabled;
+    if (this._disabled) this.cancel();
+  }
+  get disabled() {
+    return this._disabled;
   }
   /**
-   * 下载 OBJ
-   * @param filename 
+   * 操作记录
+   */
+  operationList = [];
+  rollbackList = [];
+  constructor() {
+    super();
+  }
+  /** 添加命令流
+   * @param name 
    * @returns 
    */
-  async downloadOBJ(filename) {
-    if (typeof window !== "undefined") {
-      const blob = await this.toOBJBlob();
-      if (!blob) return;
-      const a = document.createElement("a");
-      a.href = URL.createObjectURL(blob);
-      a.download = filename;
-      a.click();
-    } else if (typeof global !== "undefined") {
-      const buffer = await this.toOBJ();
-      if (buffer) {
-        const fs2 = await include("fs", false);
-        fs2.writeFileSync(filename, buffer);
-      }
-    }
+  addCommandFlow(name) {
+    if (this.commandFlowMap.has(name)) throw new Error(`${name} 命令已经存在`);
+    const commandFlow = new CommandFlow();
+    this.commandFlowMap.set(name, commandFlow);
+    return commandFlow;
   }
-  /**
-   * 下载 Gltf
-   * @param filename 
+  executionPromise = null;
+  executionResolve = null;
+  /** 执行控制流
+   * @param name 
    * @returns 
    */
-  async downloadGltf(filename, binary = true) {
-    if (typeof window !== "undefined") {
-      const blob = await this.toGltfBlob(binary);
-      if (!blob) return;
-      const a = document.createElement("a");
-      a.href = URL.createObjectURL(blob);
-      a.download = filename;
-      a.click();
-    } else if (typeof global !== "undefined") {
-      const buffer = await this.toGltf(binary);
-      if (buffer) {
-        const fs2 = await include("fs", false);
-        fs2.writeFileSync(filename, binary ? Buffer.from(buffer) : JSON.stringify(buffer));
+  async start(name, data = null, step = 0) {
+    if (this.disabled) throw new Error("命令管理器已禁用，无法启动新的命令流");
+    this.dispatchEvent({
+      type: "startedBefore",
+      name,
+      currentName: this.currentName
+    });
+    this.executionPromise && await this.executionPromise;
+    this.executionPromise = null;
+    if (this.lock) {
+      throw new Error("命令管理器已被 " + this.currentName + " 命令锁定，无法启动新的命令流，请退出或等待命令执行结束");
+    }
+    const commandFlow = this.commandFlowMap.get(name);
+    if (!commandFlow) {
+      throw new Error(`命令流 ${name} 不存在`);
+    }
+    this.lock = true;
+    this.abortController = new AbortController();
+    this.currentName = name;
+    commandFlow.dispatchEvent({ type: "started" });
+    this.dispatchEvent({ type: "started", name });
+    try {
+      for (let i = step; i < commandFlow.list.length; i++) {
+        const operation = commandFlow.list[i];
+        commandFlow.dispatchEvent({ type: "executing", index: i });
+        this.dispatchEvent({ type: "executing", name, index: i });
+        data = await new Promise((resolve) => {
+          this.resolve = resolve;
+          operation(resolve, data);
+        });
+        if (this.abortController.signal.aborted) {
+          commandFlow.dispatchEvent({ type: "executionInterrupt", index: i });
+          this.dispatchEvent({ type: "executionInterrupt", name, index: i });
+          this.dispatchEvent({ type: "cancel", name });
+          break;
+        } else {
+          commandFlow.dispatchEvent({ type: "executionCompleted", index: i, data });
+          this.dispatchEvent({ type: "executionCompleted", name, index: i, data });
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      this.lock = false;
+      this.currentName = null;
+      if (this.abortController && !this.abortController.signal.aborted) {
+        commandFlow.dispatchEvent({ type: "completed", data });
+        this.dispatchEvent({ type: "completed", name, data });
+        if (commandFlow.writeOperationList) {
+          this.operationList.push({ name, data });
+          this.rollbackList.length = 0;
+        }
+        if (commandFlow.loop) queueMicrotask(() => this.start(name));
+      }
+      this.abortController = null;
+      commandFlow.dispatchEvent({ type: "finally" });
+      this.dispatchEvent({ type: "finally", name });
+      if (this.executionResolve) {
+        this.executionResolve(null);
+        this.executionResolve = null;
       }
     }
+    return data;
   }
-}
-class DetailsPoint extends Component {
-  static name = "DetailsPoint";
-  Dxf = null;
-  WhiteModel = null;
-  Variable = null;
-  desPoints = [];
-  raylines = [];
-  data = [];
-  onAddFromParent(parent) {
-    this.Dxf = parent.findComponentByName("Dxf");
-    this.Variable = parent.findComponentByName("Variable");
-    this.Dxf?.addEventListener("setDta", () => {
-      this.updateModel();
-    });
-  }
-  /**
-   * 设置值
-   * @param data 
+  /** 取消当前命令
    */
-  async set(data) {
-    if (typeof data === "string") {
-      if (typeof global !== "undefined") {
-        const packageName = "fs";
-        const { default: fs2 } = await import(
-          /* @vite-ignore */
-          packageName
-        );
-        const buffer = fs2.readFileSync(data);
-        const json = JSON.parse(buffer.toString("utf-8"));
-        this.set(json);
-        return;
-      } else {
-        throw new Error("非node环境不允许使用路径");
-      }
+  cancel() {
+    if (this.abortController) {
+      this.abortController.abort();
+      if (this.resolve) this.resolve();
+      this.executionPromise = new Promise((resolve) => this.executionResolve = resolve);
     }
-    this.data = data;
-    this.updateModel();
   }
   /**
-   * 设置射线辅助
+   * 回滚
    */
-  racasterHelper(position, direction, far) {
-    this.raylines.push([
-      position.clone(),
-      position.clone().add(direction.clone().multiplyScalar(far))
-    ]);
-    direction.z = 0;
-    this.raylines.push([
-      position.clone(),
-      position.clone().add(direction.clone().multiplyScalar(far))
-    ]);
+  rollback() {
+    try {
+      const operation = this.operationList.pop();
+      if (!operation) return false;
+      const commandFlow = this.commandFlowMap.get(operation.name);
+      if (!commandFlow) return false;
+      const data = commandFlow.rollbacklist.reduce((data2, callBack) => callBack(data2), operation.data);
+      this.dispatchEvent({ type: "rollback", name: operation.name });
+      this.rollbackList.push({
+        data,
+        name: operation.name
+      });
+      return true;
+    } catch (error) {
+      throw new Error(`回滚失败：${error}`);
+    }
   }
-  _timer = null;
   /**
-   * 更新模型
+   * 撤销回滚
    */
-  updateModel() {
-    if (this._timer) clearTimeout(this._timer);
-    this._timer = setTimeout(() => {
-      this._timer = null;
-      const whiteModel = this.parent?.findComponentByName("WhiteModel");
-      this.raylines.length = 0;
-      this.desPoints.length = 0;
-      this.data.forEach((item) => {
-        const position = new THREE.Vector3(
-          item.position.x,
-          item.position.y,
-          item.position.z
-        );
-        const direction = new THREE.Vector3(
-          item.direction.x,
-          item.direction.y,
-          item.direction.z
-        );
-        const far = 100;
-        this.racasterHelper(position, direction, far);
-        direction.z = 0;
-        const raycaster = new THREE.Raycaster(position, direction, 0, far);
-        const list = raycaster.intersectObject(whiteModel.originalWhiteMode);
-        if (list.length) {
-          const { point } = list[0];
-          this.desPoints.push({
-            message: item.desc,
-            position,
-            intersection: point
-          });
-        }
-      });
-      this.dispatchEvent({
-        type: "handleSuccess",
-        desPoints: this.desPoints
-      });
-    }, 50);
-  }
-}
-class DxfLineModel extends Component {
-  static name = "DxfLineModel";
-  dxfLineModel = new THREE.LineSegments();
-  dxfDoorsLineModel = new THREE.LineSegments();
-  dxfModelGroup = new THREE.Group();
-  onAddFromParent(parent) {
-    const dxf = parent.findComponentByName("Dxf");
-    this.dxfModelGroup.add(this.dxfLineModel);
-    this.dxfModelGroup.add(this.dxfDoorsLineModel);
-    this.dxfDoorsLineModel.material = new THREE.LineBasicMaterial({ color: 16776960, vertexColors: true });
-    dxf?.addEventListener("lineOffset", () => this.updateMode());
+  revokeRollback() {
+    try {
+      const operation = this.rollbackList.pop();
+      if (!operation) return false;
+      const commandFlow = this.commandFlowMap.get(operation.name);
+      if (!commandFlow) return false;
+      const data = commandFlow.revokeRollbacklist.reduce((data2, callBack) => callBack(data2), operation.data);
+      this.dispatchEvent({ type: "revokeRollback", name: operation.name });
+      this.operationList.push({ name: operation.name, data });
+      return true;
+    } catch (error) {
+      throw new Error(`撤回回滚失败：${error}`);
+    }
   }
-  updateMode() {
-    const dxf = this.parent?.findComponentByName("Dxf");
-    this.dxfLineModel.clear();
-    const dxfArray = dxf.to3DArray(1 / dxf.scale, 0);
-    this.dxfLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(dxfArray, 3, true));
-    const doorsArray = new Float32Array(
-      dxf.doorLineSegment.flatMap(({ start, end }) => [start.x, start.y, 0, end.x, end.y, 0])
-    ).map((n) => n / dxf.scale);
-    const doorsColorArray = new Float32Array(dxf.doorLineSegment.flatMap(() => [1, 0, 0, 0, 1, 0]));
-    this.dxfDoorsLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(doorsArray, 3, true)).setAttribute("color", new THREE.BufferAttribute(doorsColorArray, 3));
-    this.dxfModelGroup.position.z = dxf.originalZAverage;
-    this.dispatchEvent({
-      type: "modelUpdate",
-      model: this.dxfModelGroup
-    });
+  destroy() {
+    this.cancel();
+    this.addEventListener("cancel", () => {
+      this.commandFlowMap.clear();
+      this.lock = false;
+      this.abortController = null;
+      this.resolve = null;
+      this.executionResolve = null;
+      this.executionPromise = null;
+      this.currentName = null;
+      this.operationList.length = 0;
+      this.rollbackList.length = 0;
+    }, { once: true });
   }
 }
-const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  DetailsPoint,
-  DxfLineModel,
-  WhiteModel
-}, Symbol.toStringTag, { value: "Module" }));
-function ModelDataPlugin_(dxfSystem, option = {}) {
-  const {
-    detailsPoint = true,
-    whiteModel = true,
-    dxfLineModel = true
-  } = option;
-  dxfLineModel && dxfSystem.addComponent(new DxfLineModel());
-  whiteModel && dxfSystem.addComponent(new WhiteModel());
-  detailsPoint && dxfSystem.addComponent(new DetailsPoint());
-}
-const ModelDataPlugin = Object.assign(ModelDataPlugin_, {
-  create(option = {}) {
-    return (dxfSystem) => ModelDataPlugin_(dxfSystem, option);
-  }
-});
 const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ModelDataPlugin,
-  components: index$1
+  ArrayMap,
+  AxisAlignCorr,
+  BoundExt,
+  Box2,
+  CommandFlow,
+  CommandManager,
+  Component,
+  ComponentManager,
+  CountMap,
+  DoubleWallHelper,
+  DxfSystem,
+  EventDispatcher,
+  GltfInit,
+  LineGroupType,
+  LineIndexGenerator,
+  LineSegment,
+  LineSegmentUndirectedGraph,
+  Lines,
+  MapEnhance,
+  Point,
+  PointVirtualGrid,
+  Polygon,
+  PvgList,
+  Quadtree,
+  Rectangle,
+  SceneAutoGenerat,
+  SelectLocalFile,
+  SetMap,
+  UndirectedGraph,
+  UnionFindSet,
+  buildBayWindowGroup,
+  buildDoubleWallGroup,
+  clippingDoubleWall,
+  clippingLineUserData,
+  cloneUserData,
+  closedPathArea,
+  components,
+  findCircleEdges,
+  findClosedPolygons,
+  findDiscretePoint,
+  findDiscretePointLine,
+  findDiscretePointLine2,
+  findLargestCircle,
+  findRingEdges,
+  findVerticalReference,
+  gltf,
+  lineDataToOriginalData,
+  lineDataToThreeVJiaJson,
+  lineSegmentClipping,
+  mergeLineUserData,
+  mergeSmallestCircle,
+  mergeWindow,
+  originalDataToLineData,
+  recomputedWindow,
+  recomputedWindowCenter,
+  ringsDeduplication: ringsDeduplication$1,
+  smallestCircle,
+  toOriginalDataItem,
+  tools,
+  uuid
 }, Symbol.toStringTag, { value: "Module" }));
 function loadRenderPlugin() {
   return import("./index2.js");
@@ -17074,7 +16633,7 @@ if (typeof globalThis !== "undefined") {
   globalThis.Log = Log;
 }
 async function createEditor(dom, camera, orbitControls = false, viewPermission) {
-  const mp = await Promise.resolve().then(() => index);
+  const mp = await Promise.resolve().then(() => index$1);
   const rp = await loadRenderPlugin();
   const editor = await loadEditorPlugin();
   const dxfSystem = new DxfSystem().usePlugin(mp.ModelDataPlugin.create({
@@ -17121,7 +16680,7 @@ async function getModels(originData, trajectory, itemList) {
   };
 }
 async function buildJson(opt) {
-  const mp = await Promise.resolve().then(() => index);
+  const mp = await Promise.resolve().then(() => index$1);
   const dxfSystem = new DxfSystem();
   let { json, trajectory, axisAlignCorrOption, download, itemInfo } = opt;
   dxfSystem.usePlugin(mp.ModelDataPlugin);
@@ -17224,8 +16783,8 @@ export {
   getFileAll as j,
   getGlobalDxfSystem as k,
   Dxf as l,
-  index as m,
-  index$2 as n,
+  index$1 as m,
+  index as n,
   components as o,
   recomputedWindow as r,
   uuid as u