rm-graphical-computing-node 1.0.37 → 1.0.39

package/dist/index.mjs

@@ -3150,12 +3150,8 @@ var removeNoisePoints = (lines, lineReader, lineEditor) => {
       continue;
     let gridWidth = -1;
     let gridHeight = -1;
-    let tempLineI = lineReader.readLineById(line2.id);
-    tempLineI.checkResults = lineReader.getLineCheckReultsById(line2.id);
-    tempLineI.originalPoints = lineReader.getOriginalPointsById(line2.id);
-    line2.originalPoints = tempLineI.originalPoints;
-    line2.checkResults = tempLineI.checkResults;
-    tempLineI = null;
+    line2.originalPoints = lineReader.getOriginalPointsById(line2.id);
+    line2.checkResults = lineReader.getLineCheckReultsById(line2.id);
     if (!line2.checkResults || line2.checkResults.length <= 0)
       continue;
     for (let a = 0; a < line2.checkResults.length; a++) {
@@ -3728,16 +3724,14 @@ function getTrendLineEndpoints(points, options = {}) {
 
 // src/geometry/beamLine.mjs
 import { Line as Line2 } from "three";
-var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, regionId = "") => {
+var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, onProgress = null) => {
   removeNoisePoints(lines, lineReader, lineEditor);
   if (lines.length <= 0 || runDataList.length <= 0)
     return lines;
   if (!pcdData) pcdData = [];
   for (let line2 of lines) {
     let allRegion = [];
-    let tempLineI = lineReader.readLineById(line2.id);
-    tempLineI.checkResults = lineReader.getLineCheckReultsById(line2.id);
-    line2.checkResults = tempLineI.checkResults;
+    line2.checkResults = lineReader.getLineCheckReultsById(line2.id);
     if (!line2.checkResults || line2.checkResults.length <= 0)
       continue;
     for (let r = 0; r < line2.checkResults.length; r++) {
@@ -3922,14 +3916,12 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
   const beamGroup = [];
   let nearDist = 0.15;
   for (let index = 0; index < lines.length; index++) {
+    if (onProgress != null)
+      onProgress((index + 1) / lines.length * 60);
     let line2 = lines[index];
     if (line2.noDetection) continue;
-    let tempLineIndex = lineReader.readLineById(line2.id);
-    tempLineIndex.originalPoints = lineReader.getOriginalPointsById(line2.id);
-    tempLineIndex.checkResults = lineReader.getLineCheckReultsById(line2.id);
-    line2.originalPoints = tempLineIndex.originalPoints;
-    line2.checkResults = tempLineIndex.checkResults;
-    tempLineIndex = null;
+    line2.originalPoints = lineReader.getOriginalPointsById(line2.id);
+    line2.checkResults = lineReader.getLineCheckReultsById(line2.id);
     line2.doorAndBeamData = [];
     line2.doorAndBeamIdToCheckResults = [];
     if (!line2.mergeCheckRegion || line2.mergeCheckRegion.length == 0)
@@ -4117,7 +4109,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                     const ptInsertTmp = segmentsIntersect2D(tmpLineStart, tmpLineEnd, tmpOtherLineStart, tmpOtherLineEnd, 0.1);
                     let isPerpendicularInfo = perpendicularInfo(tmpLineStart, tmpLineEnd, tmpOtherLineStart, tmpOtherLineEnd);
                     if (ptInsertTmp != null) {
-                      if (isPerpendicularInfo && isPerpendicularInfo.angle > 85) {
+                      if (isPerpendicularInfo && isPerpendicularInfo.angle > 79) {
                         let dist00 = ptInsertTmp.point.distanceTo(tmpLineStart);
                         let dist01 = ptInsertTmp.point.distanceTo(tmpLineEnd);
                         if (dist00 < 0.3) {
@@ -4129,7 +4121,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                       }
                       continue;
                     }
-                    if (isPerpendicularInfo && isPerpendicularInfo.angle > 85) {
+                    if (isPerpendicularInfo && isPerpendicularInfo.angle > 79) {
                       let tmpLine3 = new THREE5.Line3(tmpOtherLineStart, tmpOtherLineEnd);
                       const ptClose = tmpLine3.closestPointToPoint(tmpLineStart, true, ptTarget);
                       let isParallelism = getParallelism(tmpLineStart, tmpLineEnd, ptClose, tmpLineStart);
@@ -4155,10 +4147,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                       let tmpDist8 = getZZeroPointToPointDistance(tmpDoorEnd, tmpOtherLineEnd);
                       let isPPPP = getParallelism(tmpLineStart, tmpLineEnd, tmpOtherLineStart, tmpDoorStart);
                       let nearCheckResult = false;
-                      let tempLineF = lineReader.readLineById(lines[f].id);
-                      tempLineF.checkResults = lineReader.getLineCheckReultsById(lines[f].id);
-                      lines[f].checkResults = tempLineF.checkResults;
-                      tempLineF = null;
+                      lines[f].checkResults = lineReader.getLineCheckReultsById(lines[f].id);
                       if (lines[f].checkResults) {
                         for (let a = 0; a < lines[f].checkResults.length; a++) {
                           let ptsTmpp = [];
@@ -4227,7 +4216,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                     const ptInsertTmp = segmentsIntersect2D(tmpLineStart, tmpLineEnd, tmpOtherLineStart, tmpOtherLineEnd, 0.03);
                     let isPerpendicularInfo = perpendicularInfo(tmpLineStart, tmpLineEnd, tmpOtherLineStart, tmpOtherLineEnd);
                     if (ptInsertTmp != null) {
-                      if (isPerpendicularInfo && isPerpendicularInfo.angle > 85) {
+                      if (isPerpendicularInfo && isPerpendicularInfo.angle > 79) {
                         let dist00 = ptInsertTmp.point.distanceTo(tmpLineStart);
                         let dist01 = ptInsertTmp.point.distanceTo(tmpLineEnd);
                         if (dist01 < 0.3) {
@@ -4239,7 +4228,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                       }
                       continue;
                     }
-                    if (isPerpendicularInfo && isPerpendicularInfo.angle > 85) {
+                    if (isPerpendicularInfo && isPerpendicularInfo.angle > 79) {
                       let tmpLine3 = new THREE5.Line3(tmpOtherLineStart, tmpOtherLineEnd);
                       const ptClose = tmpLine3.closestPointToPoint(tmpLineEnd, true, ptTarget);
                       let isParallelism = getParallelism(tmpLineEnd, tmpLineStart, ptClose, tmpLineEnd);
@@ -4265,10 +4254,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                       let tmpDist8 = getZZeroPointToPointDistance(tmpDoorEnd, tmpOtherLineEnd);
                       let isPPPP = getParallelism(tmpLineEnd, tmpLineStart, tmpOtherLineStart, tmpDoorStart);
                       let nearCheckResult = false;
-                      let tempLineF = lineReader.readLineById(lines[f].id);
-                      tempLineF.checkResults = lineReader.getLineCheckReultsById(lines[f].id);
-                      lines[f].checkResults = tempLineF.checkResults;
-                      tempLineF = null;
+                      lines[f].checkResults = lineReader.getLineCheckReultsById(lines[f].id);
                       if (lines[f].checkResults) {
                         for (let a = 0; a < lines[f].checkResults.length; a++) {
                           let ptsTmpp = [];
@@ -4662,10 +4648,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                     }
                   }
                   const allTmpPoints = [];
-                  let tempLineX = lineReader.readLineById(lines[x].id);
-                  tempLineX.originalPoints = lineReader.getOriginalPointsById(lines[x].id);
-                  lines[x].originalPoints = tempLineX.originalPoints;
-                  tempLineX = null;
+                  lines[x].originalPoints = lineReader.getOriginalPointsById(lines[x].id);
                   lines[x].originalPoints.forEach((item) => {
                     if (item.z > doorTmpSt.z + 0.2 && item.z < doorTmpSt.z + height / 2)
                       allTmpPoints.push(new THREE5.Vector3(item.x, item.y, doorTmpSt.z));
@@ -4829,10 +4812,7 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
                   let lineIsOnlyBeam1 = false;
                   let lineIsOnlyBeam2 = false;
                   if (doorAndBeamDataObj.type == "beam" && tmpDoorBeamData.type == "beam") {
-                    let tempLineT = lineReader.readLineById(lines[doorBeamDataIndex[w2].linesIndex].id);
-                    tempLineT.originalPoints = lineReader.getOriginalPointsById(lines[doorBeamDataIndex[w2].linesIndex].id);
-                    lines[doorBeamDataIndex[w2].linesIndex].originalPoints = tempLineT.originalPoints;
-                    tempLineT = null;
+                    lines[doorBeamDataIndex[w2].linesIndex].originalPoints = lineReader.getOriginalPointsById(lines[doorBeamDataIndex[w2].linesIndex].id);
                     let Z1 = getPointsMinAndMax(lines[doorBeamDataIndex[w2].linesIndex].originalPoints);
                     let Z2 = getPointsMinAndMax(line2.originalPoints);
                     lines[doorBeamDataIndex[w2].linesIndex].originalPoints = null;
@@ -4964,6 +4944,8 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
   }
   if (findDoorIndexs.length > 1) {
     for (let j = 0; j < findDoorIndexs.length; j++) {
+      if (onProgress != null)
+        onProgress(60 + (j + 1) / findDoorIndexs.length * 5);
       let savedata2 = [];
       for (let d = 0; d < lines[findDoorIndexs[j]].doorAndBeamData.length; d++) {
         let isDel = false;
@@ -5020,142 +5002,149 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, re
   let maxDoorLength = 2;
   let isFindWallIndex = [];
   let allDoorLines = [];
-  for (let n = 0; n < doorDatas.length; n++) {
-    if (doorDatas[n].isFind || doorDatas[n].inWall)
-      continue;
-    let doorSt = new THREE5.Vector3(doorDatas[n].doorStartPt.x, doorDatas[n].doorStartPt.y, 0);
-    let doorEd = new THREE5.Vector3(doorDatas[n].doorEndPt.x, doorDatas[n].doorEndPt.y, 0);
-    let vec1 = new THREE5.Vector3().subVectors(doorSt, doorEd).normalize();
-    for (let j = 0; j < lines.length; j++) {
-      if (lines[j].length < 0.7 || lines[j].completePointAreaPercentage > 60)
+  if (doorDatas.length > 0) {
+    for (let n = 0; n < doorDatas.length; n++) {
+      if (onProgress != null)
+        onProgress(65 + (n + 1) / doorDatas.length * 35);
+      if (doorDatas[n].isFind || doorDatas[n].inWall)
         continue;
-      let beamSt = new THREE5.Vector3(lines[j].start.x, lines[j].start.y, 0);
-      let beamEd = new THREE5.Vector3(lines[j].end.x, lines[j].end.y, 0);
-      let vec2 = new THREE5.Vector3().subVectors(beamSt, beamEd).normalize();
-      let nExtend = 0.3;
-      let doorStExtended = doorSt.clone().addScaledVector(vec1, nExtend);
-      let doorEdExtended = doorEd.clone().addScaledVector(vec1.clone().negate(), nExtend);
-      let beamStExtended = beamSt.clone().addScaledVector(vec2, nExtend);
-      let beamEdExtended = beamEd.clone().addScaledVector(vec2.clone().negate(), nExtend);
-      let insertPt = segmentsIntersect2D(doorStExtended, doorEdExtended, beamStExtended, beamEdExtended);
-      let isDoorParBeam = getParallelism(
-        doorStExtended,
-        doorEdExtended,
-        beamStExtended,
-        beamEdExtended
-      );
-      let ptNear = doorSt.distanceTo(beamSt) > doorEd.distanceTo(beamSt) ? doorEd : doorSt;
-      let dist11 = ptNear.distanceTo(beamSt);
-      let dist22 = ptNear.distanceTo(beamEd);
-      let isNear = dist11 < nearDist || dist22 < nearDist;
-      if (isNear && isDoorParBeam && !isDoorParBeam.isParallel) {
-        let nearDoorDist1 = doorSt.distanceTo(beamSt);
-        let nearDoorDist2 = doorSt.distanceTo(beamEd);
-        let nearDoorPt = nearDoorDist1 < nearDoorDist2 ? beamSt : beamEd;
-        let findLine = false;
-        for (let k = 0; k < lines.length; k++) {
-          if (k == j || isFindWallIndex.includes(k) || lines[k].length < 0.7)
-            continue;
-          let beamStOther = new THREE5.Vector3(lines[k].start.x, lines[k].start.y, 0);
-          let beamEdOther = new THREE5.Vector3(lines[k].end.x, lines[k].end.y, 0);
-          let vec32 = new THREE5.Vector3().subVectors(beamStOther, beamEdOther).normalize();
-          let vec4 = vec32.clone().negate();
-          let newBeamStOther = beamStOther.clone().addScaledVector(vec32, 5);
-          let newBeamEdOther = beamEdOther.clone().addScaledVector(vec4, 5);
-          let isP = perpendicularInfo(beamSt, beamEd, beamStOther, beamEdOther);
-          let isPP = classifySegments(beamSt, beamEd, beamStOther, beamEdOther);
-          let isTmpInsert = segmentsIntersect2D(beamSt, beamEd, newBeamStOther, newBeamEdOther);
-          let isInside = true;
-          if (isTmpInsert != null) {
-            isInside = isTmpInsert.point.distanceTo(beamSt) < nearDist || isTmpInsert.point.distanceTo(beamEd) < nearDist;
-          }
-          if ((isP && isP.angle > 85 || isPP && isPP.type == "collinear_gap") && isInside) {
-            let line3 = new THREE5.Line3(beamSt, beamEd);
-            let target = new THREE5.Vector3();
-            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 doorStartPt, doorEndPt;
-            if (dist1 > dist23 && dist23 > minDoorLength) {
-              doorStartPt = beamEdOther;
-              doorEndPt = ptClose2;
-            } else if (dist1 < dist23 && dist1 > minDoorLength) {
-              doorStartPt = beamStOther;
-              doorEndPt = ptClose1;
-            } else
-              continue;
-            dist1 = nearDoorPt.distanceTo(beamStOther);
-            dist23 = nearDoorPt.distanceTo(beamEdOther);
-            if (dist1 > maxDoorLength && dist23 > maxDoorLength)
-              continue;
-            let isPP2 = getParallelism(doorStartPt, doorEndPt, beamStOther, beamEdOther);
-            let isPPP = getParallelism(doorStartPt, doorEndPt, doorStExtended, doorEdExtended);
-            if (isPPP && isPPP.isParallel)
-              continue;
-            if (!isPP2 || !isPP2.isParallel)
-              continue;
-            let resOverlap = classifySegments(doorSt, doorEd, doorStartPt, doorEndPt);
-            if (resOverlap && resOverlap.type == "collinear_overlap" && resOverlap.maxPerpendicularDistance < 0.2)
+      let doorSt = new THREE5.Vector3(doorDatas[n].doorStartPt.x, doorDatas[n].doorStartPt.y, 0);
+      let doorEd = new THREE5.Vector3(doorDatas[n].doorEndPt.x, doorDatas[n].doorEndPt.y, 0);
+      let vec1 = new THREE5.Vector3().subVectors(doorSt, doorEd).normalize();
+      for (let j = 0; j < lines.length; j++) {
+        if (lines[j].length < 0.7 || lines[j].completePointAreaPercentage > 60)
+          continue;
+        let beamSt = new THREE5.Vector3(lines[j].start.x, lines[j].start.y, 0);
+        let beamEd = new THREE5.Vector3(lines[j].end.x, lines[j].end.y, 0);
+        let vec2 = new THREE5.Vector3().subVectors(beamSt, beamEd).normalize();
+        let nExtend = 0.3;
+        let doorStExtended = doorSt.clone().addScaledVector(vec1, nExtend);
+        let doorEdExtended = doorEd.clone().addScaledVector(vec1.clone().negate(), nExtend);
+        let beamStExtended = beamSt.clone().addScaledVector(vec2, nExtend);
+        let beamEdExtended = beamEd.clone().addScaledVector(vec2.clone().negate(), nExtend);
+        let insertPt = segmentsIntersect2D(doorStExtended, doorEdExtended, beamStExtended, beamEdExtended);
+        let isDoorParBeam = getParallelism(
+          doorStExtended,
+          doorEdExtended,
+          beamStExtended,
+          beamEdExtended
+        );
+        let ptNear = doorSt.distanceTo(beamSt) > doorEd.distanceTo(beamSt) ? doorEd : doorSt;
+        let dist11 = ptNear.distanceTo(beamSt);
+        let dist22 = ptNear.distanceTo(beamEd);
+        let isNear = dist11 < nearDist || dist22 < nearDist;
+        if (isNear && isDoorParBeam && !isDoorParBeam.isParallel) {
+          let nearDoorDist1 = doorSt.distanceTo(beamSt);
+          let nearDoorDist2 = doorSt.distanceTo(beamEd);
+          let nearDoorPt = nearDoorDist1 < nearDoorDist2 ? beamSt : beamEd;
+          let findLine = false;
+          for (let k = 0; k < lines.length; k++) {
+            if (k == j || isFindWallIndex.includes(k) || lines[k].length < 0.7)
               continue;
-            doorStartPt.z = doorEndPt.z = lines[k].start.z;
-            let isOverlap = false;
-            for (let m = 0; m < allDoorLines.length; m++) {
-              let result = classifySegments(allDoorLines[m].start, allDoorLines[m].end, doorStartPt, doorEndPt);
-              if (result && result.type == "collinear_overlap" && result.maxPerpendicularDistance < 0.2) {
-                isOverlap = true;
-                break;
-              }
+            let beamStOther = new THREE5.Vector3(lines[k].start.x, lines[k].start.y, 0);
+            let beamEdOther = new THREE5.Vector3(lines[k].end.x, lines[k].end.y, 0);
+            let vec32 = new THREE5.Vector3().subVectors(beamStOther, beamEdOther).normalize();
+            let vec4 = vec32.clone().negate();
+            let newBeamStOther = beamStOther.clone().addScaledVector(vec32, 5);
+            let newBeamEdOther = beamEdOther.clone().addScaledVector(vec4, 5);
+            let isP = perpendicularInfo(beamSt, beamEd, beamStOther, beamEdOther);
+            let isPP = classifySegments(beamSt, beamEd, beamStOther, beamEdOther);
+            let isTmpInsert = segmentsIntersect2D(beamSt, beamEd, newBeamStOther, newBeamEdOther);
+            let isInside = true;
+            if (isTmpInsert != null) {
+              isInside = isTmpInsert.point.distanceTo(beamSt) < nearDist || isTmpInsert.point.distanceTo(beamEd) < nearDist;
             }
-            if (isOverlap)
-              continue;
-            for (let x = 0; x < lines.length; x++) {
-              if (lines[x].length < 0.5) continue;
-              let startPt2 = new THREE5.Vector3(lines[x].start.x, lines[x].start.y, lines[x].start.z);
-              let endPt2 = new THREE5.Vector3(lines[x].end.x, lines[x].end.y, lines[x].end.z);
-              let result = classifySegments(startPt2, endPt2, doorStartPt, doorEndPt);
-              if (result && result.type == "collinear_overlap" && result.maxPerpendicularDistance < 0.1) {
-                isOverlap = true;
-                break;
+            if ((isP && isP.angle > 85 || isPP && isPP.type == "collinear_gap") && isInside) {
+              let line3 = new THREE5.Line3(beamSt, beamEd);
+              let target = new THREE5.Vector3();
+              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 doorStartPt, doorEndPt;
+              if (dist1 > dist23 && dist23 > minDoorLength) {
+                doorStartPt = beamEdOther;
+                doorEndPt = ptClose2;
+              } else if (dist1 < dist23 && dist1 > minDoorLength) {
+                doorStartPt = beamStOther;
+                doorEndPt = ptClose1;
+              } else
+                continue;
+              dist1 = nearDoorPt.distanceTo(beamStOther);
+              dist23 = nearDoorPt.distanceTo(beamEdOther);
+              if (dist1 > maxDoorLength && dist23 > maxDoorLength)
+                continue;
+              let isPP2 = getParallelism(doorStartPt, doorEndPt, beamStOther, beamEdOther);
+              let isPPP = getParallelism(doorStartPt, doorEndPt, doorStExtended, doorEdExtended);
+              if (isPPP && isPPP.isParallel)
+                continue;
+              if (!isPP2 || !isPP2.isParallel)
+                continue;
+              let resOverlap = classifySegments(doorSt, doorEd, doorStartPt, doorEndPt);
+              if (resOverlap && resOverlap.type == "collinear_overlap" && resOverlap.maxPerpendicularDistance < 0.2)
+                continue;
+              doorStartPt.z = doorEndPt.z = lines[k].start.z;
+              let isOverlap = false;
+              for (let m = 0; m < allDoorLines.length; m++) {
+                let result = classifySegments(allDoorLines[m].start, allDoorLines[m].end, doorStartPt, doorEndPt);
+                if (result && result.type == "collinear_overlap" && result.maxPerpendicularDistance < 0.2) {
+                  isOverlap = true;
+                  break;
+                }
               }
+              if (isOverlap)
+                continue;
+              for (let x = 0; x < lines.length; x++) {
+                if (lines[x].length < 0.5) continue;
+                let startPt2 = new THREE5.Vector3(lines[x].start.x, lines[x].start.y, lines[x].start.z);
+                let endPt2 = new THREE5.Vector3(lines[x].end.x, lines[x].end.y, lines[x].end.z);
+                let result = classifySegments(startPt2, endPt2, doorStartPt, doorEndPt);
+                if (result && result.type == "collinear_overlap" && result.maxPerpendicularDistance < 0.1) {
+                  isOverlap = true;
+                  break;
+                }
+              }
+              if (isOverlap)
+                continue;
+              allDoorLines.push({
+                start: doorStartPt,
+                end: doorEndPt
+              });
+              isFindWallIndex.push(k);
+              let height1 = lines[k].rooftopPz - lines[k].start.z;
+              let height2 = lines[j].rooftopPz - lines[j].start.z;
+              let doorHeight = height1 < height2 ? height1 : height2;
+              if (!lines[k].doorAndBeamData)
+                lines[k].doorAndBeamData = [];
+              lines[k].doorAndBeamData.push({
+                id,
+                beamStart: doorStartPt,
+                beamEnd: doorEndPt,
+                beamHeight: doorHeight,
+                doorStart: doorStartPt,
+                doorEnd: doorEndPt,
+                doorHeight,
+                nearId: -1,
+                type: "onlyDoor",
+                isDoor: true,
+                beamNearWallVec: new THREE5.Vector3(0, 0, 0),
+                groundClearance: 0
+              });
+              pcdData[doorDatas[n].index].isFindBeam = true;
+              pcdData[doorDatas[n].index].isFindOnlyDoor = true;
+              beamGroup.push([{ id, beamStart: doorStartPt, beamEnd: doorEndPt }]);
+              id++;
+              findLine = true;
+              break;
             }
-            if (isOverlap)
-              continue;
-            allDoorLines.push({
-              start: doorStartPt,
-              end: doorEndPt
-            });
-            isFindWallIndex.push(k);
-            let height1 = lines[k].rooftopPz - lines[k].start.z;
-            let height2 = lines[j].rooftopPz - lines[j].start.z;
-            let doorHeight = height1 < height2 ? height1 : height2;
-            if (!lines[k].doorAndBeamData)
-              lines[k].doorAndBeamData = [];
-            lines[k].doorAndBeamData.push({
-              id,
-              beamStart: doorStartPt,
-              beamEnd: doorEndPt,
-              beamHeight: doorHeight,
-              doorStart: doorStartPt,
-              doorEnd: doorEndPt,
-              doorHeight,
-              nearId: -1,
-              type: "onlyDoor",
-              isDoor: true,
-              beamNearWallVec: new THREE5.Vector3(0, 0, 0),
-              groundClearance: 0
-            });
-            pcdData[doorDatas[n].index].isFindBeam = true;
-            pcdData[doorDatas[n].index].isFindOnlyDoor = true;
-            beamGroup.push([{ id, beamStart: doorStartPt, beamEnd: doorEndPt }]);
-            id++;
-            findLine = true;
-            break;
           }
+          if (findLine) break;
         }
-        if (findLine) break;
       }
     }
+  } else {
+    if (onProgress != null)
+      onProgress(100);
   }
   let tmpLines = [];
   for (let i = 0; i < lines.length; i++) {
@@ -5199,10 +5188,7 @@ var checkBeamIsReasonable = async (lines, lineReader) => {
               doorAndBeamDataObj.beamNearWallVec = new THREE5.Vector3().subVectors(ptClose66, tmpPt66).normalize();
           }
           const allTmpPoints = [];
-          let tempLineX = lineReader.readLineById(lines[x].id);
-          tempLineX.originalPoints = lineReader.getOriginalPointsById(lines[x].id);
-          lines[x].originalPoints = tempLineX.originalPoints;
-          tempLineX = null;
+          lines[x].originalPoints = lineReader.getOriginalPointsById(lines[x].id);
           lines[x].originalPoints.forEach((item) => {
             if (item.z > doorTmpSt.z + 0.2 && item.z < doorTmpSt.z + height / 2)
               allTmpPoints.push(new THREE5.Vector3(item.x, item.y, doorTmpSt.z));
@@ -5560,9 +5546,9 @@ var getColLine = (lines, runDataList) => {
   };
   let isFindColIndexs = /* @__PURE__ */ new Set();
   let minColLineLength = 0.1;
-  let maxColLineLength = 1.2;
+  let maxColLineLength = 2;
   let minArea = 0.15;
-  let maxArea = 2;
+  let maxArea = 2.5;
   let minPerpendicularAngle = 80;
   let maxPerpendicularAngle = 95;
   if (!lines[0].uuid) {
@@ -5590,6 +5576,7 @@ var getColLine = (lines, runDataList) => {
     if (result[i].uuids.length < 4 || result[i].area < minArea || result[i].area > maxArea)
       continue;
     let isRect = false;
+    let overlapWallLines = [];
     for (let j = 0; j < result[i].lineIndexes.length; j++) {
       let length1 = lines[result[i].lineIndexes[j]].length;
       if (length1 < minColLineLength || length1 > maxColLineLength)
@@ -8766,10 +8753,6 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
             const f1 = calculateClosePointWithOBB(array2[k].points, obb1);
             const f2 = calculateClosePointWithOBB(array1[e].points, obb2);
             const isMaxBox = compareBoxVolume(obb1, obb2);
-            if (f2 >= 0.5 && isMaxBox == -1 && type1 !== "Staircase" && type2 !== "Staircase") {
-              array1[e].isDel = true;
-              break;
-            }
             if (type1 !== "wall" && type1 !== "floor" && type1 !== "roof") {
               if (type1 === "window") {
                 if (type2 === "balcony railing" && containsObbPoints(obb1, array2[k].points)) {
@@ -8820,19 +8803,47 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
                   break;
                 }
               } else if (type1 === "door") {
-                if (type2 === "window" && containsObbPoints(obb1, array2[k].points)) {
-                  array1[e].isDel = true;
-                  break;
+                if (type2 === "window") {
+                  if (type2 === "window" && containsObbPoints(obb1, array2[k].points)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
+                  if (type2 === "window" && containsObbPoints(obb2, array1[e].points)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
+                  if (type2 === "window sill" && containsObbPoints(obb1, array2[k].points)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
+                  if (type2 === "window sill" && containsObbPoints(obb2, array1[e].points)) {
+                    array1[e].isDel = true;
+                    break;
+                  }
+                } else {
+                  if (containsObbPoints(obb1, array2[k].points)) {
+                    array2[k].isDel = true;
+                    continue;
+                  }
+                  if (containsObbPoints(obb2, array1[e].points)) {
+                    array2[k].isDel = true;
+                    continue;
+                  }
+                  if (obb1.intersectsOBB(obb2)) {
+                    array2[k].isDel = true;
+                    continue;
+                  }
                 }
-                if (type2 === "window" && containsObbPoints(obb2, array1[e].points)) {
+              } else if (type2 === "door") {
+                if (containsObbPoints(obb1, array2[k].points)) {
                   array1[e].isDel = true;
                   break;
                 }
-                if (type2 === "window sill" && containsObbPoints(obb1, array2[k].points)) {
+                if (containsObbPoints(obb2, array1[e].points)) {
                   array1[e].isDel = true;
                   break;
                 }
-                if (type2 === "window sill" && containsObbPoints(obb2, array1[e].points)) {
+                if (obb1.intersectsOBB(obb2)) {
                   array1[e].isDel = true;
                   break;
                 }
@@ -9061,6 +9072,7 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
       }
     }
   }
+  return pcdPointsArr;
   const retPcdPointArr = [];
   for (let i = 0; i < pcdPointsArr.length; i++) {
     const array = pcdPointsArr[i].array;

package/package.json

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