build-dxf 0.1.150 → 0.1.152

package/package.json

@@ -1,49 +1,49 @@
-{
-  "name": "build-dxf",
-  "version": "0.1.150",
-  "description": "",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./src/build.d.ts",
-        "default": "./src/index.js",
-        "style": "./src/index.css"
-      },
-      "require": {
-        "types": "./src/build.d.ts",
-        "default": "./src/index.js"
-      }
-    },
-    "./RenderPlugin": {
-      "import": {
-        "types": "./src/utils/DxfSystem/plugin/RenderPlugin/index.d.ts",
-        "default": "./src/index2.js"
-      },
-      "require": {
-        "types": "./src/index.d.ts",
-        "default": "./src/index2.js"
-      }
-    },
-    "./index.css": "./src/index.css"
-  },
-  "style": "src/index.css",
-  "dependencies": {
-    "@tweenjs/tween.js": ">=25.0.0",
-    "clipper-lib": ">=6.4.2",
-    "dxf-writer": ">=1.18.4",
-    "vue": ">=3.0.0",
-    "canvas": "3.2.0",
-    "three-mesh-bvh": "^0.6.6",
-    "three-bvh-csg": ">=0.0.17",
-    "three-csg-ts": ">=3.2.0",
-    "three": ">=0.181.0",
-    "node-three-gltf": "2.1.0"
-  },
-  "author": "夏过初秋",
-  "license": "UNLICENSED"
-}
+{
+  "name": "build-dxf",
+  "version": "0.1.152",
+  "description": "",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./src/build.d.ts",
+        "default": "./src/index.js",
+        "style": "./src/index.css"
+      },
+      "require": {
+        "types": "./src/build.d.ts",
+        "default": "./src/index.js"
+      }
+    },
+    "./RenderPlugin": {
+      "import": {
+        "types": "./src/utils/DxfSystem/plugin/RenderPlugin/index.d.ts",
+        "default": "./src/index2.js"
+      },
+      "require": {
+        "types": "./src/index.d.ts",
+        "default": "./src/index2.js"
+      }
+    },
+    "./index.css": "./src/index.css"
+  },
+  "style": "src/index.css",
+  "dependencies": {
+    "@tweenjs/tween.js": ">=25.0.0",
+    "clipper-lib": ">=6.4.2",
+    "dxf-writer": ">=1.18.4",
+    "vue": ">=3.0.0",
+    "canvas": "3.2.0",
+    "three-mesh-bvh": "^0.6.6",
+    "three-bvh-csg": ">=0.0.17",
+    "three-csg-ts": ">=3.2.0",
+    "three": ">=0.181.0",
+    "node-three-gltf": "2.1.0"
+  },
+  "author": "夏过初秋",
+  "license": "UNLICENSED"
+}

package/src/build.js

@@ -2681,7 +2681,7 @@ class Quadtree {
     }
     return result;
   }
-  raycaster(origin, direct, near = 0, far = 10) {
+  raycast(origin, direct, near = 0, far = 10) {
     const result = [];
     const rayBox = new Box2(
       Math.min(origin.x, origin.x + direct.x * far),
@@ -2715,7 +2715,7 @@ class Quadtree {
     }
     if (!this.isLeaf) {
       for (const child of this.children) {
-        result.push(...child.raycaster(origin, direct, near, far));
+        result.push(...child.raycast(origin, direct, near, far));
       }
     }
     if (this.depth == 1) result.sort((a2, b4) => a2.distance - b4.distance);
@@ -9955,7 +9955,7 @@ class BoundExt {
       let appendLines = [];
       exteriorLines.forEach((line) => {
         const mode = line.userData.expandDirect, direction = mode === "left" ? line.getRightDirection() : line.getLeftDirection();
-        const intersectCount = quadtree.raycaster(line.center, direction, 1e-3, wallWidth).length;
+        const intersectCount = quadtree.raycast(line.center, direction, 1e-3, wallWidth).length;
         if (intersectCount > 0) return;
         line.points.forEach((point2) => {
           const id = point2.hashCode();
@@ -10227,8 +10227,8 @@ function clippingInsertObjectDoubleWall(lines) {
         const wioLine = WallHole.holeDataToLine(line, d2);
         wioLine.setLength(wioLine.length - 4e-3);
         const len = wioLine.length;
-        let startResults = quadtree.raycaster(wioLine.start, normal, 1e-4, far).filter((item) => item.targetLine.isParallelTo(wioLine));
-        let endResults = quadtree.raycaster(wioLine.end, normal, 1e-4, far).filter((item) => item.targetLine.isParallelTo(wioLine));
+        let startResults = quadtree.raycast(wioLine.start, normal, 1e-4, far).filter((item) => item.targetLine.isParallelTo(wioLine));
+        let endResults = quadtree.raycast(wioLine.end, normal, 1e-4, far).filter((item) => item.targetLine.isParallelTo(wioLine));
         if (startResults.length > 1) startResults = startResults.filter((item) => item.targetLine.projectLineSegment(wioLine).length / len > 0.01);
         if (endResults.length > 1) endResults = endResults.filter((item) => item.targetLine.projectLineSegment(wioLine).length / len > 0.01);
         if (startResults.length === 0 || endResults.length === 0) return;
@@ -13540,6 +13540,7 @@ class Scenario {
   box;
   singleLineWallValue;
   liangNum;
+  zhuNum;
   static _instance;
   static get Instance() {
     return Scenario._instance;
@@ -13552,6 +13553,7 @@ class Scenario {
     this.controls = controls;
     this.axesHelper = new THREE.AxesHelper(20);
     this.liangNum = 0;
+    this.zhuNum = 0;
     this.scene.add(this.axesHelper);
     this.group = null;
     this.closedArray = [];
@@ -13620,6 +13622,7 @@ class Scenario {
     }
     this.group = new Group$1();
     this.liangNum = 0;
+    this.zhuNum = 0;
     this.expandedList = [];
     if (!BayWindow.Instance) new BayWindow();
     BayWindow.Instance.bayWindowExpansion = [];
@@ -13732,7 +13735,14 @@ class Scenario {
           }
           return false;
         });
-        const Mesh = this.drawTheModel(E, 0, Number(i), wallHeight, a2[i]);
+        let Mesh;
+        if (a2[i][0].userData.type === "pillar") {
+          Mesh = this.generateColumnModel(E, a2[i], wallHeight);
+          this.group.add(Mesh);
+          continue;
+        } else {
+          Mesh = this.drawTheModel(E, 0, Number(i), wallHeight, a2[i]);
+        }
         if (Mesh) {
           Mesh.material.envMap = texture;
           Mesh.material.needsUpdate = true;
@@ -13835,6 +13845,7 @@ class Scenario {
         const edges = new THREE.EdgesGeometry(geometry);
         new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0 }));
         if (colorValue && liangOriginalData) {
+          cube.material.color = new THREE.Color(5214420);
           const point1 = new THREE.Vector3(liangOriginalData.start.x, liangOriginalData.start.y, 0);
           const point2 = new THREE.Vector3(liangOriginalData.end.x, liangOriginalData.end.y, 0);
           this.liangNum = this.liangNum + 1;
@@ -13891,8 +13902,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 + 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);
+    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);
     let startingPoint = this.xinLine(MobileX, MobileY, data.start, 0);
     let finishLine = this.xinLine(MobileX, MobileY, data.end, 1);
     const grid = PointSpatialHash.fromByLines(this.lines);
@@ -14665,7 +14676,20 @@ class Scenario {
           a2 = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x };
         }
         const wallHeight = listS[x].wallHeight;
-        let Mesh = this.executionOffset(a2, Number(x) / 2, wallHeight, winDraw);
+        let Mesh;
+        let status = false;
+        for (const y in winDraw) {
+          if (winDraw[Number(y)].userData.type === "beam") {
+            status = true;
+            Mesh = this.generateBeamModel(data[Number(x) / 2]);
+          }
+        }
+        if (status) {
+          if (Mesh) this.group.add(Mesh);
+          continue;
+        } else {
+          Mesh = this.executionOffset(a2, Number(x) / 2, wallHeight, winDraw);
+        }
         for (const y in winDraw) {
           if (winDraw[Number(y)].userData.type === "beam") {
             Mesh.userData.start = a2.start;
@@ -14725,6 +14749,96 @@ class Scenario {
       }
     }
   }
+  // 生成梁模型
+  generateBeamModel(line) {
+    if (!line.userData.expansionDirction) return null;
+    const directionX = line.userData.expansionDirction.x * line.userData.expansionWidth;
+    const directionY = line.userData.expansionDirction.y * line.userData.expansionWidth;
+    let pointStart = new THREE.Vector3(line.start.x, line.start.y, this.height);
+    let pointEnd = new THREE.Vector3(line.end.x, line.end.y, this.height);
+    let startExpansion = new THREE.Vector3(pointStart.x + directionX, pointStart.y + directionY, this.height);
+    let endExpansion = new THREE.Vector3(pointEnd.x + directionX, pointEnd.y + directionY, this.height);
+    const basePoints = [pointStart, pointEnd, endExpansion, startExpansion];
+    const geometry = this.createParallelepipedFromBase(basePoints, line.userData.height);
+    const material = new THREE.MeshStandardMaterial({
+      // color: 0x4f90d4,
+      color: this.color,
+      side: THREE.DoubleSide
+    });
+    const cube = new THREE.Mesh(geometry, material);
+    const bodyGeometry = this.createParallelepipedFromBase(basePoints, line.userData.rooftopPz);
+    const brush1 = new Brush(cube.geometry);
+    brush1.updateMatrixWorld();
+    const brush2 = new Brush(bodyGeometry);
+    brush2.updateMatrixWorld();
+    const evaluator = new Evaluator();
+    const result = evaluator.evaluate(brush1, brush2, SUBTRACTION);
+    result.material = cube.material;
+    this.liangNum = this.liangNum + 1;
+    result.name = `梁_${this.liangNum}`;
+    result.userData.category = "beam";
+    result.userData.width = line.length;
+    result.userData.depth = line.userData.expansionWidth;
+    result.userData.height = line.userData.height - line.userData.rooftopPz;
+    result.userData.groundHeight = line.userData.rooftopPz;
+    return result;
+  }
+  // 生成柱模型
+  generateColumnModel(data, lines, Height) {
+    console.log(lines);
+    let basePoints = [];
+    for (const i in data) {
+      basePoints.push(new THREE.Vector3(data[i].x, data[i].y, this.height ? this.height : 0));
+    }
+    let longerSide = 0;
+    let shortSide = 100;
+    for (const w in lines) {
+      if (lines[w].length > longerSide) {
+        longerSide = lines[w].length;
+      }
+      if (lines[w].length < shortSide) {
+        shortSide = lines[w].length;
+      }
+    }
+    if (basePoints.length === 4) {
+      const spacing = basePoints[0].distanceTo(basePoints[3]);
+      if (spacing < 5e-3) {
+        return null;
+      } else {
+        const geometry = this.createParallelepipedFromBase(basePoints, Height);
+        const material = new THREE.MeshStandardMaterial({
+          // color: 0xf3feb0,
+          color: this.color,
+          side: THREE.DoubleSide
+        });
+        const cube = new THREE.Mesh(geometry, material);
+        this.zhuNum = this.zhuNum + 1;
+        cube.name = `柱_${this.zhuNum}`;
+        cube.userData.category = "pillar";
+        cube.userData.width = longerSide;
+        cube.userData.depth = shortSide;
+        cube.userData.height = Height;
+        cube.userData.groundHeight = 0;
+        return cube;
+      }
+    } else {
+      const geometry = this.createParallelepipedFromBase(basePoints, Height);
+      const material = new THREE.MeshStandardMaterial({
+        // color: 0xf3feb0,
+        color: this.color,
+        side: THREE.DoubleSide
+      });
+      const cube = new THREE.Mesh(geometry, material);
+      this.zhuNum = this.zhuNum + 1;
+      cube.name = `柱_${this.zhuNum}`;
+      cube.userData.category = "pillar";
+      cube.userData.width = longerSide;
+      cube.userData.depth = shortSide;
+      cube.userData.height = Height;
+      cube.userData.groundHeight = 0;
+      return cube;
+    }
+  }
   // 
   createAPlane(lines, menList) {
     const lineList = lines;
@@ -22771,6 +22885,40 @@ function doorToHole(lines, option) {
   });
   return lines;
 }
+function getBeamNearWallVec(line) {
+  const iterator = WallHole.getIterator(line);
+  for (const hole of iterator) {
+    if ("beamNearWallVec" in hole) return Point.from(hole.beamNearWallVec);
+  }
+}
+function beamSupportLine(lines, {}) {
+  const lsh = Quadtree.from(lines);
+  lines.forEach((line) => {
+    if (WallHole.isBeam(line)) {
+      const findLine = line.clone();
+      findLine.setLength(findLine.length - 4e-3);
+      let rectangle = line.toRectangle(2, "butt");
+      const center = findLine.center;
+      const beamNearWallVec = getBeamNearWallVec(line);
+      const list = lsh.queryRect(rectangle).filter((target) => {
+        if (target.line === line) return false;
+        if (!target.line.isParallelTo(findLine, 10)) return false;
+        if (beamNearWallVec) {
+          const dir = target.line.center.directionFrom(center);
+          if (dir.dot(beamNearWallVec) < 0) return false;
+        }
+        return true;
+      }).map((item) => item.line).sort((a2, b4) => a2.distanceToPoint(center) - b4.distanceToPoint(center));
+      if (list.length) {
+        const line2 = list[0];
+        const point2 = line2.projectPoint(center, false);
+        line.userData.expansionWidth = point2.distance(center);
+        line.userData.expansionDirction = point2.directionFrom(center);
+      }
+    }
+  });
+  return lines;
+}
 const builtinFun = {
   init,
   DoorToHole: doorToHole,
@@ -22792,7 +22940,8 @@ const builtinFun = {
   DoorSpaceHandle: doorSpaceHandle,
   /** 移除与双线墙链接的短线段
    */
-  RemoveShortDoubleWall: removeShortDoubleWall
+  RemoveShortDoubleWall: removeShortDoubleWall,
+  BeamSupportLine: beamSupportLine
 };
 const TYPE = "LINE";
 class LinePipeline extends Pipeline {
@@ -23815,7 +23964,7 @@ async function buildJson(opt, dxfSystem2 = new DxfSystem()) {
   dxfSystem2.Dxf.linePipeline.add(LinePipeline.builtin.init).add(LinePipeline.builtin.WallHeightHandle).add(LinePipeline.builtin.DoorToHole);
   doorFind && dxfSystem2.Dxf.linePipeline.add(LinePipeline.builtin.DoorFind);
   if (opt.axisAlignCorr !== false) {
-    dxfSystem2.Dxf.linePipeline.add(LinePipeline.builtin.AxisAlignCorr).add(LinePipeline.builtin.RemoveShortDoubleWall);
+    dxfSystem2.Dxf.linePipeline.add(LinePipeline.builtin.AxisAlignCorr).add(LinePipeline.builtin.RemoveShortDoubleWall).add(LinePipeline.builtin.BeamSupportLine);
   }
   if (trajectory2) {
     if (typeof trajectory2 === "string") {

package/src/dxf-system/type.d.ts

@@ -28,7 +28,7 @@ export interface HoleData {
     nearDoorId?: number;
     pair?: string | number;
 }
-export type EntityType = "beams" | "door";
+export type EntityType = "beams" | "door" | "pillar";
 export type Shape = "line" | "arc" | "polygon";
 export type WallLineGlobalOption = {
     uuid?: string;
@@ -55,6 +55,11 @@ export type WallLineGlobalOption = {
     isDoor?: boolean;
     doorAutomaticFind?: boolean;
     doorDirectConnection?: boolean;
+    expansionWidth?: number;
+    expansionDirction?: {
+        x: number;
+        y: number;
+    };
     isPassageEntrance?: boolean;
     topClearance?: number;
     isVerticalReferenceLine?: boolean;

package/src/dxf-system/utils/line-pipeline/builtin/beam-support-line.d.ts

@@ -0,0 +1,3 @@
+import { LineUserData, SetDataOption } from '../../../type';
+import { LineSegment } from '../../../../utils';
+export declare function beamSupportLine(lines: LineSegment<LineUserData>[], {}: SetDataOption): LineSegment<LineUserData>[];

package/src/dxf-system/utils/line-pipeline/builtin/index.d.ts

@@ -7,6 +7,7 @@ import { doorSpaceHandle } from './door-space-handle';
 import { removeShortDoubleWall } from './remove-short-double-wall';
 import { doorToHole } from './door-to-hole';
 import { LineSegment } from '../../../../utils/algorithms/LineSegment';
+import { beamSupportLine } from './beam-support-line';
 /**
 * 默认提供的预处理函数
 */
@@ -32,4 +33,5 @@ export declare const builtinFun: {
     /** 移除与双线墙链接的短线段
      */
     RemoveShortDoubleWall: typeof removeShortDoubleWall;
+    BeamSupportLine: typeof beamSupportLine;
 };

package/src/dxf-system/utils/line-pipeline/index.d.ts

@@ -12,6 +12,7 @@ export declare class LinePipeline<T = SetDataOption> extends Pipeline<LineSegmen
         WallHeightHandle: typeof import('./builtin/wall-height-handle').wallHeightHandle;
         DoorSpaceHandle: typeof import('./builtin/door-space-handle').doorSpaceHandle;
         RemoveShortDoubleWall: typeof import('./builtin/remove-short-double-wall').removeShortDoubleWall;
+        BeamSupportLine: typeof import('./builtin/beam-support-line').beamSupportLine;
     };
     constructor();
     add(handle: (lines: LineSegment<LineUserData>[], option: T) => LineSegment<LineUserData>[]): this;

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

@@ -73,7 +73,7 @@ export declare class Quadtree<T = any> {
      * @returns 相交的节点数组
      */
     queryLineSegment(lineSegment: LineSegment, endpoint?: boolean): QuadtreeNode<T>[];
-    raycaster(origin: Point, direct: Point, near?: number, far?: number): {
+    raycast(origin: Point, direct: Point, near?: number, far?: number): {
         targetLine: LineSegment;
         intersectPoint: Point;
         distance: number;

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

@@ -39,6 +39,7 @@ export default class Scenario {
     box: any;
     singleLineWallValue: any;
     liangNum: number;
+    zhuNum: number;
     private static _instance?;
     static get Instance(): Scenario | undefined;
     constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, renderer: THREE.WebGLRenderer, controls: OrbitControls);
@@ -73,6 +74,8 @@ export default class Scenario {
     overhangWallOffset(data: any, index: string, height: number): THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
     dashedLineCeilingTreatment(data: any, index: number | string, item: any): THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
     overallTreatmentOfSingleLineWalls(data: any): void;
+    generateBeamModel(line: any): Brush | null;
+    generateColumnModel(data: any, lines: any, Height: number): THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
     createAPlane(lines: LineSegment<Record<string, any>>[], menList: LineSegment<Record<string, any>>[]): void;
     modelLoader(): Promise<void>;
     windowModelLoader(): Promise<void>;