dxf-json 0.0.1

package/src/parser/entities/viewport/index.ts

@@ -0,0 +1,178 @@
+import type { ViewportEntity } from './types';
+import * as helpers from '../../ParseHelpers';
+import { parsePoint } from '../../shared/parsePoint';
+import {
+    pointToVector2,
+    pointToVector3,
+} from '../../../utils';
+import { CommonDxfEntity } from '../shared';
+
+export default class ViewportParser {
+    static ForEntityName = 'VIEWPORT';
+
+    parseEntity(scanner: any, curr: any) {
+        const entity = {} as ViewportEntity;
+
+        while (curr !== 'EOF') {
+            if (curr.code === 0) {
+                scanner.rewind();
+                return entity;
+            }
+
+            if (!parseViewport(entity, scanner, curr)) {
+                helpers.checkCommonEntityProperties(entity as CommonDxfEntity, curr, scanner);
+            }
+            curr = scanner.next();
+        }
+
+        return entity;
+    }
+}
+
+function parseViewport(entity: ViewportEntity, scanner: any, curr: any) {
+    if (curr === 'EOF') return false;
+
+    switch (curr.code) {
+        case 0:
+            return false;
+        case 100:
+            entity.subclassMarker = curr.value;
+            break;
+        case 10:
+            entity.viewportCenter = pointToVector3(parsePoint(scanner));
+            break;
+        case 40:
+            entity.width = curr.value;
+            break;
+        case 41:
+            entity.height = curr.value;
+            break;
+        case 68:
+            entity.status = curr.value;
+            break;
+        case 69:
+            entity.viewportId = curr.value;
+            break;
+        case 12:
+            entity.displayCenter = pointToVector2(parsePoint(scanner));
+            break;
+        case 13:
+            entity.snapBase = pointToVector2(parsePoint(scanner));
+            break;
+        case 14:
+            entity.snapSpacing = pointToVector2(parsePoint(scanner));
+            break;
+        case 15:
+            entity.gridSpacing = pointToVector2(parsePoint(scanner));
+            break;
+        case 16:
+            entity.viewDirection = pointToVector3(parsePoint(scanner));
+            break;
+        case 17:
+            entity.targetPoint = pointToVector3(parsePoint(scanner));
+            break;
+        case 42:
+            entity.perspectiveLensLength = curr.value;
+            break;
+        case 43:
+            entity.frontClipZ = curr.value;
+            break;
+        case 44:
+            entity.backClipZ = curr.value;
+            break;
+        case 45:
+            entity.viewHeight = curr.value;
+            break;
+        case 50:
+            entity.snapAngle = curr.value;
+            break;
+        case 51:
+            entity.viewTwistAngle = curr.value;
+            break;
+        case 72:
+            entity.circleZoomPercent = curr.value;
+            break;
+        case 331:
+            entity.frozenLayerIds ??= [];
+            entity.frozenLayerIds.push(curr.value);
+            break;
+        case 90:
+            entity.statusBitFlags = curr.value;
+            break;
+        case 340:
+            entity.clippingBoundaryId = curr.value;
+            break;
+        case 1:
+            entity.sheetName = curr.value;
+            break;
+        case 281:
+            entity.renderMode = curr.value;
+            break;
+        case 71:
+            entity.ucsPerViewport = curr.value;
+            break;
+        case 110:
+            entity.ucsOrigin = pointToVector3(parsePoint(scanner));
+            break;
+        case 111:
+            entity.ucsXAxis = pointToVector3(parsePoint(scanner));
+            break;
+        case 112:
+            entity.ucsYAxis = pointToVector3(parsePoint(scanner));
+            break;
+        case 345:
+            entity.ucsId = curr.value;
+            break;
+        case 346:
+            entity.ucsBaseId = curr.value;
+            break;
+        case 79:
+            entity.orthographicType = curr.value;
+            break;
+        case 146:
+            entity.elevation = curr.value;
+            break;
+        case 170:
+            entity.shadePlotMode = curr.value;
+            break;
+        case 61:
+            entity.majorGridFrequency = curr.value;
+            break;
+        case 332:
+            entity.backgroundId = curr.value;
+            break;
+        case 333:
+            entity.shadePlotId = curr.value;
+            break;
+        case 348:
+            entity.visualStyleId = curr.value;
+            break;
+        case 292:
+            entity.isDefaultLighting = !!curr.value;
+            break;
+        case 282:
+            entity.defaultLightingType = curr.value;
+            break;
+        case 141:
+            entity.brightness = curr.value;
+            break;
+        case 142:
+            entity.contrast = curr.value;
+            break;
+        case 63: // 타입이 조금씩 다름 셋 중 하나로 표현된다는 뜻인듯
+        case 421:
+        case 431:
+            entity.ambientLightColor = curr.value;
+            break;
+        case 361:
+            entity.sunId = curr.value;
+            break;
+        case 335:
+        case 343:
+        case 344:
+        case 91:
+            entity.softPointer = curr.value;
+            break;
+    }
+    return true;
+}

package/src/parser/entities/viewport/types.ts

@@ -0,0 +1,58 @@
+import {
+    DefaultLightingType,
+    OrthographicType,
+    RenderMode,
+    ShadePlotMode,
+    UCSPerViewport,
+} from '../../../consts';
+import type { Vector2, Vector3 } from 'three';
+
+export interface ViewportEntity {
+    type: 'VIEWPORT';
+    subclassMarker: string;
+    handle?: string;
+    layer?: string;
+    viewportCenter: Vector3; // WCS
+    width: number; // paper space unit
+    height: number; // paper space unit
+    status: number; // -1: ON but off scren, 0: OFF, positive: ON and active
+    viewportId: string;
+    displayCenter: Vector2; // DCS, viewportCenter가 화면 상 displayCenter에 와야된다는 뜻
+    snapBase: Vector2;
+    snapSpacing: Vector2;
+    gridSpacing: Vector2;
+    viewDirection: Vector3; // WCS
+    targetPoint: Vector3; // WCS
+    perspectiveLensLength: number;
+    frontClipZ: number;
+    backClipZ: number;
+    viewHeight: number; // model space unit
+    snapAngle: number;
+    viewTwistAngle: number;
+    circleZoomPercent: number;
+    frozenLayerIds?: string[];
+    statusBitFlags: number;
+    clippingBoundaryId?: string; // viewport가 직사각형 아닌 경우 경계선을 정의하는 entity id
+    sheetName: string;
+    renderMode: RenderMode;
+    ucsPerViewport: UCSPerViewport;
+    ucsOrigin?: Vector3;
+    ucsXAxis?: Vector3;
+    ucsYAxis?: Vector3;
+    ucsId?: string; // ID/handle of AcDbUCSTableRecord if UCS is a named UCS. If not present, then UCS is unnamed
+    ucsBaseId?: string; // ID/handle of AcDbUCSTableRecord of base UCS if UCS is orthographic. If it's not exists, taken to be WORLD
+    orthographicType?: OrthographicType;
+    elevation: number;
+    shadePlotMode: ShadePlotMode;
+    majorGridFrequency: number; // Frequency of major grid lines compared to minor grid lines
+    backgroundId?: string;
+    shadePlotId?: string;
+    visualStyleId?: string;
+    isDefaultLighting: boolean;
+    defaultLightingType?: DefaultLightingType;
+    brightness: number;
+    contrast: number;
+    ambientLightColor?: string;
+    sunId?: string;
+    softPointer?: string;
+}

package/src/parser/filterDummyBlocks.ts

@@ -0,0 +1,49 @@
+import { filter, map } from '@fxts/core';
+import type { ParsedDxf } from './types';
+import type { CommonDxfEntity } from './entities/shared';
+import type { DimensionEntity } from './entities/dimension/types';
+import type { InsertEntity } from './entities/insert';
+import { flooding } from '../utils';
+
+export function filterDummyBlocks(dxf: ParsedDxf): ParsedDxf {
+    // INSERT/DIMENSION 엔티티가 포함된 블록으로 그래프를 만듦
+    const namedBlocks = Object.entries(dxf.blocks);
+    const graph: Record<string, string[]> = {};
+    const insertBlocks = filter(
+        ([_, block]) => block.entities?.some(filterInsertOrDimension),
+        namedBlocks,
+    );
+
+    for (const [name, block] of insertBlocks) {
+        for (const subEntity of block.entities ?? []) {
+            if (!filterInsertOrDimension(subEntity)) continue;
+
+            graph[name] ??= [];
+            graph[name].push(subEntity.name);
+        }
+    }
+
+    // 루트 INSERT/DIMENSION 엔티티에서 접근가능한 모든 블록 이름을 수집
+    const insertEntities = filter(filterInsertOrDimension, dxf.entities);
+    const reachableNames = flooding<string>({
+        seeds: [...map(({ name }) => name, insertEntities)],
+        serializer: (name) => name,
+        spanner: (name) => graph[name] ?? [],
+    }).flat();
+
+    return {
+        ...dxf,
+        blocks: Object.fromEntries(
+            reachableNames.map((name) => [name, dxf.blocks[name]]),
+        ),
+    };
+}
+
+function filterInsertOrDimension(
+    entity: CommonDxfEntity,
+): entity is InsertEntity | DimensionEntity {
+    return (
+        entity.type === 'INSERT' ||
+        (entity.type === 'DIMENSION' && !!(entity as DimensionEntity).name)
+    );
+}

package/src/parser/header/index.ts

@@ -0,0 +1,30 @@
+import type DxfArrayScanner from '../DxfArrayScanner';
+import type { ScannerGroup } from '../DxfArrayScanner';
+import { parsePoint } from '../shared/parsePoint';
+import { isMatched } from '../shared';
+
+// scanner 위치는 읽히기 전이어야 함
+export function parseHeader(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    // interesting variables:
+    //  $ACADVER, $VIEWDIR, $VIEWSIZE, $VIEWCTR, $TDCREATE, $TDUPDATE
+    // http://www.autodesk.com/techpubs/autocad/acadr14/dxf/header_section_al_u05_c.htm
+    // Also see VPORT table entries
+    let currVarName = null;
+    const header: any = {};
+
+    while (!isMatched(curr, 0, 'EOF')) {
+        if (isMatched(curr, 0, 'ENDSEC')) {
+            break;
+        }
+
+        if (curr.code === 9) {
+            currVarName = curr.value;
+        } else if (curr.code === 10) {
+            header[currVarName] = parsePoint(scanner);
+        } else {
+            header[currVarName] = curr.value;
+        }
+        curr = scanner.next();
+    }
+    return header;
+}

package/src/parser/objects/common.ts

@@ -0,0 +1,55 @@
+import { DXFParserSnippet, Identity } from '../shared/parserGenerator';
+
+export const CommonObjectSnippets: DXFParserSnippet[] = [
+    {
+        code: 330,
+        name: 'ownerObjectId',
+        parser: Identity,
+    },
+    {
+        code: 102,
+        // end of ACAD_XDICTIONARY
+    },
+    {
+        code: 360,
+        name: 'ownerDictionaryIdHard',
+        parser: Identity,
+    },
+    {
+        code: 102,
+        // start of ACAD_XDICTIONARY
+    },
+    {
+        code: 102,
+        // end of ACAD_REACTOR
+    },
+    {
+        code: 330,
+        name: 'ownerDictionaryIdSoft',
+        parser: Identity,
+    },
+    {
+        code: 102,
+        // start of ACAD_REACTOR
+    },
+    {
+        code: 102,
+        // end of application defined
+    },
+    {
+        code: 102,
+        // start of application defined
+    },
+    {
+        code: 5,
+        name: 'handle',
+        parser: Identity,
+    },
+];
+
+export interface CommonDXFObject {
+    ownerObjectId: string;
+    ownerDictionaryIdHard: string;
+    ownerDictionaryIdSoft: string;
+    handle: string;
+}

package/src/parser/objects/dictionary.ts

@@ -0,0 +1,61 @@
+import {
+    DXFParserSnippet,
+    Identity,
+    ToBoolean,
+} from '../shared/parserGenerator';
+import type { CommonDXFObject } from './common';
+
+export const DictionarySnippets: DXFParserSnippet[] = [
+    {
+        code: 3,
+        name: 'entries',
+        parser: (curr, scanner) => {
+            const entry = {
+                name: curr.value,
+            } as DictionaryDXFObject['entries'][0];
+
+            curr = scanner.next();
+
+            if (curr.code === 350) {
+                entry.objectId = curr.value;
+            } else {
+                // 만약 본인 토큰 아니면 스트림에 되돌려놔야 함
+                scanner.rewind();
+            }
+
+            return entry;
+        },
+        isMultiple: true,
+    },
+    {
+        code: 281,
+        name: 'recordCloneFlag',
+        parser: Identity,
+    },
+    {
+        code: 280,
+        name: 'isHardOwned',
+        parser: ToBoolean,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+];
+
+export enum RecordCloneFlag {
+    NOT_APPLICABLE = 0,
+    KEEP_EXISTING = 1,
+    USE_CLONE = 2,
+    XREF_VALUE_NAME = 3,
+    VALUE_NAME = 4,
+    UNMANGLE_NAME = 5,
+}
+
+export interface DictionaryDXFObject extends CommonDXFObject {
+    subclassMarker: 'AcDbDictionary';
+    isHardOwned?: boolean;
+    recordCloneFlag: RecordCloneFlag;
+    entries: { name: string; objectId?: string }[];
+}

package/src/parser/objects/index.ts

@@ -0,0 +1,45 @@
+import type DxfArrayScanner from '../DxfArrayScanner';
+import { ScannerGroup } from '../DxfArrayScanner';
+import { createParser, DXFParserSnippet } from '../shared/parserGenerator';
+import { LayoutSnippets } from './layout';
+import { CommonObjectSnippets } from './common';
+import { PlotSettingsSnippets } from './plotSettings';
+import { DictionarySnippets } from './dictionary';
+import { createObjectTree } from './treefy';
+import { classify } from '../../utils';
+
+const ObjectSchemas: Record<string, DXFParserSnippet[]> = {
+    LAYOUT: LayoutSnippets,
+    PLOTSETTINGS: PlotSettingsSnippets,
+    DICTIONARY: DictionarySnippets,
+};
+
+export function parseObjects(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    const result = [] as any[];
+
+    while (curr.code !== 0 || !['EOF', 'ENDSEC'].includes(curr.value)) {
+        const objectName = curr.value as string;
+        const snippets = ObjectSchemas[objectName];
+
+        if (curr.code === 0 && snippets?.length) {
+            const parser = createParser([...CommonObjectSnippets, ...snippets]);
+            const parsedObject = { name: objectName } as any;
+
+            curr = scanner.next();
+
+            if (parser(curr, scanner, parsedObject)) {
+                result.push(parsedObject);
+                curr = scanner.peek();
+            } else {
+                curr = scanner.next();
+            }
+        } else {
+            curr = scanner.next();
+        }
+    }
+
+    return {
+        byName: classify(result, ({ name }) => name),
+        byTree: createObjectTree(result),
+    };
+}

package/src/parser/objects/layout.ts

@@ -0,0 +1,136 @@
+import type { OrthographicType } from '../../consts';
+import type { Point2D, Point3D } from '../../types';
+import {
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+} from '../shared/parserGenerator';
+import { PlotSettingDXFObject, PlotSettingsSnippets } from './plotSettings';
+
+// Snippet이 code별로 스택에 들어가기 때문에 일부로 역순으로 적음
+export const LayoutSnippets: DXFParserSnippet[] = [
+    {
+        code: 333,
+        name: 'shadePlotId',
+        parser: Identity,
+    },
+    {
+        code: 346,
+        name: 'orthographicUcsId',
+        parser: Identity,
+    },
+    {
+        code: 345,
+        name: 'namedUcsId',
+        parser: Identity,
+    },
+    {
+        code: 331,
+        name: 'viewportId',
+        parser: Identity,
+    },
+    {
+        code: 330,
+        name: 'paperSpaceTableId',
+        parser: Identity,
+    },
+    {
+        code: 76,
+        name: 'orthographicType',
+        parser: Identity,
+    },
+    {
+        code: 17,
+        name: 'ucsYAxis',
+        parser: PointParser,
+    },
+    {
+        code: 16,
+        name: 'ucsXAxis',
+        parser: PointParser,
+    },
+    {
+        code: 13,
+        name: 'ucsOrigin',
+        parser: PointParser,
+    },
+    {
+        code: 146,
+        name: 'elevation',
+        parser: Identity,
+    },
+    {
+        code: 15,
+        name: 'maxExtent',
+        parser: PointParser,
+    },
+    {
+        code: 14,
+        name: 'minExtent',
+        parser: PointParser,
+    },
+    {
+        code: 12,
+        name: 'insertionBase',
+        parser: PointParser,
+    },
+    {
+        code: 11,
+        name: 'maxLimit',
+        parser: PointParser,
+    },
+    {
+        code: 10,
+        name: 'minLimit',
+        parser: PointParser,
+    },
+    {
+        code: 71,
+        name: 'tabOrder',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'controlFlag',
+        parser: Identity,
+    },
+    {
+        code: 1,
+        name: 'layoutName',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...PlotSettingsSnippets,
+];
+
+export enum LayoutControlFlag {
+    PSLTSCALE = 1,
+    LIMCHECK = 2,
+}
+
+export interface LayoutDXFObject
+    extends Omit<PlotSettingDXFObject, 'subclassMarker'> {
+    subclassMarker: 'AcDbLayout';
+    layoutName: string;
+    controlFlag: LayoutControlFlag;
+    tabOrder: number;
+    minLimit: Point2D;
+    maxLimit: Point2D;
+    insertionPoint: Point3D;
+    minExtent: Point3D;
+    maxExtent: Point3D;
+    elevation: number;
+    ucsOrigin: Point3D;
+    ucsXAxis: Point3D;
+    ucsYAxis: Point3D;
+    orthographicType: OrthographicType;
+    paperSpaceTableId: string;
+    viewportId: string;
+    namedUcsId?: string;
+    orthographicUcsId?: string;
+    shadePlotId: string;
+}