rm-graphical-computing-node 1.0.48 → 1.0.50

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,16 +10857,150 @@ 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]);
+      slabDatas.push({
+        // points: newPoints[x],
+        contour: path3,
+        normal: lines[i][0],
+        area: area2
+      });
+    }
+  }
+  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";
 import { mergeGeometries as mergeGeometries5 } from "three/examples/jsm/utils/BufferGeometryUtils.js";
-var getWindowData = (lines, pcdData) => {
+var getWindowData = (lines, pcdData, lineReader) => {
   if (lines.length <= 0 || !pcdData)
     return lines;
   if (!pcdData) pcdData = [];
   for (let line2 of lines) {
     let allRegion = [];
+    line2.checkResults = lineReader.getLineCheckReultsById(line2.id);
     if (!line2.checkResults || line2.checkResults.length <= 0)
       continue;
     for (let r = 0; r < line2.checkResults.length; r++) {
@@ -10934,6 +11085,7 @@ var getWindowData = (lines, pcdData) => {
       }
       allRegion.push(...val);
     }
+    line2.checkResults = null;
     line2.mergeCheckRegion = allRegion;
   }
   const windowDatas = [];
@@ -10980,10 +11132,12 @@ var getWindowData = (lines, pcdData) => {
     let line2 = lines[index];
     if (line2.length < 0.5) continue;
     if (line2.noDetection) continue;
-    if (!line2.doorAndBeamData)
-      line2.doorAndBeamData = [];
-    if (!line2.doorAndBeamIdToCheckResults)
-      line2.doorAndBeamIdToCheckResults = [];
+    line2.originalPoints = lineReader.getOriginalPointsById(line2.id);
+    line2.checkResults = lineReader.getLineCheckReultsById(line2.id);
+    if (!line2.windowData)
+      line2.windowData = [];
+    if (!line2.windowIdToCheckResults)
+      line2.windowIdToCheckResults = [];
     if (!line2.mergeCheckRegion || line2.mergeCheckRegion.length == 0)
       continue;
     line2.completePointAreaPercentage = -1;
@@ -11359,11 +11513,11 @@ var getWindowData = (lines, pcdData) => {
               pcbDoorIndexs,
               groundClearance
             };
-            line2.doorAndBeamIdToCheckResults.push([region.index, id]);
-            line2.doorAndBeamData.push(doorAndBeamDataObj);
+            line2.windowIdToCheckResults.push([region.index, id]);
+            line2.windowData.push(doorAndBeamDataObj);
             doorBeamDataIndex.push({
               linesIndex: index,
-              doorIndex: line2.doorAndBeamData.length - 1
+              doorIndex: line2.windowData.length - 1
             });
             allDoorLines1.push({
               start: doorTmpSt,
@@ -11380,26 +11534,28 @@ var getWindowData = (lines, pcdData) => {
     }
     let faceArea = line2.length * (line2.rooftopPz - line2.start.z);
     line2.completePointAreaPercentage = totalArea / faceArea * 100;
+    line2.checkResults = null;
+    line2.originalPoints = null;
   }
   if (findDoorIndexs.length > 1) {
     for (let j = 0; j < findDoorIndexs.length; j++) {
       let savedata2 = [];
-      for (let d = 0; d < lines[findDoorIndexs[j]].doorAndBeamData.length; d++) {
-        if (lines[findDoorIndexs[j]].doorAndBeamData[d].type != "window")
+      for (let d = 0; d < lines[findDoorIndexs[j]].windowData.length; d++) {
+        if (lines[findDoorIndexs[j]].windowData[d].type != "window")
           continue;
         let isDel = false;
         if (!isDel) {
-          let doorSt1 = lines[findDoorIndexs[j]].doorAndBeamData[d].windowBottomSt.clone();
-          let doorEd1 = lines[findDoorIndexs[j]].doorAndBeamData[d].windowBottomEd.clone();
+          let doorSt1 = lines[findDoorIndexs[j]].windowData[d].windowBottomSt.clone();
+          let doorEd1 = lines[findDoorIndexs[j]].windowData[d].windowBottomEd.clone();
           doorSt1.z = doorEd1.z = 0;
           let doorLen1 = doorSt1.distanceTo(doorEd1);
           for (let b = 0; b < findDoorIndexs.length; b++) {
             if (j == b) continue;
-            for (let r = 0; r < lines[findDoorIndexs[b]].doorAndBeamData.length; r++) {
-              if (lines[findDoorIndexs[b]].doorAndBeamData[r].type != "window")
+            for (let r = 0; r < lines[findDoorIndexs[b]].windowData.length; r++) {
+              if (lines[findDoorIndexs[b]].windowData[r].type != "window")
                 continue;
-              let doorSt2 = lines[findDoorIndexs[b]].doorAndBeamData[r].windowBottomSt.clone();
-              let doorEd2 = lines[findDoorIndexs[b]].doorAndBeamData[r].windowBottomEd.clone();
+              let doorSt2 = lines[findDoorIndexs[b]].windowData[r].windowBottomSt.clone();
+              let doorEd2 = lines[findDoorIndexs[b]].windowData[r].windowBottomEd.clone();
               doorSt2.z = doorEd2.z = 0;
               let doorLen2 = doorSt2.distanceTo(doorEd2);
               let resultTmp = classifySegments(doorSt1, doorEd1, doorSt2, doorEd2);
@@ -11409,8 +11565,8 @@ var getWindowData = (lines, pcdData) => {
                 let ptClose = line3.closestPointToPoint(ptMid, true, new THREE10.Vector3());
                 let distTmp = ptMid.distanceTo(ptClose);
                 if (Math.abs(doorLen1 - resultTmp.overlap) < 0.1 && distTmp < 0.04) {
-                  if (lines[findDoorIndexs[b]].doorAndBeamData[r].nearId == lines[findDoorIndexs[j]].doorAndBeamData[d].id) {
-                    lines[findDoorIndexs[b]].doorAndBeamData[r].nearId = -1;
+                  if (lines[findDoorIndexs[b]].windowData[r].nearId == lines[findDoorIndexs[j]].windowData[d].id) {
+                    lines[findDoorIndexs[b]].windowData[r].nearId = -1;
                   }
                   isDel = true;
                   break;
@@ -11420,24 +11576,24 @@ var getWindowData = (lines, pcdData) => {
           }
         }
         if (isDel) {
-          for (let z = 0; z < lines[findDoorIndexs[j]].doorAndBeamIdToCheckResults.length; z++) {
-            if (lines[findDoorIndexs[j]].doorAndBeamIdToCheckResults[1] == lines[findDoorIndexs[j]].doorAndBeamData[d].id) {
-              lines[findDoorIndexs[j]].doorAndBeamIdToCheckResults.splice(z, 1);
+          for (let z = 0; z < lines[findDoorIndexs[j]].windowIdToCheckResults.length; z++) {
+            if (lines[findDoorIndexs[j]].windowIdToCheckResults[1] == lines[findDoorIndexs[j]].windowData[d].id) {
+              lines[findDoorIndexs[j]].windowIdToCheckResults.splice(z, 1);
               break;
             }
           }
         }
-        if (!isDel) savedata2.push(lines[findDoorIndexs[j]].doorAndBeamData[d]);
+        if (!isDel) savedata2.push(lines[findDoorIndexs[j]].windowData[d]);
       }
-      if (savedata2.length != lines[findDoorIndexs[j]].doorAndBeamData.length)
-        lines[findDoorIndexs[j]].doorAndBeamData = savedata2;
+      if (savedata2.length != lines[findDoorIndexs[j]].windowData.length)
+        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].doorAndBeamData.length != 0)
+    if (lines[i].isLine2 && lines[i].windowData.length != 0)
       tmpLines.push(lines[i]);
   }
   lines.length = 0;

package/package.json

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