build-dxf 0.1.134 → 0.1.136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.1.134",
+  "version": "0.1.136",
   "description": "",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/api/getSocket.d.ts

@@ -0,0 +1 @@
+export declare const getPjPointAndPathSocketApi: (idRegion: any, resourceType: any) => Promise<any>;

package/src/build.js

@@ -305,6 +305,20 @@ class Rectangle {
     };
     return isPointInRectangle(line.points[0]) && isPointInRectangle(line.points[1]);
   }
+  /**
+   * 获取所有点在轴上的投影，并且返回区间
+   * @param rect 
+   * @param axis 
+   * @returns 
+   */
+  projectRectangle(rect, axis) {
+    const projections = rect.points.map((point2) => point2.dot(axis));
+    return [Math.min(...projections), Math.max(...projections)];
+  }
+  // 检测两个投影区间是否重叠
+  isProjectionOverlap(proj1, proj2) {
+    return proj1[0] < proj2[1] && proj2[0] < proj1[1];
+  }
   /**
    * 判断矩形是否与矩形相交
    * @description 使用分离轴定理
@@ -323,17 +337,10 @@ class Rectangle {
       const p2 = rectangle.points[(i + 1) % 4];
       axes.push(p1.leftNormal(p2));
     }
-    function projectRectangle(rect, axis) {
-      const projections = rect.points.map((point2) => point2.dot(axis));
-      return [Math.min(...projections), Math.max(...projections)];
-    }
-    function isProjectionOverlap(proj1, proj2) {
-      return proj1[0] < proj2[1] && proj2[0] < proj1[1];
-    }
     for (const axis of axes) {
-      const proj1 = projectRectangle(this, axis);
-      const proj2 = projectRectangle(rectangle, axis);
-      if (!isProjectionOverlap(proj1, proj2)) {
+      const proj1 = this.projectRectangle(this, axis);
+      const proj2 = this.projectRectangle(rectangle, axis);
+      if (!this.isProjectionOverlap(proj1, proj2)) {
         return false;
       }
     }
@@ -360,15 +367,15 @@ class Rectangle {
    * 
    * @returns 
    */
-  toBox() {
+  toBox(out = new Box2()) {
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
     this.points.forEach((p2) => {
       maxX = Math.max(p2.x, maxX);
       minX = Math.min(p2.x, minX);
-      maxY = Math.max(p2.x, maxY);
-      minY = Math.min(p2.x, minY);
+      maxY = Math.max(p2.y, maxY);
+      minY = Math.min(p2.y, minY);
     });
-    return new Box2(minX, maxX, minY, maxY);
+    return out.set(minX, minY, maxX, maxY);
   }
   /**
    * 
@@ -798,6 +805,24 @@ class PointUtils {
   static get globalPoint() {
     return this._globalPoint.value;
   }
+  static getCenter(points) {
+    let area2 = 0;
+    let cx = 0;
+    let cy = 0;
+    for (let i = 0, n = points.length; i < n; i++) {
+      const p1 = points[i];
+      const p2 = points[(i + 1) % n];
+      const cross = p1.x * p2.y - p2.x * p1.y;
+      area2 += cross;
+      cx += (p1.x + p2.x) * cross;
+      cy += (p1.y + p2.y) * cross;
+    }
+    area2 *= 0.5;
+    return new Point(
+      cx / (6 * area2),
+      cy / (6 * area2)
+    );
+  }
   /** 值网格化
    * @param points 
    * @param tolerance 
@@ -893,6 +918,30 @@ class PointUtils {
     else if (point22) point2.copy(point22);
     return point2;
   }
+  /** 导出为数组
+   * @param points 
+   * @returns 
+   */
+  static toArray(points) {
+    const array = new Float32Array(points.length * 2);
+    for (let i = 0; i < points.length; i++) {
+      const point2 = points[i];
+      array[i * 2 + 0] = point2.x;
+      array[i * 2 + 1] = point2.y;
+    }
+    return array;
+  }
+  /** 导出为数组
+  * @param points 
+  * @returns 
+  */
+  static fromArray(array) {
+    const points = new Array();
+    for (let i = 0; i < array.length; i += 2) {
+      points.push(new Point(array[i], array[i + 1]));
+    }
+    return points;
+  }
 }
 const LINE_SYMBOL = /* @__PURE__ */ Symbol("LINE_SYMBOL");
 class LineSegment {
@@ -2075,8 +2124,8 @@ class Box2 {
   }
   get center() {
     return new Point(
-      this.minX + (this.maxX - this.minX) * 0.5,
-      this.minY + (this.maxY - this.minY) * 0.5
+      (this.maxX + this.minX) * 0.5,
+      (this.maxY + this.minY) * 0.5
     );
   }
   constructor(minX = 0, maxX = 0, minY = 0, maxY = 0) {
@@ -3076,6 +3125,31 @@ class LineSegmentSpatialHash {
     out.length = write;
     return out;
   }
+  rectangleBounds = new Box2();
+  /** 通过矩形查询 */
+  queryRectangle(rectangle, out = []) {
+    const bounds = rectangle.toBox(this.rectangleBounds);
+    this.visited.clear();
+    out.length = 0;
+    const minCellX = this.toCell(bounds.minX);
+    const minCellY = this.toCell(bounds.minY);
+    const maxCellX = this.toCell(bounds.maxX);
+    const maxCellY = this.toCell(bounds.maxY);
+    for (let x = minCellX; x <= maxCellX; x++) {
+      for (let y = minCellY; y <= maxCellY; y++) {
+        const bucket = this.buckets.get(this.getKey(x, y));
+        if (!bucket) continue;
+        for (const line of bucket) {
+          if (this.visited.has(line)) continue;
+          this.visited.add(line);
+          if (rectangle.containsPoint(line.start) || rectangle.containsPoint(line.end) || rectangle.intersectLineSegment(line)) {
+            out.push(line);
+          }
+        }
+      }
+    }
+    return out;
+  }
   rayIntersectSegment(origin, dir, seg) {
     const x1 = origin.x;
     const y1 = origin.y;
@@ -5988,6 +6062,10 @@ class Polygon extends Array {
     this.set(result);
     return this;
   }
+  /** 通过线段分割
+   * @param line 
+   * @returns 
+   */
   clipByLine(line) {
     if (this.length < 3) return [];
     const intersections = [];
@@ -8845,6 +8923,7 @@ class WallHole {
    */
   static splitHole(target, source) {
     if (!Array.isArray(source)) source = [];
+    source = source.filter((line) => line.length > 1e-9);
     const iterator = this.getIterator(target);
     for (const hole of iterator) {
       let find = false, min = Infinity, maxLine = null;
@@ -9377,7 +9456,7 @@ const buildDoubleWallGroup = Object.assign((lines_, clearInternalLine) => {
   return group(lines_, clearInternalLine);
 }, {
   setTrajectory(trajectory_) {
-    if (trajectory_) trajectory = Object.values(trajectory_);
+    if (trajectory_) trajectory = Object.values(trajectory_).filter((p2) => !(p2.x < 0.01 && p2.y < 0.01));
     else trajectory = void 0;
   }
 });
@@ -10810,8 +10889,11 @@ function innerWallLine(lines, trajectory2) {
     }
     singleLine.push(...temLine.setLength(temLine.length + 1e-4).toRectangle(wallWidth, "butt").toLines());
   });
-  const [p1, ...pn2] = Polygon.multipleFromByLines(singleLine);
-  singleLine = Polygon.booleanOp(p1, pn2, { type: "Union", scale: 1e4 }).flatMap((p2) => p2.toLines());
+  const paths = Polygon.multipleFromByLines(singleLine);
+  if (paths.length > 1) {
+    const [p1, ...pn2] = paths;
+    singleLine = Polygon.booleanOp(p1, pn2, { type: "Union", scale: 1e4 }).flatMap((p2) => p2.toLines());
+  }
   singleLine = singleLine.filter((line) => line.length > 0.2);
   singleLine = LineSegmentUtils.deduplicate(
     LineSegmentUtils.splitIntersections(singleLine, {
@@ -11611,7 +11693,7 @@ function layoutDesign(lines, axis, intersectPoints, opt) {
   });
   const newLines = [];
   for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i], line = lines[block.index];
+    const block = blocks[i], line = lines[block.index], occupationIndexList = [];
     let ranges = [];
     let start = block.range[0];
     for (let j = i + 1; j < blocks.length; j++) {
@@ -11622,6 +11704,7 @@ function layoutDesign(lines, axis, intersectPoints, opt) {
         ranges.push([start, nextBlock.range[0]]);
       }
       start = Math.max(start, nextBlock.range[1]);
+      occupationIndexList.push(nextBlock.index);
     }
     if (start < block.range[1]) ranges.push([start, block.range[1]]);
     ranges = ranges.filter((range) => range[1] - range[0] > 1e-4);
@@ -11636,7 +11719,10 @@ function layoutDesign(lines, axis, intersectPoints, opt) {
         newLines.push(newLine);
       }
     }
-    if (ranges.length === 0) line.currentData[DELETE_SYMBOL] = true;
+    if (ranges.length === 0) {
+      line.currentData[DELETE_SYMBOL] = true;
+      opt.onSegmentClippedAway?.(line, occupationIndexList.map((i2) => lines[i2]).filter((line2) => !line2.currentData[DELETE_SYMBOL]));
+    }
   }
   sortByAxis(newLines, axis);
   const psh = PointSpatialHash.from(intersectPoints);
@@ -11646,7 +11732,7 @@ function layoutDesign(lines, axis, intersectPoints, opt) {
     const nextLine = newLines[i + 1];
     nextLine.start.copy(line.start);
     line.currentData[DELETE_SYMBOL] = true;
-    opt.onMergeLine && opt.onMergeLine(nextLine, line);
+    opt.onMergeLine?.(nextLine, line);
   }
   lines.length = 0;
   lines.push(...newLines);
@@ -11855,7 +11941,8 @@ function correction(lines, targettLine, option) {
         group2.forEach((line) => {
           line.userData.wallWidth = dist;
         });
-      }
+      },
+      onSegmentClippedAway: WallHole.splitHole.bind(WallHole)
       // esp: 0.4
     });
   }).handle("balconyRailing", (lines2) => AlignToParallelSegments.align(lines2)).merge();

package/src/index3.js

@@ -16813,7 +16813,7 @@ class PointDrag extends Command {
     const wallObj = new Wall2D(wallLine, 0.02).setColor(new THREE.Color(65280));
     this.container.add(wallObj);
     const lineSelector = new LineSelector(this.editor);
-    lineSelector.onPointerMove = (line22) => {
+    lineSelector.onPointerMove = (_, line22) => {
       if (line22) {
         wallLine.copy(line22);
         wallObj.visible = true;
@@ -16853,6 +16853,8 @@ class PointDrag extends Command {
         line2.start.copy(newData.start);
         line2.end.copy(newData.end);
         WallHole.filterIllegal([line2]);
+        this.renderManager.removeLine(line2);
+        this.renderManager.addLine(line2);
       });
     }
     this.renderManager.draw();
@@ -16870,6 +16872,8 @@ class PointDrag extends Command {
         line2.start.copy(newData.start);
         line2.end.copy(newData.end);
         WallHole.filterIllegal([line2]);
+        this.renderManager.removeLine(line2);
+        this.renderManager.addLine(line2);
       });
     }
     this.renderManager.draw();

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

@@ -5,6 +5,7 @@ export interface AlignDescriptor {
     gap?: number;
     onMergeLine?: (target: LineSegment, source: LineSegment) => void;
     onGroup?: OnGroupFun;
+    onSegmentClippedAway?: (target: LineSegment, clipLines: LineSegment[]) => void;
 }
 /** 通过平行轴和垂直轴分组对齐线段，搭配垂直纠正使用
  */

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

@@ -0,0 +1,47 @@
+export declare class Message {
+    readonly msg: string;
+    private readonly memory;
+    constructor(msg: string, memory?: Message[]);
+    getMemory(): Message[];
+    createNewMessage(msg: string): Message;
+    eqMemory(message: Message): boolean;
+}
+export interface TopicTemplate {
+    ask(message: Message, pipeline: LLMPipeline): TaskResult;
+}
+export declare class Task {
+    private template;
+    name: string;
+    constructor(template: TopicTemplate, name?: string);
+    ask(message: Message, pipeline: LLMPipeline): Promise<TaskResult>;
+}
+export interface TaskResult {
+    message: Message;
+    nextTasks?: Task[];
+    stop?: boolean;
+}
+export declare class LLMPipeline {
+    queue: Task[];
+    private currentTaskIndex;
+    /** 获取当前任务顺序
+     * @returns
+     */
+    getTaskIndex(): number;
+    /** 插入任务, 默认队尾
+     * @param task
+     * @param index
+     */
+    insert(task: Task, index?: number): void;
+    /** 当前任务后插入
+     * @param task
+     */
+    insertNext(task: Task | Task[]): void;
+    /** 清理
+     */
+    clear(): void;
+    /** 执行
+     * @param message
+     * @returns
+     */
+    execute(msg: string): Promise<Message>;
+}

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

@@ -1,6 +1,7 @@
 import { Box2 } from './Box2';
 import { LineSegment } from './LineSegment';
 import { Point } from './Point';
+import { Rectangle } from './Rectangle';
 export interface RaycastHit {
     line: LineSegment;
     point: Point;
@@ -60,6 +61,9 @@ export declare class LineSegmentSpatialHash {
      * 查询相交线段
      */
     queryLine(line: LineSegment, out?: LineSegment[]): LineSegment<Record<string, any>>[];
+    private rectangleBounds;
+    /** 通过矩形查询 */
+    queryRectangle(rectangle: Rectangle, out?: LineSegment[]): LineSegment<Record<string, any>>[];
     private rayIntersectSegment;
     /**
      * 射线检测

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

@@ -3,6 +3,7 @@ import { Point } from './Point';
 export declare class PointUtils {
     private static _globalPoint;
     static get globalPoint(): Point<Record<string, any>>;
+    static getCenter(points: Point[]): Point<Record<string, any>>;
     /** 值网格化
      * @param points
      * @param tolerance
@@ -33,4 +34,14 @@ export declare class PointUtils {
      * @returns
      */
     static constrainPointToAxis(point: Point, baseLine: LineSegment, normalStartPoint?: Point | null, baseNormalLine?: LineSegment): Point<Record<string, any>>;
+    /** 导出为数组
+     * @param points
+     * @returns
+     */
+    static toArray(points: Point[]): Float32Array<ArrayBuffer>;
+    /** 导出为数组
+    * @param points
+    * @returns
+    */
+    static fromArray(array: Array<number> | Float32Array): Point<Record<string, any>>[];
 }

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

@@ -45,6 +45,10 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
      * @param width
      */
     closedExpansion(width: number, scale?: number): this | null;
+    /** 通过线段分割
+     * @param line
+     * @returns
+     */
     clipByLine(line: LineSegment): Polygon<Record<string, any>>[];
     /**
      * 获取点相对于多边形的位置

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

@@ -27,6 +27,14 @@ export declare class Rectangle {
      * @returns 是否完全在矩形内部
      */
     containsLineSegment(line: LineSegment): boolean;
+    /**
+     * 获取所有点在轴上的投影，并且返回区间
+     * @param rect
+     * @param axis
+     * @returns
+     */
+    private projectRectangle;
+    private isProjectionOverlap;
     /**
      * 判断矩形是否与矩形相交
      * @description 使用分离轴定理
@@ -43,7 +51,7 @@ export declare class Rectangle {
      *
      * @returns
      */
-    toBox(): Box2;
+    toBox(out?: Box2): Box2;
     /**
      *
      * @param line