dxfview 0.0.2

package/dist/types/core/dxf/DxfObject.d.ts

@@ -0,0 +1,32 @@
+import { Box3, BufferGeometry, Object3D, Layers, Material, Matrix4 } from "three";
+export declare enum ObjectType {
+    Object = 0,
+    Point = 1,
+    Line = 2,
+    LineSegment = 3,
+    Mesh = 4
+}
+export declare type CallBack = (object: DxfObject) => void;
+export declare class DxfObject {
+    name: string;
+    type: ObjectType;
+    matrix: Matrix4;
+    parent?: DxfObject;
+    children: DxfObject[];
+    layers: Layers;
+    renderOrder: number;
+    userData: any;
+    material?: Material;
+    geometry?: BufferGeometry;
+    matrixWorld?: Matrix4;
+    constructor(type?: ObjectType);
+    add(object: DxfObject, ...args: DxfObject[]): this;
+    remove(object: DxfObject, ...args: DxfObject[]): this;
+    removeFromParent(): this;
+    clear(): this;
+    traverse(callback: CallBack): void;
+    clone(recursive?: boolean): DxfObject;
+    copy(source: DxfObject, recursive?: boolean): this;
+    convertToThreejsObject(recursive?: boolean): Object3D<import("three").Event> | undefined;
+    static getBox(object: DxfObject, box: THREE.Box3, parentMatrix?: Matrix4): Box3;
+}

package/dist/types/core/dxf/DxfUtils.d.ts

@@ -0,0 +1,79 @@
+import { DxfObject } from "../../core/dxf/DxfObject";
+/**
+ * MergeHelper class is used to merge child objects for a given object
+ * @internal
+ */
+export declare class DxfUtils {
+    static mergeInfo: {
+        removedObjects: number;
+        mergedMeshes: number;
+        mergedLines: number;
+        mergedPoints: number;
+        mergedUnknownTypeObjects: number;
+        elapsedTime: number;
+    };
+    static resetMergeInfo(): void;
+    /**
+     * Merges child objects for given object.
+     * it tries to merge objects in the same level and with the same parent;
+     * @param saveBatchInfo caller can set saveBatchInfo to true, so that s/he can
+     * get the object's original data before merged.
+     * While this takes some extra space, so, we'd like to add a flag here.
+     */
+    static merge(object: DxfObject, saveBatchInfo?: boolean): void;
+    /**
+     * Merges child objects of given object.
+     * If objects' material are the same, they can be merged.
+     */
+    private static mergeInner;
+    /**
+     * @param object parent object or THREE.Object3D[]
+     * @param i index of for object.children[]
+     * @param k index of for object.children[]
+     * @param dict to store merge-able object
+     * @param nonMergeIndexes used in order to improve performance
+     */
+    private static tryHandleMergeableObjects;
+    /**
+     * TODO: Filters XC etc.
+     * there are cases where entities with xc and without xc are merged together
+     */
+    private static isFilteredByOtherFactors;
+    /**
+     * Merges all objects of given object, just leaf children.
+     * If objects' material are the same, they can be merged.
+     * Better to call mergeInner first then deepMerge for a better performance.
+     * return \{ "added": THREE.Object3D[], "removed": THREE.Object3D[] \}
+     */
+    static deepMerge(objects: DxfObject[], levelObject?: DxfObject | undefined, bRemovedAndAddedAfterMerge?: boolean, bRemoveEmptyObjectsAfterMerge?: boolean, saveBatchInfo?: boolean): {
+        added: DxfObject[];
+        removed: DxfObject[];
+    };
+    /**
+     * since we'll move geometry to another merged mesh under a group, below is the structure:
+        - root object
+          - merged objects group
+            - merged object 1
+     * need to consider a geometry's matrix for each level of ancestor
+    */
+    private static applyMatrix;
+    /**
+     * Merges geometries for lines
+     */
+    /**
+     * Removes a number from array
+     */
+    private static removeFromArray;
+    /**
+     * Checks if two geometries are mergable.
+     * It requires they have the same type and the same attributes.
+     */
+    /**
+     * Checks if two objects are mergable.
+     * It requires
+     * - They are with the same masks.
+     * - Their userData.layerName must be the same if there is. This is useful for Dxf.
+     * - They have the same type or the same draw type( Mesh or Line or Point).
+     */
+    private static areObjectsMergeable;
+}

package/dist/types/core/dxf/HatchPatternShaders.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+export interface PatternLine {
+    origin: THREE.Vector2;
+    delta: THREE.Vector2;
+    angle: number;
+    pattern: number[];
+    patternSum: number[];
+    patternLength: number;
+}
+export declare function createHatchPatternShaderMaterial(patternLines: PatternLine[], patternAngle: number, cameraZoomUniform: {
+    value: number;
+}, color: THREE.Color, fixedThicknessInWorldCoord?: number): THREE.Material;

package/dist/types/core/dxf/LinePatternShaders.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+export declare class LinePatternShaders {
+    /**
+     * Creates line shader by given pattern.
+     * Note: remember to call line.computeLineDistances() in order to make it work!
+     */
+    static createLineShaderMaterial(pattern: number[], color: number, scale: number, viewportScaleUniform: {
+        value: number;
+    }, cameraZoomUniform: {
+        value: number;
+    }): THREE.Material;
+}

package/dist/types/core/dxf/bspline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copied and ported to code standard as the b-spline library is not maintained any longer.
+ * Source:
+ * https://github.com/thibauts/b-spline
+ * Copyright (c) 2015 Thibaut Séguy <thibaut.seguy@gmail.com>
+ */
+declare const _default: (t: number, degree: number, points: number[][], knots: number[], weights?: number[]) => number[];
+export default _default;

package/dist/types/core/dxf/dxfom-mtext.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @internal
+ */
+export declare type DxfMTextContentElement = DxfMTextContentElement[] | string | {
+    /** font family */
+    f?: string;
+    /** bold */
+    b?: 0 | 1;
+    /** italic */
+    i?: 0 | 1;
+    /** code page */
+    c?: number;
+    /** pitch */
+    p?: number;
+    /** angle in degrees */
+    Q?: number;
+    /** character height (with unit) */
+    H?: [number, string];
+    /** character width (with unit) */
+    W?: [number, string];
+    /** stacking */
+    S?: [string, "^" | "/" | "#", string];
+    /** alignment (0: bottom, 1: center, 2: top) */
+    A?: 0 | 1 | 2;
+    /** color index */
+    C?: number;
+    /** character spacing */
+    T?: number;
+    /** underscore */
+    L?: 0 | 1;
+    /** overscore */
+    O?: 0 | 1;
+    /** strike through */
+    K?: 0 | 1;
+};
+/**
+ * @internal
+ * [{f:""},
+ *  {W:[,]},
+ *  {C:number},
+ *  ...
+ *  ""] // The last one must be the test string
+ */
+export declare const parseDxfMTextContent: (s: string, options?: {
+    readonly encoding?: string | TextDecoder | undefined;
+} | undefined) => DxfMTextContentElement[];

package/dist/types/core/dxf/dxfom-text.d.ts

@@ -0,0 +1,16 @@
+export interface DxfTextContentElement {
+    /** text content */
+    text: string;
+    /** strike-through */
+    k?: 1;
+    /** overscore */
+    o?: 1;
+    /** underscore */
+    u?: 1;
+}
+export declare const decodeDxfTextCharacterCodes: (text: string, mbcsEncoding?: string | TextDecoder) => string;
+export declare const decodeDxfTextUnicodeCodePoints: (text: string) => string;
+export declare const decodeDxfTextMbcsCharacterCodes: (text: string, encoding: string | TextDecoder) => string;
+export declare const parseDxfTextContent: (text: string, options?: {
+    readonly encoding?: string | TextDecoder;
+}) => DxfTextContentElement[];

package/dist/types/core/dxf/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./DxfCompare";
+export * from "./DxfLoader";
+export * as bspline from "./bspline";
+export * from "./dxfom-mtext";
+export * as round10 from "./round10";
+export * from "./DxfConstants";
+export * from "./DxfUtils";
+export * from "./HatchPatternShaders";
+export * from "./LinePatternShaders";
+export * from "./dxfom-text";

package/dist/types/core/dxf/round10.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (value: any, exp: any) => number;
+export default _default;

package/dist/types/core/dxf-parser/AutoCadColorIndex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AutoCad files sometimes use an indexed color value between 1 and 255 inclusive.
+ * Each value corresponds to a color. index 1 is red, that is 16711680 or 0xFF0000.
+ * index 0 and 256, while included in this array, are actually reserved for inheritance
+ * values in AutoCad so they should not be used for index color lookups.
+ */
+declare const _default: number[];
+export default _default;

package/dist/types/core/dxf-parser/DxfBaseReader.d.ts

@@ -0,0 +1,12 @@
+export interface IGroup {
+    code: number;
+    value: number | string | boolean;
+}
+export declare abstract class DxfBaseReader {
+    protected pointer: number;
+    protected eof: boolean;
+    lastReadGroup: IGroup | undefined;
+    abstract next(): IGroup;
+    abstract hasNext(): boolean;
+    abstract isEOF(): boolean;
+}

package/dist/types/core/dxf-parser/DxfBinaryReader.d.ts

@@ -0,0 +1,14 @@
+import { DxfBaseReader, IGroup } from "./DxfBaseReader";
+export default class DxfBinaryReader extends DxfBaseReader {
+    private reader;
+    private decoder;
+    private int8Array;
+    private caches;
+    constructor(data: ArrayBuffer);
+    next(): IGroup;
+    hasNext(): boolean;
+    isEOF(): boolean;
+    private parseGroupValue;
+    private readNullTerminatedString;
+    private ReadBinaryData;
+}

package/dist/types/core/dxf-parser/DxfParser.d.ts

@@ -0,0 +1,327 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import IGeometry, { IEntity, IPoint } from "./entities/geomtry";
+import { IObject, IObjectParser } from "./objects/common";
+/**
+ * @internal
+ */
+export declare enum BlockTypeFlags {
+    None = 0,
+    AnonymousBlock = 1,
+    NonConstantAttributeDefinitions = 2,
+    XRef = 4,
+    XRefOverlay = 8,
+    ExternallyDependent = 16,
+    ResolvedExternalReference = 32,
+    DefinitionExternalReference = 64
+}
+/**
+ * Definition of a block. Which contains entities, name, handle, etc.
+ * @internal
+ */
+export interface IBlock {
+    entities: IEntity[];
+    ownerHandle: string;
+    xrefPath: string;
+    name: string;
+    name2: string;
+    handle: string;
+    layer: string;
+    position: IPoint;
+    paperSpace: boolean;
+    blockType: BlockTypeFlags;
+    description?: string;
+}
+/**
+ * Definition of a viewport.
+ * @internal
+ */
+export interface IViewport {
+    name: string;
+    lowerLeftCorner: IPoint;
+    upperRightCorner: IPoint;
+    center: IPoint;
+    snapBasePoint: IPoint;
+    snapSpacing: IPoint;
+    gridSpacing: IPoint;
+    viewDirectionFromTarget: IPoint;
+    viewTarget: IPoint;
+    aspectRatio: number;
+    lensLength: number;
+    frontClippingPlane: string | number | boolean;
+    backClippingPlane: string | number | boolean;
+    viewHeight: number;
+    snapRotationAngle: number;
+    viewTwistAngle: number;
+    orthographicType: string;
+    ucsOrigin: IPoint;
+    ucsXAxis: IPoint;
+    ucsYAxis: IPoint;
+    renderMode: string;
+    defaultLightingType: string;
+    defaultLightingOn: string;
+    ownerHandle: string;
+    ambientColor: number;
+}
+/**
+ * Viewport table definition.
+ * @internal
+ */
+export interface IViewportTableDefinition {
+    tableRecordsProperty: "viewports";
+    tableName: "viewport";
+    dxfSymbolName: "VPORT";
+    parseTableRecords(): IViewport[];
+}
+/**
+ * Line type.
+ * @internal
+ */
+export interface ILineType {
+    name: string;
+    description: string;
+    pattern: number[];
+    patternLength: number;
+}
+/**
+ * Line type table definition.
+ * @internal
+ */
+export interface ILineTypeTableDefinition {
+    tableRecordsProperty: "lineTypes";
+    tableName: "lineType";
+    dxfSymbolName: "LTYPE";
+    parseTableRecords(): Record<string, ILineType>;
+}
+/**
+ * Definition of a layer.
+ */
+export interface ILayer {
+    /**
+     * Unique layer name with the dxf/dwg file.
+     */
+    name: string;
+    /**
+     * @internal
+     */
+    handle: string;
+    visible: boolean;
+    /**
+     * @internal
+     */
+    colorIndex: number;
+    /**
+     * color in decimal
+     */
+    color: number;
+    /**
+     * @internal
+     */
+    frozen: boolean;
+    /**
+     * @internal
+     */
+    flag: number;
+    /**
+     * @internal
+     */
+    lineType: string;
+    /**
+     * @internal
+     */
+    lineweight: 0 | 5 | 9 | 13 | 15 | 18 | 20 | 25 | 30 | 35 | 40 | 50 | 53 | 60 | 70 | 80 | 90 | 100 | 106 | 120 | 140 | 158 | 200 | 211 | -3 | -2 | -1;
+}
+/**
+ * Layer table definition.
+ * @internal
+ */
+export interface ILayerTableDefinition {
+    tableRecordsProperty: "layers";
+    tableName: "layer";
+    dxfSymbolName: "LAYER";
+    parseTableRecords(): Record<string, ILayer>;
+}
+/**
+ * BlockRecord
+ * @internal
+ */
+export interface IBlockRecord {
+    handle: string;
+    ownerHandle: string;
+    blockName: string;
+    layoutHandle: string;
+    blockInsertUnits: number;
+    blockExplodability: number;
+    blockScalability: number;
+    bitmap?: string;
+}
+/**
+ * @internal
+ */
+export interface IBlockRecordTableDefinition {
+    tableRecordsProperty: "blockRecords";
+    tableName: "blockRecord";
+    dxfSymbolName: "BLOCK_RECORD";
+    parseTableRecords(): Record<string, IBlockRecord>;
+}
+/**
+ * Definition of a style.
+ * @internal
+ */
+export interface IStyle {
+    handle: string;
+    ownerHandle: string;
+    styleName: string;
+    priorTextHeight: number;
+    textHeight: number;
+    xScale: number;
+    rotation: number;
+    mirrorType: number;
+    fontFile: string;
+    bigFontFile: string;
+}
+/**
+ * Style table definition.
+ * @internal
+ */
+export interface IStyleTableDefinition {
+    tableRecordsProperty: "styles";
+    tableName: "style";
+    dxfSymbolName: "STYLE";
+    parseTableRecords(): Record<string, IStyle>;
+}
+/**
+ * Dim style.
+ * @internal
+ */
+export interface IDimStyle {
+    styleName: string;
+    DIMSCALE: number;
+    DIMASZ: number;
+    DIMEXO: string;
+    DIMEXE: string;
+    DIMSE1: string;
+    DIMSE2: string;
+    DIMTAD: string;
+    DIMTXT: string;
+    DIMGAP: number;
+    DIMCLRD: number;
+    DIMCLRT: number;
+    DIMLFAC: number;
+    DIMDEC: string;
+    DIMLDRBLK: string;
+}
+/**
+ * Dim style table definition
+ * @internal
+ */
+export interface IDimStyleTableDefinition {
+    tableRecordsProperty: "dimStyles";
+    tableName: "dimStyle";
+    dxfSymbolName: "DIMSTYLE";
+    parseTableRecords(): Record<string, IDimStyle>;
+}
+/**
+ * Table definitions.
+ * @internal
+ */
+export interface ITableDefinitions {
+    VPORT: IViewportTableDefinition;
+    LTYPE: ILineTypeTableDefinition;
+    LAYER: ILayerTableDefinition;
+    BLOCK_RECORD: IBlockRecordTableDefinition;
+    STYLE: IStyleTableDefinition;
+    DIMSTYLE: IDimStyleTableDefinition;
+}
+/**
+ * Base table
+ * @internal
+ */
+export interface IBaseTable {
+    handle: string;
+    ownerHandle: string;
+}
+/**
+ * Viewport table
+ * @internal
+ */
+export interface IViewportTable extends IBaseTable {
+    viewports: IViewport[];
+}
+/**
+ * @internal
+ */
+export interface ILayerTypesTable extends IBaseTable {
+    lineTypes: Record<string, ILineType>;
+}
+/**
+ * @internal
+ */
+export interface ILayersTable extends IBaseTable {
+    layers: Record<string, ILayer>;
+}
+/**
+ * @internal
+ */
+export interface IStylesTable extends IBaseTable {
+    styles: Record<string, IStyle>;
+}
+/**
+ * @internal
+ */
+export interface IDimStyleTable extends IBaseTable {
+    dimStyles: Record<string, IDimStyle>;
+}
+/**
+ * @internal
+ */
+export interface IBlockRecordsTable extends IBaseTable {
+    blockRecords: Record<string, IBlockRecord>;
+}
+/**
+ * @internal
+ */
+export interface ITables {
+    viewport: IViewportTable;
+    lineType: ILayerTypesTable;
+    layer: ILayersTable;
+    blockRecord: IBlockRecordsTable;
+    style: IStylesTable;
+    dimStyle: IDimStyleTable;
+}
+/**
+ * @internal
+ */
+export declare type ITable = IViewportTable | ILayerTypesTable | ILayersTable | IBlockRecordsTable | IStylesTable | IDimStyleTable;
+/**
+ * @internal
+ */
+export interface IDxf {
+    header: Record<string, IPoint | number>;
+    entities: IEntity[];
+    blocks: Record<string, IBlock>;
+    tables: ITables;
+    objects: Record<string, IObject[]>;
+}
+export default class DxfParser {
+    private encoding?;
+    private _entityHandlers;
+    private _objectHandlers;
+    private _layoutBlocks;
+    private unhandledSections;
+    private unhandledObjects;
+    private unhandledEntities;
+    private unsupportedLineTypes;
+    constructor(encoding?: string);
+    parse(source: string | ArrayBuffer): IDxf;
+    registerEntityHandler(handlerType: new () => IGeometry): void;
+    registerObjectHandler(handlerType: new () => IObjectParser): void;
+    parseSync(source: string | ArrayBuffer): IDxf;
+    parseStream(stream: Readable): Promise<IDxf>;
+    private _parse;
+    /**
+     * Splits a string to string array by line separator, "\r\n", "\r", "\n", etc.
+     * We do this instead of using "String.prototype.split(/\r\n|\r|\n/g)", because it is extreamly slow!
+     */
+    private splitByLineSeparator;
+}

package/dist/types/core/dxf-parser/DxfTextReader.d.ts

@@ -0,0 +1,31 @@
+import { IGroup, DxfBaseReader } from './DxfBaseReader';
+/**
+ *
+ * Based off the AutoCad 2012 DXF Reference
+ * http://images.autodesk.com/adsk/files/autocad_2012_pdf_dxf-reference_enu.pdf
+ *
+ * Reads through an array representing lines of a dxf file. Takes an array and
+ * provides an easy interface to extract group code and value pairs.
+ * @param data - an array where each element represents a line in the dxf file
+ * @constructor
+ */
+export default class DxfTextRender extends DxfBaseReader {
+    private data;
+    constructor(data: string[]);
+    /**
+     * Gets the next group (code, value) from the array. A group is two consecutive elements
+     * in the array. The first is the code, the second is the value.
+     * @returns {{code: Number}|*}
+     */
+    next(): IGroup;
+    /**
+     * Returns true if there is another code/value pair (2 elements in the array).
+     * @returns {boolean}
+     */
+    hasNext(): boolean;
+    /**
+     * Returns true if the scanner is at the end of the array
+     * @returns {boolean}
+     */
+    isEOF(): boolean;
+}

package/dist/types/core/dxf-parser/ParseHelpers.d.ts

@@ -0,0 +1,36 @@
+import { DxfBaseReader, IGroup } from "./DxfBaseReader";
+import { IEntity, IPoint } from "./entities/geomtry";
+import { IObject } from "./objects/common";
+export declare const originalTypes: string[];
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @return {Number} truecolor value as a number
+ */
+export declare function getAcadColor(index: number): number;
+/**
+ * Parses the 2D or 3D coordinate, vector, or point. When complete,
+ * the scanner remains on the last group of the coordinate.
+ * @param {*} scanner
+ */
+export declare function parsePoint(scanner: DxfBaseReader): IPoint;
+/**
+ * Parses 16 numbers as an array. When complete,
+ * the scanner remains on the last group of the value.
+ * @param {*} scanner
+ * @param {*} groupCode
+ */
+export declare function parseMatrix(scanner: DxfBaseReader, groupCode: number): number[];
+/**
+ * Attempts to parse codes common to all entities. Returns true if the group
+ * was handled by this function.
+ * @param {*} entity - the entity currently being parsed
+ * @param {*} curr - the current group being parsed
+ */
+export declare function checkCommonEntityProperties(entity: IEntity, curr: IGroup): boolean;
+/**
+ * Attempts to parse codes common to all objects. Returns true if the group
+ * was handled by this function.
+ * @param {*} object - the object currently being parsed
+ * @param {*} curr - the current group being parsed
+ */
+export declare function checkCommonObjectProperties(object: IObject, curr: IGroup): boolean;

package/dist/types/core/dxf-parser/entities/3dface.d.ts

@@ -0,0 +1,11 @@
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+export interface I3DfaceEntity extends IEntity {
+    shape: boolean;
+    hasContinuousLinetypePattern: boolean;
+    vertices: IPoint[];
+}
+export default class ThreeDface implements IGeometry {
+    ForEntityName: "3DFACE";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): I3DfaceEntity;
+}

package/dist/types/core/dxf-parser/entities/arc.d.ts

@@ -0,0 +1,16 @@
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+export interface IArcEntity extends IEntity {
+    center: IPoint;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    angleLength: number;
+    extrusionDirectionX: number;
+    extrusionDirectionY: number;
+    extrusionDirectionZ: number;
+}
+export default class Arc implements IGeometry {
+    ForEntityName: "ARC";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IArcEntity;
+}