build-dxf 0.0.9 → 0.0.11

package/src/build.js

@@ -0,0 +1,2023 @@
+import * as THREE from "three";
+import { EventDispatcher as EventDispatcher$1 } from "three";
+import ClipperLib from "clipper-lib";
+import Drawing from "dxf-writer";
+import { OBJExporter } from "three/examples/jsm/exporters/OBJExporter.js";
+function uuid() {
+  return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(c) {
+    var r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+class EventDispatcher extends EventDispatcher$1 {
+  uuid = uuid();
+}
+class Component extends EventDispatcher {
+  parent;
+  constructor(...arg) {
+    super();
+    this.addEventListener("addFromParent", (e) => {
+      this.parent = e.parent;
+      this.onAddFromParent(e.parent);
+    });
+    this.addEventListener("removeFromParent", (e) => {
+      this.parent = void 0;
+      this.onRemoveFromParent(e.parent);
+    });
+  }
+  onAddFromParent(parent) {
+  }
+  onRemoveFromParent(parent) {
+  }
+  destroy() {
+  }
+}
+class ComponentManager extends EventDispatcher {
+  static EventType = {
+    ADD_COMPONENT: "addComponent"
+  };
+  components = [];
+  /**
+   * 添加组件
+   * @param component 
+   */
+  addComponent(component) {
+    if (component) {
+      this.components.push(component);
+      this.dispatchEvent({
+        type: "addComponent",
+        component
+      });
+      component.dispatchEvent({
+        type: "addFromParent",
+        parent: this
+      });
+    }
+    return this;
+  }
+  /**
+   * 移除组件
+   * @param component 
+   */
+  removeComponent(component) {
+    if (component instanceof Component) {
+      const index2 = this.components.indexOf(component);
+      if (index2 > -1) {
+        this.components.splice(index2, 1);
+        this.dispatchEvent({
+          type: "removeComponent",
+          component
+        });
+        component.dispatchEvent({
+          type: "removeFromParent",
+          parent: this
+        });
+      }
+    }
+  }
+  /**
+   * 查找符合条件的第一个组件
+   * @param callBack 
+   */
+  findComponent(predicate) {
+    for (let i = 0; i < this.components.length; i++) {
+      const component = this.components[i];
+      if (predicate(component, i)) return component;
+    }
+  }
+  /**
+   * 查找所有符合条件的组件
+   * @param callBack 
+   */
+  findComponents(predicate) {
+    return this.components.find(predicate);
+  }
+  /**
+   * 
+   * @param type 
+   */
+  findComponentByType(type) {
+    const component = this.findComponent((c) => c instanceof type);
+    return component ? component : null;
+  }
+  /**
+   * 
+   * @param type 
+   */
+  findComponentByName(name) {
+    const component = this.findComponent((c) => c.constructor.name === name);
+    return component ? component : null;
+  }
+}
+class Point {
+  x;
+  y;
+  get X() {
+    return this.x;
+  }
+  get Y() {
+    return this.y;
+  }
+  /**
+   * 
+   * @param x 
+   * @param y 
+   */
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+  setX(x) {
+    this.x = x;
+    return this;
+  }
+  setY(y) {
+    this.y = y;
+    return this;
+  }
+  /**
+   * 
+   * @param point 
+   * @returns 
+   */
+  equal(point) {
+    return point.x === this.x && point.y === this.y;
+  }
+  /**
+   * 
+   * @param arr 
+   */
+  setByArray(arr) {
+    this.x = arr[0];
+    this.y = arr[1];
+    return this;
+  }
+  /**
+   * 
+   */
+  toArray() {
+    return [this.x, this.y];
+  }
+  /**
+   * multiplyScalar
+   * @param scalar 
+   */
+  mutiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
+  }
+  multiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
+  }
+  /**
+   * 
+   * @param scalar 
+   * @returns 
+   */
+  divisionScalar(scalar) {
+    this.x /= scalar;
+    this.y /= scalar;
+    return this;
+  }
+  /**
+   * 减法
+   * @description 将当前点的坐标减去指定点的坐标
+   * @param point
+   * @returns 
+   */
+  division(point) {
+    this.x -= point.x;
+    this.y -= point.y;
+    return this;
+  }
+  /**
+   * 加法
+   * @description 将当前点的坐标加上指定点的坐标
+   * @param point 
+   * @returns 
+   */
+  add(point) {
+    this.x += point.x;
+    this.y += point.y;
+    return this;
+  }
+  /**
+   * 保留小数位数
+   * @param count 
+   */
+  fixed(count) {
+    this.x = Number(this.x.toFixed(count));
+    this.y = Number(this.y.toFixed(count));
+    return this;
+  }
+  /**
+   * 归一化
+   * @description 将当前点的坐标归一化为单位向量
+   * @returns 
+   */
+  normalize() {
+    const length = Math.sqrt(this.x * this.x + this.y * this.y);
+    if (length === 0) return this;
+    this.x /= length;
+    this.y /= length;
+    return this;
+  }
+  /**
+   * 获取单位法向量
+   * @description 计算当前点到指定点的方向向量，并返回逆时针旋转90度后的单位法向量
+   * @param point 
+   * @returns 
+   */
+  normal(point) {
+    const dx = this.x - point.x;
+    const dy = this.y - point.y;
+    const length = Math.sqrt(dx * dx + dy * dy);
+    const nx = -dy / length;
+    const ny = dx / length;
+    return new Point(nx, ny);
+  }
+  /**
+   * 获取由传入的点到该点的单位方向向量
+   * @description 计算当前点到指定点的方向向量，并返回单位方向
+   * @param point 
+   * @returns 
+   */
+  direction(point) {
+    const dx = this.x - point.x;
+    const dy = this.y - point.y;
+    const length = Math.sqrt(dx * dx + dy * dy);
+    if (length === 0) return new Point(0, 0);
+    return new Point(dx / length, dy / length);
+  }
+  /**
+   * 计算模长
+   * @returns 
+   */
+  magnitude() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  /**
+   * 计算点点积
+   * @param point 
+   * @returns 
+   */
+  dot(point) {
+    return this.x * point.x + this.y * point.y;
+  }
+  /** 计算两个向量夹角
+   * @description 公式：a · b = |a| × |b| × cosθ
+   * @param point 
+   * @returns 
+   */
+  angleBetween(point) {
+    const dotProduct = this.dot(point);
+    const magnitude1 = this.magnitude();
+    const magnitude2 = point.magnitude();
+    if (magnitude1 === 0 || magnitude2 === 0) return 0;
+    const cosTheta = dotProduct / (magnitude1 * magnitude2);
+    const clampedCosTheta = Math.max(-1, Math.min(1, cosTheta));
+    return Math.acos(clampedCosTheta);
+  }
+  /** 获取向量长度
+   */
+  length() {
+    const magnitude = Math.sqrt(this.x * this.x + this.y * this.y);
+    if (Math.abs(magnitude - Math.round(magnitude)) < 1e-9) {
+      return Math.round(magnitude);
+    }
+    return magnitude;
+  }
+  /**
+   * 获取两个点长度
+   * @param point 
+   */
+  distance(point) {
+    return Math.sqrt(
+      (this.x - point.x) * (this.x - point.x) + (this.y - point.y) * (this.y - point.y)
+    );
+  }
+  /**
+   * 克隆
+   * @returns 
+   */
+  clone() {
+    return new Point(this.x, this.y);
+  }
+  static from(arr) {
+    if (Array.isArray(arr)) {
+      return new Point(arr[0], arr[1]);
+    } else if ("x" in arr && "y" in arr) {
+      return new Point(arr.x, arr.y);
+    } else if ("X" in arr && "Y" in arr) {
+      return new Point(arr.X, arr.Y);
+    }
+    return this.zero();
+  }
+  static zero() {
+    return new Point(0, 0);
+  }
+}
+class Box2 {
+  minX = 0;
+  maxX = 0;
+  minY = 0;
+  maxY = 0;
+  get points() {
+    return [
+      new Point(this.minX, this.minY),
+      new Point(this.maxX, this.minY),
+      new Point(this.maxX, this.maxY),
+      new Point(this.minX, this.maxY)
+    ];
+  }
+  get width() {
+    return this.maxX - this.minX;
+  }
+  get height() {
+    return this.maxY - this.minY;
+  }
+  get center() {
+    return new Point(
+      this.minX + (this.maxX - this.minX) * 0.5,
+      this.minY + (this.maxY - this.minY) * 0.5
+    );
+  }
+  constructor(minX = 0, maxX = 0, minY = 0, maxY = 0) {
+    this.minX = minX;
+    this.maxX = maxX;
+    this.minY = minY;
+    this.maxY = maxY;
+  }
+  /**
+   * 
+   * @param z 
+   * @returns 
+   */
+  getPaths3D(z = 0) {
+    const points = this.points, list = [];
+    points.forEach((p, i) => {
+      const nextP = points[(i + 1) % points.length];
+      list.push(p.x, p.y, z);
+      list.push(nextP.x, nextP.y, z);
+    });
+    return list;
+  }
+  /**
+   * 判断线段是与包围盒相交
+   * @description Liang-Barsky算法的变种
+   * @param line 
+   */
+  intersectLineSegment(line) {
+    const p1 = line.points[0];
+    const p2 = line.points[1];
+    const dx = p2.x - p1.x;
+    const dy = p2.y - p1.y;
+    if (dx === 0 && dy === 0) {
+      return this.minX <= p1.x && p1.x <= this.maxX && this.minY <= p1.y && p1.y <= this.maxY;
+    }
+    let tNear = Number.NEGATIVE_INFINITY;
+    let tFar = Number.POSITIVE_INFINITY;
+    if (dx !== 0) {
+      const tx1 = (this.minX - p1.x) / dx;
+      const tx2 = (this.maxX - p1.x) / dx;
+      tNear = Math.max(tNear, Math.min(tx1, tx2));
+      tFar = Math.min(tFar, Math.max(tx1, tx2));
+    } else if (p1.x < this.minX || p1.x > this.maxX) {
+      return false;
+    }
+    if (dy !== 0) {
+      const ty1 = (this.minY - p1.y) / dy;
+      const ty2 = (this.maxY - p1.y) / dy;
+      tNear = Math.max(tNear, Math.min(ty1, ty2));
+      tFar = Math.min(tFar, Math.max(ty1, ty2));
+    } else if (p1.y < this.minY || p1.y > this.maxY) {
+      return false;
+    }
+    return tNear <= tFar && tNear <= 1 && tFar >= 0;
+  }
+  /**
+   * 判断线段是在包围盒内
+   * @param line 
+   */
+  containsLineSegment(line) {
+    const [p1, p2] = line.points;
+    return this.minX <= p1.x && p1.x <= this.maxX && this.minY <= p1.y && p1.y <= this.maxY && this.minX <= p2.x && p2.x <= this.maxX && this.minY <= p2.y && p2.y <= this.maxY;
+  }
+  /**
+   * 判断矩形与包围盒相交
+   * @param rectangle 
+   */
+  intersectRectangle(rectangle) {
+    const isPointInBox = (p) => this.minX <= p.x && p.x <= this.maxX && this.minY <= p.y && p.y <= this.maxY;
+    const isPointInRect = (point) => {
+      let sign = 0;
+      for (let i = 0; i < 4; i++) {
+        const p1 = rectangle.points[i];
+        const p2 = rectangle.points[(i + 1) % 4];
+        const edge = { x: p2.x - p1.x, y: p2.y - p1.y };
+        const toPoint = { x: point.x - p1.x, y: point.y - p1.y };
+        const cross = edge.x * toPoint.y - edge.y * toPoint.x;
+        if (cross === 0) {
+          const t = edge.x !== 0 ? (point.x - p1.x) / edge.x : (point.y - p1.y) / edge.y;
+          if (t >= 0 && t <= 1) return true;
+        } else {
+          const currentSign = cross > 0 ? 1 : -1;
+          if (sign === 0) sign = currentSign;
+          if (sign !== currentSign) return false;
+        }
+      }
+      return true;
+    };
+    const doIntersect = (l1p1, l1p2, l2p1, l2p2) => {
+      const orientation = (p, q, r) => {
+        const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+        if (val === 0) return 0;
+        return val > 0 ? 1 : 2;
+      };
+      const onSegment = (p, q, r) => {
+        return Math.min(p.x, r.x) <= q.x && q.x <= Math.max(p.x, r.x) && Math.min(p.y, r.y) <= q.y && q.y <= Math.max(p.y, r.y);
+      };
+      const o1 = orientation(l1p1, l1p2, l2p1);
+      const o2 = orientation(l1p1, l1p2, l2p2);
+      const o3 = orientation(l2p1, l2p2, l1p1);
+      const o4 = orientation(l2p1, l2p2, l1p2);
+      if (o1 !== o2 && o3 !== o4) return true;
+      if (o1 === 0 && onSegment(l1p1, l2p1, l1p2)) return true;
+      if (o2 === 0 && onSegment(l1p1, l2p2, l1p2)) return true;
+      if (o3 === 0 && onSegment(l2p1, l1p1, l2p2)) return true;
+      if (o4 === 0 && onSegment(l2p1, l1p2, l2p2)) return true;
+      return false;
+    };
+    const boxPoints = this.points;
+    for (let i = 0; i < 4; i++) {
+      const bp1 = boxPoints[i];
+      const bp2 = boxPoints[(i + 1) % 4];
+      for (let j = 0; j < 4; j++) {
+        const rp1 = rectangle.points[j];
+        const rp2 = rectangle.points[(j + 1) % 4];
+        if (doIntersect(bp1, bp2, rp1, rp2)) return true;
+      }
+    }
+    for (let p of rectangle.points) {
+      if (isPointInBox(p)) return true;
+    }
+    for (let p of boxPoints) {
+      if (isPointInRect(p)) return true;
+    }
+    return false;
+  }
+  /**
+   * 判断矩形是在包围盒内
+   * @param rectangle 
+   */
+  containsRectangle(rectangle) {
+    return rectangle.points.every(
+      (p) => this.minX <= p.x && p.x <= this.maxX && this.minY <= p.y && p.y <= this.maxY
+    );
+  }
+  /**
+   * 判断包围盒与包围盒相交
+   * @param box 
+   */
+  intersectBox(box) {
+    return !(this.maxX < box.minX || this.minX > box.maxX || this.maxY < box.minY || this.minY > box.maxY);
+  }
+  /**
+   * 判断包围盒是在包围盒内
+   * @param box 
+   */
+  containsBox(box) {
+    return this.minX <= box.minX && box.maxX <= this.maxX && this.minY <= box.minY && box.maxY <= this.maxY;
+  }
+  /** 判断点是在包围盒内
+   * @param point 
+   */
+  containsPoint(point) {
+    return point.x >= this.minX && point.x <= this.maxX && point.y >= this.minY && point.y <= this.maxY;
+  }
+  /**
+   * 
+   * @param minX 
+   * @param minY 
+   * @param maxX 
+   * @param maxY 
+   * @returns 
+   */
+  set(minX, minY, maxX, maxY) {
+    this.minX = minX;
+    this.minY = minY;
+    this.maxX = maxX;
+    this.maxY = maxY;
+    return this;
+  }
+  /**
+   * 
+   * @param maxWidth 
+   * @param maxHeight 
+   * @param mode 
+   * @returns 
+   */
+  scaleSize(maxWidth, maxHeight, mode = "min") {
+    const scaleX = maxWidth / this.width;
+    const scaleY = maxHeight / this.height;
+    return Math[mode](scaleX, scaleY);
+  }
+  /**
+   * 
+   * @param scalar 
+   * @returns 
+   */
+  multiplyScalar(scalar) {
+    this.minX *= scalar;
+    this.minY *= scalar;
+    this.maxX *= scalar;
+    this.maxY *= scalar;
+    return this;
+  }
+  /**
+   * 
+   * @returns 
+   */
+  clone() {
+    return new Box2(this.minX, this.minY, this.maxX, this.maxY);
+  }
+  /**
+   * 
+   * @param points 
+   * @returns 
+   */
+  static fromByPoints(...points) {
+    const xList = [], yList = [];
+    points.forEach((p) => {
+      xList.push(p.x);
+      yList.push(p.y);
+    });
+    return new Box2(
+      Math.min(...xList),
+      Math.max(...xList),
+      Math.min(...yList),
+      Math.max(...yList)
+    );
+  }
+}
+class LineSegment {
+  points = [new Point(), new Point()];
+  userData;
+  get center() {
+    return new Point(
+      this.points[0].x + (this.points[1].x - this.points[0].x) * 0.5,
+      this.points[0].y + (this.points[1].y - this.points[0].y) * 0.5
+    );
+  }
+  get start() {
+    return this.points[0];
+  }
+  get end() {
+    return this.points[1];
+  }
+  constructor(p1 = new Point(), p2 = new Point()) {
+    this.points = [p1, p2];
+  }
+  /**
+   * 计算线段的长度
+   * @returns 线段的长度
+   */
+  getLength() {
+    return this.points[0].distance(this.points[1]);
+  }
+  /**
+   * 获取方向
+   * @returns 
+   */
+  direction() {
+    return this.points[1].direction(this.points[0]);
+  }
+  /**
+   * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
+   * @param line 要投影的线段
+   * @returns 投影并裁剪后的线段
+   */
+  projectLineSegment(line) {
+    if (line.points.length !== 2 || this.points.length !== 2) {
+      throw new Error("每条线段必须由两个点定义");
+    }
+    const [p1, p2] = line.points;
+    const [q1, q2] = this.points;
+    const dir = new Point(q2.x - q1.x, q2.y - q1.y);
+    if (dir.x === 0 && dir.y === 0) {
+      throw new Error("投影目标线段的两个点不能重合");
+    }
+    const projectPoint = (point) => {
+      const pq = new Point(point.x - q1.x, point.y - q1.y);
+      const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
+      const dotProduct = pq.x * dir.x + pq.y * dir.y;
+      const t = dotProduct / dirLengthSquared;
+      const projX = q1.x + t * dir.x;
+      const projY = q1.y + t * dir.y;
+      return new Point(projX, projY);
+    };
+    let projP1 = projectPoint(p1);
+    let projP2 = projectPoint(p2);
+    const getT = (point) => {
+      const pq = new Point(point.x - q1.x, point.y - q1.y);
+      const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
+      return (pq.x * dir.x + pq.y * dir.y) / dirLengthSquared;
+    };
+    let t1 = getT(projP1);
+    let t2 = getT(projP2);
+    const clampPoint = (t) => {
+      const clampedT = Math.max(0, Math.min(1, t));
+      const x = q1.x + clampedT * dir.x;
+      const y = q1.y + clampedT * dir.y;
+      return new Point(x, y);
+    };
+    if (t1 < 0 || t1 > 1) {
+      projP1 = clampPoint(t1);
+    }
+    if (t2 < 0 || t2 > 1) {
+      projP2 = clampPoint(t2);
+    }
+    if (projP1.x === projP2.x && projP1.y === projP2.y) {
+      return new LineSegment(projP1, projP1);
+    }
+    return new LineSegment(projP1, projP2);
+  }
+  clone() {
+    return new LineSegment(
+      this.points[0].clone(),
+      this.points[1].clone()
+    );
+  }
+}
+const units = {
+  Unitless: 1,
+  // 无单位，1米 = 1（无单位）
+  Inches: 39.37007874015748,
+  // 英寸，1米 = 39.37007874015748英寸
+  Feet: 3.280839895013123,
+  // 英尺，1米 = 3.280839895013123英尺
+  Miles: 6213711922373339e-19,
+  // 英里，1米 = 0.0006213711922373339英里
+  Millimeters: 1e3,
+  // 毫米，1米 = 1000毫米
+  Centimeters: 100,
+  // 厘米，1米 = 100厘米
+  Meters: 1,
+  // 米，1米 = 1米
+  Kilometers: 1e-3,
+  // 千米，1米 = 0.001千米
+  Microinches: 3937007874015748e-8,
+  // 微英寸，1米 = 39370078.74015748微英寸
+  Mils: 39370.07874015748,
+  // 密耳，1米 = 39370.07874015748密耳
+  Yards: 1.0936132983377078,
+  // 码，1米 = 1.0936132983377078码
+  Angstroms: 1e10,
+  // 埃，1米 = 10^10埃
+  Nanometers: 1e9,
+  // 纳米，1米 = 10^9纳米
+  Microns: 1e6,
+  // 微米，1米 = 10^6微米
+  Decimeters: 10,
+  // 分米，1米 = 10分米
+  Decameters: 0.1,
+  // 十米，1米 = 0.1十米
+  Hectometers: 0.01,
+  // 百米，1米 = 0.01百米
+  Gigameters: 1e-9,
+  // 吉米，1米 = 10^-9吉米
+  "Astronomical units": 6684587122268445e-27,
+  // 天文单位，1米 = 0.000000000006684587122268445天文单位
+  "Light years": 10570008340246154e-32,
+  // 光年，1米 ≈ 0.00000000000000010570008340246154光年
+  Parsecs: 3240779289666404e-32
+  // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
+};
+class Dxf extends Component {
+  static name = "Dxf";
+  width = 0.04;
+  scale = 1;
+  originalData = [];
+  data = [];
+  originalBox = new Box2(0, 0, 0, 0);
+  box = new Box2(0, 0, 0, 0);
+  pointsGroups = [];
+  wallsGroup = [];
+  doors = [];
+  lineSegments = [];
+  originalZAverage = 0;
+  static EndType = {
+    etOpenSquare: 0,
+    etOpenRound: 1,
+    etOpenButt: 2
+    // etClosedLine: 3,
+    // etClosedPolygon: 4
+  };
+  static JoinType = {
+    jtSquare: 0,
+    jtRound: 1,
+    jtMiter: 2
+  };
+  /** 原始数据组
+   */
+  get lines() {
+    return this.lineSegments;
+  }
+  /**初始化
+   * @param data 点云数据
+   * @param width 墙体宽度
+   * @param scale 缩放比例
+   */
+  constructor(width = 0.04, scale = 1) {
+    super();
+    this.width = width;
+    this.scale = scale;
+  }
+  /**
+   * 设置
+   * @param data 
+   * @param width 
+   * @param scale 
+   */
+  async set(data, width = this.width, scale = this.scale) {
+    if (typeof data === "string") {
+      if (typeof global !== "undefined") {
+        const packageName = "fs";
+        const { default: fs } = await import(
+          /* @vite-ignore */
+          packageName
+        );
+        const buffer = fs.readFileSync(data);
+        const json = JSON.parse(buffer.toString("utf-8"));
+        return this.set(json, width, scale);
+      } else {
+        throw new Error("非node环境不允许使用路径");
+      }
+    }
+    this.scale = scale;
+    this.width = width;
+    this.originalData = data;
+    const zList = [];
+    this.data = data.map(({ start, end, insetionArr, isDoor = false }, index2) => {
+      zList.push(start.z ?? 0, end.z ?? 0);
+      const lineSegment = new LineSegment(
+        Point.from(start).mutiplyScalar(scale),
+        Point.from(end).mutiplyScalar(scale)
+      );
+      lineSegment.userData = { isDoor };
+      this.lineSegments.push(lineSegment);
+      return [
+        lineSegment.points[0],
+        lineSegment.points[1],
+        (insetionArr ?? []).map((i) => i.index),
+        isDoor,
+        index2
+      ];
+    });
+    this.originalZAverage = zList.reduce((count, num) => count + num, 0) / zList.length;
+    this.computedOriginalSize(data, this.originalBox);
+    this.dispatchEvent({
+      type: "setDta",
+      originalData: this.originalData,
+      data: this.data
+    });
+    this.createGroups();
+    this.computedSize();
+    this.dispatchEvent({
+      type: "createGroup",
+      groups: this.pointsGroups
+    });
+  }
+  /** 创建分组
+   * @description 根据相交数组insetionArr, 把相交的线段，划分到一组内，方便后续路径查找合并使用
+   * @returns 
+   */
+  createGroups() {
+    const groups = [], visited = /* @__PURE__ */ new Set(), doorSet = /* @__PURE__ */ new Set(), doorVisitedRecord = /* @__PURE__ */ new Map();
+    const dfs = (index2, group, preIndex = -1) => {
+      const [start, end, insetionArr, isDoor] = this.data[index2];
+      visited.add(index2);
+      if (isDoor) {
+        if (!doorVisitedRecord.has(index2)) doorVisitedRecord.set(index2, []);
+        doorVisitedRecord.get(index2)?.push(preIndex);
+        return doorSet.add(this.data[index2]);
+      }
+      group.push([start, end]);
+      insetionArr.forEach((i) => {
+        if (!visited.has(i)) {
+          dfs(i, group, index2);
+        }
+      });
+    };
+    this.data.forEach((_, index2) => {
+      if (!visited.has(index2)) {
+        const group = [];
+        dfs(index2, group);
+        groups.push(group);
+      }
+    });
+    this.doors = [...doorSet];
+    this.pointsGroups = groups;
+    return groups;
+  }
+  /** 计算当前墙体数据的边界框
+   * @description 根据分组数据pointsGroups，计算包围盒， pointsGroups数据为缩放后数据。
+   * @description 可通过box属性查看计算结果。
+   * @returns 
+   */
+  computedSize() {
+    const xArr = this.pointsGroups.flatMap((points) => points.flatMap((p) => [p[0].x, p[1].x]));
+    const yArr = this.pointsGroups.flatMap((points) => points.flatMap((p) => [p[0].y, p[1].y]));
+    const minX = Math.min(...xArr);
+    const minY = Math.min(...yArr);
+    const maxX = Math.max(...xArr);
+    const maxY = Math.max(...yArr);
+    this.box.set(minX, minY, maxX, maxY);
+    return this.box;
+  }
+  /** 线路拓扑
+   * @description 处理线路拓扑，使线路有序链接，形成长路径
+   * @param lines 
+   */
+  lineTopology(lines) {
+    const visited = [];
+    function dfs(index2, linePath) {
+      const [_0, a2] = lines[index2];
+      visited[index2] = true;
+      linePath.push(a2);
+      for (let i = 0; i < lines.length; i++) {
+        const [b1, _1] = lines[i];
+        if (!visited[i]) {
+          if (Math.abs(a2.x - b1.x) < 1e-6 && Math.abs(a2.y - b1.y) < 1e-6) {
+            return dfs(i, linePath);
+          }
+        }
+      }
+    }
+    const linePaths = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (!visited[i]) {
+        const linePath = [lines[i][0]];
+        dfs(i, linePath);
+        linePaths.push(linePath);
+      }
+    }
+    return linePaths;
+  }
+  /** etOpenRound 去除毛刺
+   * @description 检查连续的短线段数量，去除合并后产生的毛刺
+   */
+  squareRemoveBurr() {
+    this.wallsGroup = this.wallsGroup.map((lines) => {
+      if (lines.length < 3) return lines;
+      const filterLines = [lines[0]];
+      for (let i = 1; i < lines.length; i++) {
+        const prev = lines[i - 1];
+        const curr = lines[i];
+        const len = prev.distance(curr);
+        if (len < this.width * 0.5) {
+          let count = 0;
+          for (let j = i + 1; j < lines.length; j++) {
+            const prev2 = lines[j - 1];
+            const curr2 = lines[j];
+            const len2 = prev2.distance(curr2);
+            if (len2 < this.width * 0.8) count++;
+            else break;
+          }
+          if (count === 0 && i + count === lines.length - 1) ;
+          else if (i == 1 && count === 1) ;
+          else if (count === 3) {
+            filterLines.push(lines[i + 1]);
+            i += count;
+          } else if (count === 5) {
+            filterLines.push(lines[i + 2]);
+            i += count;
+          } else {
+            filterLines.push(curr);
+          }
+        } else {
+          filterLines.push(curr);
+        }
+      }
+      return filterLines;
+    });
+  }
+  /** 线偏移
+   * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
+   */
+  lineOffset(endType = Dxf.EndType.etOpenSquare, joinType = Dxf.JoinType.jtMiter, scale = 1e4) {
+    const solutions = new ClipperLib.Paths();
+    const offset = new ClipperLib.ClipperOffset(20, 0.25);
+    this.pointsGroups.forEach((points) => {
+      const linePaths = this.lineTopology(points).map((linePath) => linePath.map((p) => p.clone().mutiplyScalar(scale)));
+      offset.AddPaths(linePaths, joinType, endType);
+    });
+    offset.Execute(solutions, this.width / 2 * scale);
+    offset.Execute(solutions, this.width / 2 * scale);
+    this.wallsGroup = solutions.map((ps) => ps.map((p) => Point.from(p).divisionScalar(scale)));
+    if (endType == Dxf.EndType.etOpenSquare) this.squareRemoveBurr();
+    this.dispatchEvent({
+      type: "lineOffset",
+      wallsGroup: this.wallsGroup
+    });
+    return this.wallsGroup;
+  }
+  /**
+   * 将点云结构转换为Float32Array
+   */
+  to3DArray(scale) {
+    const array = [];
+    this.wallsGroup.forEach((points) => {
+      for (let i = 0; i < points.length; i++) {
+        const point1 = points[i];
+        const nextIndex = i === points.length - 1 ? 0 : i + 1;
+        const point2 = points[nextIndex];
+        array.push(point1.X * scale, point1.Y * scale, this.originalZAverage, point2.X * scale, point2.Y * scale, this.originalZAverage);
+      }
+    });
+    return new Float32Array(array);
+  }
+  /**
+   * 将点云结构转换为string
+   */
+  toDxfString(unit = "Millimeters") {
+    const d = new Drawing();
+    d.setUnits("Millimeters");
+    const s = units[unit];
+    this.wallsGroup.forEach((points) => {
+      for (let i = 0; i < points.length; i++) {
+        const point1 = points[i];
+        const nextIndex = i === points.length - 1 ? 0 : i + 1;
+        const point2 = points[nextIndex];
+        d.drawLine(point1.X * s, point1.Y * s, point2.X * s, point2.Y * s);
+      }
+    });
+    return d.toDxfString();
+  }
+  /**
+   * 将点云结构转换为DXF格式
+   * @returns 
+   */
+  toDxfBlob(unit = "Millimeters") {
+    const blob = new Blob([this.toDxfString(unit)]);
+    return blob;
+  }
+  /**
+   * 下载
+   * @param filename 
+   */
+  async download(filename, unit = "Millimeters") {
+    if (typeof window !== "undefined") {
+      const blob = this.toDxfBlob(unit);
+      const a = document.createElement("a");
+      a.href = URL.createObjectURL(blob);
+      a.download = filename + ".dxf";
+      a.click();
+    } else if (typeof global !== "undefined") {
+      const packageName = "fs";
+      const { default: fs } = await import(
+        /* @vite-ignore */
+        packageName
+      );
+      fs.writeFileSync(filename, this.toDxfString(unit));
+    }
+  }
+  /**
+   * 计算原始数据的边界框
+   * @description 计算所有线段的起点和终点的最小最大值，形成一个边界框
+   * @returns 
+   */
+  computedOriginalSize(data, originalBox = new Box2(0, 0, 0, 0)) {
+    const xArr = data.flatMap((item) => [item.start.x, item.end.x]);
+    const yArr = data.flatMap((item) => [item.start.y, item.end.y]);
+    const minX = Math.min(...xArr);
+    const minY = Math.min(...yArr);
+    const maxX = Math.max(...xArr);
+    const maxY = Math.max(...yArr);
+    originalBox.set(minX, minY, maxX, maxY);
+    return originalBox;
+  }
+  /**
+   * 创建数据
+   * @param pointsGroups 
+   * @returns 
+   */
+  static createData(pointsGroups, sealed = true) {
+    let count = 0;
+    const data = pointsGroups.flatMap((points) => {
+      const lines = points.map((point, index2) => {
+        const nextIndex = index2 === points.length - 1 ? 0 : index2 + 1;
+        const nextPoint = points[nextIndex];
+        return {
+          start: { x: point.x, y: point.y },
+          end: { x: nextPoint.x, y: nextPoint.y },
+          insetionArr: [
+            {
+              index: nextIndex + count
+            }
+          ]
+        };
+      });
+      count += points.length;
+      if (!sealed) {
+        lines.pop();
+        lines[lines.length - 1].insetionArr.length = 0;
+        count--;
+      }
+      return lines;
+    });
+    return data;
+  }
+}
+class Variable extends Component {
+  static name = "Variable";
+  originalLineVisible = true;
+  dxfVisible = true;
+  whiteModelVisible = true;
+  isLook = false;
+  currentWheel = 0;
+  pointerMove = { x: 0, y: 0 };
+  currentKeyUp = "";
+  set(key, value) {
+    if (key in this) {
+      const oldValue = this[key];
+      this[key] = value;
+      this.dispatchEvent({
+        type: key,
+        value,
+        oldValue
+      });
+    }
+  }
+  get(key) {
+    if (key in this) return this[key];
+  }
+}
+class Rectangle {
+  points;
+  get path() {
+    return this.points.flatMap((p, i) => {
+      const np = this.points[(i + 1) % this.points.length];
+      return [p.x, p.y, 0, np.x, np.y, 0];
+    });
+  }
+  constructor(points) {
+    if (points.length !== 4) {
+      throw new Error("Rectangle must be defined by exactly 4 points");
+    }
+    this.points = points;
+  }
+  /**
+   * 判断线段是否与矩形相交
+   * @param line 线段
+   * @returns 是否与矩形相交
+   */
+  intersectLineSegment(line) {
+    if (line.points.length !== 2) {
+      throw new Error("LineSegment must have exactly 2 points");
+    }
+    const [p1, p2] = line.points;
+    const doIntersect = (l1p1, l1p2, l2p1, l2p2) => {
+      const orientation = (p, q, r) => {
+        const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+        if (val === 0) return 0;
+        return val > 0 ? 1 : 2;
+      };
+      const onSegment = (p, q, r) => {
+        return Math.min(p.x, r.x) <= q.x && q.x <= Math.max(p.x, r.x) && Math.min(p.y, r.y) <= q.y && q.y <= Math.max(p.y, r.y);
+      };
+      const o1 = orientation(l1p1, l1p2, l2p1);
+      const o2 = orientation(l1p1, l1p2, l2p2);
+      const o3 = orientation(l2p1, l2p2, l1p1);
+      const o4 = orientation(l2p1, l2p2, l1p2);
+      if (o1 !== o2 && o3 !== o4) return true;
+      if (o1 === 0 && onSegment(l1p1, l2p1, l1p2)) return true;
+      if (o2 === 0 && onSegment(l1p1, l2p2, l1p2)) return true;
+      if (o3 === 0 && onSegment(l2p1, l1p1, l2p2)) return true;
+      if (o4 === 0 && onSegment(l2p1, l1p2, l2p2)) return true;
+      return false;
+    };
+    for (let i = 0; i < 4; i++) {
+      const rectP1 = this.points[i];
+      const rectP2 = this.points[(i + 1) % 4];
+      if (doIntersect(p1, p2, rectP1, rectP2)) {
+        return true;
+      }
+    }
+    if (this.containsLineSegment(line)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 判断线段是否完全位于矩形内部
+   * @param line 线段
+   * @returns 是否完全在矩形内部
+   */
+  containsLineSegment(line) {
+    if (line.points.length !== 2) {
+      throw new Error("LineSegment must have exactly 2 points");
+    }
+    const isPointInRectangle = (point) => {
+      let sign = 0;
+      for (let i = 0; i < 4; i++) {
+        const p1 = this.points[i];
+        const p2 = this.points[(i + 1) % 4];
+        const edge = { x: p2.x - p1.x, y: p2.y - p1.y };
+        const toPoint = { x: point.x - p1.x, y: point.y - p1.y };
+        const cross = edge.x * toPoint.y - edge.y * toPoint.x;
+        if (cross === 0) {
+          const t = edge.x !== 0 ? (point.x - p1.x) / edge.x : (point.y - p1.y) / edge.y;
+          if (t >= 0 && t <= 1) return true;
+        } else {
+          const currentSign = cross > 0 ? 1 : -1;
+          if (sign === 0) sign = currentSign;
+          if (sign !== currentSign) return false;
+        }
+      }
+      return true;
+    };
+    return isPointInRectangle(line.points[0]) && isPointInRectangle(line.points[1]);
+  }
+  /**
+   * 判断点是否完全位于矩形内部
+   * @param point 
+   */
+  containsPoint(point) {
+    let positiveCount = 0;
+    let negativeCount = 0;
+    for (let i = 0; i < 4; i++) {
+      const p1 = this.points[i];
+      const p2 = this.points[(i + 1) % 4];
+      const cross = (p2.x - p1.x) * (point.y - p1.y) - (p2.y - p1.y) * (point.x - p1.x);
+      if (cross > 0) positiveCount++;
+      else if (cross < 0) negativeCount++;
+      else return false;
+    }
+    return positiveCount === 4 || negativeCount === 4;
+  }
+  /**
+   * 
+   * @returns 
+   */
+  toBox() {
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    this.points.forEach((p) => {
+      maxX = Math.max(p.x, maxX);
+      minX = Math.min(p.x, minX);
+      maxY = Math.max(p.x, maxY);
+      minY = Math.min(p.x, minY);
+    });
+    return new Box2(minX, maxX, minY, maxY);
+  }
+  /**
+   * 
+   * @param line 
+   * @param width 
+   * @returns 
+   */
+  static fromByLineSegment(line, width = 0.1, horizontal = false, hScale = 0.5) {
+    const p1 = line.points[0], p2 = line.points[1], normal = p2.normal(p1), pDirect = horizontal ? p2.direction(p1).mutiplyScalar(width * hScale) : Point.zero(), nDirect = horizontal ? p1.direction(p2).mutiplyScalar(width * hScale) : Point.zero();
+    const offsetX = normal.x * width * 0.5;
+    const offsetY = normal.y * width * 0.5;
+    return new Rectangle([
+      new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
+      new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
+      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect),
+      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect)
+    ]);
+  }
+}
+class Quadtree {
+  bounds;
+  // 包围盒
+  capacity;
+  // 节点容量
+  maxDepth;
+  // 最大深度
+  depth;
+  // 当前深度
+  isLeaf = true;
+  // 是否为叶子节点
+  children = null;
+  // 子节点数组
+  nodes = [];
+  // 存储的节点
+  color = [Math.random(), Math.random(), Math.random()];
+  // 颜色
+  constructor(bounds, capacity = 8, maxDepth = 10, depth = 1) {
+    this.bounds = bounds;
+    this.capacity = capacity;
+    this.depth = depth;
+    this.maxDepth = maxDepth;
+  }
+  /**
+   * 插入线段节点
+   * @param node 线段节点
+   */
+  insert(node) {
+    if (!this.isLeaf) {
+      const quadrant = this.getQuadrant(node.line);
+      if (quadrant !== -1) {
+        this.children[quadrant].insert(node);
+        return;
+      }
+    }
+    this.nodes.push(node);
+    if (this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
+      this.subdivide();
+      const nodes = this.nodes;
+      this.nodes = [];
+      for (const n of nodes) {
+        const quadrant = this.getQuadrant(n.line);
+        if (quadrant !== -1) {
+          this.children[quadrant].insert(n);
+        } else {
+          this.nodes.push(n);
+        }
+      }
+    }
+  }
+  /**
+   * 获取线段所属的象限
+   * @param line 线段
+   * @returns 象限索引（0:西北,1:东北,2:西南,3:东南）或-1（跨多个象限）
+   */
+  getQuadrant(line) {
+    const intersectsNW = this.children[0].bounds.intersectLineSegment(line);
+    const intersectsNE = this.children[1].bounds.intersectLineSegment(line);
+    const intersectsSW = this.children[2].bounds.intersectLineSegment(line);
+    const intersectsSE = this.children[3].bounds.intersectLineSegment(line);
+    let count = 0;
+    let quadrant = -1;
+    if (intersectsNW) {
+      count++;
+      quadrant = 0;
+    }
+    if (intersectsNE) {
+      count++;
+      quadrant = 1;
+    }
+    if (intersectsSW) {
+      count++;
+      quadrant = 2;
+    }
+    if (intersectsSE) {
+      count++;
+      quadrant = 3;
+    }
+    if (count === 1) return quadrant;
+    return -1;
+  }
+  /**
+   * 细分当前节点为四个子节点
+   */
+  subdivide() {
+    if (!this.isLeaf) return;
+    this.isLeaf = false;
+    this.children = [];
+    const midX = (this.bounds.minX + this.bounds.maxX) / 2;
+    const midY = (this.bounds.minY + this.bounds.maxY) / 2;
+    this.children[0] = new Quadtree(
+      new Box2(this.bounds.minX, midX, this.bounds.minY, midY),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    );
+    this.children[1] = new Quadtree(
+      new Box2(midX, this.bounds.maxX, this.bounds.minY, midY),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    );
+    this.children[2] = new Quadtree(
+      new Box2(this.bounds.minX, midX, midY, this.bounds.maxY),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    );
+    this.children[3] = new Quadtree(
+      new Box2(midX, this.bounds.maxX, midY, this.bounds.maxY),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    );
+  }
+  /**
+   * 查询与包围盒相交的线段节点
+   * @param box2 包围盒
+   * @returns 相交的节点数组
+   */
+  queryBox(box2) {
+    const result = [];
+    if (!this.bounds.intersectBox(box2)) {
+      return result;
+    }
+    for (const node of this.nodes) {
+      if (box2.intersectLineSegment(node.line)) {
+        result.push(node);
+      }
+    }
+    if (!this.isLeaf) {
+      for (const child of this.children) {
+        result.push(...child.queryBox(box2));
+      }
+    }
+    return result;
+  }
+  /**
+   * 查询与圆形区域相交的线段节点
+   * @param pos 圆心
+   * @param radius 半径
+   * @returns 相交的节点数组
+   */
+  queryCircle(pos, radius) {
+    const result = [];
+    const circleBox = new Box2(
+      pos.x - radius,
+      pos.x + radius,
+      pos.y - radius,
+      pos.y + radius
+    );
+    if (!this.bounds.intersectBox(circleBox)) {
+      return result;
+    }
+    for (const node of this.nodes) {
+      const [p1, p2] = node.line.points;
+      const dx = p2.x - p1.x;
+      const dy = p2.y - p1.y;
+      const l2 = dx * dx + dy * dy;
+      let t = ((pos.x - p1.x) * dx + (pos.y - p1.y) * dy) / l2;
+      t = Math.max(0, Math.min(1, t));
+      const closestX = p1.x + t * dx;
+      const closestY = p1.y + t * dy;
+      const distance = pos.distance(new Point(closestX, closestY));
+      if (distance <= radius) {
+        result.push(node);
+      }
+    }
+    if (!this.isLeaf) {
+      for (const child of this.children) {
+        result.push(...child.queryCircle(pos, radius));
+      }
+    }
+    return result;
+  }
+  /**
+   * 查询与矩形相交的线段节点
+   * @param rectangle 矩形
+   * @returns 相交的节点数组
+   */
+  queryRect(rectangle) {
+    const result = [];
+    if (!this.bounds.intersectRectangle(rectangle)) {
+      return result;
+    }
+    for (const node of this.nodes) {
+      if (rectangle.intersectLineSegment(node.line)) {
+        result.push(node);
+      }
+    }
+    if (!this.isLeaf) {
+      for (const child of this.children) {
+        result.push(...child.queryRect(rectangle));
+      }
+    }
+    return result;
+  }
+  /**
+   * 包围盒转换为数组
+   * @param array 
+   * @param colors 
+   * @returns 
+   */
+  boundsToArray(array = [], colors, recursion = true) {
+    if (!this.isLeaf && recursion) {
+      this.children?.forEach((child) => child.boundsToArray(array, colors));
+    }
+    array.push(...this.bounds.points.flatMap((p, i, array2) => {
+      const np = array2[(i + 1) % array2.length];
+      colors?.push(...this.color);
+      colors?.push(...this.color);
+      return [p.x, p.y, 0, np.x, np.y, 0];
+    }));
+    return array;
+  }
+}
+class PointVirtualGrid {
+  map = /* @__PURE__ */ new Map();
+  gridSize;
+  constructor(gridSize = 2) {
+    this.gridSize = gridSize;
+  }
+  /**
+   * 插入
+   * @param point 
+   * @param userData 
+   */
+  insert(point, userData) {
+    if (!point || isNaN(point.x) || isNaN(point.y)) {
+      throw new Error("无效的点坐标");
+    }
+    const id = this.getGridId(point);
+    if (!this.map.has(id)) this.map.set(id, /* @__PURE__ */ new Set());
+    const set = this.map.get(id);
+    set?.add({ point, userData });
+  }
+  /**
+   * 批量加入
+   * @param points 
+   */
+  insertBatch(points) {
+    for (const { point, userData } of points) {
+      this.insert(point, userData);
+    }
+  }
+  /**
+   * 获取通过坐标，获取唯一网格索引
+   * @param point 
+   * @returns 
+   */
+  getGridId(point) {
+    const i = Math.ceil(point.x / this.gridSize), j = Math.ceil(point.y / this.gridSize);
+    return `${i}.${j}`;
+  }
+  /**
+   * 
+   * @param gridId 
+   * @returns 
+   */
+  decodeGridId(gridId) {
+    const [i, j] = gridId.split(".").map(Number);
+    return new Point(i, j);
+  }
+  /**
+   * 查询与矩形相交的点
+   * @param rectangle 矩形
+   * @returns 相交的节点数组
+   */
+  queryRect(rectangle) {
+    const box2 = rectangle.toBox();
+    const minI = Math.ceil(box2.minX / this.gridSize), maxI = Math.ceil(box2.maxX / this.gridSize), minJ = Math.ceil(box2.minY / this.gridSize), maxJ = Math.ceil(box2.maxY / this.gridSize);
+    for (let i = minI; i <= maxI; i++) {
+      for (let j = minJ; j <= maxJ; j++) {
+        const id = `${i}.${j}`;
+        if (!this.map.has(id)) continue;
+        const set = this.map.get(id);
+        set?.forEach((item) => {
+          if (rectangle.containsPoint(item.point)) ;
+        });
+      }
+    }
+  }
+  /**
+   * 查询与圆形区域相交的点
+   * @param pos 圆心
+   * @param radius 半径
+   * @returns 相交的节点数组
+   */
+  queryCircle(pos, radius) {
+    const box2 = new Box2(pos.x - radius, pos.x + radius, pos.y - radius, pos.y + radius);
+    const minI = Math.ceil(box2.minX / this.gridSize), maxI = Math.ceil(box2.maxX / this.gridSize), minJ = Math.ceil(box2.minY / this.gridSize), maxJ = Math.ceil(box2.maxY / this.gridSize), list = [];
+    for (let i = minI; i <= maxI; i++) {
+      for (let j = minJ; j <= maxJ; j++) {
+        const id = `${i}.${j}`;
+        if (!this.map.has(id)) continue;
+        const set = this.map.get(id);
+        set?.forEach((item) => {
+          if (pos.distance(item.point) <= radius) list.push(item);
+        });
+      }
+    }
+    return list;
+  }
+  /**
+   * 查询与包围盒相交的点
+   * @param box2 包围盒
+   * @returns 相交的节点数组
+   */
+  queryBox(box2) {
+    const minI = Math.ceil(box2.minX / this.gridSize), maxI = Math.ceil(box2.maxX / this.gridSize), minJ = Math.ceil(box2.minY / this.gridSize), maxJ = Math.ceil(box2.maxY / this.gridSize), list = [];
+    for (let i = minI; i <= maxI; i++) {
+      for (let j = minJ; j <= maxJ; j++) {
+        const id = `${i}.${j}`;
+        if (!this.map.has(id)) continue;
+        const set = this.map.get(id);
+        set?.forEach((item) => {
+          if (box2.containsPoint(item.point)) list.push(item);
+        });
+      }
+    }
+    return list;
+  }
+  /**
+   * 查找相同点
+   * @param point 
+   */
+  queryPoint(point) {
+    const id = this.getGridId(point), list = [];
+    if (this.map.has(id)) {
+      const set = this.map.get(id);
+      set?.forEach((item) => {
+        if (point.equal(item.point)) list.push(item);
+      });
+    }
+    return list;
+  }
+}
+class LineAnalysis extends Component {
+  static name = "LineAnalysis";
+  Dxf = null;
+  Variable = null;
+  lineSegmentList = [];
+  container = new THREE.Group();
+  // 误差角度
+  errorAngle = 4;
+  width = 0.4;
+  /**
+   * 
+   * @param parent 
+   */
+  onAddFromParent(parent) {
+    this.Dxf = parent.findComponentByType(Dxf);
+    this.Variable = this.parent?.findComponentByType(Variable);
+    console.log(this.Dxf);
+    this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this));
+    this.Dxf.addEventListener("lineOffset", this.duplicatePointFiltering.bind(this));
+  }
+  /**
+   * 去除路径上重复的点
+   * @description 判断方向向量，一个连续的方向上，只应该出现两个点
+   */
+  duplicatePointFiltering() {
+    const dxf = this.Dxf;
+    dxf.wallsGroup = dxf.wallsGroup.map((points) => {
+      const filterPoints = [];
+      points.forEach((point, index2) => {
+        if (index2 < 1 || points.length - 1 === index2) return filterPoints.push(point);
+        const preP = points[index2 - 1], nextP = points[index2 + 1], direct1 = point.direction(preP), direct2 = nextP.direction(point), angle = direct1.angleBetween(direct2) / (Math.PI / 180);
+        if (angle > 0.02 && angle < 180 - 0.02) filterPoints.push(point);
+      });
+      points = [filterPoints[0]];
+      for (let i = 1; i < filterPoints.length; i++) {
+        const point = filterPoints[i];
+        const nextP = filterPoints[i - 1];
+        if (nextP.distance(point) < dxf.width * 0.5) ;
+        points.push(point);
+      }
+      return points;
+    });
+    dxf.wallsGroup = dxf.wallsGroup.filter((i) => i.length >= 4);
+  }
+  /**
+   * 
+   * @param p1 
+   * @param p2 
+   * @param width 
+   * @returns 
+   */
+  expandLineSegment(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]
+    };
+  }
+  appendLineSegmentList = [];
+  /**
+   * 追加数据
+   * @param p1 
+   * @param p2 
+   */
+  addData(p1, p2) {
+    const dxf = this.Dxf;
+    dxf.data.push([p1.clone(), p2.clone(), [], false, dxf.data.length]);
+    this.appendLineSegmentList.push(new LineSegment(p1.clone(), p2.clone()));
+  }
+  /** 结果分析创建矩形
+   * @param result 
+   */
+  createRectangle(result) {
+    const dxf = this.Dxf;
+    const project0 = result.project, project1 = result.project2;
+    this.addData(project0.points[0], project1.points[0]);
+    this.addData(project0.points[1], project1.points[1]);
+    const leftHeight = project0.points[0].distance(project1.points[0]), rightHeight = project0.points[1].distance(project1.points[1]), count = Math.ceil(Math.max(leftHeight, rightHeight) / dxf.width), leftFragment = leftHeight / count, rightFragment = rightHeight / count, leftDirection = project1.points[0].direction(project0.points[0]), rightDirection = project1.points[1].direction(project0.points[1]), leftP = project0.points[0].clone(), rightP = project0.points[1].clone(), direction = rightP.direction(leftP);
+    direction.multiplyScalar(dxf.width * 0.5);
+    const _leftP = leftP.clone().add(direction), _rightP = rightP.clone().add(direction.multiplyScalar(-1)), d1 = leftP.direction(rightP), d2 = _leftP.direction(_rightP);
+    if (d1.x > 0 && d2.x < 0 || d1.x < 0 && d2.x > 0 || d1.y > 0 && d2.y < 0 || d1.y < 0 && d2.y > 0) return;
+    leftP.set(_leftP.x, _leftP.y);
+    rightP.set(_rightP.x, _rightP.y);
+    for (let i = 1; i < count; i++) {
+      const left = leftDirection.clone().multiplyScalar(leftFragment * i), right = rightDirection.clone().multiplyScalar(rightFragment * i), p1 = leftP.clone().add(left), p2 = rightP.clone().add(right);
+      this.addData(p1, p2);
+    }
+  }
+  pointVirtualGrid = new PointVirtualGrid();
+  /**
+   * 构建点的虚拟网格索引
+   */
+  buildVirtualGrid() {
+    const dxf = this.Dxf;
+    const pointVirtualGrid = new PointVirtualGrid();
+    dxf.originalData.forEach((d, index2) => {
+      const [p1, p2] = [Point.from(d.start), Point.from(d.end)];
+      pointVirtualGrid.insert(p1, { index: index2, type: "start" });
+      pointVirtualGrid.insert(p2, { index: index2, type: "end" });
+    });
+    this.pointVirtualGrid = pointVirtualGrid;
+  }
+  quadtree;
+  /**
+   * 构建线段四叉树，快速查找，
+   */
+  buildQuadtree() {
+    const dxf = this.Dxf;
+    const lineSegmentList = [];
+    this.quadtree = new Quadtree(dxf.originalBox, 2);
+    dxf.lineSegments.forEach((lineSegment) => {
+      if (lineSegment.userData?.isDoor) return;
+      this.quadtree?.insert({
+        line: lineSegment,
+        userData: lineSegmentList.length
+      });
+      lineSegmentList.push(lineSegment);
+    });
+    this.lineSegmentList = lineSegmentList;
+  }
+  resultList = [];
+  /** 线段分析
+   * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
+   * @param data 
+   */
+  lineAnalysis() {
+    this.buildQuadtree();
+    this.buildVirtualGrid();
+    const quadtree = this.quadtree;
+    const lineSegmentList = this.lineSegmentList;
+    const visited = /* @__PURE__ */ new Set(), resultList = [];
+    lineSegmentList.forEach((_0, i) => {
+      const sourceLineSegment = lineSegmentList[i], rectangle = Rectangle.fromByLineSegment(sourceLineSegment, this.width * 2, false, -0.01), ids = quadtree.queryRect(rectangle).map((i2) => i2.userData).filter((index2) => index2 !== i);
+      ids.forEach((id) => {
+        try {
+          if (visited.has(`${i}-${id}`) || visited.has(`${id}-${i}`)) return;
+          const res = this.projectionAnalysis(id, i, sourceLineSegment, lineSegmentList);
+          if (res) resultList.push(res);
+          visited.add(`${i}-${id}`);
+        } catch (error) {
+        }
+      });
+    });
+    this.appendLineSegmentList.length = 0;
+    resultList.forEach(this.createRectangle.bind(this));
+    this.resultList = [];
+  }
+  /** 线段投影分析
+   * @param index 
+   * @param sourceLineSegment 
+   * @param lineSegmentList 
+   * @returns 
+   */
+  projectionAnalysis(index2, sourceIndex, sourceLineSegment, lineSegmentList) {
+    const temLineSegment = lineSegmentList[index2], direct = sourceLineSegment.direction(), temDirect = temLineSegment.direction(), angle = direct.angleBetween(temDirect) / (Math.PI / 180);
+    if (angle < this.errorAngle || angle > 180 - this.errorAngle) {
+      let data;
+      const p1 = temLineSegment.projectLineSegment(sourceLineSegment), p2 = sourceLineSegment.projectLineSegment(temLineSegment), d1 = p1.direction(), d2 = p2.direction();
+      if (d1.x > 0 && d2.x < 0 || d1.x < 0 && d2.x > 0 || d1.y > 0 && d2.y < 0 || d1.y < 0 && d2.y > 0) {
+        p1.points = [p1.points[1], p1.points[0]];
+      }
+      if (p1.getLength() > p2.getLength()) {
+        data = {
+          target: temLineSegment,
+          targetIndex: index2,
+          source: sourceLineSegment,
+          sourceIndex,
+          project: p1,
+          project2: p2
+        };
+      } else {
+        data = {
+          target: sourceLineSegment,
+          targetIndex: sourceIndex,
+          source: temLineSegment,
+          sourceIndex: index2,
+          project: p2,
+          project2: p1
+        };
+      }
+      if (!data || data.project.getLength() < 0.01) return;
+      return data;
+    }
+  }
+}
+class DxfSystem extends ComponentManager {
+  Dxf;
+  Variable;
+  wallWidth;
+  environment;
+  /** 构造函数
+   * @param wallWidth 输出墙壁厚度，该墙壁厚度不受缩放影响
+   * @param scale 原始数据缩放比例
+   */
+  constructor(wallWidth = 0.1, scale = 1) {
+    super();
+    this.environment = typeof window !== "undefined" ? "browser" : typeof global !== "undefined" ? "node" : "unknown";
+    this.wallWidth = wallWidth;
+    this.Dxf = new Dxf(this.wallWidth, scale);
+    this.Variable = new Variable();
+    this.addComponent(this.Variable);
+    this.addComponent(this.Dxf);
+    this.addComponent(new LineAnalysis());
+  }
+  usePlugin(plugin) {
+    if (typeof plugin === "function") plugin.call(this, this);
+    return this;
+  }
+  destroy() {
+    this.components.forEach((com) => {
+      this.removeComponent(com);
+      com.destroy();
+    });
+  }
+}
+const exporter = new OBJExporter();
+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();
+  // 原始数据白模
+  originalWhiteMode = new THREE.Group();
+  onAddFromParent(parent) {
+    this.Dxf = parent.findComponentByName("Dxf");
+    this.Variable = parent.findComponentByName("Variable");
+    this.originalWhiteMode.visible = false;
+    this.Dxf?.addEventListener("lineOffset", () => {
+      this.updateModel();
+    });
+  }
+  updateModel() {
+    this.Variable?.set("whiteModelVisible", false);
+    const dxf = this.Dxf;
+    this.originalWhiteMode.clear();
+    this.whiteModelGroup.clear();
+    this.whiteModelGroup.position.z = dxf.originalZAverage;
+    this.originalWhiteMode.position.z = dxf.originalZAverage;
+    dxf.wallsGroup.forEach((points) => {
+      const shape = new THREE.Shape();
+      points.forEach((p, i) => i === 0 ? shape.moveTo(p.x / dxf.scale, p.y / dxf.scale) : shape.lineTo(p.x / dxf.scale, p.y / dxf.scale));
+      const geometry = new THREE.ExtrudeGeometry(shape, {
+        depth: 2.8,
+        bevelSize: 0
+      });
+      const mesh = new THREE.Mesh(geometry);
+      mesh.material = new THREE.MeshStandardMaterial({ color: 16777215, transparent: true, opacity: 0.8 });
+      this.whiteModelGroup.add(mesh);
+      this.whiteModelGroup.add(
+        new THREE.LineSegments(new THREE.EdgesGeometry(geometry), new THREE.LineBasicMaterial({ color: 6710886 }))
+      );
+    });
+    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
+    });
+  }
+  toOBJ() {
+    return new Promise((resolve) => {
+      resolve(exporter.parse(this.whiteModelGroup));
+    });
+  }
+  async toBlob() {
+    const buffer = await this.toOBJ();
+    if (buffer) {
+      return new Blob([buffer], { type: "application/octet-stream" });
+    }
+  }
+  async download(filename) {
+    if (typeof window !== "undefined") {
+      const blob = await this.toBlob();
+      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 packageName = "fs";
+        const { default: fs } = await import(
+          /* @vite-ignore */
+          packageName
+        );
+        fs.writeFileSync(filename, buffer);
+      }
+    }
+  }
+}
+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: fs } = await import(
+          /* @vite-ignore */
+          packageName
+        );
+        const buffer = fs.readFileSync(data);
+        const json = JSON.parse(buffer.toString("utf-8"));
+        this.set(json);
+        return;
+      } else {
+        throw new Error("非node环境不允许使用路径");
+      }
+    }
+    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
+          });
+        }
+      });
+      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);
+    this.dxfLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(dxfArray, 3, true));
+    const doorsArray = new Float32Array(dxf.doors.flatMap(([p1, p2]) => [p1.x, p1.y, dxf.originalZAverage, p2.x, p2.y, dxf.originalZAverage])).map((n) => n / dxf.scale);
+    const doorsColorArray = new Float32Array(dxf.doors.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));
+  }
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DetailsPoint,
+  DxfLineModel,
+  WhiteModel
+}, Symbol.toStringTag, { value: "Module" }));
+function ModelDataPlugin(dxfSystem) {
+  dxfSystem.addComponent(new DxfLineModel());
+  dxfSystem.addComponent(new WhiteModel());
+  dxfSystem.addComponent(new DetailsPoint());
+}
+function loadRenderPlugin() {
+  return import("./index2.js");
+}
+export {
+  Box2 as B,
+  Component as C,
+  DxfSystem as D,
+  ModelDataPlugin as M,
+  Point as P,
+  Variable as V,
+  DetailsPoint as a,
+  index as i,
+  loadRenderPlugin as l
+};