rm-build-dxf 0.1.186

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

@@ -0,0 +1,56 @@
+import { Octant, PointData } from 'sparse-octree';
+import { OBB } from './OBB';
+import * as THREE from 'three';
+export declare class PCSparseOctree<T> {
+    private octree;
+    bound: THREE.Box3;
+    constructor(bound: THREE.Box3);
+    /** 插入点 + 数据
+     * @param point
+     * @param data
+     */
+    insert(point: THREE.Vector3, data: T): void;
+    /** 批量插入（推荐大批量时用）
+     * @param points
+     * @param datas
+     */
+    insertBatch(points: THREE.Vector3[], datas: T[]): void;
+    /** 查找所有在 oBB 内的盒子
+     * @param queryOBB
+     * @returns
+     */
+    findNodeInOBB(queryOBB: OBB): Octant<PointData<T>>[];
+    /** 查找所有在 oBB 内的点（带数据）
+     * @param queryOBB
+     * @returns
+     */
+    findPointsInOBB(queryOBB: OBB): Array<{
+        point: THREE.Vector3;
+        data: T;
+    }>;
+    /** 通过半径查找
+     * @param position
+     * @param radius
+     * @param skipSelf
+     * @returns
+     */
+    findPointsByCircle(position: THREE.Vector3, radius: number, skipSelf?: boolean): import('sparse-octree').PointContainer<T>[];
+    /** 查找最近的点
+     * @param position
+     * @param maxDistance
+     * @param skipSelf
+     * @returns
+     */
+    findNearestPoint(position: THREE.Vector3, maxDistance: number, skipSelf?: boolean): import('sparse-octree').PointContainer<T> | null;
+    /** 批量查询
+     * @param obbList
+     * @returns
+     */
+    findPointsInOBBBatch(obbList: OBB[]): {
+        point: THREE.Vector3;
+        data: T;
+    }[][];
+    static fromPoints(points: THREE.Vector3[]): PCSparseOctree<{
+        index: number;
+    }>;
+}

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

@@ -0,0 +1,20 @@
+export interface HandlerContext<T = any, C = any> {
+    type: string;
+    data: T;
+    cache: C;
+    stopped?: boolean;
+}
+type HandleFunc<T, C> = (ctx: HandlerContext<T, C>) => void | T;
+type Type<S extends string = string> = S | S[];
+export interface Handler<T = any, C = any, S extends string = string> {
+    type: Type<S>;
+    handle: HandleFunc<T, C>;
+}
+export declare class Pipeline<T = any, C = any, S extends string = string> {
+    private map;
+    use(handler: Handler<T, C, S>): this;
+    use(type: Type<S>, func: HandleFunc<T, C>): this;
+    run(type: S, data: T, cache?: C): T;
+    clear(): void;
+}
+export {};

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

@@ -0,0 +1,271 @@
+import { Vector3 } from 'three';
+import { LineSegment } from './LineSegment';
+export type PointType = Point | {
+    x: number;
+    y: number;
+} | [number, number];
+export declare class Point<T = Record<string, any>> {
+    private _x;
+    private _y;
+    private _version;
+    get version(): number;
+    get X(): number;
+    get Y(): number;
+    get x(): number;
+    get y(): number;
+    set x(x: number);
+    set y(y: number);
+    userData: T;
+    currentData: Record<string | number | symbol, any>;
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    constructor(x?: number, y?: number);
+    private _set;
+    set(x: number, y: number): this;
+    setByDirect(direct: Point, origin: Point, width: number): void;
+    setX(x: number): this;
+    setY(y: number): this;
+    /**
+     *
+     * @param point
+     * @returns
+     */
+    equal(point: Point, eps?: number): boolean;
+    /**
+     *
+     * @param arr
+     */
+    setByArray(arr: number[]): this;
+    /** 乘法
+     * @param scalar
+     * @returns
+     */
+    multiply(point: Point): this;
+    /** 乘以一个标量
+     * @param scalar
+     * @returns
+     */
+    multiplyScalar(scalar: number): this;
+    /** 除法
+     * @param scalar
+     * @returns
+     */
+    division(point: Point): this;
+    /** 除一个标量
+     * @param scalar
+     * @returns
+     */
+    divisionScalar(scalar: number): this;
+    /**
+     * 减法
+     * @description 将当前点的坐标减去指定点的坐标
+     * @param point
+     * @returns
+     */
+    subtract(point: Point): this;
+    /**
+     * 减一个标量
+     * @description 将当前点的坐标减去指定点的坐标
+     * @param point
+     * @returns
+     */
+    subtractScalar(value: number): this;
+    /**
+     * 加法
+     * @description 将当前点的坐标加上指定点的坐标
+     * @param point
+     * @returns
+     */
+    add(point: Point): this;
+    /** 加一个标量
+    * @description 将当前点的坐标加上指定点的坐标
+    * @param point
+    * @returns
+    */
+    addScalar(value: number): this;
+    /**
+     * 加法（不可变）
+     * @description 返回当前点与指定点相加后的新点，不修改当前点
+     * @param point
+     * @param out 输出对象，用于复用对象减少 GC
+     * @returns 相加后的点
+     */
+    added(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 减法（不可变）
+     * @description 返回当前点减去指定点后的新点，不修改当前点
+     * @param point
+     * @param out 输出对象，用于复用对象减少 GC
+     * @returns 相减后的点
+     */
+    subtracted(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /** 转为整型
+     * @returns
+     */
+    parseInt(): this;
+    /**
+     * 绕point旋转angle
+     * @param point
+     * @param angle 旋转角度，单位为弧度
+     */
+    rotate(point: {
+        x: number;
+        y: number;
+    }, angle: number): this;
+    /**
+     * 旋转（不可变）
+     * @description 返回当前点绕指定中心旋转后的新点，不修改当前点
+     * @param center 旋转中心
+     * @param angle 旋转角度（弧度）
+     * @param out 输出对象，用于复用对象减少 GC
+     * @returns 旋转后的点
+     */
+    rotated(center: {
+        x: number;
+        y: number;
+    }, angle: number, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 保留小数位数
+     * @param count
+     */
+    precision(count: number): this;
+    /** 保留四位小数
+     * @returns
+     */
+    precision4(): this;
+    /**
+     * 归一化
+     * @description 将当前点的坐标归一化为单位向量
+     * @returns
+     */
+    normalize(): this;
+    /**
+    * 归一化（不可变）
+    * @description 返回当前向量归一化后的新点，不修改当前点
+    * @param out 输出对象，用于复用对象减少 GC
+    * @returns 单位向量
+    */
+    normalized(out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 获取单位左法向量
+     * @description 计算当前点到指定点的方向向量，并返回逆时针旋转90度后的单位法向量
+     * @param point
+     * @returns
+     */
+    leftNormal(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 获取由传入的点到该点的单位方向向量
+     * @description 计算当前点到指定点的方向向量，并返回单位方向
+     * @param point
+     * @returns
+     */
+    directionFrom(point: Point, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /** 展开为线
+     * @param direction
+     * @param length
+     */
+    expandAsLine<T = any>(direction: Point, length: number, userData?: T, line?: LineSegment<T>): LineSegment<T>;
+    /**
+     * 计算模长
+     * @returns
+     */
+    magnitude(): number;
+    /**
+     * 计算点点积
+     * @param point
+     * @returns
+     */
+    dot(point: Point): number;
+    /** 求两个点叉积
+     * @description 如果叉积大于 0，a 到 b 为逆时针方向。
+     * @description 如果叉积小于 0，a 到 b 为顺时针方向。
+     * @param point
+     * @returns
+     */
+    cross(point: Point): number;
+    /** 计算两个向量夹角
+     * @description 公式：a · b = |a| × |b| × cosθ
+     * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
+     * @deprecated 已弃用，请使用angle
+     * @param point
+     * @returns
+     */
+    angleBetween(point: Point, type?: 'radian' | 'cos' | 'angle', angle?: "180" | "360"): number;
+    /**
+     * @param point
+     * @deprecated 已弃用，请使用angle
+     * @returns
+     */
+    angleBetween2(point: Point): number;
+    /** 获取夹角
+     * @param point
+     * @param opt
+     * @returns
+     */
+    angle(point: Point, opt?: {
+        unit?: 'radian' | 'degree' | 'cos';
+        range?: '180' | '360';
+    }): number;
+    /** 获取向量长度
+     */
+    length(): number;
+    /**
+     * 获取两个点长度
+     * @param point
+     */
+    distance(point: {
+        x: number;
+        y: number;
+    }): number;
+    /**
+     * @param point
+     * @returns
+     */
+    distanceSquared(point: {
+        x: number;
+        y: number;
+    }): number;
+    hashCode(fixed?: number): string;
+    encode(): bigint;
+    /**
+     * 克隆
+     * @returns
+     */
+    clone(out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 克隆
+     * @returns
+     */
+    copy(p: PointType): this;
+    /** 转为数组
+     */
+    toArray(): [number, number];
+    /** 转为json
+     * @param z
+     * @returns
+     */
+    toJson(z?: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    toJson2D(): {
+        x: number;
+        y: number;
+    };
+    toVector3(z?: number): Vector3;
+    /** 创建
+     * @param arr
+     * @returns
+     */
+    static from(arr: any): Point<Record<string, any>>;
+    /** 通过列表批量创建
+     * @param arr
+     * @returns
+     */
+    static fromByList(arr: any[]): Point<Record<string, any>>[];
+    static zero(): Point<Record<string, any>>;
+}

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

@@ -0,0 +1,149 @@
+import { Box2 } from './Box2';
+import { Point } from './Point';
+import { Polygon } from './Polygon';
+import { Rectangle } from './Rectangle';
+import { LineSegment } from './LineSegment';
+type Target<T> = {
+    point: Point;
+    userData?: T;
+};
+type NodeSet<T> = Set<Target<T>>;
+export type PvgTarget<T> = Target<T>;
+export type ResultList<T = any> = Array<Target<T>>;
+export type CircleResult<T = any> = {
+    point: Point;
+    distanceSq: number;
+    userData?: T;
+};
+export declare class PointSpatialHash<T = Record<string, any>> {
+    map: Map<string, NodeSet<T>>;
+    gridSize: number;
+    id: symbol;
+    constructor(gridSize?: number);
+    /**
+     * 插入
+     * @param point
+     * @param userData
+     */
+    insert(point: Point, userData?: T): this;
+    /**
+     * 批量加入
+     * @param points
+     */
+    insertBatch(points: Array<{
+        point: Point;
+        userData?: T;
+    }>): void;
+    /** 移除点
+     * @param point
+     */
+    remove(point: Point): this;
+    /** 移除点
+     * @param points
+     */
+    removes(points: Point[]): this;
+    update(point: Point): boolean;
+    updates(point: Point[]): void;
+    /**
+     * 获取通过坐标，获取唯一网格索引
+     * @param point
+     * @returns
+     */
+    getGridIdByPoint(point: Point): string;
+    getGridId(i: number, j: number): string;
+    /**
+     * 清空所有数据
+     */
+    clear(): void;
+    /** 遍历网格
+     * @param minI
+     * @param maxI
+     * @param minJ
+     * @param maxJ
+     * @param callback
+     */
+    private forEachGrid;
+    /**
+     * 查询与矩形相交的点
+     * @param rectangle 矩形
+     * @returns 相交的节点数组
+     */
+    queryRect(rectangle: Rectangle): {
+        point: Point;
+        userData?: T;
+    }[];
+    /**
+     * 查询与圆形区域相交的点
+     * @param pos 圆心
+     * @param radius 半径
+     * @returns 相交的节点数组
+     */
+    queryCircle(pos: Point, radius: number, excludeOneself?: boolean): ResultList<T>;
+    /**
+     * 查询与包围盒相交的点
+     * @param box2 包围盒
+     * @returns 相交的节点数组
+     */
+    queryBox(box2: Box2): {
+        point: Point;
+        userData?: T;
+    }[];
+    /**
+     * 查找相同点
+     * @param point
+     */
+    queryPoint(point: Point, excludeOneself?: boolean): ResultList<T>;
+    /** 批量查询点
+     * @param points
+     * @param excludeOneself
+     * @returns
+     */
+    queryPoints(points: Point[], excludeOneself?: boolean): ResultList<T>;
+    /** 获取多边形内的点
+     * @param polygon
+     */
+    queryPolygon(polygon: Polygon, position?: "inside" | "on" | "all"): {
+        point: Point;
+        userData?: T;
+    }[];
+    /**
+     * 查找点自己
+     * @param point
+     */
+    queryPointSelf(point: Point): {
+        point: Point;
+        userData: T;
+    } | null;
+    /** 通过点，从近到远按圈层搜索
+     * 同一圈内不保证距离顺序
+     * 返回第一个满足条件的圈层
+     */
+    searchByRing(point: Point, fn: (circle: CircleResult<T>[], circleNum: number) => boolean, maxRing?: number): CircleResult<T>[] | null;
+    /**
+     * @param point
+     * @param excludeSelf
+     * @returns
+     */
+    findNearest(point: Point, excludeSelf?: boolean): CircleResult<T> | null;
+    /**
+     * @param point
+     */
+    isFreePoint(point: Point): boolean;
+    /** 查找游离的点
+     */
+    getFreePoint(): Target<T>[];
+    /** 查找第一个游离的点
+     */
+    getFreePointFirst(): Target<T> | undefined;
+    /** 通过点快速创建
+     * @param lines
+     * @returns
+     */
+    static from(points: Point[], gridSize?: number): PointSpatialHash<number>;
+    /** 通过线段快速创建
+     * @param lines
+     * @returns
+     */
+    static fromByLines<T = any>(lines: LineSegment<T>[]): PointSpatialHash<LineSegment<T>>;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { LineSegment } from './LineSegment';
+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
+     */
+    static quantize(points: Point[], tolerance?: number): Point<Record<string, any>>[];
+    /**保留小数位数
+     * @param points
+     */
+    static precision(points: Point[], count: number): Point<Record<string, any>>[];
+    /**保留四位小数位数
+     * @param points
+     */
+    static precision4(points: Point[]): Point<Record<string, any>>[];
+    /** 点吸附
+     * @param points
+     * @param tolerance
+     * @returns
+     */
+    static adsorb(points: Point[], tolerance?: number, mode?: "average" | "first"): Point<Record<string, any>>[];
+    private static _baseNormalLine;
+    private static get baseNormalLine();
+    /** 点的线段方向约束
+     * @description 点只能在线段方向和法线方向的轴上
+     * @param point
+     * @param startPoint
+     * @param baseLine
+     * @param baseNormalLine
+     * @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

@@ -0,0 +1,164 @@
+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 = {
+    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>[]);
+    set(points?: Point<T>[]): void;
+    /**
+     * 获取多边形几何中心（面积质心）
+     * @description 使用多边形面积质心公式计算
+     * @description 适用于闭合简单多边形（顺时针或逆时针均可）
+     * @description 如果面积为 0，则退化为顶点平均中心
+     * @param out 输出对象，用于减少 GC
+     * @returns
+     */
+    getCenter(out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /** 计算二维包围盒
+     * @returns
+     */
+    getBox2(): Box2;
+    /** 获取最小包围矩形
+     * @param polygon
+     * @returns
+     */
+    getMinimumBoundingRectangle(polygon?: Polygon<any>): Polygon<any> | null;
+    /** 计算面积
+     * @param signed 是否保留方向
+     * @returns
+     */
+    area(signed?: boolean): number;
+    /** 有向面积
+     * @returns
+     */
+    signedArea(): number;
+    closedLoop(): boolean;
+    /** 闭合路径向路径外膨胀width
+     * @param width
+     */
+    closedExpansion(width: number, scale?: number): this | null;
+    /** 通过线段分割
+     * @param line
+     * @returns
+     */
+    clipByLine(line: LineSegment): Polygon<Record<string, any>>[];
+    /**
+     * 获取点相对于多边形的位置
+     * @param point
+     * @returns 'on' 边上，'inside' 内部，'outside' 外部
+     */
+    getPointSideOfLine(point: Point): "on" | "outside" | "inside";
+    /** 获取最长路径长度
+     * @returns
+     */
+    getMaxLengthInfo(): {
+        start: Point<any>;
+        end: Point<any>;
+        length: number;
+    };
+    /** 获取最小路径长度
+     * @returns
+     */
+    getMinLengthInfo(): {
+        start: Point<any>;
+        end: Point<any>;
+        length: number;
+    };
+    /** 点在多边形上：包括路径和内部
+     * @param point
+     * @returns
+     */
+    pointIn(point: Point): boolean;
+    /** 点在多边形内部，不包括路径上
+     * @param point
+     * @returns
+     */
+    pointWithin(point: Point): boolean;
+    /** 缩放
+     * @param scale
+     */
+    scale(scale?: number): this;
+    round(): this;
+    /**
+     * @param polygon
+     */
+    union(polygons: Polygon | Polygon[], scale?: number): boolean;
+    /** 差集
+     * @param polygon
+     */
+    difference(polygons: Polygon | Polygon[], scale?: number): boolean;
+    /** 包围盒检测
+     * @param box
+     * @returns
+     */
+    intersectsBox(box: Box2): boolean;
+    /** 转为线段
+     * @param closed
+     * @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>>;
+    /** 通过线段创建， 默认路径只有一条
+     * @param lines
+     * @returns
+     */
+    static fromByLines(lines: LineSegment[]): Polygon<Record<string, any>>;
+    /** 通过线段创建， 默认路径只有一条
+     * @param lines
+     * @returns
+     */
+    static fromByLines2(lines: LineSegment[], skipGroup?: boolean): Polygon<any>;
+    /** 通过线段创建，返回所有路径
+     * @description 处理线路拓扑，使线路有序链接，形成长路径
+     * @param lines
+     */
+    static multipleFromByLines(lines: LineSegment[]): Polygon<any>[];
+    /** 通过线段路径创建
+     * @description 通过线段路径创建, 请确保线段路径正确无误
+     * @param lines
+     * @param polygon
+     * @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>>[];
+    /** 路径偏移
+     * @param poly
+     * @param option
+     * @returns
+     */
+    static offset(poly: Polygon, option: {
+        offsetHalfWidth: number;
+        joinType?: JoinType;
+        endType?: EndType;
+        type?: string;
+        scale?: number;
+    }): Polygon<Record<string, any>>;
+}
+type JoinType = "jtMiter" | "jtSquare" | "jtRound";
+type EndType = "etOpenSquare" | "etOpenButt" | "etOpenRound";
+export {};