build-dxf 0.1.71 → 0.1.73

package/package.json

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

package/src/build.js

@@ -8443,8 +8443,15 @@ LoadModel.addNameMap("window", "窗户");
 LoadModel.addNameMap("wall", "单线墙");
 LoadModel.addNameMap("doubleWall", "双线墙");
 LoadModel.addNameMap("balcony", "阳台");
+LoadModel.addNameMap("balconyFilm", "阳台片");
+LoadModel.addNameMap("balconyFilmFilm", "阳台片片");
+LoadModel.addNameMap("balconyFilmFilmFilm", "阳台片片片");
 class BayWindow {
   bayWindowExpansion = [];
+  dottedLinePoints = [];
+  singleLine;
+  bayWindowArea;
+  bayWindowGroup;
   static _instance;
   static get Instance() {
     return BayWindow._instance;
@@ -8452,22 +8459,22 @@ class BayWindow {
   constructor() {
     BayWindow._instance = this;
     this.bayWindowExpansion = [];
+    this.dottedLinePoints = [];
+    this.singleLine = [];
+    this.bayWindowArea = null;
+    this.bayWindowGroup = new THREE.Group();
   }
   // 飘窗处理
-  overhangTreatment(data) {
+  overhangTreatment(data, singleLine) {
+    this.singleLine = singleLine;
     const grid = createPointVirtualGrid(Scenario.Instance.lines);
     for (const i in data) {
+      this.bayWindowGroup = new THREE.Group();
+      this.dottedLinePoints.push(data[i].dottedLine);
       let dashedLine = Scenario.Instance.correctionSorting([data[i].dottedLine]);
       let lines = data[i].lines.slice();
       let listS = Scenario.Instance.correctionSorting(lines);
       const centroidPoint = this.getPolygonCentroid(listS);
-      this.dashedLineTreatment(dashedLine, centroidPoint, data[i].data);
-      const geometry = new THREE.BoxGeometry(0.05, 0.05, 0.05);
-      const materialLine = new THREE.MeshBasicMaterial({
-        color: 16776960
-      });
-      let mesh = new THREE.Mesh(geometry, materialLine);
-      mesh.position.set(centroidPoint.x, centroidPoint.y, centroidPoint.z);
       for (const a2 in listS) {
         if (Number(a2) % 2 === 0 && Number(a2) !== listS.length - 1) {
           const direction = this.pointSideOfLine(listS[a2].dian, listS[Number(a2) + 1].dian, centroidPoint);
@@ -8477,6 +8484,8 @@ class BayWindow {
       }
       let dataList = data[i].lines.slice();
       dataList.push(data[i].dottedLine);
+      this.bayWindowArea = Polygon.fromByLines2(dataList);
+      this.dashedLineTreatment(dashedLine, centroidPoint, data[i].data);
       let quanti = Scenario.Instance.correctionSorting(dataList);
       this.createBayWindowLayout(quanti, data[i].data);
       for (const x in listS) {
@@ -8513,20 +8522,23 @@ class BayWindow {
               for (const x2 in winDraw) {
                 if (winDraw.length === 1) {
                   this.installWindows(winDraw[x2], x2, Mesh.points3);
-                  let mesh2 = this.windowTreatment(winDraw[x2], Mesh.mesh3, wallHeight, Mesh.points3, a2);
-                  mesh2.name = `飘窗墙_${Number(x2) / 2}组`;
-                  mesh2.userData.category = "wall";
-                  Scenario.Instance.group.add(mesh2);
+                  let mesh = this.windowTreatment(winDraw[x2], Mesh.mesh3, wallHeight, Mesh.points3, a2);
+                  mesh.name = `飘窗墙_${Number(x2) / 2}组`;
+                  mesh.userData.category = "bayWindowWall";
+                  this.bayWindowGroup.add(mesh);
                 }
               }
             } else {
-              Mesh.mesh3.name = `单线墙_${Number(x) / 2}`;
-              Mesh.mesh3.userData.category = "wall";
-              Scenario.Instance.group.add(Mesh.mesh3);
+              Mesh.mesh3.name = `飘窗墙_${Number(x) / 2}组`;
+              Mesh.mesh3.userData.category = "bayWindowWall";
+              this.bayWindowGroup.add(Mesh.mesh3);
             }
           }
         }
       }
+      this.bayWindowGroup.name = `飘窗_${i}`;
+      this.bayWindowGroup.userData.category = "bayWindow";
+      Scenario.Instance.group.add(this.bayWindowGroup);
     }
   }
   // 虚线处理
@@ -8571,13 +8583,13 @@ class BayWindow {
         } else {
           a2 = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x, direction: listS[x].direction, shared: false };
         }
-        let Meshlist = this.bayWindowExecutionOffset(a2, Number(x) / 2, item.height3, item, true);
+        let Meshlist = this.bayWindowExecutionOffset(a2, Number(x) / 2, item.height3, item, false);
         if (!Meshlist) {
           console.log("夹角异常1", Meshlist);
           continue;
         }
-        Scenario.Instance.group.add(Meshlist.mesh1);
-        Scenario.Instance.group.add(Meshlist.mesh2);
+        this.bayWindowGroup.add(Meshlist.mesh1);
+        this.bayWindowGroup.add(Meshlist.mesh2);
       }
     }
   }
@@ -8592,9 +8604,34 @@ class BayWindow {
     const MobileY = this.angleToXAxisDegrees(data.start.x, data.start.y, data.end.x, data.end.y, scale2, false);
     let startingPoint;
     let finishLine;
+    if (statuc) {
+      const dottedGrid = createPointVirtualGrid(this.singleLine);
+      const a2 = new Point(data.start.x, data.start.y);
+      const b4 = new Point(data.end.x, data.end.y);
+      if (dottedGrid.queryCircle(a2, 1e-4).length > 0 || dottedGrid.queryCircle(b4, 1e-4).length > 0) {
+        startingPoint = this.xinLine(MobileX, MobileY, data.start, data.direction);
+        finishLine = this.xinLine(MobileX, MobileY, data.end, data.direction);
+        startingPoint.push(finishLine[1]);
+        startingPoint.push(finishLine[0]);
+        return {
+          mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+          mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+          mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+          points3: startingPoint
+        };
+      }
+    }
     if (data.shared) {
       startingPoint = this.xinLine(MobileX, MobileY, data.start, data.direction * -1);
       finishLine = this.xinLine(MobileX, MobileY, data.end, data.direction * -1);
+      startingPoint.push(finishLine[1]);
+      startingPoint.push(finishLine[0]);
+      return {
+        mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+        mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+        mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+        points3: startingPoint
+      };
     } else {
       startingPoint = this.xinLine(MobileX, MobileY, data.start, data.direction);
       finishLine = this.xinLine(MobileX, MobileY, data.end, data.direction);
@@ -8654,23 +8691,43 @@ class BayWindow {
           };
         }
       } else {
-        const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
-        const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
-        const n = end.sub(start);
-        this.bayWindowExpansion.push({ point: data.end, n });
-        startingPoint.push(finishLine1[1]);
-        startingPoint.push(finishLine1[0]);
-        let winPointList = [];
-        winPointList.push(startingPoint[0]);
-        winPointList.push(startingPoint[1]);
-        winPointList.push(finishLine[1]);
-        winPointList.push(finishLine[0]);
-        return {
-          mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
-          mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
-          mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
-          points3: winPointList
-        };
+        if (this.bayWindowArea.pointWithin(Point.from(finishLine1[0]))) {
+          const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+          const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+          const n = end.sub(start);
+          this.bayWindowExpansion.push({ point: data.end, n });
+          startingPoint.push(finishLine[1]);
+          startingPoint.push(finishLine[0]);
+          let winPointList = [];
+          winPointList.push(startingPoint[0]);
+          winPointList.push(startingPoint[1]);
+          winPointList.push(finishLine[1]);
+          winPointList.push(finishLine[0]);
+          return {
+            mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+            mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+            mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+            points3: winPointList
+          };
+        } else {
+          const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+          const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+          const n = end.sub(start);
+          this.bayWindowExpansion.push({ point: data.end, n });
+          startingPoint.push(finishLine1[1]);
+          startingPoint.push(finishLine1[0]);
+          let winPointList = [];
+          winPointList.push(startingPoint[0]);
+          winPointList.push(startingPoint[1]);
+          winPointList.push(finishLine[1]);
+          winPointList.push(finishLine[0]);
+          return {
+            mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+            mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+            mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+            points3: winPointList
+          };
+        }
       }
     }
     if (!isDouble && isDouble1) {
@@ -8743,7 +8800,10 @@ class BayWindow {
           const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
           const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
           const n = end.sub(start);
-          anglea = n.dot(this.bayWindowExpansion[x].n);
+          n.normalize();
+          const v2 = new THREE.Vector3(this.bayWindowExpansion[x].n.x, this.bayWindowExpansion[x].n.y, this.bayWindowExpansion[x].n.z);
+          v2.normalize();
+          anglea = n.dot(v2);
           anglea = Math.abs(anglea);
         }
         if (this.bayWindowExpansion[x].point.x === data.end.x && this.bayWindowExpansion[x].point.y === data.end.y && this.bayWindowExpansion[x].point.z === data.end.z) {
@@ -8751,7 +8811,10 @@ class BayWindow {
           const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
           const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
           const n = end.sub(start);
-          angleb = n.dot(this.bayWindowExpansion[x].n);
+          n.normalize();
+          const v2 = new THREE.Vector3(this.bayWindowExpansion[x].n.x, this.bayWindowExpansion[x].n.y, this.bayWindowExpansion[x].n.z);
+          v2.normalize();
+          angleb = n.dot(v2);
           angleb = Math.abs(angleb);
         }
       }
@@ -8818,8 +8881,147 @@ class BayWindow {
         const n = end.sub(start);
         this.bayWindowExpansion.push({ point: data.end, n });
         if (anglea !== null && anglea < 0.1) {
-          startingPoint.push(finishLine1[1]);
-          startingPoint.push(finishLine1[0]);
+          if (this.bayWindowArea.pointWithin(Point.from(finishLine1[0]))) {
+            startingPoint.push(finishLine[1]);
+            startingPoint.push(finishLine[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+              points3: winPointList
+            };
+          } else {
+            startingPoint.push(finishLine1[1]);
+            startingPoint.push(finishLine1[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+              points3: winPointList
+            };
+          }
+        } else if (anglea !== null && anglea > 0.9) {
+          if (this.bayWindowArea.pointWithin(Point.from(finishLine1[0]))) {
+            startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+            startingPoint1.push(finishLine[1]);
+            startingPoint1.push(finishLine[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint1, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint1, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
+              points3: winPointList
+            };
+          } else {
+            startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+            startingPoint1.push(finishLine1[1]);
+            startingPoint1.push(finishLine1[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint1, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint1, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
+              points3: winPointList
+            };
+          }
+        }
+      } else if (!statua && statub) {
+        const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+        const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+        const n = end.sub(start);
+        this.bayWindowExpansion.push({ point: data.start, n });
+        if (angleb !== null && angleb < 0.1) {
+          if (this.bayWindowArea.pointWithin(Point.from(startingPoint1[0]))) {
+            startingPoint.push(finishLine[1]);
+            startingPoint.push(finishLine[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+              points3: winPointList
+            };
+          } else {
+            startingPoint1.push(finishLine[1]);
+            startingPoint1.push(finishLine[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint1, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint1, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
+              points3: winPointList
+            };
+          }
+        } else if (angleb !== null && angleb > 0.9) {
+          if (this.bayWindowArea.pointWithin(Point.from(startingPoint1[0]))) {
+            finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
+            startingPoint.push(finishLine1[1]);
+            startingPoint.push(finishLine1[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
+              points3: winPointList
+            };
+          } else {
+            finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
+            startingPoint1.push(finishLine1[1]);
+            startingPoint1.push(finishLine1[0]);
+            let winPointList = [];
+            winPointList.push(startingPoint[0]);
+            winPointList.push(startingPoint[1]);
+            winPointList.push(finishLine[1]);
+            winPointList.push(finishLine[0]);
+            return {
+              mesh1: Scenario.Instance.drawTheModel(startingPoint1, 1, index2, wallHeightc),
+              mesh2: this.createDashedLineCeilingWall(startingPoint1, index2, item, 0),
+              mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
+              points3: winPointList
+            };
+          }
+        }
+      } else if (!statua && !statub) {
+        let npc1 = this.bayWindowArea.pointWithin(Point.from(startingPoint1[0]));
+        let npc2 = this.bayWindowArea.pointWithin(Point.from(finishLine1[0]));
+        if (npc1 && npc2) {
+          const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+          const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+          const n = end.sub(start);
+          this.bayWindowExpansion.push({ point: data.start, n });
+          this.bayWindowExpansion.push({ point: data.end, n });
+          startingPoint.push(finishLine[1]);
+          startingPoint.push(finishLine[0]);
           let winPointList = [];
           winPointList.push(startingPoint[0]);
           winPointList.push(startingPoint[1]);
@@ -8831,28 +9033,31 @@ class BayWindow {
             mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
             points3: winPointList
           };
-        } else if (anglea !== null && anglea > 0.9) {
-          startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
-          startingPoint1.push(finishLine1[1]);
-          startingPoint1.push(finishLine1[0]);
+        } else if (npc1 && !npc2) {
+          const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+          const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+          const n = end.sub(start);
+          this.bayWindowExpansion.push({ point: data.start, n });
+          this.bayWindowExpansion.push({ point: data.end, n });
+          startingPoint.push(finishLine1[1]);
+          startingPoint.push(finishLine1[0]);
           let winPointList = [];
           winPointList.push(startingPoint[0]);
           winPointList.push(startingPoint[1]);
           winPointList.push(finishLine[1]);
           winPointList.push(finishLine[0]);
           return {
-            mesh1: Scenario.Instance.drawTheModel(startingPoint1, 1, index2, wallHeightc),
-            mesh2: this.createDashedLineCeilingWall(startingPoint1, index2, item, 0),
-            mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
+            mesh1: Scenario.Instance.drawTheModel(startingPoint, 1, index2, wallHeightc),
+            mesh2: this.createDashedLineCeilingWall(startingPoint, index2, item, 0),
+            mesh3: this.createDashedLineCeilingWall(startingPoint, index2, item, 1),
             points3: winPointList
           };
-        }
-      } else if (!statua && statub) {
-        const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
-        const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
-        const n = end.sub(start);
-        this.bayWindowExpansion.push({ point: data.start, n });
-        if (angleb !== null && angleb < 0.1) {
+        } else if (!npc1 && npc2) {
+          const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+          const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+          const n = end.sub(start);
+          this.bayWindowExpansion.push({ point: data.start, n });
+          this.bayWindowExpansion.push({ point: data.end, n });
           startingPoint1.push(finishLine[1]);
           startingPoint1.push(finishLine[0]);
           let winPointList = [];
@@ -8866,8 +9071,12 @@ class BayWindow {
             mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
             points3: winPointList
           };
-        } else if (angleb !== null && angleb > 0.9) {
-          finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
+        } else {
+          const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
+          const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
+          const n = end.sub(start);
+          this.bayWindowExpansion.push({ point: data.start, n });
+          this.bayWindowExpansion.push({ point: data.end, n });
           startingPoint1.push(finishLine1[1]);
           startingPoint1.push(finishLine1[0]);
           let winPointList = [];
@@ -8882,25 +9091,6 @@ class BayWindow {
             points3: winPointList
           };
         }
-      } else if (!statua && !statub) {
-        const start = new THREE.Vector3(data.start.x, data.start.y, data.start.z);
-        const end = new THREE.Vector3(data.end.x, data.end.y, data.end.z);
-        const n = end.sub(start);
-        this.bayWindowExpansion.push({ point: data.start, n });
-        this.bayWindowExpansion.push({ point: data.end, n });
-        startingPoint1.push(finishLine1[1]);
-        startingPoint1.push(finishLine1[0]);
-        let winPointList = [];
-        winPointList.push(startingPoint[0]);
-        winPointList.push(startingPoint[1]);
-        winPointList.push(finishLine[1]);
-        winPointList.push(finishLine[0]);
-        return {
-          mesh1: Scenario.Instance.drawTheModel(startingPoint1, 1, index2, wallHeightc),
-          mesh2: this.createDashedLineCeilingWall(startingPoint1, index2, item, 0),
-          mesh3: this.createDashedLineCeilingWall(startingPoint1, index2, item, 1),
-          points3: winPointList
-        };
       }
     }
   }
@@ -9070,7 +9260,7 @@ class BayWindow {
       menModel.userData.depth = wallWidth;
       menModel.userData.height = height;
       menModel.userData.groundHeight = groundClearance;
-      Scenario.Instance.group.add(menModel);
+      this.bayWindowGroup.add(menModel);
     }
   }
   // 创建飘窗平面
@@ -9138,40 +9328,42 @@ class BayWindow {
     Scenario.Instance?.group.add(mesh2);
   }
   // 共用线处理
-  sharedLineProcessing(sharedLine, data) {
-    let listS = Scenario.Instance.correctionSorting(sharedLine);
-    for (const x in listS) {
-      if (Number(x) % 2 === 0 && Number(x) !== listS.length - 1) {
-        let point1;
-        let point2;
-        let distance2;
-        if (Number(x) < listS.length - 2) {
-          point1 = new THREE.Vector3(listS[Number(x) + 1].dian.x, listS[Number(x) + 1].dian.y, listS[Number(x) + 1].dian.z);
-          point2 = new THREE.Vector3(listS[Number(x) + 2].dian.x, listS[Number(x) + 2].dian.y, listS[Number(x) + 2].dian.z);
-        } else {
-          point1 = new THREE.Vector3(0, 0, 0);
-          point2 = new THREE.Vector3(0, 0, 0);
-        }
-        distance2 = point1.distanceTo(point2);
-        let a2;
-        if (x === "0") {
-          a2 = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x, direction: listS[x].direction };
-        }
-        if (distance2 < 0.01) {
-          a2 = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: false, index: x, direction: listS[x].direction };
-        } else {
-          a2 = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x, direction: listS[x].direction };
-        }
-        const wallHeight = listS[x].wallHeight;
-        let Mesh = this.bayWindowExecutionOffset(a2, Number(x) / 2, wallHeight, data, true);
-        if (!Mesh) {
-          console.log("夹角异常！");
-          continue;
-        }
-        Scenario.Instance.group.add(Mesh.mesh3);
-      }
-    }
-  }
+  // sharedLineProcessing(sharedLine: any, data: any) {
+  //     let listS: any = scenario.Instance!.correctionSorting(sharedLine);
+  //     for (const x in listS) {
+  //         // console.log('listS', listS);
+  //         // LineGroupType.getIdsByType(line, "bayWindow").length === 2 加个是否是共用飘窗线的判断
+  //         if (Number(x) % 2 === 0 && Number(x) !== listS.length - 1) {
+  //             let point1;
+  //             let point2;
+  //             let distance;
+  //             if (Number(x) < listS.length - 2) {
+  //                 point1 = new THREE.Vector3(listS[Number(x) + 1].dian.x, listS[Number(x) + 1].dian.y, listS[Number(x) + 1].dian.z);
+  //                 point2 = new THREE.Vector3(listS[Number(x) + 2].dian.x, listS[Number(x) + 2].dian.y, listS[Number(x) + 2].dian.z);
+  //             } else {
+  //                 point1 = new THREE.Vector3(0, 0, 0);
+  //                 point2 = new THREE.Vector3(0, 0, 0);
+  //             }
+  //             distance = point1.distanceTo(point2);
+  //             let a;
+  //             if (x === '0') {
+  //                 a = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x, direction: listS[x].direction }
+  //             }
+  //             if (distance < 0.01) {
+  //                 a = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: false, index: x, direction: listS[x].direction }
+  //             } else {
+  //                 a = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x, direction: listS[x].direction }
+  //             }
+  //             const wallHeight = listS[x].wallHeight;
+  //             let Mesh: any = this.bayWindowExecutionOffset(a, Number(x) / 2, wallHeight, data, true);
+  //             if (!Mesh) {
+  //                 console.log('夹角异常！');
+  //                 continue
+  //             }
+  //             scenario.Instance!.group.add(Mesh.mesh3);
+  //         }
+  //     }
+  // }
 }
 const DEFAULT_WALL_HALF_WIDTH = DEFAULT_WALL_WIDTH * 0.5;
 class Scenario {
@@ -9214,6 +9406,7 @@ class Scenario {
   expandedList;
   wallHeight;
   box;
+  singleLineWallValue;
   static _instance;
   static get Instance() {
     return Scenario._instance;
@@ -9252,6 +9445,7 @@ class Scenario {
     this.expandedList = [];
     this.wallHeight = DEFAULT_WALL_HEIGHT;
     this.box = null;
+    this.singleLineWallValue = null;
   }
   // 绘制图形
   async drawGraphics(lines, z, trajectoryJson) {
@@ -9293,6 +9487,7 @@ class Scenario {
     this.expandedList = [];
     if (!BayWindow.Instance) new BayWindow();
     BayWindow.Instance.bayWindowExpansion = [];
+    BayWindow.Instance.dottedLinePoints = [];
     this.splitProcessData(lines, this.texture);
     this.scene.add(this.group);
     return this.group;
@@ -9333,15 +9528,9 @@ class Scenario {
         }
       }
     });
-    BayWindow.Instance?.overhangTreatment(bayWinList);
-    groups = groups.filter((group2) => {
-      if (group2.length < 4) {
-        singleLineWall.push(...group2);
-        return false;
-      }
-      return true;
-    });
+    BayWindow.Instance?.overhangTreatment(bayWinList, singleLineWall);
     this.TheHandlingOfTheDoor(menList);
+    this.singleLineWallValue = createPointVirtualGrid(singleLineWall);
     this.overallTreatmentOfSingleLineWalls(singleLineWall);
     for (const g in groups) {
       let wallHeight = 0;
@@ -9537,10 +9726,18 @@ class Scenario {
         startingPoint.push(finishLine1[0]);
         return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
       } else {
-        this.expandedList.push(data.end);
-        startingPoint.push(finishLine1[1]);
-        startingPoint.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        const npcEnd = new Point(data.start.x, data.start.y);
+        if (this.singleLineWallValue.queryCircle(npcEnd, 1e-4).length <= 1) {
+          this.expandedList.push(data.end);
+          startingPoint.push(finishLine[1]);
+          startingPoint.push(finishLine[0]);
+          return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        } else {
+          this.expandedList.push(data.end);
+          startingPoint.push(finishLine1[1]);
+          startingPoint.push(finishLine1[0]);
+          return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        }
       }
     }
     if (!isDouble && isDouble1) {
@@ -9556,10 +9753,18 @@ class Scenario {
         startingPoint1.push(finishLine[0]);
         return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       } else {
-        this.expandedList.push(data.start);
-        startingPoint1.push(finishLine[1]);
-        startingPoint1.push(finishLine[0]);
-        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        const npcStart = new Point(data.start.x, data.start.y);
+        if (this.singleLineWallValue.queryCircle(npcStart, 1e-4).length <= 1) {
+          this.expandedList.push(data.start);
+          startingPoint.push(finishLine[1]);
+          startingPoint.push(finishLine[0]);
+          return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        } else {
+          this.expandedList.push(data.start);
+          startingPoint1.push(finishLine[1]);
+          startingPoint1.push(finishLine[0]);
+          return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        }
       }
     }
     if (!isDouble && !isDouble1) {
@@ -9580,23 +9785,65 @@ class Scenario {
         startingPoint1.push(finishLine1[0]);
         return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       } else if (statua && !statub) {
-        this.expandedList.push(data.end);
-        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
-        startingPoint1.push(finishLine1[1]);
-        startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        const npcEnd = new Point(data.end.x, data.end.y);
+        if (this.singleLineWallValue.queryCircle(npcEnd, 1e-4).length <= 1) {
+          this.expandedList.push(data.end);
+          startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+          startingPoint1.push(finishLine[1]);
+          startingPoint1.push(finishLine[0]);
+          return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        } else {
+          this.expandedList.push(data.end);
+          startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+          startingPoint1.push(finishLine1[1]);
+          startingPoint1.push(finishLine1[0]);
+          return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        }
       } else if (!statua && statub) {
-        this.expandedList.push(data.start);
-        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
-        startingPoint1.push(finishLine1[1]);
-        startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        const npcStart = new Point(data.start.x, data.start.y);
+        if (this.singleLineWallValue.queryCircle(npcStart, 1e-4).length <= 1) {
+          this.expandedList.push(data.start);
+          finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
+          startingPoint.push(finishLine1[1]);
+          startingPoint.push(finishLine1[0]);
+          return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        } else {
+          this.expandedList.push(data.start);
+          finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
+          startingPoint1.push(finishLine1[1]);
+          startingPoint1.push(finishLine1[0]);
+          return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        }
       } else if (!statua && !statub) {
-        this.expandedList.push(data.start);
-        this.expandedList.push(data.end);
-        startingPoint1.push(finishLine1[1]);
-        startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        const npcStart = new Point(data.start.x, data.start.y);
+        const npcEnd = new Point(data.end.x, data.end.y);
+        let npc1 = this.singleLineWallValue.queryCircle(npcStart, 1e-4).length <= 1;
+        let npc2 = this.singleLineWallValue.queryCircle(npcEnd, 1e-4).length <= 1;
+        if (npc1 && npc2) {
+          this.expandedList.push(data.start);
+          this.expandedList.push(data.end);
+          startingPoint.push(finishLine[1]);
+          startingPoint.push(finishLine[0]);
+          return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        } else if (!npc1 && npc2) {
+          this.expandedList.push(data.start);
+          this.expandedList.push(data.end);
+          startingPoint1.push(finishLine[1]);
+          startingPoint1.push(finishLine[0]);
+          return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        } else if (npc1 && !npc2) {
+          this.expandedList.push(data.start);
+          this.expandedList.push(data.end);
+          startingPoint.push(finishLine1[1]);
+          startingPoint.push(finishLine1[0]);
+          return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
+        } else {
+          this.expandedList.push(data.start);
+          this.expandedList.push(data.end);
+          startingPoint1.push(finishLine1[1]);
+          startingPoint1.push(finishLine1[0]);
+          return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
+        }
       }
     }
   }
@@ -9755,6 +10002,8 @@ class Scenario {
   }
   // 安装阳台
   installBalconys(data, index2) {
+    let balconyGroup = new Group$1();
+    balconyGroup.name = `阳台${index2}`;
     const point1 = new THREE.Vector3(data.start.x, data.start.y, 0);
     const point2 = new THREE.Vector3(data.end.x, data.end.y, 0);
     new THREE.Vector3(data.center.x, data.center.y, 0);
@@ -9766,19 +10015,57 @@ class Scenario {
     const wallWidth = data.userData.wallWidth ? data.userData.wallWidth : 0.18;
     (data.userData.groundClearance ?? this.WindowGroundHeight) + this.height;
     let menModel = this.balconyModely.clone();
-    if (data.center && distance2) {
-      menModel.position.set(data.center.x, data.center.y, 0);
-      const box32 = new THREE.Box3();
-      box32.setFromObject(menModel);
-      let size2 = new THREE.Vector3();
-      box32.getSize(size2);
-      menModel.rotation.x = Math.PI / 2;
-      menModel.rotation.y = angleRad;
-      menModel.scale.set(distance2 / size2.x, height / size2.y, wallWidth / size2.z);
-      menModel.position.set(data.center.x, data.center.y, this.height);
-      menModel.name = `阳台_${index2}`;
-      menModel.userData.category = "balcony";
-      this.group.add(menModel);
+    if (distance2 < 1.2) {
+      if (data.center && distance2) {
+        menModel.position.set(data.center.x, data.center.y, 0);
+        const box32 = new THREE.Box3();
+        box32.setFromObject(menModel);
+        let size2 = new THREE.Vector3();
+        box32.getSize(size2);
+        menModel.rotation.x = Math.PI / 2;
+        menModel.rotation.y = angleRad;
+        menModel.scale.set(distance2 / size2.x, height / size2.y, wallWidth / size2.z);
+        menModel.position.set(data.center.x, data.center.y, this.height);
+        menModel.name = `阳台_${index2}`;
+        menModel.userData.category = "balcony";
+        balconyGroup.add(menModel);
+        this.group.add(balconyGroup);
+      }
+    } else {
+      let splitLineInto7Points = function(startPoint, endPoint) {
+        const points2 = [];
+        const startVec = new THREE.Vector3(startPoint.x, startPoint.y, startPoint.z);
+        const endVec = new THREE.Vector3(endPoint.x, endPoint.y, endPoint.z);
+        for (let i = 0; i <= npc; i++) {
+          const fraction = i / npc;
+          const point3 = new THREE.Vector3();
+          point3.lerpVectors(startVec, endVec, fraction);
+          points2.push(point3);
+        }
+        return points2;
+      };
+      let npc = 0;
+      npc = distance2 / 0.8;
+      npc = Math.round(npc);
+      const points = splitLineInto7Points(point1, point2);
+      for (let o = 0; o < points.length - 1; o++) {
+        const spacing = points[o].distanceTo(points[o + 1]);
+        const center = new THREE.Vector3();
+        center.lerpVectors(points[o], points[o + 1], 0.5);
+        let balconyModel = this.balconyModely.clone();
+        const box32 = new THREE.Box3();
+        box32.setFromObject(menModel);
+        let size2 = new THREE.Vector3();
+        box32.getSize(size2);
+        balconyModel.rotation.x = Math.PI / 2;
+        balconyModel.rotation.y = angleRad;
+        balconyModel.scale.set(spacing / size2.x, height / size2.y, wallWidth / size2.z);
+        balconyModel.position.set(center.x, center.y, this.height);
+        balconyModel.name = `阳台_${index2}`;
+        balconyModel.userData.category = "balcony";
+        balconyGroup.add(balconyModel);
+      }
+      this.group.add(balconyGroup);
     }
   }
   // 放置柜子
@@ -10217,7 +10504,7 @@ class Scenario {
   }
   // 获取阳台模型
   async balconyModelLoader() {
-    this.balconyModely = await LoadModel.loadGlb("balcony");
+    this.balconyModely = await LoadModel.loadGlb("balconyFilmFilmFilm");
   }
   damian() {
     const planeGeometry = new THREE.BufferGeometry();

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

@@ -3,10 +3,14 @@ import * as THREE from 'three';
 export declare const DEFAULT_WALL_HALF_WIDTH: number;
 export default class BayWindow {
     bayWindowExpansion: any;
+    dottedLinePoints: any;
+    singleLine: any;
+    bayWindowArea: any;
+    bayWindowGroup: THREE.Group;
     private static _instance?;
     static get Instance(): BayWindow | undefined;
     constructor();
-    overhangTreatment(data: any): void;
+    overhangTreatment(data: any, singleLine: any): void;
     dashedLineTreatment(data: any, centroidPoint: any, item: any): void;
     bayWindowExecutionOffset(data: any, index: number, wallHeight: number, item?: any, statuc?: boolean): {
         mesh1: THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
@@ -28,5 +32,4 @@ export default class BayWindow {
     windowTreatment(dblWin: any, mesh: any, wallHeight: number, startingPoint: any, data: any): import('three-bvh-csg').Brush;
     installWindows(data: any, index: string, startingPoint: any): void;
     createBayWindowLayout(listS: any, objData: any): void;
-    sharedLineProcessing(sharedLine: any, data: any): void;
 }

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

@@ -36,6 +36,7 @@ export default class Scenario {
     expandedList: any;
     wallHeight: any;
     box: any;
+    singleLineWallValue: any;
     private static _instance?;
     static get Instance(): Scenario | undefined;
     constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, renderer: THREE.WebGLRenderer, controls: OrbitControls);