build-dxf 0.0.14 → 0.0.16

package/README.md

@@ -29,7 +29,7 @@ detailsPoint.addEventListener("handleSuccess", () => {
     // 下载白模，obj格式
     whiteModel.downloadOBJ("001.obj")
     // 下载白模，gltf或glb格式, 第二个参数为true时是glb，默认为true
-    whiteModel.downloadGltf("001.obj", true)
+    whiteModel.downloadGltf("001.glb", true)
 
     // desPoints 为射线点集合，根据需要使用
     console.log("handleSuccess", detailsPoint.desPoints)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "线段构建双线墙壁的dxf版本",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

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 
@@ -817,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;
@@ -841,6 +1096,7 @@ class Dxf extends Component {
   pointsGroups = [];
   wallsGroup = [];
   doors = [];
+  doorLineSegment = [];
   lineSegments = [];
   originalZAverage = 0;
   static EndType = {
@@ -869,7 +1125,7 @@ class Dxf extends Component {
     super();
     this.width = width;
     this.scale = scale;
-    this.shortLine = width * 0.8;
+    this.shortLine = width * 0.4;
   }
   /**
    * 设置
@@ -1003,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 检查连续的短线段数量，去除合并后产生的毛刺
    */
@@ -1039,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];
@@ -1092,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) {
@@ -1153,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({
@@ -1179,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
    */
@@ -1186,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();
@@ -1291,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;
   // 包围盒
@@ -1623,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 
@@ -1780,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));
   }
   /**
    * 
@@ -1847,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" });
     });
@@ -1873,6 +2070,7 @@ class LineAnalysis extends Component {
     this.lineSegmentList = lineSegmentList;
   }
   resultList = [];
+  mergeWallLines = [];
   /** 线段分析
    * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
    * @param data 
@@ -1897,7 +2095,7 @@ class LineAnalysis extends Component {
     });
     this.appendLineSegmentList.length = 0;
     resultList.forEach(this.createRectangle.bind(this));
-    this.resultList = [];
+    this.resultList = resultList;
   }
   /** 线段投影分析
    * @param index 
@@ -1929,10 +2127,309 @@ 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() {
+    this.parent?.findComponentByName("Renderer");
+    const dxf = this.Dxf, doorPoints = [], pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree, doorSearchNearAngle = this.doorSearchNearAngle, doorSearchDistance = this.doorSearchDistance, 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, i) => {
+      const start = doorPoints[item.doorIndex].point.clone();
+      const end = doorPoints[item.findDoorIndex].point.clone();
+      const startLine = this.findLongLineSegment(doorPoints[item.doorIndex].line);
+      const endLine = this.findLongLineSegment(doorPoints[item.findDoorIndex].line);
+      const p = startLine.projectPoint(end);
+      if (p) {
+        start.copy(p);
+        const l = new LineSegment(start, end);
+        const angle = endLine.includedAngle(l);
+        if (angle < 10 || angle > 170 || Math.abs(90 - angle) < 10) {
+          doors.push({
+            start,
+            end,
+            index: doorPoints[item.doorIndex].index
+          });
+        }
+      } else {
+        const p2 = endLine.projectPoint(start);
+        if (p2) end.copy(p2);
+        const l = new LineSegment(start, end);
+        const angle = startLine.includedAngle(l);
+        if (angle < 10 || angle > 170 || Math.abs(90 - angle) < 10) {
+          doors.push({
+            start,
+            end,
+            index: doorPoints[item.doorIndex].index
+          });
+        }
+      }
+    });
+    dxf.doorLineSegment.length = 0;
+    doors.forEach((p) => {
+      const line = new LineSegment(p?.start, p?.end);
+      const len = line.length();
+      if (len < 0.4) return;
+      const center = line.center, normal = line.normal();
+      const rLine = new LineSegment(
+        center.clone(),
+        center.clone().add(normal.clone().multiplyScalar(1))
+      );
+      rLine.directionMove(normal, -0.5);
+      const res = this.quadtree?.queryLineSegment(rLine);
+      if (res?.length) return;
+      dxf.doorLineSegment.push(line);
+    });
+  }
+  findLongLineSegment(line) {
+    const resLine = line.clone();
+    const res1 = this.pointVirtualGrid.queryPoint(line.start);
+    const res2 = this.pointVirtualGrid.queryPoint(line.end);
+    for (let i = 0; i < res1.length; i++) {
+      const { userData } = res1[i];
+      const line2 = this.lineSegmentList[userData?.index];
+      if (line2 === line) continue;
+      if (line2 && line2.directionEqual(line)) {
+        if (line2.start.equal(line.start)) resLine.start.copy(line2.end);
+        else resLine.start.copy(line2.start);
+        break;
+      }
+    }
+    for (let i = 0; i < res2.length; i++) {
+      const { userData } = res2[i];
+      const line2 = this.lineSegmentList[userData?.index];
+      if (line2 === line) continue;
+      if (line2 && line2.directionEqual(line)) {
+        if (line2.end.equal(line.end)) resLine.end.copy(line2.start);
+        else resLine.end.copy(line2.end);
+        break;
+      }
+    }
+    return resLine;
+  }
 }
 class DxfSystem extends ComponentManager {
   Dxf;
@@ -2286,8 +2783,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));
   }
 }

package/src/index2.js

@@ -7127,7 +7127,7 @@ class ModelDataRender extends Component {
           group.clear();
           dxf.wallsGroup.forEach((path, j) => {
             path.forEach((p, i) => {
-              renderer.createText(`${i}`, p, { color: "#ff00ff", fontSize: "10px" }, group).position.z = dxf.originalZAverage * 0.99;
+              renderer.createText(`${j}-${i}`, p, { color: "#ff00ff", fontSize: "10px" }, group).position.z = dxf.originalZAverage * 0.99;
             });
           });
         }

package/src/utils/DxfSystem/components/Dxf.d.ts

@@ -23,6 +23,18 @@ export interface OriginalDataItem {
         };
     }[];
     isDoor?: boolean;
+    drawDoorData?: {
+        start: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        n: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
 }
 /**
  * [开始点, 结束点, 相交点, 是否是门, 索引]
@@ -61,6 +73,7 @@ export declare class Dxf extends Component<{
     pointsGroups: Point[][][];
     wallsGroup: Point[][];
     doors: DataItem[];
+    doorLineSegment: LineSegment[];
     lineSegments: LineSegment<{
         isDoor: boolean;
     }>[];
@@ -108,18 +121,16 @@ export declare class Dxf extends Component<{
      * @description 处理线路拓扑，使线路有序链接，形成长路径
      * @param lines
      */
-    private lineTopology;
+    lineTopology(lines: Point[][]): Point[][];
+    /** 合并方向相同的线段
+     * @param lines
+     * @param errAngle
+     */
+    private mergeSameDirectionLine;
     /** etOpenRound 去除毛刺
      * @description 检查连续的短线段数量，去除合并后产生的毛刺
      */
     private squareRemoveBurr;
-    epsilon: number;
-    /**
-     * 移除共线点
-     * @param path
-     * @returns
-     */
-    removeCollinearPoints(path: Point[]): Point[];
     /**
      * 线段矫直, 线段中心突刺
      * @description 突变长度小于墙体宽度，该线段可能为突起线段，
@@ -128,6 +139,7 @@ export declare class Dxf extends Component<{
     lineSegmentStraightening(path: Point[]): Point[];
     /**
      * 移除短线段
+     * @todo 根据线段两端线段长度，选取参照物_|▔▔
      * @param path
      */
     removeShortLine(path: Point[], shortLine?: number): Point[];
@@ -139,6 +151,13 @@ export declare class Dxf extends Component<{
      * 将点云结构转换为Float32Array
      */
     to3DArray(scale: number): Float32Array<ArrayBuffer>;
+    /** 获取角度范围
+     * @param center
+     * @param p1
+     * @param p2
+     * @returns
+     */
+    private getArcAngleRange;
     /**
      * 将点云结构转换为string
      */

package/src/utils/DxfSystem/components/LineAnalysis.d.ts

@@ -64,6 +64,7 @@ export declare class LineAnalysis extends Component {
      */
     buildQuadtree(): void;
     resultList: ProjectionAnalysisResult[];
+    mergeWallLines: LineSegment[][];
     /** 线段分析
      * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
      * @param data
@@ -76,5 +77,13 @@ export declare class LineAnalysis extends Component {
      * @returns
      */
     private projectionAnalysis;
+    doorSearchNearAngle: number;
+    doorSearchDistance: number;
+    doors: LineSegment[];
+    /**
+     * 门的位置判断
+     */
+    doorsAnalysis(): void;
+    findLongLineSegment(line: LineSegment): LineSegment<Record<string, any>>;
 }
 export {};

package/src/utils/Quadtree/LineSegment.d.ts

@@ -1,4 +1,5 @@
 import { Point } from './Point';
+import { Rectangle } from './Rectangle';
 /**
  * 非轴对称线段
  */
@@ -9,6 +10,33 @@ export declare class LineSegment<T = Record<string, any>> {
     get start(): Point;
     get end(): Point;
     constructor(p1?: Point, p2?: Point);
+    /** 膨胀
+     * @description 向线段的两个端点分别膨胀 width
+     * @param width
+     */
+    expansion(width: number, direction?: "start" | "end" | "all"): this;
+    /** 向前
+     * @description 向前移动 width
+     * @param width
+     */
+    forward(width: number): this;
+    /** 向前
+     * @description 向前移动 width
+     * @param width
+     */
+    backward(width: number): this;
+    /**
+     * 向指定方向平移
+     * @param direct
+     * @param size
+     */
+    directionMove(direct: Point, size: number): this;
+    /** 膨胀为矩形
+     *
+     * @param width
+     * @returns {Rectangle}
+     */
+    expandToRectangle(width?: number): Rectangle;
     /**
      * 计算线段的长度
      * @returns 线段的长度
@@ -19,6 +47,10 @@ export declare class LineSegment<T = Record<string, any>> {
      * @returns
      */
     direction(): Point;
+    /**
+     * 获取发向量
+     */
+    normal(): Point;
     /**
      * 线段长度
      * @returns
@@ -30,6 +62,12 @@ export declare class LineSegment<T = Record<string, any>> {
      * @returns 投影并裁剪后的线段
      */
     projectLineSegment(line: LineSegment): LineSegment;
+    /**
+     * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
+     * @param line 要投影的线段
+     * @returns 投影并裁剪后的线段
+     */
+    projectPoint(p1: Point): Point | null;
     /**
      * 判断线段是与线段相交
      * @param line

package/src/utils/Quadtree/Point.d.ts

@@ -89,13 +89,20 @@ export declare class Point {
      * @returns
      */
     dot(point: Point): number;
+    /** 求两个点叉积
+     * @description 如果叉积大于 0，a 到 b 为逆时针方向。
+     * @description 如果叉积小于 0，a 到 b 为顺时针方向。
+     * @param point
+     * @returns
+     */
+    cross(point: Point): number;
     /** 计算两个向量夹角
      * @description 公式：a · b = |a| × |b| × cosθ
      * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
      * @param point
      * @returns
      */
-    angleBetween(point: Point): number;
+    angleBetween(point: Point, type?: 'radian' | 'cos' | 'angle', angle?: "180" | "360"): number;
     /** 获取向量长度
      */
     length(): number;

package/src/utils/Quadtree/Quadtree.d.ts

@@ -50,6 +50,12 @@ export declare class Quadtree<T = any> {
      * @returns 相交的节点数组
      */
     queryRect(rectangle: Rectangle): QuadtreeNode<T>[];
+    /**
+     * 查询与线段相交的线段节点
+     * @param lineSegment 线段
+     * @returns 相交的节点数组
+     */
+    queryLineSegment(lineSegment: LineSegment): QuadtreeNode<T>[];
     /**
      * 包围盒转换为数组
      * @param array

package/src/utils/Quadtree/Rectangle.d.ts

@@ -7,6 +7,7 @@ import { Point } from './Point';
 export declare class Rectangle {
     points: Point[];
     get path(): number[];
+    path2D(callback?: (point1: Point, point2: Point) => void): number[];
     constructor(points: Point[]);
     /**
      * 判断线段是否与矩形相交