rm-graphical-computing-node 1.0.59 → 1.0.60

package/dist/index.mjs

@@ -5264,9 +5264,12 @@ var expansionLine = (doorTmpSt, doorTmpEd, beamTmpSt, beamTmpEd, height, origina
   let newDoorTmpEd = doorTmpEd.clone();
   const nearFloorPoints = [];
   const nearTopPoints = [];
-  let topDoorSegLine = new THREE5.Line3(beamTmpSt, beamTmpEd);
+  const nearBottomPoints = [];
+  let topDoorSegLine = new THREE5.Line3(beamTmpSt.clone(), beamTmpEd.clone());
+  let bottomDoorSegLine = new THREE5.Line3(doorTmpSt.clone(), doorTmpEd.clone());
   let tmpTarget33 = new THREE5.Vector3();
   let addHeight = 999999;
+  let downHeight = 999999;
   originalPoints.forEach((point2) => {
     if (point2.z - doorTmpSt.z < height / 2 + 0.1 && point2.z - doorTmpSt.z > height / 2 - 0.1) {
       nearFloorPoints.push(point2);
@@ -5281,6 +5284,16 @@ var expansionLine = (doorTmpSt, doorTmpEd, beamTmpSt, beamTmpEd, height, origina
         nearTopPoints.push(point2);
       }
     }
+    if (point2.z < doorTmpSt.z) {
+      let ptCloseTmp33 = bottomDoorSegLine.closestPointToPoint(point2, true, tmpTarget33);
+      let tmpVec1 = new THREE5.Vector3().subVectors(ptCloseTmp33, doorTmpSt);
+      let tmpVec2 = new THREE5.Vector3().subVectors(ptCloseTmp33, doorTmpEd);
+      let resP1 = isParallel(doorVector1, tmpVec1);
+      let resP2 = isParallel(doorVector2, tmpVec2);
+      if (resP1 && resP1.parallel && !resP1.sameDirection && resP2 && resP2.parallel && !resP2.sameDirection) {
+        nearBottomPoints.push(point2);
+      }
+    }
   });
   if (nearFloorPoints.length > 0) {
     const { newProjectPoints } = getProjectedPointOnLine(doorTmpSt, doorTmpEd, nearFloorPoints);
@@ -5330,6 +5343,19 @@ var expansionLine = (doorTmpSt, doorTmpEd, beamTmpSt, beamTmpEd, height, origina
     beamTmpEd.z += addHeight;
     height += addHeight;
   }
+  if (nearBottomPoints.length > 10) {
+    const { newOnLinePoints } = getProjectedPointOnLine(doorTmpSt, doorTmpEd, nearBottomPoints);
+    for (let n = 0; n < newOnLinePoints.length; n++) {
+      let ptCloseTmp33 = bottomDoorSegLine.closestPointToPoint(newOnLinePoints[n], true, tmpTarget33);
+      let add = ptCloseTmp33.distanceTo(newOnLinePoints[n]);
+      if (add > 0.02) {
+        if (downHeight > add)
+          downHeight = add;
+      }
+    }
+    doorTmpSt.z -= downHeight;
+    doorTmpEd.z -= downHeight;
+  }
   return {
     pt1: doorTmpSt,
     pt2: doorTmpEd,
@@ -6016,6 +6042,7 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
         newPoints = allCenterPoints;
       let retNum = newPoints.length;
       let ps = retNum / len * 100;
+      console.log(retNum, len, ps);
       if (ps < 60) {
         colDatas.threeEdgeRect[lines2[i].index].isDel = true;
       }
@@ -6026,11 +6053,14 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
 };
 var penetratingTask = async (finalLines, trajectoryObj, collectDataPath, type = "normal", diff = 0.01) => {
   if (!finalLines.length) return finalLines;
-  const offsets = [];
-  for (let i = 0; i < finalLines[0].checkResults[0].originalVertices.length; i++) {
-    offsets.push(0.01);
+  for (let v2 = 0; v2 < finalLines.length; v2++) {
+    for (let i = 0; i < finalLines[v2].checkResults.length; i++) {
+      const offsets = [];
+      for (let t2 = 0; t2 < finalLines[v2].checkResults[i].originalVertices.length; t2++)
+        offsets.push(0.5);
+      finalLines[v2].checkResults[i].offsets = offsets;
+    }
   }
-  finalLines[0].checkResults[0].offsets = offsets;
   const t = performance.now();
   const pcdDir = type === "normal" || "res" ? `${collectDataPath}/pcd` : `${collectDataPath}/customData/pcd`;
   const floatArray = await gfx.squareBackfacePointCloudTestAsync({
@@ -10832,6 +10862,7 @@ function computeContour2(points) {
 
 // src/geometry/slabLine.mjs
 import * as THREE9 from "three";
+import { min } from "three/tsl";
 var getSlabData = (lines, runDataList, pointCloudCluster = null, getOblique = false) => {
   const flatSlabPoints = [];
   const obliqueSlabPoints = [];
@@ -11073,7 +11104,42 @@ var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
       let area2 = calculatePolygonArea(path3);
       if (area2 < 1) continue;
       getPathZ(path3, newPoints[x]);
-      const { minZ, maxZ } = getPointsMinAndMax(newPoints[x]);
+      let mapSortPoint = /* @__PURE__ */ new Map();
+      for (let c = 0; c < newPoints[x].length; c++) {
+        let z = newPoints[x][c].z;
+        z = Math.floor(z * 10) / 10;
+        if (mapSortPoint.has(z)) {
+          const item = mapSortPoint.get(z);
+          item.num += 1;
+          item.points.push(newPoints[x][c]);
+          mapSortPoint.set(z, item);
+        } else {
+          mapSortPoint.set(z, { num: 1, points: [newPoints[x][c]] });
+        }
+      }
+      mapSortPoint = new Map(
+        [...mapSortPoint.entries()].sort((a, b) => a[0] - b[0])
+      );
+      let numMax = newPoints[x].length / 10;
+      let minZ = 0;
+      let maxZ = 0;
+      for (const [z, item] of mapSortPoint) {
+        if (item.num > numMax || item.num > 1800) {
+          const ret = getPointsMinAndMax(item.points);
+          minZ = ret.minZ;
+          break;
+        }
+      }
+      mapSortPoint = new Map(
+        [...mapSortPoint].sort((a, b) => b[0] - a[0])
+      );
+      for (const [z, item] of mapSortPoint) {
+        if (item.num > numMax || item.num > 1800) {
+          const ret = getPointsMinAndMax(item.points);
+          maxZ = ret.maxZ;
+          break;
+        }
+      }
       slabDatas.push({
         // points: newPoints[x],
         contour: path3,

package/package.json

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