build-dxf 0.1.126 → 0.1.127

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.1.126",
+  "version": "0.1.127",
   "description": "",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/build.js

@@ -684,54 +684,71 @@ class PointSpatialHash {
     }
     return null;
   }
-  /** 通过点，从近到远辐射查找，同一格子，不保证远近
-   * 返回第一个满足条件的目标
+  /** 通过点，从近到远按圈层搜索
+   * 同一圈内不保证距离顺序
+   * 返回第一个满足条件的圈层
    */
-  nearestSearch(point2, fn2, maxRing = 1e3) {
+  searchByRing(point2, fn2, maxRing = 1e3) {
+    let gridCount = this.map.size;
     const centerI = Math.floor(point2.x / this.gridSize);
     const centerJ = Math.floor(point2.y / this.gridSize);
-    const set2 = this.map.get(this.getGridId(centerI, centerJ));
-    if (set2) {
+    const currentCircle = [];
+    const appendGrid = (i, j) => {
+      const set2 = this.map.get(this.getGridId(i, j));
+      if (!set2) return;
+      gridCount--;
       for (const target of set2) {
-        if (fn2(target)) return target;
+        currentCircle.push({
+          point: target.point,
+          userData: target.userData,
+          distanceSq: point2.distanceSquared(target.point)
+        });
       }
+    };
+    appendGrid(centerI, centerJ);
+    if (fn2(currentCircle, 0)) {
+      return currentCircle;
     }
+    if (gridCount === 0) return null;
     for (let r2 = 1; r2 <= maxRing; r2++) {
+      currentCircle.length = 0;
       const minI = centerI - r2;
       const maxI = centerI + r2;
       const minJ = centerJ - r2;
       const maxJ = centerJ + r2;
       for (let i = minI; i <= maxI; i++) {
-        let set22 = this.map.get(this.getGridId(i, minJ));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
-        set22 = this.map.get(this.getGridId(i, maxJ));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
+        appendGrid(i, minJ);
+        appendGrid(i, maxJ);
       }
       for (let j = minJ + 1; j < maxJ; j++) {
-        let set22 = this.map.get(this.getGridId(minI, j));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
-        set22 = this.map.get(this.getGridId(maxI, j));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
+        appendGrid(minI, j);
+        appendGrid(maxI, j);
+      }
+      if (fn2(currentCircle, r2)) {
+        return currentCircle;
       }
+      if (gridCount === 0) return null;
     }
     return null;
   }
+  /** 
+   * @param point 
+   * @param excludeSelf 
+   * @returns 
+   */
+  findNearest(point2, excludeSelf = true) {
+    let nearest = null;
+    this.searchByRing(point2, (circle) => {
+      for (const item of circle) {
+        if (excludeSelf && item.point === point2) continue;
+        if (!nearest || item.distanceSq < nearest.distanceSq) {
+          nearest = item;
+        }
+      }
+      return nearest !== null;
+    });
+    return nearest;
+  }
   /** 
    * @param point 
    */
@@ -11080,7 +11097,7 @@ function innerWallLine(lines, trajectory2) {
   lud.forEachPathLine((start, end, line, index2, endType, indxeList) => {
     temLine.start.copy(start);
     temLine.end.copy(end);
-    const wallWidth = line.userData.wallWidth ?? DEFAULT_WALL_WIDTH;
+    const wallWidth = DEFAULT_WALL_WIDTH;
     wallWidths[index2] = wallWidth;
     const hw = indxeList.length ? Math.max(...indxeList.map((i) => wallWidths[i])) * 0.5 : wallWidth * 0.5;
     if (index2 !== 0) {

package/src/utils/algorithms/PointSpatialHash.d.ts

@@ -10,6 +10,11 @@ type Target<T> = {
 type NodeSet<T> = Set<Target<T>>;
 export type PvgTarget<T> = Target<T>;
 export type ResultList<T = any> = Array<Target<T>>;
+export type CircleResult<T = any> = {
+    point: Point;
+    distanceSq: number;
+    userData?: T;
+};
 export declare class PointSpatialHash<T = Record<string, any>> {
     map: Map<string, NodeSet<T>>;
     gridSize: number;
@@ -109,10 +114,17 @@ export declare class PointSpatialHash<T = Record<string, any>> {
         point: Point;
         userData: T;
     } | null;
-    /** 通过点，从近到远辐射查找，同一格子，不保证远近
-     * 返回第一个满足条件的目标
+    /** 通过点，从近到远按圈层搜索
+     * 同一圈内不保证距离顺序
+     * 返回第一个满足条件的圈层
+     */
+    searchByRing(point: Point, fn: (circle: CircleResult<T>[], circleNum: number) => boolean, maxRing?: number): CircleResult<T>[] | null;
+    /**
+     * @param point
+     * @param excludeSelf
+     * @returns
      */
-    nearestSearch(point: Point, fn: (target: Target<T>) => boolean, maxRing?: number): Target<T> | null;
+    findNearest(point: Point, excludeSelf?: boolean): CircleResult<T> | null;
     /**
      * @param point
      */