build-dxf 0.1.55 → 0.1.57

package/package.json

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

package/src/build.d.ts

@@ -1,6 +1,7 @@
 import { DxfSystem } from './utils/DxfSystem';
-import { OriginalDataItem, SetDataOption } from './utils/DxfSystem/type';
+import { LineUserData, OriginalDataItem, SetDataOption } from './utils/DxfSystem/type';
 import { WhiteModel } from './utils/DxfSystem/plugin/ModelDataPlugin/components/WhiteModel';
+import { LineSegment } from './utils';
 import * as THREE from "three";
 export { Dxf } from './utils/DxfSystem/components/Dxf';
 export * from './utils/DxfSystem/DxfSystem';
@@ -83,4 +84,10 @@ export declare function getGlobalDxfSystem(): DxfSystem | null;
  * @param direction
  * @returns
  */
-export declare function hasCircle(lineData: OriginalDataItem[], startIndex: number, direction: any): boolean;
+export declare function hasCircle(lineData: OriginalDataItem[], startIndex: number, direction: any): {
+    readonly originalIndices: number[];
+    readonly indices: number[];
+    circle: LineSegment<Record<string, any>>[];
+    originalLines: LineSegment<LineUserData>[];
+    lines: LineSegment<Record<string, any>>[];
+} | null;

package/src/build.js

@@ -711,9 +711,9 @@ class Quadtree {
    * 插入线段节点
    * @param node 线段节点
    */
-  insert(node) {
+  insert(node, userData) {
     if (node instanceof LineSegment) {
-      this.insert({ line: node, userData: {} });
+      this.insert({ line: node, userData: userData ?? {} });
       return;
     }
     if (!this.isLeaf) {
@@ -4883,19 +4883,35 @@ class Polygon extends Array {
     this.forEach((p2) => p2.multiplyScalar(scale2));
     return this;
   }
+  round() {
+    this.forEach((p2) => {
+      p2.x = Math.round(p2.x);
+      p2.y = Math.round(p2.y);
+    });
+    return this;
+  }
   /** 
    * @param polygon
    */
-  union(polygon2) {
-    const clipper = new ClipperLib.Clipper();
-    clipper.StrictlySimple = true;
-    clipper.AddPath(this, ClipperLib.PolyType.ptSubject, true);
-    clipper.AddPath(polygon2, ClipperLib.PolyType.ptClip, true);
-    let solutions = [];
-    clipper.Execute(ClipperLib.ClipType.ctUnion, solutions, ClipperLib.PolyFillType.pftEvenOdd, ClipperLib.PolyFillType.pftEvenOdd);
-    if (solutions.length > 1) return false;
-    const points = solutions.map((path) => path.map((p2) => Point.from(p2)));
-    this.set(points[0]);
+  union(polygons, scale2 = 1) {
+    polygons = Polygon.booleanOp(this, polygons, {
+      scale: scale2,
+      type: "Union"
+    });
+    if (polygons.length !== 1) return false;
+    this.set(polygons[0]);
+    return true;
+  }
+  /** 差集
+   * @param polygon 
+   */
+  difference(polygons, scale2 = 1) {
+    polygons = Polygon.booleanOp(this, polygons, {
+      scale: scale2,
+      type: "Difference"
+    });
+    if (polygons.length !== 1) return false;
+    this.set(polygons[0]);
     return true;
   }
   /** 拆分为凸包
@@ -4936,6 +4952,10 @@ class Polygon extends Array {
     }
     return this;
   }
+  clone() {
+    const polygon2 = new Polygon([...this].map((p2) => p2.clone()));
+    return polygon2;
+  }
   /** 通过线段创建， 默认路径只有一条
    * @param lines 
    * @returns 
@@ -5023,6 +5043,53 @@ class Polygon extends Array {
     }
     return polygon2;
   }
+  /**
+   * @param poly 
+   */
+  static ensureCCW(poly) {
+    if (!ClipperLib.Clipper.Orientation(poly)) poly.reverse();
+  }
+  /** 布尔运算
+   * @param subject 
+   * @param polygons 
+   * @param scale 数据缩放
+   * @returns 
+   */
+  static booleanOp(subject, clips, opt) {
+    const { type = "Union", subjectFillType = "NonZero", clipFillType = "NonZero", scale: scale2 = 100 } = opt;
+    if (subject instanceof Polygon) subject = [subject];
+    if (clips instanceof Polygon) clips = [clips];
+    subject = subject.map((subject2) => subject2.clone().scale(scale2).round());
+    clips = clips.map((clips2) => clips2.clone().scale(scale2).round());
+    const clipper = new ClipperLib.Clipper();
+    clipper.StrictlySimple = true;
+    clipper.PreserveCollinear = true;
+    subject = subject.map((p2) => {
+      p2 = ClipperLib.Clipper.CleanPolygon(p2, 0.5 * scale2 / 100);
+      Polygon.ensureCCW(p2);
+      return p2;
+    });
+    clips = clips.map((p2) => {
+      p2 = ClipperLib.Clipper.CleanPolygon(p2, 0.5 * scale2 / 100);
+      Polygon.ensureCCW(p2);
+      return p2;
+    });
+    clipper.AddPaths(subject, ClipperLib.PolyType.ptSubject, true);
+    clipper.AddPaths(clips, ClipperLib.PolyType.ptClip, true);
+    let solutions = [];
+    clipper.Execute(
+      ClipperLib.ClipType["ct" + type],
+      solutions,
+      ClipperLib.PolyFillType["pft" + subjectFillType],
+      ClipperLib.PolyFillType["pft" + clipFillType]
+    );
+    const inv = 1 / scale2;
+    const results = solutions.map((solution) => {
+      solution = solution.map((p2) => new Point(p2.X * inv, p2.Y * inv));
+      return new Polygon(solution);
+    }).filter((poly) => Math.abs(poly.area()) > 0.01);
+    return results;
+  }
 }
 async function include(path, exportDefault = true) {
   if (typeof global !== "undefined" && typeof require !== "undefined") {
@@ -5443,8 +5510,9 @@ function createPointVirtualGrid(lines) {
 }
 function createQuadtree(lines) {
   const quadtree = new Quadtree(Box2.fromByLineSegment(...lines));
-  for (const seg of lines) {
-    quadtree.insert(seg);
+  for (let i = 0; i < lines.length; i++) {
+    const seg = lines[i];
+    quadtree.insert(seg, { index: i });
   }
   return quadtree;
 }
@@ -5454,10 +5522,50 @@ function mToMm(value) {
 function mmTom(value) {
   return Number((value / 1e3).toFixed(4));
 }
+function getLineIndexByCenter(targetLines, lines) {
+  const grid = createQuadtree(lines);
+  const indices = targetLines.map((line) => {
+    const res = grid.queryPoint(line.center);
+    if (res.length) return res[0].userData.index;
+    return -1;
+  });
+  return indices;
+}
+function lazy(fn2) {
+  let cached = false;
+  let value;
+  let type;
+  return Object.freeze({
+    get isValueCreated() {
+      return cached;
+    },
+    get value() {
+      if (!cached) {
+        value = fn2();
+        cached = true;
+      }
+      return value;
+    },
+    get cachedValue() {
+      return cached ? value : void 0;
+    },
+    get valueType() {
+      if (type === void 0) type = typeof this.value;
+      return type;
+    },
+    reset() {
+      cached = false;
+      type = void 0;
+      value = void 0;
+    }
+  });
+}
 const tools = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   createPointVirtualGrid,
   createQuadtree,
+  getLineIndexByCenter,
+  lazy,
   mToMm,
   mmTom
 }, Symbol.toStringTag, { value: "Module" }));
@@ -16526,23 +16634,41 @@ class SceneAutoGenerat {
       child.updateWorldMatrix(false, false);
     });
   }
+  createGeometryByLines(lines) {
+    const shape = new THREE.Shape();
+    Polygon.fromByLinePath(lines, polygon);
+    polygon.forEach((p2, i) => i === 0 ? shape.moveTo(p2.x, p2.y) : shape.lineTo(p2.x, p2.y));
+    shape.closePath();
+    const geometry = new THREE.ShapeGeometry(shape);
+    return geometry;
+  }
   buildPlane(lines) {
     lines = lineSegmentClipping(lines, 0);
-    const removeSet = findDiscretePointLine2(lines, null, true);
-    lines = lines.filter((line) => !removeSet.has(line) && !line.userData.isBayWindow);
-    const doors = lines.filter((line) => line.userData.isDoor);
-    const maxiCircles2 = new MaxiCircles(), { circles } = maxiCircles2.miniCircle(lines, { circleEdges: doors, side: Side.IN });
-    circles.forEach((circle, i) => {
-      const shape = new THREE.Shape();
-      Polygon.fromByLinePath(circle, polygon);
-      polygon.forEach((p2, i2) => i2 === 0 ? shape.moveTo(p2.x, p2.y) : shape.lineTo(p2.x, p2.y));
-      shape.closePath();
-      const geometry = new THREE.ShapeGeometry(shape);
-      const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color: 11184810, side: THREE.DoubleSide }));
-      mesh.position.z = this.z;
-      mesh.name = `平面_${i}`;
-      mesh.userData.category = "plane";
-      this.scene.add(mesh);
+    LineSegment.groupByPath(lines).forEach((lines2, i) => {
+      const removeSet = findDiscretePointLine2(lines2, null, true);
+      lines2 = lines2.filter((line) => !removeSet.has(line) && !line.userData.isBayWindow);
+      const doors = lines2.filter((line) => line.userData.isDoor), maxiCircles2 = new MaxiCircles(), { circles } = maxiCircles2.miniCircle(lines2, { circleEdges: doors, side: Side.IN }), { circles: outCircles } = maxiCircles2.miniCircle(lines2, { circleEdges: doors, side: Side.OUT }), ploys = circles.map(((p2) => Polygon.fromByLinePath(p2)));
+      outCircles.forEach((circle) => {
+        const polygon2 = Polygon.fromByLinePath(circle);
+        const newPolys = Polygon.booleanOp(polygon2, ploys, { scale: 100, type: "Difference" });
+        newPolys.forEach((poly, j) => {
+          const geometry = this.createGeometryByLines(poly.toLines());
+          const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color: 11184810, side: THREE.DoubleSide }));
+          mesh.position.z = this.z;
+          mesh.name = `平面_out_${i}_${j}`;
+          mesh.userData.category = "plane";
+          this.scene.add(mesh);
+        });
+      });
+      circles.forEach((circle, j) => {
+        const geometry = this.createGeometryByLines(circle);
+        const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color: 11184810, side: THREE.DoubleSide }));
+        mesh.position.z = this.z;
+        mesh.name = `平面_${i}_${j}`;
+        mesh.userData.category = "plane";
+        mesh.userData.room = true;
+        this.scene.add(mesh);
+      });
     });
   }
   wallGroup = null;
@@ -19869,22 +19995,37 @@ function getGlobalDxfSystem() {
 function hasCircle(lineData, startIndex, direction) {
   let lines = originalDataToLineData(lineData).lineSegments;
   const center = lines[startIndex].center;
-  lines = lineSegmentClipping(lines, 1e-9);
-  let removeSet = findDiscretePointLine2(lines, /* @__PURE__ */ new Set(), true);
-  lines = lines.filter((line2) => !removeSet.has(line2));
-  const list = lines.filter((line2) => line2.userData.isBayWindow && line2.isPointOnSegment(center));
-  if (list.length === 0) return false;
+  let findlines = lineSegmentClipping(lines.map((line2) => line2.clone()), 1e-9);
+  let removeSet = findDiscretePointLine2(findlines, /* @__PURE__ */ new Set(), true);
+  findlines = findlines.filter((line2) => !removeSet.has(line2));
+  const list = findlines.filter((line2) => line2.userData.isBayWindow && line2.isPointOnSegment(center));
+  if (list.length === 0) return null;
   const miniCircles = new MiniCircles(), line = list[0], direct = Point.from(direction), entity = line.center.add(direct.multiplyScalar(1e-8)), path = /* @__PURE__ */ new Set([line]);
   const result = miniCircles.findSameSidePath({
     line,
     currentPoint: line.start,
     exitPoint: line.start,
     entity: entity.clone(),
-    grid: lines,
+    grid: findlines,
     side: Side.IN,
     path
   });
-  return !!result;
+  if (result) {
+    let indices = lazy(() => getLineIndexByCenter(result, findlines).filter((i) => i > -1));
+    let originalDataIndices = lazy(() => getLineIndexByCenter(result, lines).filter((i) => i > -1));
+    return {
+      get originalIndices() {
+        return originalDataIndices.value;
+      },
+      get indices() {
+        return indices.value;
+      },
+      circle: result,
+      originalLines: lines,
+      lines: findlines
+    };
+  }
+  return null;
 }
 export {
   ArrayMap as A,

package/src/utils/DxfSystem/utils/SceneAutoGenerat.d.ts

@@ -11,6 +11,7 @@ export declare class SceneAutoGenerat {
     angle: number;
     constructor(lines: LineSegment[], itemList: any[], z: number, trajectory?: any);
     init(): Promise<void>;
+    private createGeometryByLines;
     buildPlane(lines: LineSegment<LineUserData>[]): void;
     wallGroup: Group | null;
     /** 构建墙壁

package/src/utils/DxfSystem/utils/tools.d.ts

@@ -2,6 +2,19 @@ import { PointVirtualGrid } from '../../PointVirtualGrid';
 import { LineSegment } from '../../LineSegment';
 import { Quadtree } from '../../Quadtree';
 export declare function createPointVirtualGrid<T = any>(lines: LineSegment<T>[]): PointVirtualGrid<LineSegment<T>>;
-export declare function createQuadtree<T = any>(lines: LineSegment<T>[]): Quadtree<LineSegment<T>>;
+export declare function createQuadtree<T = any>(lines: LineSegment<T>[]): Quadtree<{
+    index: number;
+}>;
 export declare function mToMm(value: number): number;
 export declare function mmTom(value: number): number;
+export declare function getLineIndexByCenter(targetLines: LineSegment[], lines: LineSegment[]): number[];
+type JSValueType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export interface Lazy<T> {
+    readonly value: T;
+    readonly cachedValue: T | undefined;
+    readonly isValueCreated: boolean;
+    readonly valueType: JSValueType;
+    reset(): void;
+}
+export declare function lazy<T>(fn: () => T): Lazy<T>;
+export {};

package/src/utils/Polygon.d.ts

@@ -1,6 +1,14 @@
 import { Box2 } from './Box2';
 import { LineSegment } from './LineSegment';
 import { Point } from './Point';
+type BooleanOpType = "Union" | "Intersection" | "Difference" | "Xor";
+type FillType = "EvenOdd" | "NonZero" | "Positive" | "Negative";
+type BooleanOpOption = {
+    type: BooleanOpType;
+    scale: number;
+    subjectFillType?: FillType;
+    clipFillType?: FillType;
+};
 export declare class Polygon<T = any> extends Array<Point<T>> {
     [Symbol.iterator](): ArrayIterator<Point<T>>;
     constructor(points?: Point<T>[]);
@@ -55,10 +63,15 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
      * @param scale
      */
     scale(scale?: number): this;
+    round(): this;
     /**
      * @param polygon
      */
-    union(polygon: Polygon): boolean;
+    union(polygons: Polygon | Polygon[], scale?: number): boolean;
+    /** 差集
+     * @param polygon
+     */
+    difference(polygons: Polygon | Polygon[], scale?: number): boolean;
     /** 拆分为凸包
      * @returns
      */
@@ -70,6 +83,7 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
     toLines(closed?: boolean): LineSegment<Record<string, any>>[];
     toArrays(): [number, number][];
     close(): this;
+    clone(): Polygon<Record<string, any>>;
     /** 通过线段创建， 默认路径只有一条
      * @param lines
      * @returns
@@ -92,4 +106,16 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
      * @returns
      */
     static fromByLinePath(lines: LineSegment[], polygon?: Polygon<any>): Polygon<any>;
+    /**
+     * @param poly
+     */
+    static ensureCCW(poly: Polygon): void;
+    /** 布尔运算
+     * @param subject
+     * @param polygons
+     * @param scale 数据缩放
+     * @returns
+     */
+    static booleanOp(subject: Polygon | Polygon[], clips: Polygon | Polygon[], opt: BooleanOpOption): Polygon<Record<string, any>>[];
 }
+export {};

package/src/utils/Quadtree.d.ts

@@ -22,7 +22,7 @@ export declare class Quadtree<T = any> {
      * 插入线段节点
      * @param node 线段节点
      */
-    insert(node: QuadtreeNode<T> | LineSegment): void;
+    insert(node: QuadtreeNode<T> | LineSegment, userData?: any): void;
     /** 移除
      * @param node
      */