rm-graphical-computing-node 1.0.49 → 1.0.51

package/dist/index.mjs

@@ -10725,9 +10725,26 @@ function computeContour2(points) {
 
 // src/geometry/slabLine.mjs
 import * as THREE9 from "three";
-var getSlabData = (lines, runDataList, pointCloudCluster = null) => {
-  const flatSlabDatas = getFlatSlabData(lines, runDataList, pointCloudCluster);
-  return flatSlabDatas;
+var getSlabData = (lines, runDataList, pointCloudCluster = null, getOblique = false) => {
+  const flatSlabPoints = [];
+  const obliqueSlabPoints = [];
+  if (getOblique) {
+    for (let i = 0; i < lines.length; i++) {
+      const normal = lines[i][0];
+      if (normal.length != 3) continue;
+      if (normal[2] > 0.98)
+        flatSlabPoints.push(lines[i]);
+      else {
+        obliqueSlabPoints.push(lines[i]);
+      }
+    }
+  } else {
+    for (let i = 0; i < lines.length; i++)
+      flatSlabPoints.push(lines[i]);
+  }
+  const flatSlabDatas = getFlatSlabData(flatSlabPoints, runDataList, pointCloudCluster);
+  const obliqueSlabDatas = getObliqueSlabData(obliqueSlabPoints, runDataList, pointCloudCluster);
+  return { flatSlabDatas, obliqueSlabDatas };
 };
 var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   if (lines.length === 0) return;
@@ -10840,6 +10857,142 @@ var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   }
   return slabDatas;
 };
+var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
+  if (lines.length === 0) return [];
+  let slabDatas = [];
+  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) + 0.3;
+  for (let i = 0; i < lines.length; i++) {
+    let points = lines[i][1].points;
+    let newPoints = [];
+    if (pointCloudCluster != null) {
+      let clusterResult = pointCloudCluster([points], {
+        tolerance: 0.2,
+        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((i2) => points[i2]);
+          newPoints.push(newOriginalPoints);
+        }
+      } else
+        newPoints.push(points);
+    } else
+      newPoints.push(points);
+    if (newPoints.length == 0)
+      continue;
+    for (let x = 0; x < newPoints.length; x++) {
+      let { minZ, maxZ, averagePz: averagePz2, minZPt, maxZPt } = getPointsMinAndMax(newPoints[x]);
+      if (minZ < averageZ) continue;
+      let slabVec = new THREE9.Vector3().subVectors(minZPt, maxZPt).normalize();
+      let pathPoints = newPoints[x].map((p) => [p.x, p.y]);
+      let path3 = computeContour(pathPoints);
+      getPathZ(path3, newPoints[x]);
+      slabDatas.push({
+        points: newPoints[x],
+        contour: path3,
+        normal: lines[i][0]
+      });
+    }
+  }
+  let delIndex = /* @__PURE__ */ new Set();
+  for (let i = 0; i < slabDatas.length; i++) {
+    if (delIndex.has(i)) continue;
+    const slabData1 = slabDatas[i];
+    for (let j = 0; j < slabDatas.length; j++) {
+      if (i == j || delIndex.has(j)) continue;
+      const slabData2 = slabDatas[j];
+      if (Math.abs(slabData1.normal.z - slabData2.normal.z) > 0.05) continue;
+      const isIntersect = contoursIntersect(slabData1.contour, slabData2.contour, 1e-3);
+      if (isIntersect) {
+        for (let b = 0; b < slabData2.points.length; b++)
+          slabData1.points.push(slabData2.points[b]);
+        let pathPoints = slabData1.points.map((p) => [p.x, p.y]);
+        pathPoints = voxelDownsample2DForContour(pathPoints, 0.1);
+        let path3 = computeContour(pathPoints);
+        getPathZ(path3, slabData1.points);
+        slabData1.contour = path3;
+        delIndex.add(j);
+        j = -1;
+      }
+    }
+  }
+  let newSlabDatas = [];
+  for (let j = 0; j < slabDatas.length; j++) {
+    if (!delIndex.has(j))
+      newSlabDatas.push({
+        contour: slabDatas[j].contour,
+        averagePz: slabDatas[j].averagePz,
+        points: slabDatas[j].points,
+        normal: slabDatas[j].normal
+      });
+  }
+  slabDatas = [];
+  for (let i = 0; i < newSlabDatas.length; i++) {
+    let points = newSlabDatas[i].points;
+    let newPoints = [];
+    if (pointCloudCluster != null) {
+      let clusterResult = pointCloudCluster([points], {
+        tolerance: 0.2,
+        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((i2) => points[i2]);
+          newPoints.push(newOriginalPoints);
+        }
+      } else
+        newPoints.push(points);
+    } else
+      newPoints.push(points);
+    if (newPoints.length == 0)
+      continue;
+    for (let x = 0; x < newPoints.length; x++) {
+      let pathPoints = newPoints[x].map((p) => [p.x, p.y]);
+      let path3 = computeContour(pathPoints);
+      let area2 = calculatePolygonArea(path3);
+      if (area2 < 1) continue;
+      getPathZ(path3, newPoints[x]);
+      const { minZ, maxZ } = getPointsMinAndMax(newPoints[x]);
+      slabDatas.push({
+        // points: newPoints[x],
+        contour: path3,
+        minZ,
+        maxZ
+        // normal: lines[i][0],
+        // area: area
+      });
+    }
+  }
+  return slabDatas;
+};
+function getPathZ(path3, points) {
+  let pathPt = new THREE9.Vector3();
+  for (let i = 0; i < points.length; i++) {
+    for (let j = 0; j < path3.length; j++) {
+      if (path3[j].length == 3)
+        continue;
+      pathPt.set(path3[j][0], path3[j][1], points[i].z);
+      if (pathPt.distanceTo(points[i]) < 1e-3) {
+        path3[j].push(points[i].z);
+        break;
+      }
+    }
+  }
+}
 
 // src/geometry/window.mjs
 import * as THREE10 from "three";

package/package.json

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