rm-graphical-computing-node 1.0.73 → 1.0.75

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";
@@ -12104,6 +12232,394 @@ 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 tmpLine4 = new THREE10.Line3(ptLongSt1, ptLongEd1);
+        let tmpLine5 = new THREE10.Line3(ptLongSt2, ptLongEd2);
+        let ptMid = getMid(ptStart2, ptEnd2);
+        let ptClose3 = tmpLine3.closestPointToPoint(ptMid, true, new THREE10.Vector3());
+        let ptClose4 = tmpLine4.closestPointToPoint(ptMid, true, new THREE10.Vector3());
+        let ptClose5 = tmpLine5.closestPointToPoint(ptMid, true, new THREE10.Vector3());
+        if (ptClose3.distanceTo(ptMid) < pcdToLineDist || ptClose4.distanceTo(ptMid) < pcdToLineDist || ptClose5.distanceTo(ptMid) < pcdToLineDist) {
+          eligibilityLines.push(line3);
+          eligibilityLinesIndexs.push(j);
+        } else {
+          tmpLine3 = new THREE10.Line3(ptStart2, ptEnd2);
+          let ptMid3 = getMid(ptMid1, ptMid2);
+          let ptMid4 = getMid(ptLongSt1, ptLongEd1);
+          let ptMid5 = getMid(ptLongSt2, ptLongEd2);
+          ptClose3 = tmpLine3.closestPointToPoint(ptMid3, true, new THREE10.Vector3());
+          ptClose4 = tmpLine3.closestPointToPoint(ptMid4, true, new THREE10.Vector3());
+          ptClose5 = tmpLine3.closestPointToPoint(ptMid5, true, new THREE10.Vector3());
+          if (ptClose3.distanceTo(ptMid3) < pcdToLineDist || ptClose4.distanceTo(ptMid4) < pcdToLineDist || ptClose5.distanceTo(ptMid5) < 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) {
@@ -13216,7 +13732,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) {
@@ -14061,13 +14577,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;
@@ -18307,6 +18823,7 @@ export {
   findWindowWalls,
   getBeamLine,
   getColLine,
+  getDoorPcdData,
   getLineCheckResults,
   getMatcherAPI,
   getMergeFloorMeaning,
@@ -18316,6 +18833,7 @@ export {
   getSlabData,
   getStaircase,
   getWindowData,
+  getWindowPcdData,
   isRawLineNearArc,
   logArcRawSegments,
   matchWalls,

package/package.json

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