build-dxf 0.0.12 → 0.0.13

package/package.json

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

package/src/build.js

@@ -3,6 +3,7 @@ import { EventDispatcher as EventDispatcher$1 } from "three";
 import ClipperLib from "clipper-lib";
 import Drawing from "dxf-writer";
 import { OBJExporter } from "three/examples/jsm/exporters/OBJExporter.js";
+import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
 function uuid() {
   return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(c) {
     var r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
@@ -274,6 +275,7 @@ class Point {
   }
   /** 计算两个向量夹角
    * @description 公式：a · b = |a| × |b| × cosθ
+   * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
    * @param point 
    * @returns 
    */
@@ -311,6 +313,14 @@ class Point {
   clone() {
     return new Point(this.x, this.y);
   }
+  /**
+   * 克隆
+   * @returns 
+   */
+  copy(p) {
+    this.x = p.x ?? 0;
+    this.y = p.y ?? 0;
+  }
   static from(arr) {
     if (Array.isArray(arr)) {
       return new Point(arr[0], arr[1]);
@@ -600,6 +610,13 @@ class LineSegment {
   direction() {
     return this.points[1].direction(this.points[0]);
   }
+  /**
+   * 线段长度
+   * @returns 
+   */
+  length() {
+    return this.points[1].distance(this.points[0]);
+  }
   /**
    * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
    * @param line 要投影的线段
@@ -650,6 +667,89 @@ class LineSegment {
     }
     return new LineSegment(projP1, projP2);
   }
+  /**
+   * 判断线段是与线段相交
+   * @param line 
+   */
+  intersectLineSegment(line) {
+    const p1 = this.start;
+    const p2 = this.end;
+    const p3 = line.start;
+    const p4 = line.end;
+    function crossProduct(p12, p22, p32) {
+      return (p22.x - p12.x) * (p32.y - p12.y) - (p22.y - p12.y) * (p32.x - p12.x);
+    }
+    const d1 = crossProduct(p1, p2, p3);
+    const d2 = crossProduct(p1, p2, p4);
+    const d3 = crossProduct(p3, p4, p1);
+    const d4 = crossProduct(p3, p4, p2);
+    return d1 * d2 < 0 && d3 * d4 < 0;
+  }
+  /**
+   * 获取交点
+   * @param line 
+   * @returns 
+   */
+  getIntersection(line) {
+    const p1 = this.start;
+    const p2 = this.end;
+    const p3 = line.start;
+    const p4 = line.end;
+    const denom = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x);
+    if (Math.abs(denom) < 1e-10) {
+      return null;
+    }
+    const t = ((p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x)) / denom;
+    const x = p1.x + t * (p2.x - p1.x);
+    const y = p1.y + t * (p2.y - p1.y);
+    return new Point(x, y);
+  }
+  /**
+   * 获取两条线段夹角
+   * @param line 
+   */
+  includedAngle(line) {
+    const d1 = this.direction(), d2 = line.direction();
+    return d1.angleBetween(d2) / (Math.PI / 180);
+  }
+  /**
+   * 两条线段方向是否一致
+   * @param line 
+   */
+  directionEqual(line, errAngle = 0.1) {
+    return this.includedAngle(line) < errAngle;
+  }
+  /**
+   * 两条线段方向相反否一致
+   * @param line 
+   */
+  directionOpposite(line, errAngle = 0.1) {
+    return 180 - this.includedAngle(line) < errAngle;
+  }
+  /**
+   * 判断两条线是否平行
+   * @param line 
+   */
+  isParallel(line, errAngle = 4) {
+    const angle = this.includedAngle(line);
+    return angle < errAngle || angle > 180 - errAngle;
+  }
+  /**
+   * 判断两条直线是否重合
+   * @param line 
+   * @returns 
+   */
+  areLinesCoincident(line) {
+    const p1 = this.start, p2 = this.end, p3 = line.start, p4 = line.end;
+    const m1 = (p2.y - p1.y) / (p2.x - p1.x);
+    const b1 = p1.y - m1 * p1.x;
+    const m2 = (p4.y - p3.y) / (p4.x - p3.x);
+    const b2 = p3.y - m2 * p3.x;
+    if (!isFinite(m1) && !isFinite(m2)) {
+      return p1.x === p3.x && p2.x === p3.x;
+    }
+    return Math.abs(m1 - m2) < 1e-3 && Math.abs(b1 - b2) < 1e-3;
+  }
   clone() {
     return new LineSegment(
       this.points[0].clone(),
@@ -701,8 +801,25 @@ const units = {
   Parsecs: 3240779289666404e-32
   // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
 };
+function pathToLines(path) {
+  const lineSegments = [];
+  for (let i = 0; i < path.length; i++) {
+    lineSegments.push(new LineSegment(
+      path[i],
+      path[(i + 1) % path.length]
+    ));
+  }
+  return lineSegments;
+}
+function linesToPath(lineSegments) {
+  return lineSegments.flatMap((line, index2) => {
+    if (index2 === lineSegments.length - 1) [...line.points, lineSegments[0].points[0]];
+    return [line.points[0]];
+  });
+}
 class Dxf extends Component {
   static name = "Dxf";
+  shortLine = 0.04;
   width = 0.04;
   scale = 1;
   originalData = [];
@@ -740,6 +857,7 @@ class Dxf extends Component {
     super();
     this.width = width;
     this.scale = scale;
+    this.shortLine = width * 0.8;
   }
   /**
    * 设置
@@ -765,6 +883,7 @@ class Dxf extends Component {
     this.scale = scale;
     this.width = width;
     this.originalData = data;
+    this.lineSegments.length = 0;
     const zList = [];
     this.data = data.map(({ start, end, insetionArr, isDoor = false }, index2) => {
       zList.push(start.z ?? 0, end.z ?? 0);
@@ -875,55 +994,158 @@ class Dxf extends Component {
   /** etOpenRound 去除毛刺
    * @description 检查连续的短线段数量，去除合并后产生的毛刺
    */
-  squareRemoveBurr() {
-    this.wallsGroup = this.wallsGroup.map((lines) => {
-      if (lines.length < 3) return lines;
-      const filterLines = [lines[0]];
-      for (let i = 1; i < lines.length; i++) {
-        const prev = lines[i - 1];
-        const curr = lines[i];
-        const len = prev.distance(curr);
-        if (len < this.width * 0.5) {
-          let count = 0;
-          for (let j = i + 1; j < lines.length; j++) {
-            const prev2 = lines[j - 1];
-            const curr2 = lines[j];
-            const len2 = prev2.distance(curr2);
-            if (len2 < this.width * 0.8) count++;
-            else break;
-          }
-          if (count === 0 && i + count === lines.length - 1) ;
-          else if (i == 1 && count === 1) ;
-          else if (count === 3) {
-            filterLines.push(lines[i + 1]);
-            i += count;
-          } else if (count === 5) {
-            filterLines.push(lines[i + 2]);
-            i += count;
-          } else {
-            filterLines.push(curr);
-          }
+  squareRemoveBurr(path) {
+    if (path.length < 3) return path;
+    const filterLines = [path[0]];
+    for (let i = 1; i < path.length; i++) {
+      const prev = path[i - 1];
+      const curr = path[i];
+      const len = prev.distance(curr);
+      if (len < this.width * 0.5) {
+        let count = 0;
+        for (let j = i + 1; j < path.length; j++) {
+          const prev2 = path[j - 1];
+          const curr2 = path[j];
+          const len2 = prev2.distance(curr2);
+          if (len2 < this.width * 0.8) count++;
+          else break;
+        }
+        if (count === 0 && i + count === path.length - 1) ;
+        else if (i == 1 && count === 1) ;
+        else if (count === 3) {
+          filterLines.push(path[i + 1]);
+          i += count;
+        } else if (count === 5) {
+          filterLines.push(path[i + 2]);
+          i += count;
         } else {
           filterLines.push(curr);
         }
+      } else {
+        filterLines.push(curr);
       }
-      return filterLines;
-    });
+    }
+    return filterLines;
+  }
+  epsilon = 1e-6;
+  // 距离阈值，用于比较点
+  /**
+   * 移除共线点
+   * @param path 
+   * @returns 
+   */
+  removeCollinearPoints(path) {
+    for (let i = 0; i < path.length; i++) {
+      const p1 = path[i];
+      const p2 = path[(i + 1) % path.length];
+      if (p1.distance(p2) > this.shortLine) {
+        path.push(...path.slice(0, i));
+        path.splice(0, i);
+        break;
+      }
+    }
+    if (path.length < 3) return path;
+    const cleanedPath = [];
+    const n = path.length;
+    for (let i = 0; i < n; i++) {
+      const p1 = path[i];
+      const p2 = path[(i + 1) % n];
+      const p3 = path[(i + 2) % n];
+      const cross = (p2.X - p1.X) * (p3.Y - p2.Y) - (p2.Y - p1.Y) * (p3.X - p2.X);
+      if (Math.abs(cross) > this.epsilon) {
+        cleanedPath.push(p1);
+      }
+    }
+    return cleanedPath;
+  }
+  /**
+   * 线段矫直, 线段中心突刺
+   * @description 突变长度小于墙体宽度，该线段可能为突起线段，
+   * @description 判断后续第2线段与上一条线段是否方向相同，相同就为突刺
+   */
+  lineSegmentStraightening(path) {
+    const lines = pathToLines(path), filterLines = [lines[0]];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      const preLine = lines[(lines.length + i - 1) % lines.length];
+      if (line.length() > this.width * 0.9) {
+        filterLines.push(line);
+        continue;
+      }
+      const line1 = lines[i + 1];
+      if (line1 && line1.length() > this.width * 0.9) {
+        filterLines.push(line);
+        filterLines.push(line1);
+        i = i + 1;
+        continue;
+      }
+      const line2 = lines[i + 2];
+      if (line2 && preLine.includedAngle(line2) < 1) {
+        i = i + 2;
+        filterLines.push(line2);
+      } else filterLines.push(line);
+    }
+    return filterLines.length > 3 ? linesToPath(filterLines) : [];
+  }
+  /**
+   * 移除短线段
+   * @param path 
+   */
+  removeShortLine(path, shortLine = this.shortLine) {
+    const lines = pathToLines(path), filterLines = [], PI_1 = Math.PI / 180;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i], len = line.length();
+      if (len > shortLine || filterLines.length === 0) {
+        filterLines.push(line);
+        continue;
+      }
+      let nextline = lines[++i];
+      const preLine = filterLines[filterLines.length - 1], d1 = preLine.direction();
+      while (i < lines.length) {
+        const angle = d1.angleBetween(nextline.direction()) / PI_1;
+        if (nextline.length() <= shortLine || angle < 4 || angle > 180 - 4) {
+          nextline = lines[++i];
+        } else break;
+      }
+      if (nextline) {
+        const intersectPoint = preLine.getIntersection(nextline);
+        if (intersectPoint) {
+          const p0 = preLine.points[1].clone(), p1 = nextline.points[0].clone();
+          preLine.points[1].copy(intersectPoint);
+          nextline.points[0].copy(intersectPoint);
+          if (preLine.length() < this.width) {
+            preLine.points[1].copy(p0);
+            nextline.points[0].copy(p0);
+          } else if (nextline.length() < this.width) {
+            preLine.points[1].copy(p1);
+            nextline.points[0].copy(p1);
+          }
+        } else {
+          preLine.points[1].copy(nextline.points[0]);
+        }
+        filterLines.push(nextline);
+      }
+    }
+    return filterLines.length > 3 ? linesToPath(filterLines) : [];
   }
   /** 线偏移
    * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
    */
   lineOffset(endType = Dxf.EndType.etOpenSquare, joinType = Dxf.JoinType.jtMiter, scale = 1e4) {
-    const solutions = new ClipperLib.Paths();
+    let solutions = new ClipperLib.Paths();
     const offset = new ClipperLib.ClipperOffset(20, 0.25);
     this.pointsGroups.forEach((points) => {
       const linePaths = this.lineTopology(points).map((linePath) => linePath.map((p) => p.clone().mutiplyScalar(scale)));
       offset.AddPaths(linePaths, joinType, endType);
     });
     offset.Execute(solutions, this.width / 2 * scale);
-    offset.Execute(solutions, this.width / 2 * scale);
-    this.wallsGroup = solutions.map((ps) => ps.map((p) => Point.from(p).divisionScalar(scale)));
-    if (endType == Dxf.EndType.etOpenSquare) this.squareRemoveBurr();
+    this.wallsGroup = solutions.map((ps) => {
+      let path = ps.map((p) => Point.from(p).divisionScalar(scale));
+      path = this.removeCollinearPoints(path);
+      path = this.lineSegmentStraightening(path);
+      if (endType == Dxf.EndType.etOpenSquare) path = this.squareRemoveBurr(path);
+      return path;
+    });
     this.dispatchEvent({
       type: "lineOffset",
       wallsGroup: this.wallsGroup
@@ -1550,31 +1772,6 @@ class LineAnalysis extends Component {
     this.Dxf = parent.findComponentByType(Dxf);
     this.Variable = this.parent?.findComponentByType(Variable);
     this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this));
-    this.Dxf.addEventListener("lineOffset", this.duplicatePointFiltering.bind(this));
-  }
-  /**
-   * 去除路径上重复的点
-   * @description 判断方向向量，一个连续的方向上，只应该出现两个点
-   */
-  duplicatePointFiltering() {
-    const dxf = this.Dxf;
-    dxf.wallsGroup = dxf.wallsGroup.map((points) => {
-      const filterPoints = [];
-      points.forEach((point, index2) => {
-        if (index2 < 1 || points.length - 1 === index2) return filterPoints.push(point);
-        const preP = points[index2 - 1], nextP = points[index2 + 1], direct1 = point.direction(preP), direct2 = nextP.direction(point), angle = direct1.angleBetween(direct2) / (Math.PI / 180);
-        if (angle > 0.02 && angle < 180 - 0.02) filterPoints.push(point);
-      });
-      points = [filterPoints[0]];
-      for (let i = 1; i < filterPoints.length; i++) {
-        const point = filterPoints[i];
-        const nextP = filterPoints[i - 1];
-        if (nextP.distance(point) < dxf.width * 0.5) ;
-        points.push(point);
-      }
-      return points;
-    });
-    dxf.wallsGroup = dxf.wallsGroup.filter((i) => i.length >= 4);
   }
   /**
    * 
@@ -1619,6 +1816,9 @@ class LineAnalysis extends Component {
   createRectangle(result) {
     const dxf = this.Dxf;
     const project0 = result.project, project1 = result.project2;
+    if (project0.includedAngle(project1) > 135) {
+      project1.points = [project1.points[1], project1.points[0]];
+    }
     this.addData(project0.points[0], project1.points[0]);
     this.addData(project0.points[1], project1.points[1]);
     const leftHeight = project0.points[0].distance(project1.points[0]), rightHeight = project0.points[1].distance(project1.points[1]), count = Math.ceil(Math.max(leftHeight, rightHeight) / dxf.width), leftFragment = leftHeight / count, rightFragment = rightHeight / count, leftDirection = project1.points[0].direction(project0.points[0]), rightDirection = project1.points[1].direction(project0.points[1]), leftP = project0.points[0].clone(), rightP = project0.points[1].clone(), direction = rightP.direction(leftP);
@@ -1701,10 +1901,7 @@ class LineAnalysis extends Component {
     const temLineSegment = lineSegmentList[index2], direct = sourceLineSegment.direction(), temDirect = temLineSegment.direction(), angle = direct.angleBetween(temDirect) / (Math.PI / 180);
     if (angle < this.errorAngle || angle > 180 - this.errorAngle) {
       let data;
-      const p1 = temLineSegment.projectLineSegment(sourceLineSegment), p2 = sourceLineSegment.projectLineSegment(temLineSegment), d1 = p1.direction(), d2 = p2.direction();
-      if (d1.x > 0 && d2.x < 0 || d1.x < 0 && d2.x > 0 || d1.y > 0 && d2.y < 0 || d1.y < 0 && d2.y > 0) {
-        p1.points = [p1.points[1], p1.points[0]];
-      }
+      const p1 = temLineSegment.projectLineSegment(sourceLineSegment), p2 = sourceLineSegment.projectLineSegment(temLineSegment);
       if (p1.getLength() > p2.getLength()) {
         data = {
           target: temLineSegment,
@@ -1760,6 +1957,7 @@ class DxfSystem extends ComponentManager {
   }
 }
 const exporter = new OBJExporter();
+const glbExporter = new GLTFExporter();
 function lineSqueezing(p1, p2, width = 0.1) {
   const normal = p2.normal(p1);
   const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
@@ -1785,8 +1983,11 @@ class WhiteModel extends Component {
   Variable = null;
   // dxf数据白模
   whiteModelGroup = new THREE.Group();
+  // dxf数据白模边缘线
+  whiteModelLineGroup = new THREE.Group();
   // 原始数据白模
   originalWhiteMode = new THREE.Group();
+  material = new THREE.MeshBasicMaterial({ color: 16777215, transparent: true, opacity: 0.8, side: THREE.DoubleSide });
   onAddFromParent(parent) {
     this.Dxf = parent.findComponentByName("Dxf");
     this.Variable = parent.findComponentByName("Variable");
@@ -1800,6 +2001,8 @@ class WhiteModel extends Component {
     const dxf = this.Dxf;
     this.originalWhiteMode.clear();
     this.whiteModelGroup.clear();
+    this.whiteModelLineGroup.clear();
+    this.whiteModelGroup.add(this.whiteModelLineGroup);
     this.whiteModelGroup.position.z = dxf.originalZAverage;
     this.originalWhiteMode.position.z = dxf.originalZAverage;
     dxf.wallsGroup.forEach((points) => {
@@ -1810,9 +2013,9 @@ class WhiteModel extends Component {
         bevelSize: 0
       });
       const mesh = new THREE.Mesh(geometry);
-      mesh.material = new THREE.MeshStandardMaterial({ color: 16777215, transparent: true, opacity: 0.8 });
+      mesh.material = this.material;
       this.whiteModelGroup.add(mesh);
-      this.whiteModelGroup.add(
+      this.whiteModelLineGroup.add(
         new THREE.LineSegments(new THREE.EdgesGeometry(geometry), new THREE.LineBasicMaterial({ color: 6710886 }))
       );
     });
@@ -1851,15 +2054,58 @@ class WhiteModel extends Component {
       resolve(exporter.parse(this.whiteModelGroup));
     });
   }
-  async toBlob() {
+  toGlb() {
+    return new Promise((resolve) => {
+      this.material.opacity = 1;
+      this.material.needsUpdate = true;
+      setTimeout(() => {
+        glbExporter.parse(this.whiteModelGroup.children, (gltf) => {
+          resolve(gltf);
+          this.material.opacity = 0.8;
+          this.material.transparent = true;
+        }, () => {
+          resolve(void 0);
+        }, {
+          binary: true
+        });
+      }, 100);
+    });
+  }
+  async toOBJBlob() {
     const buffer = await this.toOBJ();
     if (buffer) {
       return new Blob([buffer], { type: "application/octet-stream" });
     }
   }
+  async toGlbBlob() {
+    const buffer = await this.toGlb();
+    if (buffer) {
+      return new Blob([buffer], { type: "application/octet-stream" });
+    }
+  }
   async download(filename) {
     if (typeof window !== "undefined") {
-      const blob = await this.toBlob();
+      const blob = await this.toOBJBlob();
+      if (!blob) return;
+      const a = document.createElement("a");
+      a.href = URL.createObjectURL(blob);
+      a.download = filename;
+      a.click();
+    } else if (typeof global !== "undefined") {
+      const buffer = await this.toOBJ();
+      if (buffer) {
+        const packageName = "fs";
+        const { default: fs } = await import(
+          /* @vite-ignore */
+          packageName
+        );
+        fs.writeFileSync(filename, buffer);
+      }
+    }
+  }
+  async downloadGlb(filename) {
+    if (typeof window !== "undefined") {
+      const blob = await this.toGlbBlob();
       if (!blob) return;
       const a = document.createElement("a");
       a.href = URL.createObjectURL(blob);
@@ -2016,6 +2262,7 @@ export {
   ModelDataPlugin as M,
   Point as P,
   Variable as V,
+  WhiteModel as W,
   DetailsPoint as a,
   index as i,
   loadRenderPlugin as l

package/src/index2.js

@@ -1,6 +1,6 @@
-import { C as Component, P as Point, B as Box2, V as Variable, D as DxfSystem, M as ModelDataPlugin, a as DetailsPoint } from "./build.js";
+import { C as Component, P as Point, B as Box2, V as Variable, D as DxfSystem, M as ModelDataPlugin, a as DetailsPoint, W as WhiteModel } from "./build.js";
 import * as THREE from "three";
-import { BufferAttribute, Vector3, Plane, Line3, Vector2, Triangle, Sphere, Matrix4, Box3, BackSide, DoubleSide, REVISION, FrontSide, Mesh, BatchedMesh, Ray } from "three";
+import { BufferAttribute, Vector3, Plane, Line3, Vector2, Triangle, Sphere, Matrix4, Box3, BackSide, DoubleSide, REVISION, FrontSide, Mesh, BatchedMesh, Ray, Group } from "three";
 import "clipper-lib";
 import "dxf-writer";
 import { CSS3DObject, CSS3DSprite, CSS3DRenderer } from "three/addons/renderers/CSS3DRenderer.js";
@@ -3490,6 +3490,7 @@ class Renderer extends Component {
     if (pos instanceof Point) box.position.set(pos.x, pos.y, 0);
     else if (pos instanceof THREE.Vector3) box.position.copy(pos);
     parent.add(box);
+    return box;
   }
   /**
    * 创建文本
@@ -3500,11 +3501,12 @@ class Renderer extends Component {
   createText(text, pos, style, parent = this.container) {
     const div = document.createElement("div");
     div.innerHTML = text;
-    Object.assign(div.style, { fontSize: "12px", color: "#ffffff", ...style });
+    Object.assign(div.style, { fontSize: "10px", color: "#ffffff", ...style });
     const css2DObject = new Renderer.CSS2DObject(div);
     if (pos instanceof Point) css2DObject.position.set(pos.x, pos.y, 0);
     else if (pos instanceof THREE.Vector3) css2DObject.position.copy(pos);
     parent.add(css2DObject);
+    return css2DObject;
   }
   /**
    * 创建几何缓冲区
@@ -7109,12 +7111,27 @@ class ModelDataRender extends Component {
     const renderer = parent.findComponentByName("Renderer");
     const variable = parent.findComponentByName("Variable");
     const dxfLineModel = parent.findComponentByName("DxfLineModel");
+    const dxf = parent.findComponentByName("Dxf");
     renderer.container.add(dxfLineModel.dxfModelGroup);
     variable.addEventListener("dxfVisible", (e) => {
       dxfLineModel.dxfModelGroup.visible = e.value;
     });
+    let group = new Group();
+    dxfLineModel.dxfModelGroup.add(group);
     variable?.addEventListener("currentKeyUp", (e) => {
       if (e.value === "w") variable.set("dxfVisible", !variable.dxfVisible);
+      if (e.value === "b") {
+        if (group.visible) group.visible = false;
+        else {
+          group.visible = true;
+          group.clear();
+          dxf.wallsGroup.forEach((path, j) => {
+            path.forEach((p, i) => {
+              renderer.createText(`${i}`, p, { color: "#ff00ff", fontSize: "10px" }, group).position.z = dxf.originalZAverage * 0.99;
+            });
+          });
+        }
+      }
     });
   }
   whiteModel(parent) {
@@ -7237,7 +7254,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   setup(__props) {
     THREE.Object3D.DEFAULT_UP = new THREE.Vector3(0, 0, 1);
     const props = __props;
-    const elRef = ref(), originalLineVisible = ref(true), dxfVisible = ref(true), whiteModelVisible = ref(true), isLook = ref(false), dxfSystem = new DxfSystem().usePlugin(ModelDataPlugin).usePlugin(RenderPlugin), desPoint = dxfSystem.findComponentByType(DetailsPoint), domContainer = dxfSystem.findComponentByType(DomContainer);
+    const elRef = ref(), originalLineVisible = ref(true), dxfVisible = ref(true), whiteModelVisible = ref(true), isLook = ref(false), dxfSystem = new DxfSystem().usePlugin(ModelDataPlugin).usePlugin(RenderPlugin), desPoint = dxfSystem.findComponentByType(DetailsPoint), domContainer = dxfSystem.findComponentByType(DomContainer), whiteModel = dxfSystem.findComponentByType(WhiteModel);
     watch(() => props.lines, () => props.lines && setLines(props.lines));
     watch(() => props.detailsPoint, () => props.detailsPoint && desPoint?.set(props.detailsPoint));
     function setLines(lines) {
@@ -7281,59 +7298,70 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               type: "primary",
               onClick: _cache[0] || (_cache[0] = ($event) => unref(dxfSystem).Dxf.download("test.dxf"))
             }, {
-              default: withCtx(() => _cache[5] || (_cache[5] = [
+              default: withCtx(() => _cache[6] || (_cache[6] = [
                 createTextVNode(" 下载 DXF ", -1)
               ])),
               _: 1,
-              __: [5]
+              __: [6]
+            }),
+            createVNode(unref(ElButton), {
+              size: "small",
+              type: "primary",
+              onClick: _cache[1] || (_cache[1] = ($event) => unref(whiteModel).downloadGlb("test.glb"))
+            }, {
+              default: withCtx(() => _cache[7] || (_cache[7] = [
+                createTextVNode(" 下载 白模 ", -1)
+              ])),
+              _: 1,
+              __: [7]
             }),
             createVNode(unref(ElButton), {
               size: "small",
               type: "success",
               onClick: selectLocalFile
             }, {
-              default: withCtx(() => _cache[6] || (_cache[6] = [
+              default: withCtx(() => _cache[8] || (_cache[8] = [
                 createTextVNode(" 选择线路文件 ", -1)
               ])),
               _: 1,
-              __: [6]
+              __: [8]
             }),
             createVNode(unref(ElButton), {
               size: "small",
               type: "success",
               onClick: selectDetailsPointFile
             }, {
-              default: withCtx(() => _cache[7] || (_cache[7] = [
+              default: withCtx(() => _cache[9] || (_cache[9] = [
                 createTextVNode(" 选择详情点文件 ", -1)
               ])),
               _: 1,
-              __: [7]
+              __: [9]
             })
           ]),
           isLook.value ? (openBlock(), createElementBlock("div", {
             key: 0,
-            onClick: _cache[1] || (_cache[1] = ($event) => unref(dxfSystem).Variable.set("isLook", false)),
+            onClick: _cache[2] || (_cache[2] = ($event) => unref(dxfSystem).Variable.set("isLook", false)),
             class: "text-[#fff] h-fit text-[14px] rounded-[10px] bg-black p-[5px_20px] select-none cursor-pointer"
           }, " 点击这或按 ESC 取消 ")) : createCommentVNode("", true),
           createElementVNode("div", null, [
             createElementVNode("div", _hoisted_2, [
               createVNode(unref(ElCheckbox), {
                 modelValue: originalLineVisible.value,
-                "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => originalLineVisible.value = $event),
+                "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => originalLineVisible.value = $event),
                 label: "线(Q)"
               }, null, 8, ["modelValue"]),
               createVNode(unref(ElCheckbox), {
                 modelValue: dxfVisible.value,
-                "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => dxfVisible.value = $event),
+                "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => dxfVisible.value = $event),
                 label: "dxf(W)"
               }, null, 8, ["modelValue"]),
               createVNode(unref(ElCheckbox), {
                 modelValue: whiteModelVisible.value,
-                "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => whiteModelVisible.value = $event),
+                "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => whiteModelVisible.value = $event),
                 label: "墙体(E)"
               }, null, 8, ["modelValue"])
             ]),
-            _cache[8] || (_cache[8] = createStaticVNode('<div class="mt-[5px] text-[#c9c9c9] text-[10px]"><p class="text-right">详情点射线辅助线快捷键：R</p><p class="text-right">墙壁合并追加线快捷键：A</p><p class="text-right">线段序号快捷键：T</p><p class="text-right">线段端点标示快捷键：P</p><p class="text-right">线段长度（单位米）快捷键：L</p></div>', 1))
+            _cache[10] || (_cache[10] = createStaticVNode('<div class="mt-[5px] text-[#c9c9c9] text-[10px]"><p class="text-right">详情点射线辅助线快捷键：R</p><p class="text-right">墙壁合并追加线快捷键：A</p><p class="text-right">线段序号快捷键：T</p><p class="text-right">线段端点标示快捷键：P</p><p class="text-right">线段长度（单位米）快捷键：L</p></div>', 1))
           ])
         ])
       ], 512);

package/src/utils/DxfSystem/components/Dxf.d.ts

@@ -51,6 +51,7 @@ export declare class Dxf extends Component<{
     };
 }> {
     static name: string;
+    shortLine: number;
     width: number;
     scale: number;
     originalData: OriginalDataItem[];
@@ -112,6 +113,24 @@ export declare class Dxf extends Component<{
      * @description 检查连续的短线段数量，去除合并后产生的毛刺
      */
     private squareRemoveBurr;
+    epsilon: number;
+    /**
+     * 移除共线点
+     * @param path
+     * @returns
+     */
+    removeCollinearPoints(path: Point[]): Point[];
+    /**
+     * 线段矫直, 线段中心突刺
+     * @description 突变长度小于墙体宽度，该线段可能为突起线段，
+     * @description 判断后续第2线段与上一条线段是否方向相同，相同就为突刺
+     */
+    lineSegmentStraightening(path: Point[]): Point[];
+    /**
+     * 移除短线段
+     * @param path
+     */
+    removeShortLine(path: Point[], shortLine?: number): Point[];
     /** 线偏移
      * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
      */

package/src/utils/DxfSystem/components/LineAnalysis.d.ts

@@ -27,11 +27,6 @@ export declare class LineAnalysis extends Component {
      * @param parent
      */
     onAddFromParent(parent: ComponentManager): void;
-    /**
-     * 去除路径上重复的点
-     * @description 判断方向向量，一个连续的方向上，只应该出现两个点
-     */
-    duplicatePointFiltering(): void;
     /**
      *
      * @param p1

package/src/utils/DxfSystem/plugin/ModelDataPlugin/components/WhiteModel.d.ts

@@ -12,10 +12,15 @@ export declare class WhiteModel extends Component<{
     Dxf: Dxf | null;
     Variable: Variable | null;
     whiteModelGroup: THREE.Group<THREE.Object3DEventMap>;
+    whiteModelLineGroup: THREE.Group<THREE.Object3DEventMap>;
     originalWhiteMode: THREE.Group<THREE.Object3DEventMap>;
+    material: THREE.MeshBasicMaterial;
     onAddFromParent(parent: ComponentManager): void;
     updateModel(): void;
     toOBJ(): Promise<string>;
-    toBlob(): Promise<Blob | undefined>;
+    toGlb(): Promise<ArrayBuffer | undefined>;
+    toOBJBlob(): Promise<Blob | undefined>;
+    toGlbBlob(): Promise<Blob | undefined>;
     download(filename: string): Promise<void>;
+    downloadGlb(filename: string): Promise<void>;
 }

package/src/utils/DxfSystem/plugin/RenderPlugin/components/Renderer.d.ts

@@ -64,14 +64,14 @@ export declare class Renderer extends Component {
      * 创建点
      * @param pos
      */
-    createPointMesh(pos?: Point | THREE.Vector3, size?: number, parameters?: THREE.MeshBasicMaterialParameters, parent?: THREE.Object3D): void;
+    createPointMesh(pos?: Point | THREE.Vector3, size?: number, parameters?: THREE.MeshBasicMaterialParameters, parent?: THREE.Object3D): THREE.Mesh<THREE.SphereGeometry, THREE.MeshBasicMaterial, THREE.Object3DEventMap>;
     /**
      * 创建文本
      * @param text
      * @param pos
      * @param style
      */
-    createText(text: any, pos?: Point | THREE.Vector3, style?: any, parent?: THREE.Object3D): void;
+    createText(text: any, pos?: Point | THREE.Vector3, style?: any, parent?: THREE.Object3D): CSS2DObject;
     /**
      * 创建几何缓冲区
      * @param map

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

@@ -19,11 +19,53 @@ export declare class LineSegment<T = Record<string, any>> {
      * @returns
      */
     direction(): Point;
+    /**
+     * 线段长度
+     * @returns
+     */
+    length(): number;
     /**
      * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
      * @param line 要投影的线段
      * @returns 投影并裁剪后的线段
      */
     projectLineSegment(line: LineSegment): LineSegment;
+    /**
+     * 判断线段是与线段相交
+     * @param line
+     */
+    intersectLineSegment(line: LineSegment): boolean;
+    /**
+     * 获取交点
+     * @param line
+     * @returns
+     */
+    getIntersection(line: LineSegment): Point | null;
+    /**
+     * 获取两条线段夹角
+     * @param line
+     */
+    includedAngle(line: LineSegment): number;
+    /**
+     * 两条线段方向是否一致
+     * @param line
+     */
+    directionEqual(line: LineSegment, errAngle?: number): boolean;
+    /**
+     * 两条线段方向相反否一致
+     * @param line
+     */
+    directionOpposite(line: LineSegment, errAngle?: number): boolean;
+    /**
+     * 判断两条线是否平行
+     * @param line
+     */
+    isParallel(line: LineSegment, errAngle?: number): boolean;
+    /**
+     * 判断两条直线是否重合
+     * @param line
+     * @returns
+     */
+    areLinesCoincident(line: LineSegment): boolean;
     clone(): LineSegment<Record<string, any>>;
 }

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

@@ -91,6 +91,7 @@ export declare class Point {
     dot(point: Point): number;
     /** 计算两个向量夹角
      * @description 公式：a · b = |a| × |b| × cosθ
+     * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
      * @param point
      * @returns
      */
@@ -108,6 +109,14 @@ export declare class Point {
      * @returns
      */
     clone(): Point;
+    /**
+     * 克隆
+     * @returns
+     */
+    copy(p: {
+        x: number;
+        y: number;
+    }): void;
     static from(arr: any): Point;
     static zero(): Point;
 }