build-dxf 0.0.9 → 0.0.11

package/src/pages/Dxf.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/src/router/index.d.ts

@@ -0,0 +1,2 @@
+import { App } from 'vue';
+export declare function useRouter(app: App): void;

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

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

package/src/utils/ComponentManager/ComponentManager.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 ComponentManager<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<{}> | undefined;
+    /**
+     *
+     * @param type
+     */
+    findComponentByType<T extends typeof Component>(type: T): InstanceType<T> | null;
+    /**
+     *
+     * @param type
+     */
+    findComponentByName(name: string): Component<{}> | null;
+}
+export {};

package/src/utils/ComponentManager/EventDispatcher.d.ts

@@ -0,0 +1,4 @@
+import { EventDispatcher as ED } from 'three';
+export declare class EventDispatcher<TEventMap extends {} = {}> extends ED<TEventMap> {
+    uuid: string;
+}

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

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

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

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

package/src/utils/DxfSystem/components/Dxf.d.ts

@@ -0,0 +1,150 @@
+import { Component } from '../../ComponentManager';
+import { Point } from '../../Quadtree/Point';
+import { Box2 } from '../../Quadtree/Box2';
+import { LineSegment } from '../../Quadtree/LineSegment';
+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 OriginalDataItem {
+    start: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    end: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    insetionArr: {
+        index: number;
+        p: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+    isDoor?: boolean;
+}
+/**
+ * [开始点, 结束点, 相交点, 是否是门, 索引]
+ */
+export type DataItem = [Point, Point, number[], boolean, number];
+/**
+ *
+ */
+export interface PointGroup {
+    points: Point[];
+    indices: number[];
+}
+/**
+ * 将点云结构转换为DXF格式
+ */
+export declare class Dxf extends Component<{
+    setDta: {
+        originalData: OriginalDataItem[];
+        data: DataItem[];
+    };
+    lineOffset: {
+        wallsGroup: Point[][];
+    };
+    createGroup: {
+        groups: Point[][][];
+    };
+}> {
+    static name: string;
+    width: number;
+    scale: number;
+    originalData: OriginalDataItem[];
+    data: DataItem[];
+    originalBox: Box2;
+    box: Box2;
+    pointsGroups: Point[][][];
+    wallsGroup: Point[][];
+    doors: DataItem[];
+    lineSegments: LineSegment<{
+        isDoor: boolean;
+    }>[];
+    originalZAverage: number;
+    static EndType: {
+        etOpenSquare: number;
+        etOpenRound: number;
+        etOpenButt: number;
+    };
+    static JoinType: {
+        jtSquare: number;
+        jtRound: number;
+        jtMiter: number;
+    };
+    /** 原始数据组
+     */
+    get lines(): LineSegment<{
+        isDoor: boolean;
+    }>[];
+    /**初始化
+     * @param data 点云数据
+     * @param width 墙体宽度
+     * @param scale 缩放比例
+     */
+    constructor(width?: number, scale?: number);
+    /**
+     * 设置
+     * @param data
+     * @param width
+     * @param scale
+     */
+    set(data: OriginalDataItem[] | string, width?: number, scale?: number): Promise<any>;
+    /** 创建分组
+     * @description 根据相交数组insetionArr, 把相交的线段，划分到一组内，方便后续路径查找合并使用
+     * @returns
+     */
+    private createGroups;
+    /** 计算当前墙体数据的边界框
+     * @description 根据分组数据pointsGroups，计算包围盒， pointsGroups数据为缩放后数据。
+     * @description 可通过box属性查看计算结果。
+     * @returns
+     */
+    computedSize(): Box2;
+    /** 线路拓扑
+     * @description 处理线路拓扑，使线路有序链接，形成长路径
+     * @param lines
+     */
+    private lineTopology;
+    /** etOpenRound 去除毛刺
+     * @description 检查连续的短线段数量，去除合并后产生的毛刺
+     */
+    private squareRemoveBurr;
+    /** 线偏移
+     * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
+     */
+    lineOffset(endType?: number, joinType?: number, scale?: number): Point[][];
+    /**
+     * 将点云结构转换为Float32Array
+     */
+    to3DArray(scale: number): Float32Array<ArrayBuffer>;
+    /**
+     * 将点云结构转换为string
+     */
+    toDxfString(unit?: Unit): string;
+    /**
+     * 将点云结构转换为DXF格式
+     * @returns
+     */
+    toDxfBlob(unit?: Unit): Blob;
+    /**
+     * 下载
+     * @param filename
+     */
+    download(filename: string, unit?: Unit): Promise<void>;
+    /**
+     * 计算原始数据的边界框
+     * @description 计算所有线段的起点和终点的最小最大值，形成一个边界框
+     * @returns
+     */
+    private computedOriginalSize;
+    /**
+     * 创建数据
+     * @param pointsGroups
+     * @returns
+     */
+    static createData(pointsGroups: Point[][], sealed?: boolean): OriginalDataItem[];
+}
+export {};

package/src/utils/DxfSystem/components/LineAnalysis.d.ts

@@ -0,0 +1,85 @@
+import { Component, ComponentManager } from '../../ComponentManager';
+import { Dxf } from './Dxf';
+import { Variable } from './Variable';
+import { Quadtree } from '../../Quadtree/Quadtree';
+import { LineSegment } from '../../Quadtree/LineSegment';
+import { Point } from '../../Quadtree/Point';
+import { PointVirtualGrid } from '../../PointVirtualGrid';
+import * as THREE from "three";
+type ProjectionAnalysisResult = {
+    source: LineSegment;
+    sourceIndex: number;
+    target: LineSegment;
+    targetIndex: number;
+    project: LineSegment;
+    project2: LineSegment;
+};
+export declare class LineAnalysis extends Component {
+    static name: string;
+    Dxf: Dxf | null;
+    Variable: Variable | null;
+    lineSegmentList: LineSegment[];
+    container: THREE.Group<THREE.Object3DEventMap>;
+    errorAngle: number;
+    width: number;
+    /**
+     *
+     * @param parent
+     */
+    onAddFromParent(parent: ComponentManager): void;
+    /**
+     * 去除路径上重复的点
+     * @description 判断方向向量，一个连续的方向上，只应该出现两个点
+     */
+    duplicatePointFiltering(): void;
+    /**
+     *
+     * @param p1
+     * @param p2
+     * @param width
+     * @returns
+     */
+    expandLineSegment(p1: Point, p2: Point, width?: number): {
+        points: Point[];
+        indices: number[];
+        rectIndices: number[];
+    };
+    appendLineSegmentList: LineSegment[];
+    /**
+     * 追加数据
+     * @param p1
+     * @param p2
+     */
+    addData(p1: Point, p2: Point): void;
+    /** 结果分析创建矩形
+     * @param result
+     */
+    createRectangle(result: ProjectionAnalysisResult): void;
+    pointVirtualGrid: PointVirtualGrid<{
+        index: number;
+        type: "start" | "end";
+    }>;
+    /**
+     * 构建点的虚拟网格索引
+     */
+    buildVirtualGrid(): void;
+    quadtree?: Quadtree;
+    /**
+     * 构建线段四叉树，快速查找，
+     */
+    buildQuadtree(): void;
+    resultList: ProjectionAnalysisResult[];
+    /** 线段分析
+     * @description 判断两条线段距离是否较短且趋近平行，然后查找两条线段的重合部分的投影线，以此判断两根线是否需要合并
+     * @param data
+     */
+    lineAnalysis(): void;
+    /** 线段投影分析
+     * @param index
+     * @param sourceLineSegment
+     * @param lineSegmentList
+     * @returns
+     */
+    private projectionAnalysis;
+}
+export {};

package/src/utils/DxfSystem/components/Variable.d.ts

@@ -0,0 +1,33 @@
+import { Component } from '../../ComponentManager';
+type EventData<T> = {
+    value: T;
+    oldValue: T;
+};
+interface EventType {
+    originalLineVisible: EventData<boolean>;
+    dxfVisible: EventData<boolean>;
+    whiteModelVisible: EventData<boolean>;
+    isLook: EventData<boolean>;
+    currentWheel: EventData<number>;
+    pointerMove: EventData<{
+        x: number;
+        y: number;
+    }>;
+    currentKeyUp: EventData<string>;
+}
+export declare class Variable extends Component<EventType> {
+    static name: string;
+    originalLineVisible: boolean;
+    dxfVisible: boolean;
+    whiteModelVisible: boolean;
+    isLook: boolean;
+    currentWheel: number;
+    pointerMove: {
+        x: number;
+        y: number;
+    };
+    currentKeyUp: string;
+    set<KeyT extends keyof EventType>(key: KeyT, value: any): void;
+    get<KeyT extends keyof EventType>(key: KeyT): this[KeyT] | undefined;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { ComponentManager } from '../ComponentManager';
+import { Dxf } from './components/Dxf';
+import { Variable } from './components/Variable';
+export declare class DxfSystem extends ComponentManager {
+    Dxf: Dxf;
+    Variable: Variable;
+    wallWidth: number;
+    environment: "node" | "browser" | "unknown";
+    /** 构造函数
+     * @param wallWidth 输出墙壁厚度，该墙壁厚度不受缩放影响
+     * @param scale 原始数据缩放比例
+     */
+    constructor(wallWidth?: number, scale?: number);
+    usePlugin(plugin: (this: DxfSystem, dxfSystem: DxfSystem) => void): this;
+    destroy(): void;
+}

package/src/utils/DxfSystem/plugin/ModelDataPlugin/components/DetailsPoint.d.ts

@@ -0,0 +1,39 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import { Dxf } from '../../../components/Dxf';
+import { Variable } from '../../../components/Variable';
+import { WhiteModel } from './WhiteModel';
+import * as THREE from "three";
+interface IDesPointItem {
+    message: string;
+    position: THREE.Vector3;
+    intersection: THREE.Vector3;
+}
+export declare class DetailsPoint extends Component<{
+    handleSuccess: {
+        desPoints: IDesPointItem[];
+    };
+}> {
+    static name: string;
+    Dxf: Dxf | null;
+    WhiteModel: WhiteModel | null;
+    Variable: Variable | null;
+    desPoints: IDesPointItem[];
+    raylines: [THREE.Vector3, THREE.Vector3][];
+    data: any[];
+    onAddFromParent(parent: ComponentManager): void;
+    /**
+     * 设置值
+     * @param data
+     */
+    set(data: any): Promise<void>;
+    /**
+     * 设置射线辅助
+     */
+    racasterHelper(position: THREE.Vector3, direction: THREE.Vector3, far: number): void;
+    private _timer;
+    /**
+     * 更新模型
+     */
+    updateModel(): void;
+}
+export {};

package/src/utils/DxfSystem/plugin/ModelDataPlugin/components/DxfLineModel.d.ts

@@ -0,0 +1,10 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import * as THREE from "three";
+export declare class DxfLineModel extends Component {
+    static name: string;
+    private dxfLineModel;
+    private dxfDoorsLineModel;
+    dxfModelGroup: THREE.Group<THREE.Object3DEventMap>;
+    onAddFromParent(parent: ComponentManager): void;
+    updateMode(): void;
+}

package/src/utils/DxfSystem/plugin/ModelDataPlugin/components/WhiteModel.d.ts

@@ -0,0 +1,21 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import { Dxf } from '../../../components/Dxf';
+import { Variable } from '../../../components/Variable';
+import * as THREE from "three";
+export declare class WhiteModel extends Component<{
+    updateModel: {
+        whiteModelGroup: THREE.Group;
+        originalWhiteMode: THREE.Group;
+    };
+}> {
+    static name: string;
+    Dxf: Dxf | null;
+    Variable: Variable | null;
+    whiteModelGroup: THREE.Group<THREE.Object3DEventMap>;
+    originalWhiteMode: THREE.Group<THREE.Object3DEventMap>;
+    onAddFromParent(parent: ComponentManager): void;
+    updateModel(): void;
+    toOBJ(): Promise<string>;
+    toBlob(): Promise<Blob | undefined>;
+    download(filename: string): Promise<void>;
+}

package/src/utils/DxfSystem/plugin/ModelDataPlugin/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from './WhiteModel';
+export * from './DetailsPoint';
+export * from './DxfLineModel';

package/src/utils/DxfSystem/plugin/ModelDataPlugin/index.d.ts

@@ -0,0 +1,4 @@
+import { DxfSystem } from '../..';
+import * as components from "./components";
+declare function ModelDataPlugin(dxfSystem: DxfSystem): void;
+export { components, ModelDataPlugin };

package/src/utils/DxfSystem/plugin/RenderPlugin/components/DetailsPointRender.d.ts

@@ -0,0 +1,48 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import { Dxf } from '../../../components/Dxf';
+import { Renderer } from './Renderer';
+import { Variable } from '../../../components/Variable';
+import { WhiteModel } from '../../ModelDataPlugin/components';
+import * as THREE from "three";
+export declare class DetailsPointRender extends Component {
+    static name: string;
+    Dxf: Dxf | null;
+    Renderer: Renderer | null;
+    WhiteModel: WhiteModel | null;
+    Variable: Variable | null;
+    desPointGroup: THREE.Group<THREE.Object3DEventMap>;
+    rayLineGroup: THREE.Group<THREE.Object3DEventMap>;
+    data: any[];
+    onAddFromParent(parent: ComponentManager): void;
+    /**
+     * 更新模型
+     */
+    updateModel(): void;
+    createDesPoint(): void;
+    createRayline(): void;
+    private _desBoxInfo;
+    /**
+     * 显示详情div盒子
+     * @param point
+     * @param div
+     * @param param2
+     * @returns
+     */
+    showDesBox(point: THREE.Vector3, div: HTMLDivElement, { message, position }: any): void;
+    /**
+     * 隐藏详情盒子
+     */
+    hideDesBox(): void;
+    private orbitControlsTarget;
+    private fov;
+    /**
+     * 查看详情点
+     * @param point
+     * @param position
+     */
+    onLook(point: THREE.Vector3, position: THREE.Vector3): void;
+    /**
+     * 取消查看详情点
+     */
+    cancelLook(): void;
+}

package/src/utils/DxfSystem/plugin/RenderPlugin/components/DomContainer.d.ts

@@ -0,0 +1,8 @@
+import { Component } from '../../../../ComponentManager';
+export declare class DomContainer extends Component {
+    static name: string;
+    domElement: HTMLDivElement;
+    canvas: HTMLCanvasElement;
+    html2DRenderer: HTMLDivElement;
+    constructor();
+}

package/src/utils/DxfSystem/plugin/RenderPlugin/components/DomEventRegister.d.ts

@@ -0,0 +1,23 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+export declare class DomEventRegister extends Component {
+    static name: string;
+    /**
+     *
+     * @param parent
+     */
+    onAddFromParent(parent: ComponentManager): void;
+    /**
+     *
+     * @param el
+     * @param callBack
+     * @param offset
+     * @param condition
+     */
+    dragMoveHelper(el: HTMLElement, callBack: (offset: {
+        x: number;
+        y: number;
+    }, mx: number, my: number) => void, offset?: {
+        x: number;
+        y: number;
+    }, condition?: () => boolean): void;
+}

package/src/utils/DxfSystem/plugin/RenderPlugin/components/ModelDataRender.d.ts

@@ -0,0 +1,13 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import { Point } from '../../../../Quadtree/Point';
+export interface PointGroup {
+    points: Point[];
+    indices: number[];
+    rectIndices: number[];
+}
+export declare class ModelDataRender extends Component {
+    static name: string;
+    onAddFromParent(parent: ComponentManager): void;
+    dxf(parent: ComponentManager): void;
+    whiteModel(parent: ComponentManager): void;
+}

package/src/utils/DxfSystem/plugin/RenderPlugin/components/OriginalLineRender.d.ts

@@ -0,0 +1,16 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import { Dxf } from '../../../components/Dxf';
+import { Renderer } from './Renderer';
+import * as THREE from "three";
+export declare class OriginalLineRender extends Component {
+    static name: string;
+    Dxf: Dxf | null;
+    Renderer: Renderer | null;
+    originalLineMode: THREE.LineSegments<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    appendLineMode: THREE.LineSegments<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    textGroup: THREE.Group<THREE.Object3DEventMap>;
+    pointGroup: THREE.Group<THREE.Object3DEventMap>;
+    distanceGroup: THREE.Group<THREE.Object3DEventMap>;
+    onAddFromParent(parent: ComponentManager): void;
+    updateMode(data: any): void;
+}

package/src/utils/DxfSystem/plugin/RenderPlugin/components/Renderer.d.ts

@@ -0,0 +1,82 @@
+import { CSS3DRenderer, CSS3DObject, CSS3DSprite } from 'three/addons/renderers/CSS3DRenderer.js';
+import { CSS2DRenderer, CSS2DObject } from 'three/addons/renderers/CSS2DRenderer.js';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { Component } from '../../../../ComponentManager';
+import { Point } from '../../../../Quadtree/Point';
+import * as THREE from "three";
+export interface RendererDescription {
+    canvas: HTMLCanvasElement;
+    orbitControls?: {
+        enableDamping?: boolean;
+        dampingFactor?: number;
+        domElement: HTMLElement;
+    };
+    htmlRenderer?: {
+        '2d'?: HTMLElement;
+        '3d'?: HTMLElement;
+    };
+    resizeObserver?: HTMLElement | null;
+    scene?: THREE.Scene;
+    camera?: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+}
+export declare class Renderer extends Component {
+    static name: string;
+    static CSS2DObject: typeof CSS2DObject;
+    static CSS3DObject: typeof CSS3DObject;
+    static CSS3DSprite: typeof CSS3DSprite;
+    static Group: typeof THREE.Group;
+    static Object3D: typeof THREE.Object3D;
+    static Mesh: typeof THREE.Mesh;
+    static Line: typeof THREE.Line;
+    static LineSegments: typeof THREE.LineSegments;
+    static Points: typeof THREE.Points;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    renderer: THREE.WebGLRenderer;
+    orbitControls?: OrbitControls;
+    private resizeObserver?;
+    private description;
+    html2DRenderer?: CSS2DRenderer;
+    html3DRenderer?: CSS3DRenderer;
+    container: THREE.Group<THREE.Object3DEventMap>;
+    onUpdate?: () => void;
+    onResize?: (width: number, height: number) => void;
+    private tweenTaskList;
+    constructor(description: RendererDescription);
+    /**
+     * 世界坐标转屏幕坐标
+     * @param worldPosition
+     * @param camera
+     * @param renderer
+     * @returns
+     */
+    worldToScreenPosition(worldPosition: THREE.Vector3): THREE.Vector2;
+    cameraPositionRecord: [THREE.Vector3, THREE.Quaternion][];
+    /**
+     * 相机
+     * @param position
+     * @param lookAt
+     * @param onEnd
+     */
+    cameraTo(position: THREE.Vector3, lookAt: THREE.Vector3, onEnd?: any): void;
+    cameraBack(): void;
+    /**
+     * 创建点
+     * @param pos
+     */
+    createPointMesh(pos?: Point | THREE.Vector3, size?: number, parameters?: THREE.MeshBasicMaterialParameters, parent?: THREE.Object3D): void;
+    /**
+     * 创建文本
+     * @param text
+     * @param pos
+     * @param style
+     */
+    createText(text: any, pos?: Point | THREE.Vector3, style?: any, parent?: THREE.Object3D): void;
+    /**
+     * 创建几何缓冲区
+     * @param map
+     * @param count
+     */
+    createLineSegments(map: Record<string, number[]>, count: number, parameters?: THREE.LineBasicMaterialParameters, parent?: THREE.Object3D): THREE.LineSegments<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.LineBasicMaterial, THREE.Object3DEventMap>;
+    destroy(): void;
+}

package/src/utils/DxfSystem/plugin/RenderPlugin/components/index.d.ts

@@ -0,0 +1,6 @@
+export * from './DetailsPointRender';
+export * from './DomContainer';
+export * from './OriginalLineRender';
+export * from './Renderer';
+export * from './ModelDataRender';
+export * from './DomEventRegister';

package/src/utils/DxfSystem/plugin/RenderPlugin/index.d.ts

@@ -0,0 +1,5 @@
+import { DxfSystem } from '../..';
+import { default as Dxf3DView } from './pages/Dxf.vue';
+import * as components from "./components";
+declare function RenderPlugin(dxfSystem: DxfSystem): void;
+export { components, RenderPlugin, Dxf3DView };