rm-graphical-computing-node 1.0.88 → 1.0.90

package/dist/index.mjs

@@ -4012,10 +4012,11 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
     line2.mergeCheckRegion = allRegion;
   }
   const doorDatas = [];
+  const doorFrame = [];
   for (let i = 0; i < pcdData.length; i++) {
     const door = pcdData[i];
     door.isFindBeam = false;
-    if (door.category == "door") {
+    if (door.category == "door" || door.category == "door frame") {
       let boxPoints = [];
       door.coordinatesByArea.coordinates.forEach((p) => {
         boxPoints.push(new THREE5.Vector3(p.x, p.y, p.z));
@@ -4030,17 +4031,31 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
       }
       let doorStartPt = getMid(boxPoints[0], boxPoints[3], true);
       let doorEndPt = getMid(boxPoints[1], boxPoints[2], true);
-      doorDatas.push({
-        doorStartPt,
-        doorEndPt,
-        boxPoints,
-        minZ: door.coordinatesByArea.heightData.minZ,
-        maxZ: door.coordinatesByArea.heightData.maxZ,
-        index: i,
-        isFind: false,
-        inWall: false
-        //是否在墙内
-      });
+      let vecDoorFrame = new THREE5.Vector3().subVectors(doorEndPt, doorStartPt).normalize();
+      if (door.category == "door") {
+        doorDatas.push({
+          doorStartPt,
+          doorEndPt,
+          boxPoints,
+          minZ: door.coordinatesByArea.heightData.minZ,
+          maxZ: door.coordinatesByArea.heightData.maxZ,
+          index: i,
+          isFind: false,
+          inWall: false
+          //是否在墙内
+        });
+      }
+      if (door.category == "door frame") {
+        doorFrame.push({
+          doorStartPt,
+          doorEndPt,
+          vecDoorFrame,
+          boxPoints,
+          index: i,
+          minZ: door.coordinatesByArea.heightData.minZ,
+          maxZ: door.coordinatesByArea.heightData.maxZ
+        });
+      }
     }
   }
   for (let y = 0; y < doorDatas.length; y++) {
@@ -4600,7 +4615,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                 }
                 if (
                   /**!isPullOutDoor && */
-                  length2 < 1.5
+                  length2 < 1.6
                 ) {
                   for (let n = 0; n < doorDatas.length; n++) {
                     if (doorDatas[n].inWall) continue;
@@ -4885,6 +4900,72 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
             }
             doorAndBeamDataObj.type = dataType;
             doorAndBeamDataObj.wallBelowBeam = wallBelowBeam;
+            if (doorFrame && doorFrame.length > 0 && doorAndBeamDataObj.type == "door") {
+              let doorLen = doorTmpSt.distanceTo(doorTmpEd);
+              let lineStart2 = getPt3(line2.start);
+              let lineEnd2 = getPt3(line2.end);
+              const pcdToLineDist = 0.1;
+              for (let x = 0; x < doorFrame.length; x++) {
+                const ptArray = doorFrame[x].boxPoints;
+                const doorFrameStart = getPt3(doorFrame[x].doorStartPt);
+                const doorFrameEnd = getPt3(doorFrame[x].doorEndPt);
+                doorFrameStart.z = doorFrameEnd.z = doorTmpSt.z;
+                let doorFrameLen = doorFrameStart.distanceTo(doorFrameEnd);
+                if (Math.abs(doorFrameLen - doorLen) > 0.5) continue;
+                let result = getParallelism(doorFrameStart, doorFrameEnd, doorTmpSt, doorTmpEd);
+                if (result && result.angleDeg < 15) {
+                  let ptLongSt1 = getPt3(ptArray[0]);
+                  let ptLongEd1 = getPt3(ptArray[1]);
+                  let ptLongSt2 = getPt3(ptArray[2]);
+                  let ptLongEd2 = getPt3(ptArray[3]);
+                  let ptShortSt1 = getPt3(ptArray[1]);
+                  let ptShortEd1 = getPt3(ptArray[2]);
+                  let ptShortSt2 = getPt3(ptArray[3]);
+                  let ptShortEd2 = getPt3(ptArray[0]);
+                  if (ptLongSt1.distanceTo(ptLongEd1) < ptLongSt1.distanceTo(ptLongEd2)) {
+                    ptLongSt1 = getPt3(ptArray[1]);
+                    ptLongEd1 = getPt3(ptArray[2]);
+                    ptLongSt2 = getPt3(ptArray[3]);
+                    ptLongEd2 = getPt3(ptArray[0]);
+                    ptShortSt1 = getPt3(ptArray[0]);
+                    ptShortEd1 = getPt3(ptArray[1]);
+                    ptShortSt2 = getPt3(ptArray[2]);
+                    ptShortEd2 = getPt3(ptArray[3]);
+                  }
+                  let vec1 = getVector3(lineStart2, lineEnd2);
+                  let vec2 = getVector3(ptShortSt1, ptShortEd1);
+                  let vec32 = getVector3(ptShortSt2, ptShortEd2);
+                  let tmpPtStart = lineStart2.clone().addScaledVector(vec1, -pcdToLineDist);
+                  let tmpPtEnd = lineEnd2.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);
+                  if (intersect1 != null && intersect2 != null) {
+                    const ptIntersect1 = intersect1.point;
+                    const ptIntersect2 = intersect2.point;
+                    let ptOnLine1 = isPointOnLine2(ptIntersect1, ptIntersect2, doorTmpSt, 1e-3, true);
+                    let ptOnLine2 = isPointOnLine2(ptIntersect1, ptIntersect2, doorTmpEd, 1e-3, true);
+                    if (ptOnLine1 && ptOnLine2) {
+                      let originZ = doorTmpSt.z;
+                      doorTmpSt = ptIntersect1.clone();
+                      doorTmpEd = ptIntersect2.clone();
+                      doorTmpSt.z = doorTmpEd.z = originZ;
+                      doorAndBeamDataObj.doorStart = doorTmpSt.clone();
+                      doorAndBeamDataObj.doorEnd = doorTmpEd.clone();
+                      doorAndBeamDataObj.doorHeight = doorFrame[x].maxZ - doorAndBeamDataObj.doorStart.z;
+                      doorAndBeamDataObj.beamStart = doorTmpSt.clone();
+                      doorAndBeamDataObj.beamEnd = doorTmpEd.clone();
+                      doorAndBeamDataObj.beamStart.z = doorAndBeamDataObj.beamEnd.z = doorAndBeamDataObj.doorStart.z + doorAndBeamDataObj.doorHeight;
+                      doorAndBeamDataObj.beamHeight = line2.rooftopPz - doorAndBeamDataObj.beamStart.z;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
             for (let w2 = 0; w2 < doorBeamDataIndex.length; w2++) {
               const tmpDoorBeamData = lines[doorBeamDataIndex[w2].linesIndex].doorAndBeamData[doorBeamDataIndex[w2].doorIndex];
               if (tmpDoorBeamData.nearId != -1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rm-graphical-computing-node",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "description": "墙体/梁线/点云语义计算库（依赖 Python 与 three.js）",
   "type": "module",
   "main": "dist/index.mjs",
@@ -20,10 +20,9 @@
   "dependencies": {
     "d3-delaunay": "^6.0.4",
     "geojson-minimum-bounding-rectangle": "^2.0.3",
-    "rm-graphical-computing-node": "^1.0.24",
+    "rm-graphical-computing-node": "^1.0.88",
     "rm-gxf-computing-rusts": "^0.0.61",
     "rm-point-cloud-calculation": "^1.0.4",
-    "rm-point-cloud-calculation-napi": "^1.0.13",
     "three": "^0.184.0"
   },
   "devDependencies": {