rm-build-dxf 0.1.186

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

@@ -0,0 +1,258 @@
+import { Point, PointType } from './Point';
+import { Rectangle } from './Rectangle';
+/**
+ * 非轴对称线段
+ */
+export declare class LineSegment<T = Record<string, any>> {
+    static get LINE_SYMBOL(): symbol;
+    points: Point[];
+    userData: T;
+    currentData: Record<string | number | symbol, any>;
+    uuid: string;
+    private _length;
+    /**
+     * 线段长度
+     * @returns
+     */
+    get length(): number;
+    get start(): Point<Record<string, any>>;
+    get end(): Point<Record<string, any>>;
+    _center: Point | null;
+    get center(): Point<Record<string, any>>;
+    _direction: null | Point;
+    constructor(p1?: PointType, p2?: PointType);
+    private _startVersion;
+    private _endVersion;
+    private _update;
+    set(p1: PointType, p2: PointType): this;
+    setLength(len: number): this;
+    /** 获取另一个点
+     * @param point
+     * @returns
+     */
+    getAnotherPoint(point: Point): Point<Record<string, any>>;
+    /**
+     * 沿线段方向偏移起点。
+     *
+     * width > 0 时，起点向终点方向移动；
+     * width < 0 时，起点向终点反方向移动。
+     */
+    offsetStart(width: number): this;
+    /**
+     * 沿线段方向偏移起点。
+     *
+     * width > 0 时，结束点向终点方向移动；
+     * width < 0 时，结束点向终点反方向移动。
+     */
+    offsetEnd(width: number): this;
+    /**
+     * 是否有相同端点
+     * @param line
+     * @returns
+     */
+    isSameEndpoint(line: LineSegment, eps?: number): boolean;
+    /**
+     * 相同端点是否为开始
+     * @param line
+     * @returns
+     */
+    isSameEndpointAsStart(line: LineSegment, eps?: number): boolean;
+    /**
+     * 相同端点是否为结束
+     * @param line
+     * @returns
+     */
+    isSameEndpointAsEnd(line: LineSegment, eps?: number): boolean;
+    /**
+     * 获取共线点
+     * @param line
+     * @returns
+     */
+    getSameEndpoint(line: LineSegment, eps?: number): Point<Record<string, any>>[] | null;
+    /**
+     * 判断一个点是否在当前线段上（包含端点）
+     * @param point 要判断的点
+     * @returns 如果点在当前线段上则返回 true，否则返回 false
+     */
+    isPointOnSegment(point: Point): boolean;
+    /** 膨胀
+     * @description 向线段的两个端点分别膨胀 width
+     * @param width
+     */
+    extendAlongDirection(width: number, direction?: "start" | "end" | "all"): this;
+    /** 向指定方向移动
+     * @param dist
+     * @param direction
+     * @returns
+     */
+    translate(dist: number, direction?: Point<Record<string, any>>): this;
+    /** 旋转
+     * @param angle 弧度
+     */
+    rotate(angle: number, center?: Point<Record<string, any>>): this;
+    /** 镜像线段
+     */
+    mirror(): void;
+    /** 交换两个端点
+     */
+    swap(): void;
+    /** 交换两个端点值
+     */
+    swapValue(): void;
+    /** 获取点在线段上的叉积
+     * @param point
+     * @returns
+     */
+    cross(point: Point): number;
+    /**
+     * 获取方向
+     * @returns
+     */
+    direction(out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /**
+     * 获取发向量-左法线
+     */
+    normal(): Point<Record<string, any>>;
+    /**
+     * @param line
+     * @param t
+     * @returns
+     */
+    pointAt(t: number, out?: Point<Record<string, any>>): Point<Record<string, any>>;
+    /** 膨胀为矩形
+     * @param width
+     * @param cap butt: 不延长, square: 延长
+     * @returns
+     */
+    toRectangle(width?: number, cap?: "butt" | "square", out?: Rectangle): Rectangle;
+    /** 获取点在当前线段的左边还是右边，或者线段上
+     * @param point
+     */
+    getPointSideOfLine(point: Point): "on" | "left" | "right";
+    /** 获取向右的方向
+     * @returns
+     */
+    getRightDirection(): Point<Record<string, any>>;
+    /** 获取向左的方向
+     * @returns
+     */
+    getLeftDirection(): Point<Record<string, any>>;
+    /** 获取点距离线段的长度（直线距离）
+     * @param point
+     */
+    distanceToPoint(point: Point): number;
+    /** 获取点距离线段的长度平方（直线距离）
+     * @param point
+     */
+    distanceSquaredToPoint(point: Point): number;
+    /** line 获取两条线段之间的最短距离
+     * @param
+     */
+    distanceToSegment(line: LineSegment): number;
+    /**
+     * 两条线段或角度是否平行，忽略方向
+     * @param line
+     */
+    isParallelTo(line: LineSegment, eps?: number): boolean;
+    /** 两条线段或角度是否 垂直， 忽略方向
+     * @param line
+     * @param errAngle
+     * @returns
+     */
+    isPerpendicularTo(line: LineSegment, eps?: number): boolean;
+    /**
+     * @param line
+     * @param eps
+     * @returns
+     */
+    isCollinearOverlap(line: LineSegment, eps?: number): boolean;
+    /**
+     * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
+     * @param line 要投影的线段
+     * @returns 投影并裁剪后的线段
+     */
+    projectLineSegment(line: LineSegment, out?: LineSegment<Record<string, any>>): LineSegment;
+    /**
+     * 计算一条线段在另一条直线上的投影
+     * @param p1 要投影的点
+     * @param clip 是否裁剪超出目标线段的部分，默认裁剪
+     * @returns 投影并裁剪后的线段
+     */
+    projectPoint(p1: Point, clip?: boolean): Point | null;
+    /** 获取点的投影值
+     */
+    projectPointValue(point: {
+        x: number;
+        y: number;
+    }, eps?: number): number;
+    /** 获取两条线段夹角
+     * @deprecated 已废弃, 请使用 angle
+     * @param line
+     */
+    includedAngle(line: LineSegment): number;
+    /** 获取两条线段夹角
+     * @param line
+     */
+    angle(line: LineSegment, opt?: {
+        unit?: "radian" | "degree" | "cos";
+        range?: "180" | "360";
+    }): number;
+    /**
+     * 判断两条线段，是否在同一直线上：
+     *  - 返回 -1：不在同一直线（不共线）
+     *  - 返回 0：共线但没有重合部分
+     *  - 返回 1：共线且有重合（端点或区间重叠）
+     */
+    sameLine(line: LineSegment): number;
+    private crossProduct;
+    private isPointInSegmentBounds;
+    /**
+     * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
+     * @param line
+     * @param endpoint 是否包含端点相交
+     * @returns
+     */
+    intersectLineSegment(line: LineSegment, endpoint?: boolean): boolean;
+    /**
+     * 判断一个点是否在线段上（含端点）
+     * @param pt 要判断的点
+     * @returns 如果点在当前线段上返回 true，否则返回 false
+     */
+    containsPoint(pt: Point): boolean;
+    /**
+     * 获取交点
+     * @param line
+     * @returns
+     */
+    getIntersection(line: LineSegment): Point | null;
+    /**
+     * 两条线段方向是否一致
+     * @param line
+     */
+    directionEqual(line: LineSegment, errAngle?: number): boolean;
+    /** 克隆
+     * @returns
+     */
+    clone(userData?: boolean, cloneUUid?: boolean): LineSegment<T>;
+    /** 复制
+     * @param line
+     */
+    copy(line: {
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    }): this;
+    /** 获取点属于的线段
+     * @param point
+     * @returns
+     */
+    static getSegmentFromPoint(point: Point): LineSegment | null;
+    static axisY(width: number, out?: LineSegment<Record<string, any>>): LineSegment<Record<string, any>>;
+    static axisX(width: number, out?: LineSegment<Record<string, any>>): LineSegment<Record<string, any>>;
+    static angleToYAxis(line: LineSegment): number;
+}

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

@@ -0,0 +1,86 @@
+import { Box2 } from './Box2';
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+export interface RaycastHit {
+    line: LineSegment;
+    point: Point;
+    distance: number;
+    t: number;
+}
+/**
+ * 线段空间哈希
+ */
+export declare class LineSegmentSpatialHash {
+    cellSize: number;
+    /** cell => lines */
+    private buckets;
+    /** line => cellKeys */
+    private lineCells;
+    /**
+     * @param cellSize 网格大小
+     */
+    constructor(cellSize?: number);
+    /**
+     * 插入线段
+     */
+    insert(line: LineSegment): this;
+    /**
+     * 批量插入
+     */
+    insertLines(lines: LineSegment[]): this;
+    /**
+     * 删除线段
+     */
+    remove(line: LineSegment): this;
+    /**
+     * 更新线段
+     */
+    update(line: LineSegment): this;
+    /**
+     * 清空
+     */
+    clear(): this;
+    private visited;
+    /**
+     * 查询点附近线段
+     * @param point
+     * @param radius
+     */
+    queryPoint(point: Point, radius?: number, out?: LineSegment[]): LineSegment<Record<string, any>>[];
+    /**
+     * 范围查询
+     */
+    queryBounds(bounds: Box2, out?: LineSegment[]): LineSegment<Record<string, any>>[];
+    /**
+     * 查询可能相交线段
+     * @description 仅 broad phase
+     */
+    queryPotentialLine(line: LineSegment, out?: LineSegment[]): LineSegment<Record<string, any>>[];
+    /**
+     * 查询相交线段
+     */
+    queryLine(line: LineSegment, out?: LineSegment[]): LineSegment<Record<string, any>>[];
+    private rectangleBounds;
+    /** 通过矩形查询 */
+    queryRectangle(rectangle: Rectangle, out?: LineSegment[]): LineSegment<Record<string, any>>[];
+    private rayIntersectSegment;
+    /**
+     * 射线检测
+     * @param origin 起点
+     * @param direction 方向（必须归一化）
+     * @param maxDistance 最大距离
+     */
+    raycast(origin: Point, direction: Point, maxDistance?: number, out?: RaycastHit): RaycastHit | null;
+    private tempKeys;
+    /**
+     * 获取线段覆盖的所有 cell key
+     */
+    private getLineCellKeys;
+    /**
+     * 坐标转 cell
+     */
+    private toCell;
+    private getKey;
+    static from(lines: LineSegment[], cellSize?: number): LineSegmentSpatialHash;
+}

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

@@ -0,0 +1,185 @@
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+export declare class LineSegmentUtils {
+    static clone(lines: LineSegment[]): LineSegment<Record<string, any>>[];
+    /**保留小数位数
+     * @param points
+     */
+    static precision(lines: LineSegment[], count: number): LineSegment<Record<string, any>>[];
+    /** 线段合法性检测 */
+    static legitimacy(line: LineSegment): boolean;
+    /**保留四位小数位数
+     * @param points
+     */
+    static precision4(lines: LineSegment[]): LineSegment<Record<string, any>>[];
+    /** 获取最长线段索引
+     * @param lines
+     */
+    static maxLengthLineIndex(lines: LineSegment[], excludeCallBack?: (line: LineSegment) => boolean): number;
+    /** 获取线段组的中心
+     * @param lines
+     */
+    static getLinesCenter(lines: LineSegment[]): Point<Record<string, any>>;
+    /** 合并分组和处理
+     * @param groups
+     * @returns
+     */
+    static GroupBuilder<T = any, K extends PropertyKey = string>(groups: Partial<Record<K, LineSegment<T>[]>>): {
+        handle(k: K, fn: (lines: LineSegment<T>[], groups: Partial<Record<K, LineSegment<T>[]>>) => LineSegment<T>[]): /*elided*/ any;
+        merge(): LineSegment<T>[];
+    };
+    /** 自定义分组
+     * @param lines
+     * @returns
+     */
+    static group<T = any, K extends PropertyKey = string>(lines: LineSegment<T>[], fn: (line: LineSegment<T>) => K): Partial<Record<K, LineSegment<T>[]>>;
+    /** 通过在同一路径上且平行的线段分组
+     * @param lines
+     */
+    static groupByPathAndParallel(lines: LineSegment[]): LineSegment<Record<string, any>>[][];
+    /** 通过线段中心点在目标线段的左边还是右边，或者线段上 分组
+     * @param lines
+     * @param line
+     * @returns
+     */
+    static groupByCenterPointSide(lines: LineSegment[], line: LineSegment): LineSegment<Record<string, any>>[][];
+    /** 通过连通路径，给线段分组
+     * @param lines
+     * @returns
+     */
+    static groupByPath(lines: LineSegment[]): LineSegment<Record<string, any>>[][];
+    /** 通过共享点分组
+     * @param lines
+     * @returns
+     */
+    static groupBySharedPoints(lines: LineSegment[]): LineSegment<Record<string, any>>[][];
+    /** 通过最大叶子路径，给线段分组，每条路径没有分叉
+     * @param lines
+     * @returns
+     */
+    static groupByLeafPath(lines: LineSegment[]): LineSegment<Record<string, any>>[][];
+    /** 通过与轴是否平行对线段进行分组
+     * @param lines
+     * @param axisLine
+     * @param errAngle
+     * @returns
+     */
+    static groupByParallelToAxis(lines: LineSegment[], axisLine: LineSegment, errAngle?: number): LineSegment<Record<string, any>>[][];
+    /** 通过平行轴和垂直轴投影重合分组
+     * @param verticalLines
+     * @param parallelAxis 平行轴
+     * @param verticalAxis 垂直轴
+     * @param esp 垂直投影值分组距离
+     * @param gap 平行轴投影区间间隙
+     */
+    static groupByProjectedOverlap(lines: LineSegment[], parallelAxis: LineSegment, verticalAxis: LineSegment, esp?: number, gap?: number, onGroup?: (group: LineSegment[], verticalProjValues: number[], verticalAxis: LineSegment, parallelProjValues: [number, number][], parallelAxis: LineSegment) => void): LineSegment<Record<string, any>>[][];
+    /** 合并线段到最长线段
+    * @param lines
+    * @returns
+    */
+    static mergeLinesByMaxlength(...lines: LineSegment[]): LineSegment<Record<string, any>>;
+    /** 传入的线段全部投影为一条线段
+     * @param lines 请确保共线
+     * @returns
+     */
+    static mergeCollinearSegments(lines: LineSegment[]): LineSegment<Record<string, any>>;
+    /** 合并满足平行的线段
+     * @param selectLines
+     */
+    static mergeParallelSegments(lines: LineSegment[], callBack?: (newLine: LineSegment, group: LineSegment[]) => void): {
+        lines: LineSegment<Record<string, any>>[];
+        newLines: LineSegment<Record<string, any>>[];
+        deleteLines: LineSegment<Record<string, any>>[];
+    };
+    /** 合并本属于同一条的线段，且不能被其他线段分割
+     * @param lines
+     * @param callBack
+     * @returns
+     */
+    static mergeCollinearSegmentsAll(lines: LineSegment[], callBack?: (newLine: LineSegment, group: LineSegment[]) => void, removeLines?: Set<LineSegment<Record<string, any>>>, newLines?: LineSegment[]): LineSegment<Record<string, any>>[];
+    /** 去重
+     * @param lines
+     * @returns
+     */
+    static deduplicate(lines: LineSegment[], precision?: number): LineSegment<Record<string, any>>[];
+    /** 通过点裁剪线段
+     * @param line
+     * @param points
+     * @returns
+     */
+    static clippingByPoints(line: LineSegment, points: Point[], callBack?: (newLine: LineSegment, line: LineSegment) => void): LineSegment<Record<string, any>>[];
+    /** 通过线段组裁剪线段
+     * @param target
+     * @param clippingLines
+     * @param callBack
+     * @returns
+     */
+    static clippingByLines(target: LineSegment, clippingLines: LineSegment[], callBack?: (newLine: LineSegment, line: LineSegment) => void): LineSegment<Record<string, any>>[] | undefined;
+    /** 通过线段裁剪线段
+     * @param target
+     * @param clippingLine
+     */
+    static clippingByLine(target: LineSegment, clippingLine: LineSegment, callBack?: (newLine: LineSegment, line: LineSegment) => void): LineSegment<Record<string, any>>[] | undefined;
+    /**
+     * @param line
+     * @param base
+     * @returns
+     */
+    static constrainLine(line: LineSegment, base: LineSegment): LineSegment<Record<string, any>>;
+    /** 通过线段提取所有点
+     * @param lines
+     * @returns
+     */
+    static flatPoints(lines: LineSegment[] | LineSegment): any[];
+    /** 裁剪
+     * @param lines
+     * @param opt
+     * @returns
+     */
+    static splitIntersections<T>(lines: LineSegment[], opt?: {
+        onSplit?: (target: LineSegment<T>, newLines: LineSegment<T>[]) => void;
+        obstacle?: LineSegment[];
+    }): LineSegment<T>[];
+    /** 对线段组统计，找到主导方向线
+     * @param lineSegments
+     * @returns
+     */
+    static findDominantDirectionLine(lineSegments: LineSegment[], bin?: number): LineSegment<Record<string, any>>;
+    /** 创建线段修改管理器
+     * @returns
+     */
+    static createModifyManager(): {
+        readonly setPoint: (line: LineSegment, point: Point, value: Point) => void;
+        readonly modify: () => void;
+        clear(): void;
+    };
+    /** 转为虚线
+     * @param line
+     * @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)[];
+    /** 在线段上根据数量采样
+     * @param line
+     * @returns
+     */
+    static sampleSegment(line: LineSegment, count: number): Point<Record<string, any>>[];
+    /** 在线段上根据数量采样
+     * @param line
+     * @returns
+     */
+    static sampleSegmentBydistance(line: LineSegment, dist?: number): Point<Record<string, any>>[];
+}

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

@@ -0,0 +1,38 @@
+export declare class MapEnhance<K, V> extends Map<K, V> {
+    get valueArray(): V[];
+    map<T = any>(callbackfn: (v: V, k: K) => T): T[];
+    filter(callbackfn: (v: V, k: K) => boolean): V[];
+    filterKey(callbackfn: (v: V, k: K) => boolean): K[];
+    reduce<T>(callbackfn: (pre: T, v: V, k: K) => T, result: T): T;
+    some(callbackfn: (v: V, k: K) => boolean): boolean;
+    every(callbackfn: (v: V, k: K) => boolean): boolean;
+    find(callbackfn: (v: V, k: K) => boolean): V | undefined;
+    findKey(callbackfn: (v: V, k: K) => boolean): K | undefined;
+    someKeys(keys: K[]): boolean;
+    everyKeys(keys: K[]): boolean;
+    group(callbackfn: (v: V, k: K) => string): ArrayMap<string, V>;
+    toObject(): Record<string, V>;
+    first(): V | undefined;
+    firstKey(): K | undefined;
+    last(): V | undefined;
+    sortBy<T>(callback: (v: V, k: K) => T): [K, V][];
+    pluck<U>(keyPath: string): U[];
+}
+export declare class ArrayMap<K, V> extends MapEnhance<K, V[]> {
+    maxLength: number;
+    append(k: K, ...arr: V[]): this;
+    setLength(key: K, len: number): void;
+    remove(k: K, ...arr: V[]): this;
+    getOrCreate(key: K): V[];
+}
+export declare class SetMap<K, V> extends MapEnhance<K, Set<V>> {
+    append(k: K, ...arr: V[]): this;
+    hasValue(key: K, value: V): boolean;
+}
+export declare class CounterMap<K> extends MapEnhance<K, number> {
+    set(key: K, step?: number): this;
+    increment(key: K, step?: number): this;
+    getByCount(count: number): K[];
+    getMaxKey(): K | undefined;
+    getminKey(): K | undefined;
+}

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

@@ -0,0 +1,15 @@
+import { LineSegment } from './LineSegment';
+import { MiniCircles } from './MiniCircles';
+export declare class MaxiCircles extends MiniCircles {
+    #private;
+    static get instance(): MaxiCircles;
+    mergeCircles(circles: LineSegment[][], internalEdges?: LineSegment[]): {
+        internalEdges: LineSegment<Record<string, any>>[];
+        circles: LineSegment<Record<string, any>>[][];
+    };
+    maxiCircles(lines: LineSegment[], findMinCirclesFilter?: (circles: LineSegment[][]) => LineSegment<Record<string, any>>[][]): {
+        newLines: LineSegment<Record<string, any>>[];
+        circles: LineSegment<Record<string, any>>[][];
+        internalEdges: LineSegment<Record<string, any>>[];
+    };
+}

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

@@ -0,0 +1,57 @@
+import { LineSegment } from './LineSegment';
+import { LineSegmentUndirectedGraph } from './UndirectedGraph';
+import { Point } from './Point';
+import { ArrayMap } from './Map';
+import { PointSpatialHash } from './PointSpatialHash';
+export declare enum Side {
+    ALL = 0,
+    OUT = 1,
+    IN = 2
+}
+export interface MiniCirclesOption {
+    side?: Side;
+    circleEdges?: LineSegment[];
+}
+export declare class MiniCircles {
+    debug: {
+        angle: boolean;
+        edges: boolean;
+    };
+    scope: number;
+    /** 通过并查集，查找为环的一部分边
+     * @description
+     * @param lines
+     */
+    findCycleEntryEdges(lineUG_: LineSegment[] | LineSegmentUndirectedGraph): LineSegment<Record<string, any>>[];
+    /** 环去重
+     * @param rings
+     */
+    deduplicate(rings: LineSegment[][]): LineSegment<Record<string, any>>[][];
+    /** 环的侧面测试，是内侧环，还是外侧环
+     * @param circles
+     * @param side
+     * @returns
+     */
+    sideTest(circles: LineSegment[][], side?: Side): LineSegment<Record<string, any>>[][];
+    /** 同侧路径查找
+     * @param opt
+     * @returns
+     */
+    findSameSidePath(opt: {
+        A: Point;
+        B: Point;
+        exitPoint?: Point;
+        grid: PointSpatialHash<LineSegment> | LineSegment[];
+        path?: Set<LineSegment>;
+    }): LineSegment<Record<string, any>>[] | undefined;
+    /** 通过方向点查找环
+     * @description 通过 findCircleOneEdge 查找 到ringEdges，然后在一条条的找，类似迷宫算法的左右手原则
+     * @param lines
+     * @param ringEdges
+     */
+    miniCircle(lines: LineSegment[], option?: MiniCirclesOption): {
+        circles: LineSegment<Record<string, any>>[][];
+        setMap: ArrayMap<LineSegment<Record<string, any>>, Set<LineSegment<Record<string, any>>>>;
+        circleEdges: LineSegment<Record<string, any>>[];
+    };
+}

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

@@ -0,0 +1,30 @@
+import { OBB as OBB_ } from 'three/addons/math/OBB.js';
+import * as THREE from 'three';
+export declare class OBB extends OBB_ {
+    getBoxMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    getBoxEdge(color?: number): THREE.LineSegments<THREE.EdgesGeometry<THREE.BoxGeometry>, THREE.LineBasicMaterial, THREE.Object3DEventMap>;
+    toJson(): {
+        size: THREE.Vector3Tuple;
+        center: THREE.Vector3Tuple;
+        quaternion: THREE.QuaternionTuple;
+    };
+    /**
+     * @param box
+     * @param position
+     * @param rotation
+     * @param out
+     * @returns
+     */
+    static from(box: THREE.Vector3, position: THREE.Vector3, rotation: THREE.Euler | THREE.Quaternion, out?: OBB): OBB;
+    /** 通过2d路径创建
+     * @param path
+     * @param origin
+     * @param height
+     * @param out
+     * @returns
+     */
+    static fromByPath2D(path: {
+        x: number;
+        y: number;
+    }[], origin: THREE.Vector3, height: number, out?: OBB): OBB;
+}