rm-graphical-computing-node 1.0.44 → 1.0.46

package/dist/index.mjs

@@ -3782,7 +3782,7 @@ function getTrendLineEndpoints(points, options = {}) {
 }
 
 // src/geometry/beamLine.mjs
-import { Line as Line2 } from "three";
+import { Const } from "three/tsl";
 var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, onProgress = null) => {
   removeNoisePoints(lines, lineReader, lineEditor);
   if (lines.length <= 0 || runDataList.length <= 0)
@@ -3939,11 +3939,11 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
         let dist1 = door.doorStartPt.distanceTo(door.doorEndPt);
         let dist22 = newDoorSt.distanceTo(newDoorEd);
         let res = getParallelism(door.doorStartPt, door.doorEndPt, newDoorSt, newDoorEd);
-        if (Math.abs(dist22 - dist1) < 0.5 && res && res.angleDeg < 15) {
+        if (Math.abs(dist22 - 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 < 15) {
+        } else if (Math.abs(dist22 - 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);
@@ -4543,84 +4543,13 @@ var getBeamLine = async (lines, runDataList, pcdData, lineReader, lineEditor, on
             }
           }
           if (addData) {
-            if (
-              /**!isPullOutDoor */
-              true
-            ) {
-              let doorVector1 = new THREE5.Vector3().subVectors(doorTmpSt, doorTmpEd);
-              let doorVector2 = new THREE5.Vector3().subVectors(doorTmpEd, doorTmpSt);
-              let toDoorStNearDist = Infinity;
-              let toDoorEdNearDist = Infinity;
-              let newDoorTmpSt = doorTmpSt.clone();
-              let newDoorTmpEd = doorTmpEd.clone();
-              const nearFloorPoints = [];
-              const nearTopPoints = [];
-              let topDoorSegLine = new THREE5.Line3(beamTmpSt, beamTmpEd);
-              let tmpTarget33 = new THREE5.Vector3();
-              let addHeight = 999999;
-              line2.originalPoints.forEach((point2) => {
-                if (point2.z - doorTmpSt.z < height / 2 + 0.1 && point2.z - doorTmpSt.z > height / 2 - 0.1) {
-                  nearFloorPoints.push(point2);
-                }
-                if (point2.z > beamTmpSt.z) {
-                  let ptCloseTmp33 = topDoorSegLine.closestPointToPoint(point2, true, tmpTarget33);
-                  let tmpVec1 = new THREE5.Vector3().subVectors(ptCloseTmp33, beamTmpSt);
-                  let tmpVec2 = new THREE5.Vector3().subVectors(ptCloseTmp33, beamTmpEd);
-                  let resP1 = isParallel(doorVector1, tmpVec2);
-                  let resP2 = isParallel(doorVector2, tmpVec1);
-                  if (resP1 && resP1.parallel && !resP1.sameDirection && resP2 && resP2.parallel && !resP2.sameDirection) {
-                    nearTopPoints.push(point2);
-                  }
-                }
-              });
-              if (nearFloorPoints.length > 0) {
-                const { newProjectPoints } = getProjectedPointOnLine(doorTmpSt, doorTmpEd, nearFloorPoints);
-                for (const point2 of newProjectPoints) {
-                  point2.z = doorTmpSt.z;
-                }
-                newProjectPoints.forEach((point2) => {
-                  let newPt = new THREE5.Vector3(point2.x, point2.y, doorTmpSt.z);
-                  let tmpDoorVec1 = new THREE5.Vector3().subVectors(newPt, doorTmpEd);
-                  let tmpDoorVec2 = new THREE5.Vector3().subVectors(newPt, doorTmpSt);
-                  let resP1 = isParallel(doorVector1, tmpDoorVec2);
-                  let resP2 = isParallel(doorVector2, tmpDoorVec1);
-                  if (resP1 && resP1.parallel && resP1.sameDirection) {
-                    let tmpDist = newPt.distanceTo(doorTmpSt);
-                    if (tmpDist < toDoorStNearDist) {
-                      toDoorStNearDist = tmpDist;
-                      newDoorTmpSt = newPt;
-                    }
-                  } else if (resP2 && resP2.parallel && resP2.sameDirection) {
-                    let tmpDist = newPt.distanceTo(doorTmpEd);
-                    if (tmpDist < toDoorEdNearDist) {
-                      toDoorEdNearDist = tmpDist;
-                      newDoorTmpEd = newPt;
-                    }
-                  }
-                });
-              }
-              if (!newDoorTmpSt.equals(doorTmpSt)) {
-                doorTmpSt = newDoorTmpSt;
-                beamTmpEd = new THREE5.Vector3(doorTmpSt.x, doorTmpSt.y, beamTmpEd.z);
-              }
-              if (!newDoorTmpEd.equals(doorTmpEd)) {
-                doorTmpEd = newDoorTmpEd;
-                beamTmpSt = new THREE5.Vector3(doorTmpEd.x, doorTmpEd.y, beamTmpSt.z);
-              }
-              if (nearTopPoints.length > 10) {
-                const { newOnLinePoints } = getProjectedPointOnLine(beamTmpEd, beamTmpSt, nearTopPoints);
-                for (let n = 0; n < newOnLinePoints.length; n++) {
-                  let ptCloseTmp33 = topDoorSegLine.closestPointToPoint(newOnLinePoints[n], true, tmpTarget33);
-                  let add = ptCloseTmp33.distanceTo(newOnLinePoints[n]);
-                  if (add > 0.02) {
-                    if (addHeight > add)
-                      addHeight = add;
-                  }
-                }
-                beamTmpSt.z += addHeight;
-                beamTmpEd.z += addHeight;
-                height += addHeight;
-              }
+            const expansionData = expansionLine(doorTmpSt, doorTmpEd, beamTmpSt, beamTmpEd, height, line2.originalPoints);
+            if (expansionData) {
+              doorTmpSt = expansionData.pt1;
+              doorTmpEd = expansionData.pt2;
+              beamTmpSt = expansionData.pt3;
+              beamTmpEd = expansionData.pt4;
+              height = expansionData.height;
             }
             let isOverlap = false;
             for (let m = 0; m < allDoorLines1.length; m++) {
@@ -5317,6 +5246,89 @@ var checkBeamIsReasonable = async (lines, lineReader) => {
     }
   }
 };
+var expansionLine = (doorTmpSt, doorTmpEd, beamTmpSt, beamTmpEd, height, originalPoints) => {
+  let doorVector1 = new THREE5.Vector3().subVectors(doorTmpSt, doorTmpEd);
+  let doorVector2 = new THREE5.Vector3().subVectors(doorTmpEd, doorTmpSt);
+  let toDoorStNearDist = Infinity;
+  let toDoorEdNearDist = Infinity;
+  let newDoorTmpSt = doorTmpSt.clone();
+  let newDoorTmpEd = doorTmpEd.clone();
+  const nearFloorPoints = [];
+  const nearTopPoints = [];
+  let topDoorSegLine = new THREE5.Line3(beamTmpSt, beamTmpEd);
+  let tmpTarget33 = new THREE5.Vector3();
+  let addHeight = 999999;
+  originalPoints.forEach((point2) => {
+    if (point2.z - doorTmpSt.z < height / 2 + 0.1 && point2.z - doorTmpSt.z > height / 2 - 0.1) {
+      nearFloorPoints.push(point2);
+    }
+    if (point2.z > beamTmpSt.z) {
+      let ptCloseTmp33 = topDoorSegLine.closestPointToPoint(point2, true, tmpTarget33);
+      let tmpVec1 = new THREE5.Vector3().subVectors(ptCloseTmp33, beamTmpSt);
+      let tmpVec2 = new THREE5.Vector3().subVectors(ptCloseTmp33, beamTmpEd);
+      let resP1 = isParallel(doorVector1, tmpVec2);
+      let resP2 = isParallel(doorVector2, tmpVec1);
+      if (resP1 && resP1.parallel && !resP1.sameDirection && resP2 && resP2.parallel && !resP2.sameDirection) {
+        nearTopPoints.push(point2);
+      }
+    }
+  });
+  if (nearFloorPoints.length > 0) {
+    const { newProjectPoints } = getProjectedPointOnLine(doorTmpSt, doorTmpEd, nearFloorPoints);
+    for (const point2 of newProjectPoints) {
+      point2.z = doorTmpSt.z;
+    }
+    newProjectPoints.forEach((point2) => {
+      let newPt = new THREE5.Vector3(point2.x, point2.y, doorTmpSt.z);
+      let tmpDoorVec1 = new THREE5.Vector3().subVectors(newPt, doorTmpEd);
+      let tmpDoorVec2 = new THREE5.Vector3().subVectors(newPt, doorTmpSt);
+      let resP1 = isParallel(doorVector1, tmpDoorVec2);
+      let resP2 = isParallel(doorVector2, tmpDoorVec1);
+      if (resP1 && resP1.parallel && resP1.sameDirection) {
+        let tmpDist = newPt.distanceTo(doorTmpSt);
+        if (tmpDist < toDoorStNearDist) {
+          toDoorStNearDist = tmpDist;
+          newDoorTmpSt = newPt;
+        }
+      } else if (resP2 && resP2.parallel && resP2.sameDirection) {
+        let tmpDist = newPt.distanceTo(doorTmpEd);
+        if (tmpDist < toDoorEdNearDist) {
+          toDoorEdNearDist = tmpDist;
+          newDoorTmpEd = newPt;
+        }
+      }
+    });
+  }
+  if (!newDoorTmpSt.equals(doorTmpSt)) {
+    doorTmpSt = newDoorTmpSt;
+    beamTmpEd = new THREE5.Vector3(doorTmpSt.x, doorTmpSt.y, beamTmpEd.z);
+  }
+  if (!newDoorTmpEd.equals(doorTmpEd)) {
+    doorTmpEd = newDoorTmpEd;
+    beamTmpSt = new THREE5.Vector3(doorTmpEd.x, doorTmpEd.y, beamTmpSt.z);
+  }
+  if (nearTopPoints.length > 10) {
+    const { newOnLinePoints } = getProjectedPointOnLine(beamTmpEd, beamTmpSt, nearTopPoints);
+    for (let n = 0; n < newOnLinePoints.length; n++) {
+      let ptCloseTmp33 = topDoorSegLine.closestPointToPoint(newOnLinePoints[n], true, tmpTarget33);
+      let add = ptCloseTmp33.distanceTo(newOnLinePoints[n]);
+      if (add > 0.02) {
+        if (addHeight > add)
+          addHeight = add;
+      }
+    }
+    beamTmpSt.z += addHeight;
+    beamTmpEd.z += addHeight;
+    height += addHeight;
+  }
+  return {
+    pt1: doorTmpSt,
+    pt2: doorTmpEd,
+    pt3: beamTmpSt,
+    pt4: beamTmpEd,
+    height
+  };
+};
 
 // src/geometry/colLine.mjs
 import * as THREE6 from "three";
@@ -10829,83 +10841,686 @@ var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   return slabDatas;
 };
 
-// src/wall-window-matcher/utils.ts
-function dist2D(a, b) {
-  const dx = a.x - b.x;
-  const dy = a.y - b.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-function analyzeQuad(corners) {
-  let maxLen = 0;
-  let dirX = 0;
-  let dirY = 0;
-  for (let i = 0; i < 4; i++) {
-    const a = corners[i];
-    const b = corners[(i + 1) % 4];
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const len = Math.sqrt(dx * dx + dy * dy);
-    if (len > maxLen) {
-      maxLen = len;
-      dirX = dx / len;
-      dirY = dy / len;
+// src/geometry/window.mjs
+import * as THREE10 from "three";
+import { mergeGeometries as mergeGeometries5 } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+var getWindowData = async (lines, pcdData) => {
+  if (lines.length <= 0 || !pcdData)
+    return lines;
+  if (!pcdData) pcdData = [];
+  for (let line2 of lines) {
+    let allRegion = [];
+    if (!line2.checkResults || line2.checkResults.length <= 0)
+      continue;
+    for (let r = 0; r < line2.checkResults.length; r++) {
+      let find = function(i) {
+        while (parent[i] !== i) {
+          parent[i] = parent[parent[i]];
+          i = parent[i];
+        }
+        return i;
+      };
+      const result = line2.checkResults[r];
+      if (!result.originalVertices || result.originalVertices.length == 0)
+        continue;
+      const verts = [];
+      result.originalVertices.forEach((pts) => {
+        let ptsTmp = [];
+        pts.forEach((pt) => {
+          ptsTmp.push(new THREE10.Vector3(pt.x, pt.y, pt.z));
+        });
+        verts.push(ptsTmp);
+      });
+      const n = verts.length;
+      const parent = Array.from({ length: n }, (_, i) => i);
+      for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+          const qi = verts[i], qj = verts[j];
+          const touches = qi.some((pi) => qj.some((pj) => pi.equals(pj)));
+          if (touches) {
+            const ri = find(i), rj = find(j);
+            if (ri !== rj) parent[ri] = rj;
+          }
+        }
+      }
+      const groups = /* @__PURE__ */ new Map();
+      let gridWidth = -1;
+      let gridHeight = -1;
+      for (let i = 0; i < n; i++) {
+        const root = find(i);
+        if (!groups.has(root)) groups.set(root, {
+          points: [],
+          area: 0,
+          // originalVertices: [],
+          index: -1,
+          gridWidth: -1,
+          gridHeight: -1,
+          centerPts: [],
+          facePoints: [],
+          boxArea: -1,
+          totalInPlaneNum: -1
+        });
+        const group = groups.get(root);
+        let [pt0, pt1, pt2, pt3] = verts[i];
+        const center = new THREE10.Vector3().add(pt0).add(pt1).add(pt2).add(pt3).multiplyScalar(0.25);
+        group.points.push(...verts[i]);
+        group.area += pt0.distanceTo(pt1) * pt0.distanceTo(pt3);
+        group.index = r;
+        group.centerPts.push(center);
+        if (gridWidth == -1 || gridHeight == -1) {
+          let vecTmp = new THREE10.Vector3().subVectors(pt0, pt1).normalize();
+          gridHeight = pt0.distanceTo(pt3);
+          gridWidth = pt0.distanceTo(pt1);
+          let isP = isParallel(vecTmp, new THREE10.Vector3(0, 0, 1));
+          if (isP && isP.parallel) {
+            [gridHeight, gridWidth] = [gridWidth, gridHeight];
+          }
+        }
+        group.gridWidth = gridWidth;
+        group.gridHeight = gridHeight;
+      }
+      const val = groups.values();
+      for (const val2 of groups.values()) {
+        const { facePoints, boxArea, totalInPlaneNum } = getPointCloudData(
+          val2.points,
+          val2.gridWidth,
+          val2.gridHeight,
+          val2.centerPts
+        );
+        val2.centerPts = null;
+        val2.facePoints = facePoints;
+        val2.boxArea = boxArea;
+        val2.totalInPlaneNum = totalInPlaneNum;
+      }
+      allRegion.push(...val);
     }
+    line2.mergeCheckRegion = allRegion;
   }
-  return { longSide: maxLen, dirX, dirY };
-}
-function computeLocalFloorZ(walls, cx, cy) {
-  const radius = 3;
-  const zs = [];
-  for (const w of walls) {
-    const mx = (w.start.x + w.end.x) / 2;
-    const my = (w.start.y + w.end.y) / 2;
-    const dx = mx - cx;
-    const dy = my - cy;
-    if (dx * dx + dy * dy <= radius * radius) {
-      zs.push(w.start.z, w.end.z);
+  const windowDatas = [];
+  for (let i = 0; i < pcdData.length; i++) {
+    const window = pcdData[i];
+    window.isFindBeam = false;
+    if (window.category == "window") {
+      let boxPoints = [];
+      window.coordinatesByArea.coordinates.forEach((p) => {
+        boxPoints.push(new THREE10.Vector3(p.x, p.y, p.z));
+      });
+      if (boxPoints[0].equals(boxPoints[boxPoints.length - 1]))
+        boxPoints.pop();
+      let length2 = boxPoints[0].distanceTo(boxPoints[1]);
+      let width = boxPoints[0].distanceTo(boxPoints[3]);
+      if (width > length2) {
+        [length2, width] = [width, length2];
+        boxPoints = [boxPoints[0], boxPoints[3], boxPoints[2], boxPoints[1]];
+      }
+      if (length2 < 0.3)
+        continue;
+      let windowStartPt = getMid(boxPoints[0], boxPoints[3], true);
+      let windowEndPt = getMid(boxPoints[1], boxPoints[2], true);
+      windowDatas.push({
+        windowStartPt,
+        windowEndPt,
+        boxPoints,
+        minZ: window.coordinatesByArea.heightData.minZ,
+        maxZ: window.coordinatesByArea.heightData.maxZ,
+        index: i,
+        isFind: false,
+        inWall: false,
+        //是否在墙内
+        name: window.name
+      });
     }
   }
-  if (zs.length === 0) {
-    const allZ = [];
-    for (const w of walls) allZ.push(w.start.z, w.end.z);
-    if (!allZ.length) return -Infinity;
-    allZ.sort((a, b) => a - b);
-    return allZ[Math.floor(allZ.length / 2)];
-  }
-  zs.sort((a, b) => a - b);
-  return zs[Math.floor(zs.length / 2)];
-}
-function pointToSegmentDist(cx, cy, ax, ay, bx, by) {
-  const vx = bx - ax;
-  const vy = by - ay;
-  const len2 = vx * vx + vy * vy;
-  if (len2 < 1e-12) {
-    return { dist: Math.sqrt((cx - ax) ** 2 + (cy - ay) ** 2), t: 0 };
-  }
-  const wx = cx - ax;
-  const wy = cy - ay;
-  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 };
-}
-function pointInQuad(px, py, quad) {
-  let sign = 0;
-  for (let i = 0; i < 4; i++) {
-    const a = quad[i];
-    const b = quad[(i + 1) % 4];
-    const cross3 = (b.x - a.x) * (py - a.y) - (b.y - a.y) * (px - a.x);
-    if (Math.abs(cross3) < 1e-12) continue;
-    const s = cross3 > 0 ? 1 : -1;
-    if (sign === 0) sign = s;
-    else if (sign !== s) return false;
-  }
-  return true;
-}
-function segSegIntersect(ax, ay, bx, by, cx, cy, dx, dy) {
-  const rX = bx - ax;
-  const rY = by - ay;
+  let id = 0;
+  let doorBeamDataIndex = [];
+  let findDoorIndexs = [];
+  let allDoorLines1 = [];
+  let nearDist = 0.25;
+  for (let index = 0; index < lines.length; index++) {
+    let line2 = lines[index];
+    if (line2.noDetection) continue;
+    if (!line2.doorAndBeamData)
+      line2.doorAndBeamData = [];
+    if (!line2.doorAndBeamIdToCheckResults)
+      line2.doorAndBeamIdToCheckResults = [];
+    if (!line2.mergeCheckRegion || line2.mergeCheckRegion.length == 0)
+      continue;
+    line2.completePointAreaPercentage = -1;
+    let box = new THREE10.Box3();
+    box.setFromPoints(line2.originalPoints);
+    let maxZ = box.max.z;
+    let minZ = box.min.z;
+    const lineStart = new THREE10.Vector3(line2.start.x, line2.start.y, line2.start.z);
+    const lineEnd = new THREE10.Vector3(line2.end.x, line2.end.y, line2.end.z);
+    let floorHeightTmp = line2.rooftopPz - line2.start.z;
+    let totalArea = 0;
+    for (const region of line2.mergeCheckRegion) {
+      const facePoints = region.facePoints;
+      const boxArea = region.boxArea;
+      const totalInPlaneNum = region.totalInPlaneNum;
+      if (!facePoints || facePoints.length <= 0)
+        continue;
+      let regionLength = facePoints[0].distanceTo(facePoints[1]);
+      let regionHeight = facePoints[0].distanceTo(facePoints[3]);
+      const centerHeight = region.gridHeight * (regionHeight / region.gridHeight / 3 * 2) + region.gridHeight / 2;
+      let linePt1 = new THREE10.Vector3(facePoints[0].x, facePoints[0].y, facePoints[0].z + centerHeight);
+      let linePt2 = new THREE10.Vector3(facePoints[1].x, facePoints[1].y, facePoints[1].z + centerHeight);
+      const centerLine = new THREE10.Line3(linePt1, linePt2);
+      const inLinePts = [];
+      let tmpTargetPt = new THREE10.Vector3();
+      region.points.forEach((pt) => {
+        const tmpClosePt = centerLine.closestPointToPoint(pt, true, tmpTargetPt);
+        if (tmpClosePt.distanceTo(pt) < region.gridHeight + 0.01) {
+          inLinePts.push(pt);
+        }
+      });
+      let lineGroup = [];
+      let isFindPtIndex = [];
+      while (true) {
+        let tmpLine = [];
+        for (let e = 0; e < inLinePts.length; e++) {
+          if (isFindPtIndex.includes(e))
+            continue;
+          if (tmpLine.length == 0) {
+            tmpLine.push(inLinePts[e]);
+            isFindPtIndex.push(e);
+          }
+        }
+        for (let c = 0; c < inLinePts.length; c++) {
+          if (isFindPtIndex.includes(c))
+            continue;
+          for (let e = 0; e < tmpLine.length; e++) {
+            if (inLinePts[c].distanceTo(tmpLine[e]) < region.gridWidth + 0.01) {
+              tmpLine.push(inLinePts[c]);
+              isFindPtIndex.push(c);
+              c = -1;
+              break;
+            }
+          }
+        }
+        if (tmpLine.length == 0)
+          break;
+        lineGroup.push(tmpLine);
+      }
+      const regionData = [];
+      for (let e = 0; e < lineGroup.length; e++) {
+        const obj = {
+          lineSt: new THREE10.Vector3(),
+          lineEd: new THREE10.Vector3(),
+          facePoints: []
+        };
+        let resPts = getFarthestPoints(lineGroup[e]);
+        if (Array.isArray(resPts) && resPts.length == 2) {
+          obj.lineSt = resPts[0];
+          obj.lineEd = resPts[1];
+          obj.facePoints.push(new THREE10.Vector3(resPts[0].x, resPts[0].y, facePoints[0].z));
+          obj.facePoints.push(new THREE10.Vector3(resPts[1].x, resPts[1].y, facePoints[0].z));
+          obj.facePoints.push(new THREE10.Vector3(resPts[1].x, resPts[1].y, facePoints[2].z));
+          obj.facePoints.push(new THREE10.Vector3(resPts[0].x, resPts[0].y, facePoints[2].z));
+          regionData.push(obj);
+        }
+      }
+      totalArea += region.area;
+      let cutRegionArea = 0;
+      if (totalInPlaneNum != 0) {
+        cutRegionArea = region.gridHeight * region.gridWidth * totalInPlaneNum;
+      }
+      let areaPercentage = (region.area - cutRegionArea) / boxArea * 100;
+      if (areaPercentage > 70 && regionData.length == 1 || regionData.length > 1) {
+        for (let w = 0; w < regionData.length; w++) {
+          const tmpRegion = regionData[w];
+          let length2 = tmpRegion.facePoints[0].distanceTo(tmpRegion.facePoints[1]);
+          let height = tmpRegion.facePoints[0].distanceTo(tmpRegion.facePoints[3]);
+          let lengthPercentage = length2 / line2.length * 100;
+          if (length2 < 0.2 || height < 0.2)
+            continue;
+          let addData = false;
+          let isWindow = false;
+          let beforePcdDoorIsFindBeam = false;
+          let doorOpenVector = new THREE10.Vector3(0, 0, 0);
+          let pcbDoorIndexs = [];
+          let beamTmpSt = tmpRegion.facePoints[2].clone();
+          let beamTmpEd = tmpRegion.facePoints[3].clone();
+          let doorTmpSt = tmpRegion.facePoints[0].clone();
+          let doorTmpEd = tmpRegion.facePoints[1].clone();
+          let findDoorDataIndex = -1;
+          if (Math.abs(tmpRegion.facePoints[0].z - line2.start.z) > 0.25 || Math.abs(tmpRegion.facePoints[0].z - line2.start.z) < 0.25 && height > 1) {
+            const { newOriginalPoints } = getProjectedPointOnLine(doorTmpSt, doorTmpEd, line2.originalPoints);
+            const topPoints = [];
+            const bottomPoints = [];
+            newOriginalPoints.forEach((p) => {
+              if (p.z >= beamTmpSt.z)
+                topPoints.push(p);
+              else if (p.z <= doorTmpSt.z)
+                bottomPoints.push(p);
+            });
+            let tmpBeamHeight = line2.rooftopPz - beamTmpSt.z;
+            let otherBeamTmpSt = beamTmpSt.clone();
+            otherBeamTmpSt.z += tmpBeamHeight;
+            let tmpBeamLen = beamTmpSt.distanceTo(beamTmpEd);
+            let tmpBeamVec = new THREE10.Vector3().subVectors(beamTmpEd, beamTmpSt).normalize();
+            let cutNum = Math.round(Math.max(5, Math.min(350, 10 * Math.sqrt(tmpBeamLen))));
+            let addCutLen = tmpBeamLen / cutNum;
+            if (length2 > 0.2) {
+              if (!line2.isLine2) {
+                if (length2 < 3.5) {
+                  for (let n = 0; n < windowDatas.length; n++) {
+                    if (windowDatas[n].isFind) continue;
+                    let doorSt = new THREE10.Vector3(windowDatas[n].windowStartPt.x, windowDatas[n].windowStartPt.y, 0);
+                    let doorEd = new THREE10.Vector3(windowDatas[n].windowEndPt.x, windowDatas[n].windowEndPt.y, 0);
+                    let beamSt = new THREE10.Vector3(tmpRegion.facePoints[0].x, tmpRegion.facePoints[0].y, 0);
+                    let beamEd = new THREE10.Vector3(tmpRegion.facePoints[1].x, tmpRegion.facePoints[1].y, 0);
+                    let bIsTrue = tmpRegion.facePoints[2].z < windowDatas[n].maxZ || Math.abs(tmpRegion.facePoints[2].z - windowDatas[n].maxZ) < 0.3;
+                    let bIsSoTall = Math.abs(tmpRegion.facePoints[2].z - windowDatas[n].maxZ) > 0.2;
+                    if (bIsTrue) {
+                      let result = classifySegments(doorSt.clone(), doorEd.clone(), beamSt.clone(), beamEd.clone(), {
+                        distanceThreshold: 2
+                      });
+                      if (result && result.type == "collinear_gap") {
+                        let ptCenter = getMid(doorSt, doorEd);
+                        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 dist1 = beamSt.distanceTo(doorSt);
+                          let dist22 = beamEd.distanceTo(doorSt);
+                          if (dist1 > 0.25 && dist22 > 0.25) {
+                            let dist32 = beamSt.distanceTo(doorEd);
+                            let dist4 = beamEd.distanceTo(doorEd);
+                            if (dist32 > 0.2 && dist4 > 0.2) {
+                              continue;
+                            }
+                          }
+                          isWindow = true;
+                          pcbDoorIndexs.push(windowDatas[n].index);
+                          windowDatas[n].isFind = true;
+                          findDoorDataIndex = n;
+                          beforePcdDoorIsFindBeam = pcdData[windowDatas[n].index].isFindBeam;
+                          pcdData[windowDatas[n].index].isFindBeam = true;
+                          let beamVec = new THREE10.Vector3().subVectors(beamSt, beamEd).normalize();
+                          let doorLength = doorSt.distanceTo(doorEd) - result.overlap;
+                          if (dist22 < dist1)
+                            beamVec.negate();
+                          if (dist1 > dist22) {
+                            beamTmpSt = tmpRegion.facePoints[2].clone().addScaledVector(beamVec, doorLength);
+                            beamTmpEd = tmpRegion.facePoints[3].clone();
+                            doorTmpSt = beamTmpEd.clone();
+                            doorTmpEd = beamTmpSt.clone();
+                            doorTmpSt.z = doorTmpEd.z = tmpRegion.facePoints[0].z;
+                          } else {
+                            beamTmpSt = tmpRegion.facePoints[2].clone();
+                            beamTmpEd = tmpRegion.facePoints[3].clone().addScaledVector(beamVec, doorLength);
+                            doorTmpSt = beamTmpEd.clone();
+                            doorTmpEd = beamTmpSt.clone();
+                            doorTmpSt.z = doorTmpEd.z = tmpRegion.facePoints[0].z;
+                          }
+                        }
+                      } else if (result && result.type == "collinear_overlap" && result.maxPerpendicularDistance < 0.35) {
+                        let distTmp1 = beamSt.distanceTo(beamEd);
+                        let distTmp2 = doorEd.distanceTo(doorSt);
+                        if (Math.abs(distTmp1 - result.overlap) < 0.25 || Math.abs(distTmp2 - result.overlap) < 0.25) {
+                          if (length2 > 0.3) {
+                            isWindow = true;
+                            pcbDoorIndexs.push(windowDatas[n].index);
+                            windowDatas[n].isFind = true;
+                            beforePcdDoorIsFindBeam = pcdData[windowDatas[n].index].isFindBeam;
+                            pcdData[windowDatas[n].index].isFindBeam = true;
+                            findDoorDataIndex = n;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                if (length2 < 1.5) {
+                  for (let n = 0; n < windowDatas.length; n++) {
+                    if (windowDatas[n].inWall || windowDatas[n].isFind) continue;
+                    let doorSt = new THREE10.Vector3(windowDatas[n].windowStartPt.x, windowDatas[n].windowStartPt.y, 0);
+                    let doorEd = new THREE10.Vector3(windowDatas[n].windowEndPt.x, windowDatas[n].windowEndPt.y, 0);
+                    let beamSt = new THREE10.Vector3(beamTmpEd.x, beamTmpEd.y, 0);
+                    let beamEd = new THREE10.Vector3(beamTmpSt.x, beamTmpSt.y, 0);
+                    let vec1 = new THREE10.Vector3().subVectors(doorSt, doorEd).normalize();
+                    let vec2 = new THREE10.Vector3().subVectors(beamSt, beamEd).normalize();
+                    let nExtend = 0.25;
+                    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 isPPP = getParallelism(doorStExtended, doorEdExtended, beamStExtended, beamEdExtended);
+                    if (isPPP.isParallel)
+                      continue;
+                    let insertPt = segmentsIntersect2D(doorStExtended, doorEdExtended, beamStExtended, beamEdExtended);
+                    let bIsTrue = true;
+                    let dist11 = doorSt.distanceTo(beamSt);
+                    let dist22 = doorSt.distanceTo(beamEd);
+                    let dist33 = doorEd.distanceTo(beamSt);
+                    let dist44 = doorEd.distanceTo(beamEd);
+                    let isNear = dist11 < nearDist || dist22 < nearDist || dist33 < nearDist || dist44 < nearDist;
+                    if ((isNear || insertPt) && bIsTrue) {
+                      beforePcdDoorIsFindBeam = pcdData[windowDatas[n].index].isFindBeam;
+                      pcdData[windowDatas[n].index].isFindBeam = true;
+                      isWindow = true;
+                      windowDatas[n].isFind = true;
+                      findDoorDataIndex = n;
+                    }
+                  }
+                }
+              }
+              if (isWindow) {
+                addData = true;
+              }
+            }
+          }
+          if (addData) {
+            if (true) {
+              let doorVector1 = new THREE10.Vector3().subVectors(doorTmpSt, doorTmpEd);
+              let doorVector2 = new THREE10.Vector3().subVectors(doorTmpEd, doorTmpSt);
+              let toDoorStNearDist = Infinity;
+              let toDoorEdNearDist = Infinity;
+              let newDoorTmpSt = doorTmpSt.clone();
+              let newDoorTmpEd = doorTmpEd.clone();
+              const nearFloorPoints = [];
+              const nearTopPoints = [];
+              let topDoorSegLine = new THREE10.Line3(beamTmpSt, beamTmpEd);
+              let tmpTarget33 = new THREE10.Vector3();
+              let addHeight = 999999;
+              line2.originalPoints.forEach((point2) => {
+                if (point2.z - doorTmpSt.z < height / 2 + 0.1 && point2.z - doorTmpSt.z > height / 2 - 0.1) {
+                  nearFloorPoints.push(point2);
+                }
+                if (point2.z > beamTmpSt.z) {
+                  let ptCloseTmp33 = topDoorSegLine.closestPointToPoint(point2, true, tmpTarget33);
+                  let tmpVec1 = new THREE10.Vector3().subVectors(ptCloseTmp33, beamTmpSt);
+                  let tmpVec2 = new THREE10.Vector3().subVectors(ptCloseTmp33, beamTmpEd);
+                  let resP1 = isParallel(doorVector1, tmpVec2);
+                  let resP2 = isParallel(doorVector2, tmpVec1);
+                  if (resP1 && resP1.parallel && !resP1.sameDirection && resP2 && resP2.parallel && !resP2.sameDirection) {
+                    nearTopPoints.push(point2);
+                  }
+                }
+              });
+              if (nearFloorPoints.length > 0) {
+                const { newProjectPoints } = getProjectedPointOnLine(doorTmpSt, doorTmpEd, nearFloorPoints);
+                for (const point2 of newProjectPoints) {
+                  point2.z = doorTmpSt.z;
+                }
+                newProjectPoints.forEach((point2) => {
+                  let newPt = new THREE10.Vector3(point2.x, point2.y, doorTmpSt.z);
+                  let tmpDoorVec1 = new THREE10.Vector3().subVectors(newPt, doorTmpEd);
+                  let tmpDoorVec2 = new THREE10.Vector3().subVectors(newPt, doorTmpSt);
+                  let resP1 = isParallel(doorVector1, tmpDoorVec2);
+                  let resP2 = isParallel(doorVector2, tmpDoorVec1);
+                  if (resP1 && resP1.parallel && resP1.sameDirection) {
+                    let tmpDist = newPt.distanceTo(doorTmpSt);
+                    if (tmpDist < toDoorStNearDist) {
+                      toDoorStNearDist = tmpDist;
+                      newDoorTmpSt = newPt;
+                    }
+                  } else if (resP2 && resP2.parallel && resP2.sameDirection) {
+                    let tmpDist = newPt.distanceTo(doorTmpEd);
+                    if (tmpDist < toDoorEdNearDist) {
+                      toDoorEdNearDist = tmpDist;
+                      newDoorTmpEd = newPt;
+                    }
+                  }
+                });
+              }
+              if (!newDoorTmpSt.equals(doorTmpSt)) {
+                doorTmpSt = newDoorTmpSt;
+                beamTmpEd = new THREE10.Vector3(doorTmpSt.x, doorTmpSt.y, beamTmpEd.z);
+              }
+              if (!newDoorTmpEd.equals(doorTmpEd)) {
+                doorTmpEd = newDoorTmpEd;
+                beamTmpSt = new THREE10.Vector3(doorTmpEd.x, doorTmpEd.y, beamTmpSt.z);
+              }
+              if (nearTopPoints.length > 10) {
+                const { newOnLinePoints } = getProjectedPointOnLine(beamTmpEd, beamTmpSt, nearTopPoints);
+                for (let n = 0; n < newOnLinePoints.length; n++) {
+                  let ptCloseTmp33 = topDoorSegLine.closestPointToPoint(newOnLinePoints[n], true, tmpTarget33);
+                  let add = ptCloseTmp33.distanceTo(newOnLinePoints[n]);
+                  if (add > 0.02) {
+                    if (addHeight > add)
+                      addHeight = add;
+                  }
+                }
+                beamTmpSt.z += addHeight;
+                beamTmpEd.z += addHeight;
+                height += addHeight;
+              }
+            }
+            let isOverlap = false;
+            for (let m = 0; m < allDoorLines1.length; m++) {
+              let result = classifySegments(allDoorLines1[m].start, allDoorLines1[m].end, doorTmpSt, doorTmpEd);
+              if (result && result.type == "collinear_overlap" && result.maxPerpendicularDistance < 0.07) {
+                isOverlap = true;
+              }
+            }
+            if (isOverlap) {
+              if (findDoorDataIndex != -1) {
+                if (!beforePcdDoorIsFindBeam) {
+                  pcdData[windowDatas[findDoorDataIndex].index].isFindBeam = false;
+                  windowDatas[findDoorDataIndex].isFind = false;
+                }
+              }
+              continue;
+            }
+            let afterDoorLen = doorTmpEd.distanceTo(doorTmpSt);
+            if (afterDoorLen < 0.4 && !isWindow || afterDoorLen < 0.3 && isWindow)
+              continue;
+            const windowLine = new THREE10.Line3(new THREE10.Vector3(doorTmpSt.x, doorTmpSt.y, 0), new THREE10.Vector3(doorTmpEd.x, doorTmpEd.y, 0));
+            const windowPcd = windowDatas[findDoorDataIndex];
+            const windowPcdSt = windowPcd.windowStartPt.clone();
+            const windowPcdEd = windowPcd.windowEndPt.clone();
+            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 windowLen = windowPcdSt.distanceTo(windowPcdEd);
+            let wZ = doorTmpSt.z;
+            let ptClose = new THREE10.Vector3();
+            let vec2 = new THREE10.Vector3();
+            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();
+            }
+            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 beamHeight = beamTmpSt.z - doorTmpSt.z;
+            let doorAndBeamDataObj = {
+              id,
+              windowTopSt: new THREE10.Vector3(doorTmpSt.x, doorTmpSt.y, doorTmpSt.z + beamHeight),
+              windowTopEd: new THREE10.Vector3(doorTmpEd.x, doorTmpEd.y, doorTmpEd.z + beamHeight),
+              beamHeight,
+              windowBottomSt: doorTmpSt,
+              windowBottomEd: doorTmpEd,
+              // nearId: -1,
+              // type: isExtendBeam ? "extendBeam" : "doorBeam",
+              type: "window",
+              isWindow,
+              pcbDoorIndexs,
+              groundClearance
+            };
+            line2.doorAndBeamIdToCheckResults.push([region.index, id]);
+            line2.doorAndBeamData.push(doorAndBeamDataObj);
+            doorBeamDataIndex.push({
+              linesIndex: index,
+              doorIndex: line2.doorAndBeamData.length - 1
+            });
+            allDoorLines1.push({
+              start: doorTmpSt,
+              end: doorTmpEd,
+              index,
+              id: doorAndBeamDataObj.id
+            });
+            if (!findDoorIndexs.includes(index))
+              findDoorIndexs.push(index);
+            id++;
+          }
+        }
+      }
+    }
+    let faceArea = line2.length * (line2.rooftopPz - line2.start.z);
+    line2.completePointAreaPercentage = totalArea / faceArea * 100;
+  }
+  if (findDoorIndexs.length > 1) {
+    for (let j = 0; j < findDoorIndexs.length; j++) {
+      let savedata2 = [];
+      for (let d = 0; d < lines[findDoorIndexs[j]].doorAndBeamData.length; d++) {
+        if (lines[findDoorIndexs[j]].doorAndBeamData[d].type != "window")
+          continue;
+        let isDel = false;
+        if (!isDel) {
+          let doorSt1 = lines[findDoorIndexs[j]].doorAndBeamData[d].windowBottomSt.clone();
+          let doorEd1 = lines[findDoorIndexs[j]].doorAndBeamData[d].windowBottomEd.clone();
+          doorSt1.z = doorEd1.z = 0;
+          let doorLen1 = doorSt1.distanceTo(doorEd1);
+          for (let b = 0; b < findDoorIndexs.length; b++) {
+            if (j == b) continue;
+            for (let r = 0; r < lines[findDoorIndexs[b]].doorAndBeamData.length; r++) {
+              if (lines[findDoorIndexs[b]].doorAndBeamData[r].type != "window")
+                continue;
+              let doorSt2 = lines[findDoorIndexs[b]].doorAndBeamData[r].windowBottomSt.clone();
+              let doorEd2 = lines[findDoorIndexs[b]].doorAndBeamData[r].windowBottomEd.clone();
+              doorSt2.z = doorEd2.z = 0;
+              let doorLen2 = doorSt2.distanceTo(doorEd2);
+              let resultTmp = classifySegments(doorSt1, doorEd1, doorSt2, doorEd2);
+              if (resultTmp.type == "collinear_overlap" && resultTmp.maxPerpendicularDistance < 0.2) {
+                let line3 = new THREE10.Line3(doorSt2, doorEd2);
+                let ptMid = getMid(doorSt1, doorEd1);
+                let ptClose = line3.closestPointToPoint(ptMid, true, new THREE10.Vector3());
+                let distTmp = ptMid.distanceTo(ptClose);
+                if (Math.abs(doorLen1 - resultTmp.overlap) < 0.1 && distTmp < 0.04) {
+                  if (lines[findDoorIndexs[b]].doorAndBeamData[r].nearId == lines[findDoorIndexs[j]].doorAndBeamData[d].id) {
+                    lines[findDoorIndexs[b]].doorAndBeamData[r].nearId = -1;
+                  }
+                  isDel = true;
+                  break;
+                }
+              }
+            }
+          }
+        }
+        if (isDel) {
+          for (let z = 0; z < lines[findDoorIndexs[j]].doorAndBeamIdToCheckResults.length; z++) {
+            if (lines[findDoorIndexs[j]].doorAndBeamIdToCheckResults[1] == lines[findDoorIndexs[j]].doorAndBeamData[d].id) {
+              lines[findDoorIndexs[j]].doorAndBeamIdToCheckResults.splice(z, 1);
+              break;
+            }
+          }
+        }
+        if (!isDel) savedata2.push(lines[findDoorIndexs[j]].doorAndBeamData[d]);
+      }
+      if (savedata2.length != lines[findDoorIndexs[j]].doorAndBeamData.length)
+        lines[findDoorIndexs[j]].doorAndBeamData = savedata2;
+    }
+  }
+  let tmpLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!lines[i].isLine2)
+      tmpLines.push(lines[i]);
+    if (lines[i].isLine2 && lines[i].doorAndBeamData.length != 0)
+      tmpLines.push(lines[i]);
+  }
+  lines.length = 0;
+  lines.push(...tmpLines);
+  return { lines, pcdData };
+};
+
+// src/wall-window-matcher/utils.ts
+function dist2D(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function analyzeQuad(corners) {
+  let maxLen = 0;
+  let dirX = 0;
+  let dirY = 0;
+  for (let i = 0; i < 4; i++) {
+    const a = corners[i];
+    const b = corners[(i + 1) % 4];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len > maxLen) {
+      maxLen = len;
+      dirX = dx / len;
+      dirY = dy / len;
+    }
+  }
+  return { longSide: maxLen, dirX, dirY };
+}
+function computeLocalFloorZ(walls, cx, cy) {
+  const radius = 3;
+  const zs = [];
+  for (const w of walls) {
+    const mx = (w.start.x + w.end.x) / 2;
+    const my = (w.start.y + w.end.y) / 2;
+    const dx = mx - cx;
+    const dy = my - cy;
+    if (dx * dx + dy * dy <= radius * radius) {
+      zs.push(w.start.z, w.end.z);
+    }
+  }
+  if (zs.length === 0) {
+    const allZ = [];
+    for (const w of walls) allZ.push(w.start.z, w.end.z);
+    if (!allZ.length) return -Infinity;
+    allZ.sort((a, b) => a - b);
+    return allZ[Math.floor(allZ.length / 2)];
+  }
+  zs.sort((a, b) => a - b);
+  return zs[Math.floor(zs.length / 2)];
+}
+function pointToSegmentDist(cx, cy, ax, ay, bx, by) {
+  const vx = bx - ax;
+  const vy = by - ay;
+  const len2 = vx * vx + vy * vy;
+  if (len2 < 1e-12) {
+    return { dist: Math.sqrt((cx - ax) ** 2 + (cy - ay) ** 2), t: 0 };
+  }
+  const wx = cx - ax;
+  const wy = cy - ay;
+  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 };
+}
+function pointInQuad(px, py, quad) {
+  let sign = 0;
+  for (let i = 0; i < 4; i++) {
+    const a = quad[i];
+    const b = quad[(i + 1) % 4];
+    const cross3 = (b.x - a.x) * (py - a.y) - (b.y - a.y) * (px - a.x);
+    if (Math.abs(cross3) < 1e-12) continue;
+    const s = cross3 > 0 ? 1 : -1;
+    if (sign === 0) sign = s;
+    else if (sign !== s) return false;
+  }
+  return true;
+}
+function segSegIntersect(ax, ay, bx, by, cx, cy, dx, dy) {
+  const rX = bx - ax;
+  const rY = by - ay;
   const sX = dx - cx;
   const sY = dy - cy;
   const denom = rX * sY - rY * sX;
@@ -11938,6 +12553,9 @@ function processData(wallSegments, objects, options) {
   return { segments: finalSegments, matches };
 }
 
+// src/wall-door-matcher/matcher.ts
+import * as THREE11 from "three";
+
 // src/wall-door-matcher/utils.ts
 function dist2D2(a, b) {
   const dx = a.x - b.x;
@@ -12777,7 +13395,26 @@ function collectCandidates2(candidateSegments, doorLong, doorDirX, doorDirY, che
   for (const attempt of matchAttempts) {
     if (passingCandidates.length > 0) break;
     for (const seg of candidateSegments) {
-      const { start, end } = seg;
+      const { start, end, isLine2, passageEntrance } = seg;
+      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);
+        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);
+          let resultTmp = classifySegments(pt1, pt2, pt3, pt4);
+          if (resultTmp.type == "collinear_overlap" && resultTmp.maxPerpendicularDistance < 0.1) {
+            isOverLap = true;
+            break;
+          }
+        }
+        if (isOverLap)
+          continue;
+      }
       let validPoint = false;
       let minDist = Infinity;
       for (const pt of checkPoints) {
@@ -12924,8 +13561,6 @@ function mergeSourceData2(ws, srcIdxs, wallSegments) {
   if (boxData) ws.boxData = boxData;
   if (maxRooftopPz !== void 0) ws.rooftopPz = maxRooftopPz;
 }
-function logDrawDoorSummary(mergedSegments) {
-}
 function detectPerpendicularWalls2(match, mergedSegments, angleTol = 10, distTol = 0.2, perpDistTol = 0.2) {
   const results = [];
   if (!match.DrawDoor) return results;
@@ -13123,16 +13758,6 @@ function findDoorWalls(doorObjs, wallSegments, options, preMerged) {
     const checkPoints = getCheckPoints2(corners, centerX, centerY);
     debugScanDoor(door.name, candidateSegments, centerX, centerY, checkPoints, doorLong, doorDirX, doorDirY, opts);
     let passingCandidates = collectCandidates2(candidateSegments, actualDoorWidth, doorDirX, doorDirY, checkPoints, opts, door.name, verticalEdges, door.nline);
-    if (passingCandidates.length > 0) {
-      for (let ci = 0; ci < passingCandidates.length; ci++) {
-        const pc = passingCandidates[ci];
-        const seg = pc.seg;
-        const hasHinge = !!pc.hingeInfo?.hingePoint;
-        const isClosed = pc.hingeInfo?.isClosed;
-        const hDist = pc.hingeInfo?.hingeDist ?? -1;
-        const centerProj = pointToSegmentDist2(checkPoints[0].x, checkPoints[0].y, seg.start.x, seg.start.y, seg.end.x, seg.end.y);
-      }
-    }
     passingCandidates = rankCandidates2(passingCandidates, checkPoints, wallSegments, door.name);
     if (passingCandidates.length === 0) {
       for (const seg of candidateSegments) {
@@ -13221,9 +13846,6 @@ function findDoorWalls(doorObjs, wallSegments, options, preMerged) {
               };
             }
           }
-          if (door.name.includes("door_002")) {
-            window.__doorLog = true;
-          }
           ;
           pc.densityScore = densityScore.score;
           pc.densityOverlap = densityScore.bestOverlap;
@@ -13242,19 +13864,6 @@ function findDoorWalls(doorObjs, wallSegments, options, preMerged) {
         pc.densityScore = -1;
       }
     }
-    if (door.name.includes("door_002")) {
-      for (let pi = 0; pi < passingCandidates.length; pi++) {
-        const pc = passingCandidates[pi];
-        const s = pc.seg;
-        const segIdx = candidateSegments.findIndex(
-          (cs) => Math.abs(cs.start.x - s.start.x) < 1e-3 && Math.abs(cs.start.y - s.start.y) < 1e-3 && Math.abs(cs.end.x - s.end.x) < 1e-3 && Math.abs(cs.end.y - s.end.y) < 1e-3
-        );
-        const origIndices = segIdx >= 0 ? mergeSourceMap[segIdx] || [] : [];
-        for (const oi of origIndices) {
-          const orig = wallSegments[oi];
-        }
-      }
-    }
     passingCandidates.sort((a, b) => {
       const da2 = a.densityScore >= 0 ? a.densityScore : -Infinity;
       const db = b.densityScore >= 0 ? b.densityScore : -Infinity;
@@ -13271,14 +13880,6 @@ function findDoorWalls(doorObjs, wallSegments, options, preMerged) {
       if (ha !== hb) return hb - ha;
       return a.minDist - b.minDist;
     });
-    if (passingCandidates.length > 0) {
-      for (let ci = 0; ci < passingCandidates.length; ci++) {
-        const pc = passingCandidates[ci];
-        const s = pc.seg;
-        const ratio = pc.ratio || s.length / doorWidth;
-        const ratioDiff = Math.abs(ratio - 1);
-      }
-    }
     let bestSeg = null;
     let bestDist = Infinity;
     let bestRatio = 0;
@@ -13400,7 +14001,6 @@ function findDoorWalls(doorObjs, wallSegments, options, preMerged) {
     if (!srcIdxs || srcIdxs.length <= 1) continue;
     mergeSourceData2(ws, srcIdxs, wallSegments);
   }
-  logDrawDoorSummary(mergedSegments);
   return results;
 }
 
@@ -13922,10 +14522,10 @@ function normalizeAngles(lines) {
     hist[binIdx] += len;
   }
   const smooth = new Array(bins).fill(0);
-  const window2 = 5;
+  const window = 5;
   for (let i = 0; i < bins; i++) {
     let sum2 = 0;
-    for (let j = -window2; j <= window2; j++) {
+    for (let j = -window; j <= window; j++) {
       let idx = i + j;
       if (idx < 0) idx += bins;
       if (idx >= bins) idx -= bins;
@@ -16346,10 +16946,10 @@ function normalizeAngles2(lines) {
     hist[binIdx] += len;
   }
   const smooth = new Array(bins).fill(0);
-  const window2 = 5;
+  const window = 5;
   for (let i = 0; i < bins; i++) {
     let sum2 = 0;
-    for (let j = -window2; j <= window2; j++) {
+    for (let j = -window; j <= window; j++) {
       let idx = i + j;
       if (idx < 0) idx += bins;
       if (idx >= bins) idx -= bins;
@@ -17034,6 +17634,7 @@ export {
   detectPerpWalls,
   detectPerpendicularWalls,
   drawStaircase,
+  expansionLine,
   filterFalseArcCurves,
   filterWalls,
   filterWallsHard,
@@ -17050,6 +17651,7 @@ export {
   getOneLineClusterResults,
   getSlabData,
   getStaircase,
+  getWindowData,
   isRawLineNearArc,
   logArcRawSegments,
   matchWalls,

package/package.json

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