build-dxf 0.0.5 → 0.0.7

package/README.md

@@ -7,10 +7,16 @@ npm i build-dxf
 
 # 使用 
 ```typescript
+
 import { DxfSystem } from "build-dxf"
 
+/**
+ * json 文件格式为{ start: {x: number, y: number}, end: {x: number, y: number } , insetionArr: {index: number}[] }[]
+ */
+const path = process.argv[2] ?? "./json/d7.json"
 const dxfSystem = new DxfSystem()
-dxfSystem.Dxf.set(data)
-dxfSystem.Dxf.lineOffset()
-dxfSystem.Dxf.download("01.dxf")
+dxfSystem.Dxf.set(path).then(()=> {
+    dxfSystem.Dxf.lineOffset()
+    dxfSystem.Dxf.download("01.dxf")
+})
 ```

package/package.json

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

package/src/index.d.ts

@@ -10,6 +10,12 @@ declare class Box2 {
     get height(): number;
     get center(): Point;
     constructor(minX?: number, maxX?: number, minY?: number, maxY?: number);
+    /**
+     *
+     * @param z
+     * @returns
+     */
+    getPaths3D(z?: number): number[];
     /**
      * 判断线段是与包围盒相交
      * @description Liang-Barsky算法的变种
@@ -41,6 +47,10 @@ declare class Box2 {
      * @param box
      */
     containsBox(box: Box2): boolean;
+    /** 判断点是在包围盒内
+     * @param point
+     */
+    containsPoint(point: Point): boolean;
     /**
      *
      * @param minX
@@ -340,6 +350,7 @@ declare class Point {
      * @param y
      */
     constructor(x?: number, y?: number);
+    set(x: number, y: number): this;
     setX(x: number): this;
     setY(y: number): this;
     /**
@@ -362,6 +373,7 @@ declare class Point {
      * @param scalar
      */
     mutiplyScalar(scalar: number): this;
+    multiplyScalar(scalar: number): this;
     /**
      *
      * @param scalar
@@ -401,7 +413,7 @@ declare class Point {
      */
     normal(point: Point): Point;
     /**
-     * 获取单位方向向量
+     * 获取由传入的点到该点的单位方向向量
      * @description 计算当前点到指定点的方向向量，并返回单位方向
      * @param point
      * @returns
@@ -460,6 +472,16 @@ declare class Rectangle {
      * @returns 是否完全在矩形内部
      */
     containsLineSegment(line: LineSegment): boolean;
+    /**
+     * 判断点是否完全位于矩形内部
+     * @param point
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     *
+     * @returns
+     */
+    toBox(): Box2;
     /**
      *
      * @param line

package/src/index.js

@@ -12545,6 +12545,11 @@ class Point {
     this.x = x;
     this.y = y;
   }
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
   setX(x) {
     this.x = x;
     return this;
@@ -12585,6 +12590,11 @@ class Point {
     this.y *= scalar;
     return this;
   }
+  multiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
+  }
   /**
    * 
    * @param scalar 
@@ -12653,7 +12663,7 @@ class Point {
     return new Point(nx, ny);
   }
   /**
-   * 获取单位方向向量
+   * 获取由传入的点到该点的单位方向向量
    * @description 计算当前点到指定点的方向向量，并返回单位方向
    * @param point 
    * @returns 
@@ -12764,6 +12774,20 @@ class Box2 {
     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算法的变种
@@ -12891,6 +12915,12 @@ class Box2 {
   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 
@@ -13519,6 +13549,37 @@ class Rectangle {
     };
     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 
@@ -13719,8 +13780,7 @@ class Quadtree {
    */
   queryRect(rectangle) {
     const result = [];
-    const rectBox = Box2.fromByPoints(...rectangle.points);
-    if (!this.bounds.intersectBox(rectBox)) {
+    if (!this.bounds.intersectRectangle(rectangle)) {
       return result;
     }
     for (const node of this.nodes) {
@@ -13754,17 +13814,135 @@ class Quadtree {
     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 {
   Dxf = null;
   Variable = null;
   lineSegmentList = [];
   container = new Group();
-  showQuadtreeGrid = false;
-  showLineInfo = false;
-  showProjectLineInfo = false;
-  showSearchRectangle = false;
   // 误差角度
   errorAngle = 4;
+  width = 0.4;
   /**
    * 
    * @param parent 
@@ -13781,16 +13959,25 @@ class LineAnalysis extends Component {
    */
   duplicatePointFiltering() {
     const dxf = this.Dxf;
-    dxf.wallsGroup = dxf.wallsGroup.filter((i) => i.length >= 4);
     dxf.wallsGroup = dxf.wallsGroup.map((points) => {
       const filterPoints = [];
       points.forEach((point, index) => {
         if (index < 1 || points.length - 1 === index) return filterPoints.push(point);
         const preP = points[index - 1], nextP = points[index + 1], direct1 = point.direction(preP), direct2 = nextP.direction(point), angle = direct1.angleBetween(direct2) / (Math.PI / 180);
-        if (angle > 0.2 && angle < 180 - 0.2) filterPoints.push(point);
+        if (angle > 0.02 && angle < 180 - 0.02) filterPoints.push(point);
       });
-      return filterPoints;
+      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) {
+          console.log(111);
+        }
+        points.push(point);
+      }
+      return points;
     });
+    dxf.wallsGroup = dxf.wallsGroup.filter((i) => i.length >= 4);
   }
   /**
    * 
@@ -13818,29 +14005,50 @@ class LineAnalysis extends Component {
       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 pl0 = result.source.projectLineSegment(result.project);
-    dxf.data.push([pl0.points[0].clone(), result.project.points[0].clone(), [], false, dxf.data.length]);
-    dxf.data.push([pl0.points[1].clone(), result.project.points[1].clone(), [], false, dxf.data.length]);
-    const direct = pl0.points[0].direction(result.project.points[0]);
-    const distance = Math.min(
-      result.project.points[0].distance(pl0.points[0]),
-      result.project.points[1].distance(pl0.points[1])
-    );
-    const count = Math.ceil(distance / dxf.width);
-    const fragment = distance / count;
-    for (let i = 1; i <= count; i++) {
-      const incrementP = direct.clone().mutiplyScalar(fragment * i), p1 = result.project.points[0].clone().add(incrementP), p2 = result.project.points[1].clone().add(incrementP);
-      const temDirect = p2.direction(p1).mutiplyScalar(dxf.width);
-      p2.division(temDirect);
-      p1.division(temDirect.mutiplyScalar(-1));
-      dxf.data.push([p1, p2, [], false, dxf.data.length]);
+    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, index) => {
+      const [p1, p2] = [Point.from(d.start), Point.from(d.end)];
+      pointVirtualGrid.insert(p1, { index, type: "start" });
+      pointVirtualGrid.insert(p2, { index, type: "end" });
+    });
+    this.pointVirtualGrid = pointVirtualGrid;
+  }
   quadtree;
   /**
    * 构建线段四叉树，快速查找，
@@ -13848,7 +14056,7 @@ class LineAnalysis extends Component {
   buildQuadtree() {
     const dxf = this.Dxf;
     const lineSegmentList = [];
-    this.quadtree = new Quadtree(new Box2(-20, 20, -20, 20), 2);
+    this.quadtree = new Quadtree(dxf.originalBox, 2);
     dxf.originalData.forEach((d) => {
       if (d.isDoor) return;
       const lineSegment = new LineSegment(Point.from(d.start), Point.from(d.end));
@@ -13867,11 +14075,12 @@ class LineAnalysis extends Component {
    */
   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, 0.4 * 2, true, -0.01), ids = quadtree.queryRect(rectangle).map((i2) => i2.userData).filter((index) => index !== i);
+      const sourceLineSegment = lineSegmentList[i], rectangle = Rectangle.fromByLineSegment(sourceLineSegment, this.width * 2, false, -0.01), ids = quadtree.queryRect(rectangle).map((i2) => i2.userData).filter((index) => index !== i);
       ids.forEach((id) => {
         try {
           if (visited.has(`${i}-${id}`) || visited.has(`${id}-${i}`)) return;
@@ -13879,10 +14088,10 @@ class LineAnalysis extends Component {
           if (res) resultList.push(res);
           visited.add(`${i}-${id}`);
         } catch (error) {
-          console.log(error);
         }
       });
     });
+    this.appendLineSegmentList.length = 0;
     resultList.forEach(this.createRectangle.bind(this));
     this.resultList = [];
   }
@@ -13896,13 +14105,18 @@ class LineAnalysis extends Component {
     const temLineSegment = lineSegmentList[index], direct = sourceLineSegment.direction(), temDirect = temLineSegment.direction(), angle = direct.angleBetween(temDirect) / (Math.PI / 180);
     if (angle < this.errorAngle || angle > 180 - this.errorAngle) {
       let data;
-      if (temLineSegment.getLength() > sourceLineSegment.getLength()) {
+      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: index,
           source: sourceLineSegment,
           sourceIndex,
-          project: temLineSegment.projectLineSegment(sourceLineSegment)
+          project: p1,
+          project2: p2
         };
       } else {
         data = {
@@ -13910,10 +14124,11 @@ class LineAnalysis extends Component {
           targetIndex: sourceIndex,
           source: temLineSegment,
           sourceIndex: index,
-          project: sourceLineSegment.projectLineSegment(temLineSegment)
+          project: p2,
+          project2: p1
         };
       }
-      if (!data || data.project.getLength() < 1e-3) return;
+      if (!data || data.project.getLength() < 0.01) return;
       return data;
     }
   }