build-dxf 0.1.84 → 0.1.86

package/package.json

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

package/src/build.js

@@ -1562,19 +1562,21 @@ class LineSegment {
    * 两条线段或角度是否平行，忽略方向
    * @param line 
    */
-  isParallelTo(angle, eps = 1) {
-    if (angle instanceof LineSegment) return this.isParallelTo(this.includedAngle(angle), eps);
-    if (typeof angle !== "number") angle = Number(angle);
-    return angle < eps || angle > 180 - eps;
+  isParallelTo(line, eps = 1) {
+    const d1 = this.direction();
+    const d2 = line.direction();
+    const angle = d1.angle(d2, { unit: "degree", range: "180" });
+    return Math.min(angle, 180 - angle) < eps;
   }
   /** 两条线段或角度是否 垂直， 忽略方向
    * @param line 
    * @param errAngle 
    * @returns 
    */
-  isPerpendicularTo(angle, eps = 0.1) {
-    if (angle instanceof LineSegment) return this.isPerpendicularTo(this.includedAngle(angle), eps);
-    if (typeof angle !== "number") angle = Number(angle);
+  isPerpendicularTo(line, eps = 1) {
+    const d1 = this.direction();
+    const d2 = line.direction();
+    const angle = d1.angle(d2, { unit: "degree", range: "180" });
     return Math.abs(angle - 90) < eps;
   }
   /** 
@@ -2286,6 +2288,7 @@ class LineSegment {
     };
   }
 }
+const PRECISION = 1e-6;
 class Point {
   x;
   y;
@@ -2428,6 +2431,14 @@ class Point {
     this.y = Number(this.y.toFixed(count));
     return this;
   }
+  /** 精度处理
+   * @returns 
+   */
+  precision() {
+    this.x = Math.round(this.x / PRECISION) * PRECISION;
+    this.y = Math.round(this.y / PRECISION) * PRECISION;
+    return this;
+  }
   /**
    * 归一化
    * @description 将当前点的坐标归一化为单位向量
@@ -3310,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);
     });
@@ -6655,8 +6666,7 @@ function buildDoubleWallGroup_(lines_, clearInternalLine = false) {
     // peDoors,
     peDoubleDoors
   } = initData(lines_);
-  const { notFoundLines, circlesList } = getPeDoubleDoorCircles(otherLines, peDoubleDoors);
-  otherLines.push(...notFoundLines);
+  const { circlesList } = getPeDoubleDoorCircles(otherLines, peDoubleDoors);
   let { internalEdges, circles } = maxiCircles.maxiCircles(otherLines, (circles2) => circles2.filter(isPolyHasTrajectoryPoint));
   const { circles: finalCircles } = maxiCircles.mergeCircles([...circlesList, ...circles], internalEdges);
   lines_.forEach((line) => LineGroupType.removeByTypes(line, ["doubleWall", "wall"]));
@@ -6817,7 +6827,8 @@ class DoubleWallHelper {
     lines = lineSegmentClipping(lines, 1e-9);
     quadtree.clear();
     lines.push(...otherLines);
-    return lines.filter((line) => line.length() > 1e-9);
+    Point.adsorb(lines.flatMap((line) => line.points), 1e-4);
+    return lines.filter((line) => line.length() > 1e-5);
   }
   /**
    * 创建分组
@@ -7398,6 +7409,7 @@ class ThreeVJiaJson extends Pipeline {
    */
   wallHoleHandle({ data: { lines, json } }) {
     lines.forEach((line) => {
+      if (line.length() < 1e-4) return;
       let type = holeTypeMap[line.userData.type] ?? "WALL_HOLE";
       const hole = {
         id: this.index++,
@@ -7418,8 +7430,8 @@ class ThreeVJiaJson extends Pipeline {
    * @param param0 
    * @returns 
    */
-  balconyRailing({ data }) {
-    return data;
+  balconyRailing({ data: { lines }, cache }) {
+    cache.wallLines.push(...lines);
   }
   /** 转换
    * @returns 
@@ -7447,7 +7459,7 @@ class ThreeVJiaJson extends Pipeline {
         ID: this.index++,
         start: line.start.toJson2D(),
         end: line.end.toJson2D(),
-        thickness: line.userData.wallWidth ? line.userData.wallWidth : 0.12,
+        thickness: Math.max(line.userData.wallWidth ? line.userData.wallWidth : 0.12, 0.12),
         type: "LINE",
         isDoor: false,
         loadBearingWall: false,
@@ -8297,236 +8309,6 @@ class DxfDataPlugin extends Pipeline {
     DxfDataPlugin.initData(cad, this.lines);
   }
 }
-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 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 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 = 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 
@@ -10231,8 +10013,8 @@ class Scenario {
   }
   windowTreatment1(dblWin, mesh, wallHeight) {
     const doorList = dblWin;
-    const MobileX = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, doorList.userData.wallWidth ? doorList.userData.wallWidth + 1e-4 : 0.5, true);
-    const MobileY = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, doorList.userData.wallWidth ? doorList.userData.wallWidth + 1e-4 : 0.5, false);
+    const MobileX = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, doorList.userData.wallWidth ? doorList.userData.wallWidth + 1e-3 : 0.5, true);
+    const MobileY = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, doorList.userData.wallWidth ? doorList.userData.wallWidth + 1e-3 : 0.5, false);
     let startingPoint = BayWindow.Instance.xinLine(MobileX, MobileY, doorList.start, wallHeight);
     let finishLine = BayWindow.Instance.xinLine(MobileX, MobileY, doorList.end, wallHeight);
     startingPoint.push(finishLine[1]);
@@ -10651,14 +10433,12 @@ class Scenario {
   xinLine1(x, y, pointa, pointb, num, wallHeight) {
     let point1;
     let point2;
-    let xx = x > 0 ? x + -1e-3 : 1e-3;
-    let yy = y > 0 ? y + -1e-3 : 1e-3;
     if (num === 0) {
-      point1 = new THREE.Vector3(pointa.x - xx, pointa.y - yy, wallHeight);
-      point2 = new THREE.Vector3(pointb.x - xx, pointb.y - yy, wallHeight);
+      point1 = new THREE.Vector3(pointa.x - x, pointa.y - y, wallHeight);
+      point2 = new THREE.Vector3(pointb.x - x, pointb.y - y, wallHeight);
     } else {
-      point1 = new THREE.Vector3(pointa.x + xx, pointa.y + yy, wallHeight);
-      point2 = new THREE.Vector3(pointb.x + xx, pointb.y + yy, wallHeight);
+      point1 = new THREE.Vector3(pointa.x + x, pointa.y + y, wallHeight);
+      point2 = new THREE.Vector3(pointb.x + x, pointb.y + y, wallHeight);
     }
     return [point1, point2];
   }
@@ -10888,7 +10668,6 @@ class Scenario {
   // 
   createAPlane(lines, menList) {
     const lineList = lines;
-    console.log("初始数据", lines);
     let precision = lineList.map((pos) => {
       pos.start.x = parseFloat(pos.start.x.toFixed(3));
       pos.start.y = parseFloat(pos.start.y.toFixed(3));
@@ -18972,11 +18751,363 @@ 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 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 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 {
@@ -19164,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;
@@ -21817,7 +21948,6 @@ const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   Side,
   UndirectedGraph,
   UnionFindSet,
-  axisAlignCorr: axisAlignCorr$1,
   buildBayWindowGroup,
   buildDoubleWallGroup,
   buildDoubleWallGroup_,
@@ -22031,7 +22161,6 @@ async function buildJson(opt) {
   if (opt.axisAlignCorr !== false) {
     dxfSystem.Dxf.addPreProcessor(PRE_PROCESSOR.AxisAlignCorr);
     dxfSystem.Dxf.addPreProcessor(PRE_PROCESSOR.LinesSmoothing);
-    dxfSystem.Dxf.addPreProcessor(PRE_PROCESSOR.RemoveShortDoubleWall);
   }
   if (trajectory2) {
     if (typeof trajectory2 === "string") {

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/tools/lineDataToThreeVJiaJson.d.ts

@@ -99,7 +99,7 @@ export declare class ThreeVJiaJson extends Pipeline<DataOption, ICache> {
      * @param param0
      * @returns
      */
-    balconyRailing({ data }: HandlerContext<DataOption>): DataOption;
+    balconyRailing({ data: { lines }, cache }: HandlerContext<DataOption, ICache>): void;
     /** 转换
      * @returns
      */

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

@@ -139,13 +139,13 @@ export declare class LineSegment<T = Record<string, any>> {
      * 两条线段或角度是否平行，忽略方向
      * @param line
      */
-    isParallelTo(angle: LineSegment | number, eps?: number): boolean;
+    isParallelTo(line: LineSegment, eps?: number): boolean;
     /** 两条线段或角度是否 垂直， 忽略方向
      * @param line
      * @param errAngle
      * @returns
      */
-    isPerpendicularTo(angle: LineSegment | number, eps?: number): boolean;
+    isPerpendicularTo(line: LineSegment, eps?: number): boolean;
     /**
      * @param line
      * @param eps

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

@@ -73,6 +73,10 @@ export declare class Point<T = Record<string, any>> {
      * @param count
      */
     fixed(count: number): this;
+    /** 精度处理
+     * @returns
+     */
+    precision(): this;
     /**
      * 归一化
      * @description 将当前点的坐标归一化为单位向量

package/src/utils/modelScenario/scenario.d.ts

@@ -47,7 +47,7 @@ export default class Scenario {
     executionOffset(data: any, index: number, wallHeight: number): THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null | undefined;
     windowTreatment(dblWin: any, mesh: any, wallHeight: number): Brush;
     windowTreatment1(dblWin: any, mesh: any, wallHeight: number): Brush;
-    TheHandlingOfTheDoor1(data: LineSegment<LineUserData>): THREE.Vector3[];
+    TheHandlingOfTheDoor1(data: LineSegment<LineUserData>): any[];
     TheHandlingOfTheDoor(data: LineSegment<LineUserData>[]): void;
     doorCenterOffset(distanceFromB: number, point: any, pointc: THREE.Vector3): THREE.Vector3;
     installWindows(data: any, index: string): void;
@@ -60,7 +60,7 @@ export default class Scenario {
     doorHoleOpening(wallHeight: number, data: any, data1: any, groundHeight?: number, Height?: number, distance?: number, center?: THREE.Vector3, angleRad?: any, index?: string, doorList?: LineSegment): void;
     angleToXAxisDegrees(x1: number, y1: number, x2: number, y2: number, wide: number, cd: boolean): number;
     xinLine(x: number, y: number, point: THREE.Vector3 | Point, wallHeight: number): THREE.Vector3[];
-    xinLine1(x: number, y: number, pointa: THREE.Vector3, pointb: THREE.Vector3, num: number, wallHeight: number): THREE.Vector3[];
+    xinLine1(x: number, y: number, pointa: THREE.Vector3, pointb: THREE.Vector3, num: number, wallHeight: number): any[];
     createParallelepipedFromBase(points: any, height: number): THREE.ExtrudeGeometry;
     correctionSorting(bitem: any): {
         dian: THREE.Vector3;

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>[];