build-dxf 0.0.17 → 0.0.19-1

package/src/build.js

@@ -12,6 +12,35 @@ function uuid() {
 }
 class EventDispatcher extends EventDispatcher$1 {
   uuid = uuid();
+  addEventListener(type, listener, option) {
+    const { once = false } = option ?? {};
+    const callBack = (event) => {
+      listener(event);
+      once && canceCallBack();
+    };
+    const canceCallBack = () => this.removeEventListener(type, callBack);
+    super.addEventListener(type, callBack);
+    return canceCallBack;
+  }
+  eventRecordStack = /* @__PURE__ */ new Map();
+  addEventRecord(name, ...cancels) {
+    if (!this.eventRecordStack.has(name)) this.eventRecordStack.set(name, []);
+    cancels.forEach((cancel) => {
+      this.eventRecordStack.get(name)?.push(cancel);
+    });
+    const add = (cancel) => {
+      this.addEventRecord(name, cancel);
+      return { add };
+    };
+    return { add };
+  }
+  canceEventRecord(name) {
+    const list = this.eventRecordStack.get(name);
+    if (list) {
+      list.forEach((cancel) => cancel());
+      this.eventRecordStack.delete(name);
+    }
+  }
 }
 class Component extends EventDispatcher {
   parent;
@@ -119,6 +148,7 @@ class Point {
   get Y() {
     return this.y;
   }
+  userData = {};
   /**
    * 
    * @param x 
@@ -333,6 +363,12 @@ class Point {
     this.x = p.x ?? 0;
     this.y = p.y ?? 0;
   }
+  toJson() {
+    return {
+      x: this.x,
+      y: this.y
+    };
+  }
   static from(arr) {
     if (Array.isArray(arr)) {
       return new Point(arr[0], arr[1]);
@@ -564,12 +600,19 @@ class Box2 {
     this.maxY *= scalar;
     return this;
   }
+  expansion(w) {
+    this.minX -= w;
+    this.minY -= w;
+    this.maxX += w;
+    this.maxY += w;
+    return this;
+  }
   /**
    * 
    * @returns 
    */
   clone() {
-    return new Box2(this.minX, this.minY, this.maxX, this.maxY);
+    return new Box2(this.minX, this.maxX, this.minY, this.maxY);
   }
   /**
    * 
@@ -617,6 +660,16 @@ class Rectangle {
       return [p.x, p.y, np.x, np.y];
     });
   }
+  createGeometry() {
+    return [
+      this.p0,
+      this.p2,
+      this.p1,
+      this.p2,
+      this.p0,
+      this.p3
+    ].flatMap((p) => [p.x, p.y, 0]);
+  }
   constructor(points) {
     if (points.length !== 4) {
       throw new Error("Rectangle must be defined by exactly 4 points");
@@ -781,6 +834,7 @@ class Rectangle {
 class LineSegment {
   points = [new Point(), new Point()];
   userData = {};
+  line;
   get center() {
     return new Point(
       this.points[0].x + (this.points[1].x - this.points[0].x) * 0.5,
@@ -937,11 +991,12 @@ class LineSegment {
     return new LineSegment(projP1, projP2);
   }
   /**
-   * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
-   * @param line 要投影的线段
+   * 计算一条线段在另一条直线上的投影
+   * @param p1 要投影的点
+   * @param clip 是否裁剪超出目标线段的部分，默认裁剪
    * @returns 投影并裁剪后的线段
    */
-  projectPoint(p1) {
+  projectPoint(p1, clip = true) {
     const [q1, q2] = this.points;
     const dir = new Point(q2.x - q1.x, q2.y - q1.y);
     if (dir.x === 0 && dir.y === 0) {
@@ -957,6 +1012,7 @@ class LineSegment {
       return new Point(projX, projY);
     };
     let projP1 = projectPoint(p1);
+    if (!clip) return projP1;
     const getT = (point) => {
       const pq = new Point(point.x - q1.x, point.y - q1.y);
       const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
@@ -1199,13 +1255,13 @@ class Dxf extends Component {
     this.originalData = data;
     this.lineSegments.length = 0;
     const zList = [];
-    this.data = data.map(({ start, end, insetionArr, isDoor = false, isWindow }, index2) => {
+    this.data = data.map(({ start, end, insetionArr, isDoor = false, isWindow, drawDoorData }, index2) => {
       zList.push(start.z ?? 0, end.z ?? 0);
       const lineSegment = new LineSegment(
         Point.from(start).mutiplyScalar(scale),
         Point.from(end).mutiplyScalar(scale)
       );
-      lineSegment.userData = { isDoor, isWindow };
+      lineSegment.userData = { isDoor, isWindow, drawDoorData };
       this.lineSegments.push(lineSegment);
       return [
         lineSegment.points[0],
@@ -1470,14 +1526,14 @@ class Dxf extends Component {
   /**
    * 将点云结构转换为Float32Array
    */
-  to3DArray(scale) {
+  to3DArray(scale, z = this.originalZAverage) {
     const array = [];
     this.wallsGroup.forEach((points) => {
       for (let i = 0; i < points.length; i++) {
         const point1 = points[i];
         const nextIndex = i === points.length - 1 ? 0 : i + 1;
         const point2 = points[nextIndex];
-        array.push(point1.X * scale, point1.Y * scale, this.originalZAverage, point2.X * scale, point2.Y * scale, this.originalZAverage);
+        array.push(point1.X * scale, point1.Y * scale, z, point2.X * scale, point2.Y * scale, z);
       }
     });
     return new Float32Array(array);
@@ -1562,6 +1618,20 @@ class Dxf extends Component {
     });
     d.addLayer("l_yellow", Drawing.ACI.YELLOW, "DOTTED");
     d.setActiveLayer("l_yellow");
+    this.lineSegments.forEach((line) => {
+      if (!line.userData.isWindow) return false;
+      if (Array.isArray(line.userData.drawDoorData)) {
+        line.userData.drawDoorData.forEach((w) => {
+          const { p, width } = w;
+          const center = Point.from(p);
+          const start = center.clone().add(line.direction().multiplyScalar(width * 0.5));
+          const end = center.clone().add(line.direction().multiplyScalar(-width * 0.5));
+          const blinds = new LineSegment(start, end);
+          drawLine(blinds.start, blinds.end);
+          blinds.expandToRectangle(this.width, "bothSides").path2D((p1, p2) => drawLine(p1, p2));
+        });
+      }
+    });
     return d.toDxfString();
   }
   /**
@@ -1644,6 +1714,10 @@ class Variable extends Component {
   currentWheel = 0;
   pointerMove = { x: 0, y: 0 };
   currentKeyUp = "";
+  currentKeyDown = "";
+  currentMouseUp = "";
+  currentMouseDown = "";
+  focus = false;
   set(key, value) {
     if (key in this) {
       const oldValue = this[key];
@@ -1695,6 +1769,7 @@ class Quadtree {
       }
     }
     this.nodes.push(node);
+    node.parent = this;
     if (this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
       this.subdivide();
       const nodes = this.nodes;
@@ -1704,11 +1779,21 @@ class Quadtree {
         if (quadrant !== -1) {
           this.children[quadrant].insert(n);
         } else {
+          n.parent = this;
           this.nodes.push(n);
         }
       }
     }
   }
+  /** 移除
+   * @param node 
+   */
+  remove(node) {
+    const index2 = node.parent?.nodes.indexOf(node);
+    if (index2 > -1) {
+      node.parent?.nodes.splice(index2, 1);
+    }
+  }
   /**
    * 获取线段所属的象限
    * @param line 线段
@@ -1915,7 +2000,9 @@ class PointVirtualGrid {
     const id = this.getGridId(point);
     if (!this.map.has(id)) this.map.set(id, /* @__PURE__ */ new Set());
     const set = this.map.get(id);
-    set?.add({ point, userData });
+    const target = { point, userData };
+    set.add(target);
+    point.userData.pointVirtualGrid = { set, target };
   }
   /**
    * 批量加入
@@ -1926,6 +2013,16 @@ class PointVirtualGrid {
       this.insert(point, userData);
     }
   }
+  /** 移除点
+   * @param point 
+   */
+  remove(point) {
+    const { set, target } = point?.userData?.pointVirtualGrid;
+    if (set) {
+      set.delete(target);
+      delete point?.userData?.pointVirtualGridMap;
+    }
+  }
   /**
    * 获取通过坐标，获取唯一网格索引
    * @param point 
@@ -2018,218 +2115,167 @@ class PointVirtualGrid {
     return list;
   }
 }
-class LineAnalysis extends Component {
-  static name = "LineAnalysis";
-  Dxf = null;
-  Variable = null;
-  lineSegmentList = [];
-  container = new THREE.Group();
-  // 误差角度
-  errorAngle = 4;
-  width = 0.4;
-  /**
-   * 
-   * @param parent 
-   */
-  onAddFromParent(parent) {
-    this.Dxf = parent.findComponentByType(Dxf);
-    this.Variable = this.parent?.findComponentByType(Variable);
-    this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this));
-    this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
-  }
-  /**
-   * 
-   * @param p1 
-   * @param p2 
-   * @param width 
-   * @returns 
-   */
-  expandLineSegment(p1, p2, width = 0.1) {
-    const normal = p2.normal(p1);
-    const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
-    const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
-    const offsetX = normal.x * width * 0.5;
-    const offsetY = normal.y * width * 0.5;
-    return {
-      points: [
-        // 第一条线
-        new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
-        new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
-        // 第二条线
-        new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
-        new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
-      ],
-      indices: [0, 1, 1, 3, 3, 2, 2, 0],
-      rectIndices: [0, 1, 3, 2, 0]
-    };
-  }
-  appendLineSegmentList = [];
-  /**
-   * 追加数据
-   * @param p1 
-   * @param p2 
-   */
-  addData(p1, p2) {
-    const dxf = this.Dxf;
-    dxf.data.push([p1.clone(), p2.clone(), [], false, dxf.data.length]);
-    this.appendLineSegmentList.push(new LineSegment(p1.clone(), p2.clone()));
-  }
-  /** 结果分析创建矩形
-   * @param result 
-   */
-  createRectangle(result) {
-    const dxf = this.Dxf;
-    const project0 = result.project, project1 = result.project2;
-    if (project0.includedAngle(project1) > 135) {
-      project1.points = [project1.points[1], project1.points[0]];
-    }
-    this.addData(project0.points[0], project1.points[0]);
-    this.addData(project0.points[1], project1.points[1]);
-    const leftHeight = project0.points[0].distance(project1.points[0]), rightHeight = project0.points[1].distance(project1.points[1]), count = Math.ceil(Math.max(leftHeight, rightHeight) / dxf.width), leftFragment = leftHeight / count, rightFragment = rightHeight / count, leftDirection = project1.points[0].direction(project0.points[0]), rightDirection = project1.points[1].direction(project0.points[1]), leftP = project0.points[0].clone(), rightP = project0.points[1].clone(), direction = rightP.direction(leftP);
-    direction.multiplyScalar(dxf.width * 0.5);
-    const _leftP = leftP.clone().add(direction), _rightP = rightP.clone().add(direction.multiplyScalar(-1)), d1 = leftP.direction(rightP), d2 = _leftP.direction(_rightP);
-    if (d1.x > 0 && d2.x < 0 || d1.x < 0 && d2.x > 0 || d1.y > 0 && d2.y < 0 || d1.y < 0 && d2.y > 0) return;
-    leftP.set(_leftP.x, _leftP.y);
-    rightP.set(_rightP.x, _rightP.y);
-    for (let i = 1; i < count; i++) {
-      const left = leftDirection.clone().multiplyScalar(leftFragment * i), right = rightDirection.clone().multiplyScalar(rightFragment * i), p1 = leftP.clone().add(left), p2 = rightP.clone().add(right);
-      this.addData(p1, p2);
-    }
-  }
+class DoorsAnalysis {
+  // 所有可查找的点位
+  possibleDoorPoints = [];
+  doorPoint = [];
+  dxf;
+  // 包含所有点的虚拟网格
   pointVirtualGrid = new PointVirtualGrid();
-  /**
-   * 构建点的虚拟网格索引
-   */
-  buildVirtualGrid() {
-    const dxf = this.Dxf;
-    const pointVirtualGrid = new PointVirtualGrid();
-    dxf.lineSegments.forEach((d, index2) => {
-      if (d.userData?.isDoor) return;
-      const [p1, p2] = [d.start, d.end];
-      pointVirtualGrid.insert(p1, { index: index2, type: "start" });
-      pointVirtualGrid.insert(p2, { index: index2, type: "end" });
+  // 只包含可查找点的虚拟网格
+  findPointVirtualGrid;
+  quadtree;
+  resultList;
+  // 已过滤门的线段
+  lineSegments;
+  doorSearchNearAngle = 110;
+  doorSearchDistance = 2;
+  doors = [];
+  lineAnalysis;
+  continueFind = true;
+  constructor(lineAnalysis) {
+    this.lineAnalysis = lineAnalysis;
+    this.dxf = lineAnalysis.Dxf;
+    this.findPointVirtualGrid = new PointVirtualGrid();
+    this.quadtree = lineAnalysis.quadtree;
+    this.resultList = lineAnalysis.resultList;
+    this.lineSegments = lineAnalysis.lineSegmentList;
+    this.dxf.doorLineSegment.length = 0;
+    this.lineSegments.forEach((line) => {
+      this.pointVirtualGrid.insert(line.start, line);
+      this.pointVirtualGrid.insert(line.end, line);
+    });
+    this.doorPoint = this.getDoorPoint();
+    if (!this.continueFind) return;
+    const excludeIndexMap = this.searchDoubleLinePoint();
+    this.addPointsExcludeRule((line, _2, pointIndex) => {
+      const index2 = this.lineSegments.indexOf(line);
+      const excludeMode = excludeIndexMap.get(index2);
+      if (typeof excludeMode === "number") {
+        return excludeMode === -1 || excludeMode === pointIndex;
+      }
+      return false;
+    });
+    this.addPointsExcludeRule((_1, point) => {
+      return !!this.doorPoint.find((p1) => p1.point.equal(point));
+    });
+    this.possibleDoorPoints = this.getPossiblePoints();
+    this.possibleDoorPoints.forEach((p) => this.findPointVirtualGrid.insert(p.point, p.line));
+    this.handle();
+  }
+  handle() {
+    this.dxf.doorLineSegment.push(...this.search(this.doorPoint, this.possibleDoorPoints, 0.5));
+    if (this.doorPoint.length < 2) this.dxf.doorLineSegment.push(...this.search(this.possibleDoorPoints, this.possibleDoorPoints, 0.6));
+  }
+  search(doorPoints, possibleDoorPoints = [], minDoorWidth = 0.6, doorSearchDistance = this.doorSearchDistance, doorSearchNearAngle = this.doorSearchNearAngle) {
+    const dxf = this.dxf;
+    const doors = this.searchNearby(doorPoints, possibleDoorPoints, doorSearchDistance, doorSearchNearAngle);
+    doors.push(
+      ...doorPoints.map((item) => {
+        const res2 = this.searchAlongDirection(item, doorSearchDistance);
+        if (res2) return {
+          start: item.point,
+          end: res2.point
+        };
+        const res3 = this.searchAlongNormalDirection(item, doorSearchDistance);
+        if (res3) return {
+          start: item.point,
+          end: res3.point
+        };
+      }).filter((i) => !!i && i.start.distance(i.end) < doorSearchDistance)
+    );
+    const doorLineSegment = [];
+    doors.forEach((p) => {
+      const line = new LineSegment(p?.start, p?.end);
+      const len = line.length();
+      if (len < minDoorWidth) return;
+      const normal = line.normal(), direction = line.direction(), step = (len - dxf.width * 2) / 2;
+      for (let i = 0; i < 3; i++) {
+        const point = line.start.clone().add(direction.clone().multiplyScalar(dxf.width + step * i));
+        const rLine = new LineSegment(
+          point,
+          point.clone().add(normal.clone().multiplyScalar(1))
+        );
+        rLine.directionMove(normal, -0.5);
+        const res = this.quadtree.queryLineSegment(rLine);
+        if (res.length) return;
+      }
+      doorLineSegment.push(line);
     });
-    this.pointVirtualGrid = pointVirtualGrid;
+    return doorLineSegment;
   }
-  quadtree;
-  /**
-   * 构建线段四叉树，快速查找，
+  /** 添加可查找点的过滤规则
+   * @param rule 
    */
-  buildQuadtree() {
-    const dxf = this.Dxf;
-    const lineSegmentList = [];
-    this.quadtree = new Quadtree(dxf.originalBox, 2);
-    dxf.lineSegments.forEach((lineSegment) => {
-      if (lineSegment.userData?.isDoor) return;
-      this.quadtree?.insert({
-        line: lineSegment,
-        userData: lineSegmentList.length
-      });
-      lineSegmentList.push(lineSegment);
-    });
-    this.lineSegmentList = lineSegmentList;
+  addPointsExcludeRule(rule) {
+    this._pointsExcludeRule.push(rule);
   }
-  resultList = [];
-  mergeWallLines = [];
-  /** 线段分析
-   * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
-   * @param data 
+  _pointsExcludeRule = [];
+  /**
+   * 查找所有可能为门的点位
    */
-  lineAnalysis() {
-    this.buildQuadtree();
-    this.buildVirtualGrid();
-    const quadtree = this.quadtree;
-    const lineSegmentList = this.lineSegmentList;
-    const visited = /* @__PURE__ */ new Set(), resultList = [];
-    lineSegmentList.forEach((_0, i) => {
-      const sourceLineSegment = lineSegmentList[i], rectangle = Rectangle.fromByLineSegment(sourceLineSegment, this.width * 2, false, -0.01), ids = quadtree.queryRect(rectangle).map((i2) => i2.userData).filter((index2) => index2 !== i);
-      ids.forEach((id) => {
-        try {
-          if (visited.has(`${i}-${id}`) || visited.has(`${id}-${i}`)) return;
-          const res = this.projectionAnalysis(id, i, sourceLineSegment, lineSegmentList);
-          if (res) resultList.push(res);
-          visited.add(`${i}-${id}`);
-        } catch (error) {
+  getPossiblePoints() {
+    const doorPoints = [];
+    this.lineSegments.forEach((line) => {
+      line.points.forEach((p, j) => {
+        for (let i = 0; i < this._pointsExcludeRule.length; i++) if (this._pointsExcludeRule[i](line, p, j)) return;
+        const res = this.pointVirtualGrid.queryPoint(p).filter((d) => d.userData !== line);
+        if (res.length === 0) {
+          doorPoints.push({ line, point: p, uuid: uuid() });
         }
       });
     });
-    this.appendLineSegmentList.length = 0;
-    resultList.forEach(this.createRectangle.bind(this));
-    this.resultList = resultList;
-  }
-  /** 线段投影分析
-   * @param index 
-   * @param sourceLineSegment 
-   * @param lineSegmentList 
-   * @returns 
-   */
-  projectionAnalysis(index2, sourceIndex, sourceLineSegment, lineSegmentList) {
-    const temLineSegment = lineSegmentList[index2], direct = sourceLineSegment.direction(), temDirect = temLineSegment.direction(), angle = direct.angleBetween(temDirect) / (Math.PI / 180);
-    if (angle < this.errorAngle || angle > 180 - this.errorAngle) {
-      let data;
-      const p1 = temLineSegment.projectLineSegment(sourceLineSegment), p2 = sourceLineSegment.projectLineSegment(temLineSegment);
-      if (p1.getLength() > p2.getLength()) {
-        data = {
-          target: temLineSegment,
-          targetIndex: index2,
-          source: sourceLineSegment,
-          sourceIndex,
-          project: p1,
-          project2: p2
-        };
-      } else {
-        data = {
-          target: sourceLineSegment,
-          targetIndex: sourceIndex,
-          source: temLineSegment,
-          sourceIndex: index2,
-          project: p2,
-          project2: p1
-        };
-      }
-      if (!data || data.project.getLength() < 0.2 || data.project2.getLength() < 0.2) return;
-      return data;
-    }
+    return doorPoints;
   }
-  doorSearchNearAngle = 110;
-  doorSearchDistance = 2;
-  doors = [];
   /**
-   * 门的位置判断
+   * 查找已知为门的点位
    */
-  doorsAnalysis() {
-    const dxf = this.Dxf, doorPoints = [], pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree, doorSearchNearAngle = this.doorSearchNearAngle, doorSearchDistance = this.doorSearchDistance, doors = [];
-    const excludePoints = dxf.doors.flatMap((item) => {
-      const index2 = item[4];
-      const doorData = dxf.originalData[index2];
+  getDoorPoint() {
+    const doorPoints = [], dxf = this.dxf, pointVirtualGrid = this.pointVirtualGrid;
+    dxf.doors.forEach((item) => {
+      const doorLine = dxf.lineSegments[item[4]];
+      const doorData = dxf.originalData[item[4]];
       if (doorData.drawDoorData) {
         const point = Point.from(doorData.drawDoorData.start);
         const direct = Point.from(doorData.drawDoorData.n);
         const resList = pointVirtualGrid.queryPoint(point).filter((res) => {
-          if (res.userData?.index === index2) return false;
-          const line = dxf.lineSegments[res.userData?.index];
+          if (res.userData === doorLine) return false;
+          const line = res.userData;
           const direct2 = line.direction();
           if (line.start.equal(point)) direct2.multiplyScalar(-1);
           const angle = direct.angleBetween(direct2, "angle");
           return angle > 80 || angle < 10;
         });
         if (resList.length) {
-          const index22 = resList[0].userData?.index;
           doorPoints.push({
-            line: dxf.lineSegments[index22],
-            point: Point.from(doorData.drawDoorData.start),
-            index: index22,
-            direct,
-            sure: true
+            line: resList[0].userData,
+            point,
+            uuid: uuid()
           });
-          return [point];
         }
+      } else if (doorData.doorDirectConnection) {
+        this.continueFind = false;
+        const line = new LineSegment(Point.from(doorData.start), Point.from(doorData.end));
+        line.userData = {
+          doorDirectConnection: true,
+          isDoor: true
+        };
+        this.dxf.doorLineSegment.push(line);
+      } else {
+        console.warn(`门的线段顺序${item[4]} 没有drawDoorData属性`);
       }
-      return [];
     });
+    console.log("门点位数量：", doorPoints.length);
+    return doorPoints;
+  }
+  /**
+   * 查找双线墙的点位
+   * @returns 
+   */
+  searchDoubleLinePoint() {
     const excludeIndexMap = /* @__PURE__ */ new Map();
     this.resultList.flatMap((p) => {
-      const line0 = this.lineSegmentList[p.sourceIndex], line1 = this.lineSegmentList[p.targetIndex], start0 = line1.projectPoint(line0.start), end0 = line1.projectPoint(line0.end), start1 = line0.projectPoint(line1.start), end1 = line0.projectPoint(line1.end), mode0 = start0 && end0 ? -1 : start0 ? 0 : end0 ? 1 : -1, mode1 = start1 && end1 ? -1 : start1 ? 0 : end1 ? 1 : -1;
+      const line0 = this.lineSegments[p.sourceIndex], line1 = this.lineSegments[p.targetIndex], start0 = line1.projectPoint(line0.start), end0 = line1.projectPoint(line0.end), start1 = line0.projectPoint(line1.start), end1 = line0.projectPoint(line1.end), mode0 = start0 && end0 ? -1 : start0 ? 0 : end0 ? 1 : -1, mode1 = start1 && end1 ? -1 : start1 ? 0 : end1 ? 1 : -1;
       if (excludeIndexMap.has(p.sourceIndex)) {
         if (excludeIndexMap.get(p.sourceIndex) != mode0) excludeIndexMap.set(p.sourceIndex, -1);
       } else excludeIndexMap.set(p.sourceIndex, mode0);
@@ -2237,54 +2283,42 @@ class LineAnalysis extends Component {
         if (excludeIndexMap.get(p.targetIndex) != mode1) excludeIndexMap.set(p.targetIndex, -1);
       } else excludeIndexMap.set(p.targetIndex, mode1);
     });
-    dxf.lineSegments.forEach((line, i) => {
-      if (line.userData?.isDoor) return;
-      const excludeMode = excludeIndexMap.get(i);
-      if (excludeMode === -1) return;
-      line.points.forEach((p, j) => {
-        if (excludeMode === j) return;
-        if (excludePoints.find((p1) => p1.equal(p))) return;
-        const res = this.pointVirtualGrid.queryPoint(p).filter((d) => d.userData?.index !== i);
-        if (res.length === 0) {
-          doorPoints.push({
-            line,
-            point: p,
-            index: i
-          });
-        }
-      });
-    });
-    function searchNearby({ point, line, index: index2 }, doorIndex, record2) {
+    return excludeIndexMap;
+  }
+  /** 查找方案一：最近点查找
+   * @description 以点为圆心，查找半径内符合角度的点
+   * @param doorPoints 
+   * @param possibleDoorPoints 
+   * @param doorSearchDistance 查找的距离（半径）
+   * @param doorSearchNearAngle 查找的角度
+   * @returns 
+   */
+  searchNearby(doorPoints, possibleDoorPoints = [], doorSearchDistance = this.doorSearchDistance, doorSearchNearAngle = this.doorSearchNearAngle) {
+    const findPointVirtualGrid = this.findPointVirtualGrid, quadtree = this.quadtree;
+    function find({ point, line }, doorIndex, record2) {
       const direct = line.direction();
       if (line.start === point) direct.multiplyScalar(-1);
-      const res = pointVirtualGrid.queryCircle(point, doorSearchDistance).filter(
-        (r) => (
-          // 不能是自己
-          r.userData?.index !== index2 && // 存在于可疑点位内，且不能是已知门的点位
-          !!doorPoints.find((p) => !p.sure && p.point === r.point)
-        )
-      ).sort((a, b) => a.point.distance(point) - b.point.distance(point));
+      const res = findPointVirtualGrid.queryCircle(point, doorSearchDistance).filter((r) => r.userData !== line).sort((a, b) => a.point.distance(point) - b.point.distance(point));
       const list = [];
       for (let i = 0; i < res.length; i++) {
-        const doorIndex2 = doorPoints.findIndex((p) => p.point === res[i].point);
-        if (record2.has(`${doorIndex}.${doorIndex2}`)) continue;
-        record2.add(`${doorIndex}.${doorIndex2}`);
-        record2.add(`${doorIndex2}.${doorIndex}`);
+        const doorIndex2 = possibleDoorPoints.findIndex((p) => p.point === res[i].point);
+        const id1 = doorPoints[doorIndex].uuid, id2 = possibleDoorPoints[doorIndex2].uuid;
+        if (record2.has(`${id1}.${id2}`)) continue;
+        record2.add(`${id1}.${id2}`);
+        record2.add(`${id2}.${id1}`);
         const targetPoint = res[i].point, line2 = new LineSegment(point.clone(), targetPoint.clone()), angle = line2.direction().angleBetween(direct, "angle");
         if (angle < doorSearchNearAngle) {
           const direct2 = doorPoints[doorIndex2].line.direction();
-          const line22 = dxf.lineSegments[res[i].userData?.index];
+          const line22 = res[i].userData;
           if (line22.start.equal(res[i].point)) direct2.multiplyScalar(-1);
           const angle2 = line2.direction().multiplyScalar(-1).angleBetween(direct2, "angle");
           if (angle2 < doorSearchNearAngle) {
             if (!quadtree.queryLineSegment(line2).length) {
               list.push({
                 findData: res[i],
-                findDoorIndex: doorIndex2,
-                findAngle: angle2,
-                doorAngle: angle,
+                findUuid: id2,
                 doorLine: line2,
-                doorIndex
+                doorUuid: id1
               });
             }
           }
@@ -2292,65 +2326,15 @@ class LineAnalysis extends Component {
       }
       return list;
     }
-    function searchAlongDirection({ point, line }) {
-      const direct = line.direction();
-      if (line.start === point) direct.multiplyScalar(-1);
-      const endPoint = point.clone().add(direct.clone().multiplyScalar(doorSearchDistance)), rline = new LineSegment(point.clone(), endPoint), result = quadtree.queryLineSegment(rline).map((l) => {
-        const res = l.line.getIntersection(rline);
-        return {
-          point: res,
-          line: l.line
-        };
-      }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
-      if (result.length) {
-        const item = result[0];
-        if (Math.abs(90 - item.line.direction().angleBetween(direct, "angle")) < 5) {
-          return item;
-        }
-      }
-    }
-    function searchAlongNormalDirection({ point, line, index: index2 }) {
-      const direct = line.direction();
-      if (line.start === point) direct.multiplyScalar(-1);
-      const normal = line.start.normal(line.end);
-      const prePoint = line.start.clone();
-      if (line.start === point) prePoint.copy(line.end);
-      const result = pointVirtualGrid.queryPoint(prePoint).filter((r) => r.userData?.index !== index2);
-      for (let i = 0; i < result.length; i++) {
-        const element = result[i];
-        const l = dxf.lineSegments[element.userData?.index ?? 0];
-        const d1 = l.direction();
-        if (l.start === element.point) direct.multiplyScalar(-1);
-        const angle = d1.angleBetween(normal) / (Math.PI / 180);
-        if (angle > 90) {
-          normal.multiplyScalar(-1);
-          break;
-        }
-      }
-      const rline3 = new LineSegment(point.clone(), point.clone().add(normal.multiplyScalar(doorSearchDistance)));
-      const r3 = quadtree.queryLineSegment(rline3).map((l) => {
-        const res = l.line.getIntersection(rline3);
-        return {
-          point: res,
-          line: l.line
-        };
-      }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
-      if (r3.length) {
-        const item = r3[0];
-        if (Math.abs(90 - item.line.direction().angleBetween(normal, "angle")) < 5) {
-          return item;
-        }
-      }
-    }
-    function deepSearchNearHandle(index2, snFindRecord2, list, record2, other) {
-      record2.add(`${index2}`);
+    function deepSearchNearHandle(uuid2, snFindRecord2, list, record2, other) {
+      record2.add(uuid2);
       const newList = [];
       if (other) newList.push(other);
       for (let i = 0; i < list.length; i++) {
         const item = list[i];
-        if (snFindRecord2.has(item.findDoorIndex)) {
-          const list2 = snFindRecord2.get(item.findDoorIndex);
-          if (deepSearchNearHandle(item.findDoorIndex, snFindRecord2, list2, record2, item)) newList.push(item);
+        if (snFindRecord2.has(item.findUuid)) {
+          const list2 = snFindRecord2.get(item.findUuid);
+          if (deepSearchNearHandle(item.findUuid, snFindRecord2, list2, record2, item)) newList.push(item);
         } else newList.push(item);
       }
       newList.sort((a, b) => a.doorLine.length() - b.doorLine.length());
@@ -2364,22 +2348,21 @@ class LineAnalysis extends Component {
     const record = /* @__PURE__ */ new Set();
     const snFindRecord = /* @__PURE__ */ new Map();
     doorPoints.map((p, index2) => {
-      if (dxf.doors.length >= 2 && !p.sure) return;
-      const list = searchNearby(p, index2, record);
-      if (list.length) snFindRecord.set(index2, list);
+      const list = find(p, index2, record);
+      if (list.length) snFindRecord.set(p.uuid, list);
     });
     record.clear();
     const temMap = /* @__PURE__ */ new Map();
     snFindRecord.forEach((list, key) => {
-      if (!record.has(`${key}`) && list.length) {
+      if (!record.has(key) && list.length) {
         deepSearchNearHandle(key, snFindRecord, list, record);
       }
       if (list.length) {
         const item = list[0];
-        if (!temMap.has(item.doorIndex)) temMap.set(item.doorIndex, []);
-        temMap.get(item.doorIndex)?.push(item);
-        if (!temMap.has(item.findDoorIndex)) temMap.set(item.findDoorIndex, []);
-        temMap.get(item.findDoorIndex)?.push(item);
+        if (!temMap.has(item.doorUuid)) temMap.set(item.doorUuid, []);
+        temMap.get(item.doorUuid)?.push(item);
+        if (!temMap.has(item.findUuid)) temMap.set(item.findUuid, []);
+        temMap.get(item.findUuid)?.push(item);
       }
     });
     const deleteSet = /* @__PURE__ */ new Set();
@@ -2389,38 +2372,24 @@ class LineAnalysis extends Component {
         for (let i = 1; i < list.length; i++) deleteSet.add(list[i]);
       }
     });
-    const searchNearRasult = [], removeDoorPointsIndex = [];
+    const searchNearRasult = [], removeDoorPointsUuid = [];
     snFindRecord.forEach((list) => {
       if (list.length) {
         const item = list[0];
         if (!deleteSet.has(item)) {
           searchNearRasult.push(item);
-          removeDoorPointsIndex.push(item.doorIndex, item.findDoorIndex);
+          removeDoorPointsUuid.push(item.doorUuid, item.findUuid);
         }
       }
     });
-    const doors_ = doorPoints.map((item, index2) => {
-      if (removeDoorPointsIndex.includes(index2)) return;
-      if (dxf.doors.length >= 2 && !item.sure) return;
-      const res2 = searchAlongDirection(item);
-      if (res2) return {
-        start: item.point,
-        end: res2.point,
-        index: item.index
-      };
-      const res3 = searchAlongNormalDirection(item);
-      if (res3) return {
-        start: item.point,
-        end: res3.point,
-        index: item.index
-      };
-    }).filter((i) => !!i && i.start.distance(i.end) < doorSearchDistance);
-    doors.push(...doors_);
+    const doors = [];
     searchNearRasult.forEach((item) => {
-      const start = doorPoints[item.doorIndex].point.clone();
-      const end = doorPoints[item.findDoorIndex].point.clone();
-      const startLine = this.findLongLineSegment(doorPoints[item.doorIndex].line);
-      const endLine = this.findLongLineSegment(doorPoints[item.findDoorIndex].line);
+      const doorIndex = doorPoints.findIndex((p2) => p2.uuid === item.doorUuid);
+      const findDoorIndex = possibleDoorPoints.findIndex((p2) => p2.uuid === item.findUuid);
+      const start = doorPoints[doorIndex].point.clone();
+      const end = possibleDoorPoints[findDoorIndex].point.clone();
+      const startLine = this.findLongLineSegment(doorPoints[doorIndex].line);
+      const endLine = this.findLongLineSegment(possibleDoorPoints[findDoorIndex].line);
       const p = startLine.projectPoint(end);
       if (p) {
         start.copy(p);
@@ -2429,8 +2398,7 @@ class LineAnalysis extends Component {
         if (angle < 10 || angle > 170 || Math.abs(90 - angle) < 10) {
           doors.push({
             start,
-            end,
-            index: doorPoints[item.doorIndex].index
+            end
           });
         }
       } else {
@@ -2441,30 +2409,82 @@ class LineAnalysis extends Component {
         if (angle < 10 || angle > 170 || Math.abs(90 - angle) < 10) {
           doors.push({
             start,
-            end,
-            index: doorPoints[item.doorIndex].index
+            end
           });
         }
       }
     });
-    dxf.doorLineSegment.length = 0;
-    doors.forEach((p) => {
-      const line = new LineSegment(p?.start, p?.end);
-      const len = line.length();
-      if (len < 0.6) return;
-      const normal = line.normal(), direction = line.direction(), step = (len - dxf.width * 2) / 2;
-      for (let i = 0; i < 3; i++) {
-        const point = line.start.clone().add(direction.clone().multiplyScalar(dxf.width + step * i));
-        const rLine = new LineSegment(
-          point,
-          point.clone().add(normal.clone().multiplyScalar(1))
-        );
-        rLine.directionMove(normal, -0.5);
-        const res = this.quadtree?.queryLineSegment(rLine);
-        if (res?.length) return;
+    possibleDoorPoints.splice(
+      0,
+      possibleDoorPoints.length,
+      ...possibleDoorPoints.filter((p) => removeDoorPointsUuid.indexOf(p.uuid) === -1)
+    );
+    doorPoints.splice(
+      0,
+      doorPoints.length,
+      ...doorPoints.filter((p) => removeDoorPointsUuid.indexOf(p.uuid) === -1)
+    );
+    return doors;
+  }
+  /** 方案二： 沿方向查找
+   * @description 
+   * @param param0 
+   * @returns 
+   */
+  searchAlongDirection({ point, line }, doorSearchDistance = this.doorSearchDistance) {
+    const quadtree = this.quadtree;
+    const direct = line.direction();
+    if (line.start === point) direct.multiplyScalar(-1);
+    const endPoint = point.clone().add(direct.clone().multiplyScalar(doorSearchDistance)), rline = new LineSegment(point.clone(), endPoint), result = quadtree.queryLineSegment(rline).map((l) => {
+      const res = l.line.getIntersection(rline);
+      return {
+        point: res,
+        line: l.line
+      };
+    }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
+    if (result.length) {
+      const item = result[0];
+      if (Math.abs(90 - item.line.direction().angleBetween(direct, "angle")) < 5) {
+        return item;
       }
-      dxf.doorLineSegment.push(line);
-    });
+    }
+  }
+  /** 方案三： 沿法线方向查找
+   * @description 
+   * @param param0 
+   * @param doorSearchDistance 
+   * @returns 
+   */
+  searchAlongNormalDirection({ point, line }, doorSearchDistance = this.doorSearchDistance) {
+    const pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree, direct = line.direction(), normal = line.start.normal(line.end), prePoint = line.start.clone();
+    if (line.start === point) direct.multiplyScalar(-1);
+    if (line.start === point) prePoint.copy(line.end);
+    const result = pointVirtualGrid.queryPoint(prePoint).filter((r) => r.userData !== line);
+    for (let i = 0; i < result.length; i++) {
+      const element = result[i];
+      const l = element.userData;
+      const d1 = l.direction();
+      if (l.start === element.point) direct.multiplyScalar(-1);
+      const angle = d1.angleBetween(normal) / (Math.PI / 180);
+      if (angle > 90) {
+        normal.multiplyScalar(-1);
+        break;
+      }
+    }
+    const rline3 = new LineSegment(point.clone(), point.clone().add(normal.multiplyScalar(doorSearchDistance)));
+    const r3 = quadtree.queryLineSegment(rline3).map((l) => {
+      const res = l.line.getIntersection(rline3);
+      return {
+        point: res,
+        line: l.line
+      };
+    }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
+    if (r3.length) {
+      const item = r3[0];
+      if (Math.abs(90 - item.line.direction().angleBetween(normal, "angle")) < 5) {
+        return item;
+      }
+    }
   }
   /**
    * 
@@ -2476,8 +2496,7 @@ class LineAnalysis extends Component {
     const res1 = this.pointVirtualGrid.queryPoint(line.start);
     const res2 = this.pointVirtualGrid.queryPoint(line.end);
     for (let i = 0; i < res1.length; i++) {
-      const { userData } = res1[i];
-      const line2 = this.lineSegmentList[userData?.index];
+      const { userData: line2 } = res1[i];
       if (line2 === line) continue;
       if (line2 && line2.directionEqual(line)) {
         if (line2.start.equal(line.start)) resLine.start.copy(line2.end);
@@ -2486,8 +2505,7 @@ class LineAnalysis extends Component {
       }
     }
     for (let i = 0; i < res2.length; i++) {
-      const { userData } = res2[i];
-      const line2 = this.lineSegmentList[userData?.index];
+      const { userData: line2 } = res2[i];
       if (line2 === line) continue;
       if (line2 && line2.directionEqual(line)) {
         if (line2.end.equal(line.end)) resLine.end.copy(line2.start);
@@ -2497,127 +2515,169 @@ class LineAnalysis extends Component {
     }
     return resLine;
   }
-  doorsAnalysis2() {
-    const renderer = this.parent?.findComponentByName("Renderer");
-    const dxf = this.Dxf, pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree;
-    this.doorSearchNearAngle;
-    this.doorSearchDistance;
-    const doorsAnalysis = new DoorsAnalysis(dxf, pointVirtualGrid, quadtree, this.resultList, this.lineSegmentList);
-    const possiblePoints = doorsAnalysis.searchPossiblePoints();
-    possiblePoints.forEach((l) => {
-      renderer.createPointMesh(l.point).position.z = dxf.originalZAverage;
-    });
-  }
 }
-class DoorsAnalysis {
-  // 所有可查找的点位
-  possibleDoorPoints = [];
-  doorPoint = [];
-  dxf;
-  pointVirtualGrid;
-  quadtree;
-  resultList;
-  // 已过滤门的线段
-  lineSegments;
-  constructor(dxf, pointVirtualGrid, quadtree, resultList = [], lineSegments = []) {
-    this.dxf = dxf;
-    this.pointVirtualGrid = pointVirtualGrid;
-    this.quadtree = quadtree;
-    this.resultList = resultList;
-    this.lineSegments = lineSegments;
-    this.addPointsExcludeRule((line) => line.userData.isDoor);
-    const excludeIndexMap = this.searchDoubleLinePoint();
-    this.addPointsExcludeRule((_1, _2, index2, pointIndex) => {
-      const excludeMode = excludeIndexMap.get(index2);
-      if (typeof excludeMode === "number") {
-        return excludeMode === -1 || excludeMode === pointIndex;
-      }
-      return false;
-    });
-    this.doorPoint = this.searchDoorPoint();
-    this.addPointsExcludeRule((_1, point) => {
-      return !!this.doorPoint.find((p1) => p1.point.equal(point));
-    });
-    this.possibleDoorPoints = this.searchPossiblePoints();
+class LineAnalysis extends Component {
+  static name = "LineAnalysis";
+  Dxf = null;
+  Variable = null;
+  lineSegmentList = [];
+  container = new THREE.Group();
+  // 误差角度
+  errorAngle = 4;
+  width = 0.4;
+  /**
+   * 
+   * @param parent 
+   */
+  onAddFromParent(parent) {
+    this.Dxf = parent.findComponentByType(Dxf);
+    this.Variable = this.parent?.findComponentByType(Variable);
+    this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this));
+    this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
   }
   /**
    * 
-   * @param rule 
+   * @param p1 
+   * @param p2 
+   * @param width 
+   * @returns 
    */
-  addPointsExcludeRule(rule) {
-    this._pointsExcludeRule.push(rule);
+  expandLineSegment(p1, p2, width = 0.1) {
+    const normal = p2.normal(p1);
+    const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
+    const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
+    const offsetX = normal.x * width * 0.5;
+    const offsetY = normal.y * width * 0.5;
+    return {
+      points: [
+        // 第一条线
+        new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
+        new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
+        // 第二条线
+        new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
+        new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
+      ],
+      indices: [0, 1, 1, 3, 3, 2, 2, 0],
+      rectIndices: [0, 1, 3, 2, 0]
+    };
   }
-  _pointsExcludeRule = [];
+  appendLineSegmentList = [];
   /**
-   * 查找所有可能为门的点位
+   * 追加数据
+   * @param p1 
+   * @param p2 
    */
-  searchPossiblePoints() {
-    const dxf = this.dxf, doorPoints = [];
-    dxf.lineSegments.forEach((line, i) => {
-      line.points.forEach((p, j) => {
-        for (let i2 = 0; i2 < this._pointsExcludeRule.length; i2++)
-          if (this._pointsExcludeRule[i2](line, p, i2, j)) return;
-        const res = this.pointVirtualGrid.queryPoint(p).filter((d) => d.userData?.index !== i);
-        if (res.length === 0) {
-          doorPoints.push({
-            line,
-            point: p,
-            index: i
-          });
-        }
+  addData(p1, p2) {
+    const dxf = this.Dxf;
+    dxf.data.push([p1.clone(), p2.clone(), [], false, dxf.data.length]);
+    this.appendLineSegmentList.push(new LineSegment(p1.clone(), p2.clone()));
+  }
+  /** 结果分析创建矩形
+   * @param result 
+   */
+  createRectangle(result) {
+    const dxf = this.Dxf;
+    const project0 = result.project, project1 = result.project2;
+    if (project0.includedAngle(project1) > 135) {
+      project1.points = [project1.points[1], project1.points[0]];
+    }
+    this.addData(project0.points[0], project1.points[0]);
+    this.addData(project0.points[1], project1.points[1]);
+    const leftHeight = project0.points[0].distance(project1.points[0]), rightHeight = project0.points[1].distance(project1.points[1]), count = Math.ceil(Math.max(leftHeight, rightHeight) / dxf.width), leftFragment = leftHeight / count, rightFragment = rightHeight / count, leftDirection = project1.points[0].direction(project0.points[0]), rightDirection = project1.points[1].direction(project0.points[1]), leftP = project0.points[0].clone(), rightP = project0.points[1].clone(), direction = rightP.direction(leftP);
+    direction.multiplyScalar(dxf.width * 0.5);
+    const _leftP = leftP.clone().add(direction), _rightP = rightP.clone().add(direction.multiplyScalar(-1)), d1 = leftP.direction(rightP), d2 = _leftP.direction(_rightP);
+    if (d1.x > 0 && d2.x < 0 || d1.x < 0 && d2.x > 0 || d1.y > 0 && d2.y < 0 || d1.y < 0 && d2.y > 0) return;
+    leftP.set(_leftP.x, _leftP.y);
+    rightP.set(_rightP.x, _rightP.y);
+    for (let i = 1; i < count; i++) {
+      const left = leftDirection.clone().multiplyScalar(leftFragment * i), right = rightDirection.clone().multiplyScalar(rightFragment * i), p1 = leftP.clone().add(left), p2 = rightP.clone().add(right);
+      this.addData(p1, p2);
+    }
+  }
+  quadtree;
+  /**
+   * 构建线段四叉树，快速查找，
+   */
+  buildQuadtree() {
+    const dxf = this.Dxf;
+    const lineSegmentList = [];
+    this.quadtree = new Quadtree(dxf.originalBox, 2);
+    dxf.lineSegments.forEach((lineSegment) => {
+      if (lineSegment.userData?.isDoor) return;
+      this.quadtree?.insert({
+        line: lineSegment,
+        userData: lineSegmentList.length
       });
+      lineSegmentList.push(lineSegment);
     });
-    return doorPoints;
+    this.lineSegmentList = lineSegmentList;
   }
-  /**
-   * 查找已知为门的点位
+  resultList = [];
+  mergeWallLines = [];
+  /** 线段分析
+   * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
+   * @param data 
    */
-  searchDoorPoint() {
-    const doorPoints = [], dxf = this.dxf, pointVirtualGrid = this.pointVirtualGrid;
-    dxf.doors.forEach((item) => {
-      const index2 = item[4];
-      const doorData = dxf.originalData[index2];
-      if (doorData.drawDoorData) {
-        const point = Point.from(doorData.drawDoorData.start);
-        const direct = Point.from(doorData.drawDoorData.n);
-        const resList = pointVirtualGrid.queryPoint(point).filter((res) => {
-          if (res.userData?.index === index2) return false;
-          const line = dxf.lineSegments[res.userData?.index];
-          const direct2 = line.direction();
-          if (line.start.equal(point)) direct2.multiplyScalar(-1);
-          const angle = direct.angleBetween(direct2, "angle");
-          return angle > 80 || angle < 10;
-        });
-        if (resList.length) {
-          const index22 = resList[0].userData?.index;
-          doorPoints.push({
-            line: dxf.lineSegments[index22],
-            point: Point.from(doorData.drawDoorData.start),
-            index: index22,
-            direct,
-            sure: true
-          });
+  lineAnalysis() {
+    this.buildQuadtree();
+    const quadtree = this.quadtree;
+    const lineSegmentList = this.lineSegmentList;
+    const visited = /* @__PURE__ */ new Set(), resultList = [];
+    lineSegmentList.forEach((_0, i) => {
+      const sourceLineSegment = lineSegmentList[i], rectangle = Rectangle.fromByLineSegment(sourceLineSegment, this.width * 2, false, -0.01), ids = quadtree.queryRect(rectangle).map((i2) => i2.userData).filter((index2) => index2 !== i);
+      ids.forEach((id) => {
+        try {
+          if (visited.has(`${i}-${id}`) || visited.has(`${id}-${i}`)) return;
+          const res = this.projectionAnalysis(id, i, sourceLineSegment, lineSegmentList);
+          if (res) resultList.push(res);
+          visited.add(`${i}-${id}`);
+        } catch (error) {
         }
-      }
+      });
     });
-    return doorPoints;
+    this.appendLineSegmentList.length = 0;
+    resultList.forEach(this.createRectangle.bind(this));
+    this.resultList = resultList;
   }
-  /**
-   * 查找双线墙的点位
+  /** 线段投影分析
+   * @param index 
+   * @param sourceLineSegment 
+   * @param lineSegmentList 
    * @returns 
    */
-  searchDoubleLinePoint() {
-    const excludeIndexMap = /* @__PURE__ */ new Map();
-    this.resultList.flatMap((p) => {
-      const line0 = this.lineSegments[p.sourceIndex], line1 = this.lineSegments[p.targetIndex], start0 = line1.projectPoint(line0.start), end0 = line1.projectPoint(line0.end), start1 = line0.projectPoint(line1.start), end1 = line0.projectPoint(line1.end), mode0 = start0 && end0 ? -1 : start0 ? 0 : end0 ? 1 : -1, mode1 = start1 && end1 ? -1 : start1 ? 0 : end1 ? 1 : -1;
-      if (excludeIndexMap.has(p.sourceIndex)) {
-        if (excludeIndexMap.get(p.sourceIndex) != mode0) excludeIndexMap.set(p.sourceIndex, -1);
-      } else excludeIndexMap.set(p.sourceIndex, mode0);
-      if (excludeIndexMap.has(p.targetIndex)) {
-        if (excludeIndexMap.get(p.targetIndex) != mode1) excludeIndexMap.set(p.targetIndex, -1);
-      } else excludeIndexMap.set(p.targetIndex, mode1);
-    });
-    return excludeIndexMap;
+  projectionAnalysis(index2, sourceIndex, sourceLineSegment, lineSegmentList) {
+    const temLineSegment = lineSegmentList[index2], direct = sourceLineSegment.direction(), temDirect = temLineSegment.direction(), angle = direct.angleBetween(temDirect) / (Math.PI / 180);
+    if (angle < this.errorAngle || angle > 180 - this.errorAngle) {
+      let data;
+      const p1 = temLineSegment.projectLineSegment(sourceLineSegment), p2 = sourceLineSegment.projectLineSegment(temLineSegment);
+      if (p1.getLength() > p2.getLength()) {
+        data = {
+          target: temLineSegment,
+          targetIndex: index2,
+          source: sourceLineSegment,
+          sourceIndex,
+          project: p1,
+          project2: p2
+        };
+      } else {
+        data = {
+          target: sourceLineSegment,
+          targetIndex: sourceIndex,
+          source: temLineSegment,
+          sourceIndex: index2,
+          project: p2,
+          project2: p1
+        };
+      }
+      if (!data || data.project.getLength() < 0.2 || data.project2.getLength() < 0.2) return;
+      return data;
+    }
+  }
+  doorSearchNearAngle = 110;
+  doorSearchDistance = 2;
+  doors = [];
+  doorsAnalysis() {
+    new DoorsAnalysis(this);
   }
 }
 class DxfSystem extends ComponentManager {
@@ -2970,38 +3030,84 @@ class DxfLineModel extends Component {
   updateMode() {
     const dxf = this.parent?.findComponentByName("Dxf");
     this.dxfLineModel.clear();
-    const dxfArray = dxf.to3DArray(1 / dxf.scale);
+    const dxfArray = dxf.to3DArray(1 / dxf.scale, 0);
     this.dxfLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(dxfArray, 3, true));
     const doorsArray = new Float32Array(
-      dxf.doorLineSegment.flatMap(({ start, end }) => [start.x, start.y, dxf.originalZAverage * 0.99, end.x, end.y, dxf.originalZAverage * 0.99])
+      dxf.doorLineSegment.flatMap(({ start, end }) => [start.x, start.y, 0, end.x, end.y, 0])
     ).map((n) => n / dxf.scale);
     const doorsColorArray = new Float32Array(dxf.doorLineSegment.flatMap(() => [1, 0, 0, 0, 1, 0]));
     this.dxfDoorsLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(doorsArray, 3, true)).setAttribute("color", new THREE.BufferAttribute(doorsColorArray, 3));
+    this.dxfModelGroup.position.z = dxf.originalZAverage;
+    this.dispatchEvent({
+      type: "modelUpdate",
+      model: this.dxfModelGroup
+    });
   }
 }
-const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   DetailsPoint,
   DxfLineModel,
   WhiteModel
 }, Symbol.toStringTag, { value: "Module" }));
-function ModelDataPlugin(dxfSystem) {
-  dxfSystem.addComponent(new DxfLineModel());
-  dxfSystem.addComponent(new WhiteModel());
-  dxfSystem.addComponent(new DetailsPoint());
+function ModelDataPlugin_(dxfSystem, option = {}) {
+  const {
+    detailsPoint = true,
+    whiteModel = true,
+    dxfLineModel = true
+  } = option;
+  dxfLineModel && dxfSystem.addComponent(new DxfLineModel());
+  whiteModel && dxfSystem.addComponent(new WhiteModel());
+  detailsPoint && dxfSystem.addComponent(new DetailsPoint());
 }
+const ModelDataPlugin = Object.assign(ModelDataPlugin_, {
+  create(option = {}) {
+    return (dxfSystem) => ModelDataPlugin_(dxfSystem, option);
+  }
+});
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ModelDataPlugin,
+  components: index$1
+}, Symbol.toStringTag, { value: "Module" }));
 function loadRenderPlugin() {
   return import("./index2.js");
 }
+function loadEditorPlugin() {
+  return import("./index3.js");
+}
+async function createEditor(dom, camera) {
+  const mp = await Promise.resolve().then(() => index);
+  const rp = await loadRenderPlugin();
+  const editor = await loadEditorPlugin();
+  const dxfSystem = new DxfSystem().usePlugin(mp.ModelDataPlugin.create({
+    detailsPoint: false,
+    whiteModel: false
+  })).usePlugin(rp.RenderPlugin.create({
+    originalLine: false,
+    modelData: false,
+    detailsPoint: false,
+    camera
+  })).usePlugin(editor.Editor);
+  const domContainer = dxfSystem.findComponentByType(rp.components.DomContainer);
+  domContainer && dom.appendChild(domContainer.domElement);
+  return {
+    dxfSystem
+  };
+}
 export {
   Box2 as B,
   Component as C,
   DxfSystem as D,
+  EventDispatcher as E,
+  LineSegment as L,
   ModelDataPlugin as M,
   Point as P,
+  Quadtree as Q,
   Variable as V,
   WhiteModel as W,
   DetailsPoint as a,
-  index as i,
-  loadRenderPlugin as l
+  PointVirtualGrid as b,
+  createEditor as c,
+  index$1 as i
 };