rm-build-dxf 0.1.186

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

@@ -0,0 +1,9 @@
+import { LineSegment } from './LineSegment';
+import { Polygon } from './Polygon';
+export declare class PolygonUtils {
+    /** 拆分为凸包
+     * @returns
+     */
+    static splitConvexHull(ploy: Polygon): Polygon<Record<string, any>>[] | null;
+    static splitByLine(lines: LineSegment[], clipLine: LineSegment): LineSegment[][];
+}

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

@@ -0,0 +1,89 @@
+import { Box2 } from './Box2';
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+export interface QuadtreeNode<T = any> {
+    line: LineSegment;
+    userData: T;
+    parent?: Quadtree;
+}
+export declare class Quadtree<T = any> {
+    bounds: Box2;
+    capacity: number;
+    maxDepth: number;
+    depth: number;
+    isLeaf: boolean;
+    children: Quadtree[] | null;
+    nodes: QuadtreeNode<T>[];
+    color: number[];
+    id: symbol;
+    constructor(bounds: Box2, capacity?: number, maxDepth?: number, depth?: number, id?: symbol);
+    /**
+     * 插入线段节点
+     * @param node 线段节点
+     */
+    insert(node: QuadtreeNode<T> | LineSegment, userData?: any): void;
+    /** 移除
+     * @param node
+     */
+    remove(node: QuadtreeNode<T> | LineSegment): void;
+    /** 移除
+     * @param node
+     */
+    update(node: QuadtreeNode<T> | LineSegment): void;
+    clear(): void;
+    /**
+     * 获取线段所属的象限
+     * @param line 线段
+     * @returns 象限索引（0:西北,1:东北,2:西南,3:东南）或-1（跨多个象限）
+     */
+    private getQuadrant;
+    /**
+     * 细分当前节点为四个子节点
+     */
+    private subdivide;
+    /**
+     * 查询与包围盒相交的线段节点
+     * @param box2 包围盒
+     * @returns 相交的节点数组
+     */
+    queryBox(box2: Box2): QuadtreeNode<T>[];
+    /**
+     * 查询与圆形区域相交的线段节点
+     * @param pos 圆心
+     * @param radius 半径
+     * @returns 相交的节点数组
+     */
+    queryCircle(pos: Point, radius: number): QuadtreeNode<T>[];
+    /**
+     * 查询与点相交的线段节点
+     * @param point 圆心
+     * @returns 相交的节点数组
+     */
+    queryPoint(point: Point): QuadtreeNode<T>[];
+    /**
+     * 查询与矩形相交的线段节点
+     * @param rectangle 矩形
+     * @returns 相交的节点数组
+     */
+    queryRect(rectangle: Rectangle): QuadtreeNode<T>[];
+    /**
+     * 查询与线段相交的线段节点
+     * @param lineSegment 线段
+     * @returns 相交的节点数组
+     */
+    queryLineSegment(lineSegment: LineSegment, endpoint?: boolean): QuadtreeNode<T>[];
+    raycast(origin: Point, direct: Point, near?: number, far?: number): {
+        targetLine: LineSegment;
+        intersectPoint: Point;
+        distance: number;
+    }[];
+    /**
+     * 包围盒转换为数组
+     * @param array
+     * @param colors
+     * @returns
+     */
+    boundsToArray(array?: number[], colors?: number[], recursion?: boolean): number[];
+    static from(lines: LineSegment[], userDataFun?: (line: LineSegment, index: number) => any): Quadtree<any>;
+}

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

@@ -0,0 +1,62 @@
+import { Box2 } from './Box2';
+import { LineSegment } from './LineSegment';
+import { Point, PointType } from './Point';
+/**
+ * 非轴对称矩形
+ */
+export declare class Rectangle {
+    points: Point[];
+    get p0(): Point<Record<string, any>>;
+    get p1(): Point<Record<string, any>>;
+    get p2(): Point<Record<string, any>>;
+    get p3(): Point<Record<string, any>>;
+    get path(): number[];
+    constructor(points?: PointType[]);
+    path2D(callback?: (point1: Point, point2: Point) => void): number[];
+    toLines(): LineSegment<Record<string, any>>[];
+    createGeometry(): number[];
+    /**
+     * 判断线段是否与矩形相交
+     * @param line 线段
+     * @returns 是否与矩形相交
+     */
+    intersectLineSegment(line: LineSegment): boolean;
+    /**
+     * 判断线段是否完全位于矩形内部
+     * @param line 线段
+     * @returns 是否完全在矩形内部
+     */
+    containsLineSegment(line: LineSegment): boolean;
+    /**
+     * 获取所有点在轴上的投影，并且返回区间
+     * @param rect
+     * @param axis
+     * @returns
+     */
+    private projectRectangle;
+    private isProjectionOverlap;
+    /**
+     * 判断矩形是否与矩形相交
+     * @description 使用分离轴定理
+     * @param rectangle 矩形
+     * @returns 是否与矩形相交
+     */
+    intersectRectangle(rectangle: Rectangle): boolean;
+    /**
+     * 判断点是否完全位于矩形内部
+     * @param point
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     *
+     * @returns
+     */
+    toBox(out?: Box2): Box2;
+    /**
+     *
+     * @param line
+     * @param width
+     * @returns
+     */
+    static fromByLineSegment(line: LineSegment, width?: number, horizontal?: boolean, hScale?: number): Rectangle;
+}

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

@@ -0,0 +1,124 @@
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+type EndType = "none" | "intersect" | "isolated";
+export declare class UndirectedGraph {
+    protected adjacencyList: Map<number, Set<number>>;
+    get size(): number;
+    constructor();
+    addNode(node: number): void;
+    addEdge(u: number, v: number): void;
+    removeEdge(u: number, v: number): void;
+    removeNode(node: number): void;
+    getNeighbors(node: number): Set<number> | undefined;
+    printGraph(): void;
+    /** 获取能组成的所有路径
+     * @returns
+     */
+    getPaths(): number[][];
+    /** 循环
+     * @param callbackFun
+     */
+    forEach(callbackFun: (node: number, neighbors: Set<number>) => void): void;
+    /** 遍历边
+     * @param callbackFun
+     */
+    forEachEdge(callbackFun: (u: number, v: number) => void): void;
+}
+/**
+ * 线段无向图
+ */
+export declare class LineSegmentUndirectedGraph extends UndirectedGraph {
+    private readonly lineMap;
+    private readonly pointToIndex;
+    private readonly indexToPoint;
+    private nextIndex;
+    constructor(lines?: readonly LineSegment[]);
+    private buildFromLines;
+    /**
+     * 获取两点之间的线段（无向）
+     */
+    getLine(a: number, b: number): LineSegment | undefined;
+    /** 获取所有线段
+     * @returns
+     */
+    getLineAll(): LineSegment<Record<string, any>>[];
+    /**
+     * 获取或创建点的索引
+     */
+    private getOrCreateIndex;
+    /**
+     * 安全获取点索引（已存在才返回）
+     */
+    getIndex(point: Point): number | undefined;
+    /**
+     * @param index
+     * @returns
+     */
+    getPoint(index: number): Point | undefined;
+    /**
+     * 获取所有点（只读数组，懒计算或缓存可进一步优化）
+     */
+    get points(): readonly Point[];
+    /**
+     * 获取所有线段
+     */
+    get lines(): readonly LineSegment[];
+    /**
+     * 批量添加线段（比逐条 addLine 更快）
+     */
+    addLines(lines: readonly LineSegment[]): this;
+    /** 批量移除线段边
+     * @param lines
+     */
+    removeLines(lines: readonly LineSegment[]): void;
+    /** 路径转线段组
+     * @param path
+     */
+    pathToLines(path: number[]): LineSegment<Record<string, any>>[];
+    /**
+     * 清空图
+     */
+    clear(): void;
+    /** 断点合并
+     * @description 合并断开的直线，断点
+     * @param lines
+     * @param callBack
+     * @returns
+     */
+    breakpointMerging(callBack?: (newLine: LineSegment, group: LineSegment[]) => void, removeLines?: Set<LineSegment<Record<string, any>>>, newLines?: LineSegment[]): void;
+    /**
+     * @param fun
+     */
+    forEachPathLine(
+    /**
+     * 遍历每条线段时的回调函数
+     * @param start     当前线段的起点
+     * @param end       当前线段的终点（start 和 end 只是线段的两端，顺序可能和原始线段相反）
+     * @param line      当前正在处理的线段对象
+     * @param index     当前线段在遍历过程中的序号（按遍历规则产生，并非原数组索引）
+     * @param endType 当前线段终点的性质：
+     *                  - noEnd         → 这个终点不是整个路径的结尾点
+     *                  - "intersect"   → 是路径的结尾点，但与其他线段有相交
+     *                  - "noIntersect" → 是路径的结尾点，且与其他线段无相交
+     * @param indexList 所有与当前起点相交、并且已经被遍历过的线段的遍历序号数组
+     */
+    fun: (start: Point, end: Point, line: LineSegment, index: number, endType: EndType, indexList: number[]) => void): void;
+    /** 断点合并
+     * @param lines
+     * @param callBack
+     * @param removeLines
+     * @param newLines
+     * @returns
+     */
+    static breakpointMerging(lines: LineSegment[], callBack?: (newLine: LineSegment, group: LineSegment[]) => void, removeLines?: Set<LineSegment<Record<string, any>>>, newLines?: LineSegment[]): LineSegment<Record<string, any>>[];
+    /** 线段图旋转
+     * @param lines
+     * @param angle 弧度
+     */
+    static rotate(lines: LineSegment[], angle: number, callbackFun?: (line: LineSegment, center: Point, angle: number) => void): LineSegment<Record<string, any>>[];
+    toJson(): {
+        points: readonly Point<Record<string, any>>[];
+        edges: [number, number][];
+    };
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { ArrayMap } from './Map';
+export declare class UnionFindSet {
+    private parent;
+    private rank;
+    constructor(size: number);
+    find(x: number): number;
+    union(x: number, y: number): void;
+    /** 获取所有集合
+     * @returns
+     */
+    getAllSets(): ArrayMap<number, number>;
+}

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

@@ -0,0 +1,2 @@
+import { LineSegment } from './LineSegment';
+export declare function ccw(lines: LineSegment[]): LineSegment<Record<string, any>>[];

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

@@ -0,0 +1,14 @@
+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;
+}
+/** 懒加载
+ * @param fn
+ * @returns
+ */
+export declare function lazy<T>(fn: () => T): Lazy<T>;
+export {};

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

@@ -0,0 +1,3 @@
+export declare function precision(value: number, count: number): number;
+export declare function precision4(value: number): number;
+export declare function precision4Nullable(value?: number | null): number | undefined;

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

@@ -0,0 +1,6 @@
+import { LineSegment } from './LineSegment';
+/** 路径阶梯合并
+ * @param lineSegments
+ * @returns
+ */
+export declare function stepElimination(lineSegments: LineSegment[], findMinWidth?: number, onMerge?: (mainLine: LineSegment, sortLine: LineSegment, secondaryLine: LineSegment, oldLine: LineSegment) => void): LineSegment<Record<string, any>>[];

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

@@ -0,0 +1 @@
+export declare function uuid(): string;

package/src/utils/command/CommandFlow.d.ts

@@ -0,0 +1,45 @@
+import { EventDispatcher } from '../ecs';
+export type NextFn<T = any> = (data?: T) => void;
+export type CommandFlowFn<IN = any, OUT = any> = (next: NextFn<OUT>, data?: IN) => void;
+export declare class CommandFlow extends EventDispatcher<{
+    started: {};
+    executing: {
+        index: number;
+    };
+    executionCompleted: {
+        index: number;
+        data?: any;
+    };
+    executionInterrupt: {
+        index: number;
+    };
+    completed: {
+        data?: any;
+    };
+    finally: {};
+}> {
+    list: CommandFlowFn[];
+    dataList: any[];
+    rollbacklist: ((data?: any) => void)[];
+    revokeRollbacklist: ((data?: any) => void)[];
+    writeOperationRecord: boolean;
+    loop: boolean;
+    currentIndex: number;
+    setLoop(loop: boolean): this;
+    /**
+     *
+     * @param operation
+     * @returns
+     */
+    add<T = Record<string, any>>(operation: CommandFlowFn, data?: T): this;
+    /** 添加回滚回调列表
+     * @param callBack
+     */
+    addRollback(callBack: (data?: any) => void): this;
+    /** 添加撤回回滚回调列表
+     * @param callBack
+     * @returns
+     */
+    addRevokeRollback(callBack: (data?: any) => void): this;
+    getData<T = Record<string, any>>(index: number): T;
+}

package/src/utils/command/CommandSystem.d.ts

@@ -0,0 +1,96 @@
+import { EventDispatcher } from '../ecs';
+import { CommandFlow } from './CommandFlow';
+export type Operation = {
+    name: string;
+    data: any;
+};
+type CommandFlowMap<T extends CommandFlow = CommandFlow> = Map<string, T>;
+export declare class CommandManager extends EventDispatcher<{
+    startedBefore: {
+        name: string;
+        currentName: string | null;
+    };
+    started: {
+        name: string;
+    };
+    cancel: {
+        name: string;
+    };
+    executing: {
+        name: string;
+        index: number;
+    };
+    executionCompleted: {
+        name: string;
+        index: number;
+        data?: any;
+    };
+    executionInterrupt: {
+        name: string;
+        index: number;
+    };
+    completed: {
+        name: string;
+        data?: any;
+    };
+    finally: {
+        name: string;
+    };
+    rollback: {
+        name: string;
+    };
+    revokeRollback: {
+        name: string;
+    };
+}> {
+    commandFlowMap: CommandFlowMap;
+    lock: boolean;
+    private abortController;
+    private resolve;
+    currentName: string | null;
+    private _disabled;
+    set disabled(disabled: boolean);
+    get disabled(): boolean;
+    /**
+     * 操作记录
+     */
+    operationList: Operation[];
+    rollbackList: Operation[];
+    constructor();
+    /** 写入记录
+     * @param name
+     * @param data
+     */
+    addOperation(name: string, data: Record<string, any>): void;
+    /** 添加命令流
+     * @param name
+     * @param custom 自定义命令流类
+     * @returns
+     */
+    addCommandFlow<T extends CommandFlow = CommandFlow>(name: string, custom?: () => T): CommandFlow;
+    /** 获取命令流
+     * @param name
+     * @returns
+     */
+    getCommandFlow<T extends CommandFlow = CommandFlow>(name: string): T | undefined;
+    private executionPromise;
+    private executionResolve;
+    /** 执行控制流
+     * @param name
+     * @returns
+     */
+    start(name: string, data?: any, step?: number): Promise<any>;
+    /** 取消当前命令
+     */
+    cancel(): void;
+    /**
+     * 回滚
+     */
+    rollback(): boolean;
+    /**
+     * 撤销回滚
+     */
+    revokeRollback(): boolean;
+    destroy(): void;
+}
+export {};

package/src/utils/command/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CommandFlow';
+export * from './CommandSystem';

package/src/utils/decorators/measure-time.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 老版 TypeScript 装饰器（experimentalDecorators）
+ * 打印函数执行耗时
+ */
+export declare function MeasureTime(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/src/utils/ecs/Component.d.ts

@@ -0,0 +1,18 @@
+import { ComponentContainer } from './Container';
+import { EventDispatcher } from '../EventDispatcher';
+export declare class Component<TEventMap extends {} = {}> extends EventDispatcher<{
+    addFromParent: {
+        parent: ComponentContainer;
+    };
+    removeFromParent: {
+        parent: ComponentContainer;
+    };
+    update: {};
+} & TEventMap> {
+    parent?: ComponentContainer;
+    destroyed: boolean;
+    constructor(...arg: any[]);
+    onAddFromParent(parent: ComponentContainer): void;
+    onRemoveFromParent(parent: ComponentContainer): void;
+    destroy(): void;
+}

package/src/utils/ecs/Container.d.ts

@@ -0,0 +1,47 @@
+import { Component } from './Component';
+import { EventDispatcher } from '../EventDispatcher';
+interface EventTypeMap {
+    addComponent: {
+        component: Component;
+    };
+    removeComponent: {
+        component: Component;
+    };
+}
+export declare class ComponentContainer<TEventMap extends {} = {}> extends EventDispatcher<TEventMap & EventTypeMap> {
+    static readonly EventType: {
+        ADD_COMPONENT: string;
+    };
+    components: Component[];
+    /**
+     * 添加组件
+     * @param component
+     */
+    addComponent(component: Component): this;
+    /**
+     * 移除组件
+     * @param component
+     */
+    removeComponent(component: Component): void;
+    /**
+     * 查找符合条件的第一个组件
+     * @param callBack
+     */
+    findComponent(predicate: (component: Component, index: number) => boolean): Component<{}> | undefined;
+    /**
+     * 查找所有符合条件的组件
+     * @param callBack
+     */
+    findComponents(predicate: (component: Component, index: number) => boolean): Component<{}>[];
+    /**
+     *
+     * @param type
+     */
+    findComponentByType<T extends typeof Component>(type: T): InstanceType<T> | null;
+    /**
+     *
+     * @param type
+     */
+    findComponentByName(name: string): Component<{}> | null;
+}
+export {};

package/src/utils/ecs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Component';
+export * from './Container';
+export * from '../EventDispatcher';
+export * from '../algorithms/uuid';

package/src/utils/geometry-manager/GeometryManager.d.ts

@@ -0,0 +1,2 @@
+export declare class GeometryManager {
+}

package/src/utils/index.d.ts

@@ -0,0 +1,25 @@
+export * from './algorithms/Box2';
+export * from './algorithms/LineIndexGenerator';
+export * from './algorithms/LineSegment';
+export * from './algorithms/LineSegmentUtils';
+export * from './three-object-3d/Lines';
+export * from './algorithms/Map';
+export * from './algorithms/Point';
+export * from './algorithms/PointUtils';
+export * from './algorithms/Polygon';
+export * from './algorithms/Quadtree';
+export * from './algorithms/Rectangle';
+export * from './algorithms/UndirectedGraph';
+export * from './algorithms/UnionFindSet';
+export * from './tools/clone-user-data';
+export * from './tools/selectLocal-file';
+export * from './algorithms/PointSpatialHash';
+export * from './command';
+export * from './ecs';
+export * from './tools/Gltf';
+export * from './algorithms/MaxiCircles';
+export * from './algorithms/MiniCircles';
+export * from './algorithms/OBB';
+export * from './algorithms/PCSparseOctree';
+export * from './algorithms/CheckPointCloudContinuity';
+export * from './tools/SnapLine';

package/src/utils/modelScenario/bayWindow.d.ts

@@ -0,0 +1,35 @@
+import { Point } from '../algorithms/Point';
+import * as THREE from 'three';
+export declare const DEFAULT_WALL_HALF_WIDTH: number;
+export default class BayWindow {
+    bayWindowExpansion: any;
+    dottedLinePoints: any;
+    singleLine: any;
+    bayWindowArea: any;
+    bayWindowGroup: THREE.Group;
+    private static _instance?;
+    static get Instance(): BayWindow | undefined;
+    constructor();
+    overhangTreatment(data: any, singleLine: any): void;
+    dashedLineTreatment(data: any, centroidPoint: any, item: any): void;
+    bayWindowExecutionOffset(data: any, index: number, wallHeight: number, item?: any, statuc?: boolean): {
+        mesh1: THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
+        mesh2: THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
+        mesh3: THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
+        points3: THREE.Vector3[];
+    } | undefined;
+    createDashedLineCeilingWall(startingPoint: any, index: number | string, item: any, num: number): THREE.Mesh<THREE.ExtrudeGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap> | null;
+    angleToXAxisDegrees(x1: number, y1: number, x2: number, y2: number, wide: number, cd: boolean): number;
+    windowOpeningOffset(x: number, y: number, point: THREE.Vector3 | Point, wallHeight: number): THREE.Vector3[];
+    xinLine(x: number, y: number, point: THREE.Vector3 | Point, wallHeight: number): THREE.Vector3[];
+    xinLine1(x: number, y: number, pointa: THREE.Vector3, pointb: THREE.Vector3, num: number, wallHeight?: number): THREE.Vector3[];
+    getPolygonCentroid(points: any): {
+        x: number;
+        y: number;
+        z: any;
+    };
+    pointSideOfLine(p1: THREE.Vector3, p2: THREE.Vector3, p: any): 0 | 1 | -1;
+    windowTreatment(dblWin: any, mesh: any, wallHeight: number, startingPoint: any, data: any): import('three-bvh-csg').Brush;
+    installWindows(data: any, index: string, startingPoint: any): void;
+    createBayWindowLayout(listS: any, objData: any): void;
+}