rm-graphical-computing-node 1.0.72 → 1.0.74

package/dist/index.mjs

@@ -2610,6 +2610,7 @@ var PointsUtils = class {
 };
 
 // src/utils/utils.mjs
+import { randomUUID } from "crypto";
 var addLine = (pt1, pt2, scene) => {
   let lineMaterial = new THREE3.LineBasicMaterial({ color: "#0011ff" });
   let pts = [];
@@ -3220,14 +3221,24 @@ var isPointOnLine = (line2, point2, tolerance = 1e-6) => {
   line2.closestPointToPoint(point2, true, closestPoint);
   return closestPoint.distanceTo(point2) < tolerance;
 };
-var isPointOnLine2 = (lineStart, lineEnd, point2, tolerance = 1e-6) => {
-  const line2 = new THREE3.Line3(
-    new THREE3.Vector3(lineStart.x, lineStart.y, lineStart.z),
-    new THREE3.Vector3(lineEnd.x, lineEnd.y, lineEnd.z)
-  );
-  const closestPoint = new THREE3.Vector3();
-  line2.closestPointToPoint(new THREE3.Vector3(point2.x, point2.y, point2.z), true, closestPoint);
-  return closestPoint.distanceTo(new THREE3.Vector3(point2.x, point2.y, point2.z)) < tolerance;
+var isPointOnLine2 = (lineStart, lineEnd, point2, tolerance = 1e-6, setZZero = false) => {
+  if (setZZero) {
+    const line2 = new THREE3.Line3(
+      new THREE3.Vector3(lineStart.x, lineStart.y, 0),
+      new THREE3.Vector3(lineEnd.x, lineEnd.y, 0)
+    );
+    const closestPoint = new THREE3.Vector3();
+    line2.closestPointToPoint(new THREE3.Vector3(point2.x, point2.y, 0), true, closestPoint);
+    return closestPoint.distanceTo(new THREE3.Vector3(point2.x, point2.y, 0)) < tolerance;
+  } else {
+    const line2 = new THREE3.Line3(
+      new THREE3.Vector3(lineStart.x, lineStart.y, lineStart.z),
+      new THREE3.Vector3(lineEnd.x, lineEnd.y, lineEnd.z)
+    );
+    const closestPoint = new THREE3.Vector3();
+    line2.closestPointToPoint(new THREE3.Vector3(point2.x, point2.y, point2.z), true, closestPoint);
+    return closestPoint.distanceTo(new THREE3.Vector3(point2.x, point2.y, point2.z)) < tolerance;
+  }
 };
 var getFarthestPoints = (points) => {
   let maxDist = 0;
@@ -3511,6 +3522,123 @@ var setPointsSameZ = (points, z) => {
     points[i].z = z;
   return points;
 };
+var getPt3 = (pt) => {
+  return new THREE3.Vector3(pt.x, pt.y, pt.z);
+};
+var getVector3 = (pt1, pt2, isNormalize = true) => {
+  if (isNormalize)
+    return new THREE3.Vector3().subVectors(pt2, pt1).normalize();
+  return new THREE3.Vector3().subVectors(pt2, pt1);
+};
+var mergeLines = (lines) => {
+  let allMergeIndex = [];
+  let newLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    let line1 = lines[i];
+    if (allMergeIndex.includes(i) || line1.isDoor)
+      continue;
+    let start1 = getPt3(line1.start);
+    let end1 = getPt3(line1.end);
+    let mergeIndexs = [];
+    for (let j = 0; j < lines.length; j++) {
+      let line2 = lines[j];
+      if (i == j || mergeIndexs.includes(j) || allMergeIndex.includes(j) || line2.isDoor)
+        continue;
+      let start2 = getPt3(line2.start);
+      let end2 = getPt3(line2.end);
+      let isP = classifySegments(start1, end1, start2, end2);
+      if (!isP || isP.type != "collinear_gap")
+        continue;
+      let isEq1 = ptIsEqual(start1, start2);
+      let isEq2 = ptIsEqual(start1, end2);
+      let isEq3 = ptIsEqual(end1, start2);
+      let isEq4 = ptIsEqual(end1, end2);
+      if (isEq1) {
+        start1 = end1.clone();
+        end1 = end2.clone();
+      } else if (isEq2) {
+        start1 = end1.clone();
+        end1 = start2.clone();
+      } else if (isEq3) {
+        end1 = end2.clone();
+      } else if (isEq4) {
+        end1 = start2.clone();
+      } else continue;
+      mergeIndexs.push(j);
+      j = -1;
+    }
+    if (!mergeIndexs.length)
+      continue;
+    let newOriginalPoints = line1.originalPoints;
+    let newDoorAndBeamDatas = [];
+    if (line1.doorAndBeamData)
+      newDoorAndBeamDatas = line1.doorAndBeamData;
+    let newWindowData = [];
+    if (line1.windowData)
+      newWindowData = line1.windowData;
+    let newRooftopPz = line1.rooftopPz;
+    let newIsPassageEntrance = false;
+    if (line1.isPassageEntrance)
+      newIsPassageEntrance = line1.isPassageEntrance;
+    let newInPassageEntranceDoor = false;
+    if (line1.inPassageEntranceDoor)
+      newInPassageEntranceDoor = line1.inPassageEntranceDoor;
+    let newPassageEntrance = [];
+    if (line1.passageEntrance)
+      newPassageEntrance = line1.passageEntrance;
+    let newDrawWindow = [];
+    if (line1.drawWindow)
+      newDrawWindow = line1.drawWindow;
+    let newIsHoleWindow = false;
+    if (line1.isHoleWindow)
+      newIsHoleWindow = line1.isHoleWindow;
+    for (let t = 0; t < mergeIndexs.length; t++) {
+      let line3 = lines[mergeIndexs[t]];
+      for (let e = 0; e < line3.originalPoints.length; e++)
+        newOriginalPoints.push(line3.originalPoints[e]);
+      if (line3.doorAndBeamData)
+        newDoorAndBeamDatas.push(...line3.doorAndBeamData);
+      if (line3.windowData)
+        newWindowData.push(...line3.windowData);
+      newRooftopPz = newRooftopPz < line3.rooftopPz ? line3.rooftopPz : newRooftopPz;
+      if (line3.isPassageEntrance)
+        newIsPassageEntrance = line3.isPassageEntrance;
+      if (line3.inPassageEntranceDoor)
+        newInPassageEntranceDoor = line3.inPassageEntranceDoor;
+      if (line3.passageEntrance)
+        newPassageEntrance.push(...line3.passageEntrance);
+      if (line3.drawWindow)
+        newDrawWindow.push(...line3.drawWindow);
+      if (line3.isHoleWindow)
+        newIsHoleWindow = line3.isHoleWindow;
+    }
+    if (mergeIndexs.length)
+      mergeIndexs.push(i);
+    let newLine = {
+      start: start1,
+      end: end1,
+      length: start1.distanceTo(end1),
+      originalPoints: newOriginalPoints,
+      isRebuild: false,
+      doorAndBeamData: newDoorAndBeamDatas,
+      windowData: newWindowData,
+      rooftopPz: newRooftopPz,
+      id: randomUUID(),
+      direction: line1.direction,
+      // isDoor: newIsDoor,
+      // drawDoorData: newDrawDoorData,
+      isPassageEntrance: newIsPassageEntrance,
+      inPassageEntranceDoor: newInPassageEntranceDoor,
+      passageEntrance: newPassageEntrance,
+      drawWindow: newDrawWindow,
+      isHoleWindow: newIsHoleWindow,
+      mergeIndexs
+    };
+    newLines.push(newLine);
+    allMergeIndex.push(...mergeIndexs);
+  }
+  return newLines;
+};
 
 // src/utils/updateLine.mjs
 import * as THREE4 from "three";
@@ -11470,7 +11598,7 @@ var getWindowData = (lines, pcdData, lineReader) => {
   for (let i = 0; i < pcdData.length; i++) {
     const window = pcdData[i];
     window.isFindWindow = false;
-    if (window.category == "window") {
+    if (window.category == "window" && !window.isBayWindowObj) {
       let boxPoints = [];
       window.coordinatesByArea.coordinates.forEach((p) => {
         boxPoints.push(new THREE10.Vector3(p.x, p.y, p.z));
@@ -11841,104 +11969,124 @@ var getWindowData = (lines, pcdData, lineReader) => {
             let afterDoorLen = doorTmpEd.distanceTo(doorTmpSt);
             if (afterDoorLen < 0.4 && !isWindow || afterDoorLen < 0.3 && isWindow)
               continue;
-            const windowLine = new THREE10.Line3(doorTmpSt, doorTmpEd);
             const windowPcd = windowDatas[findDoorDataIndex];
             const windowPcdSt = windowPcd.windowStartPt.clone();
             const windowPcdEd = windowPcd.windowEndPt.clone();
-            const windowLen = windowPcdSt.distanceTo(windowPcdEd);
-            let rectPts = windowPcd.rectPts.map((p) => new THREE10.Vector3(p.x, p.y, p.z));
-            rectPts = setPointsSameZ(rectPts, doorTmpSt.z);
-            let ptClose = new THREE10.Vector3();
-            let vec2 = new THREE10.Vector3();
-            if (rectPts.length == 5)
-              rectPts.splice(4, 1);
-            let shortLinePt1 = rectPts[0];
-            let shortLinePt2 = rectPts[1];
-            let shortLinePt3 = rectPts[2];
-            let shortLinePt4 = rectPts[3];
-            if (rectPts[0].distanceTo(rectPts[1]) > rectPts[1].distanceTo(rectPts[2])) {
-              shortLinePt1 = rectPts[1];
-              shortLinePt2 = rectPts[2];
-              shortLinePt3 = rectPts[3];
-              shortLinePt4 = rectPts[0];
+            const windowPcdLen = windowPcdSt.distanceTo(windowPcdEd);
+            const windowPcdHeight = Math.abs(windowPcd.maxZ - windowPcd.minZ);
+            let windowHeight = beamTmpSt.z - doorTmpSt.z;
+            const windowLen = doorTmpSt.distanceTo(doorTmpEd);
+            let changeWindowSize = false;
+            let windowSizeThreshold = 0.5;
+            if ((Math.abs(windowPcdLen - windowLen) < windowSizeThreshold || windowPcdLen > windowLen) && (Math.abs(windowPcdHeight - windowHeight) < windowSizeThreshold || windowPcdHeight > windowHeight)) {
+              changeWindowSize = true;
+            } else {
+              let checkResultsNum = region.points.length / 4;
+              let gridWidth = region.gridWidth;
+              let gridHeight = region.gridHeight;
+              let lenNum = Math.floor(windowLen / gridWidth);
+              let heightNum = Math.floor(windowHeight / gridHeight);
+              let totalCheckResultsNum = lenNum * heightNum;
+              let checkResultsPercentage = checkResultsNum / totalCheckResultsNum;
+              if (checkResultsPercentage < 0.8)
+                changeWindowSize = true;
             }
-            let addShortLen = 0.2;
-            let vecShort1 = new THREE10.Vector3().subVectors(shortLinePt2, shortLinePt1).normalize();
-            let vecShort2 = new THREE10.Vector3().subVectors(shortLinePt4, shortLinePt3).normalize();
-            shortLinePt1 = shortLinePt1.addScaledVector(vecShort1, -addShortLen);
-            shortLinePt2 = shortLinePt2.addScaledVector(vecShort1, addShortLen);
-            shortLinePt3 = shortLinePt3.addScaledVector(vecShort2, -addShortLen);
-            shortLinePt4 = shortLinePt4.addScaledVector(vecShort2, addShortLen);
-            let tmpVec = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize();
-            let tmpDoorTmpSt = doorTmpSt.clone().addScaledVector(tmpVec, -addShortLen);
-            let tmpDoorTmpEd = doorTmpEd.clone().addScaledVector(tmpVec, addShortLen);
-            let intersect1 = segmentsIntersect2D(shortLinePt1, shortLinePt2, tmpDoorTmpSt, tmpDoorTmpEd);
-            let intersect2 = segmentsIntersect2D(shortLinePt3, shortLinePt4, tmpDoorTmpSt, tmpDoorTmpEd);
-            let distIntersect1 = 99999;
-            let distIntersect2 = 99999;
-            let near1St = false;
-            let near2St = false;
-            if (intersect1 != null) {
-              let dist55 = intersect1.point.distanceTo(doorTmpSt);
-              let dist66 = intersect1.point.distanceTo(doorTmpEd);
-              if (dist55 < 0.1 || dist66 < 0.1) {
-                if (dist55 < dist66) {
-                  near1St = true;
-                  distIntersect1 = dist55;
-                } else
-                  distIntersect1 = dist66;
+            if (changeWindowSize) {
+              const windowLine = new THREE10.Line3(doorTmpSt, doorTmpEd);
+              let rectPts = windowPcd.rectPts.map((p) => new THREE10.Vector3(p.x, p.y, p.z));
+              rectPts = setPointsSameZ(rectPts, doorTmpSt.z);
+              let ptClose = new THREE10.Vector3();
+              let vec2 = new THREE10.Vector3();
+              if (rectPts.length == 5)
+                rectPts.splice(4, 1);
+              let shortLinePt1 = rectPts[0];
+              let shortLinePt2 = rectPts[1];
+              let shortLinePt3 = rectPts[2];
+              let shortLinePt4 = rectPts[3];
+              if (rectPts[0].distanceTo(rectPts[1]) > rectPts[1].distanceTo(rectPts[2])) {
+                shortLinePt1 = rectPts[1];
+                shortLinePt2 = rectPts[2];
+                shortLinePt3 = rectPts[3];
+                shortLinePt4 = rectPts[0];
               }
-            }
-            if (intersect2 != null) {
-              let dist55 = intersect2.point.distanceTo(doorTmpSt);
-              let dist66 = intersect2.point.distanceTo(doorTmpEd);
-              if (dist55 < 0.1 || dist66 < 0.1) {
-                if (dist55 < dist66) {
-                  near2St = true;
-                  distIntersect2 = dist55;
-                } else
-                  distIntersect2 = dist66;
+              let addShortLen = 0.2;
+              let vecShort1 = new THREE10.Vector3().subVectors(shortLinePt2, shortLinePt1).normalize();
+              let vecShort2 = new THREE10.Vector3().subVectors(shortLinePt4, shortLinePt3).normalize();
+              shortLinePt1 = shortLinePt1.addScaledVector(vecShort1, -addShortLen);
+              shortLinePt2 = shortLinePt2.addScaledVector(vecShort1, addShortLen);
+              shortLinePt3 = shortLinePt3.addScaledVector(vecShort2, -addShortLen);
+              shortLinePt4 = shortLinePt4.addScaledVector(vecShort2, addShortLen);
+              let tmpVec = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize();
+              let tmpDoorTmpSt = doorTmpSt.clone().addScaledVector(tmpVec, -addShortLen);
+              let tmpDoorTmpEd = doorTmpEd.clone().addScaledVector(tmpVec, addShortLen);
+              let intersect1 = segmentsIntersect2D(shortLinePt1, shortLinePt2, tmpDoorTmpSt, tmpDoorTmpEd);
+              let intersect2 = segmentsIntersect2D(shortLinePt3, shortLinePt4, tmpDoorTmpSt, tmpDoorTmpEd);
+              let distIntersect1 = 99999;
+              let distIntersect2 = 99999;
+              let near1St = false;
+              let near2St = false;
+              if (intersect1 != null) {
+                let dist55 = intersect1.point.distanceTo(doorTmpSt);
+                let dist66 = intersect1.point.distanceTo(doorTmpEd);
+                if (dist55 < 0.1 || dist66 < 0.1) {
+                  if (dist55 < dist66) {
+                    near1St = true;
+                    distIntersect1 = dist55;
+                  } else
+                    distIntersect1 = dist66;
+                }
               }
-            }
-            if (distIntersect1 == 99999 && distIntersect2 == 99999) {
-              windowPcdSt.z = windowPcdEd.z = doorTmpSt.z;
-              let dist11 = doorTmpSt.distanceTo(windowPcdSt);
-              let dist22 = doorTmpSt.distanceTo(windowPcdEd);
-              let dist33 = doorTmpEd.distanceTo(windowPcdSt);
-              let dist44 = doorTmpEd.distanceTo(windowPcdEd);
-              let minDist = Math.min(dist11, dist22, dist33, dist44);
-              let wZ = doorTmpSt.z;
-              if (dist11 == minDist) {
-                ptClose = windowLine.closestPointToPoint(windowPcdSt, false, new THREE10.Vector3());
-                vec2 = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize();
-              } else if (dist22 == minDist) {
-                ptClose = windowLine.closestPointToPoint(windowPcdEd, false, new THREE10.Vector3());
-                vec2 = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize();
-              } else if (dist33 == minDist) {
-                ptClose = windowLine.closestPointToPoint(windowPcdSt, false, new THREE10.Vector3());
-                vec2 = new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
-              } else if (dist44 == minDist) {
-                ptClose = windowLine.closestPointToPoint(windowPcdEd, false, new THREE10.Vector3());
-                vec2 = new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+              if (intersect2 != null) {
+                let dist55 = intersect2.point.distanceTo(doorTmpSt);
+                let dist66 = intersect2.point.distanceTo(doorTmpEd);
+                if (dist55 < 0.1 || dist66 < 0.1) {
+                  if (dist55 < dist66) {
+                    near2St = true;
+                    distIntersect2 = dist55;
+                  } else
+                    distIntersect2 = dist66;
+                }
               }
-            } else {
-              if (distIntersect1 < distIntersect2) {
-                ptClose = intersect1.point.clone();
-                vec2 = near1St ? new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize() : new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+              if (distIntersect1 == 99999 && distIntersect2 == 99999) {
+                windowPcdSt.z = windowPcdEd.z = doorTmpSt.z;
+                let dist11 = doorTmpSt.distanceTo(windowPcdSt);
+                let dist22 = doorTmpSt.distanceTo(windowPcdEd);
+                let dist33 = doorTmpEd.distanceTo(windowPcdSt);
+                let dist44 = doorTmpEd.distanceTo(windowPcdEd);
+                let minDist = Math.min(dist11, dist22, dist33, dist44);
+                let wZ = doorTmpSt.z;
+                if (dist11 == minDist) {
+                  ptClose = windowLine.closestPointToPoint(windowPcdSt, false, new THREE10.Vector3());
+                  vec2 = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize();
+                } else if (dist22 == minDist) {
+                  ptClose = windowLine.closestPointToPoint(windowPcdEd, false, new THREE10.Vector3());
+                  vec2 = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize();
+                } else if (dist33 == minDist) {
+                  ptClose = windowLine.closestPointToPoint(windowPcdSt, false, new THREE10.Vector3());
+                  vec2 = new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+                } else if (dist44 == minDist) {
+                  ptClose = windowLine.closestPointToPoint(windowPcdEd, false, new THREE10.Vector3());
+                  vec2 = new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+                }
               } else {
-                ptClose = intersect2.point.clone();
-                vec2 = near2St ? new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize() : new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+                if (distIntersect1 < distIntersect2) {
+                  ptClose = intersect1.point.clone();
+                  vec2 = near1St ? new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize() : new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+                } else {
+                  ptClose = intersect2.point.clone();
+                  vec2 = near2St ? new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt).normalize() : new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd).normalize();
+                }
               }
+              doorTmpSt = ptClose.clone();
+              doorTmpEd = doorTmpSt.clone().addScaledVector(vec2, windowPcdLen);
+              doorTmpSt.z = doorTmpEd.z = windowPcd.minZ;
+              beamTmpSt = doorTmpSt.clone();
+              beamTmpEd = doorTmpEd.clone();
+              beamTmpSt.z = beamTmpEd.z = windowPcd.maxZ;
             }
-            doorTmpSt = ptClose.clone();
-            doorTmpEd = doorTmpSt.clone().addScaledVector(vec2, windowLen);
-            doorTmpSt.z = doorTmpEd.z = windowPcd.minZ;
-            beamTmpSt = doorTmpSt.clone();
-            beamTmpEd = doorTmpEd.clone();
-            beamTmpSt.z = beamTmpEd.z = windowPcd.maxZ;
             let doorType = "";
             let groundClearance = doorTmpSt.z - line2.start.z > 1e-4 ? doorTmpSt.z - line2.start.z : 0;
-            let windowHeight = beamTmpSt.z - doorTmpSt.z;
+            windowHeight = beamTmpSt.z - doorTmpSt.z;
             let doorAndBeamDataObj = {
               id,
               windowTopSt: new THREE10.Vector3(doorTmpSt.x, doorTmpSt.y, doorTmpSt.z + windowHeight),
@@ -12084,6 +12232,386 @@ var checkWindowAndDoorIsTrue = async (lines, runDataList, collectDataPath, point
   }
   return lines;
 };
+var getWindowPcdData = (lines, pcdData) => {
+  if (!lines || !lines.length || !pcdData || !pcdData.length)
+    return lines;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].drawWindow && lines[i].drawWindow.length)
+      lines[i].drawWindow.length = 0;
+  }
+  const pcdToLineDist = 0.3;
+  for (let i = 0; i < pcdData.length; i++) {
+    const pcd = pcdData[i];
+    if (pcd.category != "window" || pcd.isBayWindowObj || pcd.isFindWindow)
+      continue;
+    let ptArray = pcd.coordinatesByArea.coordinates;
+    let minZ = pcd.coordinatesByArea.heightData.minZ;
+    let maxZ = pcd.coordinatesByArea.heightData.maxZ;
+    let height = maxZ - minZ;
+    let ptLongSt1 = getPt3(ptArray[0]);
+    let ptLongEd1 = getPt3(ptArray[1]);
+    let ptLongSt2 = getPt3(ptArray[2]);
+    let ptLongEd2 = getPt3(ptArray[3]);
+    let ptShortSt1 = getPt3(ptArray[1]);
+    let ptShortEd1 = getPt3(ptArray[2]);
+    let ptShortSt2 = getPt3(ptArray[3]);
+    let ptShortEd2 = getPt3(ptArray[0]);
+    if (ptLongSt1.distanceTo(ptLongEd1) < ptLongSt1.distanceTo(ptLongEd2)) {
+      ptLongSt1 = getPt3(ptArray[1]);
+      ptLongEd1 = getPt3(ptArray[2]);
+      ptLongSt2 = getPt3(ptArray[3]);
+      ptLongEd2 = getPt3(ptArray[0]);
+      ptShortSt1 = getPt3(ptArray[0]);
+      ptShortEd1 = getPt3(ptArray[1]);
+      ptShortSt2 = getPt3(ptArray[2]);
+      ptShortEd2 = getPt3(ptArray[3]);
+    }
+    let ptMid1 = getMid(ptShortSt1, ptShortEd1);
+    let ptMid2 = getMid(ptShortSt2, ptShortEd2);
+    let shortLen = ptShortSt1.distanceTo(ptShortEd1);
+    let eligibilityLines = [];
+    let eligibilityLinesIndexs = [];
+    for (let j = 0; j < lines.length; j++) {
+      const line3 = lines[j];
+      let ptStart2 = getPt3(line3.start);
+      let ptEnd2 = getPt3(line3.end);
+      ptStart2.z = ptEnd2.z = ptMid1.z;
+      let isp = getParallelism(ptMid1, ptMid2, ptStart2, ptEnd2);
+      if (isp && isp.angleDeg < 25) {
+        let tmpLine3 = new THREE10.Line3(ptMid1, ptMid2);
+        let ptMid = getMid(ptStart2, ptEnd2);
+        let ptClose = tmpLine3.closestPointToPoint(ptMid, true, new THREE10.Vector3());
+        if (ptClose.distanceTo(ptMid) < pcdToLineDist) {
+          eligibilityLines.push(line3);
+          eligibilityLinesIndexs.push(j);
+        } else {
+          tmpLine3 = new THREE10.Line3(ptStart2, ptEnd2);
+          ptMid = getMid(ptMid1, ptMid2);
+          ptClose = tmpLine3.closestPointToPoint(ptMid, true, new THREE10.Vector3());
+          if (ptClose.distanceTo(ptMid) < pcdToLineDist) {
+            eligibilityLines.push(line3);
+            eligibilityLinesIndexs.push(j);
+          }
+        }
+      }
+    }
+    let newLines = mergeLines(eligibilityLines);
+    let tmpLines = [];
+    if (newLines && newLines.length) {
+      for (let k = 0; k < newLines.length; k++) {
+        let mergeIndexs = newLines[k].mergeIndexs;
+        for (let c = 0; c < eligibilityLines.length; c++) {
+          if (mergeIndexs.includes(c))
+            continue;
+          tmpLines.push(eligibilityLines[c]);
+        }
+      }
+      tmpLines.push(...newLines);
+    } else
+      tmpLines = [...eligibilityLines];
+    let maxLen = -1;
+    let maxIndex = -1;
+    for (let t = 0; t < tmpLines.length; t++) {
+      if (tmpLines[t].length > maxLen) {
+        maxLen = tmpLines[t].length;
+        maxIndex = t;
+      }
+    }
+    if (maxIndex == -1)
+      continue;
+    const line2 = tmpLines[maxIndex];
+    let ptStart = getPt3(line2.start);
+    let ptEnd = getPt3(line2.end);
+    ptStart.z = ptEnd.z = ptShortEd1.z;
+    let intersect1 = segmentsIntersect2D(ptStart, ptEnd, ptShortSt1, ptShortEd1, pcdToLineDist);
+    let intersect2 = segmentsIntersect2D(ptStart, ptEnd, ptShortSt2, ptShortEd2, pcdToLineDist);
+    if (intersect1 != null && intersect2 != null) {
+      if (line2.mergeIndexs) {
+        let tmpIndex = [];
+        for (let h = 0; h < line2.mergeIndexs.length; h++) {
+          tmpIndex.push(eligibilityLinesIndexs[line2.mergeIndexs[h]]);
+        }
+        for (let h = 0; h < lines.length; h++) {
+          if (tmpIndex.includes(h))
+            lines[h].isRebuild = true;
+        }
+        lines.push(line2);
+      }
+      let ptWindowSt = getPt3(intersect1.point);
+      let ptWindowEd = getPt3(intersect2.point);
+      if (ptStart.distanceTo(ptWindowSt) > ptStart.distanceTo(ptWindowEd))
+        [ptWindowSt, ptWindowEd] = [ptWindowEd, ptWindowSt];
+      let groundClearance = minZ - ptWindowSt.z;
+      groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+      if (!line2.drawWindow)
+        line2.drawWindow = [];
+      let p = getMid(ptWindowSt, ptWindowEd);
+      p.z = minZ;
+      line2.drawWindow.push({
+        p,
+        full: false,
+        groundClearance,
+        height,
+        width: ptWindowSt.distanceTo(ptWindowEd)
+      });
+      line2.isWindow = true;
+      pcd.isWindowDoor = true;
+    } else if (intersect1 != null || intersect2 != null) {
+      if (line2.mergeIndexs) {
+        let tmpIndex = [];
+        for (let h = 0; h < line2.mergeIndexs.length; h++) {
+          tmpIndex.push(eligibilityLinesIndexs[line2.mergeIndexs[h]]);
+        }
+        for (let h = 0; h < lines.length; h++) {
+          if (tmpIndex.includes(h))
+            lines[h].isRebuild = true;
+        }
+        lines.push(line2);
+      }
+      let ptWindowSt = null;
+      let pcdMid = null;
+      if (intersect1 != null) {
+        ptWindowSt = getPt3(intersect1.point);
+        pcdMid = ptMid2.clone();
+      } else {
+        ptWindowSt = getPt3(intersect2.point);
+        pcdMid = ptMid1.clone();
+      }
+      let line3 = new THREE10.Line3(ptStart, ptEnd);
+      let ptClose = line3.closestPointToPoint(pcdMid, false, new THREE10.Vector3());
+      let vec2 = getVector3(ptWindowSt, ptClose);
+      let width = ptMid1.distanceTo(ptMid2);
+      let ptWindowEd = ptWindowSt.clone().addScaledVector(vec2, width);
+      let groundClearance = minZ - ptWindowSt.z;
+      groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+      if (!line2.drawWindow)
+        line2.drawWindow = [];
+      let p = getMid(ptWindowSt, ptWindowEd);
+      p.z = minZ;
+      line2.drawWindow.push({
+        p,
+        full: false,
+        groundClearance,
+        height,
+        width: ptWindowSt.distanceTo(ptWindowEd)
+      });
+      line2.isWindow = true;
+      pcd.isWindowDoor = true;
+    } else {
+      let shortLine1 = new THREE10.Line3(ptShortSt1, ptShortEd1);
+      let shortLine2 = new THREE10.Line3(ptShortSt2, ptShortEd2);
+      let ptClose1 = shortLine1.closestPointToPoint(ptStart, true, new THREE10.Vector3());
+      let ptClose2 = shortLine1.closestPointToPoint(ptEnd, true, new THREE10.Vector3());
+      let ptClose3 = shortLine2.closestPointToPoint(ptStart, true, new THREE10.Vector3());
+      let ptClose4 = shortLine2.closestPointToPoint(ptEnd, true, new THREE10.Vector3());
+      let dist1 = ptClose1.distanceTo(ptStart);
+      let dist2 = ptClose2.distanceTo(ptEnd);
+      let dist3 = ptClose3.distanceTo(ptStart);
+      let dist4 = ptClose4.distanceTo(ptEnd);
+      let nearDist = 0.1;
+      if ((dist1 < nearDist || dist2 < nearDist) && (dist3 < nearDist || dist4 < nearDist)) {
+        if (line2.mergeIndexs) {
+          let tmpIndex = [];
+          for (let h = 0; h < line2.mergeIndexs.length; h++) {
+            tmpIndex.push(eligibilityLinesIndexs[line2.mergeIndexs[h]]);
+          }
+          for (let h = 0; h < lines.length; h++) {
+            if (tmpIndex.includes(h))
+              lines[h].isRebuild = true;
+          }
+          lines.push(line2);
+        }
+        let ptWindowSt = ptClose1.clone();
+        let ptWindowEd = ptClose3.clone();
+        if (dist2 < nearDist)
+          ptWindowSt = ptClose2.clone();
+        if (dist4 < nearDist)
+          ptWindowEd = ptClose4.clone();
+        ptWindowSt.z = ptWindowEd.z = minZ;
+        let groundClearance = minZ - ptWindowSt.z;
+        groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+        if (!line2.drawWindow)
+          line2.drawWindow = [];
+        let p = getMid(ptWindowSt, ptWindowEd);
+        p.z = minZ;
+        line2.drawWindow.push({
+          p,
+          full: false,
+          groundClearance,
+          height,
+          width: ptWindowSt.distanceTo(ptWindowEd)
+        });
+        line2.isWindow = true;
+        pcd.isWindowDoor = true;
+      }
+    }
+  }
+  return lines;
+};
+
+// src/geometry/door.mjs
+import * as THREE11 from "three";
+import { randomUUID as randomUUID2 } from "crypto";
+var getDoorPcdData = (lines, pcdData) => {
+  if (!lines || !lines.length || !pcdData || !pcdData.length)
+    return lines;
+  for (let i = 0; i < pcdData.length; i++) {
+    const pcd = pcdData[i];
+    if (pcd.category != "door" || pcd.isFindBeam)
+      continue;
+    let ptArray = pcd.coordinatesByArea.coordinates;
+    let minZ = pcd.coordinatesByArea.heightData.minZ;
+    let maxZ = pcd.coordinatesByArea.heightData.maxZ;
+    let height = maxZ - minZ;
+    let ptLongSt1 = getPt3(ptArray[0]);
+    let ptLongEd1 = getPt3(ptArray[1]);
+    let ptLongSt2 = getPt3(ptArray[2]);
+    let ptLongEd2 = getPt3(ptArray[3]);
+    let ptShortSt1 = getPt3(ptArray[1]);
+    let ptShortEd1 = getPt3(ptArray[2]);
+    let ptShortSt2 = getPt3(ptArray[3]);
+    let ptShortEd2 = getPt3(ptArray[0]);
+    if (ptLongSt1.distanceTo(ptLongEd1) < ptLongSt1.distanceTo(ptLongEd2)) {
+      ptLongSt1 = getPt3(ptArray[1]);
+      ptLongEd1 = getPt3(ptArray[2]);
+      ptLongSt2 = getPt3(ptArray[3]);
+      ptLongEd2 = getPt3(ptArray[0]);
+      ptShortSt1 = getPt3(ptArray[0]);
+      ptShortEd1 = getPt3(ptArray[1]);
+      ptShortSt2 = getPt3(ptArray[2]);
+      ptShortEd2 = getPt3(ptArray[3]);
+    }
+    let ptMid1 = getMid(ptShortSt1, ptShortEd1);
+    let ptMid2 = getMid(ptShortSt2, ptShortEd2);
+    let shortLen = ptShortSt1.distanceTo(ptShortEd1);
+    let eligibilityLines = [];
+    let eligibilityLinesIndexs = [];
+    for (let j = 0; j < lines.length; j++) {
+      const line3 = lines[j];
+      let ptStart2 = getPt3(line3.start);
+      let ptEnd2 = getPt3(line3.end);
+      ptStart2.z = ptEnd2.z = ptMid1.z;
+      let classify = classifySegments(ptMid1, ptMid2, ptStart2, ptEnd2);
+      if (classify.type == "collinear_overlap" && classify.maxPerpendicularDistance < 0.3) {
+        eligibilityLines.push(line3);
+        eligibilityLinesIndexs.push(j);
+      }
+    }
+    let newLines = mergeLines(eligibilityLines);
+    let tmpLines = [];
+    if (newLines && newLines.length) {
+      for (let k = 0; k < newLines.length; k++) {
+        let mergeIndexs = newLines[k].mergeIndexs;
+        for (let c = 0; c < eligibilityLines.length; c++) {
+          if (mergeIndexs.includes(c))
+            continue;
+          tmpLines.push(eligibilityLines[c]);
+        }
+      }
+      tmpLines.push(...newLines);
+    } else
+      tmpLines = [...eligibilityLines];
+    let maxLen = -1;
+    let maxIndex = -1;
+    for (let t = 0; t < tmpLines.length; t++) {
+      if (tmpLines[t].length > maxLen) {
+        maxLen = tmpLines[t].length;
+        maxIndex = t;
+      }
+    }
+    if (maxIndex == -1)
+      continue;
+    const line2 = tmpLines[maxIndex];
+    let ptStart = getPt3(line2.start);
+    let ptEnd = getPt3(line2.end);
+    let intersect1 = segmentsIntersect2D(ptStart, ptEnd, ptShortSt1, ptShortEd1, 0.05);
+    let intersect2 = segmentsIntersect2D(ptStart, ptEnd, ptShortSt2, ptShortEd2, 0.05);
+    if (intersect1 != null && intersect2 != null) {
+      if (line2.mergeIndexs) {
+        let tmpIndex = [];
+        for (let h = 0; h < line2.mergeIndexs.length; h++) {
+          tmpIndex.push(eligibilityLinesIndexs[line2.mergeIndexs[h]]);
+        }
+        for (let h = 0; h < lines.length; h++) {
+          if (tmpIndex.includes(h))
+            lines[h].isRebuild = true;
+        }
+      }
+      let ptDoorSt = getPt3(intersect1.point);
+      let ptDoorEd = getPt3(intersect2.point);
+      if (ptStart.distanceTo(ptDoorSt) > ptStart.distanceTo(ptDoorEd))
+        [ptDoorSt, ptDoorEd] = [ptDoorEd, ptDoorSt];
+      const newOriginPts1 = getProjectedPointOnLine(ptStart, ptDoorSt, line2.originalPoints);
+      const newOriginPts2 = getProjectedPointOnLine(ptDoorSt, ptDoorEd, line2.originalPoints);
+      const newOriginPts3 = getProjectedPointOnLine(ptDoorEd, ptEnd, line2.originalPoints);
+      const newDoorAndBeamData1 = [];
+      const newDoorAndBeamData2 = [];
+      const newDoorAndBeamData3 = [];
+      if (line2.doorAndBeamData) {
+        for (let a = 0; a < line2.doorAndBeamData.length; a++) {
+          let doorStart = line2.doorAndBeamData[a].doorStart;
+          let doorEnd = line2.doorAndBeamData[a].doorEnd;
+          if (isPointOnLine2(ptStart, ptDoorSt, doorStart, 1e-3, true) && isPointOnLine2(ptStart, ptDoorSt, doorEnd, 1e-3, true))
+            newDoorAndBeamData1.push(line2.doorAndBeamData[a]);
+          else if (isPointOnLine2(ptDoorEd, ptEnd, doorStart, 1e-3, true) && isPointOnLine2(ptDoorEd, ptEnd, doorEnd, 1e-3, true))
+            newDoorAndBeamData3.push(line2.doorAndBeamData[a]);
+        }
+      }
+      let groundClearance = minZ - ptDoorSt.z;
+      groundClearance = groundClearance > 0.01 ? groundClearance : 0;
+      let newLine1 = {
+        start: ptStart,
+        end: ptDoorSt,
+        length: ptStart.distanceTo(ptDoorSt),
+        originalPoints: newOriginPts1.newOriginalPoints,
+        doorAndBeamData: newDoorAndBeamData1,
+        id: randomUUID2(),
+        rooftopPz: line2.rooftopPz,
+        isRebuild: false,
+        direction: line2.direction
+      };
+      let newLine2 = {
+        start: ptDoorSt,
+        end: ptDoorEd,
+        length: ptDoorSt.distanceTo(ptDoorEd),
+        originalPoints: newOriginPts2.newOriginalPoints,
+        doorAndBeamData: newDoorAndBeamData2,
+        id: randomUUID2(),
+        rooftopPz: line2.rooftopPz,
+        isRebuild: false,
+        direction: line2.direction,
+        drawDoorData: {
+          start: new THREE11.Vector3(ptDoorSt.x, ptDoorSt.y, minZ),
+          end: new THREE11.Vector3(ptDoorEd.x, ptDoorEd.y, minZ),
+          n: new THREE11.Vector3(0, 0, 0),
+          height,
+          groundClearance
+        },
+        isDoor: true
+      };
+      let newLine3 = {
+        start: ptDoorEd,
+        end: ptEnd,
+        length: ptDoorEd.distanceTo(ptEnd),
+        originalPoints: newOriginPts3.newOriginalPoints,
+        doorAndBeamData: newDoorAndBeamData3,
+        id: randomUUID2(),
+        rooftopPz: line2.rooftopPz,
+        isRebuild: false,
+        direction: line2.direction
+      };
+      if (newLine1.originalPoints.length > 0)
+        lines.push(newLine1);
+      if (newLine2.originalPoints.length > 0)
+        lines.push(newLine2);
+      if (newLine3.originalPoints.length > 0)
+        lines.push(newLine3);
+      pcd.isFindDoor = true;
+      line2.isRebuild = true;
+    }
+  }
+  return lines;
+};
 
 // src/wall-window-matcher/utils.ts
 function dist2D(a, b) {
@@ -13196,7 +13724,7 @@ function processData(wallSegments, objects, options) {
 }
 
 // src/wall-door-matcher/matcher.ts
-import * as THREE11 from "three";
+import * as THREE12 from "three";
 
 // src/wall-door-matcher/utils.ts
 function dist2D2(a, b) {
@@ -14041,13 +14569,13 @@ function collectCandidates2(candidateSegments, doorLong, doorDirX, doorDirY, che
       if (isLine2)
         continue;
       if (passageEntrance) {
-        const pt1 = new THREE11.Vector3(nline.start.x, nline.start.y, nline.start.z);
-        const pt2 = new THREE11.Vector3(nline.end.x, nline.end.y, nline.end.z);
+        const pt1 = new THREE12.Vector3(nline.start.x, nline.start.y, nline.start.z);
+        const pt2 = new THREE12.Vector3(nline.end.x, nline.end.y, nline.end.z);
         let isOverLap = false;
         for (let v2 = 0; v2 < passageEntrance.length; v2++) {
           const data = passageEntrance[v2];
-          const pt3 = new THREE11.Vector3(data.start.x, data.start.y, data.start.z);
-          const pt4 = new THREE11.Vector3(data.end.x, data.end.y, data.end.z);
+          const pt3 = new THREE12.Vector3(data.start.x, data.start.y, data.start.z);
+          const pt4 = new THREE12.Vector3(data.end.x, data.end.y, data.end.z);
           let resultTmp = classifySegments(pt1, pt2, pt3, pt4);
           if (resultTmp.type == "collinear_overlap" && resultTmp.maxPerpendicularDistance < 0.1) {
             isOverLap = true;
@@ -18287,6 +18815,7 @@ export {
   findWindowWalls,
   getBeamLine,
   getColLine,
+  getDoorPcdData,
   getLineCheckResults,
   getMatcherAPI,
   getMergeFloorMeaning,
@@ -18296,6 +18825,7 @@ export {
   getSlabData,
   getStaircase,
   getWindowData,
+  getWindowPcdData,
   isRawLineNearArc,
   logArcRawSegments,
   matchWalls,

package/package.json

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