build-dxf 0.1.12 → 0.1.14

package/src/build.js

@@ -8,6 +8,7 @@ import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { GLTFExporter } from "three/addons/exporters/GLTFExporter.js";
 const VITE_OSS_BASEURL = "https://image.cnyang.cn/common-assets/".endsWith("/") ? "https://image.cnyang.cn/common-assets/" : "https://image.cnyang.cn/common-assets//";
 const DEFAULT_WALL_WIDTH = 0.12;
+const DEFAULT_WALL_HEIGHT = 2.8;
 const DEFAULT_DOOR_HEIGHT = 2.1;
 const DOOR_GROUND_CLEARANCE_HEIGHT = 0;
 const DEFAULT_WINDOW_HEIGHT = 0.8;
@@ -170,20 +171,20 @@ class PointVirtualGrid {
    * @param point 
    * @param userData 
    */
-  insert(point, userData) {
-    if (!point || isNaN(point.x) || isNaN(point.y)) {
+  insert(point2, userData) {
+    if (!point2 || isNaN(point2.x) || isNaN(point2.y)) {
       console.error("无效的点坐标");
       return;
     }
-    if (point.currentData[this.id]) this.remove(point);
-    const id = this.getGridId(point);
+    if (point2.currentData[this.id]) this.remove(point2);
+    const id = this.getGridId(point2);
     if (!this.map.has(id)) this.map.set(id, /* @__PURE__ */ new Set());
     const set2 = this.map.get(id);
-    const target = { point, userData };
+    const target = { point: point2, userData };
     set2.add(target);
     const opt = { set: set2, target, id };
-    point.currentData.pointVirtualGrid = opt;
-    point.currentData[this.id] = opt;
+    point2.currentData.pointVirtualGrid = opt;
+    point2.currentData[this.id] = opt;
     return this;
   }
   /**
@@ -191,29 +192,29 @@ class PointVirtualGrid {
    * @param points 
    */
   insertBatch(points) {
-    for (const { point, userData } of points) {
-      this.insert(point, userData);
+    for (const { point: point2, userData } of points) {
+      this.insert(point2, userData);
     }
   }
   /** 移除点
    * @param point 
    */
-  remove(point) {
-    if (point.currentData[this.id]) {
-      const { target, set: set2, id } = point.currentData[this.id];
+  remove(point2) {
+    if (point2.currentData[this.id]) {
+      const { target, set: set2, id } = point2.currentData[this.id];
       if (set2) {
         set2.delete(target);
-        delete point?.userData?.pointVirtualGridMap;
-        delete point.currentData[this.id];
+        delete point2?.userData?.pointVirtualGridMap;
+        delete point2.currentData[this.id];
         if (set2.size === 0) this.map.delete(id);
       }
     }
     return this;
   }
-  update(point) {
-    const { target, set: set2 } = point.currentData[this.id];
+  update(point2) {
+    const { target, set: set2 } = point2.currentData[this.id];
     if (!target) return false;
-    const id = this.getGridId(point);
+    const id = this.getGridId(point2);
     let newSet = this.map.get(id);
     if (newSet === set2) return false;
     set2.delete(target);
@@ -222,8 +223,8 @@ class PointVirtualGrid {
       this.map.set(id, newSet);
     }
     newSet.add(target);
-    point.currentData[this.id].set = newSet;
-    point.currentData[this.id].id = id;
+    point2.currentData[this.id].set = newSet;
+    point2.currentData[this.id].id = id;
     return true;
   }
   /**
@@ -231,8 +232,8 @@ class PointVirtualGrid {
    * @param point 
    * @returns 
    */
-  getGridId(point) {
-    const i = Math.ceil(point.x / this.gridSize), j = Math.ceil(point.y / this.gridSize);
+  getGridId(point2) {
+    const i = Math.ceil(point2.x / this.gridSize), j = Math.ceil(point2.y / this.gridSize);
     return `${i}.${j}`;
   }
   /**
@@ -320,18 +321,18 @@ class PointVirtualGrid {
    * 查找相同点
    * @param point 
    */
-  queryPoint(point, excludeOneself = false) {
+  queryPoint(point2, excludeOneself = false) {
     const list = new PvgList();
     let set2;
-    if (point.currentData[this.id]) {
-      set2 = point.currentData[this.id]?.set;
+    if (point2.currentData[this.id]) {
+      set2 = point2.currentData[this.id]?.set;
     } else {
-      const id = this.getGridId(point);
+      const id = this.getGridId(point2);
       if (this.map.has(id)) set2 = this.map.get(id);
     }
     set2?.forEach((item) => {
-      if (point.equal(item.point)) {
-        if (excludeOneself && point === item.point) return;
+      if (point2.equal(item.point)) {
+        if (excludeOneself && point2 === item.point) return;
         list.push(item);
       }
     });
@@ -349,9 +350,9 @@ class PointVirtualGrid {
    * 查找点自己
    * @param point 
    */
-  queryPointSelf(point) {
-    if (point.currentData[this.id]) {
-      const { target } = point.currentData[this.id];
+  queryPointSelf(point2) {
+    if (point2.currentData[this.id]) {
+      const { target } = point2.currentData[this.id];
       return target;
     }
     return null;
@@ -496,16 +497,16 @@ class Rectangle {
     if (line.points.length !== 2) {
       throw new Error("LineSegment must have exactly 2 points");
     }
-    const isPointInRectangle = (point) => {
+    const isPointInRectangle = (point2) => {
       let sign = 0;
       for (let i = 0; i < 4; i++) {
         const p1 = this.points[i];
         const p2 = this.points[(i + 1) % 4];
         const edge = { x: p2.x - p1.x, y: p2.y - p1.y };
-        const toPoint = { x: point.x - p1.x, y: point.y - p1.y };
+        const toPoint = { x: point2.x - p1.x, y: point2.y - p1.y };
         const cross = edge.x * toPoint.y - edge.y * toPoint.x;
         if (cross === 0) {
-          const t = edge.x !== 0 ? (point.x - p1.x) / edge.x : (point.y - p1.y) / edge.y;
+          const t = edge.x !== 0 ? (point2.x - p1.x) / edge.x : (point2.y - p1.y) / edge.y;
           if (t >= 0 && t <= 1) return true;
         } else {
           const currentSign = cross > 0 ? 1 : -1;
@@ -536,7 +537,7 @@ class Rectangle {
       axes.push(p1.normal(p2));
     }
     function projectRectangle(rect, axis) {
-      const projections = rect.points.map((point) => point.dot(axis));
+      const projections = rect.points.map((point2) => point2.dot(axis));
       return [Math.min(...projections), Math.max(...projections)];
     }
     function isProjectionOverlap(proj1, proj2) {
@@ -555,13 +556,13 @@ class Rectangle {
    * 判断点是否完全位于矩形内部
    * @param point 
    */
-  containsPoint(point) {
+  containsPoint(point2) {
     let positiveCount = 0;
     let negativeCount = 0;
     for (let i = 0; i < 4; i++) {
       const p1 = this.points[i];
       const p2 = this.points[(i + 1) % 4];
-      const cross = (p2.x - p1.x) * (point.y - p1.y) - (p2.y - p1.y) * (point.x - p1.x);
+      const cross = (p2.x - p1.x) * (point2.y - p1.y) - (p2.y - p1.y) * (point2.x - p1.x);
       if (cross > 0) positiveCount++;
       else if (cross < 0) negativeCount++;
       else return false;
@@ -828,17 +829,17 @@ class Quadtree {
    * @param point 圆心
    * @returns 相交的节点数组
    */
-  queryPoint(point) {
+  queryPoint(point2) {
     const result = [];
-    if (point.x < this.bounds.minX || point.x > this.bounds.maxX || point.y < this.bounds.minY || point.y > this.bounds.maxY) {
+    if (point2.x < this.bounds.minX || point2.x > this.bounds.maxX || point2.y < this.bounds.minY || point2.y > this.bounds.maxY) {
       return result;
     }
     for (const node of this.nodes) {
-      if (node.line.isPointOnSegment(point)) result.push(node);
+      if (node.line.isPointOnSegment(point2)) result.push(node);
     }
     if (!this.isLeaf) {
       for (const child of this.children) {
-        result.push(...child.queryPoint(point));
+        result.push(...child.queryPoint(point2));
       }
     }
     return result;
@@ -1102,10 +1103,26 @@ class LineSegment {
     this.end.copy(p2);
     return this;
   }
-  getAnotherPoint(point) {
-    if (point === this.start) return this.end;
+  getAnotherPoint(point2) {
+    if (point2 === this.start) return this.end;
     else return this.start;
   }
+  /** 开始点向线段内收缩 width
+   * @param width 
+   */
+  startShrink(width) {
+    const d = this.end.direction(this.start);
+    this.start.add(d.multiplyScalar(width));
+    return this;
+  }
+  /** 结束点向线段内收缩 width
+   * @param width 
+   */
+  endShrink(width) {
+    const d = this.start.direction(this.end);
+    this.end.add(d.multiplyScalar(width));
+    return this;
+  }
   /**
    * 是否有相同端点
    * @param line 
@@ -1139,13 +1156,13 @@ class LineSegment {
    * @param point 要判断的点
    * @returns 如果点在当前线段上则返回 true，否则返回 false
    */
-  isPointOnSegment(point) {
+  isPointOnSegment(point2) {
     const { start, end } = this;
-    const cross = (point.y - start.y) * (end.x - start.x) - (point.x - start.x) * (end.y - start.y);
+    const cross = (point2.y - start.y) * (end.x - start.x) - (point2.x - start.x) * (end.y - start.y);
     if (Math.abs(cross) > 1e-10) {
       return false;
     }
-    const dot = (point.x - start.x) * (point.x - end.x) + (point.y - start.y) * (point.y - end.y);
+    const dot = (point2.x - start.x) * (point2.x - end.x) + (point2.y - start.y) * (point2.y - end.y);
     return dot <= 1e-10;
   }
   /**
@@ -1229,7 +1246,7 @@ class LineSegment {
     const nDirect = direct === "bothSides" ? Point.zero() : p1.direction(p2).mutiplyScalar(width * 0.5);
     const offsetX = normal.x * width * 0.5;
     const offsetY = normal.y * width * 0.5;
-    const point = [
+    const point2 = [
       // 第一条线
       new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
       new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
@@ -1237,7 +1254,7 @@ class LineSegment {
       new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
       new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
     ];
-    return new Rectangle([0, 1, 3, 2].map((i) => point[i]));
+    return new Rectangle([0, 1, 3, 2].map((i) => point2[i]));
   }
   /**
    * 计算线段的长度
@@ -1288,8 +1305,8 @@ class LineSegment {
       console.error("投影目标线段的两个点不能重合");
       return new LineSegment();
     }
-    const projectPoint = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
+    const projectPoint = (point2) => {
+      const pq = new Point(point2.x - q1.x, point2.y - q1.y);
       const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
       const dotProduct = pq.x * dir.x + pq.y * dir.y;
       const t = dotProduct / dirLengthSquared;
@@ -1299,8 +1316,8 @@ class LineSegment {
     };
     let projP1 = projectPoint(p1);
     let projP2 = projectPoint(p2);
-    const getT = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
+    const getT = (point2) => {
+      const pq = new Point(point2.x - q1.x, point2.y - q1.y);
       const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
       return (pq.x * dir.x + pq.y * dir.y) / dirLengthSquared;
     };
@@ -1335,8 +1352,8 @@ class LineSegment {
     if (dir.x === 0 && dir.y === 0) {
       return null;
     }
-    const projectPoint = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
+    const projectPoint = (point2) => {
+      const pq = new Point(point2.x - q1.x, point2.y - q1.y);
       const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
       const dotProduct = pq.x * dir.x + pq.y * dir.y;
       const t = dotProduct / dirLengthSquared;
@@ -1346,8 +1363,8 @@ class LineSegment {
     };
     let projP1 = projectPoint(p1);
     if (!clip) return projP1;
-    const getT = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
+    const getT = (point2) => {
+      const pq = new Point(point2.x - q1.x, point2.y - q1.y);
       const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
       return (pq.x * dir.x + pq.y * dir.y) / dirLengthSquared;
     };
@@ -1359,13 +1376,13 @@ class LineSegment {
   }
   /** 获取点的投影值
    */
-  projectValue(point) {
+  projectValue(point2) {
     const [q1, q2] = this.points;
     const dir = new Point(q2.x - q1.x, q2.y - q1.y);
     if (dir.x === 0 && dir.y === 0) {
       return 0;
     }
-    const pq = new Point(point.x - q1.x, point.y - q1.y);
+    const pq = new Point(point2.x - q1.x, point2.y - q1.y);
     const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
     const dotProduct = pq.x * dir.x + pq.y * dir.y;
     return dotProduct / dirLengthSquared;
@@ -1507,10 +1524,10 @@ class LineSegment {
   /** 判断点在当前线段的左边还是右边，或者线段上
    * @param point 
    */
-  pointPosition(point) {
+  pointPosition(point2) {
     const p1 = this.start;
     const p2 = this.end;
-    const cross = (p2.x - p1.x) * (point.y - p1.y) - (p2.y - p1.y) * (point.x - p1.x);
+    const cross = (p2.x - p1.x) * (point2.y - p1.y) - (p2.y - p1.y) * (point2.x - p1.x);
     if (Math.abs(cross) < 1e-10) {
       return "on";
     }
@@ -1683,8 +1700,8 @@ class LineSegment {
   static groupByPath(lines) {
     const pointVirtualGrid = new PointVirtualGrid();
     lines.forEach((line) => line.points.forEach((p) => pointVirtualGrid.insert(p, line)));
-    function dfs(point, group2, visted2) {
-      const list = pointVirtualGrid.queryPoint(point, true);
+    function dfs(point2, group2, visted2) {
+      const list = pointVirtualGrid.queryPoint(point2, true);
       list.forEach((item) => {
         const line = item.userData;
         if (visted2.has(line)) return;
@@ -1713,8 +1730,8 @@ class LineSegment {
   static groupByPoint(lines) {
     const unionFindSet = new UnionFindSet(lines.length), map = /* @__PURE__ */ new Map();
     for (let i = 0; i < lines.length; i++) {
-      lines[i].points.forEach((point) => {
-        const id = point.hashCode();
+      lines[i].points.forEach((point2) => {
+        const id = point2.hashCode();
         if (map.has(id)) unionFindSet.union(map.get(id), i);
         map.set(id, i);
       });
@@ -1729,8 +1746,8 @@ class LineSegment {
     Point.adsorb(lines.flatMap((line) => line.points));
     const grid = new PointVirtualGrid(), visited = /* @__PURE__ */ new Set();
     lines.forEach((line) => line.points.forEach((p) => grid.insert(p, line)));
-    function dfs(point, path, maxPath = []) {
-      const list = grid.queryPoint(point, true);
+    function dfs(point2, path, maxPath = []) {
+      const list = grid.queryPoint(point2, true);
       if (list.length === 0) {
         if (maxPath.length < path.size) {
           maxPath.length = 0;
@@ -1807,8 +1824,8 @@ class LineSegment {
     ), crossAxisMap = /* @__PURE__ */ new Map(), crossValueList = [], principalAxisStartMap = /* @__PURE__ */ new Map(), principalAxisEndMap = /* @__PURE__ */ new Map();
     lines.forEach((line) => {
       const value = crossAxis.projectValue(line.start);
-      const point = crossAxis.projectPoint(line.start, false);
-      const opt = { value, line, point, index: -1 };
+      const point2 = crossAxis.projectPoint(line.start, false);
+      const opt = { value, line, point: point2, index: -1 };
       crossAxisMap.set(line, opt);
       crossValueList.push(opt);
       line.points.forEach((p, i) => {
@@ -1857,8 +1874,8 @@ class LineSegment {
       }
       let index2 = 1;
       for (; index2 < list.length; index2++) {
-        const { point } = list[index2];
-        if (list[0].point.distance(point) > distanceThreshold) break;
+        const { point: point2 } = list[index2];
+        if (list[0].point.distance(point2) > distanceThreshold) break;
       }
       return [list.slice(0, index2).map((o) => o.line), list.slice(index2).map((o) => o.line)];
     }).flat(1);
@@ -2088,8 +2105,8 @@ class Point {
    * @param point 
    * @returns 
    */
-  equal(point) {
-    return Math.abs(point.x - this.x) < 1e-9 && Math.abs(point.y - this.y) < 1e-9;
+  equal(point2) {
+    return Math.abs(point2.x - this.x) < 1e-9 && Math.abs(point2.y - this.y) < 1e-9;
   }
   /**
    * 
@@ -2136,9 +2153,9 @@ class Point {
    * @param point
    * @returns 
    */
-  division(point) {
-    this.x -= point.x;
-    this.y -= point.y;
+  division(point2) {
+    this.x -= point2.x;
+    this.y -= point2.y;
     return this;
   }
   /**
@@ -2147,9 +2164,9 @@ class Point {
    * @param point
    * @returns 
    */
-  subtract(point) {
-    this.x -= point.x;
-    this.y -= point.y;
+  subtract(point2) {
+    this.x -= point2.x;
+    this.y -= point2.y;
     return this;
   }
   /**
@@ -2158,9 +2175,9 @@ class Point {
    * @param point 
    * @returns 
    */
-  add(point) {
-    this.x += point.x;
-    this.y += point.y;
+  add(point2) {
+    this.x += point2.x;
+    this.y += point2.y;
     return this;
   }
   parseInt() {
@@ -2173,15 +2190,15 @@ class Point {
    * @param point 
    * @param angle 旋转角度，单位为弧度
    */
-  rotate(point, angle) {
-    const dx = this.x - point.x;
-    const dy = this.y - point.y;
+  rotate(point2, angle) {
+    const dx = this.x - point2.x;
+    const dy = this.y - point2.y;
     const cosAngle = Math.cos(angle);
     const sinAngle = Math.sin(angle);
     const rotatedX = dx * cosAngle - dy * sinAngle;
     const rotatedY = dx * sinAngle + dy * cosAngle;
-    this.x = rotatedX + point.x;
-    this.y = rotatedY + point.y;
+    this.x = rotatedX + point2.x;
+    this.y = rotatedY + point2.y;
     return this;
   }
   /**
@@ -2211,9 +2228,9 @@ class Point {
    * @param point 
    * @returns 
    */
-  normal(point) {
-    const dx = this.x - point.x;
-    const dy = this.y - point.y;
+  normal(point2) {
+    const dx = this.x - point2.x;
+    const dy = this.y - point2.y;
     const length = Math.sqrt(dx * dx + dy * dy);
     if (length === 0) return Point.zero();
     const nx = -dy / length;
@@ -2226,9 +2243,9 @@ class Point {
    * @param point 
    * @returns 
    */
-  direction(point) {
-    const dx = this.x - point.x;
-    const dy = this.y - point.y;
+  direction(point2) {
+    const dx = this.x - point2.x;
+    const dy = this.y - point2.y;
     const length = Math.sqrt(dx * dx + dy * dy);
     if (length === 0) return new Point(0, 0);
     return new Point(dx / length, dy / length);
@@ -2254,8 +2271,8 @@ class Point {
    * @param point 
    * @returns 
    */
-  dot(point) {
-    return this.x * point.x + this.y * point.y;
+  dot(point2) {
+    return this.x * point2.x + this.y * point2.y;
   }
   /** 求两个点叉积
    * @description 如果叉积大于 0，a 到 b 为逆时针方向。
@@ -2263,8 +2280,8 @@ class Point {
    * @param point 
    * @returns 
    */
-  cross(point) {
-    return this.x * point.y - this.y * this.x;
+  cross(point2) {
+    return this.x * point2.y - this.y * this.x;
   }
   /** 计算两个向量夹角
    * @description 公式：a · b = |a| × |b| × cosθ
@@ -2272,28 +2289,28 @@ class Point {
    * @param point 
    * @returns 
    */
-  angleBetween(point, type = "radian", angle = "180") {
-    const dotProduct = this.dot(point);
+  angleBetween(point2, type = "radian", angle = "180") {
+    const dotProduct = this.dot(point2);
     const magnitude1 = this.magnitude();
-    const magnitude2 = point.magnitude();
+    const magnitude2 = point2.magnitude();
     if (magnitude1 === 0 || magnitude2 === 0) return 0;
     const cosTheta = dotProduct / (magnitude1 * magnitude2);
     const clampedCosTheta = Math.max(-1, Math.min(1, cosTheta));
     if (type === "radian") return Math.acos(clampedCosTheta);
     if (type === "cos") return clampedCosTheta;
-    if (angle === "180" || this.cross(point) < 0) return Math.acos(clampedCosTheta) / (Math.PI / 180);
+    if (angle === "180" || this.cross(point2) < 0) return Math.acos(clampedCosTheta) / (Math.PI / 180);
     return 360 - Math.acos(clampedCosTheta) / (Math.PI / 180);
   }
   /** 
    * @param point 
    * @returns 
    */
-  angleBetween2(point) {
+  angleBetween2(point2) {
     const magnitude1 = Math.hypot(this.x, this.y);
-    const magnitude2 = Math.hypot(point.x, point.y);
+    const magnitude2 = Math.hypot(point2.x, point2.y);
     if (magnitude1 === 0 || magnitude2 === 0) return 0;
-    const dot = this.x * point.x + this.y * point.y;
-    const cross = this.x * point.y - this.y * point.x;
+    const dot = this.x * point2.x + this.y * point2.y;
+    const cross = this.x * point2.y - this.y * point2.x;
     return Math.atan2(cross, dot);
   }
   /** 获取向量长度
@@ -2310,13 +2327,13 @@ class Point {
    * @param point 
    */
   _distanceMap = /* @__PURE__ */ new Map();
-  distance(point, cached = true) {
-    if (cached && this._distanceMap.has(point)) return this._distanceMap.get(point);
+  distance(point2, cached = true) {
+    if (cached && this._distanceMap.has(point2)) return this._distanceMap.get(point2);
     const num = Math.sqrt(
-      (this.x - point.x) * (this.x - point.x) + (this.y - point.y) * (this.y - point.y)
+      (this.x - point2.x) * (this.x - point2.x) + (this.y - point2.y) * (this.y - point2.y)
     );
     if (cached) {
-      this._distanceMap.set(point, num);
+      this._distanceMap.set(point2, num);
       Point.addDistanceCacheClear(this);
     }
     return num;
@@ -2352,19 +2369,19 @@ class Point {
     points.forEach((p) => grid.insert(p));
     const visited = /* @__PURE__ */ new Set();
     for (let i = 0; i < points.length; i++) {
-      const point = points[i];
-      if (visited.has(point)) continue;
-      const results = grid.queryCircle(point, tolerance).map((item) => item.point);
+      const point2 = points[i];
+      if (visited.has(point2)) continue;
+      const results = grid.queryCircle(point2, tolerance).map((item) => item.point);
       let countX = 0, countY = 0;
-      results.forEach((point2) => {
-        countX += point2.x;
-        countY += point2.y;
+      results.forEach((point22) => {
+        countX += point22.x;
+        countY += point22.y;
       });
       const x = countX / results.length, y = countY / results.length;
-      results.forEach((point2) => {
-        point2.set(x, y);
-        visited.add(point2);
-        grid.remove(point2);
+      results.forEach((point22) => {
+        point22.set(x, y);
+        visited.add(point22);
+        grid.remove(point22);
       });
     }
     visited.clear();
@@ -2526,15 +2543,15 @@ class Box2 {
       if (p.x >= this.minX && p.x <= this.maxX && p.y >= this.minY && p.y <= this.maxY)
         return true;
     }
-    const isPointInRect = (point) => {
+    const isPointInRect = (point2) => {
       let sign = 0;
       for (let i = 0; i < 4; i++) {
         const p1 = rPoints[i];
         const p2 = rPoints[(i + 1) % 4];
-        const cross = (p2.x - p1.x) * (point.y - p1.y) - (p2.y - p1.y) * (point.x - p1.x);
+        const cross = (p2.x - p1.x) * (point2.y - p1.y) - (p2.y - p1.y) * (point2.x - p1.x);
         if (cross === 0) {
           const denom = Math.abs(p2.x - p1.x) > 1e-10 ? p2.x - p1.x : p2.y - p1.y;
-          const t = denom ? (point.x - p1.x) / denom : 0;
+          const t = denom ? (point2.x - p1.x) / denom : 0;
           if (t >= 0 && t <= 1) return true;
         } else {
           const currentSign = cross > 0 ? 1 : -1;
@@ -2575,8 +2592,8 @@ class Box2 {
   /** 判断点是在包围盒内
    * @param point 
    */
-  containsPoint(point) {
-    return point.x >= this.minX && point.x <= this.maxX && point.y >= this.minY && point.y <= this.maxY;
+  containsPoint(point2) {
+    return point2.x >= this.minX && point2.x <= this.maxX && point2.y >= this.minY && point2.y <= this.maxY;
   }
   /**
    * 
@@ -2737,16 +2754,16 @@ class Polygon extends Array {
    * @param point 
    * @returns 'on' 边上，'inside' 内部，'outside' 外部
    */
-  pointPosition(point) {
+  pointPosition(point2) {
     if (this.length < 3) return "outside";
     const eps = 1e-10;
     for (let i = 0, j = this.length - 1; i < this.length; j = i++) {
       const a = this[j], b = this[i];
-      const cross = (b.x - a.x) * (point.y - a.y) - (b.y - a.y) * (point.x - a.x);
+      const cross = (b.x - a.x) * (point2.y - a.y) - (b.y - a.y) * (point2.x - a.x);
       if (Math.abs(cross) < eps) {
         const minX = Math.min(a.x, b.x), maxX = Math.max(a.x, b.x);
         const minY = Math.min(a.y, b.y), maxY = Math.max(a.y, b.y);
-        if (point.x >= minX - eps && point.x <= maxX + eps && point.y >= minY - eps && point.y <= maxY + eps) {
+        if (point2.x >= minX - eps && point2.x <= maxX + eps && point2.y >= minY - eps && point2.y <= maxY + eps) {
           return "on";
         }
       }
@@ -2755,9 +2772,9 @@ class Polygon extends Array {
     for (let i = 0, j = this.length - 1; i < this.length; j = i++) {
       const xi2 = this[i].x, yi2 = this[i].y;
       const xj = this[j].x, yj = this[j].y;
-      if (yi2 > point.y !== yj > point.y) {
-        const intersectionX = (xj - xi2) * (point.y - yi2) / (yj - yi2) + xi2;
-        if (point.x < intersectionX) {
+      if (yi2 > point2.y !== yj > point2.y) {
+        const intersectionX = (xj - xi2) * (point2.y - yi2) / (yj - yi2) + xi2;
+        if (point2.x < intersectionX) {
           inside = !inside;
         }
       }
@@ -2810,15 +2827,15 @@ class Polygon extends Array {
    * @param point 
    * @returns 
    */
-  pointIn(point) {
-    return this.pointPosition(point) !== "outside";
+  pointIn(point2) {
+    return this.pointPosition(point2) !== "outside";
   }
   /** 点在多边形内部，不包括路径上
    * @param point 
    * @returns 
    */
-  pointWithin(point) {
-    return this.pointPosition(point) !== "inside";
+  pointWithin(point2) {
+    return this.pointPosition(point2) !== "inside";
   }
   /** 缩放
    * @param scale 
@@ -2879,8 +2896,8 @@ class Polygon extends Array {
     while (true) {
       const list = grid.queryPoint(current, true);
       if (list.length !== 1) break;
-      const { point, userData } = list[0];
-      current = userData?.getAnotherPoint(point);
+      const { point: point2, userData } = list[0];
+      current = userData?.getAnotherPoint(point2);
       if (points.has(current)) break;
       points.add(current);
     }
@@ -3280,10 +3297,10 @@ function mergeWindow(...windowLines) {
       windowLine.currentData.wd = w;
       return windowLine;
     }), points = windowLines2.flatMap((l) => {
-      const points2 = l.points.map((point) => {
-        point.currentData.line = l;
-        point.currentData.distance = point.distance(line.start);
-        return point;
+      const points2 = l.points.map((point2) => {
+        point2.currentData.line = l;
+        point2.currentData.distance = point2.distance(line.start);
+        return point2;
       });
       points2.sort((a, b) => a.currentData.distance - b.currentData.distance);
       points2.forEach((p, index2) => p.currentData.index = index2);
@@ -3295,16 +3312,16 @@ function mergeWindow(...windowLines) {
     const newWindowLines = [];
     let activeCount = 0, mergeStart = null, lineSet = /* @__PURE__ */ new Set();
     for (let i = 0; i < points.length; i++) {
-      const point = points[i];
-      if (!mergeStart) mergeStart = point;
-      if (point.currentData.index === 0) {
+      const point2 = points[i];
+      if (!mergeStart) mergeStart = point2;
+      if (point2.currentData.index === 0) {
         activeCount++;
-        lineSet.add(point.currentData.line);
+        lineSet.add(point2.currentData.line);
         continue;
       }
       activeCount--;
       if (activeCount === 0) {
-        const newWindowLine = new LineSegment(mergeStart, point);
+        const newWindowLine = new LineSegment(mergeStart, point2);
         newWindowLine.currentData.wds = [...lineSet].map((line2) => line2.currentData.wd);
         newWindowLines.push(newWindowLine);
         mergeStart = null;
@@ -3328,8 +3345,8 @@ function clippingLineUserData(line1, line2) {
   if (drawWindow) {
     if (!line1.userData.drawWindow) line1.userData.drawWindow = [];
     drawWindow.forEach((item) => {
-      const point = Point.from(item.p);
-      const projp = line1.projectPoint(point);
+      const point2 = Point.from(item.p);
+      const projp = line1.projectPoint(point2);
       if (projp) line1.userData.drawWindow?.push(item);
     });
     recomputedWindow(line1);
@@ -3465,10 +3482,10 @@ function segmentationPath(lines, clipLine) {
       removeLines.add(line);
       continue;
     }
-    const point = line.getIntersection(queryLine);
-    if (point) {
-      if (line.start.equal(point) || line.end.equal(point)) continue;
-      const newLines = LineSegment.clipping(line, [point], clippingLineUserData);
+    const point2 = line.getIntersection(queryLine);
+    if (point2) {
+      if (line.start.equal(point2) || line.end.equal(point2)) continue;
+      const newLines = LineSegment.clipping(line, [point2], clippingLineUserData);
       removeLines.add(line);
       newLines.forEach((line2) => fractureLines.add(line2));
     }
@@ -3538,32 +3555,24 @@ function doubleWallPoint(grid, line) {
 function winDrawLine(line, grid) {
   if (line.userData.isWindow && Array.isArray(line.userData.drawWindow)) {
     mergeWindow(line);
+    const list = grid && doubleWallPoint(grid, line), dwh = defaultWallWidth$1 * 0.5;
     return line.userData.drawWindow.map(({ full, width, p, height, groundClearance }) => {
-      const point = Point.from(p), direct = line.direction();
-      let offset = 0;
-      if (full) {
-        const dwh = defaultWallWidth$1 * 0.5;
-        width = line.length();
-        if (grid) {
-          const list = doubleWallPoint(grid, line);
-          if (list[0] === 0) {
-            width += dwh;
-            offset -= dwh * 0.5;
-          } else if (list[0] === 1) {
-            width -= dwh;
-            offset += dwh * 0.5;
-          }
-          if (list[1] === 0) {
-            width += dwh;
-            offset += dwh * 0.5;
-          } else if (list[1] === 1) {
-            width -= dwh;
-            offset -= dwh * 0.5;
-          }
-        }
-      }
-      const winLine = point.expandAsLine(direct, width).directionMove(direct, -width * 0.5 + offset);
+      if (full) width = line.length();
+      const point2 = Point.from(p), direct = line.direction(), winLine = point2.expandAsLine(direct, width).directionMove(direct, -width * 0.5);
       winLine.userData = { wallWidth: defaultWallWidth$1, height, groundClearance };
+      winLine.start.copy(line.projectPoint(winLine.start, false));
+      winLine.end.copy(line.projectPoint(winLine.end, false));
+      if (!list) return winLine;
+      const startDistance = winLine.start.distance(line.start);
+      if (startDistance < dwh && list[0] === 1) {
+        const diff = dwh - startDistance;
+        winLine.startShrink(diff);
+      }
+      const endDistance = winLine.end.distance(line.end);
+      if (endDistance < dwh && list[1] === 1) {
+        const diff = dwh - endDistance;
+        winLine.endShrink(diff);
+      }
       return winLine;
     }).filter((line2) => line2.length() > defaultWallWidth$1);
   }
@@ -3580,9 +3589,9 @@ function doubleWinDrawLine(lines) {
   mergeLineUserData(newLine, lines);
   mergeWindow(newLine);
   return (newLine.userData?.drawWindow?.map(({ full, width, p, height, groundClearance }) => {
-    const point = Point.from(p), direct = newLine.direction();
+    const point2 = Point.from(p), direct = newLine.direction();
     if (full) width = newLine.length();
-    const winLine2 = point.expandAsLine(direct, width).directionMove(direct, -width * 0.5);
+    const winLine2 = point2.expandAsLine(direct, width).directionMove(direct, -width * 0.5);
     try {
       winLine2.start.copy(newLine.projectPoint(winLine2.start, false));
       winLine2.end.copy(newLine.projectPoint(winLine2.end, false));
@@ -3951,7 +3960,7 @@ class CAD {
       drawDottedLine(p2C, p2, 0.04, 0.05, "line2");
       drawLine2(p1C, p2C);
       color = "white";
-      drawText2((length * 10).toFixed(2) + "cm", line.center);
+      drawText2((length * 100).toFixed(2) + "cm", line.center);
     }
     function drawArc(pos, radius, startAngle, endAngle) {
       data.arcs.push([
@@ -4412,21 +4421,21 @@ class LineSegmentUndirectedGraph extends UndirectedGraph {
   /** 
    * 获取或创建点的索引
    */
-  getOrCreateIndex(point) {
-    const code = point.hashCode();
+  getOrCreateIndex(point2) {
+    const code = point2.hashCode();
     let index2 = this.pointToIndex.get(code);
     if (index2 === void 0) {
       index2 = this.nextIndex++;
       this.pointToIndex.set(code, index2);
-      this.indexToPoint.set(index2, point);
+      this.indexToPoint.set(index2, point2);
     }
     return index2;
   }
   /** 
    * 安全获取点索引（已存在才返回）
    */
-  getIndex(point) {
-    return this.pointToIndex.get(point.hashCode());
+  getIndex(point2) {
+    return this.pointToIndex.get(point2.hashCode());
   }
   /** 
    * @param index 
@@ -4500,17 +4509,17 @@ function smallestCircle(lines, ringEdges, halfCircle = false) {
     const center = line.center, direct = line.normal(), otherPoint = line.getAnotherPoint(startPoint), lineDirect = otherPoint.direction(startPoint);
     temLine.start.copy(center);
     temLine.end.copy(center).add(direct.clone().multiplyScalar(1));
-    const point = preInnerDirect.getIntersection(temLine);
-    temLine.end.copy(point);
+    const point2 = preInnerDirect.getIntersection(temLine);
+    temLine.end.copy(point2);
     if (preInnerDirect.direction().angleBetween(lineDirect) > PI_1 * 170) temLine.mirror();
     return temLine.clone();
   }
-  function dfs(edge, line, point, preInnerDirect, path, isPreInnerDirect = true) {
+  function dfs(edge, line, point2, preInnerDirect, path, isPreInnerDirect = true) {
     if (path.length > lines.length) return;
     if (visited.has(line)) return;
     visited.add(line);
-    let innerDirect = isPreInnerDirect ? getInnerDirect(line, point, preInnerDirect) : preInnerDirect;
-    const otherPoint = line.getAnotherPoint(point);
+    let innerDirect = isPreInnerDirect ? getInnerDirect(line, point2, preInnerDirect) : preInnerDirect;
+    const otherPoint = line.getAnotherPoint(point2);
     let result = grid.queryPoint(otherPoint, true);
     if (result.length === 1) {
       const item = result[0], nextLine = item.userData;
@@ -4548,8 +4557,8 @@ function smallestCircle(lines, ringEdges, halfCircle = false) {
       visited.clear();
       const directLine = directLines[i], d0 = directLine.direction(), path = [line];
       if (dfs(line, line, line.start, directLine, path, false)) {
-        const point = center.clone().add(d0.multiplyScalar(5e-4));
-        if (path.length > 5 && !Polygon.fromByLines(path).pointIn(point)) {
+        const point2 = center.clone().add(d0.multiplyScalar(5e-4));
+        if (path.length > 5 && !Polygon.fromByLines(path).pointIn(point2)) {
           continue;
         } else {
           ringList.push(path);
@@ -4719,15 +4728,15 @@ function migration(newLine, oldLine) {
   if (oldLine.userData.isWindow) {
     newLine.userData.isWindow = true;
     newLine.userData.drawWindow = oldLine.userData.drawWindow?.filter((w) => {
-      const point = Point.from(w.p);
-      return !!newLine.projectPoint(point);
+      const point2 = Point.from(w.p);
+      return !!newLine.projectPoint(point2);
     }) ?? [];
   }
   if (oldLine.currentData.isFittedLine) {
     const userDataList = oldLine.currentData.userDataList;
     newLine.userData.isBayWindow = false;
-    userDataList.forEach((userData, point) => {
-      if (newLine.projectPoint(point)) {
+    userDataList.forEach((userData, point2) => {
+      if (newLine.projectPoint(point2)) {
         if (userData.isBayWindow) {
           newLine.userData.isBayWindow = true;
         }
@@ -4741,9 +4750,9 @@ function lineSegmentClipping(lines, minLen = 0.03) {
   const result = lines.flatMap((line) => {
     const points = quadtree.queryLineSegment(line, true).map((res) => {
       if (res.line === line) return;
-      const point = res.line.getIntersection(line);
-      if (!point || line.start.equal(point) || line.end.equal(point)) return;
-      return point;
+      const point2 = res.line.getIntersection(line);
+      if (!point2 || line.start.equal(point2) || line.end.equal(point2)) return;
+      return point2;
     }).filter((i) => !!i);
     if (points.length) {
       const cloneLine = line.clone();
@@ -4898,17 +4907,17 @@ function shortDistanceLink(lines, radius = 0.1, pointVirtualGrid) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i], distanceMap = /* @__PURE__ */ new Map();
     if (line.userData.isDoor) continue;
-    line.points.forEach((point) => {
-      if (visited.has(point)) return false;
-      if (pointVirtualGrid.queryPoint(point).length > 1) return;
-      const list = pointVirtualGrid.queryCircle(point, radius).filter((item) => {
+    line.points.forEach((point2) => {
+      if (visited.has(point2)) return false;
+      if (pointVirtualGrid.queryPoint(point2).length > 1) return;
+      const list = pointVirtualGrid.queryCircle(point2, radius).filter((item) => {
         if (visited.has(item.point)) return false;
         const resLine = item.userData;
         if (resLine === line || !line.parallel(resLine, 25)) return false;
         if (pointVirtualGrid.queryPoint(item.point).length > 1) return false;
-        const distance = point.distance(item.point);
+        const distance = point2.distance(item.point);
         if (distance < 1e-3) return false;
-        const direct1 = point.direction(line.getAnotherPoint(point)), direct2 = item.point.direction(resLine.getAnotherPoint(item.point));
+        const direct1 = point2.direction(line.getAnotherPoint(point2)), direct2 = item.point.direction(resLine.getAnotherPoint(item.point));
         if (180 - direct1.angleBetween(direct2, "angle") < 25) {
           distanceMap.set(item.point, distance);
           return true;
@@ -4918,11 +4927,11 @@ function shortDistanceLink(lines, radius = 0.1, pointVirtualGrid) {
         return aDistance - bDistance;
       });
       if (list.length === 0) return;
-      visited.add(point);
+      visited.add(point2);
       visited.add(list[0].point);
       const targetLine = list[0].userData;
       const projectLine1 = line.projectLineSegment(targetLine), projectLine2 = targetLine.projectLineSegment(line), len1 = projectLine1.length(), len2 = projectLine2.length();
-      if (len1 === 0 && len2 === 0) appendLines.push(new LineSegment(point.clone(), list[0].point.clone()));
+      if (len1 === 0 && len2 === 0) appendLines.push(new LineSegment(point2.clone(), list[0].point.clone()));
       else appendLines.push(new LineSegment(projectLine1.center, projectLine2.center));
     });
   }
@@ -5052,11 +5061,11 @@ function correction$1(targettLine, lines, intersectMap, errAngle = 15) {
 function groupByAxis(lines, principalAxis, crossAxis, principalAxisThreshold, crossAxistThreshold) {
   const projectPoints = [], crossAxisMap = /* @__PURE__ */ new Map();
   lines.forEach((line) => {
-    const point = crossAxis.projectPoint(line.start, false);
-    if (point) {
-      point.userData = line;
-      projectPoints.push(point);
-      crossAxisMap.set(line, point);
+    const point2 = crossAxis.projectPoint(line.start, false);
+    if (point2) {
+      point2.userData = line;
+      projectPoints.push(point2);
+      crossAxisMap.set(line, point2);
     }
   });
   projectPoints.sort((a, b) => {
@@ -5064,27 +5073,27 @@ function groupByAxis(lines, principalAxis, crossAxis, principalAxisThreshold, cr
   });
   const groups = [], group2 = [];
   for (let i = 0; i < projectPoints.length; i++) {
-    const point = projectPoints[i];
+    const point2 = projectPoints[i];
     if (i === 0) {
-      group2.push(point);
+      group2.push(point2);
       continue;
     }
     const prePoint = projectPoints[i - 1];
-    if (prePoint.distance(point) < crossAxistThreshold) group2.push(point);
+    if (prePoint.distance(point2) < crossAxistThreshold) group2.push(point2);
     else {
       groups.push([...group2]);
       group2.length = 0;
-      group2.push(point);
+      group2.push(point2);
     }
     if (i === projectPoints.length - 1) groups.push(group2);
   }
   return groups.flatMap((group3) => {
-    const points = group3.flatMap((point) => {
-      const line = point.userData;
+    const points = group3.flatMap((point2) => {
+      const line = point2.userData;
       return line.points.map((p) => {
-        const point2 = principalAxis.projectPoint(p, false);
-        point2.userData = line;
-        return point2;
+        const point22 = principalAxis.projectPoint(p, false);
+        point22.userData = line;
+        return point22;
       });
     });
     points.sort((a, b) => {
@@ -5092,15 +5101,15 @@ function groupByAxis(lines, principalAxis, crossAxis, principalAxisThreshold, cr
     });
     const map = /* @__PURE__ */ new Map(), newGroup = [];
     let newGroups = [];
-    points.forEach((point, i) => {
+    points.forEach((point2, i) => {
       if (map.size === 0 && i > 0) {
         const prePoint = points[i - 1];
-        if (prePoint.distance(point) > principalAxisThreshold) {
+        if (prePoint.distance(point2) > principalAxisThreshold) {
           newGroups.push([...newGroup]);
           newGroup.length = 0;
         }
       }
-      map.set(point.userData, (map.get(point.userData) ?? 0) + 1);
+      map.set(point2.userData, (map.get(point2.userData) ?? 0) + 1);
       for (const v of map.values()) if (v !== 2) return;
       newGroup.push(...map.keys());
       map.clear();
@@ -5113,8 +5122,8 @@ function groupByCrossAxis(lines, principalAxis, crossAxis, crossAxistThreshold)
   const crossAxisMap = /* @__PURE__ */ new Map(), crossValueList = [], principalAxisStartMap = /* @__PURE__ */ new Map(), principalAxisEndMap = /* @__PURE__ */ new Map();
   lines.forEach((line) => {
     const value = crossAxis.projectValue(line.start);
-    const point = crossAxis.projectPoint(line.start, false);
-    const opt = { value, line, point, index: -1 };
+    const point2 = crossAxis.projectPoint(line.start, false);
+    const opt = { value, line, point: point2, index: -1 };
     crossAxisMap.set(line, opt);
     crossValueList.push(opt);
     line.points.forEach((p, i) => {
@@ -5163,8 +5172,8 @@ function groupByCrossAxis(lines, principalAxis, crossAxis, crossAxistThreshold)
     }
     let index2 = 1;
     for (; index2 < list.length; index2++) {
-      const { point } = list[index2];
-      if (list[0].point.distance(point) > crossAxistThreshold) break;
+      const { point: point2 } = list[index2];
+      if (list[0].point.distance(point2) > crossAxistThreshold) break;
     }
     return [list.slice(0, index2).map((o) => o.line), list.slice(index2).map((o) => o.line)];
   }).flat(1);
@@ -5287,50 +5296,50 @@ function adsorption(lines, intersectionMap, option) {
   lines.forEach((line) => {
     if (line.userData.isDoor) return;
     quadtree.insert(line);
-    line.points.forEach((point) => pointVirtualGrid.insert(point, line));
+    line.points.forEach((point2) => pointVirtualGrid.insert(point2, line));
   });
   function setPoint(line, line1) {
     if (!map.has(line)) map.set(line, []);
     map.get(line)?.push(line1);
   }
-  function getAdsorptionPointByLine(point, line) {
-    if (quadtree.queryPoint(point).length > 1) return;
+  function getAdsorptionPointByLine(point2, line) {
+    if (quadtree.queryPoint(point2).length > 1) return;
     const direction = line.direction().multiplyScalar(threshold);
-    queryLine.set(point, point);
+    queryLine.set(point2, point2);
     queryLine.start.add(direction);
     queryLine.end.add(direction.multiplyScalar(-1));
     const map2 = /* @__PURE__ */ new Map();
     const list = quadtree.queryLineSegment(queryLine).filter((res) => res.line !== line).map((res) => {
-      const point2 = res.line.getIntersection(queryLine);
-      map2.set(res.line, point2);
+      const point22 = res.line.getIntersection(queryLine);
+      map2.set(res.line, point22);
       return res.line;
     }).sort((line1, line2) => {
       const point1 = map2.get(line1);
-      const point2 = map2.get(line2);
-      if (point1 && point2) return point1.distance(point) - point2.distance(point);
+      const point22 = map2.get(line2);
+      if (point1 && point22) return point1.distance(point2) - point22.distance(point2);
       return 0;
     });
     if (list.length) return map2.get(list[0]);
   }
-  function getObtainNearestAbsorbableLine(point, line) {
-    let newPoint = getAdsorptionPointByLine(point, line);
+  function getObtainNearestAbsorbableLine(point2, line) {
+    let newPoint = getAdsorptionPointByLine(point2, line);
     if (newPoint) {
-      return setPoint(line, new LineSegment(point.clone(), newPoint.clone()));
+      return setPoint(line, new LineSegment(point2.clone(), newPoint.clone()));
     }
-    if (pointVirtualGrid.queryPoint(point).filter((item) => item.userData !== line).length !== 0) return;
-    const list0 = quadtree.queryCircle(point, 1e-3).filter((item) => item.line !== line);
+    if (pointVirtualGrid.queryPoint(point2).filter((item) => item.userData !== line).length !== 0) return;
+    const list0 = quadtree.queryCircle(point2, 1e-3).filter((item) => item.line !== line);
     if (list0.length > 0) return;
-    const list = pointVirtualGrid.queryCircle(point, threshold).filter((item) => item.userData !== line && item.userData?.vertical(line)).sort((item02, item1) => item02.point.distance(point) - item1.point.distance(point));
+    const list = pointVirtualGrid.queryCircle(point2, threshold).filter((item) => item.userData !== line && item.userData?.vertical(line)).sort((item02, item1) => item02.point.distance(point2) - item1.point.distance(point2));
     if (!list.length) return;
     const item0 = list[0];
-    const pPoint = item0.userData?.projectPoint(point, false);
+    const pPoint = item0.userData?.projectPoint(point2, false);
     if (pPoint) {
       const line0 = item0.userData;
-      setPoint(line, new LineSegment(point.clone(), pPoint.clone()));
+      setPoint(line, new LineSegment(point2.clone(), pPoint.clone()));
       setPoint(line0, new LineSegment(item0.point.clone(), pPoint.clone()));
     }
   }
-  function handle(line, point, intersectList) {
+  function handle(line, point2, intersectList) {
     return null;
   }
   for (let i = 0; i < lines.length; i++) {
@@ -5341,12 +5350,12 @@ function adsorption(lines, intersectionMap, option) {
       else groups2[1].push(item);
       return groups2;
     }, [[], []]);
-    const [isStart, isEnd] = line.points.map((point, j) => {
-      if (!pointVirtualGrid.queryPoint(point, true).length) {
-        const newPoint = handle(line, point, groups[j]);
+    const [isStart, isEnd] = line.points.map((point2, j) => {
+      if (!pointVirtualGrid.queryPoint(point2, true).length) {
+        const newPoint = handle(line, point2, groups[j]);
         if (newPoint) {
-          point.copy(newPoint);
-          pointVirtualGrid.update(point);
+          point2.copy(newPoint);
+          pointVirtualGrid.update(point2);
           quadtree.update(line);
         } else return false;
       }
@@ -5392,8 +5401,8 @@ function doorRecover(doorLines) {
         doorLine.start.copy(startIntersection.end);
       }
     } else {
-      const point = startIntersection.projectPoint(doorLine.start);
-      point && doorLine.start.copy(point);
+      const point2 = startIntersection.projectPoint(doorLine.start);
+      point2 && doorLine.start.copy(point2);
     }
     if (doorLine.parallel(endIntersection, 45)) {
       if (doorLine.end.distance(endIntersection.start) < doorLine.end.distance(endIntersection.end)) {
@@ -5402,8 +5411,8 @@ function doorRecover(doorLines) {
         doorLine.end.copy(endIntersection.end);
       }
     } else {
-      const point = endIntersection.projectPoint(doorLine.end);
-      point && doorLine.end.copy(point);
+      const point2 = endIntersection.projectPoint(doorLine.end);
+      point2 && doorLine.end.copy(point2);
     }
     lines.push(startIntersection, endIntersection);
   }
@@ -5414,32 +5423,32 @@ function doorAdsorption(lines, doorLines) {
   const quadtree = createQuadtree(lines);
   for (let i = 0; i < doorLines.length; i++) {
     const doorLine = doorLines[i];
-    doorLine.points.map((point) => {
-      if (quadtree.queryPoint(point).length !== 0) return;
-      const otherPoint = doorLine.getAnotherPoint(point), queryLine = point.expandAsLine(point.direction(otherPoint), 0.4);
+    doorLine.points.map((point2) => {
+      if (quadtree.queryPoint(point2).length !== 0) return;
+      const otherPoint = doorLine.getAnotherPoint(point2), queryLine = point2.expandAsLine(point2.direction(otherPoint), 0.4);
       const list = grid.queryCircle(queryLine.center, 0.4).flatMap((item) => {
         if (item.userData?.vertical(doorLine, 35)) {
-          const pPoint = item.userData.projectPoint(point);
+          const pPoint = item.userData.projectPoint(point2);
           if (pPoint) {
             return [item.point, pPoint];
           }
         }
         return [item.point];
-      }).sort((a, b) => a.distance(point) - b.distance(point));
+      }).sort((a, b) => a.distance(point2) - b.distance(point2));
       if (list.length) {
-        point.copy(list[0]);
+        point2.copy(list[0]);
       } else {
         const list2 = quadtree.queryLineSegment(queryLine).flatMap((item) => {
           if (item.line.vertical(doorLine, 35)) {
-            const pPoint = item.line.projectPoint(point);
+            const pPoint = item.line.projectPoint(point2);
             if (pPoint) {
               return [pPoint];
             }
           }
           return [];
-        }).sort((a, b) => a.distance(point) - b.distance(point));
+        }).sort((a, b) => a.distance(point2) - b.distance(point2));
         if (list2.length) {
-          point.copy(list2[0]);
+          point2.copy(list2[0]);
         }
       }
     });
@@ -5552,21 +5561,21 @@ function getIntersection(line, mode, cell) {
   }, [-1, -1, -1]);
 }
 function createNewLine(cell, reference, opt, appendLines, grid) {
-  const { point } = cell[opt[0]];
-  const newLine = new LineSegment(point.clone(), reference.clone());
+  const { point: point2 } = cell[opt[0]];
+  const newLine = new LineSegment(point2.clone(), reference.clone());
   newLine.points.forEach((p) => grid.insert(p, newLine));
   appendLines.push(newLine);
   return newLine;
 }
 function setSameDirection(cell, reference, opt, grid) {
-  const { point } = cell[opt[1]];
-  point.copy(reference);
-  grid.update(point);
+  const { point: point2 } = cell[opt[1]];
+  point2.copy(reference);
+  grid.update(point2);
 }
 function setDifferentDirection(cell, reference, opt, grid) {
-  const { point } = cell[opt[2]];
-  point.copy(reference);
-  grid.update(point);
+  const { point: point2 } = cell[opt[2]];
+  point2.copy(reference);
+  grid.update(point2);
 }
 function modify(reference, cell, opt, appendLines, grid) {
   const hasParallel = opt[0] > -1, hasSameDirection = opt[1] > -1, hasDifferentDirection = opt[2] > -1;
@@ -5623,9 +5632,9 @@ class BoundExt {
       }
       const center = line.center;
       const set2 = /* @__PURE__ */ new Set();
-      for (const point of trajectoryPoints) {
+      for (const point2 of trajectoryPoints) {
         if (set2.size === 2) break;
-        const lineA = new LineSegment(center, point);
+        const lineA = new LineSegment(center, point2);
         const list = quadtree.queryLineSegment(lineA).filter((target) => {
           if (target.line === line) return false;
           if (LineGroupType.hasGroup(line)) return true;
@@ -5638,7 +5647,7 @@ class BoundExt {
           return true;
         });
         if (!list.length) {
-          const position = line.pointPosition(point);
+          const position = line.pointPosition(point2);
           position !== "on" && set2.add(position);
         }
       }
@@ -5729,16 +5738,16 @@ function findMinRing(lines, ringEdges) {
     const center = line.center, direct = line.normal();
     temLine.start.copy(center);
     temLine.end.copy(center).add(direct.clone().multiplyScalar(1));
-    const point = preDirect.getIntersection(temLine);
-    temLine.end.copy(point);
+    const point2 = preDirect.getIntersection(temLine);
+    temLine.end.copy(point2);
     return temLine.clone();
   }
-  function find(edge, line, point, preLine, preDirect, path, isPreDirect = true) {
+  function find(edge, line, point2, preLine, preDirect, path, isPreDirect = true) {
     if (path.length > lines.length) return;
     if (visited.has(line)) return;
     visited.add(line);
     let direct;
-    const otherPoint = line.getAnotherPoint(point);
+    const otherPoint = line.getAnotherPoint(point2);
     if (isPreDirect) {
       if (line.vertical(preLine)) direct = getDirect(line, preDirect);
       else {
@@ -5751,7 +5760,7 @@ function findMinRing(lines, ringEdges) {
       const item = result[0], nextLine = item.userData, otherPoint1 = nextLine.getAnotherPoint(item.point), d0 = otherPoint1.direction(item.point);
       if (edge === nextLine) return path;
       if (nextLine.vertical(line)) {
-        const d1 = otherPoint.direction(point), center = nextLine.center, isSameDirection = d0.angleBetween(direct.direction()) < 1e-9;
+        const d1 = otherPoint.direction(point2), center = nextLine.center, isSameDirection = d0.angleBetween(direct.direction()) < 1e-9;
         direct.start.copy(center);
         direct.end.copy(center).add(d1.multiplyScalar(0.02));
         if (isSameDirection) direct.end.rotate(direct.start, Math.PI);
@@ -6010,9 +6019,9 @@ function lineDataToThreeVJiaJson(lineSegments, angle = 0, updateGroup = true) {
   newLines = LineSegmentUndirectedGraph.rotate(newLines, angle, (line, center, angle2) => {
     if (line.userData.drawWindow) {
       line.userData.drawWindow.forEach((windowItem) => {
-        const point = Point.from(windowItem.p);
-        point.rotate(center, angle2 * (Math.PI / 180));
-        windowItem.p = point.toJson(windowItem.p.z);
+        const point2 = Point.from(windowItem.p);
+        point2.rotate(center, angle2 * (Math.PI / 180));
+        windowItem.p = point2.toJson(windowItem.p.z);
       });
     }
   });
@@ -6023,6 +6032,38 @@ function lineDataToThreeVJiaJson(lineSegments, angle = 0, updateGroup = true) {
     }
   };
 }
+const point = new Point();
+class HeightQuery {
+  static query(line, rootTopContourInfo) {
+    const inLinePoints = [], len = line.length(), newLine = line.clone(), center = line.center;
+    newLine.startShrink(len * 0.2);
+    newLine.endShrink(len * 0.2);
+    inLinePoints.push([center.x, center.y], [newLine.start.x, newLine.start.y], [newLine.end.x, newLine.end.y]);
+    const contoursData = this.whichContourContainsPoint(inLinePoints, rootTopContourInfo);
+    contoursData.sort((a, b) => a.averagePz - b.averagePz);
+    const height = contoursData[0]?.averagePz ?? DEFAULT_WALL_HEIGHT;
+    return height;
+  }
+  static whichContourContainsPoint(points, rootTopContourInfo) {
+    const contoursData = [], { contours, maxContourIndex, quadtree } = rootTopContourInfo;
+    points.filter((p) => {
+      point.set(p[0], p[1]);
+      for (let i = 0; i < contours.length; i++) {
+        const { contour, polygon } = contours[i];
+        if (!contour.length || i === maxContourIndex) continue;
+        if (polygon?.pointIn(point)) contoursData.push({ i, averagePz: contours[i].averagePz });
+      }
+    });
+    if (contoursData.length) return contoursData;
+    points.filter((p) => {
+      point.set(p[0], p[1]);
+      new Array(...new Set(quadtree?.queryCircle(point, 0.4).map((item) => item.line.currentData.contourIndex))).forEach((index2) => {
+        contoursData.push({ i: index2, averagePz: contours[index2].averagePz });
+      });
+    });
+    return contoursData;
+  }
+}
 const PRE_PROCESSOR = {
   DoorsAnalysis(lines) {
     return lines;
@@ -6085,8 +6126,6 @@ class Dxf extends Component {
   verticalReferenceLine;
   originalZAverage = 0;
   _preProcessorSet = /* @__PURE__ */ new Set();
-  trajectory = null;
-  onBoundExt;
   /** 原始数据组
    */
   get lines() {
@@ -6099,9 +6138,25 @@ class Dxf extends Component {
     super();
     this.width = width;
   }
-  setTrajectory(trajectory, onBoundExt) {
-    this.trajectory = trajectory;
-    this.onBoundExt = this.onBoundExt ?? onBoundExt;
+  /** 添加预处理
+   * @param handler 
+   */
+  addPreProcessor(handler) {
+    this._preProcessorSet.add(handler);
+    return this;
+  }
+  /** 删除预处理
+   * @param handler 
+   */
+  removePreProcessor(handler) {
+    this._preProcessorSet.delete(handler);
+    return this;
+  }
+  /** 清空预处理
+   * @returns 
+   */
+  clearPreProcessor() {
+    this._preProcessorSet.clear();
     return this;
   }
   /** 完整线段数据
@@ -6128,8 +6183,27 @@ class Dxf extends Component {
   preprocessing(data, options) {
     let { lineSegments, originalZAverage } = originalDataToLineData(data);
     this.originalZAverage = originalZAverage;
+    if (options?.publicInfo?.rootTopContourInfo) {
+      const polygons = options.publicInfo.rootTopContourInfo.contours.map((item) => {
+        if (!item.polygon) Object.defineProperty(item, "polygon", { value: new Polygon(Point.fromByList(item.contour)) });
+        return item.polygon;
+      });
+      if (!options.publicInfo.rootTopContourInfo.quadtree) {
+        const lines = polygons.flatMap((polygon, index2) => {
+          const lines2 = polygon?.toLines() ?? [];
+          lines2.forEach((line) => line.currentData.contourIndex = index2);
+          return lines2;
+        });
+        const quadtree = createQuadtree(lines);
+        Object.defineProperty(options.publicInfo.rootTopContourInfo, "quadtree", { value: quadtree });
+      }
+    }
     lineSegments.forEach((line) => {
       if (line.userData.isDoor && line.userData.doorDirectConnection) this.doorLineSegment.push(line);
+      if (!("height" in line.userData)) {
+        if (typeof line.userData.rooftopPz === "number") line.userData.height = Math.abs(line.userData.rooftopPz - originalZAverage);
+        else if (options?.publicInfo?.rootTopContourInfo) line.userData.height = HeightQuery.query(line, options.publicInfo.rootTopContourInfo);
+      }
     });
     this._preProcessorSet.forEach((handler) => {
       lineSegments = handler(lineSegments, options);
@@ -6138,27 +6212,6 @@ class Dxf extends Component {
     this.verticalReferenceLine.userData.isVerticalReferenceLine = true;
     return { lineSegments, data };
   }
-  /** 添加预处理
-   * @param handler 
-   */
-  addPreProcessor(handler) {
-    this._preProcessorSet.add(handler);
-    return this;
-  }
-  /** 删除预处理
-   * @param handler 
-   */
-  removePreProcessor(handler) {
-    this._preProcessorSet.delete(handler);
-    return this;
-  }
-  /** 清空预处理
-   * @returns 
-   */
-  clearPreProcessor() {
-    this._preProcessorSet.clear();
-    return this;
-  }
   /** 设置
    * @param data 房屋结构数据，node环境可以为路径
    * @param width 墙体宽度
@@ -6167,6 +6220,7 @@ class Dxf extends Component {
    * @param option 
    * @returns 
    */
+  options = {};
   async set(data, options = {}) {
     if (typeof data === "string") {
       if (typeof global !== "undefined") {
@@ -6183,6 +6237,7 @@ class Dxf extends Component {
     if (data.length === 0) return;
     this.doorLineSegment.length = 0;
     this.cad = null;
+    this.options = options;
     if (data.length === 0) {
       this.lineSegments = [];
       this.originalData = data;
@@ -6199,12 +6254,14 @@ class Dxf extends Component {
     this.dispatchEvent({
       type: "dataChange",
       originalData: this.originalData,
-      data: this.data
+      data: this.data,
+      options
     });
     this.dispatchEvent({
       type: "setDta",
       originalData: this.originalData,
-      data: this.data
+      data: this.data,
+      options
     });
     let lines = this.getLineSegments(true);
     const doors = lines.filter((line) => line.userData.isDoor);
@@ -6214,11 +6271,13 @@ class Dxf extends Component {
     this.cad = new CAD().usePlugin(new DxfDataPlugin(lines)).usePlugin(new DxfDrawPlugin());
     this.dispatchEvent({
       type: "cadChange",
-      cad: this.cad
+      cad: this.cad,
+      options
     });
     this.dispatchEvent({
       type: "lineOffset",
-      cad: this.cad
+      cad: this.cad,
+      options
     });
   }
   /**
@@ -6383,11 +6442,11 @@ class DoorsAnalysis {
       }
       return false;
     });
-    this.addPointsExcludeRule((_1, point) => {
-      return !!this.doorPoint.find((p1) => p1.point.equal(point));
+    this.addPointsExcludeRule((_1, point2) => {
+      return !!this.doorPoint.find((p1) => p1.point.equal(point2));
     });
-    this.addPointsExcludeRule((_1, point) => {
-      return !!this.calculatedDoorPoint.find((p1) => p1.point.equal(point));
+    this.addPointsExcludeRule((_1, point2) => {
+      return !!this.calculatedDoorPoint.find((p1) => p1.point.equal(point2));
     });
     this.possibleDoorPoints = this.getPossiblePoints();
     this.possibleDoorPoints.forEach((p) => {
@@ -6430,10 +6489,10 @@ class DoorsAnalysis {
       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 point2 = line.start.clone().add(direction.clone().multiplyScalar(dxf.width + step * i));
         const rLine = new LineSegment(
-          point,
-          point.clone().add(normal.clone().multiplyScalar(1))
+          point2,
+          point2.clone().add(normal.clone().multiplyScalar(1))
         );
         rLine.directionMove(normal, -0.5);
         const res = this.quadtree.queryLineSegment(rLine);
@@ -6478,8 +6537,8 @@ class DoorsAnalysis {
       if (doorData.doorDirectConnection) {
         this.continueFind = false;
         this.dxf.doorLineSegment.push(doorLine);
-        doorLine.points.forEach((point) => {
-          const res = pointVirtualGrid.queryPoint(point);
+        doorLine.points.forEach((point2) => {
+          const res = pointVirtualGrid.queryPoint(point2);
           if (res.length) {
             calculatedDoorPoint.push({
               line: res[0].userData,
@@ -6489,19 +6548,19 @@ class DoorsAnalysis {
           }
         });
       } else if (doorData.drawDoorData) {
-        const point = Point.from(doorData.drawDoorData.start);
+        const point2 = Point.from(doorData.drawDoorData.start);
         const direct = Point.from(doorData.drawDoorData.n);
-        const resList = pointVirtualGrid.queryPoint(point).filter((res) => {
+        const resList = pointVirtualGrid.queryPoint(point2).filter((res) => {
           if (res.userData === doorLine) return false;
           const line = res.userData;
           const direct2 = line.direction();
-          if (line.start.equal(point)) direct2.multiplyScalar(-1);
+          if (line.start.equal(point2)) direct2.multiplyScalar(-1);
           const angle = direct.angleBetween(direct2, "angle");
           return angle > 180 - 10 || angle < 10;
         });
         if (resList.length) doorPoints.push({
           line: resList[0].userData,
-          point,
+          point: point2,
           uuid: uuid()
         });
       } else {
@@ -6537,10 +6596,10 @@ class DoorsAnalysis {
    */
   searchNearby(doorPoints, possibleDoorPoints = [], doorSearchDistance = this.doorSearchDistance, doorSearchNearAngle = this.doorSearchNearAngle) {
     const findPointVirtualGrid = this.findPointVirtualGrid, quadtree = this.quadtree;
-    function find({ point, line }, doorIndex, record2) {
+    function find({ point: point2, line }, doorIndex, record2) {
       const direct = line.direction();
-      if (line.start === point) direct.multiplyScalar(-1);
-      const res = findPointVirtualGrid.queryCircle(point, doorSearchDistance).filter((r) => r.userData !== line).sort((a, b) => a.point.distance(point) - b.point.distance(point));
+      if (line.start === point2) direct.multiplyScalar(-1);
+      const res = findPointVirtualGrid.queryCircle(point2, doorSearchDistance).filter((r) => r.userData !== line).sort((a, b) => a.point.distance(point2) - b.point.distance(point2));
       const list = [];
       for (let i = 0; i < res.length; i++) {
         const doorIndex2 = possibleDoorPoints.findIndex((p) => p.point === res[i].point);
@@ -6549,7 +6608,7 @@ class DoorsAnalysis {
         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");
+        const targetPoint = res[i].point, line2 = new LineSegment(point2.clone(), targetPoint.clone()), angle = line2.direction().angleBetween(direct, "angle");
         if (angle < doorSearchNearAngle) {
           const direct2 = doorPoints[doorIndex].line.direction();
           const line22 = res[i].userData;
@@ -6557,7 +6616,7 @@ class DoorsAnalysis {
           const angle2 = line2.direction().multiplyScalar(-1).angleBetween(direct2, "angle");
           if (angle2 < doorSearchNearAngle) {
             const queryList = quadtree.queryLineSegment(line2).filter((item) => {
-              if (item.line.start.equal(point) || item.line.end.equal(point)) return false;
+              if (item.line.start.equal(point2) || item.line.end.equal(point2)) return false;
               if (item.line === line22) return false;
               return true;
             });
@@ -6679,17 +6738,17 @@ class DoorsAnalysis {
    * @param param0 
    * @returns 
    */
-  searchAlongDirection({ point, line }, doorSearchDistance = this.doorSearchDistance) {
+  searchAlongDirection({ point: point2, 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) => {
+    if (line.start === point2) direct.multiplyScalar(-1);
+    const endPoint = point2.clone().add(direct.clone().multiplyScalar(doorSearchDistance)), rline = new LineSegment(point2.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));
+    }).filter((i) => i.point).sort((a, b) => point2.distance(a.point) - point2.distance(b.point));
     if (result.length) {
       const item = result[0];
       if (Math.abs(90 - item.line.direction().angleBetween(direct, "angle")) < 5) {
@@ -6703,10 +6762,10 @@ class DoorsAnalysis {
    * @param doorSearchDistance 
    * @returns 
    */
-  searchAlongNormalDirection({ point, line }, doorSearchDistance = this.doorSearchDistance) {
+  searchAlongNormalDirection({ point: point2, 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);
+    if (line.start === point2) direct.multiplyScalar(-1);
+    if (line.start === point2) 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];
@@ -6719,14 +6778,14 @@ class DoorsAnalysis {
         break;
       }
     }
-    const rline3 = new LineSegment(point.clone(), point.clone().add(normal.multiplyScalar(doorSearchDistance)));
+    const rline3 = new LineSegment(point2.clone(), point2.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));
+    }).filter((i) => i.point).sort((a, b) => point2.distance(a.point) - point2.distance(b.point));
     if (r3.length) {
       const item = r3[0];
       if (Math.abs(90 - item.line.direction().angleBetween(normal, "angle")) < 5) {
@@ -6927,25 +6986,25 @@ function drawLines$1(lines, parameters, offset = 1e-3) {
     }
   }
 }
-function drawPoint(point, parameters, offset = 1e-3) {
+function drawPoint(point2, parameters, offset = 1e-3) {
   const dxfSystem = DxfSystem.finalInstance;
   if (dxfSystem) {
     const renderer = dxfSystem.findComponentByName("Renderer");
     if (renderer) {
       const editor = dxfSystem.findComponentByName("Editor");
-      const obj3d = renderer.createCircle(point, parameters, editor?.container);
+      const obj3d = renderer.createCircle(point2, parameters, editor?.container);
       obj3d.position.z = offset;
       return obj3d;
     }
   }
 }
-function drawText$1(text, point, style, offset = 1e-3) {
+function drawText$1(text, point2, style, offset = 1e-3) {
   const dxfSystem = DxfSystem.finalInstance;
   if (dxfSystem) {
     const renderer = dxfSystem.findComponentByName("Renderer");
     const editor = dxfSystem.findComponentByName("Editor");
     if (renderer) {
-      const obj3d = renderer.createText(text, point, style, editor?.container);
+      const obj3d = renderer.createText(text, point2, style, editor?.container);
       obj3d.position.z = offset;
       return obj3d;
     }
@@ -7091,6 +7150,7 @@ class Scenario {
   // 饮水机
   height;
   expandedList;
+  wallHeight;
   static _instance;
   static get Instance() {
     return Scenario._instance;
@@ -7126,6 +7186,7 @@ class Scenario {
     this.WindowGroundHeight = WINDOW_GROUND_CLEARANCE_HEIGHT;
     this.height = 0;
     this.expandedList = [];
+    this.wallHeight = DEFAULT_WALL_HEIGHT;
   }
   // 绘制图形
   async drawGraphics(lines, z, trajectoryJson) {
@@ -7187,6 +7248,15 @@ class Scenario {
     this.TheHandlingOfTheDoor(menList);
     this.overallTreatmentOfSingleLineWalls(singleLineWall);
     for (const g in groups) {
+      let wallHeight = 20;
+      for (const x in groups[g]) {
+        if (groups[g][x].userData.height < wallHeight) {
+          wallHeight = groups[g][x].userData.height;
+        }
+      }
+      if (wallHeight === 20) {
+        wallHeight = this.wallHeight;
+      }
       const a = clippingDoubleWall(groups[g]);
       for (const i in a) {
         let bitem = a[i].slice();
@@ -7241,7 +7311,7 @@ class Scenario {
           }
           return false;
         });
-        const Mesh = this.drawTheModel(E, 0, Number(i));
+        const Mesh = this.drawTheModel(E, 0, Number(i), wallHeight);
         Mesh.material.envMap = texture;
         Mesh.material.needsUpdate = true;
         const doubleLinesWindow = doubleWinDrawLine(a[i]);
@@ -7249,23 +7319,23 @@ class Scenario {
           let houMesh = null;
           for (const x in doubleLinesWindow) {
             if (doubleLinesWindow.length === 1) {
-              const edges = new THREE.EdgesGeometry(this.windowTreatment(doubleLinesWindow[x], Mesh).geometry);
+              const edges = new THREE.EdgesGeometry(this.windowTreatment(doubleLinesWindow[x], Mesh, wallHeight).geometry);
               new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0 }));
               this.installWindows(doubleLinesWindow[x], x);
-              this.group.add(this.windowTreatment(doubleLinesWindow[x], Mesh));
+              this.group.add(this.windowTreatment(doubleLinesWindow[x], Mesh, wallHeight));
             } else if (houMesh) {
               if (Number(x) === doubleLinesWindow.length - 1) {
-                const edges = new THREE.EdgesGeometry(this.windowTreatment(doubleLinesWindow[x], houMesh).geometry);
+                const edges = new THREE.EdgesGeometry(this.windowTreatment(doubleLinesWindow[x], houMesh, wallHeight).geometry);
                 new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0 }));
                 this.installWindows(doubleLinesWindow[x], x);
-                this.group.add(this.windowTreatment(doubleLinesWindow[x], houMesh));
+                this.group.add(this.windowTreatment(doubleLinesWindow[x], houMesh, wallHeight));
               } else {
                 this.installWindows(doubleLinesWindow[x], x);
-                houMesh = this.windowTreatment(doubleLinesWindow[x], houMesh);
+                houMesh = this.windowTreatment(doubleLinesWindow[x], houMesh, wallHeight);
               }
             } else {
               this.installWindows(doubleLinesWindow[x], x);
-              houMesh = this.windowTreatment(doubleLinesWindow[x], Mesh);
+              houMesh = this.windowTreatment(doubleLinesWindow[x], Mesh, wallHeight);
             }
           }
         } else {
@@ -7275,7 +7345,7 @@ class Scenario {
     }
   }
   // 绘制模型
-  drawTheModel(data, num, index2) {
+  drawTheModel(data, num, index2, wallHeight) {
     const basePoints = [
       new THREE.Vector3(data[0].x, data[0].y, this.height ? this.height : 0),
       new THREE.Vector3(data[1].x, data[1].y, this.height ? this.height : 0),
@@ -7283,7 +7353,7 @@ class Scenario {
       // 可以不是矩形
       new THREE.Vector3(data[3].x, data[3].y, this.height ? this.height : 0)
     ];
-    const geometry = this.createParallelepipedFromBase(basePoints, 2.8);
+    const geometry = this.createParallelepipedFromBase(basePoints, wallHeight);
     const material = new THREE.MeshStandardMaterial({
       color: this.color,
       side: THREE.DoubleSide
@@ -7307,10 +7377,11 @@ class Scenario {
     return cube;
   }
   // 执行偏移
-  executionOffset(data, index2) {
+  executionOffset(data, index2, wallHeight) {
+    const wallHeightc = wallHeight ? wallHeight : this.wallHeight;
     const points = [];
-    points.push(new THREE.Vector3(data.start.x, data.start.y, 2.8));
-    points.push(new THREE.Vector3(data.end.x, data.end.y, 2.8));
+    points.push(new THREE.Vector3(data.start.x, data.start.y, wallHeightc));
+    points.push(new THREE.Vector3(data.end.x, data.end.y, wallHeightc));
     new THREE.BufferGeometry().setFromPoints(points);
     new THREE.LineBasicMaterial({
       color: 65280
@@ -7322,12 +7393,12 @@ class Scenario {
     const grid = createPointVirtualGrid(this.lines);
     const isDouble = grid.queryCircle(Point.from(data.start), 1e-3).some((item) => LineGroupType.hasType(item.userData, "doubleWall") || item.userData?.userData.isDoor);
     const isDouble1 = grid.queryCircle(Point.from(data.end), 1e-3).some((item) => LineGroupType.hasType(item.userData, "doubleWall") || item.userData?.userData.isDoor);
-    let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 0);
-    let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 1);
+    let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 0, wallHeightc);
+    let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 1, wallHeightc);
     if (isDouble && isDouble1) {
       startingPoint.push(finishLine[1]);
       startingPoint.push(finishLine[0]);
-      return this.drawTheModel(startingPoint, 1, index2);
+      return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
     }
     if (isDouble && !isDouble1) {
       let status = false;
@@ -7337,15 +7408,15 @@ class Scenario {
         }
       }
       if (status) {
-        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
         startingPoint.push(finishLine1[1]);
         startingPoint.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint, 1, index2);
+        return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
       } else {
         this.expandedList.push(data.end);
         startingPoint.push(finishLine1[1]);
         startingPoint.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint, 1, index2);
+        return this.drawTheModel(startingPoint, 1, index2, wallHeightc);
       }
     }
     if (!isDouble && isDouble1) {
@@ -7356,15 +7427,15 @@ class Scenario {
         }
       }
       if (status) {
-        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
+        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
         startingPoint1.push(finishLine[1]);
         startingPoint1.push(finishLine[0]);
-        return this.drawTheModel(startingPoint1, 1, index2);
+        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       } else {
         this.expandedList.push(data.start);
         startingPoint1.push(finishLine[1]);
         startingPoint1.push(finishLine[0]);
-        return this.drawTheModel(startingPoint1, 1, index2);
+        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       }
     }
     if (!isDouble && !isDouble1) {
@@ -7379,50 +7450,51 @@ class Scenario {
         }
       }
       if (statua && statub) {
-        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
-        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
         startingPoint1.push(finishLine1[1]);
         startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2);
+        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       } else if (statua && !statub) {
         this.expandedList.push(data.end);
-        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
+        startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
         startingPoint1.push(finishLine1[1]);
         startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2);
+        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       } else if (!statua && statub) {
         this.expandedList.push(data.start);
-        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+        finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
         startingPoint1.push(finishLine1[1]);
         startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2);
+        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       } else if (!statua && !statub) {
         this.expandedList.push(data.start);
         this.expandedList.push(data.end);
         startingPoint1.push(finishLine1[1]);
         startingPoint1.push(finishLine1[0]);
-        return this.drawTheModel(startingPoint1, 1, index2);
+        return this.drawTheModel(startingPoint1, 1, index2, wallHeightc);
       }
     }
   }
   // 窗的处理
-  windowTreatment(dblWin, mesh) {
+  windowTreatment(dblWin, mesh, wallHeight) {
     const doorList = dblWin;
     const MobileX = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, doorList.userData.wallWidth ? doorList.userData.wallWidth + 1e-4 : 0.5, true);
     const MobileY = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, doorList.userData.wallWidth ? doorList.userData.wallWidth + 1e-4 : 0.5, false);
-    let startingPoint = this.xinLine(MobileX, MobileY, doorList.start, 0);
-    let finishLine = this.xinLine(MobileX, MobileY, doorList.end, 1);
+    let startingPoint = this.xinLine(MobileX, MobileY, doorList.start, wallHeight);
+    let finishLine = this.xinLine(MobileX, MobileY, doorList.end, wallHeight);
     startingPoint.push(finishLine[1]);
     startingPoint.push(finishLine[0]);
     return this.winHoleOpening(startingPoint, mesh, dblWin.userData.groundClearance, dblWin.userData.height);
   }
   // 门体的处理
   TheHandlingOfTheDoor1(data) {
+    const wallHeightc = data.userData.height ? data.userData.height : this.wallHeight;
     const doorList = data;
     const MobileX = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, DEFAULT_WALL_HALF_WIDTH + 1e-3, true);
     const MobileY = this.angleToXAxisDegrees(doorList.start.x, doorList.start.y, doorList.end.x, doorList.end.y, DEFAULT_WALL_HALF_WIDTH + 1e-3, false);
-    let startingPoint = this.xinLine(MobileX, MobileY, doorList.start, 0);
-    let finishLine = this.xinLine(MobileX, MobileY, doorList.end, 1);
+    let startingPoint = this.xinLine(MobileX, MobileY, doorList.start, doorList.userData.height ? doorList.userData.height : this.wallHeight);
+    let finishLine = this.xinLine(MobileX, MobileY, doorList.end, doorList.userData.height ? doorList.userData.height : this.wallHeight);
     const quadtree = createQuadtree(this.lines);
     const doorPoint = doorList.start;
     const doorPoint1 = doorList.end;
@@ -7435,18 +7507,18 @@ class Scenario {
       return item.line.vertical(doorList, 20) && !LineGroupType.hasType(item.line, "doubleWall");
     });
     if (statua && !statub) {
-      let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
+      let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
       startingPoint1.push(finishLine[1]);
       startingPoint1.push(finishLine[0]);
       return startingPoint1;
     } else if (!statua && statub) {
-      let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+      let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
       startingPoint.push(finishLine1[1]);
       startingPoint.push(finishLine1[0]);
       return startingPoint;
     } else if (statua && statub) {
-      let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
-      let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+      let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+      let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
       startingPoint1.push(finishLine1[1]);
       startingPoint1.push(finishLine1[0]);
       return startingPoint1;
@@ -7460,6 +7532,7 @@ class Scenario {
   TheHandlingOfTheDoor(data) {
     const doorList = data;
     for (const i in doorList) {
+      const wallHeightc = data[i].userData.height ? data[i].userData.height : this.wallHeight;
       const point1 = new THREE.Vector3(doorList[i].start.x, doorList[i].start.y, 0);
       const point2 = new THREE.Vector3(doorList[i].end.x, doorList[i].end.y, 0);
       const point3 = new THREE.Vector3(doorList[i].center.x, doorList[i].center.y, 0);
@@ -7469,8 +7542,8 @@ class Scenario {
       const distance = point1.distanceTo(point2);
       const MobileX = this.angleToXAxisDegrees(doorList[i].start.x, doorList[i].start.y, doorList[i].end.x, doorList[i].end.y, DEFAULT_WALL_HALF_WIDTH, true);
       const MobileY = this.angleToXAxisDegrees(doorList[i].start.x, doorList[i].start.y, doorList[i].end.x, doorList[i].end.y, DEFAULT_WALL_HALF_WIDTH, false);
-      let startingPoint = this.xinLine(MobileX, MobileY, doorList[i].start, 0);
-      let finishLine = this.xinLine(MobileX, MobileY, doorList[i].end, 1);
+      let startingPoint = this.xinLine(MobileX, MobileY, doorList[i].start, doorList[i].userData.height ? doorList[i].userData.height : this.wallHeight);
+      let finishLine = this.xinLine(MobileX, MobileY, doorList[i].end, doorList[i].userData.height ? doorList[i].userData.height : this.wallHeight);
       const quadtree = createQuadtree(this.lines);
       const doorPoint = doorList[i].start;
       const doorPoint1 = doorList[i].end;
@@ -7483,32 +7556,32 @@ class Scenario {
         return item.line.vertical(doorList[i], 20) && !LineGroupType.hasType(item.line, "doubleWall");
       });
       if (statua && !statub) {
-        let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
+        let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
         startingPoint1.push(finishLine[1]);
         startingPoint1.push(finishLine[0]);
-        this.doorHoleOpening(startingPoint1, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData?.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance - DEFAULT_WALL_HALF_WIDTH, this.doorCenterOffset(0.03, doorList[i].end, point3), angleRad, i);
+        this.doorHoleOpening(wallHeightc, startingPoint1, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData?.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance - DEFAULT_WALL_HALF_WIDTH, this.doorCenterOffset(0.03, doorList[i].end, point3), angleRad, i);
       } else if (!statua && statub) {
-        let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+        let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
         startingPoint.push(finishLine1[1]);
         startingPoint.push(finishLine1[0]);
-        this.doorHoleOpening(startingPoint, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance - DEFAULT_WALL_HALF_WIDTH, this.doorCenterOffset(0.03, doorList[i].start, point3), angleRad, i);
+        this.doorHoleOpening(wallHeightc, startingPoint, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance - DEFAULT_WALL_HALF_WIDTH, this.doorCenterOffset(0.03, doorList[i].start, point3), angleRad, i);
       } else if (statua && statub) {
-        let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1);
-        let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0);
+        let startingPoint1 = this.xinLine1(MobileY, MobileX, startingPoint[0], startingPoint[1], 1, wallHeightc);
+        let finishLine1 = this.xinLine1(MobileY, MobileX, finishLine[0], finishLine[1], 0, wallHeightc);
         startingPoint1.push(finishLine1[1]);
         startingPoint1.push(finishLine1[0]);
-        this.doorHoleOpening(startingPoint1, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance - DEFAULT_WALL_WIDTH, point3, angleRad, i);
+        this.doorHoleOpening(wallHeightc, startingPoint1, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance - DEFAULT_WALL_WIDTH, point3, angleRad, i);
       } else {
         startingPoint.push(finishLine[1]);
         startingPoint.push(finishLine[0]);
-        this.doorHoleOpening(startingPoint, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance, point3, angleRad, i);
+        this.doorHoleOpening(wallHeightc, startingPoint, this.TheHandlingOfTheDoor1(doorList[i]), doorList[i].userData.drawDoorData?.groundClearance, doorList[i].userData.drawDoorData?.height, distance, point3, angleRad, i);
       }
     }
   }
   // 门中心偏移
-  doorCenterOffset(distanceFromB, point, pointc) {
-    point = new THREE.Vector3(point.x, point.y, 0);
-    const direction = new THREE.Vector3().subVectors(pointc, point).normalize();
+  doorCenterOffset(distanceFromB, point2, pointc) {
+    point2 = new THREE.Vector3(point2.x, point2.y, 0);
+    const direction = new THREE.Vector3().subVectors(pointc, point2).normalize();
     const point3 = new THREE.Vector3().copy(pointc).addScaledVector(direction.negate(), distanceFromB);
     return point3;
   }
@@ -7607,7 +7680,7 @@ class Scenario {
     return result;
   }
   // 门扣洞
-  doorHoleOpening(data, data1, groundHeight, Height, distance, center, angleRad, index2) {
+  doorHoleOpening(wallHeight, data, data1, groundHeight, Height, distance, center, angleRad, index2) {
     groundHeight = (groundHeight ?? this.doorGroundHeight) + this.height;
     const basePoints = [
       new THREE.Vector3(data[0].x, data[0].y, groundHeight),
@@ -7630,7 +7703,7 @@ class Scenario {
       // 可以不是矩形
       new THREE.Vector3(data[3].x, data1[3].y, groundHeight)
     ];
-    const geometry = this.createParallelepipedFromBase(basePoints, 2.8);
+    const geometry = this.createParallelepipedFromBase(basePoints, wallHeight);
     const geometry1 = this.createParallelepipedFromBase(basePoints1, Height ? Height : this.doorHeight);
     const geometry2 = this.createParallelepipedFromBase(basePoints2, Height ? Height : this.doorHeight);
     const brush1 = new Brush(geometry);
@@ -7693,21 +7766,21 @@ class Scenario {
     }
   }
   // 外偏移点坐标
-  xinLine(x, y, point, num) {
-    const point1 = new THREE.Vector3(point.x + x, point.y - y, 2.8);
-    const point2 = new THREE.Vector3(point.x - x, point.y + y, 2.8);
-    return [point1, point2];
+  xinLine(x, y, point2, wallHeight) {
+    const point1 = new THREE.Vector3(point2.x + x, point2.y - y, wallHeight);
+    const point22 = new THREE.Vector3(point2.x - x, point2.y + y, wallHeight);
+    return [point1, point22];
   }
   // 内偏移点坐标
-  xinLine1(x, y, pointa, pointb, num) {
+  xinLine1(x, y, pointa, pointb, num, wallHeight) {
     let point1;
     let point2;
     if (num === 0) {
-      point1 = new THREE.Vector3(pointa.x - x, pointa.y - y, 2.8);
-      point2 = new THREE.Vector3(pointb.x - x, pointb.y - y, 2.8);
+      point1 = new THREE.Vector3(pointa.x - x, pointa.y - y, wallHeight);
+      point2 = new THREE.Vector3(pointb.x - x, pointb.y - y, wallHeight);
     } else {
-      point1 = new THREE.Vector3(pointa.x + x, pointa.y + y, 2.8);
-      point2 = new THREE.Vector3(pointb.x + x, pointb.y + y, 2.8);
+      point1 = new THREE.Vector3(pointa.x + x, pointa.y + y, wallHeight);
+      point2 = new THREE.Vector3(pointb.x + x, pointb.y + y, wallHeight);
     }
     return [point1, point2];
   }
@@ -7736,22 +7809,22 @@ class Scenario {
       if (listS.length === 0) {
         const b = new THREE.Vector3(bitem[i].start.x, bitem[i].start.y, bitem[i].start.z);
         const c = new THREE.Vector3(bitem[i].end.x, bitem[i].end.y, bitem[i].end.z);
-        listS.push({ dian: b, zhong: i });
-        listS.push({ dian: c, zhong: i });
+        listS.push({ dian: b, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
+        listS.push({ dian: c, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
       } else {
         const b = new THREE.Vector3(bitem[i].start.x, bitem[i].start.y, bitem[i].start.z);
         const c = new THREE.Vector3(bitem[i].end.x, bitem[i].end.y, bitem[i].end.z);
         const distanceAB = listS[listS.length - 1].dian.distanceTo(b);
         const distanceAC = listS[listS.length - 1].dian.distanceTo(c);
         if (distanceAB < distanceAC) {
-          listS.push({ dian: b, zhong: i });
-          listS.push({ dian: c, zhong: i });
+          listS.push({ dian: b, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
+          listS.push({ dian: c, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
         } else if (distanceAC < distanceAB) {
-          listS.push({ dian: c, zhong: i });
-          listS.push({ dian: b, zhong: i });
+          listS.push({ dian: c, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
+          listS.push({ dian: b, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
         } else {
-          listS.push({ dian: b, zhong: i });
-          listS.push({ dian: c, zhong: i });
+          listS.push({ dian: b, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
+          listS.push({ dian: c, zhong: i, wallHeight: bitem[i].userData.height ? bitem[i].userData.height : this.wallHeight });
         }
       }
     }
@@ -7789,34 +7862,35 @@ class Scenario {
         } else {
           a = { start: listS[x].dian, end: listS[Number(x) + 1].dian, isTheFirst: true, index: x };
         }
-        let Mesh = this.executionOffset(a, Number(x) / 2);
+        const wallHeight = listS[x].wallHeight;
+        let Mesh = this.executionOffset(a, Number(x) / 2, wallHeight);
         if (winDraw && winDraw.length > 0) {
           let houMesh = null;
           for (const x2 in winDraw) {
             if (winDraw.length === 1) {
-              const edges = new THREE.EdgesGeometry(this.windowTreatment(winDraw[x2], Mesh).geometry);
+              const edges = new THREE.EdgesGeometry(this.windowTreatment(winDraw[x2], Mesh, wallHeight).geometry);
               new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0 }));
               this.installWindows(winDraw[x2], x2);
-              let mesh = this.windowTreatment(winDraw[x2], Mesh);
+              let mesh = this.windowTreatment(winDraw[x2], Mesh, wallHeight);
               mesh.name = `单线墙_${Number(x2) / 2}`;
               mesh.userData.category = "wall";
               this.group.add(mesh);
             } else if (houMesh) {
               if (Number(x2) === winDraw.length - 1) {
-                const edges = new THREE.EdgesGeometry(this.windowTreatment(winDraw[x2], houMesh).geometry);
+                const edges = new THREE.EdgesGeometry(this.windowTreatment(winDraw[x2], houMesh, wallHeight).geometry);
                 this.installWindows(winDraw[x2], x2);
                 new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0 }));
-                let mesh = this.windowTreatment(winDraw[x2], houMesh);
+                let mesh = this.windowTreatment(winDraw[x2], houMesh, wallHeight);
                 mesh.name = `单线墙_${Number(x2) / 2}`;
                 mesh.userData.category = "wall";
                 this.group.add(mesh);
               } else {
                 this.installWindows(winDraw[x2], x2);
-                houMesh = this.windowTreatment(winDraw[x2], houMesh);
+                houMesh = this.windowTreatment(winDraw[x2], houMesh, wallHeight);
               }
             } else {
               this.installWindows(winDraw[x2], x2);
-              houMesh = this.windowTreatment(winDraw[x2], Mesh);
+              houMesh = this.windowTreatment(winDraw[x2], Mesh, wallHeight);
             }
           }
         } else {
@@ -7827,6 +7901,50 @@ class Scenario {
       }
     }
   }
+  // 
+  createAPlane(lines, menList) {
+    const lineList = lines;
+    console.log("初始数据", lines);
+    let precision = lineList.map((pos) => {
+      pos.start.x = parseFloat(pos.start.x.toFixed(3));
+      pos.start.y = parseFloat(pos.start.y.toFixed(3));
+      pos.end.x = parseFloat(pos.end.x.toFixed(3));
+      pos.end.y = parseFloat(pos.end.y.toFixed(3));
+      return pos;
+    });
+    let points = [];
+    let head = null;
+    let theTail = null;
+    for (const x in precision) {
+      if (x === "0") {
+        head = precision[x].start;
+        theTail = precision[x].end;
+        points.push([precision[x].start.x, precision[x].start.y]);
+        points.push([precision[x].end.x, precision[x].end.y]);
+      } else {
+        if (precision[x].start.x === head.x && precision[x].start.y === head.y) {
+          points.push([precision[x].end.x, precision[x].end.y]);
+          theTail = precision[x].end;
+        } else if (precision[x].end.x === head.x && precision[x].end.y === head.y) {
+          points.push([precision[x].start.x, precision[x].start.y]);
+          head = precision[x].start;
+        } else if (precision[x].start.x === theTail.x && precision[x].start.y === theTail.y) {
+          points.push([precision[x].end.x, precision[x].end.y]);
+          head = theTail;
+          theTail = precision[x].end;
+        } else if (precision[x].end.x === theTail.x && precision[x].end.y === theTail.y) {
+          points.push([precision[x].start.x, precision[x].start.y]);
+          head = precision[x].start;
+        } else {
+          points.push([precision[x].start.x, precision[x].start.y]);
+          head = precision[x].start;
+          points.push([precision[x].end.x, precision[x].end.y]);
+          theTail = precision[x].end;
+        }
+      }
+    }
+    return;
+  }
   // 获取门模型
   async modelLoader() {
     this.doorModely = await LoadModel.loadGlb("door");
@@ -15059,7 +15177,8 @@ class WhiteModel extends Component {
   onAddFromParent(parent) {
     this.Dxf = parent.findComponentByName("Dxf");
     this.Variable = parent.findComponentByName("Variable");
-    this.Dxf?.addEventListener("cadChange", () => {
+    this.Dxf?.addEventListener("cadChange", ({ options }) => {
+      this.setItemList(options?.publicInfo ?? []);
       this.promise = this.updateModel();
     });
   }
@@ -15708,13 +15827,13 @@ async function buildJson(opt) {
         trajectory = JSON.parse(buffer.toString("utf-8"));
       } else throw new Error("非node环境不允许使用路径");
     }
-    dxfSystem.CorrectionDxf.setTrajectory(trajectory);
   }
   await dxfSystem.Dxf.set(json, {
     groupMethod: "cross",
     fittingMethod: "max",
     crossAxistThreshold: 0.08,
-    ...axisAlignCorrOption
+    ...axisAlignCorrOption,
+    trajectory
   });
   download?.json && await dxfSystem.Dxf.downloadOriginalData(download.json);
   download?.dxf && await dxfSystem.Dxf.downloadDxf(download.dxf);