rm-build-dxf 0.1.186

package/src/dxf-system/plugins/renderer/index.d.ts

@@ -0,0 +1,13 @@
+import { DxfSystem } from '../../DxfSystem';
+import * as components from "./components";
+import * as THREE from "three";
+type Option = {
+    modelData?: boolean;
+    orbitControls?: boolean;
+    camera?: THREE.Camera;
+};
+declare function RendererPlugin_(dxfSystem: DxfSystem, option?: Option): void;
+declare const RenderPlugin: typeof RendererPlugin_ & {
+    create(option?: Option): (dxfSystem: DxfSystem) => void;
+};
+export { components, RenderPlugin };

package/src/dxf-system/type.d.ts

@@ -0,0 +1,218 @@
+import { Quadtree, QuadtreeNode } from '../utils/algorithms/Quadtree';
+import { Point } from '../utils/algorithms/Point';
+import { LineSegment } from '../utils/algorithms/LineSegment';
+import { Polygon } from '../utils/algorithms/Polygon';
+export type Unit = "Unitless" | "Inches" | "Feet" | "Miles" | "Millimeters" | "Centimeters" | "Meters" | "Kilometers" | "Microinches" | "Mils" | "Yards" | "Angstroms" | "Nanometers" | "Microns" | "Decimeters" | "Decameters" | "Hectometers" | "Gigameters" | "Astronomical units" | "Light years" | "Parsecs";
+export interface GroupItem {
+    id: string;
+    type?: string;
+}
+export type HoleStorageType = 'drawWindow' | 'passageEntrance';
+export type HoleType = "door" | "window" | "beam" | "passageEntrance";
+export interface HoleData {
+    p: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    width: number;
+    full: boolean;
+    rooftopPz?: number;
+    uuid?: string;
+    height?: number;
+    groundClearance?: number;
+    type?: HoleType;
+    id?: number;
+    nearId?: number;
+    doorId?: number;
+    nearDoorId?: number;
+    pair?: string | number;
+}
+export type EntityType = "beams" | "door" | "pillar";
+export type Shape = "line" | "arc" | "polygon";
+export type WallLineGlobalOption = {
+    uuid?: string;
+    groupId?: string;
+    groupType?: string;
+    groups?: GroupItem[];
+    rooftopPz?: number;
+    height?: number;
+    wallWidth?: number;
+    sillHeight?: number;
+    length?: number;
+    type?: EntityType;
+    shape?: Shape;
+    /** 是不是窗户线 */
+    isWindow?: boolean;
+    /** 是不是飘窗虚线 */
+    isBayWindow?: boolean;
+    /** 是不是飘窗墙壁 */
+    isWindowWall?: boolean;
+    isBayWindowWin?: boolean;
+    /** 是不是阳台护栏 */
+    isBalconyRailing?: boolean;
+    /** 是不是门线 */
+    isDoor?: boolean;
+    doorAutomaticFind?: boolean;
+    doorDirectConnection?: boolean;
+    expansionWidth?: number;
+    expansionDirction?: {
+        x: number;
+        y: number;
+    };
+    isPassageEntrance?: boolean;
+    topClearance?: number;
+    isVerticalReferenceLine?: boolean;
+    insetionArr?: {
+        index: number;
+        p: {
+            x: number;
+            y: number;
+            z?: number;
+        };
+    }[];
+    outSize?: {
+        direction: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    drawWindow?: HoleData[];
+    drawDoorData?: {
+        start: {
+            x: number;
+            y: number;
+            z?: number;
+        };
+        n: {
+            x: number;
+            y: number;
+            z?: number;
+        };
+        height: number;
+        groundClearance: number;
+        sillHeight?: number;
+    };
+    passageEntrance?: HoleData[];
+    pair?: string | number;
+};
+export type LineUserData = {
+    quadtreeNode?: QuadtreeNode;
+} & WallLineGlobalOption;
+export type OriginalDataItem = {
+    start: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    end: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+} & WallLineGlobalOption;
+/**
+ * [开始点, 结束点, 相交点, 是否是门, 索引]
+ */
+export type DataItem = [Point, Point, number[], boolean, number];
+export type FittingMethodType = "average" | "max";
+export type SetDataOption = {
+    /**
+     * 主轴阈值，默认 0.3 groupMethod是precision时生效
+     */
+    principalAxisThreshold?: number;
+    /**
+     * 交叉轴阈值，默认 0.06
+     */
+    crossAxistThreshold?: number;
+    /**
+     * 吸附阈值，默认 0.2
+     */
+    snapThreshold?: number;
+    /**
+     * 拟合方式, 默认 max
+     * @description average 以分组线段平均数作为拟合位置
+     * @description max 以分组线段中最长线段作为拟合位置
+     */
+    fittingMethod?: FittingMethodType;
+    /**
+     * 分组方式, 默认 default
+     * @description cross 以交叉轴辅助分组
+     * @description principalAndCross 以主轴和交叉轴辅助分组
+     * @description originalInterPoint 通过原始交点计算分组，把原来平行的放到分组里
+     */
+    groupMethod?: "cross" | "principalAndCross" | "originalInterPoint";
+    /**
+     * 吸附方式, 默认 adsorption
+     */
+    adsorptionMethod?: "originalInterPoint" | "adsorption";
+    wallGroup?: boolean;
+    trajectory?: Record<string, any>;
+    onBoundExt?: (lines: LineSegment[], trajectory: any) => void;
+    publicInfo?: IPublicInfoFile;
+    originalZ?: number;
+    minWidth?: number;
+};
+/**
+ *
+ */
+export interface PointGroup {
+    points: Point[];
+    indices: number[];
+}
+export type Contour = {
+    contour: [number, number][];
+    polygon?: Polygon;
+    averagePz: number;
+};
+export type CootTopContourInfo = {
+    contours: Contour[];
+    maxContourIndex: number;
+    quadtree?: Quadtree;
+};
+export type ItemInfo = {
+    category: string;
+    box: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    contour: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    quadContour?: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    obj_id: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+export interface IPublicInfoFile {
+    itemInfo: ItemInfo[];
+    rootTopContourInfo?: CootTopContourInfo;
+}

package/src/dxf-system/utils/BayWindowHelper.d.ts

@@ -0,0 +1,58 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { LineUserData } from '../type';
+import { Point } from '../../utils/algorithms/Point';
+import * as THREE from "three";
+export interface IDrawBayWindowData {
+    height1: number;
+    height2: number;
+    height3: number;
+    depth: number;
+    windowWidth: number;
+    windowHeight: number;
+    bayWindowLine: LineSegment;
+    windowLine: LineSegment;
+    deptLine: LineSegment;
+    direction: Point;
+}
+export interface IDrawBayWindowData2 {
+    height1: number;
+    height2: number;
+    height3: number;
+    windowWidth: number;
+    windowHeight: number;
+    direction: Point;
+}
+export declare class BayWindowHelper {
+    /** 计算飘窗信息
+     * @param lines
+     */
+    static computedInfo(lines: LineSegment<LineUserData>[]): {
+        side: "LEFT" | "RIGHT";
+        depth: number;
+        dottedLine: LineSegment<LineUserData>;
+        windowLine: LineSegment<LineUserData> | undefined;
+    } | undefined;
+    /** 获取绘制数据
+     * @param lines
+     * @returns
+     */
+    static getDrawData(lines: LineSegment<LineUserData>[]): IDrawBayWindowData | null;
+    /** 获取绘制数据
+     * @param lines
+     * @returns
+     */
+    static getDrawData2(lines: LineSegment<LineUserData>[]): IDrawBayWindowData2 | null;
+    /** 获取所有绘制数据
+     * @param lineSegments
+     * @returns
+     */
+    static getDrawDataAll(lineSegments: LineSegment[]): {
+        group: LineSegment<Record<string, any>>[];
+        drawData: IDrawBayWindowData;
+    }[];
+    /** 绘制数据转模型
+     * @param drawData
+     * @returns
+     */
+    static drawDataToModel(drawData: IDrawBayWindowData): THREE.Group<THREE.Object3DEventMap>;
+}

package/src/dxf-system/utils/BoundExt.d.ts

@@ -0,0 +1,51 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { Point } from '../../utils/algorithms/Point';
+import { LineUserData, OriginalDataItem } from '../type';
+interface IByTraj {
+    lines: LineSegment[];
+    trajectory: any;
+    wallWidth: number;
+    updateDoubleWallGroup?: boolean;
+    findCallBack?: (lines: LineSegment[], trajectory: Point[]) => void;
+}
+interface IByTrajAnOriginData {
+    data: OriginalDataItem[];
+    trajectory: any;
+    wallWidth: number;
+    updateDoubleWallGroup?: boolean;
+    findCallBack?: (lines: LineSegment[], trajectory: Point[]) => void;
+}
+/**
+ * 外墙外扩
+ */
+export declare class BoundExt {
+    /** 通过轨迹点查找外墙
+     * @param lines
+     * @param trajectoryPoints
+     * @returns
+     */
+    static findExtWallByTraj(lines: LineSegment<LineUserData & {
+        expandDirect?: 'left' | 'right' | 'on';
+    }>[], trajectoryPoints: Point[], minWidth?: number): LineSegment<{
+        quadtreeNode?: import('../../utils').QuadtreeNode;
+    } & import('../type').WallLineGlobalOption & {
+        expandDirect?: "left" | "right" | "on";
+    }>[];
+    /** 通过轨迹点外扩边线
+     * @param lines
+     * @param trajectoryPoints
+     */
+    static boundExtbyTrajAndOriginalData(opt: IByTrajAnOriginData): OriginalDataItem[];
+    /** 通过轨迹点外扩边线
+     * @param lines
+     * @param trajectory
+     * @param wallWidth
+     * @param findCallBack
+     * @returns
+     */
+    static boundExtbyTraj(opt: IByTraj): {
+        lines: LineSegment<Record<string, any>>[];
+        toOriginalData(originalZAverage: number): OriginalDataItem[];
+    };
+}
+export {};

package/src/dxf-system/utils/DoorFind.d.ts

@@ -0,0 +1,44 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { LineUserData } from '../type';
+import { PointSpatialHash } from '../../utils/algorithms/PointSpatialHash';
+import { Quadtree } from '../../utils/algorithms/Quadtree';
+import { Point } from '../../utils/algorithms/Point';
+interface IDockInfo {
+    dockLine: LineSegment<LineUserData>;
+    dockPoint: Point<Record<string, any>>;
+    point: Point<Record<string, any>>;
+    pointType: string;
+}
+export declare class DoorFind {
+    lines: LineSegment[];
+    grid: PointSpatialHash<LineSegment<LineUserData>>;
+    quadtree: Quadtree<{
+        index: number;
+    }>;
+    constructor(lines: LineSegment<LineUserData>[]);
+    /**
+     * 查找兄弟门(双开门)
+     */
+    findBrotherDoor(lines: LineSegment<LineUserData>[]): LineSegment<LineUserData>[];
+    /** 处理封闭门
+     * @param line
+     * @returns
+     */
+    private findCloseDoors;
+    /** 处理开门
+     * @param line
+     * @returns
+     */
+    findOpenDoors(line: LineSegment<LineUserData>): void;
+    /**
+     * 对门的两侧进行吸附
+     * @param dock
+     * @param line
+     * @param maxAngle 找到的门线与原来的之间最大夹角
+     * @returns
+     */
+    adsorpt(dock: IDockInfo, line: LineSegment, maxAngle?: number): Point<Record<string, any>> | null;
+    extendLink(dock: IDockInfo, line: LineSegment): Point<Record<string, any>> | null;
+    getLines(): LineSegment<Record<string, any>>[];
+}
+export {};

package/src/dxf-system/utils/DoubleWallFinder.d.ts

@@ -0,0 +1,24 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { LineUserData } from '../type';
+export declare class DoubleWallFinder {
+    /**
+     * @param lines
+     * @param parallelAxis
+     * @param verticalAxis
+     * @param esp
+     * @param gap
+     * @returns
+     */
+    private static group;
+    /** 查找
+     * @param lines
+     * @param obstacle
+     * @param esp
+     * @returns
+     */
+    static find(lines: LineSegment<LineUserData>[], obstacle?: LineSegment[], esp?: number): LineSegment<LineUserData>[];
+    /**
+     * 创建分组
+     */
+    static buildGroup(lineSegments: LineSegment<LineUserData>[]): (LineSegment<Record<string, any>> | LineSegment<LineUserData>)[];
+}

package/src/dxf-system/utils/HeightQuery.d.ts

@@ -0,0 +1,12 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { CootTopContourInfo } from '../type';
+/**
+ * 墙高查询
+ */
+export declare class HeightQuery {
+    static query(line: LineSegment, rootTopContourInfo: CootTopContourInfo): number;
+    static whichContourContainsPoint(points: [number, number][], rootTopContourInfo: CootTopContourInfo): {
+        i: number;
+        averagePz: number;
+    }[];
+}

package/src/dxf-system/utils/LineGroupType.d.ts

@@ -0,0 +1,125 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { LineUserData } from '../type';
+/**
+ * 线段分组管理
+ */
+export declare class LineGroupType {
+    /**
+     * 获取线段的所有分组信息
+     * @param line
+     * @returns
+     */
+    static get(line: LineSegment<LineUserData>): {
+        id: string;
+        type?: string;
+    }[];
+    /**
+     * 为线段添加新的分组
+     * @param line
+     * @param id
+     * @param type
+     * @returns
+     */
+    static set(line: LineSegment<LineUserData>, id: string, type: string, repeat?: boolean): void;
+    /** 通过类型获取id
+     * @param line
+     * @param type
+     * @returns
+     */
+    static getIdByType(line: LineSegment<LineUserData>, type: string): string | undefined;
+    /** 通过类型获取所有id
+     * @param line
+     * @param type
+     * @returns
+     */
+    static getIdsByType(line: LineSegment<LineUserData>, type: string): string[];
+    /** 通过类型获取所有组
+     * @param lines
+     * @param type
+     */
+    static getGroupsByType(lines: LineSegment[], type: string, remainingLines?: LineSegment[]): LineSegment<Record<string, any>>[][] & {
+        remainingLines: LineSegment<Record<string, any>>[];
+    };
+    /**
+     * 替换线段中的分组信息
+     * @param line
+     * @param id
+     * @param type
+     * @returns
+     */
+    static replace(line: LineSegment<LineUserData>, id: string, type: string): boolean;
+    /** 有组
+     * @param line
+     */
+    static hasGroup(line: LineSegment<LineUserData>): boolean;
+    /**
+     * 检查线段是否包含指定的分组ID
+     * @param line
+     * @param id
+     * @returns
+     */
+    static hasId(line: LineSegment<LineUserData>, id: string): boolean | undefined;
+    /**
+     * 检查线段是否包含指定的分组类型
+     * @param line
+     * @param type
+     * @returns
+     */
+    static hasType(line: LineSegment<LineUserData>, type: string): boolean;
+    /**
+     * 检查线段是否包含所有指定的分组类型
+     * @param line
+     * @param types
+     * @returns
+     */
+    static hasTypes(line: LineSegment<LineUserData>, types: string[]): boolean;
+    /**
+     * 检查线段是否包含所有指定的分组类型
+     * @param lines
+     * @param type
+     * @returns
+     */
+    static everyType(lines: LineSegment<LineUserData>[], type: string): boolean;
+    /**
+     * 获取所有线段的交集类型（所有线段都包含的类型）
+     * @param lines
+     * @returns
+     */
+    static getIntersectionTypes(lines: LineSegment<LineUserData>[]): string[];
+    /**
+     * 获取所有线段的并集类型
+     * @param lines
+     * @returns
+     */
+    static getUnionTypes(lines: LineSegment<LineUserData>[]): string[];
+    /** 是否为一组
+     * @param lines
+     */
+    static isGroup(lines: LineSegment<LineUserData>[]): boolean;
+    /**
+     *
+     * @param line
+     * @param id
+     * @returns
+     */
+    static remove(line: LineSegment<LineUserData>, id: string): boolean;
+    /**
+     * 通过类型移除
+     * @param line
+     * @param id
+     * @returns
+     */
+    static removeByType(line: LineSegment<LineUserData>, type: string): boolean;
+    /**
+     * 通过类型移除
+     * @param line
+     * @param id
+     * @returns
+     */
+    static removeByTypes(line: LineSegment<LineUserData>, types: string[]): void;
+    /**
+     * 清空线段的所有分组信息
+     * @param line
+     */
+    static clear(line: LineSegment<LineUserData>): void;
+}

package/src/dxf-system/utils/LoadModel.d.ts

@@ -0,0 +1,7 @@
+import { Group } from 'three';
+export declare class LoadModel {
+    private static _cache;
+    private static _nameMap;
+    static addNameMap(mapName: string, name: string): void;
+    static loadGlb(name: string): Promise<Group<import('three').Object3DEventMap> | null> | undefined;
+}

package/src/dxf-system/utils/RunJianPipeline.d.ts

@@ -0,0 +1,92 @@
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { LineUserData } from '../type';
+import { WallGroupManager } from './WallGroupManager';
+import { Pipeline, HandlerContext } from '../../utils/algorithms/Pipeline';
+type Component = {
+    index: number;
+    id: number;
+    name: "梁" | "柱" | "板" | "墙";
+    floor: number;
+    length: number;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    z: number;
+};
+export type RunJianObject = {
+    version: string;
+    title: string;
+    floor: number;
+    components: Component[];
+};
+type DataOption = {
+    lines: LineSegment[];
+    json: RunJianObject;
+};
+interface ICache {
+    wallLines: LineSegment[];
+}
+export declare class RunJianPipeline extends Pipeline<DataOption, ICache> {
+    manager: WallGroupManager;
+    index: number;
+    z: number;
+    floor: number;
+    lines: LineSegment[];
+    constructor(lines: LineSegment[], z: number, floor: number);
+    /** 双线墙处理
+     *  孔洞提取
+     *  会拆分成有宽度的单线墙壁
+     * @param param0
+     * @returns
+     */
+    doubleWallHandle({ data: { lines }, cache }: HandlerContext<DataOption, ICache>): void;
+    /** 柱子处理
+     * @param param0
+     * @returns
+     */
+    pillarHandle({ data: { lines, json } }: HandlerContext<DataOption>): void;
+    /**
+     * 单线墙处理 - 孔洞提取
+     * @param param0
+     */
+    wallHandle({ data: { lines }, cache }: HandlerContext<DataOption, ICache>): void;
+    /**
+     * 门线处理
+     * @param param0
+     */
+    doorHandle({ data: { lines }, cache }: HandlerContext<DataOption, ICache>): void;
+    /** 飘窗处理
+     * @param data
+     * @returns
+     */
+    bayWindowHandle({ data: { lines }, cache }: HandlerContext<DataOption, ICache>): void;
+    /** 阳台护栏
+     * @param param0
+     * @returns
+     */
+    balconyRailing({ data: { lines }, cache }: HandlerContext<DataOption, ICache>): void;
+    /** 墙壁孔洞处理
+     * @param param0
+     * @returns
+     */
+    wallHoleHandle({ data: { lines, json } }: HandlerContext<DataOption, ICache>): void;
+    /** 转换
+     * @returns
+     */
+    transform(): RunJianObject;
+    /**
+     * 转为 润建 结构
+     * @param lineSegments
+     * @param angle 弧度
+     * @param updateGroup
+     * @returns
+     */
+    static toJson(lineSegments: LineSegment<LineUserData>[], opt?: {
+        z?: number;
+        angle?: number;
+        floor: number;
+        updateGroup?: boolean;
+    }): RunJianObject;
+}
+export {};

package/src/dxf-system/utils/SceneAutoGenerat.d.ts

@@ -0,0 +1,42 @@
+import { Group } from 'three';
+import { LineSegment } from '../../utils/algorithms/LineSegment';
+import { LineUserData } from '../type';
+import * as THREE from "three";
+export declare class SceneAutoGenerat {
+    lines: LineSegment[];
+    itemList: any[];
+    z: number;
+    scene: Group<THREE.Object3DEventMap>;
+    trajectory?: any;
+    angle: number;
+    constructor(lines: LineSegment[], itemList: any[], z: number, trajectory?: any);
+    init(): Promise<void>;
+    private createGeometryByLines;
+    getDoorAll(lines: LineSegment<LineUserData>[]): LineSegment<LineUserData>[];
+    buildPlane(lines: LineSegment<LineUserData>[]): void;
+    wallGroup: Group | null;
+    /** 构建墙壁
+     */
+    buildWall(): Promise<void>;
+    /** 获取模型
+     * @param item
+     * @param walls
+     */
+    getModel(item: any): Promise<void>;
+    /** 构建物品模型
+     */
+    buildItem(): Promise<void>;
+    static itemParse(item: any): {
+        geometry: THREE.ExtrudeGeometry;
+        box: THREE.LineSegments<THREE.EdgesGeometry<THREE.ExtrudeGeometry>, THREE.LineBasicMaterial, THREE.Object3DEventMap>;
+        center: THREE.Vector3;
+        category: any;
+        angle: number;
+        info: {
+            center: THREE.Vector3;
+            start: THREE.Vector3;
+            end: THREE.Vector3;
+            length: number;
+        }[];
+    } | null;
+}