rm-graphical-computing-node 1.0.69 → 1.0.70

package/dist/index.mjs

@@ -10881,7 +10881,7 @@ var getSlabData = (lines, runDataList, pointCloudCluster = null, getOblique = fa
   const flatSlabDatas = getFlatSlabData(flatSlabPoints, runDataList, pointCloudCluster);
   const flatFloorDatas = getFlatFloorData(flatSlabPoints, runDataList, pointCloudCluster);
   const obliqueSlabDatas = getObliqueSlabData(obliqueSlabPoints, runDataList, pointCloudCluster);
-  return { flatSlabDatas, obliqueSlabDatas };
+  return { flatSlabDatas, obliqueSlabDatas, flatFloorDatas };
 };
 var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   if (lines.length === 0) return;
@@ -11052,8 +11052,8 @@ var getFlatFloorData = (lines, runDataList, pointCloudCluster = null) => {
       if (averageZ < maxZ) continue;
       let pathPoints = newPoints[u4].map((p) => [p.x, p.y]);
       let path3 = computeContour(pathPoints);
-      let area2 = calculatePolygonArea(path3);
-      if (area2 < 0.5) continue;
+      let area3 = calculatePolygonArea(path3);
+      if (area3 < 0.5) continue;
       const floorData = {
         contour: path3,
         averagePz: averagePz2,
@@ -11099,11 +11099,62 @@ var getFlatFloorData = (lines, runDataList, pointCloudCluster = null) => {
     if (!delIndex.has(j))
       floorDatas.push({
         contour: newFloorDatas[j].contour,
-        averagePz: newFloorDatas[j].averagePz
-        // points: newFloorDatas[j].points
+        averagePz: newFloorDatas[j].averagePz,
+        points: newFloorDatas[j].points
       });
   }
-  return floorDatas;
+  let maxContourIndex = -1;
+  let maxPointsLength = 0;
+  let area2 = 0;
+  let avaregPzs = [];
+  let disIncludeIndexs = [];
+  for (let i = 0; i < floorDatas.length; i++) {
+    const contour = floorDatas[i].contour;
+    if (contour.length) {
+      const points = floorDatas[i].points;
+      let avaregZ = 0;
+      points.forEach((p) => {
+        avaregZ += p.z;
+      });
+      avaregZ /= points.length;
+      avaregPzs.push(avaregZ);
+      if (avaregZ < averageZ) {
+        const { width, height } = getOBB(contour);
+        const newArea = width * height;
+        if (newArea > area2) {
+          if (points.length > maxPointsLength && (avaregZ < runDataList[0].z || Math.abs(avaregZ - runDataList[0].z) < 0.1)) {
+            if (maxContourIndex > -1) {
+              disIncludeIndexs.push(maxContourIndex);
+            }
+            area2 = newArea;
+            maxContourIndex = i;
+            maxPointsLength = points.length;
+            continue;
+          }
+          disIncludeIndexs.push(i);
+        } else {
+          if (points.length > maxPointsLength && area2 - newArea < area2 / 3 && (avaregZ < runDataList[0].z || Math.abs(avaregZ - runDataList[0].z) < 0.1)) {
+            if (maxContourIndex > -1) {
+              disIncludeIndexs.push(maxContourIndex);
+            }
+            area2 = newArea;
+            maxContourIndex = i;
+            maxPointsLength = points.length;
+            continue;
+          }
+          disIncludeIndexs.push(i);
+        }
+      }
+    } else {
+      console.log("\u4E0D\u5B58\u5728\uFF01");
+      avaregPzs.push(1e4);
+    }
+  }
+  return {
+    contour: floorDatas[maxContourIndex].contour,
+    averagePz: avaregPzs[maxContourIndex]
+    /**, points: floorDatas[maxContourIndex].points  */
+  };
 };
 var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
   if (lines.length === 0) return [];
@@ -11280,6 +11331,46 @@ function getPathZ(path3, points) {
     }
   }
 }
+var getOBB = (contour) => {
+  const center = [0, 0];
+  for (const [x, y] of contour) {
+    center[0] += x;
+    center[1] += y;
+  }
+  center[0] /= contour.length;
+  center[1] /= contour.length;
+  let covXX = 0, covXY = 0, covYY = 0;
+  for (const [x, y] of contour) {
+    const dx = x - center[0];
+    const dy = y - center[1];
+    covXX += dx * dx;
+    covXY += dx * dy;
+    covYY += dy * dy;
+  }
+  covXX /= contour.length;
+  covXY /= contour.length;
+  covYY /= contour.length;
+  const det = Math.sqrt((covXX - covYY) ** 2 + 4 * covXY ** 2);
+  const eigenVal1 = (covXX + covYY + det) / 2;
+  const eigenVal2 = (covXX + covYY - det) / 2;
+  const angle = Math.atan2(2 * covXY, covXX - covYY) / 2;
+  const rotatedPoints = contour.map((p) => {
+    const x = p[0] * Math.cos(-angle) - p[1] * Math.sin(-angle);
+    const y = p[0] * Math.sin(-angle) + p[1] * Math.cos(-angle);
+    return [x, y];
+  });
+  let minX = Infinity, maxX = -Infinity;
+  let minY = Infinity, maxY = -Infinity;
+  for (const [x, y] of rotatedPoints) {
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  return { width, height };
+};
 
 // src/geometry/window.mjs
 import * as THREE10 from "three";

package/package.json

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