rm-graphical-computing-node 1.0.85 → 1.0.86

package/dist/index.mjs

@@ -12502,7 +12502,7 @@ var getWindowPcdData = (lines, pcdData) => {
 // src/geometry/door.mjs
 import * as THREE11 from "three";
 import { randomUUID as randomUUID2 } from "crypto";
-var getDoorPcdData = (lines, pcdData) => {
+var getDoorPcdData = (lines, pcdData, needFindOtherDoor = true) => {
   if (!lines || !lines.length || !pcdData || !pcdData.length)
     return lines;
   const pcdToLineDist = 0.1;
@@ -12575,8 +12575,21 @@ var getDoorPcdData = (lines, pcdData) => {
     const line2 = tmpLines[maxIndex];
     let ptStart = getPt3(line2.start);
     let ptEnd = getPt3(line2.end);
-    let intersect1 = segmentsIntersect2D(ptStart, ptEnd, ptShortSt1, ptShortEd1, pcdToLineDist);
-    let intersect2 = segmentsIntersect2D(ptStart, ptEnd, ptShortSt2, ptShortEd2, pcdToLineDist);
+    let vec1 = getVector3(ptStart, ptEnd);
+    let vec2 = getVector3(ptShortSt1, ptShortEd1);
+    let vec32 = getVector3(ptShortSt2, ptShortEd2);
+    let tmpPtStart = ptStart.clone().addScaledVector(vec1, -pcdToLineDist);
+    let tmpPtEnd = ptEnd.clone().addScaledVector(vec1, pcdToLineDist);
+    let tmpPtShortSt1 = ptShortSt1.clone().addScaledVector(vec2, -pcdToLineDist);
+    let tmpPtShortEd1 = ptShortEd1.clone().addScaledVector(vec2, pcdToLineDist);
+    let tmpPtShortSt2 = ptShortSt2.clone().addScaledVector(vec32, -pcdToLineDist);
+    let tmpPtShortEd2 = ptShortEd2.clone().addScaledVector(vec32, pcdToLineDist);
+    let intersect1 = segmentsIntersect2D(tmpPtStart, tmpPtEnd, tmpPtShortSt1, tmpPtShortEd1, pcdToLineDist);
+    let intersect2 = segmentsIntersect2D(tmpPtStart, tmpPtEnd, tmpPtShortSt2, tmpPtShortEd2, pcdToLineDist);
+    console.log(intersect1, intersect2);
+    let newDoorSt = null;
+    let newDoorEd = null;
+    let doorAddGroundClearance = 0;
     if (intersect1 != null && intersect2 != null) {
       if (line2.mergeIndexs) {
         let tmpIndex = [];
@@ -12610,6 +12623,7 @@ var getDoorPcdData = (lines, pcdData) => {
       }
       let groundClearance = minZ - line2.start.z;
       groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+      doorAddGroundClearance = line2.start.z + groundClearance;
       let newLine1 = {
         start: ptStart,
         end: ptDoorSt,
@@ -12659,6 +12673,8 @@ var getDoorPcdData = (lines, pcdData) => {
         lines.push(newLine3);
       pcd.isFindDoor = true;
       line2.isRebuild = true;
+      newDoorSt = newLine2.drawDoorData.start.clone();
+      newDoorEd = newLine2.drawDoorData.end.clone();
     } else if (intersect1 == null && intersect2 == null) {
       ptShortSt1.z = ptShortEd1.z = ptShortSt2.z = ptShortEd2.z = line2.start.z;
       let shortLine1 = new THREE11.Line3(ptShortSt1, ptShortEd1);
@@ -12707,6 +12723,7 @@ var getDoorPcdData = (lines, pcdData) => {
         }
         let groundClearance = minZ - line2.start.z;
         groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+        doorAddGroundClearance = line2.start.z + groundClearance;
         let newLine1 = {
           start: ptStart,
           end: ptDoorSt,
@@ -12756,6 +12773,104 @@ var getDoorPcdData = (lines, pcdData) => {
           lines.push(newLine3);
         pcd.isFindDoor = true;
         line2.isRebuild = true;
+        newDoorSt = newLine2.drawDoorData.start.clone();
+        newDoorEd = newLine2.drawDoorData.end.clone();
+      }
+    }
+    if (newDoorSt != null && newDoorEd != null && needFindOtherDoor) {
+      const newDoorLength = newDoorSt.distanceTo(newDoorEd);
+      let isFind = false;
+      for (let u4 = 0; u4 < lines.length; u4++) {
+        const lineTmp = lines[u4];
+        let ptLineSt = getPt3(lineTmp.start);
+        let ptLineEd = getPt3(lineTmp.end);
+        let line3 = new THREE11.Line3(ptLineSt, ptLineEd);
+        if (!lineTmp || lineTmp.isRebuild || !lineTmp.doorAndBeamData || lineTmp.doorAndBeamData.length <= 0)
+          continue;
+        for (let w = 0; w < lineTmp.doorAndBeamData.length; w++) {
+          const oldDoorData = lineTmp.doorAndBeamData[w];
+          const doorStart = getPt3(oldDoorData.doorStart);
+          const doorEnd = getPt3(oldDoorData.doorEnd);
+          doorStart.z = doorEnd.z = newDoorSt.z;
+          let classify = classifySegments(newDoorSt, newDoorEd, doorStart, doorEnd);
+          if (classify && classify.type == "collinear_overlap" && classify.maxPerpendicularDistance < 0.3 && Math.abs(classify.overlap - newDoorLength) < 0.15) {
+            let originDoorZ = newDoorSt.z;
+            newDoorSt.z = newDoorEd.z = ptLineSt.z;
+            let ptNewDoorSt = line3.closestPointToPoint(newDoorSt, false, new THREE11.Vector3());
+            let ptNewDoorEd = line3.closestPointToPoint(newDoorEd, false, new THREE11.Vector3());
+            if (ptLineSt.distanceTo(ptNewDoorSt) > ptLineSt.distanceTo(ptNewDoorEd))
+              [ptNewDoorSt, ptNewDoorEd] = [ptNewDoorEd, ptNewDoorSt];
+            const newOriginPts1 = getProjectedPointOnLine(ptLineSt, ptNewDoorSt, lineTmp.originalPoints);
+            const newOriginPts2 = getProjectedPointOnLine(ptNewDoorSt, ptNewDoorEd, lineTmp.originalPoints);
+            const newOriginPts3 = getProjectedPointOnLine(ptNewDoorEd, ptLineEd, lineTmp.originalPoints);
+            const newDoorAndBeamData1 = [];
+            const newDoorAndBeamData2 = [];
+            const newDoorAndBeamData3 = [];
+            if (lineTmp.doorAndBeamData) {
+              for (let a = 0; a < lineTmp.doorAndBeamData.length; a++) {
+                let doorStart2 = lineTmp.doorAndBeamData[a].doorStart;
+                let doorEnd2 = lineTmp.doorAndBeamData[a].doorEnd;
+                if (isPointOnLine2(ptLineSt, ptNewDoorSt, doorStart2, 1e-3, true) && isPointOnLine2(ptLineSt, ptNewDoorSt, doorEnd2, 1e-3, true))
+                  newDoorAndBeamData1.push(lineTmp.doorAndBeamData[a]);
+                else if (isPointOnLine2(ptNewDoorEd, ptLineEd, doorStart2, 1e-3, true) && isPointOnLine2(ptNewDoorEd, ptLineEd, doorEnd2, 1e-3, true))
+                  newDoorAndBeamData3.push(lineTmp.doorAndBeamData[a]);
+              }
+            }
+            let groundClearance = doorAddGroundClearance - lineTmp.start.z;
+            groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+            let newLine1 = {
+              start: ptLineSt,
+              end: ptNewDoorSt,
+              length: ptLineSt.distanceTo(ptNewDoorSt),
+              originalPoints: newOriginPts1.newOriginalPoints,
+              doorAndBeamData: newDoorAndBeamData1,
+              id: randomUUID2(),
+              rooftopPz: lineTmp.rooftopPz,
+              isRebuild: false,
+              direction: lineTmp.direction
+            };
+            let newLine2 = {
+              start: ptNewDoorSt,
+              end: ptNewDoorEd,
+              length: ptNewDoorSt.distanceTo(ptNewDoorEd),
+              originalPoints: newOriginPts2.newOriginalPoints,
+              doorAndBeamData: newDoorAndBeamData2,
+              id: randomUUID2(),
+              rooftopPz: lineTmp.rooftopPz,
+              isRebuild: false,
+              direction: lineTmp.direction,
+              drawDoorData: {
+                start: new THREE11.Vector3(ptNewDoorSt.x, ptNewDoorSt.y, lineTmp.start.z),
+                end: new THREE11.Vector3(ptNewDoorEd.x, ptNewDoorEd.y, lineTmp.start.z),
+                n: new THREE11.Vector3(0, 0, 0),
+                height,
+                groundClearance
+              },
+              isDoor: true
+            };
+            let newLine3 = {
+              start: ptNewDoorEd,
+              end: ptLineEd,
+              length: ptNewDoorEd.distanceTo(ptLineEd),
+              originalPoints: newOriginPts3.newOriginalPoints,
+              doorAndBeamData: newDoorAndBeamData3,
+              id: randomUUID2(),
+              rooftopPz: lineTmp.rooftopPz,
+              isRebuild: false,
+              direction: lineTmp.direction
+            };
+            if (newLine1.originalPoints.length > 0 && newLine1.length > 0.01)
+              lines.push(newLine1);
+            if (newLine2.originalPoints.length > 0 && newLine2.length > 0.01)
+              lines.push(newLine2);
+            if (newLine3.originalPoints.length > 0 && newLine3.length > 0.01)
+              lines.push(newLine3);
+            lineTmp.isRebuild = true;
+            isFind = true;
+            break;
+          }
+        }
+        if (isFind) break;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rm-graphical-computing-node",
-  "version": "1.0.85",
+  "version": "1.0.86",
   "description": "墙体/梁线/点云语义计算库（依赖 Python 与 three.js）",
   "type": "module",
   "main": "dist/index.mjs",