build-dxf 0.1.144 → 0.1.146

package/package.json

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

package/src/build.js

@@ -4337,6 +4337,35 @@ class LineSegmentUtils {
     }
     return result;
   }
+  /** 线段最佳吸附参考线查找
+   * @param opt 
+   */
+  static findBestReferenceSegment(opt) {
+    const { lines } = opt;
+    const lsh = LineSegmentSpatialHash.from(opt.referenceLines);
+    const results = new Array(lines.length);
+    function parallelWeight(angle) {
+      return Math.abs(angle - 90) / 90;
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const rectangle = line.toRectangle(0.5, "butt");
+      const findResult = lsh.queryRectangle(rectangle).filter((quLine) => quLine.isParallelTo(line, 20)).sort((l1, l2) => {
+        const angle1 = line.angle(l1, { unit: "degree", range: "180" });
+        const angle2 = line.angle(l2, { unit: "degree", range: "180" });
+        const aW1 = parallelWeight(angle1) * 5;
+        const aW2 = parallelWeight(angle2) * 5;
+        const dist1 = line.distanceToSegment(l1);
+        const dist2 = line.distanceToSegment(l2);
+        const maxDist = Math.max(dist1, dist2);
+        const dW1 = (1 - dist1 / maxDist) * 3;
+        const dW2 = (1 - dist2 / maxDist) * 3;
+        return aW2 + dW2 - (aW1 + dW1);
+      });
+      results[i] = findResult.length ? findResult[0] : null;
+    }
+    return results;
+  }
 }
 class Lines extends THREE.LineSegments {
   geometry = new THREE.BufferGeometry();
@@ -6267,6 +6296,16 @@ class Polygon extends Array {
     }
     return lines.filter((line) => line.length > 1e-9);
   }
+  /** 转为矩形
+   * @param out 
+   */
+  toRectangle(out = new Rectangle()) {
+    const polygon2 = this.getMinimumBoundingRectangle();
+    if (polygon2) {
+      out.points = [polygon2[0], polygon2[1], polygon2[2], polygon2[3]];
+      return out;
+    }
+  }
   toArrays() {
     return this.map((p2) => p2.toArray());
   }
@@ -8480,10 +8519,144 @@ class PCSparseOctree {
   }
 }
 const box3$1 = new THREE.Box3();
+function projectPointToSegment(point2, start, end) {
+  const dir = end.clone().sub(start);
+  const len2 = dir.lengthSq();
+  if (len2 < 1e-12) {
+    return 0;
+  }
+  let t2 = point2.clone().sub(start).dot(dir) / len2;
+  t2 = Math.max(0, Math.min(1, t2));
+  return t2;
+}
+function rectangleToLine(rectangle) {
+  const [l0, l1, l2, l3] = rectangle.toLines();
+  if (l0.length < l1.length) return new LineSegment(l0.center, l2.center);
+  return new LineSegment(l1.center, l3.center);
+}
+class CheckPointCloudContinuity {
+  static continuity(ts2, len, gridSize = 0.02, ratio = 0.6) {
+    if (ts2.length < 2) return false;
+    const voxels = /* @__PURE__ */ new Set();
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i2 = 0; i2 < ts2.length; i2++) {
+      const dist = ts2[i2] * len;
+      const voxel = Math.floor(dist / gridSize);
+      voxels.add(voxel);
+      min = Math.min(min, voxel);
+      max = Math.max(max, voxel);
+    }
+    const values = [...voxels].sort((a2, b4) => a2 - b4);
+    let start = values[0], i = 0;
+    const ranges = [];
+    for (i = 1; i < values.length; i++) {
+      const pre = values[i - 1];
+      const v2 = values[i];
+      if (v2 - pre > 2) {
+        ranges.push([start, pre]);
+        start = v2;
+      }
+    }
+    ranges.push([start, values[values.length - 1]]);
+    const occupiedLength = ranges.reduce((sum, [start2, end]) => sum + (end - start2 + 1), 0);
+    const totalLength = max - min + 1;
+    if (occupiedLength / totalLength < ratio) {
+      return false;
+    }
+    return true;
+  }
+  /** 多轴投影连续性检测
+   * @param points 
+   */
+  static checkByProjectionContinuity(points, opt) {
+    let { ratio = 0.6, axisLine } = opt ?? {};
+    if (!axisLine) {
+      const rectangle = new Polygon(
+        points.map((p2) => new Point(p2.x, p2.y))
+      ).toRectangle();
+      axisLine = rectangleToLine(rectangle);
+    } else if (!(axisLine instanceof LineSegment)) {
+      axisLine = new LineSegment(Point.from(axisLine.start), Point.from(axisLine.end));
+    }
+    const xline = axisLine;
+    const start = new Vector3(), end = new Vector3();
+    start.set(xline.start.x, xline.start.y, 0);
+    end.set(xline.end.x, xline.end.y, 0);
+    const xts = this.projectPoint(points, start, end);
+    if (!this.continuity(xts, xline.length, ratio)) return false;
+    const yline2 = xline.clone().rotate(Math.PI * 0.5);
+    start.set(yline2.start.x, yline2.start.y, 0);
+    end.set(yline2.end.x, yline2.end.y, 0);
+    const yts = this.projectPoint(points, start, end);
+    if (!this.continuity(yts, yline2.length, ratio)) return false;
+    const center = xline.center.clone();
+    start.set(center.x, center.y, 10);
+    end.set(center.x, center.y, -10);
+    const zts = this.projectPoint(points, start, end);
+    if (!this.continuity(zts, 20, ratio)) return false;
+    return true;
+  }
+  /** 通过区域投影面积占比检测
+   * @param points 
+   * @returns 
+   */
+  static checkByVoxelDensity(points, opt) {
+    let { gridSize = 0.08, xRatio = 0.5, yRatio = 0.4, overallRatio = 0.5, axisLine } = opt ?? {};
+    if (!axisLine) {
+      const rectangle = new Polygon(
+        points.map((p2) => new Point(p2.x, p2.y))
+      ).toRectangle();
+      axisLine = rectangleToLine(rectangle);
+    } else if (!(axisLine instanceof LineSegment)) {
+      axisLine = new LineSegment(Point.from(axisLine.start), Point.from(axisLine.end));
+    }
+    let xline = axisLine;
+    if (!xline) {
+      const rectangle = new Polygon(points.map((p2) => new Point(p2.x, p2.y))).toRectangle();
+      xline = rectangleToLine(rectangle);
+    }
+    const dir = xline.direction(), angle = Math.atan2(dir.y, dir.x), center = xline.center, cos = Math.cos(-angle), sin = Math.sin(-angle), voxelizationPoints = [], xMap = new CounterMap(), yMap = new CounterMap(), occupied = /* @__PURE__ */ new Set();
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    points.forEach((p2) => {
+      const dx = p2.x - center.x, dy = p2.y - center.y, x = Math.floor((dx * cos - dy * sin) / gridSize), y = Math.floor(p2.z / gridSize), key = BigInt(x) << 32n ^ BigInt(y) & 0xffffffffn;
+      if (occupied.has(key)) return;
+      occupied.add(key);
+      xMap.increment(x, 1);
+      yMap.increment(y, 1);
+      voxelizationPoints.push(x, y);
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    });
+    const xRange = maxX - minX + 1, yRange = maxY - minY + 1;
+    let satisfyQuantity = 0;
+    for (let i = 0; i < voxelizationPoints.length; i += 2) {
+      const x = voxelizationPoints[i], y = voxelizationPoints[i + 1], xCount = xMap.get(x), yCount = yMap.get(y);
+      if (xCount / yRange > xRatio && yCount / xRange > yRatio) satisfyQuantity++;
+    }
+    return satisfyQuantity / (voxelizationPoints.length / 2) > overallRatio;
+  }
+  /** 获取投影值
+   * @param points 
+   * @param start 
+   * @param end 
+   * @returns 
+   */
+  static projectPoint(points, start, end) {
+    const point2 = new Vector3();
+    return points.map((p2) => {
+      point2.copy(p2);
+      return projectPointToSegment(point2, start, end);
+    }).sort((a2, b4) => a2 - b4);
+  }
+}
 const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   ArrayMap,
   Box2,
+  CheckPointCloudContinuity,
   CommandFlow,
   CommandManager,
   Component,

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

@@ -0,0 +1,62 @@
+import { Vector3 } from 'three';
+type Point3D = {
+    x: number;
+    y: number;
+    z: number;
+};
+type LineSegmentType = {
+    start: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    end: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+};
+/**
+ * 检测点云在分部轴上的连续性，z朝上
+ */
+export declare class CheckPointCloudContinuity {
+    static continuity(ts: number[], len: number, gridSize?: number, ratio?: number): boolean;
+    /** 多轴投影连续性检测
+     * @param points
+     */
+    static checkByProjectionContinuity(points: Point3D[], opt?: {
+        ratio?: number;
+        axisLine?: LineSegmentType;
+    }): boolean;
+    /** 通过区域投影面积占比检测
+     * @param points
+     * @returns
+     */
+    static checkByVoxelDensity(points: Point3D[], opt?: {
+        /**
+         * 体素大小
+         */
+        gridSize?: number;
+        /**
+         * 竖直轴占比比例
+         */
+        xRatio?: number;
+        /**
+         * 水平轴占比比例
+         */
+        yRatio?: number;
+        /**
+         * 总占比比例
+         */
+        overallRatio?: number;
+        axisLine?: LineSegmentType;
+    }): boolean;
+    /** 获取投影值
+     * @param points
+     * @param start
+     * @param end
+     * @returns
+     */
+    static projectPoint(points: Point3D[], start: Vector3, end: Vector3): number[];
+}
+export {};

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

@@ -1,5 +1,6 @@
 import { LineSegment } from './LineSegment';
 import { Point } from './Point';
+import { Rectangle } from './Rectangle';
 export declare class LineSegmentUtils {
     static clone(lines: LineSegment[]): LineSegment<Record<string, any>>[];
     /**保留小数位数
@@ -156,4 +157,17 @@ export declare class LineSegmentUtils {
      * @param pattern
      */
     static dash(line: LineSegment, pattern: number[]): LineSegment<Record<string, any>>[];
+    /** 线段最佳吸附参考线查找
+     * @param opt
+     */
+    static findBestReferenceSegment<TLines extends readonly LineSegment[], TReferenceLines extends readonly LineSegment[]>(opt: {
+        lines: TLines;
+        linesScope: {
+            [K in keyof TLines]: Rectangle;
+        };
+        referenceLines: TReferenceLines;
+        referenceLinesScope: {
+            [K in keyof TReferenceLines]: Rectangle;
+        };
+    }): (LineSegment<Record<string, any>> | null)[];
 }

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

@@ -1,6 +1,7 @@
 import { Box2 } from './Box2';
 import { LineSegment } from './LineSegment';
 import { Point } from './Point';
+import { Rectangle } from './Rectangle';
 type BooleanOpType = "Union" | "Intersection" | "Difference" | "Xor";
 type FillType = "EvenOdd" | "NonZero" | "Positive" | "Negative";
 type BooleanOpOption = {
@@ -105,6 +106,10 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
      * @returns
      */
     toLines(closed?: boolean): LineSegment<Record<string, any>>[];
+    /** 转为矩形
+     * @param out
+     */
+    toRectangle(out?: Rectangle): Rectangle | undefined;
     toArrays(): [number, number][];
     close(): this;
     clone(): Polygon<Record<string, any>>;

package/src/utils/index.d.ts

@@ -21,3 +21,4 @@ export * from './algorithms/MaxiCircles';
 export * from './algorithms/MiniCircles';
 export * from './algorithms/OBB';
 export * from './algorithms/PCSparseOctree';
+export * from './algorithms/CheckPointCloudContinuity';