build-dxf 0.1.83 → 0.1.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "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 = 0.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 将当前点的坐标归一化为单位向量
@@ -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,
@@ -7465,7 +7477,6 @@ 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) => {
@@ -8297,6 +8308,67 @@ 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 
+   * @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);
@@ -8467,6 +8539,66 @@ function preprocessing(lines) {
   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++) {
@@ -8508,6 +8640,7 @@ function axisAlignCorr$1(lines, targettLine, option) {
   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);
@@ -10066,8 +10199,8 @@ class Scenario {
     new THREE.LineBasicMaterial({
       color: 65280
     });
-    const MobileX = this.angleToXAxisDegrees(data.start.x, data.start.y, data.end.x, data.end.y, DEFAULT_WALL_HALF_WIDTH, true);
-    const MobileY = this.angleToXAxisDegrees(data.start.x, data.start.y, data.end.x, data.end.y, DEFAULT_WALL_HALF_WIDTH, false);
+    const MobileX = this.angleToXAxisDegrees(data.start.x, data.start.y, data.end.x, data.end.y, DEFAULT_WALL_HALF_WIDTH + 0.01, true);
+    const MobileY = this.angleToXAxisDegrees(data.start.x, data.start.y, data.end.x, data.end.y, DEFAULT_WALL_HALF_WIDTH + 0.01, false);
     let startingPoint = this.xinLine(MobileX, MobileY, data.start, 0);
     let finishLine = this.xinLine(MobileX, MobileY, data.end, 1);
     const grid = createPointVirtualGrid(this.lines);
@@ -10217,18 +10350,22 @@ class Scenario {
   // 窗的处理
   windowTreatment(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 : 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 : 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 = this.xinLine(MobileX, MobileY, doorList.start, wallHeight);
     let finishLine = this.xinLine(MobileX, MobileY, doorList.end, wallHeight);
-    startingPoint.push(finishLine[1]);
-    startingPoint.push(finishLine[0]);
-    return this.winHoleOpening(startingPoint, mesh, dblWin.userData.groundClearance, dblWin.userData.height);
+    let x = MobileX > 0 ? 3e-3 : -3e-3;
+    let y = MobileY > 0 ? 3e-3 : -3e-3;
+    let startingPoint1 = this.xinLine1(y, x, startingPoint[0], startingPoint[1], 0, wallHeight);
+    let finishLine1 = this.xinLine1(y, x, finishLine[0], finishLine[1], 1, wallHeight);
+    startingPoint1.push(finishLine1[1]);
+    startingPoint1.push(finishLine1[0]);
+    return this.winHoleOpening(startingPoint1, mesh, dblWin.userData.groundClearance, dblWin.userData.height);
   }
   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]);
@@ -10239,8 +10376,8 @@ class Scenario {
   TheHandlingOfTheDoor1(data) {
     const wallHeightc = data.userData.height ? data.userData.height : this.wallHeight;
     const doorList = data;
-    const MobileX = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, DEFAULT_WALL_HALF_WIDTH, true);
-    const MobileY = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, DEFAULT_WALL_HALF_WIDTH, false);
+    const MobileX = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, DEFAULT_WALL_HALF_WIDTH + 0.01, true);
+    const MobileY = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, DEFAULT_WALL_HALF_WIDTH + 0.01, false);
     let startingPoint = this.xinLine(MobileX, MobileY, doorList.start, doorList.userData.height ? doorList.userData.height : this.wallHeight);
     let finishLine = this.xinLine(MobileX, MobileY, doorList.end, doorList.userData.height ? doorList.userData.height : this.wallHeight);
     const quadtree = createQuadtree(this.lines);
@@ -10288,8 +10425,8 @@ class Scenario {
       const dy = point2.y - point1.y;
       const angleRad = Math.atan2(dy, dx);
       const distance2 = point1.distanceTo(point2);
-      const MobileX = this.angleToXAxisDegrees(doorList[i].start.x, doorList[i].start.y, doorList[i].end.x, doorList[i].end.y, DEFAULT_WALL_HALF_WIDTH, true);
-      const MobileY = this.angleToXAxisDegrees(doorList[i].start.x, doorList[i].start.y, doorList[i].end.x, doorList[i].end.y, DEFAULT_WALL_HALF_WIDTH, false);
+      const MobileX = this.angleToXAxisDegrees(doorList[i].start.x, doorList[i].start.y, doorList[i].end.x, doorList[i].end.y, DEFAULT_WALL_HALF_WIDTH + 0.01, true);
+      const MobileY = this.angleToXAxisDegrees(doorList[i].start.x, doorList[i].start.y, doorList[i].end.x, doorList[i].end.y, DEFAULT_WALL_HALF_WIDTH + 0.01, false);
       let startingPoint = this.xinLine(MobileX, MobileY, doorList[i].start, doorList[i].userData.height ? doorList[i].userData.height : this.wallHeight);
       let finishLine = this.xinLine(MobileX, MobileY, doorList[i].end, doorList[i].userData.height ? doorList[i].userData.height : this.wallHeight);
       const quadtree = createQuadtree(this.lines);
@@ -10882,7 +11019,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));
@@ -19261,6 +19397,9 @@ 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 = {
@@ -22025,7 +22164,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/lineHandle/CadPreProcessor/axisAlignCorr.d.ts

@@ -1,9 +1,9 @@
 import { LineSegment } from '../../../../algorithmsStructures/LineSegment';
-import { SetDataOption } from '../../../type';
+import { LineUserData, SetDataOption } from '../../../type';
 /** 轴对齐垂直纠正
 * @param lines
 * @param option
 * @param verticalReferenceLine
 * @returns
 */
-export declare function axisAlignCorr(lines: LineSegment[], option: SetDataOption, verticalReferenceLine?: LineSegment): LineSegment<any>[];
+export declare function axisAlignCorr(lines: LineSegment<LineUserData>[], option: SetDataOption, verticalReferenceLine?: LineSegment): LineSegment<any>[];

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;