rm-graphical-computing-node 1.0.40 → 1.0.42

package/dist/index.mjs

@@ -3447,6 +3447,65 @@ function pointToSegmentDistance(p, a, b) {
     p.y - y
   );
 }
+var voxelDownsample2DForContour = (points, cellSize) => {
+  if (!points || points.length === 0) return [];
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    const x = p[0];
+    const y = p[1];
+    const gx = Math.floor(x / cellSize);
+    const gy = Math.floor(y / cellSize);
+    const key = `${gx}_${gy}`;
+    let cell = map.get(key);
+    if (!cell) {
+      const cx = (gx + 0.5) * cellSize;
+      const cy = (gy + 0.5) * cellSize;
+      const dx2 = x - cx;
+      const dy2 = y - cy;
+      cell = {
+        minX: p,
+        maxX: p,
+        minY: p,
+        maxY: p,
+        center: p,
+        centerDist2: dx2 * dx2 + dy2 * dy2,
+        cx,
+        cy
+      };
+      map.set(key, cell);
+      continue;
+    }
+    if (x < cell.minX[0]) cell.minX = p;
+    if (x > cell.maxX[0]) cell.maxX = p;
+    if (y < cell.minY[1]) cell.minY = p;
+    if (y > cell.maxY[1]) cell.maxY = p;
+    const dx = x - cell.cx;
+    const dy = y - cell.cy;
+    const dist22 = dx * dx + dy * dy;
+    if (dist22 < cell.centerDist2) {
+      cell.center = p;
+      cell.centerDist2 = dist22;
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  function addPoint(p) {
+    const key = `${p[0]}_${p[1]}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(p);
+    }
+  }
+  for (const cell of map.values()) {
+    addPoint(cell.minX);
+    addPoint(cell.maxX);
+    addPoint(cell.minY);
+    addPoint(cell.maxY);
+    addPoint(cell.center);
+  }
+  return result;
+};
 
 // src/utils/updateLine.mjs
 import * as THREE4 from "three";
@@ -4582,8 +4641,6 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
             let afterDoorLen = doorTmpEd.distanceTo(doorTmpSt);
             if (afterDoorLen < 0.4 && !isDoor || afterDoorLen < 0.3 && isDoor)
               continue;
-            if (!findDoorIndexs.includes(index))
-              findDoorIndexs.push(index);
             let dataType = "";
             let doorType = isDoor ? "singleDoor" : "";
             doorType = isPullOutDoor ? "pullOutDoor" : doorType;
@@ -4635,11 +4692,23 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                 let isPPP = getParallelism(startPt2, endPt2, doorTmpSt, doorTmpEd);
                 if (result && result.maxPerpendicularDistance < 0.5) {
                   if (isPPP && isPPP.isParallel) {
+                    let lineLen = startPt2.distanceTo(endPt2);
+                    let doorLen = doorTmpSt.distanceTo(doorTmpEd);
                     let tmpLine66 = new THREE5.Line3(startPt2, endPt2);
                     let tmpPt66 = new THREE5.Vector3(doorTmpSt.x, doorTmpSt.y, startPt2.z);
                     let ptClose66 = tmpLine66.closestPointToPoint(tmpPt66, true, new THREE5.Vector3());
                     let isPPPP = perpendicularInfo(ptClose66, tmpPt66, doorTmpSt, doorTmpEd);
-                    if (isPPPP && isPPPP.angle > 85) {
+                    if (doorLen > lineLen) {
+                      tmpLine66 = new THREE5.Line3(
+                        new THREE5.Vector3(doorTmpSt.x, doorTmpSt.y, startPt2.z),
+                        new THREE5.Vector3(doorTmpEd.x, doorTmpEd.y, startPt2.z)
+                      );
+                      tmpPt66 = startPt2.clone();
+                      ptClose66 = tmpLine66.closestPointToPoint(tmpPt66, true, new THREE5.Vector3());
+                      isPPPP = perpendicularInfo(ptClose66, tmpPt66, doorTmpSt, doorTmpEd);
+                      [ptClose66, tmpPt66] = [tmpPt66, ptClose66];
+                    }
+                    if (isPPPP && isPPPP.angle > 85 && !wallBelowBeam) {
                       doorAndBeamDataObj.beamNearWallVec = new THREE5.Vector3().subVectors(ptClose66, tmpPt66).normalize();
                       if (doorAndBeamDataObj.beamStart.z > lines[x].rooftopPz - 0.03 && length2 > 1) {
                         wallBelowBeam = true;
@@ -4928,8 +4997,12 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
             });
             allDoorLines1.push({
               start: doorTmpSt,
-              end: doorTmpEd
+              end: doorTmpEd,
+              index,
+              id: doorAndBeamDataObj.id
             });
+            if (!findDoorIndexs.includes(index))
+              findDoorIndexs.push(index);
             id++;
             if (isPullOutDoor && length2 < 2) break;
           }
@@ -5538,7 +5611,8 @@ function clonePoint(p) {
 }
 
 // src/geometry/colLine.mjs
-var getColLine = (lines, runDataList) => {
+import * as gfx from "rm-gxf-computing-rusts";
+var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster = null) => {
   if (!lines || lines.length <= 0) return;
   let colDatas = {
     rectangles: [],
@@ -5756,6 +5830,7 @@ var getColLine = (lines, runDataList) => {
       continue;
     let colIndexs = {
       uuids: [],
+      rooftopPz: 0,
       missingEdge: {
         start: new THREE6.Vector3(),
         end: new THREE6.Vector3()
@@ -5854,6 +5929,7 @@ var getColLine = (lines, runDataList) => {
         let area2 = length1 * length2;
         if (area2 < minArea || area2 > maxArea) continue;
         colIndexs.uuids = [lines[i].uuid, lines[j].uuid, lines[k].uuid];
+        colIndexs.rooftopPz = Math.max(lines[i].rooftopPz, lines[j].rooftopPz, lines[k].rooftopPz);
         colIndexs.missingEdge.start = nextNextEndPt;
         colIndexs.missingEdge.end = startPt;
         break;
@@ -8755,17 +8831,25 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
             const isMaxBox = compareBoxVolume(obb1, obb2);
             if (type1 !== "wall" && type1 !== "floor" && type1 !== "roof") {
               if (type1 === "window") {
-                if (type2 === "balcony railing" && containsObbPoints(obb1, array2[k].points)) {
-                  array2[k].isDel = true;
-                  continue;
-                }
-                if (type2 === "balcony railing" && containsObbPoints(obb2, array1[e].points)) {
-                  array1[e].isDel = true;
-                  break;
-                }
-                if (type2 === "balcony railing" && checkBundingBox(obb1, obb2, array1[e].points, array2[k].points) && (Math.abs(minz1 - minz2) < 0.1 || Math.abs(minz2 - averagePz3) > 0.3)) {
-                  array2[k].isDel = true;
-                  continue;
+                const size1 = new THREE8.Vector3();
+                obb1.getSize(size1);
+                let maxLen1 = size1.x > size1.y ? size1.x : size1.y;
+                const size2 = new THREE8.Vector3();
+                obb2.getSize(size2);
+                let maxLen2 = size2.x > size2.y ? size2.x : size2.y;
+                if (Math.abs(maxLen1 - maxLen2) < 0.5 || maxLen1 > maxLen2) {
+                  if (type2 === "balcony railing" && containsObbPoints(obb1, array2[k].points)) {
+                    array2[k].isDel = true;
+                    continue;
+                  }
+                  if (type2 === "balcony railing" && containsObbPoints(obb2, array1[e].points)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
+                  if (type2 === "balcony railing" && checkBundingBox(obb1, obb2, array1[e].points, array2[k].points) && (Math.abs(minz1 - minz2) < 0.1 || Math.abs(minz2 - averagePz3) > 0.3)) {
+                    array2[k].isDel = true;
+                    continue;
+                  }
                 }
                 if (type2 === "door" && containsObbPoints(obb1, array2[k].points)) {
                   array2[k].isDel = true;
@@ -8778,17 +8862,25 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
                 if (type2 === "window sill")
                   continue;
               } else if (type1 === "balcony railing") {
-                if (type2 === "window" && containsObbPoints(obb1, array2[k].points)) {
-                  array2[k].isDel = true;
-                  continue;
-                }
-                if (type2 === "window" && containsObbPoints(obb2, array1[e].points)) {
-                  array1[e].isDel = true;
-                  break;
-                }
-                if (type2 === "window" && checkBundingBox(obb1, obb2, array1[e].points, array2[k].points) && (Math.abs(minz1 - minz2) < 0.1 || Math.abs(minz1 - averagePz3) > 0.3)) {
-                  array1[e].isDel = true;
-                  break;
+                const size1 = new THREE8.Vector3();
+                obb1.getSize(size1);
+                let maxLen1 = size1.x > size1.y ? size1.x : size1.y;
+                const size2 = new THREE8.Vector3();
+                obb2.getSize(size2);
+                let maxLen2 = size2.x > size2.y ? size2.x : size2.y;
+                if (Math.abs(maxLen1 - maxLen2) < 0.5 || maxLen1 < maxLen2) {
+                  if (type2 === "window" && containsObbPoints(obb1, array2[k].points)) {
+                    array2[k].isDel = true;
+                    continue;
+                  }
+                  if (type2 === "window" && containsObbPoints(obb2, array1[e].points)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
+                  if (type2 === "window" && checkBundingBox(obb1, obb2, array1[e].points, array2[k].points) && (Math.abs(minz1 - minz2) < 0.1 || Math.abs(minz1 - averagePz3) > 0.3)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
                 }
                 if (type2 === "Staircase" && containsObbPoints(obb1, array2[k].points)) {
                   array1[e].isStaircaseBalconyRailing = true;
@@ -10547,65 +10639,6 @@ function obbContainsPoint(obb, point2, epsilon3 = 1e-6) {
   const z = v2.dot(zAxis);
   return Math.abs(x) <= h.x + epsilon3 && Math.abs(y) <= h.y + epsilon3 && Math.abs(z) <= h.z + epsilon3;
 }
-function voxelDownsample2DForContour(points, cellSize) {
-  if (!points || points.length === 0) return [];
-  const map = /* @__PURE__ */ new Map();
-  for (let i = 0; i < points.length; i++) {
-    const p = points[i];
-    const x = p[0];
-    const y = p[1];
-    const gx = Math.floor(x / cellSize);
-    const gy = Math.floor(y / cellSize);
-    const key = `${gx}_${gy}`;
-    let cell = map.get(key);
-    if (!cell) {
-      const cx = (gx + 0.5) * cellSize;
-      const cy = (gy + 0.5) * cellSize;
-      const dx2 = x - cx;
-      const dy2 = y - cy;
-      cell = {
-        minX: p,
-        maxX: p,
-        minY: p,
-        maxY: p,
-        center: p,
-        centerDist2: dx2 * dx2 + dy2 * dy2,
-        cx,
-        cy
-      };
-      map.set(key, cell);
-      continue;
-    }
-    if (x < cell.minX[0]) cell.minX = p;
-    if (x > cell.maxX[0]) cell.maxX = p;
-    if (y < cell.minY[1]) cell.minY = p;
-    if (y > cell.maxY[1]) cell.maxY = p;
-    const dx = x - cell.cx;
-    const dy = y - cell.cy;
-    const dist22 = dx * dx + dy * dy;
-    if (dist22 < cell.centerDist2) {
-      cell.center = p;
-      cell.centerDist2 = dist22;
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  function addPoint(p) {
-    const key = `${p[0]}_${p[1]}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      result.push(p);
-    }
-  }
-  for (const cell of map.values()) {
-    addPoint(cell.minX);
-    addPoint(cell.maxX);
-    addPoint(cell.minY);
-    addPoint(cell.maxY);
-    addPoint(cell.center);
-  }
-  return result;
-}
 
 // src/utils/clusert.mjs
 function alphaForTriangle(points, ia, ib, ic) {
@@ -10775,10 +10808,9 @@ var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
       if (isIntersect) {
         for (let b = 0; b < slabData2.points.length; b++)
           slabData1.points.push(slabData2.points[b]);
-        let pathPoints = slabData1.contour;
-        for (let b = 0; b < slabData2.contour.length; b++)
-          pathPoints.push(slabData2.contour[b]);
-        let path3 = computeContour(pathPoints);
+        let tmpPoints = slabData1.points.map((p) => [p.x, p.y]);
+        tmpPoints = voxelDownsample2DForContour(tmpPoints, 0.1);
+        let path3 = computeContour(tmpPoints);
         slabData1.contour = path3;
         delIndex.add(k);
         k = -1;

package/package.json

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