build-dxf 0.1.85 → 0.1.86

package/package.json

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

package/src/build.js

@@ -1573,7 +1573,7 @@ class LineSegment {
    * @param errAngle 
    * @returns 
    */
-  isPerpendicularTo(line, eps = 0.1) {
+  isPerpendicularTo(line, eps = 1) {
     const d1 = this.direction();
     const d2 = line.direction();
     const angle = d1.angle(d2, { unit: "degree", range: "180" });
@@ -3321,7 +3321,7 @@ function findDiscretePointLine2(lines, lineSet, deep = false) {
   lines.forEach((line) => {
     if (lineSet.size && lineSet.has(line)) return;
     line.points.forEach((p2) => {
-      const id = p2.hashCode();
+      const id = p2.hashCode(4);
       if (!map.has(id)) map.set(id, /* @__PURE__ */ new Set());
       map.get(id)?.add(line);
     });
@@ -7477,6 +7477,7 @@ class ThreeVJiaJson extends Pipeline {
   }
 }
 function lineDataToThreeVJiaJson(lineSegments, angle = 0, updateGroup = true) {
+  angle = 0;
   lineSegments = LineSegmentUndirectedGraph.rotate(lineSegments.map((line) => line.clone()), angle, (line, center, angle2) => {
     WallInsertObject.forEachInsertObjectData(line, (data) => {
       data.forEach((item) => {
@@ -8308,530 +8309,178 @@ class DxfDataPlugin extends Pipeline {
     DxfDataPlugin.initData(cad, this.lines);
   }
 }
-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 
+class BoundExt {
+  /** 通过轨迹点查找外墙
+   * @param lines 
+   * @param trajectoryPoints
    * @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;
+  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 }));
+    lines = lines.filter((line) => {
+      if (LineGroupType.hasType(line, "doubleWall")) 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.isParallelTo(line)) {
+            if (line.distanceToSegment(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.getPointSideOfLine(point2);
+          position !== "on" && set2.add(position);
+        }
+      }
+      line.userData.expandDirect = [...set2][0];
+      if (set2.size < 2) return true;
+    });
+    return lines;
   }
-  /** 
-   * @param point 
-   * @param radius 
-   * @param opt 
+  /** 通过轨迹点外扩边线
+   * @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 
    */
-  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
-        };
+  static boundExtbyTraj(opt) {
+    let { lines, trajectory: trajectory2, wallWidth = 0.12, updateDoubleWallGroup = false, findCallBack } = opt;
+    if (updateDoubleWallGroup) lines = DoubleWallHelper.buildGroup(lines);
+    const trajectoryPoints = Object.keys(trajectory2).map((key) => Point.from(trajectory2[key]));
+    const findLines = BoundExt.findExtWallByTraj(lines, trajectoryPoints);
+    let exteriorLines = findLines.filter((line) => line.userData.expandDirect).filter((line) => !line.userData.isBalconyRailing).filter((line) => !LineGroupType.hasType(line, "bayWindow"));
+    lines = lines.filter((line) => !exteriorLines.includes(line));
+    lines.push(...exteriorLines);
+    const grid = createPointVirtualGrid(lines), quadtree = createQuadtree(lines), arrayMap = new ArrayMap(), pointMap = /* @__PURE__ */ new Map();
+    let appendLines = [];
+    exteriorLines.forEach((line) => {
+      const mode = line.userData.expandDirect, direction = mode === "left" ? line.getRightDirection() : line.getLeftDirection();
+      line.points.forEach((point2) => {
+        const id = point2.hashCode();
+        arrayMap.append(id, { point: point2, line });
+        if (!pointMap.has(id)) pointMap.set(id, point2.clone());
+        grid.update(point2);
+      });
+      line.translate(wallWidth * 0.5, direction);
+    });
+    arrayMap.forEach((list, id) => {
+      if (list.length >= 2) {
+        const p1 = list[0].line.getIntersection(list[1].line);
+        if (p1) {
+          list[0].point.copy(p1);
+          list[1].point.copy(p1);
+        }
+      } else {
+        const queryList = grid.queryCircle(pointMap.get(id), 1e-4);
+        if (queryList.length) {
+          const newLine = new LineSegment(pointMap.get(id), list[0].point.clone());
+          const list_ = list.filter((i) => !i.line.userData.isDoor && !i.line.userData.isWindow);
+          if (list_.length) newLine.userData = cloneUserData(list_[0].line.userData);
+          if (quadtree.queryCircle(newLine.center, 1e-4).length) return;
+          appendLines.push(newLine);
+        }
+      }
+    });
+    appendLines = LineSegment.mergeParallelSegments(appendLines).lines;
+    lines.push(...appendLines.filter((line) => line.length() > 1e-9));
+    lines = lineSegmentClipping(lines, 1e-9);
+    const doors = lines.filter((line) => line.userData.isDoor);
+    const walls = lines.filter((line) => !line.userData.isDoor);
+    lines = [...LineSegment.mergeCollinearSegments(walls, mergeLineUserData), ...doors];
+    WallInsertObject.recomputed(lines);
+    lines = lines.filter((line) => line.length() > 1e-4).filter((line) => line.userData.isDoor ? line.length() > 0.25 : true);
+    findCallBack && findCallBack([...exteriorLines, ...appendLines], trajectoryPoints);
+    return {
+      lines,
+      toOriginalData(originalZAverage) {
+        return lineDataToOriginalData(lines, originalZAverage);
       }
-      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 parallel(line, baseline) {
-  const currentAngle = Math.atan2(line.end.y - line.start.y, line.end.x - line.start.x);
-  const targetAngle = Math.atan2(baseline.end.y - baseline.start.y, baseline.end.x - baseline.start.x);
-  let diff = targetAngle - currentAngle;
-  while (diff > Math.PI) diff -= 2 * Math.PI;
-  while (diff < -Math.PI) diff += 2 * Math.PI;
-  const center = line.center;
-  line.start.rotate(center, diff);
-  line.end.rotate(center, diff);
-  if (Math.abs(diff) > Math.PI / 2) line.swapValue();
-  return line;
+if (typeof globalThis !== "undefined" && typeof ProgressEvent === "undefined") {
+  globalThis.ProgressEvent = class ProgressEvent extends EventTarget {
+    type;
+    lengthComputable;
+    loaded;
+    total;
+    bubbles;
+    cancelable;
+    defaultPrevented;
+    eventPhase;
+    timeStamp;
+    isTrusted;
+    constructor(type, options = {}) {
+      super();
+      this.type = type;
+      this.lengthComputable = options.lengthComputable || false;
+      this.loaded = options.loaded || 0;
+      this.total = options.total || 0;
+      this.bubbles = false;
+      this.cancelable = false;
+      this.defaultPrevented = false;
+      this.eventPhase = 0;
+      this.timeStamp = Date.now();
+      this.isTrusted = true;
+    }
+    preventDefault() {
+    }
+    stopPropagation() {
+    }
+    stopImmediatePropagation() {
+    }
+  };
 }
-function vertical(line, baseline) {
-  const currentAngle = Math.atan2(line.end.y - line.start.y, line.end.x - line.start.x);
-  const targetAngle = Math.atan2(baseline.end.y - baseline.start.y, baseline.end.x - baseline.start.x);
-  let diff1 = targetAngle + Math.PI / 2 - currentAngle;
-  let diff2 = targetAngle - Math.PI / 2 - currentAngle;
-  while (diff1 > Math.PI) diff1 -= 2 * Math.PI;
-  while (diff1 < -Math.PI) diff1 += 2 * Math.PI;
-  while (diff2 > Math.PI) diff2 -= 2 * Math.PI;
-  while (diff2 < -Math.PI) diff2 += 2 * Math.PI;
-  const diff = Math.abs(diff1) < Math.abs(diff2) ? diff1 : diff2;
-  const center = line.center;
-  line.start.rotate(center, diff);
-  line.end.rotate(center, diff);
-  if (Math.abs(diff) > Math.PI / 2) line.swapValue();
-  return line;
+let gltfLoader = GLTFExporter;
+let gltfExporter = GLTFLoader;
+let promise;
+function GltfInit() {
+  if (promise) return promise;
+  promise = new Promise(async (resolve) => {
+    try {
+      const { GLTFLoader: GLTFLoader2 } = await (typeof window !== "undefined" ? import("three/addons/loaders/GLTFLoader.js") : include("node-three-gltf", false));
+      gltfLoader = GLTFLoader2;
+      const { GLTFExporter: GLTFExporter2 } = await (typeof window !== "undefined" ? import("three/addons/exporters/GLTFExporter.js") : include("node-three-gltf", false));
+      gltfExporter = GLTFExporter2;
+    } catch (error) {
+      console.error(error);
+    }
+    resolve(true);
+  });
+  return promise;
 }
-class AxisAlignCorr {
-  static start(lines, targettLine) {
-    return new AxisAlignCorr(lines, targettLine).start();
-  }
-  lines;
-  baseline;
-  grid;
-  constructor(lines, baseline) {
-    this.lines = lines;
-    this.baseline = baseline;
-    this.grid = createPointVirtualGrid(lines);
-  }
-  visited = /* @__PURE__ */ new Set();
-  newLines = [];
-  start() {
-    for (let i = 0; i < this.lines.length; i++) {
-      const line = this.lines[i];
-      if (this.visited.has(line)) continue;
-      this.correction(line);
-    }
-    return [
-      ...this.lines,
-      ...this.newLines
-    ];
-  }
-  /** 添加
-   * @param lines 
-   * @returns 
-   */
-  addVisited(lines) {
-    if (lines instanceof LineSegment) lines = [lines];
-    lines.forEach((line) => this.visited.add(line));
-    return this;
-  }
-  queryPoint(point2) {
-    return this.grid.queryPoint(point2, true).filter((item) => !this.visited.has(item.userData));
-  }
-  /** 纠正
-   * @param line 
-   * @param targettLine 
-   */
-  correction(line) {
-    const startConnectList = this.queryPoint(line.start);
-    const endConnectLines = this.queryPoint(line.end);
-    this.rotate(line);
-    startConnectList.forEach(({ userData: queryLine, point: point2 }) => {
-      this.recursion(queryLine, point2, line, line.start);
-    });
-    endConnectLines.forEach(({ userData: queryLine, point: point2 }) => {
-      this.recursion(queryLine, point2, line, line.end);
-    });
-  }
-  /** 递归执行
-   * @param line 
-   * @param enterPoint 
-   */
-  recursion(line, enterPoint, nextLine, nextPoint) {
-    const otherPoint = line.getAnotherPoint(enterPoint);
-    const connectList = this.queryPoint(otherPoint);
-    this.rotate(line);
-    this.establishConnection(enterPoint, line, nextLine, nextPoint);
-    connectList.forEach(({ userData: queryLine, point: point2 }) => {
-      this.recursion(queryLine, point2, line, otherPoint);
-    });
-  }
-  /** 构建连接
-   */
-  establishConnection(point2, line, nextLine, nextPoint) {
-    if (line.isParallelTo(nextLine)) {
-      const interPoint2 = nextLine.projectPoint(point2, false);
-      const newLine = new LineSegment(point2.clone(), interPoint2?.clone() ?? nextPoint.clone());
-      newLine.length() > 1e-9 && this.newLines.push(newLine);
-      return;
-    }
-    const interPoint = nextLine.projectPoint(point2, false);
-    if (!interPoint) return;
-    point2.copy(interPoint);
-    if (nextLine.isPointOnSegment(interPoint)) return;
-    nextPoint.copy(interPoint);
-  }
-  point = new Point();
-  /** 旋转
-   * @param line 
-   * @param errAngle 
-   */
-  rotate(line, errAngle = 45) {
-    const baseline = this.baseline;
-    this.point.copy(line.start);
-    if (line.isParallelTo(baseline, errAngle)) parallel(line, baseline);
-    else vertical(line, baseline);
-    this.addVisited(line);
-  }
-}
-function shortDistanceLink(lines, radius = 0.1) {
-  const dpSet = findDiscretePoint(lines.filter((line) => !line.userData.isDoor)), pointVirtualGrid = createPointVirtualGrid(dpSet.map((v2) => v2)), appendLines = [], visited = /* @__PURE__ */ new Set();
-  const getWeight2 = (target, point2, line) => {
-    if (target.weight) return target.weight;
-    const targetLine = target.userData, targetPoint = target.point;
-    const direct1 = line.getAnotherPoint(point2).directionFrom(point2), direct2 = targetLine.getAnotherPoint(targetPoint).directionFrom(targetPoint), direct3 = targetPoint.directionFrom(point2), angle = direct1.angleBetween(direct2), angle2 = direct1.angleBetween(direct3), length = point2.distance(target.point), weight = 1 - length / radius + angle / Math.PI * 1.2 + (1 - angle2 / Math.PI) * 1.2;
-    target.weight = weight;
-    return weight;
-  };
-  for (const [point2, line] of dpSet) {
-    if (line.userData.isDoor) continue;
-    if (visited.has(point2)) continue;
-    const list = pointVirtualGrid.queryCircle(point2, radius, true).map((item) => Object.assign({}, item)).filter((item) => {
-      const targetLine2 = item.userData, targetPoint2 = item.point, direct1 = line.getAnotherPoint(point2).directionFrom(point2), direct2 = targetLine2.getAnotherPoint(targetPoint2).directionFrom(targetPoint2), angle = direct1.angleBetween(direct2, "angle");
-      return angle > 90;
-    }).sort((a2, b4) => getWeight2(b4, point2, line) - getWeight2(a2, point2, line));
-    if (list.length === 0) continue;
-    const { point: targetPoint } = list[0];
-    const targetLine = list[0].userData;
-    visited.add(point2);
-    visited.add(targetPoint);
-    const projectLine1 = line.projectLineSegment(targetLine), projectLine2 = targetLine.projectLineSegment(line), len1 = projectLine1.length(), len2 = projectLine2.length();
-    if (len1 === 0 && len2 === 0) appendLines.push(new LineSegment(point2.clone(), list[0].point.clone()));
-    else appendLines.push(new LineSegment(projectLine1.center, projectLine2.center));
-  }
-  return [...lines, ...appendLines];
-}
-function preprocessing(lines) {
-  const pointVirtualGrid = new PointVirtualGrid(), quadtree = new Quadtree(Box2.fromByLineSegment(...lines)), doors = [];
-  lines.forEach((line) => {
-    if (line.userData.isDoor) doors.push(line);
-    else {
-      line.points.forEach((p2) => pointVirtualGrid.insert(p2, line));
-      quadtree.insert(line);
-    }
-  });
-  doors.forEach((door) => {
-    const startIntersection = pointVirtualGrid.queryPoint(door.start);
-    const endIntersection = pointVirtualGrid.queryPoint(door.end);
-    if (startIntersection.length) door.userData.startIntersection = startIntersection[0].userData;
-    else door.userData.startIntersection = quadtree.queryPoint(door.start)[0]?.line;
-    if (endIntersection.length) door.userData.endIntersection = endIntersection[0].userData;
-    else door.userData.endIntersection = quadtree.queryPoint(door.end)[0]?.line;
-  });
-  lines = shortDistanceLink(lines, 0.4);
-  pointVirtualGrid.clear();
-  quadtree.clear();
-  return lines;
-}
-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.directionFrom(point2);
-    const len = line.length();
-    const result = lineQueryer.queryNearestLine(point2, {
-      radius: threshold,
-      condition: (node, projPoint) => {
-        if (line !== node.line && node.line.isPerpendicularTo(line, 35)) {
-          if (projPoint.distance(point2) < len) return true;
-          const direct2 = projPoint.directionFrom(point2);
-          return direct2.angleBetween(direct) > Math.PI * 0.5;
-        }
-        return false;
-      }
-    });
-    if (result) return modifyManager.setPoint(line, point2, result.point.clone());
-  }
-  function adsorptPoint(point2, line) {
-    const result = lineQueryer.queryNearestPoint(point2, {
-      radius: threshold,
-      condition(node) {
-        const line2 = node.userData;
-        return line2.isPerpendicularTo(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];
-    line.points.map((point2) => {
-      let results = lineQueryer.pointVirtualGrid.queryPoint(point2, true);
-      if (results.length === 0 && lineQueryer.quadtree.queryCircle(point2, 1e-4).length < 2) adsorptLine(point2, line);
-    });
-  }
-  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-4).length < 2) {
-        adsorptPoint(point2, line);
-      }
-    });
-  }
-  modifyManager.modify();
-  lineQueryer.clear();
-  Point.adsorb(lines.flatMap((line) => line.points), 1e-4, "first");
-  return lines;
-}
-function removeShortLine(lines, len = 0.01) {
-  let defaultLines = [], doorLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.userData.isDoor) doorLines.push(line);
-    else defaultLines.push(line);
-  }
-  const lineSet = findDiscretePointLine2(lines);
-  const grid = createPointVirtualGrid([...lineSet]);
-  for (let i = 0; i < doorLines.length; i++) {
-    const doorLine = doorLines[i];
-    doorLine.points.forEach((p2) => {
-      grid.queryPoint(p2, true).forEach((item) => lineSet.delete(item.userData));
-    });
-  }
-  defaultLines = defaultLines.filter((line) => !lineSet.has(line) || line.length() > len);
-  defaultLines = LineSegmentUndirectedGraph.breakpointMerging(defaultLines, (newLine, lines2) => {
-    lines2 = lines2.filter((line) => line.length() > 0);
-    mergeLineUserData(newLine, lines2);
-    newLine.userData.isBayWindow = lines2.some((line) => line.userData.isBayWindow);
-  });
-  WallInsertObject.recomputed(defaultLines);
-  return [...defaultLines, ...doorLines];
-}
-function breakpointMerging(lines) {
-  let defaultLines = [], doorLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.userData.isDoor) doorLines.push(line);
-    else defaultLines.push(line);
-  }
-  defaultLines = LineSegmentUndirectedGraph.breakpointMerging(defaultLines, mergeLineUserData);
-  doorLines = LineSegmentUndirectedGraph.breakpointMerging(doorLines, mergeLineUserData);
-  return [...defaultLines, ...doorLines];
-}
-function axisAlignCorr$1(lines, targettLine, option) {
-  lines = lines.map((line) => line.clone());
-  lines = breakpointMerging(lines);
-  lines = lineSegmentClipping(lines, 1e-9);
-  lines = preprocessing(lines);
-  lines = AxisAlignCorr.start(lines, targettLine);
-  lines = adsorption(lines, option);
-  lines = lineSegmentClipping(lines, 1e-9);
-  lines = removeShortLine(lines, 0.15);
-  let newLines = lines.filter((line) => !line.userData.isDoor);
-  let doorLines = lines.filter((line) => line.userData.isDoor);
-  newLines = buildBayWindowGroup(newLines, false);
-  const { wallGroup = true } = option ?? {};
-  if (wallGroup) {
-    newLines = DoubleWallHelper.complementSide(newLines);
-    WallInsertObject.recomputed(newLines);
-    newLines = buildDoubleWallGroup(newLines, true);
-    newLines = buildBayWindowGroup(newLines, false);
-  }
-  new WallInsertObject(lines).recomputed().merge();
-  newLines.push(...doorLines);
-  Point.adsorb(newLines.flatMap((line) => line.points), 1e-4);
-  lines = removeShortLine(lines, 0.05);
-  lines = breakpointMerging(lines);
-  return newLines;
-}
-class BoundExt {
-  /** 通过轨迹点查找外墙
-   * @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 }));
-    lines = lines.filter((line) => {
-      if (LineGroupType.hasType(line, "doubleWall")) 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.isParallelTo(line)) {
-            if (line.distanceToSegment(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.getPointSideOfLine(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: trajectory2, wallWidth = 0.12, updateDoubleWallGroup = false, findCallBack } = opt;
-    if (updateDoubleWallGroup) lines = DoubleWallHelper.buildGroup(lines);
-    const trajectoryPoints = Object.keys(trajectory2).map((key) => Point.from(trajectory2[key]));
-    const findLines = BoundExt.findExtWallByTraj(lines, trajectoryPoints);
-    let exteriorLines = findLines.filter((line) => line.userData.expandDirect).filter((line) => !line.userData.isBalconyRailing).filter((line) => !LineGroupType.hasType(line, "bayWindow"));
-    lines = lines.filter((line) => !exteriorLines.includes(line));
-    lines.push(...exteriorLines);
-    const grid = createPointVirtualGrid(lines), quadtree = createQuadtree(lines), arrayMap = new ArrayMap(), pointMap = /* @__PURE__ */ new Map();
-    let appendLines = [];
-    exteriorLines.forEach((line) => {
-      const mode = line.userData.expandDirect, direction = mode === "left" ? line.getRightDirection() : line.getLeftDirection();
-      line.points.forEach((point2) => {
-        const id = point2.hashCode();
-        arrayMap.append(id, { point: point2, line });
-        if (!pointMap.has(id)) pointMap.set(id, point2.clone());
-        grid.update(point2);
-      });
-      line.translate(wallWidth * 0.5, direction);
-    });
-    arrayMap.forEach((list, id) => {
-      if (list.length >= 2) {
-        const p1 = list[0].line.getIntersection(list[1].line);
-        if (p1) {
-          list[0].point.copy(p1);
-          list[1].point.copy(p1);
-        }
-      } else {
-        const queryList = grid.queryCircle(pointMap.get(id), 1e-4);
-        if (queryList.length) {
-          const newLine = new LineSegment(pointMap.get(id), list[0].point.clone());
-          const list_ = list.filter((i) => !i.line.userData.isDoor && !i.line.userData.isWindow);
-          if (list_.length) newLine.userData = cloneUserData(list_[0].line.userData);
-          if (quadtree.queryCircle(newLine.center, 1e-4).length) return;
-          appendLines.push(newLine);
-        }
-      }
-    });
-    appendLines = LineSegment.mergeParallelSegments(appendLines).lines;
-    lines.push(...appendLines.filter((line) => line.length() > 1e-9));
-    lines = lineSegmentClipping(lines, 1e-9);
-    const doors = lines.filter((line) => line.userData.isDoor);
-    const walls = lines.filter((line) => !line.userData.isDoor);
-    lines = [...LineSegment.mergeCollinearSegments(walls, mergeLineUserData), ...doors];
-    WallInsertObject.recomputed(lines);
-    lines = lines.filter((line) => line.length() > 1e-4).filter((line) => line.userData.isDoor ? line.length() > 0.25 : true);
-    findCallBack && findCallBack([...exteriorLines, ...appendLines], trajectoryPoints);
-    return {
-      lines,
-      toOriginalData(originalZAverage) {
-        return lineDataToOriginalData(lines, originalZAverage);
-      }
-    };
-  }
-}
-if (typeof globalThis !== "undefined" && typeof ProgressEvent === "undefined") {
-  globalThis.ProgressEvent = class ProgressEvent extends EventTarget {
-    type;
-    lengthComputable;
-    loaded;
-    total;
-    bubbles;
-    cancelable;
-    defaultPrevented;
-    eventPhase;
-    timeStamp;
-    isTrusted;
-    constructor(type, options = {}) {
-      super();
-      this.type = type;
-      this.lengthComputable = options.lengthComputable || false;
-      this.loaded = options.loaded || 0;
-      this.total = options.total || 0;
-      this.bubbles = false;
-      this.cancelable = false;
-      this.defaultPrevented = false;
-      this.eventPhase = 0;
-      this.timeStamp = Date.now();
-      this.isTrusted = true;
-    }
-    preventDefault() {
-    }
-    stopPropagation() {
-    }
-    stopImmediatePropagation() {
-    }
-  };
-}
-let gltfLoader = GLTFExporter;
-let gltfExporter = GLTFLoader;
-let promise;
-function GltfInit() {
-  if (promise) return promise;
-  promise = new Promise(async (resolve) => {
-    try {
-      const { GLTFLoader: GLTFLoader2 } = await (typeof window !== "undefined" ? import("three/addons/loaders/GLTFLoader.js") : include("node-three-gltf", false));
-      gltfLoader = GLTFLoader2;
-      const { GLTFExporter: GLTFExporter2 } = await (typeof window !== "undefined" ? import("three/addons/exporters/GLTFExporter.js") : include("node-three-gltf", false));
-      gltfExporter = GLTFExporter2;
-    } catch (error) {
-      console.error(error);
-    }
-    resolve(true);
-  });
-  return promise;
-}
-const gltf = {
-  get GLTFLoader() {
-    return gltfLoader;
-  },
-  get GLTFExporter() {
-    return gltfExporter;
+const gltf = {
+  get GLTFLoader() {
+    return gltfLoader;
+  },
+  get GLTFExporter() {
+    return gltfExporter;
   }
 };
 let loader;
@@ -19013,100 +18662,452 @@ class DoorFind {
       line.getAnotherPoint(dock.point).copy(point2);
     }
   }
-  /**
-   * 对门的两侧进行吸附
-   * @param dock 
+  /**
+   * 对门的两侧进行吸附
+   * @param dock 
+   * @param line 
+   * @param maxAngle 找到的门线与原来的之间最大夹角 
+   * @returns 
+   */
+  adsorpt(dock, line, maxAngle = 70) {
+    const length = line.length(), targetDirect = dock.dockLine.getAnotherPoint(dock.dockPoint).directionFrom(dock.dockPoint);
+    dock.point.copy(dock.dockPoint);
+    const list = this.grid.queryCircle(dock.point, length * 2, true).map((item) => {
+      return { ...item };
+    }).filter((item) => item.userData !== dock.dockLine).filter((item) => {
+      return this.grid.queryPoint(item.point, true).length === 0;
+    }).filter((item) => {
+      const d1 = item.point.directionFrom(dock.point);
+      return d1.angleBetween(targetDirect, "angle") > 70;
+    }).filter((item) => {
+      const line2 = item.userData, d1 = item.point.directionFrom(dock.point), d2 = line2.getAnotherPoint(item.point).directionFrom(item.point), d3 = dock.dockPoint.directionFrom(dock.dockLine.getAnotherPoint(dock.dockPoint));
+      return d1.angleBetween(d2, "angle") < maxAngle && d3.angleBetween(d2, "angle") < maxAngle;
+    }).filter((item) => {
+      const queryLine = new LineSegment(item.point.clone(), dock.point.clone());
+      queryLine.startShrink(0.01).endShrink(1e-3);
+      return this.quadtree.queryLineSegment(queryLine).length === 0;
+    }).filter((item) => {
+      return item.point.distance(dock.point) / length > 0.5;
+    }).filter((item) => {
+      const normal = item.point.normal(dock.point), center = new Point((item.point.x + dock.point.x) / 2, (item.point.y + dock.point.y) / 2), length2 = item.point.distance(dock.point);
+      const normalLine = new LineSegment(
+        center,
+        center.clone().add(normal.clone().multiplyScalar(length2))
+      );
+      normalLine.translate(-length2 * 0.5, normal);
+      const results = this.quadtree.queryLineSegment(normalLine).filter((result) => result.line !== line && result.line !== dock.dockLine);
+      return results.length === 0;
+    }).sort((a2, b4) => {
+      return getWeight(b4, dock, length) - getWeight(a2, dock, length);
+    });
+    if (list.length) {
+      const line2 = list[0].userData;
+      let point2 = list[0].point;
+      if (dock.dockLine.isPerpendicularTo(line2, 25)) {
+        const p2 = line2.projectPoint(dock.point, true);
+        if (p2) point2 = p2;
+      }
+      return point2;
+    }
+    return this.extendLink(dock, line);
+  }
+  extendLink(dock, line) {
+    const length = line.length();
+    const direct = dock.dockPoint.directionFrom(dock.dockLine.getAnotherPoint(dock.dockPoint)), queryLine = new LineSegment(
+      dock.dockPoint,
+      dock.dockPoint.clone().add(direct.multiplyScalar(length * 2))
+    );
+    let result = this.quadtree.queryLineSegment(queryLine, false).filter((item) => item.line !== dock.dockLine && item.line !== line).map((item) => item.line.getIntersection(queryLine)).filter((p2) => !!p2).filter((p2) => p2.distance(dock.dockPoint, true) > 0.2).sort((a2, b4) => a2.distance(dock.dockPoint, true) - b4.distance(dock.dockPoint, true));
+    if (result.length) return result[0];
+    const normal = dock.dockLine.normal(), nNormal = normal.multiplyScalar(-1), direct2 = line.getAnotherPoint(dock.point).directionFrom(dock.point);
+    if (direct2.angleBetween(normal) < direct2.angleBetween(nNormal)) {
+      queryLine.set(
+        dock.dockPoint,
+        dock.dockPoint.clone().add(normal.multiplyScalar(length * 2))
+      );
+    } else {
+      queryLine.set(
+        dock.dockPoint,
+        dock.dockPoint.clone().add(nNormal.multiplyScalar(length * 2))
+      );
+    }
+    result = this.quadtree.queryLineSegment(queryLine, false).filter((item) => {
+      item.line !== dock.dockLine && item.line !== line;
+    }).map((item) => {
+      const point2 = item.line.getIntersection(queryLine);
+      if (point2) return point2;
+    }).filter((p2) => !!p2).filter((p2) => p2.distance(dock.dockPoint, true) > 0.2).sort((a2, b4) => a2.distance(dock.dockPoint, true) - b4.distance(dock.dockPoint, true));
+    if (result.length) return result[0];
+    return null;
+  }
+  getLines() {
+    return this.lines.filter((line) => {
+      if (line.userData.isDoor && line.length() < 0.4) return false;
+      return true;
+    });
+  }
+}
+function init(lines, option) {
+  buildDoubleWallGroup.setTrajectory(option.trajectory);
+  return lines;
+}
+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 parallel(line, baseline) {
+  const currentAngle = Math.atan2(line.end.y - line.start.y, line.end.x - line.start.x);
+  const targetAngle = Math.atan2(baseline.end.y - baseline.start.y, baseline.end.x - baseline.start.x);
+  let diff = targetAngle - currentAngle;
+  while (diff > Math.PI) diff -= 2 * Math.PI;
+  while (diff < -Math.PI) diff += 2 * Math.PI;
+  const center = line.center;
+  line.start.rotate(center, diff);
+  line.end.rotate(center, diff);
+  if (Math.abs(diff) > Math.PI / 2) line.swapValue();
+  return line;
+}
+function vertical(line, baseline) {
+  const currentAngle = Math.atan2(line.end.y - line.start.y, line.end.x - line.start.x);
+  const targetAngle = Math.atan2(baseline.end.y - baseline.start.y, baseline.end.x - baseline.start.x);
+  let diff1 = targetAngle + Math.PI / 2 - currentAngle;
+  let diff2 = targetAngle - Math.PI / 2 - currentAngle;
+  while (diff1 > Math.PI) diff1 -= 2 * Math.PI;
+  while (diff1 < -Math.PI) diff1 += 2 * Math.PI;
+  while (diff2 > Math.PI) diff2 -= 2 * Math.PI;
+  while (diff2 < -Math.PI) diff2 += 2 * Math.PI;
+  const diff = Math.abs(diff1) < Math.abs(diff2) ? diff1 : diff2;
+  const center = line.center;
+  line.start.rotate(center, diff);
+  line.end.rotate(center, diff);
+  if (Math.abs(diff) > Math.PI / 2) line.swapValue();
+  return line;
+}
+class AxisAlignCorr {
+  static start(lines, targettLine) {
+    return new AxisAlignCorr(lines, targettLine).start();
+  }
+  lines;
+  baseline;
+  grid;
+  constructor(lines, baseline) {
+    this.lines = lines;
+    this.baseline = baseline;
+    this.grid = createPointVirtualGrid(lines);
+  }
+  visited = /* @__PURE__ */ new Set();
+  newLines = [];
+  start() {
+    for (let i = 0; i < this.lines.length; i++) {
+      const line = this.lines[i];
+      if (this.visited.has(line)) continue;
+      this.correction(line);
+    }
+    return [
+      ...this.lines,
+      ...this.newLines
+    ];
+  }
+  /** 添加
+   * @param lines 
+   * @returns 
+   */
+  addVisited(lines) {
+    if (lines instanceof LineSegment) lines = [lines];
+    lines.forEach((line) => this.visited.add(line));
+    return this;
+  }
+  queryPoint(point2) {
+    return this.grid.queryPoint(point2, true).filter((item) => !this.visited.has(item.userData));
+  }
+  /** 纠正
+   * @param line 
+   * @param targettLine 
+   */
+  correction(line) {
+    const startConnectList = this.queryPoint(line.start);
+    const endConnectLines = this.queryPoint(line.end);
+    this.rotate(line);
+    startConnectList.forEach(({ userData: queryLine, point: point2 }) => {
+      this.recursion(queryLine, point2, line, line.start);
+    });
+    endConnectLines.forEach(({ userData: queryLine, point: point2 }) => {
+      this.recursion(queryLine, point2, line, line.end);
+    });
+  }
+  /** 递归执行
+   * @param line 
+   * @param enterPoint 
+   */
+  recursion(line, enterPoint, nextLine, nextPoint) {
+    const otherPoint = line.getAnotherPoint(enterPoint);
+    const connectList = this.queryPoint(otherPoint);
+    this.rotate(line);
+    this.establishConnection(enterPoint, line, nextLine, nextPoint);
+    connectList.forEach(({ userData: queryLine, point: point2 }) => {
+      this.recursion(queryLine, point2, line, otherPoint);
+    });
+  }
+  /** 构建连接
+   */
+  establishConnection(point2, line, nextLine, nextPoint) {
+    if (line.isParallelTo(nextLine)) {
+      const interPoint2 = nextLine.projectPoint(point2, false);
+      const newLine = new LineSegment(point2.clone(), interPoint2?.clone() ?? nextPoint.clone());
+      newLine.length() > 1e-9 && this.newLines.push(newLine);
+      return;
+    }
+    const interPoint = nextLine.projectPoint(point2, false);
+    if (!interPoint) return;
+    point2.copy(interPoint);
+    if (nextLine.isPointOnSegment(interPoint)) return;
+    nextPoint.copy(interPoint);
+  }
+  point = new Point();
+  /** 旋转
    * @param line 
-   * @param maxAngle 找到的门线与原来的之间最大夹角 
-   * @returns 
+   * @param errAngle 
    */
-  adsorpt(dock, line, maxAngle = 70) {
-    const length = line.length(), targetDirect = dock.dockLine.getAnotherPoint(dock.dockPoint).directionFrom(dock.dockPoint);
-    dock.point.copy(dock.dockPoint);
-    const list = this.grid.queryCircle(dock.point, length * 2, true).map((item) => {
-      return { ...item };
-    }).filter((item) => item.userData !== dock.dockLine).filter((item) => {
-      return this.grid.queryPoint(item.point, true).length === 0;
-    }).filter((item) => {
-      const d1 = item.point.directionFrom(dock.point);
-      return d1.angleBetween(targetDirect, "angle") > 70;
-    }).filter((item) => {
-      const line2 = item.userData, d1 = item.point.directionFrom(dock.point), d2 = line2.getAnotherPoint(item.point).directionFrom(item.point), d3 = dock.dockPoint.directionFrom(dock.dockLine.getAnotherPoint(dock.dockPoint));
-      return d1.angleBetween(d2, "angle") < maxAngle && d3.angleBetween(d2, "angle") < maxAngle;
-    }).filter((item) => {
-      const queryLine = new LineSegment(item.point.clone(), dock.point.clone());
-      queryLine.startShrink(0.01).endShrink(1e-3);
-      return this.quadtree.queryLineSegment(queryLine).length === 0;
-    }).filter((item) => {
-      return item.point.distance(dock.point) / length > 0.5;
-    }).filter((item) => {
-      const normal = item.point.normal(dock.point), center = new Point((item.point.x + dock.point.x) / 2, (item.point.y + dock.point.y) / 2), length2 = item.point.distance(dock.point);
-      const normalLine = new LineSegment(
-        center,
-        center.clone().add(normal.clone().multiplyScalar(length2))
-      );
-      normalLine.translate(-length2 * 0.5, normal);
-      const results = this.quadtree.queryLineSegment(normalLine).filter((result) => result.line !== line && result.line !== dock.dockLine);
-      return results.length === 0;
-    }).sort((a2, b4) => {
-      return getWeight(b4, dock, length) - getWeight(a2, dock, length);
+  rotate(line, errAngle = 45) {
+    const baseline = this.baseline;
+    this.point.copy(line.start);
+    if (line.isParallelTo(baseline, errAngle)) parallel(line, baseline);
+    else vertical(line, baseline);
+    this.addVisited(line);
+  }
+}
+function shortDistanceLink(lines, radius = 0.1) {
+  const dpSet = findDiscretePoint(lines.filter((line) => !line.userData.isDoor)), pointVirtualGrid = createPointVirtualGrid(dpSet.map((v2) => v2)), appendLines = [], visited = /* @__PURE__ */ new Set();
+  const getWeight2 = (target, point2, line) => {
+    if (target.weight) return target.weight;
+    const targetLine = target.userData, targetPoint = target.point;
+    const direct1 = line.getAnotherPoint(point2).directionFrom(point2), direct2 = targetLine.getAnotherPoint(targetPoint).directionFrom(targetPoint), direct3 = targetPoint.directionFrom(point2), angle = direct1.angleBetween(direct2), angle2 = direct1.angleBetween(direct3), length = point2.distance(target.point), weight = 1 - length / radius + angle / Math.PI * 1.2 + (1 - angle2 / Math.PI) * 1.2;
+    target.weight = weight;
+    return weight;
+  };
+  for (const [point2, line] of dpSet) {
+    if (line.userData.isDoor) continue;
+    if (visited.has(point2)) continue;
+    const list = pointVirtualGrid.queryCircle(point2, radius, true).map((item) => Object.assign({}, item)).filter((item) => {
+      const targetLine2 = item.userData, targetPoint2 = item.point, direct1 = line.getAnotherPoint(point2).directionFrom(point2), direct2 = targetLine2.getAnotherPoint(targetPoint2).directionFrom(targetPoint2), angle = direct1.angleBetween(direct2, "angle");
+      return angle > 90;
+    }).sort((a2, b4) => getWeight2(b4, point2, line) - getWeight2(a2, point2, line));
+    if (list.length === 0) continue;
+    const { point: targetPoint } = list[0];
+    const targetLine = list[0].userData;
+    visited.add(point2);
+    visited.add(targetPoint);
+    const projectLine1 = line.projectLineSegment(targetLine), projectLine2 = targetLine.projectLineSegment(line), len1 = projectLine1.length(), len2 = projectLine2.length();
+    if (len1 === 0 && len2 === 0) appendLines.push(new LineSegment(point2.clone(), list[0].point.clone()));
+    else appendLines.push(new LineSegment(projectLine1.center, projectLine2.center));
+  }
+  return [...lines, ...appendLines];
+}
+function preprocessing(lines) {
+  const pointVirtualGrid = new PointVirtualGrid(), quadtree = new Quadtree(Box2.fromByLineSegment(...lines)), doors = [];
+  lines.forEach((line) => {
+    if (line.userData.isDoor) doors.push(line);
+    else {
+      line.points.forEach((p2) => pointVirtualGrid.insert(p2, line));
+      quadtree.insert(line);
+    }
+  });
+  doors.forEach((door) => {
+    const startIntersection = pointVirtualGrid.queryPoint(door.start);
+    const endIntersection = pointVirtualGrid.queryPoint(door.end);
+    if (startIntersection.length) door.userData.startIntersection = startIntersection[0].userData;
+    else door.userData.startIntersection = quadtree.queryPoint(door.start)[0]?.line;
+    if (endIntersection.length) door.userData.endIntersection = endIntersection[0].userData;
+    else door.userData.endIntersection = quadtree.queryPoint(door.end)[0]?.line;
+  });
+  lines = shortDistanceLink(lines, 0.4);
+  pointVirtualGrid.clear();
+  quadtree.clear();
+  return lines;
+}
+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.directionFrom(point2);
+    const len = line.length();
+    const result = lineQueryer.queryNearestLine(point2, {
+      radius: threshold,
+      condition: (node, projPoint) => {
+        if (line !== node.line && node.line.isPerpendicularTo(line, 35)) {
+          if (projPoint.distance(point2) < len) return true;
+          const direct2 = projPoint.directionFrom(point2);
+          return direct2.angleBetween(direct) > Math.PI * 0.5;
+        }
+        return false;
+      }
     });
-    if (list.length) {
-      const line2 = list[0].userData;
-      let point2 = list[0].point;
-      if (dock.dockLine.isPerpendicularTo(line2, 25)) {
-        const p2 = line2.projectPoint(dock.point, true);
-        if (p2) point2 = p2;
+    if (result) return modifyManager.setPoint(line, point2, result.point.clone());
+  }
+  function adsorptPoint(point2, line) {
+    const result = lineQueryer.queryNearestPoint(point2, {
+      radius: threshold,
+      condition(node) {
+        const line2 = node.userData;
+        return line2.isPerpendicularTo(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);
       }
-      return point2;
     }
-    return this.extendLink(dock, line);
   }
-  extendLink(dock, line) {
-    const length = line.length();
-    const direct = dock.dockPoint.directionFrom(dock.dockLine.getAnotherPoint(dock.dockPoint)), queryLine = new LineSegment(
-      dock.dockPoint,
-      dock.dockPoint.clone().add(direct.multiplyScalar(length * 2))
-    );
-    let result = this.quadtree.queryLineSegment(queryLine, false).filter((item) => item.line !== dock.dockLine && item.line !== line).map((item) => item.line.getIntersection(queryLine)).filter((p2) => !!p2).filter((p2) => p2.distance(dock.dockPoint, true) > 0.2).sort((a2, b4) => a2.distance(dock.dockPoint, true) - b4.distance(dock.dockPoint, true));
-    if (result.length) return result[0];
-    const normal = dock.dockLine.normal(), nNormal = normal.multiplyScalar(-1), direct2 = line.getAnotherPoint(dock.point).directionFrom(dock.point);
-    if (direct2.angleBetween(normal) < direct2.angleBetween(nNormal)) {
-      queryLine.set(
-        dock.dockPoint,
-        dock.dockPoint.clone().add(normal.multiplyScalar(length * 2))
-      );
-    } else {
-      queryLine.set(
-        dock.dockPoint,
-        dock.dockPoint.clone().add(nNormal.multiplyScalar(length * 2))
-      );
-    }
-    result = this.quadtree.queryLineSegment(queryLine, false).filter((item) => {
-      item.line !== dock.dockLine && item.line !== line;
-    }).map((item) => {
-      const point2 = item.line.getIntersection(queryLine);
-      if (point2) return point2;
-    }).filter((p2) => !!p2).filter((p2) => p2.distance(dock.dockPoint, true) > 0.2).sort((a2, b4) => a2.distance(dock.dockPoint, true) - b4.distance(dock.dockPoint, true));
-    if (result.length) return result[0];
-    return null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    line.points.map((point2) => {
+      let results = lineQueryer.pointVirtualGrid.queryPoint(point2, true);
+      if (results.length === 0 && lineQueryer.quadtree.queryCircle(point2, 1e-4).length < 2) adsorptLine(point2, line);
+    });
   }
-  getLines() {
-    return this.lines.filter((line) => {
-      if (line.userData.isDoor && line.length() < 0.4) return false;
-      return true;
+  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-4).length < 2) {
+        adsorptPoint(point2, line);
+      }
     });
   }
-}
-function init(lines, option) {
-  buildDoubleWallGroup.setTrajectory(option.trajectory);
+  modifyManager.modify();
+  lineQueryer.clear();
+  Point.adsorb(lines.flatMap((line) => line.points), 1e-4, "first");
   return lines;
 }
+function removeShortLine(lines, len = 0.01) {
+  let defaultLines = [], doorLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.userData.isDoor) doorLines.push(line);
+    else defaultLines.push(line);
+  }
+  const lineSet = findDiscretePointLine2(lines);
+  const grid = createPointVirtualGrid([...lineSet]);
+  for (let i = 0; i < doorLines.length; i++) {
+    const doorLine = doorLines[i];
+    doorLine.points.forEach((p2) => {
+      grid.queryPoint(p2, true).forEach((item) => lineSet.delete(item.userData));
+    });
+  }
+  defaultLines = defaultLines.filter((line) => !lineSet.has(line) || line.length() > len);
+  defaultLines = LineSegmentUndirectedGraph.breakpointMerging(defaultLines, (newLine, lines2) => {
+    lines2 = lines2.filter((line) => line.length() > 0);
+    mergeLineUserData(newLine, lines2);
+    newLine.userData.isBayWindow = lines2.some((line) => line.userData.isBayWindow);
+  });
+  WallInsertObject.recomputed(defaultLines);
+  return [...defaultLines, ...doorLines];
+}
+function breakpointMerging(lines) {
+  let defaultLines = [], doorLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.userData.isDoor) doorLines.push(line);
+    else defaultLines.push(line);
+  }
+  defaultLines = LineSegmentUndirectedGraph.breakpointMerging(defaultLines, mergeLineUserData);
+  doorLines = LineSegmentUndirectedGraph.breakpointMerging(doorLines, mergeLineUserData);
+  return [...defaultLines, ...doorLines];
+}
+function correction(lines, targettLine, option) {
+  lines = lines.map((line) => line.clone());
+  lines = breakpointMerging(lines);
+  lines = lineSegmentClipping(lines, 1e-9);
+  lines = preprocessing(lines);
+  lines = AxisAlignCorr.start(lines, targettLine);
+  lines = adsorption(lines, option);
+  lines = lineSegmentClipping(lines, 1e-9);
+  lines = removeShortLine(lines, 0.15);
+  let newLines = lines.filter((line) => !line.userData.isDoor);
+  let doorLines = lines.filter((line) => line.userData.isDoor);
+  newLines = buildBayWindowGroup(newLines, false);
+  const { wallGroup = true } = option ?? {};
+  if (wallGroup) {
+    newLines = DoubleWallHelper.complementSide(newLines);
+    WallInsertObject.recomputed(newLines);
+    newLines = buildDoubleWallGroup(newLines, true);
+    newLines = buildBayWindowGroup(newLines, false);
+  }
+  new WallInsertObject(lines).recomputed().merge();
+  newLines.push(...doorLines);
+  Point.adsorb(newLines.flatMap((line) => line.points), 1e-4);
+  lines = removeShortLine(lines, 0.05);
+  lines = breakpointMerging(lines);
+  return newLines;
+}
 function axisAlignCorr(lines, option, verticalReferenceLine) {
   verticalReferenceLine = verticalReferenceLine ?? findVerticalReference(lines.filter((line) => !line.userData.isDoor));
   if (verticalReferenceLine) {
     const t2 = performance.now();
-    const lineSegments = axisAlignCorr$1(lines, verticalReferenceLine, option);
+    const lineSegments = correction(lines, verticalReferenceLine, option);
     console.log("垂直纠正总消耗时间：", (performance.now() - t2).toFixed(2), "ms", "处理线段数量：", lines.length);
     return lineSegments;
   } else {
@@ -19294,7 +19295,7 @@ function stepElimination(lineSegments, findMinWidth = 0.1, onMerge) {
     let parallel2 = new PvgList();
     for (let i = 0; i < intersList.length; i++) {
       const res = intersList[i];
-      if (line.isPerpendicularTo(res.userData)) {
+      if (line.isPerpendicularTo(res.userData, 5)) {
         count++;
         firstLine = res.userData;
         firstPoint = res.point;
@@ -19397,9 +19398,6 @@ function stepEliminationMerge(target, _, source, oldLine) {
 function linesSmoothing(lines, _) {
   repetitiveTask(2, () => lines = stepElimination(lines, 0.1, stepEliminationMerge));
   WallInsertObject.recomputed(lines);
-  TEST = true;
-  lines = stepElimination(lines, 0.1, stepEliminationMerge);
-  TEST = false;
   return lines;
 }
 const PRE_PROCESSOR = {
@@ -21950,7 +21948,6 @@ const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   Side,
   UndirectedGraph,
   UnionFindSet,
-  axisAlignCorr: axisAlignCorr$1,
   buildBayWindowGroup,
   buildDoubleWallGroup,
   buildDoubleWallGroup_,

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

@@ -1,4 +1,3 @@
-export * from './lineHandle/AxisAlignCorr';
 export * from './lineHandle/BoundExt';
 export * from './lineHandle/lineSegmentClipping';
 export * from './lineHandle/DoubleWallHelper';

package/src/utils/DxfSystem/utils/lineHandle/CadPreProcessor/axisAlignCorr.d.ts

@@ -1,5 +1,15 @@
 import { LineSegment } from '../../../../algorithmsStructures/LineSegment';
-import { LineUserData, SetDataOption } from '../../../type';
+import { SetDataOption, LineUserData } from '../../../type';
+/**
+ * 门的障碍物清理
+ */
+/**
+ * 轴对齐垂直修正
+ * @param lines 待调整线段组
+ * @param targettLine 轴线段
+ * @returns
+ */
+export declare function correction(lines: LineSegment<LineUserData>[], targettLine: LineSegment<LineUserData>, option?: SetDataOption): LineSegment<any>[];
 /** 轴对齐垂直纠正
 * @param lines
 * @param option

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

@@ -1,12 +0,0 @@
-import { LineSegment } from '../../../algorithmsStructures/LineSegment';
-import { SetDataOption, LineUserData } from '../../type';
-/**
- * 门的障碍物清理
- */
-/**
- * 轴对齐垂直修正
- * @param lines 待调整线段组
- * @param targettLine 轴线段
- * @returns
- */
-export declare function axisAlignCorr(lines: LineSegment<LineUserData>[], targettLine: LineSegment<LineUserData>, option?: SetDataOption): LineSegment<any>[];