rm-graphical-computing-node 1.0.68 → 1.0.69

package/dist/index.mjs

@@ -10879,6 +10879,7 @@ var getSlabData = (lines, runDataList, pointCloudCluster = null, getOblique = fa
       flatSlabPoints.push(lines[i]);
   }
   const flatSlabDatas = getFlatSlabData(flatSlabPoints, runDataList, pointCloudCluster);
+  const flatFloorDatas = getFlatFloorData(flatSlabPoints, runDataList, pointCloudCluster);
   const obliqueSlabDatas = getObliqueSlabData(obliqueSlabPoints, runDataList, pointCloudCluster);
   return { flatSlabDatas, obliqueSlabDatas };
 };
@@ -10993,6 +10994,117 @@ var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   }
   return slabDatas;
 };
+var getFlatFloorData = (lines, runDataList, pointCloudCluster = null) => {
+  if (lines.length === 0) return;
+  let floorDatas = [];
+  let maxHeightTrajectoryPt = new THREE9.Vector3(runDataList[0].x, runDataList[0].y, runDataList[0].z);
+  let totalZ = 0;
+  for (let i = 1; i < runDataList.length; i++) {
+    totalZ += runDataList[i].z;
+    if (runDataList[i].z > maxHeightTrajectoryPt.z) {
+      maxHeightTrajectoryPt.set(runDataList[i].x, runDataList[i].y, runDataList[i].z);
+    }
+  }
+  const averageZ = totalZ / (runDataList.length - 1);
+  let maxPointsNum = 0;
+  let maxPointsZ = 0;
+  for (const line2 of lines) {
+    let points = line2[1].points;
+    if (points.length < 30) continue;
+    let mapSortPoint = /* @__PURE__ */ new Map();
+    for (let c = 0; c < points.length; c++) {
+      let z = points[c].z;
+      z = Math.floor(z * 10) / 10;
+      if (mapSortPoint.has(z)) {
+        const item = mapSortPoint.get(z);
+        item.num += 1;
+        item.points.push(points[c]);
+        mapSortPoint.set(z, item);
+      } else {
+        mapSortPoint.set(z, { num: 1, points: [points[c]] });
+      }
+    }
+    let mostFrequentEntry = [...mapSortPoint.entries()].reduce(
+      (max2, cur) => cur[1].num > max2[1].num ? cur : max2
+    );
+    points = mostFrequentEntry[1].points.map((p) => new THREE9.Vector3(p.x, p.y, p.z));
+    let newPoints = [];
+    if (pointCloudCluster != null) {
+      let clusterResult = pointCloudCluster([points], {
+        tolerance: 0.1,
+        minClusterSize: 30,
+        maxClusterSize: 1e7,
+        threadCount: 1
+      });
+      if (clusterResult.length > 0) {
+        for (const cluster of clusterResult[0]) {
+          if (cluster.length < 50) continue;
+          const newOriginalPoints = cluster.map((i) => points[i]);
+          newPoints.push(newOriginalPoints);
+        }
+      } else
+        newPoints.push(points);
+    } else
+      newPoints.push(points);
+    for (let u4 = 0; u4 < newPoints.length; u4++) {
+      let { minZ, maxZ, averagePz: averagePz2 } = getPointsMinAndMax(newPoints[u4]);
+      const height = maxZ - minZ;
+      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;
+      const floorData = {
+        contour: path3,
+        averagePz: averagePz2,
+        points: newPoints[u4]
+      };
+      if (newPoints[u4].length > maxPointsNum) {
+        maxPointsNum = newPoints[u4].length;
+        maxPointsZ = averagePz2;
+      }
+      floorDatas.push(floorData);
+    }
+  }
+  const newFloorDatas = [];
+  for (const floorData of floorDatas) {
+    if (floorData.averagePz <= maxPointsZ || floorData.averagePz < averageZ) {
+      newFloorDatas.push(floorData);
+    }
+  }
+  let delIndex = /* @__PURE__ */ new Set();
+  for (let j = 0; j < newFloorDatas.length; j++) {
+    if (delIndex.has(j)) continue;
+    const floorData1 = newFloorDatas[j];
+    for (let k = 0; k < newFloorDatas.length; k++) {
+      if (j == k || delIndex.has(k))
+        continue;
+      const floorData2 = newFloorDatas[k];
+      if (Math.abs(floorData1.averagePz - floorData2.averagePz) > 0.05) continue;
+      const isIntersect = contoursIntersect(floorData1.contour, floorData2.contour, 1e-3);
+      if (isIntersect) {
+        for (let b = 0; b < floorData2.points.length; b++)
+          floorData1.points.push(floorData2.points[b]);
+        let tmpPoints = floorData1.points.map((p) => [p.x, p.y]);
+        tmpPoints = voxelDownsample2DForContour(tmpPoints, 0.1);
+        let path3 = computeContour(tmpPoints);
+        floorData1.contour = path3;
+        delIndex.add(k);
+        k = -1;
+      }
+    }
+  }
+  floorDatas = [];
+  for (let j = 0; j < newFloorDatas.length; j++) {
+    if (!delIndex.has(j))
+      floorDatas.push({
+        contour: newFloorDatas[j].contour,
+        averagePz: newFloorDatas[j].averagePz
+        // points: newFloorDatas[j].points
+      });
+  }
+  return floorDatas;
+};
 var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
   if (lines.length === 0) return [];
   let slabDatas = [];
@@ -11830,15 +11942,6 @@ var getWindowData = (lines, pcdData, lineReader) => {
         lines[findDoorIndexs[j]].windowData = savedata2;
     }
   }
-  let tmpLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (!lines[i].isLine2)
-      tmpLines.push(lines[i]);
-    if (lines[i].isLine2 && lines[i].windowData.length != 0)
-      tmpLines.push(lines[i]);
-  }
-  lines.length = 0;
-  lines.push(...tmpLines);
   return { lines, pcdData };
 };
 var checkWindowAndDoorIsTrue = async (lines, runDataList, collectDataPath, pointCloudCluster = null) => {

package/package.json

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