rm-graphical-computing-node 1.0.68 → 1.0.70

package/dist/index.mjs

@@ -10879,8 +10879,9 @@ 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 };
+  return { flatSlabDatas, obliqueSlabDatas, flatFloorDatas };
 };
 var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   if (lines.length === 0) return;
@@ -10993,6 +10994,168 @@ 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 area3 = calculatePolygonArea(path3);
+      if (area3 < 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
+      });
+  }
+  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 [];
   let slabDatas = [];
@@ -11168,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";
@@ -11830,15 +12033,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.70",
   "description": "墙体/梁线/点云语义计算库（依赖 Python 与 three.js）",
   "type": "module",
   "main": "dist/index.mjs",