dxf-json 0.0.1

package/src/parser/entities/hatch/boundaryPathData/edge.ts

@@ -0,0 +1,190 @@
+import { BoundaryPathEdgeType } from '../../../../consts';
+import { parsePoint } from '../../../shared/parsePoint';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+    ToBoolean,
+} from '../../../shared/parserGenerator';
+import { CommonBoundaryPathDataSnippets } from './shared';
+
+export const LineEdgeSnippets: DXFParserSnippet[] = [
+    {
+        code: 11,
+        name: 'end',
+        parser: PointParser,
+    },
+    {
+        code: 10,
+        name: 'start',
+        parser: PointParser,
+    },
+];
+
+export const CircularEdgeSnippets: DXFParserSnippet[] = [
+    {
+        code: 73,
+        name: 'isCCW',
+        parser: ToBoolean,
+    },
+    {
+        code: 51,
+        name: 'endAngle',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'startAngle',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'radius',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'center',
+        parser: PointParser,
+    },
+];
+
+export const EllipseEdgeSnippets: DXFParserSnippet[] = [
+    {
+        code: 73,
+        name: 'isCCW',
+        parser: ToBoolean,
+    },
+    {
+        code: 51,
+        name: 'endAngle',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'startAngle',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'lengthOfMinorAxis',
+        parser: Identity,
+    },
+    {
+        code: 11,
+        name: 'end',
+        parser: PointParser,
+    },
+    {
+        code: 10,
+        name: 'center',
+        parser: PointParser,
+    },
+];
+
+export const SplineEdgeSnippets: DXFParserSnippet[] = [
+    {
+        code: 13,
+        name: 'endTangent',
+        parser: PointParser,
+    },
+    {
+        code: 12,
+        name: 'startTangent',
+        parser: PointParser,
+    },
+    {
+        code: 11,
+        name: 'fitDatum',
+        isMultiple: true,
+        parser: PointParser,
+    },
+    {
+        code: 97,
+        name: 'numberOfFitData',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'controlPoints',
+        isMultiple: true,
+        parser(curr, scanner) {
+            const controlPoint = { ...parsePoint(scanner), weight: 1 };
+            curr = scanner.next();
+
+            if (curr.code === 42) {
+                controlPoint.weight = curr.value;
+            } else {
+                scanner.rewind();
+            }
+
+            return controlPoint;
+        },
+    },
+    {
+        code: 40,
+        name: 'knots',
+        isMultiple: true,
+        parser: Identity,
+    },
+    {
+        code: 96,
+        name: 'numberOfControlPoints',
+        parser: Identity,
+    },
+    {
+        code: 95,
+        name: 'numberOfKnots',
+        parser: Identity,
+    },
+    {
+        code: 74,
+        name: 'isPeriodic',
+        parser: ToBoolean,
+    },
+    {
+        code: 73,
+        name: 'splineFlag',
+        parser: Identity,
+    },
+    {
+        code: 94,
+        name: 'degree',
+        parser: Identity,
+    },
+];
+
+const EdgeSnippetMap = {
+    [BoundaryPathEdgeType.Line]: LineEdgeSnippets,
+    [BoundaryPathEdgeType.Circular]: CircularEdgeSnippets,
+    [BoundaryPathEdgeType.Elliptic]: EllipseEdgeSnippets,
+    [BoundaryPathEdgeType.Spline]: SplineEdgeSnippets,
+};
+
+export const EdgeBoundaryPathDataSnippets: DXFParserSnippet[] = [
+    ...CommonBoundaryPathDataSnippets,
+    {
+        code: 72,
+        name: 'edges',
+        parser(curr, scanner) {
+            const edge = { type: curr.value };
+            const parser = createParser(
+                EdgeSnippetMap[edge.type as BoundaryPathEdgeType],
+            );
+
+            if (!parser) {
+                throw new Error(`Invalid edge type ${edge.type}`);
+            }
+            curr = scanner.next();
+            parser(curr, scanner, edge);
+            return edge;
+        },
+        isMultiple: true,
+    },
+    {
+        code: 93,
+        name: 'numberOfEdges',
+        parser: Identity,
+    },
+];

package/src/parser/entities/hatch/boundaryPathData/index.ts

@@ -0,0 +1,27 @@
+import { BoundaryPathTypeFlag } from '../../../../consts';
+import type DxfArrayScanner from '../../../DxfArrayScanner';
+import type { ScannerGroup } from '../../../DxfArrayScanner';
+import { createParser } from '../../../shared/parserGenerator';
+import { EdgeBoundaryPathDataSnippets } from './edge';
+import { PolylineSnippets } from './polyline';
+
+export function parseBoundaryPathData(
+    curr: ScannerGroup,
+    scanner: DxfArrayScanner,
+) {
+    // assume start with 92
+    const boundaryPathData = {
+        boundaryPathTypeFlag: curr.value,
+    };
+    const isPolyline =
+        boundaryPathData.boundaryPathTypeFlag & BoundaryPathTypeFlag.Polyline;
+
+    curr = scanner.next();
+
+    if (isPolyline) {
+        createParser(PolylineSnippets)(curr, scanner, boundaryPathData);
+        return boundaryPathData;
+    }
+    createParser(EdgeBoundaryPathDataSnippets)(curr, scanner, boundaryPathData);
+    return boundaryPathData;
+}

package/src/parser/entities/hatch/boundaryPathData/polyline.ts

@@ -0,0 +1,43 @@
+import { parsePoint } from '../../../shared/parsePoint';
+import {
+    DXFParserSnippet,
+    Identity,
+    ToBoolean,
+} from '../../../shared/parserGenerator';
+import { CommonBoundaryPathDataSnippets } from './shared';
+
+export const PolylineSnippets: DXFParserSnippet[] = [
+    ...CommonBoundaryPathDataSnippets,
+    {
+        code: 10,
+        name: 'vertices',
+        parser(curr, scanner) {
+            const vertex = { ...parsePoint(scanner), bulge: 0 };
+
+            curr = scanner.next();
+            if (curr.code === 42) {
+                vertex.bulge = curr.value;
+            } else {
+                scanner.rewind();
+            }
+
+            return vertex;
+        },
+        isMultiple: true,
+    },
+    {
+        code: 93,
+        name: 'numberOfVertices',
+        parser: Identity,
+    },
+    {
+        code: 73,
+        name: 'isClosed',
+        parser: ToBoolean,
+    },
+    {
+        code: 72,
+        name: 'hasBulge',
+        parser: ToBoolean,
+    },
+];

package/src/parser/entities/hatch/boundaryPathData/shared.ts

@@ -0,0 +1,16 @@
+import { DXFParserSnippet, Identity } from '../../../shared/parserGenerator';
+
+export const CommonBoundaryPathDataSnippets: DXFParserSnippet[] = [
+    {
+        code: 330,
+        name: 'sourceBoundaryObjects',
+        parser: Identity,
+        isMultiple: true,
+    },
+    {
+        code: 97,
+        name: 'numberOfSourceBoundaryObjects',
+        parser: Identity,
+    },
+    // 92는 분기에 써야해서 외부에서 주입함
+];

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

@@ -0,0 +1,189 @@
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+    ToBoolean,
+} from '../../shared/parserGenerator';
+import { CommonEntitySnippets } from '../shared';
+import { parseBoundaryPathData } from './boundaryPathData';
+import { parsePatternData } from './patternData';
+import type { HatchEntity } from './types';
+
+const DefaultHathEntity = {
+    extrusionDirection: { x: 0, y: 0, z: 1 },
+    gradientRotation: 0,
+    colorTint: 0,
+};
+
+const HatchSnippet: DXFParserSnippet[] = [
+    {
+        // Unused - String (default = LINEAR)
+        code: 470,
+    },
+    {
+        // Unused - Reserved for future use:
+        code: 463,
+    },
+    {
+        code: 462,
+        name: 'colorTint',
+        parser: Identity,
+    },
+    {
+        code: 461,
+        name: 'gradientDefinition',
+        parser: Identity,
+    },
+    {
+        code: 460,
+        name: 'gradientRotation', // radian
+        parser: Identity,
+    },
+    {
+        code: 453,
+        name: 'numberOfColors',
+        parser: Identity,
+    },
+    {
+        code: 452,
+        name: 'gradientColorFlag',
+        parser: Identity,
+    },
+    {
+        // Unused - Zero is reserved for future use
+        code: 451,
+    },
+    {
+        code: 450,
+        name: 'gradientFlag',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'seedPoints',
+        parser: PointParser,
+        isMultiple: true,
+    },
+    {
+        // Unused - Number of degenerate boundary paths
+        code: 99,
+    },
+    {
+        code: 11,
+        name: 'offsetVector',
+        parser: PointParser,
+    },
+    {
+        code: 98,
+        name: 'numberOfSeedPoints',
+        parser: Identity,
+    },
+    {
+        code: 47,
+        name: 'pixelSize',
+        parser: Identity,
+    },
+    {
+        code: 53,
+        name: 'definitionLines',
+        parser: parsePatternData,
+        isMultiple: true,
+    },
+    {
+        code: 78,
+        name: 'numberOfDefinitionLines',
+        parser: Identity,
+    },
+    {
+        code: 77,
+        name: 'isDouble',
+        parser: ToBoolean,
+    },
+    {
+        code: 73,
+        name: 'isAnnotated',
+        parser: ToBoolean,
+    },
+    {
+        code: 41,
+        name: 'patternScale',
+        parser: Identity,
+    },
+    {
+        code: 52,
+        name: 'patternAngle',
+        parser: Identity,
+    },
+    {
+        code: 76,
+        name: 'patternType',
+        parser: Identity,
+    },
+    {
+        code: 75,
+        name: 'hatchStyle',
+        parser: Identity,
+    },
+    {
+        code: 92,
+        name: 'boundaryPaths',
+        parser: parseBoundaryPathData,
+        isMultiple: true,
+    },
+    {
+        code: 91,
+        name: 'numberOfBoundaryPaths',
+        parser: Identity,
+    },
+    {
+        code: 71,
+        name: 'associativity',
+        parser: Identity,
+    },
+    {
+        code: 63,
+        name: 'patternFillColor',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'solidFill',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'patternName',
+        parser: Identity,
+    },
+    {
+        code: 210,
+        name: 'extrusionDirection',
+        parser: PointParser,
+    },
+    {
+        code: 10,
+        name: 'elevationPoint',
+        parser: PointParser,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+        pushContext: true,
+    },
+    ...CommonEntitySnippets,
+];
+
+export class HatchEntityParser {
+    static ForEntityName = 'HATCH';
+    private parser = createParser(HatchSnippet, DefaultHathEntity);
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as any;
+        this.parser(curr, scanner, entity);
+        return entity as HatchEntity;
+    }
+}

package/src/parser/entities/hatch/patternData.ts

@@ -0,0 +1,57 @@
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+} from '../../shared/parserGenerator';
+
+const PatternDataSnippets: DXFParserSnippet[] = [
+    {
+        code: 49,
+        name: 'dashLengths',
+        parser: Identity,
+        isMultiple: true,
+    },
+    {
+        code: 79,
+        name: 'numberOfDashLengths',
+        parser: Identity,
+    },
+    {
+        code: 45,
+        name: 'offset',
+        parser: pseudoPointParser,
+    },
+    {
+        code: 43,
+        name: 'base',
+        parser: pseudoPointParser,
+    },
+    {
+        code: 53,
+        name: 'angle',
+        parser: Identity,
+    },
+];
+
+function pseudoPointParser(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    const nextCode = curr.code + 1;
+    const offset = {
+        x: curr.value,
+        y: 1,
+    };
+    curr = scanner.next();
+    if (curr.code === nextCode) {
+        offset.y = curr.value;
+    } else {
+        scanner.rewind();
+    }
+    return offset;
+}
+
+export function parsePatternData(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    const patternData: any = {};
+    createParser(PatternDataSnippets)(curr, scanner, patternData);
+    return patternData;
+}

package/src/parser/entities/hatch/types/boundaryPath.ts

@@ -0,0 +1,72 @@
+import type { BoundaryPathEdgeType } from '../../../../consts/hatch';
+import type { Point2D } from '../../../../types';
+
+interface BoundaryPathBase {
+    boundaryPathTypeFlag: number; // bit combination of BoundaryPathTypeFlag
+    numberOfSourceBoundaryObjects: number;
+    sourceBoundaryObjects: string[];
+}
+
+export interface PolylineBoundaryPath extends BoundaryPathBase {
+    hasBulge: boolean;
+    isClosed: boolean;
+    numberOfVertices: number;
+    vertices: (Point2D & {
+        bulge: number;
+    })[];
+}
+
+export interface EdgeBoundaryPath<EdgeType extends BoundaryPathEdge>
+    extends BoundaryPathBase {
+    numberOfEdges: number;
+    edges: EdgeType[];
+}
+
+interface BoundaryPathEdgeCommon {
+    type: BoundaryPathEdgeType;
+}
+
+export type BoundaryPath =
+    | PolylineBoundaryPath
+    | EdgeBoundaryPath<BoundaryPathEdge>;
+
+export interface LineEdge extends BoundaryPathEdgeCommon {
+    start: Point2D;
+    end: Point2D;
+}
+
+export interface ArcEdge extends BoundaryPathEdgeCommon {
+    center: Point2D;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    isCCW?: boolean;
+}
+
+export interface EllipseEdge extends BoundaryPathEdgeCommon {
+    center: Point2D;
+    // end point of major axis relative to center
+    end: Point2D;
+    lengthOfMinorAxis: number;
+    startAngle: number;
+    endAngle: number;
+    isCCW?: boolean;
+}
+
+export interface SplineEdge extends BoundaryPathEdgeCommon {
+    degree: number;
+    splineFlag: number;
+    isPeriodic?: boolean;
+    numberOfKnots: number;
+    numberOfControlPoints: number;
+    knots: number[];
+    controlPoints: (Point2D & {
+        weight?: number; // default = 1
+    })[];
+    numberOfFitData: number;
+    fitDatum: Point2D[];
+    startTangent: Point2D;
+    endTangent: Point2D;
+}
+
+export type BoundaryPathEdge = LineEdge | ArcEdge | EllipseEdge | SplineEdge;

package/src/parser/entities/hatch/types/definitionLine.ts

@@ -0,0 +1,14 @@
+import { Point2D } from '../../../../types';
+
+/*
+ * offset이란 선과 선 사이의 간격을 만드는 벡터이다.
+ * 그런데 이게 무조건 y축과 평행하다는 보장은 없다.
+ * (angle과도 무관하다)
+ */
+export interface HatchDefinitionLine {
+    angle: number; // degree
+    base: Point2D;
+    offset: Point2D;
+    numberOfDashLengths: number;
+    dashLengths: number[];
+}

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

@@ -0,0 +1,47 @@
+import type {
+    HatchAssociativity,
+    HatchGradientColorFlag,
+    HatchGradientFlag,
+    HatchPatternType,
+    HatchSolidFill,
+    HatchStyle,
+} from '../../../../consts/hatch';
+import type { Point3D } from '../../../../types';
+import type { CommonDxfEntity } from '../../shared';
+import type { BoundaryPath } from './boundaryPath';
+import type { HatchDefinitionLine } from './definitionLine';
+
+interface HatchEntityBase extends CommonDxfEntity {
+    type: 'HATCH';
+    subclassMarker: 'AcDbHatch';
+    elevationPoint: Point3D;
+    extrusionDirection?: Point3D;
+    patternName: string;
+    solidFill: HatchSolidFill;
+    patternFillColor: any; // ?
+    associativity: HatchAssociativity;
+    numberOfBoundaryPaths: number;
+    boundaryPaths: BoundaryPath[];
+    hatchStyle: HatchStyle;
+    patternType: HatchPatternType;
+    patternAngle?: number; // Pattern Fill Only
+    patternScale?: number; // Pattern Fill Only
+    numberOfDefinitionLines: number;
+    definitionLines: HatchDefinitionLine[];
+    pixelSize: number;
+    numberOfSeedPoints: number;
+    offsetVector?: Point3D;
+    seedPoints?: Point3D[];
+    gradientFlag?: HatchGradientFlag;
+}
+
+export interface GradientHatchEntity extends HatchEntityBase {
+    gradientFlag: HatchGradientFlag.Gradient;
+    gradientColorFlag: HatchGradientColorFlag;
+    numberOfColors: 0 | 2;
+    gradientRotation?: number; // radian, default = 0
+    gradientDefinition: number; // 0 ~ 1
+    colorTint?: number; // 0 ~ 1, default = 0
+}
+
+export type HatchEntity = GradientHatchEntity | HatchEntityBase;

package/src/parser/entities/hatch/types/index.ts

@@ -0,0 +1,3 @@
+export * from './boundaryPath';
+export * from './definitionLine';
+export * from './hatch';