rm-graphical-computing-node 1.0.71 → 1.0.72

package/dist/index.mjs

@@ -774,11 +774,11 @@ var require_concaveman = __commonJS({
       while (node) {
         for (var i = 0; i < node.children.length; i++) {
           var child = node.children[i];
-          var dist3 = node.leaf ? sqSegDist(child, b, c) : sqSegBoxDist(b, c, child);
-          if (dist3 > maxDist) continue;
+          var dist2 = node.leaf ? sqSegDist(child, b, c) : sqSegBoxDist(b, c, child);
+          if (dist2 > maxDist) continue;
           queue.push({
             node: child,
-            dist: dist3
+            dist: dist2
           });
         }
         while (queue.length && !queue.peek().node.children) {
@@ -3087,8 +3087,8 @@ var removeNoisePoints = (lines, lineReader, lineEditor) => {
           let ptCenter = line2.checkResults[g].allCenterPoints[h];
           ptCenter = new THREE3.Vector3(ptCenter.x, ptCenter.y, ptCenter.z);
           let ptClose = line3.closestPointToPoint(ptCenter, true, ptTarget);
-          let dist3 = ptCenter.distanceTo(ptClose);
-          if (Math.abs(dist3 - halfLen) < 0.01) {
+          let dist2 = ptCenter.distanceTo(ptClose);
+          if (Math.abs(dist2 - halfLen) < 0.01) {
             tmpNum++;
             if (!removePtsIndexMap.has(g)) {
               removePtsIndexMap.set(g, {
@@ -3234,9 +3234,9 @@ var getFarthestPoints = (points) => {
   let result = [];
   for (let i = 0; i < points.length; i++) {
     for (let j = i + 1; j < points.length; j++) {
-      const dist3 = points[i].distanceTo(points[j]);
-      if (dist3 > maxDist) {
-        maxDist = dist3;
+      const dist2 = points[i].distanceTo(points[j]);
+      if (dist2 > maxDist) {
+        maxDist = dist2;
         result = [points[i], points[j]];
       }
     }
@@ -3482,10 +3482,10 @@ var voxelDownsample2DForContour = (points, cellSize) => {
     if (y > cell.maxY[1]) cell.maxY = p;
     const dx = x - cell.cx;
     const dy = y - cell.cy;
-    const dist22 = dx * dx + dy * dy;
-    if (dist22 < cell.centerDist2) {
+    const dist2 = dx * dx + dy * dy;
+    if (dist2 < cell.centerDist2) {
       cell.center = p;
-      cell.centerDist2 = dist22;
+      cell.centerDist2 = dist2;
     }
   }
   const seen = /* @__PURE__ */ new Set();
@@ -3942,13 +3942,13 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
         let newDoorSt = new THREE5.Vector3(lines[u4].start.x, lines[u4].start.y, 0);
         let newDoorEd = new THREE5.Vector3(lines[u4].end.x, lines[u4].end.y, 0);
         let dist1 = door.doorStartPt.distanceTo(door.doorEndPt);
-        let dist22 = newDoorSt.distanceTo(newDoorEd);
+        let dist2 = newDoorSt.distanceTo(newDoorEd);
         let res = getParallelism(door.doorStartPt, door.doorEndPt, newDoorSt, newDoorEd);
-        if (Math.abs(dist22 - dist1) < 0.5 && res && res.angleDeg < 10) {
+        if (Math.abs(dist2 - dist1) < 0.5 && res && res.angleDeg < 10) {
           door.doorStartPt = new THREE5.Vector3(lines[u4].start.x, lines[u4].start.y, 0);
           door.doorEndPt = new THREE5.Vector3(lines[u4].end.x, lines[u4].end.y, 0);
           break;
-        } else if (Math.abs(dist22 - dist1) > 1.3 && res && res.angleDeg < 10) {
+        } else if (Math.abs(dist2 - dist1) > 1.3 && res && res.angleDeg < 10) {
           let restmp = classifySegments(door.doorStartPt, door.doorEndPt, newDoorSt, newDoorEd, { parallelAngleMax: THREE5.MathUtils.degToRad(15) });
           let dist11 = door.doorStartPt.distanceTo(newDoorSt);
           let dist12 = door.doorStartPt.distanceTo(newDoorEd);
@@ -3963,8 +3963,8 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
             let resTmp1 = lineTmp33.closestPointToPoint(door.doorStartPt, true, new THREE5.Vector3());
             let resTmp2 = lineTmp33.closestPointToPoint(door.doorEndPt, true, new THREE5.Vector3());
             let dist15 = resTmp1.distanceTo(door.doorStartPt);
-            let dist23 = resTmp2.distanceTo(door.doorEndPt);
-            if (dist15 < 0.1 || dist23 < 0.1) {
+            let dist22 = resTmp2.distanceTo(door.doorEndPt);
+            if (dist15 < 0.1 || dist22 < 0.1) {
               door.inWall = true;
               break;
             }
@@ -4392,14 +4392,14 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                         let line3 = new THREE5.Line3(new THREE5.Vector3(line2.start.x, line2.start.y, 0), new THREE5.Vector3(line2.end.x, line2.end.y, 0));
                         let targeVec = new THREE5.Vector3();
                         let ptClose = line3.closestPointToPoint(ptCenter, true, targeVec);
-                        let dist3 = ptCenter.distanceTo(ptClose);
-                        if (dist3 < 0.15) {
+                        let dist2 = ptCenter.distanceTo(ptClose);
+                        if (dist2 < 0.15) {
                           let dist1 = beamSt.distanceTo(doorSt);
                           let dist22 = beamEd.distanceTo(doorSt);
                           if (dist1 > 0.25 && dist22 > 0.25) {
-                            let dist32 = beamSt.distanceTo(doorEd);
+                            let dist3 = beamSt.distanceTo(doorEd);
                             let dist4 = beamEd.distanceTo(doorEd);
-                            if (dist32 > 0.2 && dist4 > 0.2) {
+                            if (dist3 > 0.2 && dist4 > 0.2) {
                               continue;
                             }
                           }
@@ -4434,10 +4434,10 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                         if (Math.abs(distTmp1 - result.overlap) < 0.25 || Math.abs(distTmp2 - result.overlap) < 0.25) {
                           if (distTmp2 > distTmp1 && Math.abs(distTmp2 - result.overlap) > 1) {
                             let dist1 = beamSt.distanceTo(doorSt);
-                            let dist22 = beamSt.distanceTo(doorEd);
+                            let dist2 = beamSt.distanceTo(doorEd);
                             let dist3 = beamEd.distanceTo(doorSt);
                             let dist4 = beamEd.distanceTo(doorEd);
-                            let dist5 = dist1 < dist22 ? dist1 : dist22;
+                            let dist5 = dist1 < dist2 ? dist1 : dist2;
                             let dist6 = dist3 < dist4 ? dist3 : dist4;
                             let beamVec = new THREE5.Vector3().subVectors(beamSt, beamEd).normalize();
                             let addDoorLen = distTmp2 - result.overlap;
@@ -4783,13 +4783,13 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                 }
                 let targetVector = new THREE5.Vector3();
                 let ptClose = line3.closestPointToPoint(ptCenter, true, targetVector);
-                let dist3 = ptClose.distanceTo(ptCenter);
+                let dist2 = ptClose.distanceTo(ptCenter);
                 let vec2 = new THREE5.Vector3().subVectors(ptCenter, ptClose).normalize();
                 let vecNegate = vec2.clone().negate();
-                let ptCenterOther = ptCenter.clone().addScaledVector(vecNegate, dist3 + 0.1);
+                let ptCenterOther = ptCenter.clone().addScaledVector(vecNegate, dist2 + 0.1);
                 let isInsert = segmentsIntersect2D(line3.start, line3.end, ptCenter, ptCenterOther);
                 let isTrue = !isDoor && !tmpDoorBeamData.isDoor && (length1 > length22 * 2.5 || length22 > length1 * 2.5);
-                if (dist3 < 0.4 && isInsert != null && !isTrue) {
+                if (dist2 < 0.5 && isInsert != null && !isTrue) {
                   let isSameLine = false;
                   for (let v2 = 0; v2 < line2.doorAndBeamData.length; v2++) {
                     if (line2.doorAndBeamData[v2].id == tmpDoorBeamData.id) {
@@ -4836,28 +4836,28 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                       vec2 = vec2.negate();
                     }
                     if (length1 > minDoorLength2 && !tmpDoorBeamData.isPullOutDoor) {
-                      tmpDoorBeamData.beamStart = beamTmpSt.clone().addScaledVector(vecNegate, dist3);
-                      tmpDoorBeamData.beamEnd = beamTmpEd.clone().addScaledVector(vecNegate, dist3);
-                      tmpDoorBeamData.doorStart = doorTmpSt.clone().addScaledVector(vecNegate, dist3);
-                      tmpDoorBeamData.doorEnd = doorTmpEd.clone().addScaledVector(vecNegate, dist3);
+                      tmpDoorBeamData.beamStart = beamTmpSt.clone().addScaledVector(vecNegate, dist2);
+                      tmpDoorBeamData.beamEnd = beamTmpEd.clone().addScaledVector(vecNegate, dist2);
+                      tmpDoorBeamData.doorStart = doorTmpSt.clone().addScaledVector(vecNegate, dist2);
+                      tmpDoorBeamData.doorEnd = doorTmpEd.clone().addScaledVector(vecNegate, dist2);
                       tmpDoorBeamData.doorHeight = doorAndBeamDataObj.doorHeight;
                       tmpDoorBeamData.beamStart.z = tmpDoorBeamData.beamEnd.z = tmpDoorBeamData.doorStart.z + tmpDoorBeamData.doorHeight;
                       tmpDoorBeamData.doorOpenEndPoint = doorAndBeamDataObj.doorOpenEndPoint.clone();
                       tmpDoorBeamData.doorOpenVector = doorAndBeamDataObj.doorOpenVector.clone();
                     } else if (!isPullOutDoor || isPullOutDoor && tmpDoorBeamData.isPullOutDoor && hasCommon) {
-                      doorAndBeamDataObj.beamStart = tmpDoorBeamData.beamStart.clone().addScaledVector(vec2, dist3);
-                      doorAndBeamDataObj.beamEnd = tmpDoorBeamData.beamEnd.clone().addScaledVector(vec2, dist3);
-                      doorAndBeamDataObj.doorStart = tmpDoorBeamData.doorStart.clone().addScaledVector(vec2, dist3);
-                      doorAndBeamDataObj.doorEnd = tmpDoorBeamData.doorEnd.clone().addScaledVector(vec2, dist3);
+                      doorAndBeamDataObj.beamStart = tmpDoorBeamData.beamStart.clone().addScaledVector(vec2, dist2);
+                      doorAndBeamDataObj.beamEnd = tmpDoorBeamData.beamEnd.clone().addScaledVector(vec2, dist2);
+                      doorAndBeamDataObj.doorStart = tmpDoorBeamData.doorStart.clone().addScaledVector(vec2, dist2);
+                      doorAndBeamDataObj.doorEnd = tmpDoorBeamData.doorEnd.clone().addScaledVector(vec2, dist2);
                       doorAndBeamDataObj.doorHeight = tmpDoorBeamData.doorHeight;
                       doorAndBeamDataObj.beamStart.z = doorAndBeamDataObj.beamEnd.z = doorAndBeamDataObj.doorStart.z + doorAndBeamDataObj.doorHeight;
                       doorAndBeamDataObj.doorOpenEndPoint = tmpDoorBeamData.doorOpenEndPoint.clone();
                       doorAndBeamDataObj.doorOpenVector = tmpDoorBeamData.doorOpenVector.clone();
                     } else {
-                      tmpDoorBeamData.beamStart = beamTmpSt.clone().addScaledVector(vecNegate, dist3);
-                      tmpDoorBeamData.beamEnd = beamTmpEd.clone().addScaledVector(vecNegate, dist3);
-                      tmpDoorBeamData.doorStart = doorTmpSt.clone().addScaledVector(vecNegate, dist3);
-                      tmpDoorBeamData.doorEnd = doorTmpEd.clone().addScaledVector(vecNegate, dist3);
+                      tmpDoorBeamData.beamStart = beamTmpSt.clone().addScaledVector(vecNegate, dist2);
+                      tmpDoorBeamData.beamEnd = beamTmpEd.clone().addScaledVector(vecNegate, dist2);
+                      tmpDoorBeamData.doorStart = doorTmpSt.clone().addScaledVector(vecNegate, dist2);
+                      tmpDoorBeamData.doorEnd = doorTmpEd.clone().addScaledVector(vecNegate, dist2);
                       tmpDoorBeamData.doorHeight = doorAndBeamDataObj.doorHeight;
                       tmpDoorBeamData.beamStart.z = tmpDoorBeamData.beamEnd.z = tmpDoorBeamData.doorStart.z + tmpDoorBeamData.doorHeight;
                       tmpDoorBeamData.doorOpenEndPoint = doorAndBeamDataObj.doorOpenEndPoint.clone();
@@ -4869,28 +4869,28 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
                       vec2 = vec2.negate();
                     }
                     if (length22 > minDoorLength2 && !isPullOutDoor) {
-                      doorAndBeamDataObj.beamStart = tmpDoorBeamData.beamStart.clone().addScaledVector(vecNegate, dist3);
-                      doorAndBeamDataObj.beamEnd = tmpDoorBeamData.beamEnd.clone().addScaledVector(vecNegate, dist3);
-                      doorAndBeamDataObj.doorStart = tmpDoorBeamData.doorStart.clone().addScaledVector(vecNegate, dist3);
-                      doorAndBeamDataObj.doorEnd = tmpDoorBeamData.doorEnd.clone().addScaledVector(vecNegate, dist3);
+                      doorAndBeamDataObj.beamStart = tmpDoorBeamData.beamStart.clone().addScaledVector(vecNegate, dist2);
+                      doorAndBeamDataObj.beamEnd = tmpDoorBeamData.beamEnd.clone().addScaledVector(vecNegate, dist2);
+                      doorAndBeamDataObj.doorStart = tmpDoorBeamData.doorStart.clone().addScaledVector(vecNegate, dist2);
+                      doorAndBeamDataObj.doorEnd = tmpDoorBeamData.doorEnd.clone().addScaledVector(vecNegate, dist2);
                       doorAndBeamDataObj.doorHeight = tmpDoorBeamData.doorHeight;
                       doorAndBeamDataObj.beamStart.z = doorAndBeamDataObj.beamEnd.z = doorAndBeamDataObj.doorStart.z + doorAndBeamDataObj.doorHeight;
                       doorAndBeamDataObj.doorOpenEndPoint = tmpDoorBeamData.doorOpenEndPoint.clone();
                       doorAndBeamDataObj.doorOpenVector = tmpDoorBeamData.doorOpenVector.clone();
                     } else if (!tmpDoorBeamData.isPullOutDoor || isPullOutDoor && tmpDoorBeamData.isPullOutDoor && hasCommon) {
-                      tmpDoorBeamData.beamStart = beamTmpSt.clone().addScaledVector(vec2, dist3);
-                      tmpDoorBeamData.beamEnd = beamTmpEd.clone().addScaledVector(vec2, dist3);
-                      tmpDoorBeamData.doorStart = doorTmpSt.clone().addScaledVector(vec2, dist3);
-                      tmpDoorBeamData.doorEnd = doorTmpEd.clone().addScaledVector(vec2, dist3);
+                      tmpDoorBeamData.beamStart = beamTmpSt.clone().addScaledVector(vec2, dist2);
+                      tmpDoorBeamData.beamEnd = beamTmpEd.clone().addScaledVector(vec2, dist2);
+                      tmpDoorBeamData.doorStart = doorTmpSt.clone().addScaledVector(vec2, dist2);
+                      tmpDoorBeamData.doorEnd = doorTmpEd.clone().addScaledVector(vec2, dist2);
                       tmpDoorBeamData.doorHeight = doorAndBeamDataObj.doorHeight;
                       tmpDoorBeamData.beamStart.z = tmpDoorBeamData.beamEnd.z = tmpDoorBeamData.doorStart.z + tmpDoorBeamData.doorHeight;
                       tmpDoorBeamData.doorOpenEndPoint = doorAndBeamDataObj.doorOpenEndPoint.clone();
                       tmpDoorBeamData.doorOpenVector = doorAndBeamDataObj.doorOpenVector.clone();
                     } else {
-                      doorAndBeamDataObj.beamStart = tmpDoorBeamData.beamStart.clone().addScaledVector(vecNegate, dist3);
-                      doorAndBeamDataObj.beamEnd = tmpDoorBeamData.beamEnd.clone().addScaledVector(vecNegate, dist3);
-                      doorAndBeamDataObj.doorStart = tmpDoorBeamData.doorStart.clone().addScaledVector(vecNegate, dist3);
-                      doorAndBeamDataObj.doorEnd = tmpDoorBeamData.doorEnd.clone().addScaledVector(vecNegate, dist3);
+                      doorAndBeamDataObj.beamStart = tmpDoorBeamData.beamStart.clone().addScaledVector(vecNegate, dist2);
+                      doorAndBeamDataObj.beamEnd = tmpDoorBeamData.beamEnd.clone().addScaledVector(vecNegate, dist2);
+                      doorAndBeamDataObj.doorStart = tmpDoorBeamData.doorStart.clone().addScaledVector(vecNegate, dist2);
+                      doorAndBeamDataObj.doorEnd = tmpDoorBeamData.doorEnd.clone().addScaledVector(vecNegate, dist2);
                       doorAndBeamDataObj.doorHeight = tmpDoorBeamData.doorHeight;
                       doorAndBeamDataObj.beamStart.z = doorAndBeamDataObj.beamEnd.z = doorAndBeamDataObj.doorStart.z + doorAndBeamDataObj.doorHeight;
                       doorAndBeamDataObj.doorOpenEndPoint = tmpDoorBeamData.doorOpenEndPoint.clone();
@@ -5069,19 +5069,19 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
               let ptClose1 = line3.closestPointToPoint(beamStOther, true, target);
               let ptClose2 = line3.closestPointToPoint(beamEdOther, true, target);
               let dist1 = ptClose1.distanceTo(beamStOther);
-              let dist23 = ptClose2.distanceTo(beamEdOther);
+              let dist2 = ptClose2.distanceTo(beamEdOther);
               let doorStartPt, doorEndPt;
-              if (dist1 > dist23 && dist23 > minDoorLength) {
+              if (dist1 > dist2 && dist2 > minDoorLength) {
                 doorStartPt = beamEdOther;
                 doorEndPt = ptClose2;
-              } else if (dist1 < dist23 && dist1 > minDoorLength) {
+              } else if (dist1 < dist2 && dist1 > minDoorLength) {
                 doorStartPt = beamStOther;
                 doorEndPt = ptClose1;
               } else
                 continue;
               dist1 = nearDoorPt.distanceTo(beamStOther);
-              dist23 = nearDoorPt.distanceTo(beamEdOther);
-              if (dist1 > maxDoorLength && dist23 > maxDoorLength)
+              dist2 = nearDoorPt.distanceTo(beamEdOther);
+              if (dist1 > maxDoorLength && dist2 > maxDoorLength)
                 continue;
               let isPP2 = getParallelism(doorStartPt, doorEndPt, beamStOther, beamEdOther);
               let isPPP = getParallelism(doorStartPt, doorEndPt, doorStExtended, doorEdExtended);
@@ -5409,7 +5409,6 @@ var findClosedRegionUuidGroups = (inputSegments, options = {}) => {
   for (const seg of segments) {
     const a2 = project(seg.start);
     const b2 = project(seg.end);
-    if (dist2(a2, b2) < EPS * EPS) continue;
     const va = getVertexId(a2);
     const vb = getVertexId(b2);
     if (va === vb) continue;
@@ -5572,9 +5571,6 @@ function splitSegmentsAtIntersections(inputSegments, project, EPS = 1e-6) {
     for (let k = 0; k < uniquePoints.length - 1; k++) {
       const p1 = uniquePoints[k].point;
       const p2 = uniquePoints[k + 1].point;
-      const p12 = project(p1);
-      const p22 = project(p2);
-      if (dist2(p12, p22) < EPS * EPS) continue;
       result.push({
         start: p1,
         end: p2,
@@ -5620,11 +5616,6 @@ function segmentIntersection(p1, p2, q1, q2, EPS = 1e-6) {
 function cross2(a, b) {
   return a.x * b.y - a.y * b.x;
 }
-function dist2(a, b) {
-  const dx = a.x - b.x;
-  const dy = a.y - b.y;
-  return dx * dx + dy * dy;
-}
 function signedArea(points) {
   let area2 = 0;
   for (let i = 0; i < points.length; i++) {
@@ -5665,7 +5656,8 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
     threeEdgeRect: []
   };
   let isFindColIndexs = /* @__PURE__ */ new Set();
-  let minColLineLength = 0.05;
+  let minColLineLength = 0.01;
+  let threeMinColLineLength = 0.15;
   let maxColLineLength = 2;
   let minArea = 0.1;
   let maxArea = 2.5;
@@ -5814,7 +5806,7 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
             let isEq6 = ptIsEqual(startPt4, endPt1);
             let isEq7 = ptIsEqual(endPt4, startPt1);
             let isEq8 = ptIsEqual(endPt4, endPt1);
-            if (isEq5 || isEq6 || isEq7 || isEq8) {
+            if ((isEq5 || isEq6 || isEq7 || isEq8) && length1 < length2 * 3 && length2 < length1 * 3) {
               isRect = true;
             } else {
               for (let m = l + 1; m < result[i].lineIndexes.length; m++) {
@@ -5850,8 +5842,10 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
                   isEq7 = ptIsEqual(endPt4, startPt1);
                   isEq8 = ptIsEqual(endPt4, endPt1);
                   if (isEq5 || isEq6 || isEq7 || isEq8) {
-                    isRect = true;
-                    break;
+                    if (length1 < length2 * 3 && length2 < length1 * 3) {
+                      isRect = true;
+                      break;
+                    }
                   }
                 }
               }
@@ -5872,7 +5866,7 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
   }
   for (let i = 0; i < lines.length; i++) {
     let length1 = lines[i].length;
-    if (isFindColIndexs.has(lines[i].uuid) || length1 < minColLineLength || length1 > maxColLineLength)
+    if (isFindColIndexs.has(lines[i].uuid) || length1 < threeMinColLineLength || length1 > maxColLineLength)
       continue;
     let colIndexs = {
       uuids: [],
@@ -5911,7 +5905,7 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
     let vec2 = vec1.clone().negate();
     for (let j = 0; j < lines.length; j++) {
       let length2 = lines[j].length;
-      if (j == i || isFindColIndexs.has(j) || length2 < minColLineLength || length2 > maxColLineLength)
+      if (j == i || isFindColIndexs.has(j) || length2 < threeMinColLineLength || length2 > maxColLineLength)
         continue;
       let startPt2 = new THREE6.Vector3(lines[j].start.x, lines[j].start.y, lines[j].start.z);
       let endPt2 = new THREE6.Vector3(lines[j].end.x, lines[j].end.y, lines[j].end.z);
@@ -5932,7 +5926,7 @@ var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster =
       }
       for (let k = 0; k < lines.length; k++) {
         let length3 = lines[k].length;
-        if (k == i || k == j || isFindColIndexs.has(k) || length3 < minColLineLength || length3 > maxColLineLength)
+        if (k == i || k == j || isFindColIndexs.has(k) || length3 < threeMinColLineLength || length3 > maxColLineLength)
           continue;
         let startPt3 = new THREE6.Vector3(lines[k].start.x, lines[k].start.y, lines[k].start.z);
         let endPt3 = new THREE6.Vector3(lines[k].end.x, lines[k].end.y, lines[k].end.z);
@@ -8081,8 +8075,8 @@ function calculateRhumbDistance(origin, destination, radius) {
   const delta = Math.sqrt(
     DeltaPhi * DeltaPhi + q * q * DeltaLambda * DeltaLambda
   );
-  const dist3 = delta * R;
-  return dist3;
+  const dist2 = delta * R;
+  return dist2;
 }
 
 // node_modules/@turf/rhumb-destination/dist/esm/index.js
@@ -10113,7 +10107,7 @@ var getStaircase = (allProjectionResults, scene) => {
         let isP = perpendicularInfo(ptBottom3i, ptBottom1i, ptBottom3j, ptBottom1j);
         if (isP && isP.angle > 75) {
           let dist1 = ptBottom1j.distanceTo(ptTop1i);
-          let dist22 = ptBottom1j.distanceTo(ptTop2i);
+          let dist2 = ptBottom1j.distanceTo(ptTop2i);
           let dist3 = ptBottom2j.distanceTo(ptTop1i);
           let dist4 = ptBottom2j.distanceTo(ptTop2i);
           let retcBotton1j = ptTop1i.clone();
@@ -10125,8 +10119,8 @@ var getStaircase = (allProjectionResults, scene) => {
           let newTop1j = retcBotton1j.clone().addScaledVector(vecMove, stairDatas[j].stairLength);
           let newTop2j = rectBotton2j.clone().addScaledVector(vecMove, stairDatas[j].stairLength);
           let nearDist = dist1;
-          if (nearDist > dist22 || nearDist > dist4) {
-            nearDist = dist22;
+          if (nearDist > dist2 || nearDist > dist4) {
+            nearDist = dist2;
             retcBotton1j = ptTop2i.clone();
             rectBotton2j = retcBotton1j.clone().addScaledVector(vecStepWidthi, stairDatas[j].staitWidth);
             vecMove = new THREE8.Vector3().subVectors(ptTop1i, ptTop2i).normalize();
@@ -10354,12 +10348,12 @@ function getStaircaseFloor(stairDatas, finalFloorMap) {
           for (let f = 0; f < floorPoints.length; f++) {
             let tmpFloorPoint = new THREE8.Vector3(floorPoints[f].x, floorPoints[f].y, ptTmpTmpBottom1i.z);
             let ptTmpClose = tmpTmpLine.closestPointToPoint(tmpFloorPoint, false, new THREE8.Vector3());
-            let dist3 = ptTmpClose.distanceTo(tmpFloorPoint);
+            let dist2 = ptTmpClose.distanceTo(tmpFloorPoint);
             let ptTmpClose2 = tmpTmpLine2.closestPointToPoint(tmpFloorPoint, false, new THREE8.Vector3());
             let tmpVec = new THREE8.Vector3().subVectors(tmpFloorPoint, ptTmpClose2).normalize();
             const isP = isParallel(tmpVec, stairDatas[i].vecStepWidth.clone().negate(), 0.1);
-            if (dist3 < maxDist && isP.sameDirection) {
-              maxDist = dist3;
+            if (dist2 < maxDist && isP.sameDirection) {
+              maxDist = dist2;
               moveDist = tmpFloorPoint.distanceTo(ptTmpClose2);
               nearPt = tmpFloorPoint.clone();
               nearPtZ = floorPoints[f].z;
@@ -10383,10 +10377,10 @@ function getStaircaseFloor(stairDatas, finalFloorMap) {
             let ptTmpClose = tmpTmpLine.closestPointToPoint(tmpFloorPoint, false, new THREE8.Vector3());
             let ptTmpClose2 = tmpTmpLine2.closestPointToPoint(tmpFloorPoint, false, new THREE8.Vector3());
             let tmpVec = new THREE8.Vector3().subVectors(tmpFloorPoint, ptTmpClose2).normalize();
-            let dist3 = ptTmpClose.distanceTo(tmpFloorPoint);
+            let dist2 = ptTmpClose.distanceTo(tmpFloorPoint);
             const isP = isParallel(tmpVec, stairDatas[i].vecStepWidth);
-            if (dist3 < maxDist && isP.sameDirection) {
-              maxDist = dist3;
+            if (dist2 < maxDist && isP.sameDirection) {
+              maxDist = dist2;
               moveDist = tmpFloorPoint.distanceTo(ptTmpClose2);
               nearPt = tmpFloorPoint;
               nearPtZ = floorPoints[f].z;
@@ -11150,6 +11144,8 @@ var getFlatFloorData = (lines, runDataList, pointCloudCluster = null) => {
       avaregPzs.push(1e4);
     }
   }
+  if (maxContourIndex == -1)
+    return null;
   return {
     contour: floorDatas[maxContourIndex].contour,
     averagePz: avaregPzs[maxContourIndex]
@@ -11658,14 +11654,14 @@ var getWindowData = (lines, pcdData, lineReader) => {
                         let line3 = new THREE10.Line3(new THREE10.Vector3(line2.start.x, line2.start.y, 0), new THREE10.Vector3(line2.end.x, line2.end.y, 0));
                         let targeVec = new THREE10.Vector3();
                         let ptClose = line3.closestPointToPoint(ptCenter, true, targeVec);
-                        let dist3 = ptCenter.distanceTo(ptClose);
-                        if (dist3 < 0.15) {
+                        let dist2 = ptCenter.distanceTo(ptClose);
+                        if (dist2 < 0.15) {
                           let dist1 = beamSt.distanceTo(doorSt);
                           let dist22 = beamEd.distanceTo(doorSt);
                           if (dist1 > 0.25 && dist22 > 0.25) {
-                            let dist32 = beamSt.distanceTo(doorEd);
+                            let dist3 = beamSt.distanceTo(doorEd);
                             let dist4 = beamEd.distanceTo(doorEd);
-                            if (dist32 > 0.2 && dist4 > 0.2) {
+                            if (dist3 > 0.2 && dist4 > 0.2) {
                               continue;
                             }
                           }
@@ -12147,8 +12143,8 @@ function pointToSegmentDist(cx, cy, ax, ay, bx, by) {
   const t = (wx * vx + wy * vy) / len2;
   const projX = ax + t * vx;
   const projY = ay + t * vy;
-  const dist3 = Math.sqrt((cx - projX) ** 2 + (cy - projY) ** 2);
-  return { dist: dist3, t };
+  const dist2 = Math.sqrt((cx - projX) ** 2 + (cy - projY) ** 2);
+  return { dist: dist2, t };
 }
 function pointInQuad(px, py, quad) {
   let sign = 0;
@@ -12293,8 +12289,8 @@ function scoreDistanceVariance(wall, checkPoints) {
   const ds = [];
   const { start, end } = wall;
   for (const pt of checkPoints) {
-    const { dist: dist3 } = pointToSegmentDist(pt.x, pt.y, start.x, start.y, end.x, end.y);
-    ds.push(dist3);
+    const { dist: dist2 } = pointToSegmentDist(pt.x, pt.y, start.x, start.y, end.x, end.y);
+    ds.push(dist2);
   }
   const mean = ds.reduce((s, v2) => s + v2, 0) / ds.length;
   const variance = ds.reduce((s, v2) => s + (v2 - mean) ** 2, 0) / ds.length;
@@ -12407,8 +12403,8 @@ function mergeIntervals(group, gref, dirX, dirY, gapTol) {
     const last = merged[merged.length - 1];
     if (l <= last.r + gapTol) {
       const overlapLen = Math.min(last.r, r) - Math.max(last.l, l);
-      const dist3 = Math.hypot(last.endPt.x - startPt.x, last.endPt.y - startPt.y);
-      if (overlapLen >= overlapForceMergeLen || dist3 <= endPointDistTol) {
+      const dist2 = Math.hypot(last.endPt.x - startPt.x, last.endPt.y - startPt.y);
+      if (overlapLen >= overlapForceMergeLen || dist2 <= endPointDistTol) {
         if (l < last.l) {
           last.l = l;
           last.startPt = startPt;
@@ -12624,10 +12620,10 @@ function collectCandidates(candidateSegments, winLong, winDirX, winDirY, checkPo
       let validPoint = false;
       let minDist = Infinity;
       for (const pt of checkPoints) {
-        const { dist: dist3, t } = pointToSegmentDist(pt.x, pt.y, start.x, start.y, end.x, end.y);
-        if (t >= -attempt.margin && t <= 1 + attempt.margin && dist3 <= attempt.maxDist) {
+        const { dist: dist2, t } = pointToSegmentDist(pt.x, pt.y, start.x, start.y, end.x, end.y);
+        if (t >= -attempt.margin && t <= 1 + attempt.margin && dist2 <= attempt.maxDist) {
           validPoint = true;
-          minDist = Math.min(minDist, dist3);
+          minDist = Math.min(minDist, dist2);
         }
       }
       if (!validPoint) {
@@ -13264,8 +13260,8 @@ function pointToSegmentDist2(cx, cy, ax, ay, bx, by) {
   const t = (wx * vx + wy * vy) / len2;
   const projX = ax + t * vx;
   const projY = ay + t * vy;
-  const dist3 = Math.sqrt((cx - projX) ** 2 + (cy - projY) ** 2);
-  return { dist: dist3, t };
+  const dist2 = Math.sqrt((cx - projX) ** 2 + (cy - projY) ** 2);
+  return { dist: dist2, t };
 }
 function pointInQuad2(px, py, quad) {
   let sign = 0;
@@ -13333,9 +13329,9 @@ function extractVerticalEdges(corners) {
       if (usedTop.has(i)) continue;
       const dx = topPts[i].x - bp.x;
       const dy = topPts[i].y - bp.y;
-      const dist3 = Math.sqrt(dx * dx + dy * dy);
-      if (dist3 < bestDist) {
-        bestDist = dist3;
+      const dist2 = Math.sqrt(dx * dx + dy * dy);
+      if (dist2 < bestDist) {
+        bestDist = dist2;
         bestIdx = i;
       }
     }
@@ -13723,8 +13719,8 @@ function scoreDistanceVariance2(wall, checkPoints) {
   const ds = [];
   const { start, end } = wall;
   for (const pt of checkPoints) {
-    const { dist: dist3 } = pointToSegmentDist2(pt.x, pt.y, start.x, start.y, end.x, end.y);
-    ds.push(dist3);
+    const { dist: dist2 } = pointToSegmentDist2(pt.x, pt.y, start.x, start.y, end.x, end.y);
+    ds.push(dist2);
   }
   const mean = ds.reduce((s, v2) => s + v2, 0) / ds.length;
   const variance = ds.reduce((s, v2) => s + (v2 - mean) ** 2, 0) / ds.length;
@@ -13837,8 +13833,8 @@ function mergeIntervals2(group, gref, dirX, dirY, gapTol) {
     const last = merged[merged.length - 1];
     if (l <= last.r + gapTol) {
       const overlapLen = Math.min(last.r, r) - Math.max(last.l, l);
-      const dist3 = Math.hypot(last.endPt.x - startPt.x, last.endPt.y - startPt.y);
-      if (overlapLen >= overlapForceMergeLen || dist3 <= endPointDistTol) {
+      const dist2 = Math.hypot(last.endPt.x - startPt.x, last.endPt.y - startPt.y);
+      if (overlapLen >= overlapForceMergeLen || dist2 <= endPointDistTol) {
         if (l < last.l) {
           last.l = l;
           last.startPt = startPt;
@@ -14064,10 +14060,10 @@ function collectCandidates2(candidateSegments, doorLong, doorDirX, doorDirY, che
       let validPoint = false;
       let minDist = Infinity;
       for (const pt of checkPoints) {
-        const { dist: dist3, t } = pointToSegmentDist2(pt.x, pt.y, start.x, start.y, end.x, end.y);
-        if (t >= -attempt.margin && t <= 1 + attempt.margin && dist3 <= attempt.maxDist) {
+        const { dist: dist2, t } = pointToSegmentDist2(pt.x, pt.y, start.x, start.y, end.x, end.y);
+        if (t >= -attempt.margin && t <= 1 + attempt.margin && dist2 <= attempt.maxDist) {
           validPoint = true;
-          if (dist3 < minDist) minDist = dist3;
+          if (dist2 < minDist) minDist = dist2;
         }
       }
       if (!validPoint) {
@@ -14409,8 +14405,8 @@ function findDoorWalls(doorObjs, wallSegments, options, preMerged) {
       for (const seg of candidateSegments) {
         const dx = seg.start.x + (seg.end.x - seg.start.x) / 2 - centerX;
         const dy = seg.start.y + (seg.end.y - seg.start.y) / 2 - centerY;
-        const dist3 = Math.sqrt(dx * dx + dy * dy);
-        if (dist3 > 2) continue;
+        const dist2 = Math.sqrt(dx * dx + dy * dy);
+        if (dist2 > 2) continue;
         const segDx = seg.end.x - seg.start.x;
         const segDy = seg.end.y - seg.start.y;
         const segLen = Math.sqrt(segDx * segDx + segDy * segDy);
@@ -16024,8 +16020,8 @@ function fitCircle(pts) {
   const r = Math.sqrt(Math.abs((sx2 + sz2 - 2 * cx * sx - 2 * cz * sz) / n + cx * cx + cz * cz));
   let sumSq = 0;
   for (const p of pts) {
-    const dist3 = Math.hypot(p.x - cx, p.z - cz);
-    const diff = dist3 - r;
+    const dist2 = Math.hypot(p.x - cx, p.z - cz);
+    const diff = dist2 - r;
     sumSq += diff * diff;
   }
   const rmsResidual = Math.sqrt(sumSq / n);
@@ -16456,8 +16452,8 @@ function findWallCorners(lineSegs) {
       for (const e1 of endpoints1) {
         for (const e2 of endpoints2) {
           const dx = e1.x - e2.x, dz = e1.z - e2.z;
-          const dist3 = Math.sqrt(dx * dx + dz * dz);
-          if (dist3 < CORNER_DIST) {
+          const dist2 = Math.sqrt(dx * dx + dz * dz);
+          if (dist2 < CORNER_DIST) {
             corners.push({ x: (e1.x + e2.x) / 2, z: (e1.z + e2.z) / 2 });
           }
         }
@@ -16985,9 +16981,9 @@ function processFromPointCloud(points3D, rawLines, pcConfig) {
         let bestDist = Infinity, bestJ = -1;
         for (let k = 0; k < pts.length; k++) {
           const dx = pts[k].x - corner.x, dz = pts[k].z - corner.z;
-          const dist3 = dx * dx + dz * dz;
-          if (dist3 < bestDist) {
-            bestDist = dist3;
+          const dist2 = dx * dx + dz * dz;
+          if (dist2 < bestDist) {
+            bestDist = dist2;
             bestJ = k;
           }
         }

package/package.json

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