build-dxf 0.0.13 → 0.0.15

package/src/build.js

@@ -273,20 +273,32 @@ class Point {
   dot(point) {
     return this.x * point.x + this.y * point.y;
   }
+  /** 求两个点叉积
+   * @description 如果叉积大于 0，a 到 b 为逆时针方向。
+   * @description 如果叉积小于 0，a 到 b 为顺时针方向。
+   * @param point 
+   * @returns 
+   */
+  cross(point) {
+    return this.x * point.y - this.y * this.x;
+  }
   /** 计算两个向量夹角
    * @description 公式：a · b = |a| × |b| × cosθ
    * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
    * @param point 
    * @returns 
    */
-  angleBetween(point) {
+  angleBetween(point, type = "radian", angle = "180") {
     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);
+    if (type === "radian") return Math.acos(clampedCosTheta);
+    if (type === "cos") return clampedCosTheta;
+    if (angle === "180" || this.cross(point) < 0) return Math.acos(clampedCosTheta) / (Math.PI / 180);
+    return 360 - Math.acos(clampedCosTheta) / (Math.PI / 180);
   }
   /** 获取向量长度
    */
@@ -578,6 +590,148 @@ class Box2 {
     );
   }
 }
+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];
+    });
+  }
+  path2D(callback) {
+    return this.points.flatMap((p, i) => {
+      const np = this.points[(i + 1) % this.points.length];
+      callback && callback(new Point(p.x, p.y), new Point(np.x, np.y));
+      return [p.x, p.y, np.x, np.y];
+    });
+  }
+  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 LineSegment {
   points = [new Point(), new Point()];
   userData;
@@ -596,6 +750,69 @@ class LineSegment {
   constructor(p1 = new Point(), p2 = new Point()) {
     this.points = [p1, p2];
   }
+  /** 膨胀
+   * @description 向线段的两个端点分别膨胀 width
+   * @param width 
+   */
+  expansion(width, direction = "all") {
+    const step = this.direction().multiplyScalar(width);
+    if (direction === "end" || direction === "all") this.end.add(step);
+    if (direction === "start" || direction === "all") this.start.add(step.multiplyScalar(-1));
+    return this;
+  }
+  /** 向前
+   * @description 向前移动 width
+   * @param width 
+   */
+  forward(width) {
+    const step = this.direction().multiplyScalar(width);
+    this.start.add(step);
+    this.end.add(step);
+    return this;
+  }
+  /** 向前
+   * @description 向前移动 width
+   * @param width 
+   */
+  backward(width) {
+    const step = this.direction().multiplyScalar(-width);
+    this.start.add(step);
+    this.end.add(step);
+    return this;
+  }
+  /**
+   * 向指定方向平移
+   * @param direct 
+   * @param size 
+   */
+  directionMove(direct, size) {
+    const step = direct.clone().multiplyScalar(size);
+    this.start.add(step);
+    this.end.add(step);
+    return this;
+  }
+  /** 膨胀为矩形
+   * 
+   * @param width 
+   * @returns {Rectangle}
+   */
+  expandToRectangle(width = 0.1) {
+    const p1 = this.start, p2 = this.end;
+    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;
+    const point = [
+      // 第一条线
+      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)
+    ];
+    return new Rectangle([0, 1, 3, 2].map((i) => point[i]));
+  }
   /**
    * 计算线段的长度
    * @returns 线段的长度
@@ -610,6 +827,12 @@ class LineSegment {
   direction() {
     return this.points[1].direction(this.points[0]);
   }
+  /**
+   * 获取发向量
+   */
+  normal() {
+    return this.points[1].normal(this.points[0]);
+  }
   /**
    * 线段长度
    * @returns 
@@ -667,6 +890,38 @@ class LineSegment {
     }
     return new LineSegment(projP1, projP2);
   }
+  /**
+   * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
+   * @param line 要投影的线段
+   * @returns 投影并裁剪后的线段
+   */
+  projectPoint(p1) {
+    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);
+    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);
+    if (t1 < 0 || t1 > 1) {
+      return null;
+    }
+    return projP1;
+  }
   /**
    * 判断线段是与线段相交
    * @param line 
@@ -757,6 +1012,18 @@ class LineSegment {
     );
   }
 }
+async function include(path, exportDefault = true) {
+  if (typeof global !== "undefined" && typeof require !== "undefined") {
+    return require(path);
+  } else {
+    let pack = await import(
+      /* @vite-ignore */
+      path
+    );
+    if (exportDefault) pack = pack.default;
+    return pack;
+  }
+}
 const units = {
   Unitless: 1,
   // 无单位，1米 = 1（无单位）
@@ -805,8 +1072,8 @@ function pathToLines(path) {
   const lineSegments = [];
   for (let i = 0; i < path.length; i++) {
     lineSegments.push(new LineSegment(
-      path[i],
-      path[(i + 1) % path.length]
+      path[i].clone(),
+      path[(i + 1) % path.length].clone()
     ));
   }
   return lineSegments;
@@ -829,6 +1096,7 @@ class Dxf extends Component {
   pointsGroups = [];
   wallsGroup = [];
   doors = [];
+  doorLineSegment = [];
   lineSegments = [];
   originalZAverage = 0;
   static EndType = {
@@ -857,7 +1125,7 @@ class Dxf extends Component {
     super();
     this.width = width;
     this.scale = scale;
-    this.shortLine = width * 0.8;
+    this.shortLine = width * 0.4;
   }
   /**
    * 设置
@@ -991,6 +1259,28 @@ class Dxf extends Component {
     }
     return linePaths;
   }
+  /** 合并方向相同的线段
+   * @param lines 
+   * @param errAngle 
+   */
+  mergeSameDirectionLine(lines, errAngle = 3) {
+    if (lines[0].includedAngle(lines[lines.length - 1]) < 0.1) {
+      const line = lines.pop();
+      line.end.copy(lines[0].end);
+      lines.splice(0, 1, line);
+    }
+    const filterLines = [lines[0]];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      const preLine = lines[i - 1];
+      if (preLine.includedAngle(line) < errAngle) {
+        preLine.end.copy(line.end);
+      } else {
+        filterLines.push(line);
+      }
+    }
+    return filterLines;
+  }
   /** etOpenRound 去除毛刺
    * @description 检查连续的短线段数量，去除合并后产生的毛刺
    */
@@ -1027,44 +1317,22 @@ class Dxf extends Component {
     }
     return filterLines;
   }
-  epsilon = 1e-6;
-  // 距离阈值，用于比较点
   /**
-   * 移除共线点
-   * @param path 
-   * @returns 
+   * 线段矫直, 线段中心突刺
+   * @description 突变长度小于墙体宽度，该线段可能为突起线段，
+   * @description 判断后续第2线段与上一条线段是否方向相同，相同就为突刺
    */
-  removeCollinearPoints(path) {
+  lineSegmentStraightening(path) {
     for (let i = 0; i < path.length; i++) {
       const p1 = path[i];
       const p2 = path[(i + 1) % path.length];
       if (p1.distance(p2) > this.shortLine) {
-        path.push(...path.slice(0, i));
-        path.splice(0, i);
+        path.push(...path.slice(0, i + 1));
+        path.splice(0, i + 1);
         break;
       }
     }
-    if (path.length < 3) return path;
-    const cleanedPath = [];
-    const n = path.length;
-    for (let i = 0; i < n; i++) {
-      const p1 = path[i];
-      const p2 = path[(i + 1) % n];
-      const p3 = path[(i + 2) % n];
-      const cross = (p2.X - p1.X) * (p3.Y - p2.Y) - (p2.Y - p1.Y) * (p3.X - p2.X);
-      if (Math.abs(cross) > this.epsilon) {
-        cleanedPath.push(p1);
-      }
-    }
-    return cleanedPath;
-  }
-  /**
-   * 线段矫直, 线段中心突刺
-   * @description 突变长度小于墙体宽度，该线段可能为突起线段，
-   * @description 判断后续第2线段与上一条线段是否方向相同，相同就为突刺
-   */
-  lineSegmentStraightening(path) {
-    const lines = pathToLines(path), filterLines = [lines[0]];
+    const lines = this.mergeSameDirectionLine(pathToLines(path)), filterLines = [lines[0]];
     for (let i = 1; i < lines.length; i++) {
       const line = lines[i];
       const preLine = lines[(lines.length + i - 1) % lines.length];
@@ -1080,15 +1348,16 @@ class Dxf extends Component {
         continue;
       }
       const line2 = lines[i + 2];
-      if (line2 && preLine.includedAngle(line2) < 1) {
+      if (line2 && preLine.includedAngle(line2) < 2) {
         i = i + 2;
         filterLines.push(line2);
       } else filterLines.push(line);
     }
-    return filterLines.length > 3 ? linesToPath(filterLines) : [];
+    return filterLines.length > 3 ? linesToPath(this.mergeSameDirectionLine(filterLines)) : [];
   }
   /**
    * 移除短线段
+   * @todo 根据线段两端线段长度，选取参照物_|▔▔
    * @param path 
    */
   removeShortLine(path, shortLine = this.shortLine) {
@@ -1141,9 +1410,9 @@ class Dxf extends Component {
     offset.Execute(solutions, this.width / 2 * scale);
     this.wallsGroup = solutions.map((ps) => {
       let path = ps.map((p) => Point.from(p).divisionScalar(scale));
-      path = this.removeCollinearPoints(path);
       path = this.lineSegmentStraightening(path);
       if (endType == Dxf.EndType.etOpenSquare) path = this.squareRemoveBurr(path);
+      path = this.removeShortLine(path);
       return path;
     });
     this.dispatchEvent({
@@ -1167,6 +1436,32 @@ class Dxf extends Component {
     });
     return new Float32Array(array);
   }
+  /** 获取角度范围
+   * @param center 
+   * @param p1 
+   * @param p2 
+   * @returns 
+   */
+  getArcAngleRange(center, p1, p2) {
+    const x1 = p1.x - center.x;
+    const y1 = p1.y - center.y;
+    const x2 = p2.x - center.x;
+    const y2 = p2.y - center.y;
+    let angle1 = Math.atan2(y1, x1);
+    let angle2 = Math.atan2(y2, x2);
+    angle1 = angle1 < 0 ? angle1 + 2 * Math.PI : angle1;
+    angle2 = angle2 < 0 ? angle2 + 2 * Math.PI : angle2;
+    let r1, r2;
+    const diff = Math.abs(angle2 - angle1);
+    if (diff <= Math.PI) {
+      r1 = Math.min(angle1, angle2);
+      r2 = Math.max(angle1, angle2);
+    } else {
+      r1 = Math.max(angle1, angle2);
+      r2 = Math.min(angle1, angle2) + 2 * Math.PI;
+    }
+    return [r1 / (Math.PI / 180), r2 / (Math.PI / 180)];
+  }
   /**
    * 将点云结构转换为string
    */
@@ -1174,12 +1469,37 @@ class Dxf extends Component {
     const d = new Drawing();
     d.setUnits("Millimeters");
     const s = units[unit];
+    function drawLine(p1, p2) {
+      d.drawLine(p1.X * s, p1.Y * s, p2.X * s, p2.Y * s);
+    }
     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);
+        drawLine(point1, point2);
+      }
+    });
+    const doorThickness = this.width * 0.2;
+    d.addLayer("l_yellow", Drawing.ACI.CYAN, "DOTTED");
+    this.doorLineSegment.forEach((lineSegment) => {
+      if (lineSegment.length() < 0.4) return;
+      const line = lineSegment.clone().expansion(-this.width * 0.5);
+      d.setActiveLayer("l_yellow");
+      if (line.length() < 1.2) {
+        line.expansion(-doorThickness * 0.5);
+        const normal = lineSegment.normal();
+        const door = new LineSegment(
+          line.start.clone(),
+          line.start.clone().add(normal.clone().multiplyScalar(line.length()))
+        );
+        door.expansion(-doorThickness * 0.5).expandToRectangle(this.width * 0.2).path2D((p1, p2) => drawLine(p1, p2));
+        const a = line.length(), b = door.length(), r = (a ** 2 + b ** 2) / (2 * b), center = door.end.clone().add(door.direction().multiplyScalar(-r)), [startAngle, endAngle] = this.getArcAngleRange(center, line.end, door.end);
+        d.drawArc(center.x * s, center.y * s, r * s, Math.min(startAngle, endAngle), Math.max(startAngle, endAngle));
+      } else {
+        line.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((p1, p2) => drawLine(p1, p2));
+        line.clone().directionMove(line.normal(), doorThickness * 0.5).expansion(-line.length() * 0.4, "end").forward(doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
+        line.clone().directionMove(line.normal(), -doorThickness * 0.5).expansion(-line.length() * 0.4, "start").forward(-doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
       }
     });
     return d.toDxfString();
@@ -1204,11 +1524,7 @@ class Dxf extends Component {
       a.download = filename + ".dxf";
       a.click();
     } else if (typeof global !== "undefined") {
-      const packageName = "fs";
-      const { default: fs } = await import(
-        /* @vite-ignore */
-        packageName
-      );
+      const fs = await include("fs", false);
       fs.writeFileSync(filename, this.toDxfString(unit));
     }
   }
@@ -1283,141 +1599,6 @@ class Variable extends Component {
     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;
   // 包围盒
@@ -1615,6 +1796,28 @@ class Quadtree {
     }
     return result;
   }
+  /**
+   * 查询与线段相交的线段节点
+   * @param lineSegment 线段
+   * @returns 相交的节点数组
+   */
+  queryLineSegment(lineSegment) {
+    const result = [];
+    if (!this.bounds.intersectLineSegment(lineSegment)) {
+      return result;
+    }
+    for (const node of this.nodes) {
+      if (lineSegment.intersectLineSegment(node.line)) {
+        result.push(node);
+      }
+    }
+    if (!this.isLeaf) {
+      for (const child of this.children) {
+        result.push(...child.queryLineSegment(lineSegment));
+      }
+    }
+    return result;
+  }
   /**
    * 包围盒转换为数组
    * @param array 
@@ -1772,6 +1975,7 @@ class LineAnalysis extends Component {
     this.Dxf = parent.findComponentByType(Dxf);
     this.Variable = this.parent?.findComponentByType(Variable);
     this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this));
+    this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
   }
   /**
    * 
@@ -1839,8 +2043,9 @@ class LineAnalysis extends Component {
   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)];
+    dxf.lineSegments.forEach((d, index2) => {
+      if (d.userData?.isDoor) return;
+      const [p1, p2] = [d.start, d.end];
       pointVirtualGrid.insert(p1, { index: index2, type: "start" });
       pointVirtualGrid.insert(p2, { index: index2, type: "end" });
     });
@@ -1865,6 +2070,7 @@ class LineAnalysis extends Component {
     this.lineSegmentList = lineSegmentList;
   }
   resultList = [];
+  mergeWallLines = [];
   /** 线段分析
    * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
    * @param data 
@@ -1889,7 +2095,7 @@ class LineAnalysis extends Component {
     });
     this.appendLineSegmentList.length = 0;
     resultList.forEach(this.createRectangle.bind(this));
-    this.resultList = [];
+    this.resultList = resultList;
   }
   /** 线段投影分析
    * @param index 
@@ -1921,10 +2127,259 @@ class LineAnalysis extends Component {
           project2: p1
         };
       }
-      if (!data || data.project.getLength() < 0.01) return;
+      if (!data || data.project.getLength() < 0.2 || data.project2.getLength() < 0.2) return;
       return data;
     }
   }
+  doorSearchNearAngle = 110;
+  doorSearchDistance = 2;
+  doors = [];
+  /**
+   * 门的位置判断
+   */
+  doorsAnalysis() {
+    const dxf = this.Dxf;
+    const doorPoints = [];
+    const pointVirtualGrid = this.pointVirtualGrid;
+    const quadtree = this.quadtree;
+    const doorSearchNearAngle = this.doorSearchNearAngle;
+    const doorSearchDistance = this.doorSearchDistance;
+    const doors = [];
+    const excludePoints = dxf.doors.flatMap((item) => {
+      const index2 = item[4];
+      const doorData = dxf.originalData[index2];
+      if (doorData.drawDoorData) {
+        const point = Point.from(doorData.drawDoorData.start);
+        const direct = Point.from(doorData.drawDoorData.n);
+        const resList = pointVirtualGrid.queryPoint(point).filter((res) => {
+          if (res.userData?.index === index2) return false;
+          const line = dxf.lineSegments[res.userData?.index];
+          const direct2 = line.direction();
+          if (line.start.equal(point)) direct2.multiplyScalar(-1);
+          const angle = direct.angleBetween(direct2, "angle");
+          return angle > 80 || angle < 10;
+        });
+        if (resList.length) {
+          const index22 = resList[0].userData?.index;
+          doorPoints.push({
+            line: dxf.lineSegments[index22],
+            point: Point.from(doorData.drawDoorData.start),
+            index: index22,
+            direct,
+            sure: true
+          });
+          return [point];
+        }
+      }
+      return [];
+    });
+    const excludeIndexMap = /* @__PURE__ */ new Map();
+    this.resultList.flatMap((p) => {
+      const line0 = this.lineSegmentList[p.sourceIndex], line1 = this.lineSegmentList[p.targetIndex], start0 = line1.projectPoint(line0.start), end0 = line1.projectPoint(line0.end), start1 = line0.projectPoint(line1.start), end1 = line0.projectPoint(line1.end), mode0 = start0 && end0 ? -1 : start0 ? 0 : end0 ? 1 : -1, mode1 = start1 && end1 ? -1 : start1 ? 0 : end1 ? 1 : -1;
+      if (excludeIndexMap.has(p.sourceIndex)) {
+        if (excludeIndexMap.get(p.sourceIndex) != mode0) excludeIndexMap.set(p.sourceIndex, -1);
+      } else excludeIndexMap.set(p.sourceIndex, mode0);
+      if (excludeIndexMap.has(p.targetIndex)) {
+        if (excludeIndexMap.get(p.targetIndex) != mode1) excludeIndexMap.set(p.targetIndex, -1);
+      } else excludeIndexMap.set(p.targetIndex, mode1);
+    });
+    dxf.lineSegments.forEach((line, i) => {
+      if (line.userData?.isDoor) return;
+      const excludeMode = excludeIndexMap.get(i);
+      if (excludeMode === -1) return;
+      line.points.forEach((p, j) => {
+        if (excludeMode === j) return;
+        if (excludePoints.find((p1) => p1.equal(p))) return;
+        const res = this.pointVirtualGrid.queryPoint(p).filter((d) => d.userData?.index !== i);
+        if (res.length === 0) {
+          doorPoints.push({
+            line,
+            point: p,
+            index: i
+          });
+        }
+      });
+    });
+    function searchNearby({ point, line, index: index2 }, doorIndex, record2) {
+      const direct = line.direction();
+      if (line.start === point) direct.multiplyScalar(-1);
+      const res = pointVirtualGrid.queryCircle(point, doorSearchDistance).filter(
+        (r) => (
+          // 不能是自己
+          r.userData?.index !== index2 && // 存在于可疑点位内，且不能是已知门的点位
+          !!doorPoints.find((p) => !p.sure && p.point === r.point)
+        )
+      ).sort((a, b) => a.point.distance(point) - b.point.distance(point));
+      const list = [];
+      for (let i = 0; i < res.length; i++) {
+        const doorIndex2 = doorPoints.findIndex((p) => p.point === res[i].point);
+        if (record2.has(`${doorIndex}.${doorIndex2}`)) continue;
+        record2.add(`${doorIndex}.${doorIndex2}`);
+        record2.add(`${doorIndex2}.${doorIndex}`);
+        const targetPoint = res[i].point, line2 = new LineSegment(point.clone(), targetPoint.clone()), angle = line2.direction().angleBetween(direct, "angle");
+        if (angle < doorSearchNearAngle) {
+          const direct2 = doorPoints[doorIndex2].line.direction();
+          const line22 = dxf.lineSegments[res[i].userData?.index];
+          if (line22.start.equal(res[i].point)) direct2.multiplyScalar(-1);
+          const angle2 = line2.direction().multiplyScalar(-1).angleBetween(direct2, "angle");
+          if (angle2 < doorSearchNearAngle) {
+            if (!quadtree.queryLineSegment(line2).length) {
+              list.push({
+                findData: res[i],
+                findDoorIndex: doorIndex2,
+                findAngle: angle2,
+                doorAngle: angle,
+                doorLine: line2,
+                doorIndex
+              });
+            }
+          }
+        }
+      }
+      return list;
+    }
+    function searchAlongDirection({ point, line }) {
+      const direct = line.direction();
+      if (line.start === point) direct.multiplyScalar(-1);
+      const endPoint = point.clone().add(direct.clone().multiplyScalar(doorSearchDistance)), rline = new LineSegment(point.clone(), endPoint), result = quadtree.queryLineSegment(rline).map((l) => {
+        const res = l.line.getIntersection(rline);
+        return {
+          point: res,
+          line: l.line
+        };
+      }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
+      if (result.length) {
+        const item = result[0];
+        if (Math.abs(90 - item.line.direction().angleBetween(direct, "angle")) < 5) {
+          return item;
+        }
+      }
+    }
+    function searchAlongNormalDirection({ point, line, index: index2 }) {
+      const direct = line.direction();
+      if (line.start === point) direct.multiplyScalar(-1);
+      const normal = line.start.normal(line.end);
+      const prePoint = line.start.clone();
+      if (line.start === point) prePoint.copy(line.end);
+      const result = pointVirtualGrid.queryPoint(prePoint).filter((r) => r.userData?.index !== index2);
+      for (let i = 0; i < result.length; i++) {
+        const element = result[i];
+        const l = dxf.lineSegments[element.userData?.index ?? 0];
+        const d1 = l.direction();
+        if (l.start === element.point) direct.multiplyScalar(-1);
+        const angle = d1.angleBetween(normal) / (Math.PI / 180);
+        if (angle > 90) {
+          normal.multiplyScalar(-1);
+          break;
+        }
+      }
+      const rline3 = new LineSegment(point.clone(), point.clone().add(normal.multiplyScalar(doorSearchDistance)));
+      const r3 = quadtree.queryLineSegment(rline3).map((l) => {
+        const res = l.line.getIntersection(rline3);
+        return {
+          point: res,
+          line: l.line
+        };
+      }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
+      if (r3.length) {
+        const item = r3[0];
+        if (Math.abs(90 - item.line.direction().angleBetween(normal, "angle")) < 5) {
+          return item;
+        }
+      }
+    }
+    function deepSearchNearHandle(index2, snFindRecord2, list, record2, other) {
+      record2.add(`${index2}`);
+      const newList = [];
+      if (other) newList.push(other);
+      for (let i = 0; i < list.length; i++) {
+        const item = list[i];
+        if (snFindRecord2.has(item.findDoorIndex)) {
+          const list2 = snFindRecord2.get(item.findDoorIndex);
+          if (deepSearchNearHandle(item.findDoorIndex, snFindRecord2, list2, record2, item)) newList.push(item);
+        } else newList.push(item);
+      }
+      newList.sort((a, b) => a.doorLine.length() - b.doorLine.length());
+      if (other && newList[0] === other) {
+        list.splice(0);
+        return true;
+      }
+      list.splice(1);
+      return false;
+    }
+    const record = /* @__PURE__ */ new Set();
+    const snFindRecord = /* @__PURE__ */ new Map();
+    doorPoints.map((p, index2) => {
+      if (dxf.doors.length >= 2 && !p.sure) return;
+      const list = searchNearby(p, index2, record);
+      if (list.length) snFindRecord.set(index2, list);
+    });
+    record.clear();
+    const temMap = /* @__PURE__ */ new Map();
+    snFindRecord.forEach((list, key) => {
+      if (!record.has(`${key}`) && list.length) {
+        deepSearchNearHandle(key, snFindRecord, list, record);
+      }
+      if (list.length) {
+        const item = list[0];
+        if (!temMap.has(item.doorIndex)) temMap.set(item.doorIndex, []);
+        temMap.get(item.doorIndex)?.push(item);
+        if (!temMap.has(item.findDoorIndex)) temMap.set(item.findDoorIndex, []);
+        temMap.get(item.findDoorIndex)?.push(item);
+      }
+    });
+    const deleteSet = /* @__PURE__ */ new Set();
+    temMap.forEach((list) => {
+      if (list.length > 1) {
+        list.sort((a, b) => a.doorLine.length() - b.doorLine.length());
+        for (let i = 1; i < list.length; i++) deleteSet.add(list[i]);
+      }
+    });
+    const searchNearRasult = [], removeDoorPointsIndex = [];
+    snFindRecord.forEach((list) => {
+      if (list.length) {
+        const item = list[0];
+        if (!deleteSet.has(item)) {
+          searchNearRasult.push(item);
+          removeDoorPointsIndex.push(item.doorIndex, item.findDoorIndex);
+        }
+      }
+    });
+    const doors_ = doorPoints.map((item, index2) => {
+      if (removeDoorPointsIndex.includes(index2)) return;
+      if (dxf.doors.length >= 2 && !item.sure) return;
+      const res2 = searchAlongDirection(item);
+      if (res2) return {
+        start: item.point,
+        end: res2.point,
+        index: item.index
+      };
+      const res3 = searchAlongNormalDirection(item);
+      if (res3) return {
+        start: item.point,
+        end: res3.point,
+        index: item.index
+      };
+    }).filter((i) => !!i && i.start.distance(i.end) < doorSearchDistance);
+    doors.push(...doors_);
+    searchNearRasult.forEach((item) => {
+      doors.push({
+        start: doorPoints[item.doorIndex].point,
+        end: doorPoints[item.findDoorIndex].point,
+        index: doorPoints[item.doorIndex].index
+      });
+    });
+    dxf.doorLineSegment.length = 0;
+    doors.forEach((p) => dxf.doorLineSegment.push(new LineSegment(p?.start, p?.end)));
+    dxf.doorLineSegment = dxf.doorLineSegment.filter((i) => {
+      const len = i.length();
+      if (len < 0.4) return false;
+      if (len > 1.2) {
+        this.addData(i.start.clone(), i.end.clone());
+      }
+      return true;
+    });
+  }
 }
 class DxfSystem extends ComponentManager {
   Dxf;
@@ -2012,11 +2467,10 @@ class WhiteModel extends Component {
         depth: 2.8,
         bevelSize: 0
       });
-      const mesh = new THREE.Mesh(geometry);
-      mesh.material = this.material;
+      const mesh = new THREE.Mesh(geometry, this.material);
       this.whiteModelGroup.add(mesh);
       this.whiteModelLineGroup.add(
-        new THREE.LineSegments(new THREE.EdgesGeometry(geometry), new THREE.LineBasicMaterial({ color: 6710886 }))
+        new THREE.LineSegments(new THREE.EdgesGeometry(geometry), new THREE.LineBasicMaterial({ color: 0 }))
       );
     });
     const walls = dxf.originalData.map(({ start, end, insetionArr }) => {
@@ -2049,41 +2503,87 @@ class WhiteModel extends Component {
       whiteModelGroup: this.whiteModelGroup
     });
   }
+  /**
+   * 转为obj
+   * @returns 
+   */
   toOBJ() {
     return new Promise((resolve) => {
-      resolve(exporter.parse(this.whiteModelGroup));
+      this.material.opacity = 1;
+      this.material.needsUpdate = true;
+      setTimeout(() => {
+        resolve(exporter.parse(this.whiteModelGroup));
+        this.material.opacity = 0.8;
+        this.material.transparent = true;
+      }, 20);
     });
   }
-  toGlb() {
+  /**
+   * 转为 glb
+   * @param binary 
+   * @returns 
+   */
+  toGltf(binary = true) {
     return new Promise((resolve) => {
       this.material.opacity = 1;
       this.material.needsUpdate = true;
-      setTimeout(() => {
-        glbExporter.parse(this.whiteModelGroup.children, (gltf) => {
-          resolve(gltf);
-          this.material.opacity = 0.8;
-          this.material.transparent = true;
-        }, () => {
-          resolve(void 0);
-        }, {
-          binary: true
-        });
-      }, 100);
+      setTimeout(async () => {
+        if (typeof window === "object") {
+          glbExporter.parse(this.whiteModelGroup.children, (gltf) => {
+            resolve(gltf);
+            this.material.opacity = 0.8;
+            this.material.transparent = true;
+          }, () => {
+            resolve(void 0);
+          }, {
+            binary
+          });
+        } else if (typeof global !== "function") {
+          try {
+            const obj2gltf = await include("obj2gltf", true);
+            const fs = await include("fs", false);
+            const obj = await this.toOBJ();
+            fs.writeFileSync(this.uuid, obj);
+            const result = await obj2gltf(this.uuid, {
+              binary
+            });
+            fs.unlinkSync(this.uuid);
+            if (binary) resolve(result);
+            else resolve(JSON.stringify(result));
+          } catch (error) {
+            resolve(void 0);
+            console.log(error);
+          }
+        }
+      }, 20);
     });
   }
+  /**
+   * 转为 OBJBlob
+   * @returns 
+   */
   async toOBJBlob() {
     const buffer = await this.toOBJ();
     if (buffer) {
       return new Blob([buffer], { type: "application/octet-stream" });
     }
   }
-  async toGlbBlob() {
-    const buffer = await this.toGlb();
+  /**
+   * 转为 GltfBlob
+   * @returns 
+   */
+  async toGltfBlob(binary = true) {
+    const buffer = await this.toGltf(binary);
     if (buffer) {
       return new Blob([buffer], { type: "application/octet-stream" });
     }
   }
-  async download(filename) {
+  /**
+   * 下载 OBJ
+   * @param filename 
+   * @returns 
+   */
+  async downloadOBJ(filename) {
     if (typeof window !== "undefined") {
       const blob = await this.toOBJBlob();
       if (!blob) return;
@@ -2094,32 +2594,29 @@ class WhiteModel extends Component {
     } else if (typeof global !== "undefined") {
       const buffer = await this.toOBJ();
       if (buffer) {
-        const packageName = "fs";
-        const { default: fs } = await import(
-          /* @vite-ignore */
-          packageName
-        );
+        const fs = await include("fs", false);
         fs.writeFileSync(filename, buffer);
       }
     }
   }
-  async downloadGlb(filename) {
+  /**
+   * 下载 Gltf
+   * @param filename 
+   * @returns 
+   */
+  async downloadGltf(filename, binary = true) {
     if (typeof window !== "undefined") {
-      const blob = await this.toGlbBlob();
+      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.toOBJ();
+      const buffer = await this.toGltf(binary);
       if (buffer) {
-        const packageName = "fs";
-        const { default: fs } = await import(
-          /* @vite-ignore */
-          packageName
-        );
-        fs.writeFileSync(filename, buffer);
+        const fs = await include("fs", false);
+        fs.writeFileSync(filename, binary ? buffer : Buffer.from(buffer));
       }
     }
   }
@@ -2236,8 +2733,10 @@ class DxfLineModel extends Component {
     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]));
+    const doorsArray = new Float32Array(
+      dxf.doorLineSegment.flatMap(({ start, end }) => [start.x, start.y, dxf.originalZAverage * 0.99, end.x, end.y, dxf.originalZAverage * 0.99])
+    ).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));
   }
 }