build-dxf 0.1.48 → 0.1.50

package/package.json

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

package/src/DomEventRegister.js

@@ -1230,12 +1230,12 @@ class DomEventRegister extends Component {
     const click = (e) => {
       if (lock) return;
       lock = true;
+      setTimeout(() => lock = false, 200);
       let rect = domElement.getBoundingClientRect();
       const { offsetX, offsetY } = this.computedPosition(e, rect);
       if (!this.pointInDOMRect(offsetX, offsetY, rect)) return;
       this.pointer.set(offsetX, offsetY);
       this.dispatchEvent({ type: "click", x: offsetX, y: offsetY });
-      setTimeout(() => lock = false, 100);
     };
     document.addEventListener("click", click);
     this.addEventRecord("destory", () => {

package/src/build.js

@@ -946,6 +946,13 @@ class MapEnhance extends Map {
     }
     return result;
   }
+  filterKey(callbackfn) {
+    const result = [];
+    for (const [k, v2] of this) {
+      callbackfn(v2, k) && result.push(k);
+    }
+    return result;
+  }
   reduce(callbackfn, result) {
     for (const [k, v2] of this) {
       result = callbackfn(result, v2, k);
@@ -1023,7 +1030,7 @@ class ArrayMap extends MapEnhance {
       const list = this.get(k);
       list.push(v2);
       if (list.length > this.maxLength) {
-        list.splice(0, this.maxLength - list.length);
+        list.splice(0, list.length - this.maxLength);
       }
     });
     return this;
@@ -1060,12 +1067,20 @@ class SetMap extends MapEnhance {
     return this.get(key)?.has(value) ?? false;
   }
 }
-class CountMap extends MapEnhance {
-  set(key) {
-    let count = super.get(key) ?? 0;
-    super.set(key, ++count);
+class CounterMap extends MapEnhance {
+  set(key, step = 1) {
+    console.warn("Use increment() instead of set() in CounterMap");
+    this.increment(key, step);
+    return this;
+  }
+  increment(key, step = 1) {
+    const count = super.get(key) ?? 0;
+    super.set(key, count + step);
     return this;
   }
+  getByCount(count) {
+    return this.filterKey((v2) => v2 === count);
+  }
 }
 class UnionFindSet {
   parent;
@@ -1148,7 +1163,11 @@ function addLengthAsyncClear(line) {
   });
   set$1.add(line);
 }
+const LINE_SYMBOL = Symbol("LINE_SYMBOL");
 class LineSegment {
+  static get LINE_SYMBOL() {
+    return LINE_SYMBOL;
+  }
   points = [new Point(), new Point()];
   userData = {};
   currentData = {};
@@ -1166,8 +1185,10 @@ class LineSegment {
   get end() {
     return this.points[1];
   }
-  constructor(p1 = new Point(), p2 = new Point()) {
-    this.points = [p1, p2];
+  constructor(p1, p2) {
+    this.set(p1 ?? this.start, p2 ?? this.end);
+    this.start.currentData[LineSegment.LINE_SYMBOL] = this;
+    this.end.currentData[LineSegment.LINE_SYMBOL] = this;
   }
   set(p1, p2) {
     this.start.copy(p1);
@@ -1731,6 +1752,13 @@ class LineSegment {
     this.start.copy(line.start);
     this.end.copy(line.end);
   }
+  /** 获取点属于的线段
+   * @param point 
+   * @returns 
+   */
+  static getPointBelongLine(point2) {
+    return point2.currentData[LINE_SYMBOL] ?? null;
+  }
   /**
    * 获取最长线段
    * @param lines 
@@ -2135,8 +2163,8 @@ class LineSegment {
     for (const line of lines) {
       const p1 = line.start;
       const p2 = line.end;
-      const key1 = `${p1.x.toFixed(6)}_${p1.y.toFixed(6)}`;
-      const key2 = `${p2.x.toFixed(6)}_${p2.y.toFixed(6)}`;
+      const key1 = `${p1.x.toFixed(2)}_${p1.y.toFixed(2)}`;
+      const key2 = `${p2.x.toFixed(2)}_${p2.y.toFixed(2)}`;
       const key = key1 < key2 ? `${key1}_${key2}` : `${key2}_${key1}`;
       if (!seen.has(key)) {
         seen.add(key);
@@ -2203,7 +2231,7 @@ class LineSegment {
       const arrayMap = modifyMap.get(line);
       arrayMap.append(point2, value);
     }
-    function modify2() {
+    function modify() {
       modifyMap.forEach((arrayMap, line) => {
         arrayMap.forEach((list, point2) => {
           const otherPoint = line.getAnotherPoint(point2);
@@ -2220,7 +2248,10 @@ class LineSegment {
         return setPoint;
       },
       get modify() {
-        return modify2;
+        return modify;
+      },
+      clear() {
+        modifyMap.clear();
       }
     };
   }
@@ -2400,12 +2431,12 @@ class Point {
    * @param point 
    * @returns 
    */
-  direction(point2) {
+  direction(point2, out = new Point()) {
     const dx = this.x - point2.x;
     const dy = this.y - point2.y;
     const length = Math.sqrt(dx * dx + dy * dy);
-    if (length === 0) return new Point(0, 0);
-    return new Point(dx / length, dy / length);
+    if (length !== 0) out.set(dx / length, dy / length);
+    return out;
   }
   /** 展开为线
    * @param direction 
@@ -2484,7 +2515,7 @@ class Point {
    * @param point 
    */
   _distanceMap = /* @__PURE__ */ new Map();
-  distance(point2, cached = true) {
+  distance(point2, cached = false) {
     if (cached && this._distanceMap.has(point2)) return this._distanceMap.get(point2);
     const num = Math.sqrt(
       (this.x - point2.x) * (this.x - point2.x) + (this.y - point2.y) * (this.y - point2.y)
@@ -2531,7 +2562,12 @@ class Point {
   toVector3(z = 0) {
     return new Vector3(this.x, this.y, z);
   }
-  static adsorb(points, tolerance = 15e-5) {
+  /** 点吸附
+   * @param points 
+   * @param tolerance 
+   * @returns 
+   */
+  static adsorb(points, tolerance = 15e-5, mode = "average") {
     const grid = new PointVirtualGrid();
     points.forEach((p2) => grid.insert(p2));
     const visited = /* @__PURE__ */ new Set();
@@ -2539,21 +2575,30 @@ class Point {
       const point2 = points[i];
       if (visited.has(point2)) continue;
       const results = grid.queryCircle(point2, tolerance).map((item) => item.point);
-      let countX = 0, countY = 0;
-      results.forEach((point22) => {
-        countX += point22.x;
-        countY += point22.y;
-      });
-      const x = countX / results.length, y = countY / results.length;
-      results.forEach((point22) => {
-        point22.set(x, y);
-        visited.add(point22);
-        grid.remove(point22);
+      let x = 0, y = 0;
+      if (mode === "average") {
+        let countX = 0, countY = 0;
+        results.forEach((point22) => (countX += point22.x, countY += point22.y));
+        x = countX / results.length;
+        y = countY / results.length;
+      } else {
+        x = point2.x;
+        y = point2.y;
+      }
+      results.forEach((p2) => {
+        p2.set(x, y);
+        visited.add(p2);
+        grid.update(p2);
+        grid.remove(p2);
       });
     }
     visited.clear();
     return points;
   }
+  /** 创建
+   * @param arr 
+   * @returns 
+   */
   static from(arr) {
     if (Array.isArray(arr)) {
       return new Point(arr[0], arr[1]);
@@ -5075,12 +5120,12 @@ class LineGroupType {
    * @returns 
    */
   static getIntersectionTypes(lines) {
-    const countMap = new CountMap();
+    const countMap = new CounterMap();
     lines.forEach((line) => {
       if (line.userData.groups) {
         line.userData.groups.forEach((group2) => countMap.set(group2.type));
       }
-      if (line.userData.groupType) countMap.set(line.userData.groupType);
+      if (line.userData.groupType) countMap.increment(line.userData.groupType);
     });
     const types = [];
     countMap.forEach((v2, k) => {
@@ -5185,6 +5230,7 @@ class LineGroupType {
 }
 function mergeLineUserData(line1, line2) {
   if (Array.isArray(line2)) {
+    line2 = [...line2].sort((a2, b4) => a2.length(true) - b4.length(true));
     return line2.forEach((l) => mergeLineUserData(line1, l));
   }
   const { drawWindow, ...opt } = line2.userData;
@@ -6376,6 +6422,12 @@ class LineSegmentUndirectedGraph extends UndirectedGraph {
     const key = a2 < b4 ? `${a2}-${b4}` : `${b4}-${a2}`;
     return this.lineMap.get(key);
   }
+  /** 获取所有线段
+   * @returns 
+   */
+  getLineAll() {
+    return Array.from(this.lineMap.values());
+  }
   /** 
    * 获取或创建点的索引
    */
@@ -6421,6 +6473,20 @@ class LineSegmentUndirectedGraph extends UndirectedGraph {
     this.buildFromLines(lines);
     return this;
   }
+  /** 批量移除线段边
+   * @param lines 
+   */
+  removeLines(lines) {
+    for (const line of lines) {
+      const i1 = this.getIndex(line.start);
+      const i2 = this.getIndex(line.end);
+      if (i1 !== void 0 && i2 !== void 0) {
+        super.removeEdge(i1, i2);
+        const key = i1 < i2 ? `${i1}-${i2}` : `${i2}-${i1}`;
+        this.lineMap.delete(key);
+      }
+    }
+  }
   /** 路径转线段组
    * @param path 
    */
@@ -6442,6 +6508,47 @@ class LineSegmentUndirectedGraph extends UndirectedGraph {
     this.indexToPoint.clear();
     this.nextIndex = 0;
   }
+  /** 断点合并
+   * @description 合并断开的直线，断点
+   * @param lines 
+   * @param callBack 
+   * @returns 
+   */
+  breakpointMerging(callBack, removeLines = /* @__PURE__ */ new Set(), newLines = []) {
+    const unionFindSet = new UnionFindSet(this.lineMap.size);
+    const lineIndexGenerator = new LineIndexGenerator();
+    this.adjacencyList.forEach((set2, k) => {
+      if (set2.size !== 2) return;
+      const values = set2.values(), v12 = values.next().value, v2 = values.next().value, line1 = this.getLine(k, v12), line2 = this.getLine(k, v2);
+      if (!line1.parallel(line2)) return;
+      unionFindSet.union(
+        lineIndexGenerator.getIndex(line1),
+        lineIndexGenerator.getIndex(line2)
+      );
+    });
+    unionFindSet.getAllSets().forEach((list) => {
+      if (list.length <= 1) return;
+      const lines = list.map((i) => lineIndexGenerator.getLine(i)), newLine = LineSegment.mergeLines(...lines);
+      callBack && callBack(newLine, lines);
+      lines.forEach((line) => removeLines.add(line));
+      newLines.push(newLine);
+      this.removeLines(lines);
+      this.addLines([newLine]);
+    });
+  }
+  /** 断点合并
+   * @param lines 
+   * @param callBack 
+   * @param removeLines 
+   * @param newLines 
+   * @returns 
+   */
+  static breakpointMerging(lines, callBack, removeLines = /* @__PURE__ */ new Set(), newLines = []) {
+    const lud = new LineSegmentUndirectedGraph(lines);
+    lud.breakpointMerging(callBack, removeLines, newLines);
+    lines = lud.getLineAll();
+    return lines;
+  }
   /** 线段图旋转
    * @param lines 
    * @param angle 弧度
@@ -6609,13 +6716,13 @@ class MaxiCircles extends MiniCircles {
         else visited.set(line, index2);
       }
     });
-    const countMap = new CountMap();
+    const countMap = new CounterMap();
     const groups = unionFindSet.getAllSets().valueArray.map((list) => {
       let group2 = list.map((i) => circles[i]);
       if (group2.length === 1) return group2[0];
       countMap.clear();
       group2 = this.deduplicate(group2);
-      group2.forEach((lines) => lines.forEach((line) => countMap.set(line)));
+      group2.forEach((lines) => lines.forEach((line) => countMap.increment(line)));
       if (test) {
         countMap.forEach((count, line) => drawText(count, line.center));
         drawLines(circles.flat(), { color: randomColor() });
@@ -6833,8 +6940,14 @@ class DoubleWallHelper {
       return data;
     }
   }
+  /** 查找
+   * @param lines 
+   * @param wallWidth 
+   * @returns 
+   */
   static findDoubleLine(lines, wallWidth = 0.4) {
-    const walls = lines.filter((line) => !line.userData.isDoor && !LineGroupType.hasType(line, "doubleWall")), visited = /* @__PURE__ */ new Set(), resultList = [];
+    let walls = lines.filter((line) => !line.userData.isDoor && !LineGroupType.hasType(line, "doubleWall")), visited = /* @__PURE__ */ new Set(), resultList = [];
+    walls = walls.filter((line) => !line.userData.isWindowWall);
     let quadtree = new Quadtree(Box2.fromByLineSegment(...walls));
     walls.forEach((line, index2) => quadtree.insert({ line, userData: index2 }));
     walls.forEach((sourceLineSegment, i) => {
@@ -6856,10 +6969,7 @@ class DoubleWallHelper {
       quadtree
     };
   }
-  // static findDoubleLine2( lines: LineSegment<LineUserData>[], wallWidth = 0.4 ) {
-  //     // LineSegment.groupByAxis()
-  // }
-  /** 
+  /** 补双线墙壁
    * @param lines 
    * @param wallWidth 
    * @returns 
@@ -6940,6 +7050,67 @@ class DoubleWallHelper {
     return [...lineSegments, ...doors];
   }
 }
+class LineQueryer {
+  pointVirtualGrid;
+  quadtree;
+  constructor(lines) {
+    this.pointVirtualGrid = createPointVirtualGrid(lines);
+    this.quadtree = createQuadtree(lines);
+  }
+  update(lines) {
+    this.clear();
+    this.pointVirtualGrid = createPointVirtualGrid(lines);
+    this.quadtree = createQuadtree(lines);
+  }
+  clear() {
+    this.pointVirtualGrid.clear();
+    this.quadtree.clear();
+  }
+  /** 
+   * @param point 
+   * @param radius 
+   * @param opt 
+   * @returns 
+   */
+  queryNearestPoint(point2, opt) {
+    if (!point2) throw new Error("请传入查询点");
+    const { resultIndex = 0, radius = 0.4, condition } = opt ?? {};
+    const results = this.pointVirtualGrid.queryCircle(point2, radius).filter((item) => item.point !== point2).filter((item) => condition ? condition(item) : true);
+    results.sort((a2, b4) => a2.point.distance(point2, true) - b4.point.distance(point2, true));
+    if (results.length > resultIndex) return {
+      point: results[resultIndex].point,
+      line: results[resultIndex].userData
+    };
+    return null;
+  }
+  /** 
+   * @param point 
+   * @param radius 
+   * @param opt 
+   * @returns 
+   */
+  queryNearestLine(point2, opt) {
+    if (!point2) throw new Error("请传入查询点");
+    const { resultIndex = 0, radius = 0.4, condition } = opt ?? {};
+    const results = this.quadtree.queryCircle(point2, radius).map((item) => {
+      const projPoint = item.line.projectPoint(point2, false);
+      if (projPoint && (!condition || condition(item, projPoint))) {
+        if (projPoint) return {
+          ...item,
+          distance: projPoint.distance(point2) ?? Infinity,
+          projPoint
+        };
+      }
+      return null;
+    }).filter((i) => !!i);
+    results.sort((a2, b4) => a2.distance - b4.distance);
+    if (results.length > resultIndex) return {
+      point: results[resultIndex].projPoint,
+      line: results[resultIndex].line
+    };
+    return null;
+  }
+}
 function shortDistanceLink(lines, radius = 0.1) {
   const dpLines = [...findDiscretePointLine2(lines.filter((line) => !line.userData.isDoor), void 0, false)], pointVirtualGrid = createPointVirtualGrid(dpLines), appendLines = [], visited = /* @__PURE__ */ new Set();
   const getWeight2 = (target, point2, line) => {
@@ -7014,7 +7185,7 @@ function calculateIntersectionPoint(lines) {
   quadtree.clear();
   return map;
 }
-function correction$1(targettLine, lines, intersectMap, errAngle = 15) {
+function correction(targettLine, lines, intersectMap, errAngle = 15) {
   const parallelLines = [targettLine], verticalLines = [], doorLines = [], windowLines = [];
   function parallel(line) {
     if (line.userData.isDoor) return doorLines.push(line);
@@ -7120,7 +7291,7 @@ function removeGroupLinkLine(groups, intersectmap) {
   });
   return groups.map((group2) => group2.filter((line) => !removeSet.has(line)));
 }
-function lineSegmentFitting2(groups, minWallWidth = 0.1, option) {
+function lineSegmentFitting(groups, minWallWidth = 0.1, option) {
   const { fittingMethod = "average" } = option ?? {};
   return groups.flatMap((group2) => {
     if (group2.length <= 1) return group2;
@@ -7145,89 +7316,101 @@ function lineSegmentFitting2(groups, minWallWidth = 0.1, option) {
       line.userData.wallWidth = line.userData.wallWidth ?? wallWidth;
     });
     Point.adsorb(group2.flatMap((line) => line.points), 5e-3);
+    group2 = group2.filter((line) => line.length() > 1e-9);
+    const points = group2.flatMap((line) => line.points);
+    points.forEach((point2) => point2.currentData.sortValue = fittedLine.projectValue(point2));
+    points.sort((a2, b4) => a2.currentData.sortValue - b4.currentData.sortValue);
+    const visited = /* @__PURE__ */ new Set(), counter = new CounterMap(), arrayMap = new ArrayMap();
+    for (let i = 0; i < points.length - 1; i++) {
+      const point2 = points[i], line = LineSegment.getPointBelongLine(point2);
+      if (visited.has(line)) continue;
+      counter.clear();
+      arrayMap.clear();
+      for (let j = i + 1; j < points.length; j++) {
+        const point22 = points[j], line2 = LineSegment.getPointBelongLine(point22);
+        if (line === line2) {
+          const countLines = counter.getByCount(2);
+          if (countLines.length) {
+            countLines.flatMap((line3) => arrayMap.get(line3)).sort((a2, b4) => b4 - a2).forEach((index2) => {
+              points[index2].set(0, 0);
+              points.splice(index2, 1);
+              j--;
+            });
+          }
+          if (j - i > 1) {
+            point22.copy(points[i + 1]);
+            points.splice(j, 1);
+          }
+          break;
+        }
+        counter.increment(line2);
+        arrayMap.append(line2, j);
+      }
+      visited.add(line);
+    }
+    group2 = group2.filter((line) => line.length() > 1e-9);
     return group2;
   });
 }
-function adsorption(lines, intersectionMap, option) {
-  const { snapThreshold: threshold = 0.2 } = option ?? {};
-  const pointVirtualGrid = new PointVirtualGrid(), quadtree = new Quadtree(Box2.fromByLineSegment(...lines)), queryLine = new LineSegment(), map = /* @__PURE__ */ new Map();
-  lines.forEach((line) => {
-    if (line.userData.isDoor) return;
-    quadtree.insert(line);
-    line.points.forEach((point2) => pointVirtualGrid.insert(point2, line));
-  });
-  function setPoint(line, line1) {
-    if (!map.has(line)) map.set(line, []);
-    map.get(line)?.push(line1);
-  }
-  function getAdsorptionPointByLine(point2, line) {
-    if (quadtree.queryPoint(point2).length > 1) return;
-    const direction = line.direction().multiplyScalar(threshold);
-    queryLine.set(point2, point2);
-    queryLine.start.add(direction);
-    queryLine.end.add(direction.multiplyScalar(-1));
-    const map2 = /* @__PURE__ */ new Map();
-    const list = quadtree.queryLineSegment(queryLine).filter((res) => res.line !== line).map((res) => {
-      const point22 = res.line.getIntersection(queryLine);
-      map2.set(res.line, point22);
-      return res.line;
-    }).sort((line1, line2) => {
-      const point1 = map2.get(line1);
-      const point22 = map2.get(line2);
-      if (point1 && point22) return point1.distance(point2) - point22.distance(point2);
-      return 0;
+function adsorption(lines, option) {
+  const { snapThreshold: threshold = 0.2 } = option ?? {}, lineQueryer = new LineQueryer(lines), modifyManager = LineSegment.createModifyManager();
+  function adsorptLine(point2, line) {
+    const otherPoint = line.getAnotherPoint(point2);
+    const direct = otherPoint.direction(point2);
+    const len = line.length();
+    const result = lineQueryer.queryNearestLine(point2, {
+      radius: threshold,
+      condition: (node, projPoint) => {
+        if (line !== node.line && node.line.vertical(line, 35)) {
+          if (projPoint.distance(point2) < len) return true;
+          const direct2 = projPoint.direction(point2);
+          return direct2.angleBetween(direct) > Math.PI * 0.5;
+        }
+        return false;
+      }
     });
-    if (list.length) return map2.get(list[0]);
-  }
-  function getObtainNearestAbsorbableLine(point2, line) {
-    let newPoint = getAdsorptionPointByLine(point2, line);
-    if (newPoint) {
-      return setPoint(line, new LineSegment(point2.clone(), newPoint.clone()));
-    }
-    if (pointVirtualGrid.queryPoint(point2).filter((item) => item.userData !== line).length !== 0) return;
-    const list0 = quadtree.queryCircle(point2, 1e-3).filter((item) => item.line !== line);
-    if (list0.length > 0) return;
-    const list = pointVirtualGrid.queryCircle(point2, threshold).filter((item) => item.userData !== line && item.userData?.vertical(line)).sort((item02, item1) => item02.point.distance(point2) - item1.point.distance(point2));
-    if (!list.length) return;
-    const item0 = list[0];
-    const pPoint = item0.userData?.projectPoint(point2, false);
-    if (pPoint) {
-      const line0 = item0.userData;
-      setPoint(line, new LineSegment(point2.clone(), pPoint.clone()));
-      setPoint(line0, new LineSegment(item0.point.clone(), pPoint.clone()));
-    }
-  }
-  function handle(line, point2, intersectList) {
-    return null;
+    if (result) return modifyManager.setPoint(line, point2, result.point.clone());
+  }
+  function adsorptPoint(point2, line) {
+    const otherPoint = line.getAnotherPoint(point2);
+    otherPoint.direction(point2);
+    line.length();
+    const result = lineQueryer.queryNearestPoint(point2, {
+      radius: threshold,
+      condition(node) {
+        const line2 = node.userData;
+        return line2.vertical(line, 15);
+      }
+    });
+    if (result) {
+      const propPoint = result.line.projectPoint(point2, false);
+      if (propPoint) {
+        modifyManager.setPoint(line, point2, propPoint);
+        modifyManager.setPoint(result.line, result.point, propPoint);
+      }
+    }
   }
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    const intersections = intersectionMap.get(line) ?? [];
-    const groups = intersections.reduce((groups2, item) => {
-      if (item.sourcePoint === line.start) groups2[0].push(item);
-      else groups2[1].push(item);
-      return groups2;
-    }, [[], []]);
-    const [isStart, isEnd] = line.points.map((point2, j) => {
-      if (!pointVirtualGrid.queryPoint(point2, true).length) {
-        const newPoint = handle(line, point2, groups[j]);
-        if (newPoint) {
-          point2.copy(newPoint);
-          pointVirtualGrid.update(point2);
-          quadtree.update(line);
-        } else return false;
-      }
-      return true;
+    line.points.map((point2) => {
+      let results = lineQueryer.pointVirtualGrid.queryPoint(point2, true);
+      if (results.length === 0 && lineQueryer.quadtree.queryCircle(point2, 1e-3).length < 2) adsorptLine(point2, line);
     });
-    if (!isStart) getObtainNearestAbsorbableLine(line.start, line);
-    if (!isEnd) getObtainNearestAbsorbableLine(line.end, line);
   }
-  map.forEach((lines2, line) => {
-    const newLine = LineSegment.mergeLines(line, ...lines2);
-    line.set(newLine.start, newLine.end);
-  });
-  pointVirtualGrid.clear();
-  quadtree.clear();
+  modifyManager.modify();
+  lines = lines.filter((line) => line.length() > 1e-9);
+  const dpls = [...findDiscretePointLine2(lines)];
+  lineQueryer.update(lines);
+  for (let i = 0; i < dpls.length; i++) {
+    const line = dpls[i];
+    line.points.map((point2) => {
+      let results = lineQueryer.pointVirtualGrid.queryPoint(point2, true);
+      if (results.length === 0 && lineQueryer.quadtree.queryCircle(point2, 1e-3).length < 2) adsorptPoint(point2, line);
+    });
+  }
+  modifyManager.modify();
+  lineQueryer.clear();
+  Point.adsorb(lines.flatMap((line) => line.points), 1e-4, "first");
   return lines;
 }
 function removeShortLine(lines, doorLines, len = 0.01) {
@@ -7336,7 +7519,7 @@ class AxisAlignCorr {
     targettLine = targetLineIndex > -1 ? lines[targetLineIndex] : targettLine;
     lines = preprocessing(lines);
     const intersectionMap = calculateIntersectionPoint(lines);
-    const { parallelLines, verticalLines, doorLines } = correction$1(targettLine, lines, intersectionMap, 25);
+    const { parallelLines, verticalLines, doorLines } = correction(targettLine, lines, intersectionMap, 25);
     const normal = targettLine.normal(), center = targettLine.center, direction = targettLine.direction(), xAxisLine = new LineSegment(
       center.clone().add(normal.clone().multiplyScalar(-1e3)),
       center.clone().add(normal.clone().multiplyScalar(1e3))
@@ -7346,13 +7529,14 @@ class AxisAlignCorr {
     );
     let groups = group(parallelLines, verticalLines, xAxisLine, yAxisLine2, option);
     groups = removeGroupLinkLine(groups, intersectionMap);
-    let newLines = lineSegmentFitting2(groups, 0.1, option);
-    newLines = adsorption(newLines, intersectionMap, option);
-    newLines = LineSegment.brokenLineMerging(newLines, mergeLineUserData);
+    let newLines = lineSegmentFitting(groups, 0.1, option);
+    newLines = adsorption(newLines, option);
     newLines = lineSegmentClipping(newLines, 1e-9);
+    newLines = LineSegmentUndirectedGraph.breakpointMerging(newLines, mergeLineUserData);
     doorRecover(doorLines);
     newLines = removeShortLine(newLines, doorLines, 0.15);
     newLines = buildBayWindowGroup(newLines);
+    doorAdsorption(newLines, doorLines);
     const { wallGroup = true } = option ?? {};
     if (wallGroup) {
       newLines = buildDoubleWallGroup(newLines);
@@ -7360,7 +7544,6 @@ class AxisAlignCorr {
       newLines = buildDoubleWallGroup(newLines, doorLines, true, true);
       newLines = buildBayWindowGroup(newLines, false);
     }
-    doorAdsorption(newLines, doorLines);
     recomputedWindow(...newLines);
     mergeWindow(...newLines);
     newLines.push(...doorLines);
@@ -7369,7 +7552,7 @@ class AxisAlignCorr {
     return newLines;
   }
 }
-let BoundExt$1 = class BoundExt {
+class BoundExt {
   /** 通过轨迹点查找外墙
    * @param lines 
    * @param trajectoryPoints
@@ -7470,7 +7653,9 @@ let BoundExt$1 = class BoundExt {
     appendLines = LineSegment.autoMergeLines(appendLines).lines;
     lines.push(...appendLines.filter((line) => line.length() > 1e-9));
     lines = lineSegmentClipping(lines, 1e-9);
-    lines = LineSegment.brokenLineMerging(lines, mergeLineUserData);
+    const doors = lines.filter((line) => line.userData.isDoor);
+    const walls = lines.filter((line) => !line.userData.isDoor);
+    lines = [...LineSegment.brokenLineMerging(walls, mergeLineUserData), ...doors];
     recomputedWindow(...lines);
     lines = lines.filter((line) => line.length() > 0.01);
     findCallBack && findCallBack([...exteriorLines, ...appendLines], trajectoryPoints);
@@ -7481,7 +7666,7 @@ let BoundExt$1 = class BoundExt {
       }
     };
   }
-};
+}
 function getGroups(lines, updateGroup = true) {
   if (updateGroup) lines = DoubleWallHelper.buildGroup(lines);
   const map = lines.reduce((map2, line) => {
@@ -16417,7 +16602,6 @@ class DoorFind {
     const openDoors = doors.filter((line) => !line.userData.doorDirectConnection), closeDoors = doors.filter((line) => line.userData.doorDirectConnection);
     this.grid = createPointVirtualGrid(noDoorLines);
     this.quadtree = createQuadtree([...noDoorLines, ...closeDoors]);
-    openDoors.forEach((l) => l.userData.doorDirectConnection = true);
     closeDoors.forEach((line) => this.findCloseDoors(line));
     openDoors.forEach((line) => this.findOpenDoors(line));
   }
@@ -16625,160 +16809,6 @@ class DoorFind {
     return this.lines;
   }
 }
-function getIntersection(line, mode, cell) {
-  return cell.reduce((list, item, i) => {
-    const currentLine = item.userData;
-    if (currentLine.parallel(line)) list[0] = i;
-    else {
-      const center = currentLine.center, position = line.pointPosition(center);
-      if (mode !== position) list[1] = i;
-      else list[2] = i;
-    }
-    return list;
-  }, [-1, -1, -1]);
-}
-function createNewLine(cell, reference, opt, appendLines, grid) {
-  const { point: point2 } = cell[opt[0]];
-  const newLine = new LineSegment(point2.clone(), reference.clone());
-  newLine.points.forEach((p2) => grid.insert(p2, newLine));
-  appendLines.push(newLine);
-  return newLine;
-}
-function setSameDirection(cell, reference, opt, grid) {
-  const { point: point2 } = cell[opt[1]];
-  point2.copy(reference);
-  grid.update(point2);
-}
-function setDifferentDirection(cell, reference, opt, grid) {
-  const { point: point2 } = cell[opt[2]];
-  point2.copy(reference);
-  grid.update(point2);
-}
-function modify(reference, cell, opt, appendLines, grid) {
-  const hasParallel = opt[0] > -1, hasSameDirection = opt[1] > -1, hasDifferentDirection = opt[2] > -1;
-  if (hasSameDirection) setSameDirection(cell, reference, opt, grid);
-  if (hasParallel) {
-    const newLine = createNewLine(cell, reference, opt, appendLines, grid);
-    if (hasSameDirection) newLine.userData = cloneUserData(cell[opt[1]].userData?.userData ?? {});
-    newLine.userData.rooftopPz = cell[opt[1]]?.userData?.userData.rooftopPz ?? newLine.userData.rooftopPz;
-    return;
-  }
-  if (hasDifferentDirection) {
-    if (hasSameDirection) {
-      const line = cell[opt[1]].userData;
-      reference = line.start.distance(cell[opt[2]].point) < line.end.distance(cell[opt[2]].point) ? line.start : line.end;
-    }
-    setDifferentDirection(cell, reference, opt, grid);
-  }
-}
-function correction(line, wallWidth = 0.12, appendLines, grid, quadtree) {
-  const startCell = grid.queryPoint(line.start, true), endCell = grid.queryPoint(line.end, true), mode = line.userData.expandDirect, startIntersection = getIntersection(line, mode, startCell), endIntersection = getIntersection(line, mode, endCell), direction = mode === "left" ? line.getRightDirection() : line.getLeftDirection(), doorIntersection = line.userData.isDoor ? [] : quadtree.queryLineSegment(line, false);
-  line.directionMove(direction, wallWidth * 0.5);
-  line.points.forEach((p2) => grid.update(p2));
-  modify(line.start, startCell, startIntersection, appendLines, grid);
-  modify(line.end, endCell, endIntersection, appendLines, grid);
-  if (line.userData.isDoor) return quadtree.update(line);
-  if (!doorIntersection.length) return;
-  doorIntersection.forEach(({ line: doorLine }) => {
-    if (line.parallel(doorLine, 25)) return;
-    const interPoint = line.getIntersection(doorLine);
-    if (!interPoint) return;
-    if (doorLine.start.distance(interPoint) < doorLine.end.distance(interPoint)) {
-      doorLine.start.copy(interPoint);
-      grid.update(doorLine.start);
-    } else {
-      doorLine.end.copy(interPoint);
-      grid.update(doorLine.end);
-    }
-    quadtree.update(doorLine);
-  });
-}
-class BoundExt2 {
-  /** 通过轨迹点查找外墙
-   * @param lines 
-   * @param trajectoryPoints
-   * @returns 
-   */
-  static findExtWallByTraj(lines, trajectoryPoints, minWidth = 0.4) {
-    lines = lines.filter((line) => !line.userData.isBayWindow);
-    const quadtree = new Quadtree(Box2.fromByLineSegment(...lines));
-    lines.forEach((line) => quadtree.insert({ line, userData: void 0 }));
-    const vrLine = findVerticalReference(lines);
-    lines = lines.filter((line) => {
-      if (LineGroupType.hasType(line, "doubleWall")) return;
-      if (line.userData.isDoor) {
-        if (!(vrLine.vertical(line, 0.1) || vrLine.parallel(line, 0.1))) return;
-      }
-      const center = line.center;
-      const set2 = /* @__PURE__ */ new Set();
-      for (const point2 of trajectoryPoints) {
-        if (set2.size === 2) break;
-        const lineA = new LineSegment(center, point2);
-        const list = quadtree.queryLineSegment(lineA).filter((target) => {
-          if (target.line === line) return false;
-          if (LineGroupType.hasGroup(line)) return true;
-          if (target.line.parallel(line)) {
-            if (line.getMinLength(target.line) < minWidth) {
-              const projectLine = target.line.projectLineSegment(line);
-              if (projectLine.length() / line.length() > 0.6) return false;
-            }
-          }
-          return true;
-        });
-        if (!list.length) {
-          const position = line.pointPosition(point2);
-          position !== "on" && set2.add(position);
-        }
-      }
-      line.userData.expandDirect = [...set2][0];
-      if (set2.size < 2) return true;
-    });
-    return lines;
-  }
-  /** 通过轨迹点外扩边线
-   * @param lines 
-   * @param trajectoryPoints 
-   */
-  static boundExtbyTrajAndOriginalData(opt) {
-    const zList = [];
-    let lines = opt.data.map(({ start, end, ...opt2 }) => {
-      const line = new LineSegment(Point.from(start), Point.from(end));
-      line.userData = opt2;
-      zList.push(start.z ?? 0, end.z ?? 0);
-      return line;
-    });
-    const originalZAverage = zList.reduce((count, num) => count + num, 0) / zList.length;
-    return this.boundExtbyTraj({ ...opt, lines }).toOriginalData(originalZAverage);
-  }
-  /** 通过轨迹点外扩边线
-   * @param lines 
-   * @param trajectory 
-   * @param wallWidth 
-   * @param findCallBack 
-   * @returns 
-   */
-  static boundExtbyTraj(opt) {
-    let { lines, trajectory, wallWidth = 0.12, updateDoubleWallGroup = true, findCallBack } = opt;
-    if (updateDoubleWallGroup) lines = DoubleWallHelper.buildGroup(lines);
-    const trajectoryPoints = Object.keys(trajectory).map((key) => Point.from(trajectory[key]));
-    const findLines = BoundExt2.findExtWallByTraj(lines, trajectoryPoints);
-    let exteriorLines = findLines.filter((line) => line.userData.expandDirect);
-    lines = lines.filter((line) => !exteriorLines.includes(line));
-    lines.push(...exteriorLines);
-    const grid = createPointVirtualGrid(lines), quadtree = createQuadtree(lines.filter((line) => line.userData.isDoor)), appendLines = [];
-    exteriorLines.forEach((line) => correction(line, wallWidth, appendLines, grid, quadtree));
-    lines.push(...appendLines.filter((line) => line.length() > 1e-9));
-    recomputedWindow(...lines);
-    lines = lines.filter((line) => line.length() > 0.01);
-    findCallBack && findCallBack(exteriorLines, trajectoryPoints);
-    return {
-      lines,
-      toOriginalData(originalZAverage) {
-        return lineDataToOriginalData(lines, originalZAverage);
-      }
-    };
-  }
-}
 const PRE_PROCESSOR = {
   /** 根据交点，对线段进行裁剪
    * @param lines 
@@ -16796,7 +16826,7 @@ const PRE_PROCESSOR = {
     polygons.forEach((polygon2) => {
       polygon2.pop();
       polygon2.splitConvexHull()?.forEach((poly) => {
-        drawLines(poly, { color: randomColor() });
+        drawLines(poly, { color: randomColor() }, 5e-3);
         drawLines(poly.getMinimumBoundingRectangle());
       });
     });
@@ -16847,7 +16877,7 @@ const PRE_PROCESSOR = {
       return lines;
     }
     let t2 = performance.now();
-    lines = BoundExt2.boundExtbyTraj({ lines, trajectory, wallWidth: DEFAULT_WALL_WIDTH, findCallBack: onBoundExt }).lines;
+    lines = BoundExt.boundExtbyTraj({ lines, trajectory, wallWidth: DEFAULT_WALL_WIDTH, findCallBack: onBoundExt }).lines;
     console.log(`外墙外扩总消耗时间： ${(performance.now() - t2).toFixed(2)} ms 处理线段数量：`, lines.length);
     return lines;
   },
@@ -19498,13 +19528,13 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   __proto__: null,
   ArrayMap,
   AxisAlignCorr,
-  BoundExt: BoundExt$1,
+  BoundExt,
   Box2,
   CommandFlow,
   CommandManager,
   Component,
   ComponentManager,
-  CountMap,
+  CounterMap,
   DoubleWallHelper,
   DxfSystem,
   EventDispatcher,
@@ -19621,7 +19651,7 @@ async function getModels(originData, trajectory, itemList) {
     itemList = [];
   }
   const { lineSegments, originalZAverage } = originalDataToLineData(originData);
-  const lines = BoundExt$1.boundExtbyTraj({
+  const lines = BoundExt.boundExtbyTraj({
     lines: lineSegments,
     trajectory,
     updateDoubleWallGroup: true,

package/src/index3.js

@@ -11335,7 +11335,9 @@ class Default extends CommandFlowComponent {
             const direction = line2.direction();
             currentSelectWinIndex = line2.userData.drawWindow?.findIndex((d) => {
               Point.from(d.p).expandAsLine(direction, d.width, {}, wiLine).directionMove(direction, -d.width * 0.5);
-              return wiLine.isPointOnSegment(Point.from(point));
+              const p = Point.from(point);
+              const p2 = wiLine.projectPoint(p, true);
+              return (p2?.distance(p) ?? Infinity) < 0.08;
             });
           }
           dom.style.cursor = "pointer";

package/src/utils/DxfSystem/type.d.ts

@@ -21,10 +21,13 @@ export type WallLineGlobalOption = {
     isWindow?: boolean;
     /** 是不是飘窗虚线 */
     isBayWindow?: boolean;
+    /** 是不是飘窗墙壁 */
+    isWindowWall?: boolean;
     /** 是不是门线 */
     isDoor?: boolean;
     doorAutomaticFind?: boolean;
     doorDirectConnection?: boolean;
+    topClearance?: number;
     isVerticalReferenceLine?: boolean;
     insetionArr?: {
         index: number;

package/src/utils/DxfSystem/utils/AxisAlignCorr copy.d.ts

@@ -0,0 +1,14 @@
+import { LineSegment } from '../../LineSegment';
+import { SetDataOption, LineUserData } from '../type';
+/**
+ * 轴对齐垂直纠正类
+ */
+export declare class AxisAlignCorr {
+    /**
+     * 轴对齐垂直修正
+     * @param lines 待调整线段组
+     * @param targettLine 轴线段
+     * @returns
+     */
+    static correction(lines: LineSegment<LineUserData>[], targettLine: LineSegment<LineUserData>, option?: SetDataOption): LineSegment<any>[];
+}

package/src/utils/DxfSystem/utils/BayWindowHelper.d.ts

@@ -0,0 +1,23 @@
+import { LineSegment } from '../../LineSegment';
+import { LineUserData } from '../type';
+import { Point } from '../../Point';
+interface IDrawBayWindowData {
+    height1: number;
+    height2: number;
+    height3: number;
+    depth: number;
+    windowWidth: number;
+    windowHeight: number;
+    bayWindowLine: LineSegment;
+    windowLine: LineSegment;
+    deptLine: LineSegment;
+    direction: Point;
+}
+export declare class BayWindowHelper {
+    static getDrawData(lines: LineSegment<LineUserData>[]): IDrawBayWindowData | null;
+    static getDrawDataAll(lineSegments: LineSegment[]): {
+        group: LineSegment<Record<string, any>>[];
+        drawData: IDrawBayWindowData;
+    }[];
+}
+export {};

package/src/utils/DxfSystem/utils/DoubleWallHelper.d.ts

@@ -18,12 +18,17 @@ export declare class DoubleWallHelper {
      * @returns
      */
     private static projectionAnalysis;
+    /** 查找
+     * @param lines
+     * @param wallWidth
+     * @returns
+     */
     static findDoubleLine(lines: LineSegment<LineUserData>[], wallWidth?: number): {
         resultList: ProjectionAnalysisResult[];
         walls: LineSegment<LineUserData>[];
         quadtree: Quadtree<number>;
     };
-    /**
+    /** 补双线墙壁
      * @param lines
      * @param wallWidth
      * @returns

package/src/utils/LineQueryer.d.ts

@@ -0,0 +1,42 @@
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+import { PointVirtualGrid } from './PointVirtualGrid';
+import { Quadtree, QuadtreeNode } from './Quadtree';
+export declare class LineQueryer {
+    pointVirtualGrid: PointVirtualGrid<LineSegment>;
+    quadtree: Quadtree<any>;
+    constructor(lines: LineSegment[]);
+    update(lines: LineSegment[]): void;
+    clear(): void;
+    /**
+     * @param point
+     * @param radius
+     * @param opt
+     * @returns
+     */
+    queryNearestPoint(point: Point, opt?: {
+        resultIndex?: number;
+        radius?: number;
+        condition?: (node: {
+            point: Point<Record<string, any>>;
+            userData?: LineSegment<Record<string, any>> | undefined;
+        }) => boolean;
+    }): {
+        point: Point<Record<string, any>>;
+        line: LineSegment;
+    } | null;
+    /**
+     * @param point
+     * @param radius
+     * @param opt
+     * @returns
+     */
+    queryNearestLine(point: Point, opt?: {
+        resultIndex?: number;
+        radius?: number;
+        condition?: (node: QuadtreeNode<any>, point: Point) => boolean;
+    }): {
+        point: Point<Record<string, any>>;
+        line: LineSegment<Record<string, any>>;
+    } | null;
+}

package/src/utils/LineSegment.d.ts

@@ -4,6 +4,7 @@ import { Rectangle } from './Rectangle';
  * 非轴对称线段
  */
 export declare class LineSegment<T = Record<string, any>> {
+    static get LINE_SYMBOL(): symbol;
     points: Point[];
     userData: T;
     currentData: Record<string | number | symbol, any>;
@@ -222,6 +223,11 @@ export declare class LineSegment<T = Record<string, any>> {
      * @param line
      */
     copy(line: LineSegment): void;
+    /** 获取点属于的线段
+     * @param point
+     * @returns
+     */
+    static getPointBelongLine(point: Point): LineSegment | null;
     /**
      * 获取最长线段
      * @param lines
@@ -315,5 +321,6 @@ export declare class LineSegment<T = Record<string, any>> {
     static createModifyManager(): {
         readonly setPoint: (line: LineSegment, point: Point, value: Point) => void;
         readonly modify: () => void;
+        clear(): void;
     };
 }

package/src/utils/Map.d.ts

@@ -2,6 +2,7 @@ export declare class MapEnhance<K, V> extends Map<K, V> {
     get valueArray(): V[];
     map<T = any>(callbackfn: (v: V, k: K) => T): T[];
     filter(callbackfn: (v: V, k: K) => boolean): V[];
+    filterKey(callbackfn: (v: V, k: K) => boolean): K[];
     reduce<T>(callbackfn: (pre: T, v: V, k: K) => T, result: T): T;
     some(callbackfn: (v: V, k: K) => boolean): boolean;
     every(callbackfn: (v: V, k: K) => boolean): boolean;
@@ -28,6 +29,8 @@ export declare class SetMap<K, V> extends MapEnhance<K, Set<V>> {
     append(k: K, ...arr: V[]): this;
     hasValue(key: K, value: V): boolean;
 }
-export declare class CountMap<K> extends MapEnhance<K, number> {
-    set(key: K): this;
+export declare class CounterMap<K> extends MapEnhance<K, number> {
+    set(key: K, step?: number): this;
+    increment(key: K, step?: number): this;
+    getByCount(count: number): K[];
 }

package/src/utils/Point.d.ts

@@ -92,7 +92,7 @@ export declare class Point<T = Record<string, any>> {
      * @param point
      * @returns
      */
-    direction(point: Point): Point<Record<string, any>>;
+    direction(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
     /** 展开为线
      * @param direction
      * @param length
@@ -161,7 +161,16 @@ export declare class Point<T = Record<string, any>> {
         z: number;
     };
     toVector3(z?: number): Vector3;
-    static adsorb(points: Point[], tolerance?: number): Point<Record<string, any>>[];
+    /** 点吸附
+     * @param points
+     * @param tolerance
+     * @returns
+     */
+    static adsorb(points: Point[], tolerance?: number, mode?: "average" | "first"): Point<Record<string, any>>[];
+    /** 创建
+     * @param arr
+     * @returns
+     */
     static from(arr: any): Point<Record<string, any>>;
     static fromByList(arr: any[]): Point<Record<string, any>>[];
     static zero(): Point<Record<string, any>>;

package/src/utils/UndirectedGraph.d.ts

@@ -19,6 +19,9 @@ export declare class UndirectedGraph {
      */
     forEach(callbackFun: (node: number, neighbors: Set<number>) => void): void;
 }
+/**
+ * 线段无向图
+ */
 export declare class LineSegmentUndirectedGraph extends UndirectedGraph {
     private readonly lineMap;
     private readonly pointToIndex;
@@ -30,6 +33,10 @@ export declare class LineSegmentUndirectedGraph extends UndirectedGraph {
      * 获取两点之间的线段（无向）
      */
     getLine(a: number, b: number): LineSegment | undefined;
+    /** 获取所有线段
+     * @returns
+     */
+    getLineAll(): LineSegment<Record<string, any>>[];
     /**
      * 获取或创建点的索引
      */
@@ -55,6 +62,10 @@ export declare class LineSegmentUndirectedGraph extends UndirectedGraph {
      * 批量添加线段（比逐条 addLine 更快）
      */
     addLines(lines: readonly LineSegment[]): this;
+    /** 批量移除线段边
+     * @param lines
+     */
+    removeLines(lines: readonly LineSegment[]): void;
     /** 路径转线段组
      * @param path
      */
@@ -63,6 +74,21 @@ export declare class LineSegmentUndirectedGraph extends UndirectedGraph {
      * 清空图
      */
     clear(): void;
+    /** 断点合并
+     * @description 合并断开的直线，断点
+     * @param lines
+     * @param callBack
+     * @returns
+     */
+    breakpointMerging(callBack?: (newLine: LineSegment, group: LineSegment[]) => void, removeLines?: Set<LineSegment<Record<string, any>>>, newLines?: LineSegment[]): void;
+    /** 断点合并
+     * @param lines
+     * @param callBack
+     * @param removeLines
+     * @param newLines
+     * @returns
+     */
+    static breakpointMerging(lines: LineSegment[], callBack?: (newLine: LineSegment, group: LineSegment[]) => void, removeLines?: Set<LineSegment<Record<string, any>>>, newLines?: LineSegment[]): LineSegment<Record<string, any>>[];
     /** 线段图旋转
      * @param lines
      * @param angle 弧度