build-dxf 0.1.105 → 0.1.107

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.1.105",
+  "version": "0.1.107",
   "description": "线段构建双线墙壁的dxf版本",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/build.js

@@ -316,12 +316,12 @@ class Rectangle {
     for (let i = 0; i < 4; i++) {
       const p1 = this.points[i];
       const p2 = this.points[(i + 1) % 4];
-      axes.push(p1.normal(p2));
+      axes.push(p1.leftNormal(p2));
     }
     for (let i = 0; i < 4; i++) {
       const p1 = rectangle.points[i];
       const p2 = rectangle.points[(i + 1) % 4];
-      axes.push(p1.normal(p2));
+      axes.push(p1.leftNormal(p2));
     }
     function projectRectangle(rect, axis) {
       const projections = rect.points.map((point2) => point2.dot(axis));
@@ -377,7 +377,7 @@ class Rectangle {
    * @returns 
    */
   static fromByLineSegment(line, width = 0.1, horizontal = false, hScale = 0.5) {
-    const p1 = line.points[0], p2 = line.points[1], normal = p2.normal(p1), pDirect = horizontal ? p2.directionFrom(p1).mutiplyScalar(width * hScale) : Point.zero(), nDirect = horizontal ? p1.directionFrom(p2).mutiplyScalar(width * hScale) : Point.zero();
+    const p1 = line.points[0], p2 = line.points[1], normal = p2.leftNormal(p1), pDirect = horizontal ? p2.directionFrom(p1).multiplyScalar(width * hScale) : Point.zero(), nDirect = horizontal ? p1.directionFrom(p2).multiplyScalar(width * hScale) : Point.zero();
     const offsetX = normal.x * width * 0.5;
     const offsetY = normal.y * width * 0.5;
     return new Rectangle([
@@ -451,9 +451,17 @@ class LineSegment {
   }
   setLength(len) {
     const direct = this.direction();
-    const start = this.#center.clone().add(direct.clone().multiplyScalar(len * 0.5));
-    const end = this.#center.clone().add(direct.clone().multiplyScalar(-len * 0.5));
-    this.set(start, end);
+    const half = len * 0.5;
+    const dx = direct.x * half;
+    const dy = direct.y * half;
+    this.start.set(
+      this.#center.x - dx,
+      this.#center.y - dy
+    );
+    this.end.set(
+      this.#center.x + dx,
+      this.#center.y + dy
+    );
     return this;
   }
   /** 获取另一个点
@@ -603,10 +611,10 @@ class LineSegment {
     return this.#direction.clone();
   }
   /**
-   * 获取发向量
+   * 获取发向量-左法线
    */
   normal() {
-    return this.points[1].normal(this.points[0]);
+    return this.points[1].leftNormal(this.points[0]);
   }
   /** 
    * @param line 
@@ -623,9 +631,9 @@ class LineSegment {
    */
   toRectangle(width = 0.1, cap = "square") {
     const p1 = this.start, p2 = this.end;
-    const normal = p2.normal(p1);
-    const pDirect = cap === "butt" ? Point.zero() : p2.directionFrom(p1).mutiplyScalar(width * 0.5);
-    const nDirect = cap === "butt" ? Point.zero() : p1.directionFrom(p2).mutiplyScalar(width * 0.5);
+    const normal = p2.leftNormal(p1);
+    const pDirect = cap === "butt" ? Point.zero() : p2.directionFrom(p1).multiplyScalar(width * 0.5);
+    const nDirect = cap === "butt" ? Point.zero() : p1.directionFrom(p2).multiplyScalar(width * 0.5);
     const offsetX = normal.x * width * 0.5;
     const offsetY = normal.y * width * 0.5;
     const point2 = [
@@ -995,7 +1003,17 @@ class LineSegment {
     return point2.currentData[LINE_SYMBOL] ?? null;
   }
 }
-const PRECISION = 1e-6;
+const POW10 = [
+  1,
+  10,
+  100,
+  1e3,
+  1e4,
+  1e5,
+  1e6,
+  1e7,
+  1e8
+];
 class Point {
   x;
   y;
@@ -1051,22 +1069,34 @@ class Point {
     this.y = arr[1];
     return this;
   }
-  /**
-   * multiplyScalar
+  /** 乘法
    * @param scalar 
+   * @returns 
    */
-  mutiplyScalar(scalar) {
-    this.x *= scalar;
-    this.y *= scalar;
+  multiply(point2) {
+    this.x *= point2.x;
+    this.y *= point2.y;
     return this;
   }
+  /** 乘以一个标量
+   * @param scalar 
+   * @returns 
+   */
   multiplyScalar(scalar) {
     this.x *= scalar;
     this.y *= scalar;
     return this;
   }
-  /**
-   * 
+  /** 除法
+   * @param scalar 
+   * @returns 
+   */
+  division(point2) {
+    this.x /= point2.x;
+    this.y /= point2.y;
+    return this;
+  }
+  /** 除一个标量
    * @param scalar 
    * @returns 
    */
@@ -1081,20 +1111,20 @@ class Point {
    * @param point
    * @returns 
    */
-  division(point2) {
+  subtract(point2) {
     this.x -= point2.x;
     this.y -= point2.y;
     return this;
   }
   /**
-   * 减法
+   * 减一个标量
    * @description 将当前点的坐标减去指定点的坐标
    * @param point
    * @returns 
    */
-  subtract(point2) {
-    this.x -= point2.x;
-    this.y -= point2.y;
+  subtractScalar(value) {
+    this.x -= value;
+    this.y -= value;
     return this;
   }
   /**
@@ -1108,8 +1138,7 @@ class Point {
     this.y += point2.y;
     return this;
   }
-  /**
-  * 加法
+  /** 加一个标量
   * @description 将当前点的坐标加上指定点的坐标
   * @param point 
   * @returns 
@@ -1118,6 +1147,35 @@ class Point {
     this.x += value;
     this.y += value;
   }
+  /**
+   * 加法（不可变）
+   * @description 返回当前点与指定点相加后的新点，不修改当前点
+   * @param point
+   * @param out 输出对象，用于复用对象减少 GC
+   * @returns 相加后的点
+   */
+  added(point2, out = new Point()) {
+    return out.set(
+      this.x + point2.x,
+      this.y + point2.y
+    );
+  }
+  /**
+   * 减法（不可变）
+   * @description 返回当前点减去指定点后的新点，不修改当前点
+   * @param point
+   * @param out 输出对象，用于复用对象减少 GC
+   * @returns 相减后的点
+   */
+  subtracted(point2, out = new Point()) {
+    return out.set(
+      this.x - point2.x,
+      this.y - point2.y
+    );
+  }
+  /** 转为整型
+   * @returns 
+   */
   parseInt() {
     this.x = ~~this.x;
     this.y = ~~this.y;
@@ -1139,21 +1197,40 @@ class Point {
     this.y = rotatedY + point2.y;
     return this;
   }
+  /**
+   * 旋转（不可变）
+   * @description 返回当前点绕指定中心旋转后的新点，不修改当前点
+   * @param center 旋转中心
+   * @param angle 旋转角度（弧度）
+   * @param out 输出对象，用于复用对象减少 GC
+   * @returns 旋转后的点
+   */
+  rotated(center, angle, out = new Point()) {
+    const dx = this.x - center.x;
+    const dy = this.y - center.y;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return out.set(
+      dx * cos - dy * sin + center.x,
+      dx * sin + dy * cos + center.y
+    );
+  }
   /**
    * 保留小数位数
    * @param count 
    */
-  fixed(count) {
-    this.x = Number(this.x.toFixed(count));
-    this.y = Number(this.y.toFixed(count));
+  precision(count) {
+    const factor = POW10[count] ?? 10 ** count;
+    this.x = Math.round(this.x * factor) / factor;
+    this.y = Math.round(this.y * factor) / factor;
     return this;
   }
-  /** 精度处理
+  /** 保留四位小数
    * @returns 
    */
-  precision() {
-    this.x = Math.round(this.x / PRECISION) * PRECISION;
-    this.y = Math.round(this.y / PRECISION) * PRECISION;
+  precision4() {
+    this.x = Math.round(this.x * 1e4) / 1e4;
+    this.y = Math.round(this.y * 1e4) / 1e4;
     return this;
   }
   /**
@@ -1169,12 +1246,28 @@ class Point {
     return this;
   }
   /**
-   * 获取单位法向量
+  * 归一化（不可变）
+  * @description 返回当前向量归一化后的新点，不修改当前点
+  * @param out 输出对象，用于复用对象减少 GC
+  * @returns 单位向量
+  */
+  normalized(out = new Point()) {
+    const length = Math.hypot(this.x, this.y);
+    if (length === 0) {
+      return out.set(0, 0);
+    }
+    return out.set(
+      this.x / length,
+      this.y / length
+    );
+  }
+  /**
+   * 获取单位左法向量
    * @description 计算当前点到指定点的方向向量，并返回逆时针旋转90度后的单位法向量
    * @param point 
    * @returns 
    */
-  normal(point2) {
+  leftNormal(point2) {
     const dx = this.x - point2.x;
     const dy = this.y - point2.y;
     const length = Math.sqrt(dx * dx + dy * dy);
@@ -1329,12 +1422,15 @@ class Point {
     this.y = p2.y ?? 0;
     return this;
   }
-  /**
-   * 
+  /** 转为数组
    */
   toArray() {
     return [this.x, this.y];
   }
+  /** 转为json
+   * @param z 
+   * @returns 
+   */
   toJson(z = 0) {
     return {
       x: this.x,
@@ -2952,10 +3048,18 @@ class PointUtils {
   /**保留小数位数
    * @param points 
    */
-  static round(points, scale2 = 1e4) {
+  static precision(points, count) {
+    for (const p2 of points) {
+      p2.precision(count);
+    }
+    return points;
+  }
+  /**保留四位小数位数
+   * @param points 
+   */
+  static precision4(points) {
     for (const p2 of points) {
-      p2.x = Math.round(p2.x * scale2) / scale2;
-      p2.y = Math.round(p2.y * scale2) / scale2;
+      p2.precision4();
     }
     return points;
   }
@@ -3034,9 +3138,30 @@ class UnionFindSet {
   }
 }
 class LineSegmentUtils {
+  // 克隆
   clone(lines) {
     return lines.map((line) => line.clone());
   }
+  /**保留小数位数
+   * @param points 
+   */
+  static precision(lines, count) {
+    for (const l of lines) {
+      l.start.precision(count);
+      l.end.precision(count);
+    }
+    return lines;
+  }
+  /**保留四位小数位数
+   * @param points 
+   */
+  static precision4(lines) {
+    for (const l of lines) {
+      l.start.precision4();
+      l.end.precision4();
+    }
+    return lines;
+  }
   /** 获取最长线段索引
    * @param lines 
    */
@@ -5362,13 +5487,49 @@ class Polygon extends Array {
     this.length = 0;
     this.push(...points);
   }
-  getCenter() {
-    let countX = 0, countY = 0;
-    this.forEach((p2) => {
-      countX += p2.x;
-      countY += p2.y;
-    });
-    return new Point(countX / this.length, countY / this.length);
+  /**
+   * 获取多边形几何中心（面积质心）
+   * @description 使用多边形面积质心公式计算
+   * @description 适用于闭合简单多边形（顺时针或逆时针均可）
+   * @description 如果面积为 0，则退化为顶点平均中心
+   * @param out 输出对象，用于减少 GC
+   * @returns
+   */
+  getCenter(out = new Point()) {
+    const len = this.length;
+    if (len === 0) {
+      return out.set(0, 0);
+    }
+    let area2 = 0;
+    let centerX = 0;
+    let centerY = 0;
+    for (let i = 0; i < len; i++) {
+      const p1 = this[i];
+      const p2 = this[(i + 1) % len];
+      const cross = p1.x * p2.y - p2.x * p1.y;
+      area2 += cross;
+      centerX += (p1.x + p2.x) * cross;
+      centerY += (p1.y + p2.y) * cross;
+    }
+    area2 *= 0.5;
+    if (Math.abs(area2) < 1e-9) {
+      let sumX = 0;
+      let sumY = 0;
+      for (let i = 0; i < len; i++) {
+        sumX += this[i].x;
+        sumY += this[i].y;
+      }
+      const inv = 1 / len;
+      return out.set(
+        sumX * inv,
+        sumY * inv
+      );
+    }
+    const factor = 1 / (6 * area2);
+    return out.set(
+      centerX * factor,
+      centerY * factor
+    );
   }
   /** 计算二维包围盒
    * @returns 
@@ -6428,6 +6589,7 @@ function segmentationPath(lines, clipLine) {
 function clippingDoubleWall(lines) {
   lines = lines.map((line) => line.clone());
   lines = mergeChains(lines);
+  if (lines.length === 4) return [lines];
   const queue = [lines], groups = [], maxCount2 = 2e4;
   let pendingLines, count = 0;
   while ((pendingLines = queue.pop()) !== void 0) {
@@ -6457,6 +6619,7 @@ function clippingDoubleWall(lines) {
 }
 const miniCircles = new MiniCircles();
 function clippingInsertObjectDoubleWall(lines) {
+  if (lines.length === 4) return [lines];
   const hasInsertObject = lines.some((line) => WallInsertObject.isInsertObject(line));
   if (!hasInsertObject) return clippingDoubleWall(lines);
   const quadtree = createQuadtree(lines), poly = Polygon.fromByLines2(lines), far = 10;
@@ -9396,6 +9559,12 @@ class BuildGroup {
     return buildDoubleWallGroup;
   }
 }
+function precision4(value) {
+  return Math.round(value * 1e4) * 1e-4;
+}
+function precision4Nullable(value) {
+  return value == null ? void 0 : precision4(value);
+}
 const holeTypeMap = {
   door: "DOOR",
   RAILING: "RAILING",
@@ -9433,11 +9602,21 @@ class ThreeVJiaPipeline extends Pipeline {
     const { door, window: windowLines, passageEntrance, untreatedDoubleWallGroup } = WallInsertObjectDrawData.handleHoleDrawData(groups, []);
     const walls = untreatedDoubleWallGroup.flatMap((lines2) => {
       if (lines2.length < 4) return lines2;
-      lines2 = lines2.sort((a2, b4) => a2.length() - b4.length());
-      const line1 = lines2[0], line2 = lines2[1];
-      const newLine = new LineSegment(line1.center.clone(), line2.center.clone());
+      let newLine = null;
+      let wallWidth = 0;
+      const poly = Polygon.fromByLinePath(lines2).getMinimumBoundingRectangle();
+      if (poly) {
+        const len1 = poly[0].distance(poly[1]), len2 = poly[1].distance(poly[2]), direct = len1 > len2 ? poly[0].directionFrom(poly[1]) : poly[1].directionFrom(poly[2]), center = poly.getCenter(), len = Math.max(len1, len2);
+        newLine = center.expandAsLine(direct, len).translate(-len * 0.5, direct);
+        wallWidth = Math.min(len1, len2);
+      } else {
+        lines2 = [...lines2].sort((a2, b4) => a2.length() - b4.length());
+        const line1 = lines2[0], line2 = lines2[1];
+        newLine = new LineSegment(line1.center.clone(), line2.center.clone());
+        wallWidth = line1.length();
+      }
       mergeLineUserData(newLine, lines2);
-      newLine.userData.wallWidth = line1.length();
+      newLine.userData.wallWidth = wallWidth;
       return [newLine];
     });
     this.manager.add({ type: "wallHole", lines: windowLines });
@@ -9534,12 +9713,12 @@ class ThreeVJiaPipeline extends Pipeline {
       const hole = {
         id: this.index++,
         type,
-        start: line.start.toJson2D(),
-        end: line.end.toJson2D(),
-        depth: line.userData.depth,
-        height: line.userData?.height ?? DEFAULT_DOOR_HEIGHT,
-        sillHeight: line.userData?.groundClearance ?? DOOR_GROUND_CLEARANCE_HEIGHT,
-        groundClearance: line.userData?.groundClearance ?? DOOR_GROUND_CLEARANCE_HEIGHT
+        start: line.start.precision4().toJson2D(),
+        end: line.end.precision4().toJson2D(),
+        depth: precision4Nullable(line.userData.depth),
+        height: precision4Nullable(line.userData?.height ?? DEFAULT_DOOR_HEIGHT),
+        sillHeight: precision4Nullable(line.userData?.groundClearance ?? DOOR_GROUND_CLEARANCE_HEIGHT),
+        groundClearance: precision4Nullable(line.userData?.groundClearance ?? DOOR_GROUND_CLEARANCE_HEIGHT)
         // ?非三维家需要数据
       };
       if (type === "DOOR") Object.assign(hole, { openSide: "RIGHT" });
@@ -9575,16 +9754,16 @@ class ThreeVJiaPipeline extends Pipeline {
     };
     this.manager.forEach((group) => this.run(group.type, { lines: group.lines, json: option }, cache));
     cache.wallLines.forEach((line) => {
+      line.setLength(line.len + 4e-3);
       option.walls.push({
         ID: this.index++,
-        start: line.start.toJson2D(),
-        end: line.end.toJson2D(),
-        thickness: Math.max(line.userData.wallWidth ? line.userData.wallWidth : 0.12, 0.12),
+        start: line.start.precision4().toJson2D(),
+        end: line.end.precision4().toJson2D(),
+        thickness: precision4(Math.max(line.userData.wallWidth ? line.userData.wallWidth : 0.12, 0.12)),
         type: "LINE",
         isDoor: false,
         loadBearingWall: false,
-        // height: line.userData.height ?? DEFAULT_WALL_HEIGHT
-        height: line.currentData[WALL_HEIGHT_KEY] ?? this.maxHeight
+        height: precision4(line.currentData[WALL_HEIGHT_KEY] ?? this.maxHeight)
       });
     });
     return option;
@@ -9616,6 +9795,7 @@ class ThreeVJiaPipeline extends Pipeline {
     const rooms = json.rooms, roomPloys = rooms.map((room) => new Polygon(room.polygon.map((p2) => Point.from(p2))));
     if (roomPloys.length === 0) return json;
     publicInfo.itemInfo.forEach((item, i) => {
+      if (item.category !== "switch" && item.category !== "socket") return;
       const itemPoly = new Polygon(item.contour.map((p2) => Point.from(p2).rotate(json.center, json.angle))), center = itemPoly.getCenter(), index2 = roomPloys.findIndex((poly) => poly.pointWithin(center));
       if (index2 < 0) return;
       json.placeHolders.push({
@@ -9661,7 +9841,7 @@ class ThreeVJiaPipeline extends Pipeline {
       });
     });
     if (heights.length === 0) heights.push(DEFAULT_WALL_HEIGHT);
-    const maxHeight = Math.max(...heights);
+    const maxHeight = precision4(Math.max(...heights));
     if (updateGroup) lineSegments = BuildGroup.doubleWall(lineSegments);
     const threeVJiaJson = new ThreeVJiaPipeline(lineSegments, maxHeight);
     const json = threeVJiaJson.transform();
@@ -9968,8 +10148,8 @@ class CAD {
   resetOrigin() {
     const lines = this.groups.flatMap((group) => group.lines), box = Box2.fromByLineSegment(...lines), center = box.center;
     this.groups.forEach((group) => group.lines.forEach((line) => {
-      line.start.division(center);
-      line.end.division(center);
+      line.start.subtract(center);
+      line.end.subtract(center);
     }));
     this.needUpdate = true;
   }
@@ -9981,8 +10161,8 @@ class CAD {
     const lines = this.groups.flatMap((group) => group.lines), box = Box2.fromByLineSegment(...lines), center = box.center;
     this.groups.forEach((group) => group.lines.forEach((line) => {
       line.rotate(angle, center);
-      line.start.division(center);
-      line.end.division(center);
+      line.start.subtract(center);
+      line.end.subtract(center);
     }));
     this.needUpdate = true;
   }
@@ -10534,13 +10714,19 @@ class DoubleWallHelper {
       const newLine1 = new LineSegment(project0.start.clone(), project1.start.clone());
       const newLine2 = new LineSegment(project0.end.clone(), project1.end.clone());
       newLine1.userData.height = line0.userData.height;
+      newLine1.userData.rooftopPz = line0.userData.rooftopPz;
       newLine2.userData.height = line1.userData.height;
+      newLine2.userData.rooftopPz = line1.userData.rooftopPz;
       appendLines.push(newLine1, newLine2);
       addClipingMap(line0, project0);
       addClipingMap(line1, project1);
     });
     clipingMap.forEach((list, line) => {
       const newLines = LineSegmentUtils.clippingByPoints(line, list);
+      newLines.forEach((newLine) => {
+        newLine.userData.height = line.userData.height;
+        newLine.userData.rooftopPz = line.userData.rooftopPz;
+      });
       lines.push(...newLines);
     });
     lines = lines.filter((line) => !removeLines.has(line));
@@ -10551,9 +10737,11 @@ class DoubleWallHelper {
       const queryLines = quadtree.queryRect(line.toRectangle(1e-3, "butt")).filter((item) => item.line.isParallelTo(line)).map((item) => item.line);
       if (queryLines.length) {
         const newLines = LineSegmentUtils.clippingByLines(line, queryLines);
-        if (newLines) return newLines.forEach((line2) => {
-          quadtree.insert(line2);
-          lines.push(line2);
+        if (newLines) return newLines.forEach((newLine) => {
+          newLine.userData.height = line.userData.height;
+          newLine.userData.rooftopPz = line.userData.rooftopPz;
+          quadtree.insert(newLine);
+          lines.push(newLine);
         });
       }
       quadtree.insert(line);
@@ -10581,9 +10769,6 @@ class DoubleWallHelper {
     lineSegments = this.complementSide(lineSegments, otherLines);
     WIO.recomputed(lineSegments);
     lineSegments = BuildGroup.doubleWall(lineSegments, true);
-    PointUtils.round(
-      PointUtils.quantize(LineSegmentUtils.flatPoints(lineSegments), 1e-4)
-    );
     return [...lineSegments, ...otherLines];
   }
 }
@@ -10889,7 +11074,7 @@ class AlignToParallelSegments {
    * @param esp 垂直投影值分组距离
    * @param gap 平行轴投影区间间隙
    */
-  static group(lines, parallelAxis, verticalAxis, esp = 0.05, gap = 0.01) {
+  static group(lines, parallelAxis, verticalAxis, esp = 0.05, gap = 0.01, onGroup) {
     esp = esp / verticalAxis.len;
     gap = gap / parallelAxis.len;
     const vls = lines.map((line) => [
@@ -10897,16 +11082,29 @@ class AlignToParallelSegments {
       line,
       [parallelAxis.projectPointValue(line.start), parallelAxis.projectPointValue(line.end)].sort((a2, b4) => a2 - b4)
     ]).sort((a2, b4) => a2[0] - b4[0]), unionFindSet = new UnionFindSet(vls.length);
-    for (let i = 0; i < vls.length; i++) {
-      const [ipv, _iline, [istart, iend]] = vls[i];
-      for (let j = i + 1; j < vls.length; j++) {
+    for (let i2 = 0; i2 < vls.length; i2++) {
+      const [ipv, _iline, [istart, iend]] = vls[i2];
+      for (let j = i2 + 1; j < vls.length; j++) {
         const [jpv, _jline, [jstart, jend]] = vls[j];
         if (jpv - ipv > esp) break;
         const overlap = Math.min(iend, jend) - Math.max(istart, jstart);
-        if (overlap > -gap) unionFindSet.union(i, j);
-      }
-    }
-    const groups = unionFindSet.getAllSets().map((v2) => v2.map((v22) => vls[v22][1]));
+        if (overlap > -gap) unionFindSet.union(i2, j);
+      }
+    }
+    const map = unionFindSet.getAllSets();
+    const groups = new Array(map.size);
+    let i = 0;
+    map.forEach((list) => {
+      const group = new Array(list.length);
+      const pvList = new Array(list.length);
+      groups[i++] = group;
+      for (let i2 = 0; i2 < list.length; i2++) {
+        const [pv, line] = vls[list[i2]];
+        group[i2] = line;
+        pvList[i2] = pv;
+      }
+      onGroup?.(group, pvList, verticalAxis);
+    });
     return groups;
   }
   /** 拟合并对齐线段
@@ -10946,13 +11144,13 @@ class AlignToParallelSegments {
    * @returns 
    */
   static align(lines, opt = {}) {
-    const { esp = 0.06, gap = 0.05 } = opt;
+    const { esp = 0.08, gap = 0.05 } = opt;
     const axisLine = lines[LineSegmentUtils.maxLengthLineIndex(lines)].clone().setLength(100), axisLineV = axisLine.clone().rotate(Math.PI * 0.5, axisLine.center);
     let [pllLines, verticalLines] = LineSegmentUtils.groupByParallelToAxis(lines, axisLine);
-    const groups = this.group(pllLines, axisLine, axisLineV, esp, gap);
+    const groups = this.group(pllLines, axisLine, axisLineV, esp, gap, opt.onGroup);
     pllLines = this.fittingAlignment(groups, verticalLines, opt);
     verticalLines = verticalLines.filter((line) => line.length() > 1e-6);
-    const groups2 = this.group(verticalLines, axisLineV, axisLine, esp, gap);
+    const groups2 = this.group(verticalLines, axisLineV, axisLine, esp, gap, opt.onGroup);
     verticalLines = this.fittingAlignment(groups2, pllLines, opt);
     pllLines = pllLines.filter((line) => line.length() > 1e-6);
     return [
@@ -11088,7 +11286,17 @@ function correction(lines, targettLine, option) {
   lines = AxisAlignCorr.start(lines, targettLine);
   lines = lineSegmentClipping(lines, 1e-9);
   lines = AlignToParallelSegments.align(lines, {
-    onMergeLine: mergeLineUserData
+    onMergeLine: mergeLineUserData,
+    onGroup(group, projValues, axis) {
+      if (group.length <= 1) return;
+      const max = Math.max(...projValues);
+      const min = Math.min(...projValues);
+      const dist = precision4((max - min) * axis.len);
+      if (dist < DEFAULT_WALL_WIDTH) return;
+      group.forEach((line) => {
+        line.userData.wallWidth = dist;
+      });
+    }
     // esp: 0.4
   });
   lines = adsorption(lines, option);
@@ -11314,7 +11522,7 @@ class DoorFind {
     }).filter((item) => {
       return item.point.distance(dock.point) / length > 0.5;
     }).filter((item) => {
-      const normal = item.point.normal(dock.point), center = new Point((item.point.x + dock.point.x) / 2, (item.point.y + dock.point.y) / 2), length2 = item.point.distance(dock.point);
+      const normal = item.point.leftNormal(dock.point), center = new Point((item.point.x + dock.point.x) / 2, (item.point.y + dock.point.y) / 2), length2 = item.point.distance(dock.point);
       const normalLine = new LineSegment(
         center,
         center.clone().add(normal.clone().multiplyScalar(length2))
@@ -11601,7 +11809,7 @@ class HeightQuery {
     if (contoursData.length) return contoursData;
     points.filter((p2) => {
       point.set(p2[0], p2[1]);
-      new Array(...new Set(quadtree?.queryCircle(point, 0.4).map((item) => item.line.currentData.contourIndex))).forEach((index2) => {
+      new Array(...new Set(quadtree?.queryCircle(point, 0.6).map((item) => item.line.currentData.contourIndex))).forEach((index2) => {
         if (index2 === maxContourIndex) return;
         contoursData.push({ i: index2, averagePz: contours[index2].averagePz });
       });
@@ -11625,9 +11833,17 @@ function wallHeightHandle(lineSegments, option) {
       Object.defineProperty(option.publicInfo.rootTopContourInfo, "quadtree", { value: quadtree });
     }
   }
+  const psh = PointSpatialHash.fromByLines(lineSegments);
   lineSegments.forEach((line) => {
     if (!("height" in line.userData)) {
-      if (!line.userData.rooftopPz && option?.publicInfo?.rootTopContourInfo) line.userData.rooftopPz = HeightQuery.query(line, option.publicInfo.rootTopContourInfo);
+      if (!line.userData.rooftopPz && option?.publicInfo?.rootTopContourInfo) {
+        const list = psh.queryPoints(line.points, true).map((item) => item.userData?.userData.rooftopPz ?? 0);
+        if (list.length) {
+          line.userData.rooftopPz = Math.max(...list);
+        } else {
+          line.userData.rooftopPz = HeightQuery.query(line, option.publicInfo.rootTopContourInfo);
+        }
+      }
       if ("rooftopPz" in line.userData) line.userData.height = Math.abs(line.userData.rooftopPz - (option.originalZ ?? 0));
     }
   });

package/src/index3.js

@@ -16415,7 +16415,7 @@ class VerticalCorrContinue extends CommandFlowComponent {
   }
 }
 function buildDashedHelperLine$1(start, end, offset = 0.5) {
-  const offsetDistance = end.normal(start).multiplyScalar(offset);
+  const offsetDistance = end.leftNormal(start).multiplyScalar(offset);
   const startOffPoint = start.clone().add(offsetDistance);
   const endOffPoint = end.clone().add(offsetDistance);
   return [
@@ -16494,7 +16494,7 @@ class RayDistance extends CommandFlowComponent {
   }
 }
 function buildDashedHelperLine(start, end, offset = 0.5) {
-  const offsetDistance = end.normal(start).multiplyScalar(offset);
+  const offsetDistance = end.leftNormal(start).multiplyScalar(offset);
   const startOffPoint = start.clone().add(offsetDistance);
   const endOffPoint = end.clone().add(offsetDistance);
   return [

package/src/utils/algorithms/AlignToParallelSegments.d.ts

@@ -1,8 +1,10 @@
 import { LineSegment } from './LineSegment';
+type OnGroupFun = (group: LineSegment[], projValues: number[], axis: LineSegment) => void;
 export interface AlignDescriptor {
     esp?: number;
     gap?: number;
     onMergeLine?: (target: LineSegment, source: LineSegment) => void;
+    onGroup?: OnGroupFun;
 }
 /** 通过平行轴和垂直轴分组对齐线段，搭配垂直纠正使用
  */
@@ -14,7 +16,7 @@ export declare class AlignToParallelSegments {
      * @param esp 垂直投影值分组距离
      * @param gap 平行轴投影区间间隙
      */
-    static group(lines: LineSegment[], parallelAxis: LineSegment, verticalAxis: LineSegment, esp?: number, gap?: number): LineSegment<Record<string, any>>[][];
+    static group(lines: LineSegment[], parallelAxis: LineSegment, verticalAxis: LineSegment, esp?: number, gap?: number, onGroup?: OnGroupFun): LineSegment<Record<string, any>>[][];
     /** 拟合并对齐线段
      * @param groups
      * @param verticalLines
@@ -26,3 +28,4 @@ export declare class AlignToParallelSegments {
      */
     static align(lines: LineSegment[], opt?: AlignDescriptor): LineSegment<Record<string, any>>[];
 }
+export {};

package/src/utils/algorithms/LineSegment.d.ts

@@ -101,7 +101,7 @@ export declare class LineSegment<T = Record<string, any>> {
      */
     direction(): Point<Record<string, any>>;
     /**
-     * 获取发向量
+     * 获取发向量-左法线
      */
     normal(): Point<Record<string, any>>;
     /**

package/src/utils/algorithms/LineSegmentUtils.d.ts

@@ -2,6 +2,14 @@ import { LineSegment } from './LineSegment';
 import { Point } from './Point';
 export declare class LineSegmentUtils {
     clone(lines: LineSegment[]): LineSegment<Record<string, any>>[];
+    /**保留小数位数
+     * @param points
+     */
+    static precision(lines: LineSegment[], count: number): LineSegment<Record<string, any>>[];
+    /**保留四位小数位数
+     * @param points
+     */
+    static precision4(lines: LineSegment[]): LineSegment<Record<string, any>>[];
     /** 获取最长线段索引
      * @param lines
      */

package/src/utils/algorithms/Point.d.ts

@@ -28,14 +28,22 @@ export declare class Point<T = Record<string, any>> {
      * @param arr
      */
     setByArray(arr: number[]): this;
-    /**
-     * multiplyScalar
+    /** 乘法
      * @param scalar
+     * @returns
+     */
+    multiply(point: Point): this;
+    /** 乘以一个标量
+     * @param scalar
+     * @returns
      */
-    mutiplyScalar(scalar: number): this;
     multiplyScalar(scalar: number): this;
-    /**
-     *
+    /** 除法
+     * @param scalar
+     * @returns
+     */
+    division(point: Point): this;
+    /** 除一个标量
      * @param scalar
      * @returns
      */
@@ -46,14 +54,14 @@ export declare class Point<T = Record<string, any>> {
      * @param point
      * @returns
      */
-    division(point: Point): this;
+    subtract(point: Point): this;
     /**
-     * 减法
+     * 减一个标量
      * @description 将当前点的坐标减去指定点的坐标
      * @param point
      * @returns
      */
-    subtract(point: Point): this;
+    subtractScalar(value: number): this;
     /**
      * 加法
      * @description 将当前点的坐标加上指定点的坐标
@@ -61,13 +69,31 @@ export declare class Point<T = Record<string, any>> {
      * @returns
      */
     add(point: Point): this;
-    /**
-    * 加法
+    /** 加一个标量
     * @description 将当前点的坐标加上指定点的坐标
     * @param point
     * @returns
     */
     addScalar(value: number): void;
+    /**
+     * 加法（不可变）
+     * @description 返回当前点与指定点相加后的新点，不修改当前点
+     * @param point
+     * @param out 输出对象，用于复用对象减少 GC
+     * @returns 相加后的点
+     */
+    added(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 减法（不可变）
+     * @description 返回当前点减去指定点后的新点，不修改当前点
+     * @param point
+     * @param out 输出对象，用于复用对象减少 GC
+     * @returns 相减后的点
+     */
+    subtracted(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /** 转为整型
+     * @returns
+     */
     parseInt(): this;
     /**
      * 绕point旋转angle
@@ -78,15 +104,27 @@ export declare class Point<T = Record<string, any>> {
         x: number;
         y: number;
     }, angle: number): this;
+    /**
+     * 旋转（不可变）
+     * @description 返回当前点绕指定中心旋转后的新点，不修改当前点
+     * @param center 旋转中心
+     * @param angle 旋转角度（弧度）
+     * @param out 输出对象，用于复用对象减少 GC
+     * @returns 旋转后的点
+     */
+    rotated(center: {
+        x: number;
+        y: number;
+    }, angle: number, out?: Point<Record<string, any>>): Point<Record<string, any>>;
     /**
      * 保留小数位数
      * @param count
      */
-    fixed(count: number): this;
-    /** 精度处理
+    precision(count: number): this;
+    /** 保留四位小数
      * @returns
      */
-    precision(): this;
+    precision4(): this;
     /**
      * 归一化
      * @description 将当前点的坐标归一化为单位向量
@@ -94,12 +132,19 @@ export declare class Point<T = Record<string, any>> {
      */
     normalize(): this;
     /**
-     * 获取单位法向量
+    * 归一化（不可变）
+    * @description 返回当前向量归一化后的新点，不修改当前点
+    * @param out 输出对象，用于复用对象减少 GC
+    * @returns 单位向量
+    */
+    normalized(out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 获取单位左法向量
      * @description 计算当前点到指定点的方向向量，并返回逆时针旋转90度后的单位法向量
      * @param point
      * @returns
      */
-    normal(point: Point): Point<Record<string, any>>;
+    leftNormal(point: Point): Point<Record<string, any>>;
     /**
      * 获取由传入的点到该点的单位方向向量
      * @description 计算当前点到指定点的方向向量，并返回单位方向
@@ -176,10 +221,13 @@ export declare class Point<T = Record<string, any>> {
         x: number;
         y: number;
     }): this;
-    /**
-     *
+    /** 转为数组
      */
     toArray(): [number, number];
+    /** 转为json
+     * @param z
+     * @returns
+     */
     toJson(z?: number): {
         x: number;
         y: number;

package/src/utils/algorithms/PointUtils.d.ts

@@ -8,7 +8,11 @@ export declare class PointUtils {
     /**保留小数位数
      * @param points
      */
-    static round(points: Point[], scale?: number): Point<Record<string, any>>[];
+    static precision(points: Point[], count: number): Point<Record<string, any>>[];
+    /**保留四位小数位数
+     * @param points
+     */
+    static precision4(points: Point[]): Point<Record<string, any>>[];
     /** 点吸附
      * @param points
      * @param tolerance

package/src/utils/algorithms/Polygon.d.ts

@@ -13,7 +13,15 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
     [Symbol.iterator](): ArrayIterator<Point<T>>;
     constructor(points?: Point<T>[]);
     set(points?: Point<T>[]): void;
-    getCenter(): Point<Record<string, any>>;
+    /**
+     * 获取多边形几何中心（面积质心）
+     * @description 使用多边形面积质心公式计算
+     * @description 适用于闭合简单多边形（顺时针或逆时针均可）
+     * @description 如果面积为 0，则退化为顶点平均中心
+     * @param out 输出对象，用于减少 GC
+     * @returns
+     */
+    getCenter(out?: Point<Record<string, any>>): Point<Record<string, any>>;
     /** 计算二维包围盒
      * @returns
      */

package/src/utils/algorithms/precision.d.ts

@@ -0,0 +1,3 @@
+export declare function precision(value: number, count: number): number;
+export declare function precision4(value: number): number;
+export declare function precision4Nullable(value?: number | null): number | undefined;