build-dxf 0.1.56 → 0.1.57

package/package.json

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

package/src/build.js

@@ -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") {
@@ -5464,11 +5531,41 @@ function getLineIndexByCenter(targetLines, lines) {
   });
   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" }));
@@ -16537,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;
@@ -19896,16 +20011,14 @@ function hasCircle(lineData, startIndex, direction) {
     path
   });
   if (result) {
-    let indices = null;
-    let originalDataIndices = null;
+    let indices = lazy(() => getLineIndexByCenter(result, findlines).filter((i) => i > -1));
+    let originalDataIndices = lazy(() => getLineIndexByCenter(result, lines).filter((i) => i > -1));
     return {
       get originalIndices() {
-        if (!originalDataIndices) originalDataIndices = getLineIndexByCenter(result, lines).filter((i) => i > -1);
-        return originalDataIndices;
+        return originalDataIndices.value;
       },
       get indices() {
-        if (!indices) indices = getLineIndexByCenter(result, findlines).filter((i) => i > -1);
-        return indices;
+        return indices.value;
       },
       circle: result,
       originalLines: lines,

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

@@ -8,3 +8,13 @@ export declare function createQuadtree<T = any>(lines: LineSegment<T>[]): Quadtr
 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 {};