981 lines
36 KiB
TypeScript
981 lines
36 KiB
TypeScript
import {Readable} from 'stream';
|
|
import DxfArrayScanner, {IGroup} from './DxfArrayScanner';
|
|
import AUTO_CAD_COLOR_INDEX from './AutoCadColorIndex';
|
|
import dimStyleCodes from './DimStyleCodes';
|
|
|
|
import Face from './entities/3dface';
|
|
import Arc from './entities/arc';
|
|
import AttDef from './entities/attdef';
|
|
import Attribute from './entities/attribute'
|
|
import Circle from './entities/circle';
|
|
import Dimension from './entities/dimension';
|
|
import Ellipse from './entities/ellipse';
|
|
import Hatch from './entities/hatch';
|
|
import Insert from './entities/insert';
|
|
import Line from './entities/line';
|
|
import LWPolyline from './entities/lwpolyline';
|
|
import MText from './entities/mtext';
|
|
import Point from './entities/point';
|
|
import Polyline from './entities/polyline';
|
|
import Solid from './entities/solid';
|
|
import Spline from './entities/spline';
|
|
import Text from './entities/text';
|
|
import Vertex from './entities/vertex';
|
|
|
|
import log from '@/utils/log/Logger';
|
|
import IGeometry, {EntityName, IEntity, IPoint} from './entities/geomtry';
|
|
|
|
export interface IBlock {
|
|
entities: IEntity[];
|
|
type: number;
|
|
ownerHandle: string;
|
|
// entities: any[];
|
|
xrefPath: string;
|
|
name: string;
|
|
name2: string;
|
|
handle: string;
|
|
layer: string;
|
|
position: IPoint;
|
|
paperSpace: boolean;
|
|
}
|
|
|
|
export interface IViewPort {
|
|
name: string;
|
|
lowerLeftCorner: IPoint;
|
|
upperRightCorner: IPoint;
|
|
center: IPoint;
|
|
snapBasePoint: IPoint;
|
|
snapSpacing: IPoint;
|
|
gridSpacing: IPoint;
|
|
viewDirectionFromTarget: IPoint;
|
|
viewTarget: IPoint;
|
|
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;
|
|
viewMode: string;
|
|
}
|
|
|
|
export interface IViewPortTableDefinition {
|
|
tableRecordsProperty: 'viewPorts';
|
|
tableName: 'viewPort';
|
|
dxfSymbolName: 'VPORT';
|
|
|
|
parseTableRecords(): IViewPort[];
|
|
}
|
|
|
|
export interface ILineType {
|
|
name: string;
|
|
description: string;
|
|
pattern: string[];
|
|
patternLength: number;
|
|
}
|
|
|
|
export interface ILineTypeTableDefinition {
|
|
tableRecordsProperty: 'lineTypes';
|
|
tableName: 'lineType';
|
|
dxfSymbolName: 'LTYPE';
|
|
|
|
parseTableRecords(): Record<string, ILineType>;
|
|
}
|
|
|
|
export interface ILayer {
|
|
name: string;
|
|
visible: boolean;
|
|
colorIndex: number;
|
|
color: number;
|
|
frozen: boolean;
|
|
}
|
|
|
|
export interface ILayerTableDefinition {
|
|
tableRecordsProperty: 'layers';
|
|
tableName: 'layer';
|
|
dxfSymbolName: 'LAYER';
|
|
|
|
parseTableRecords(): Record<string, ILayer>;
|
|
}
|
|
|
|
export interface ITableDefinitions {
|
|
VPORT: IViewPortTableDefinition;
|
|
LTYPE: ILineTypeTableDefinition;
|
|
LAYER: ILayerTableDefinition;
|
|
DIMSTYLE: any;
|
|
STYLE: any;
|
|
}
|
|
|
|
export interface IBaseTable {
|
|
handle: string;
|
|
ownerHandle: string;
|
|
}
|
|
|
|
export interface IViewPortTable extends IBaseTable {
|
|
viewPorts: IViewPort[];
|
|
}
|
|
|
|
export interface ILayerTypesTable extends IBaseTable {
|
|
lineTypes: Record<string, ILineType>;
|
|
}
|
|
|
|
export interface ILayersTable extends IBaseTable {
|
|
layers: Record<string, ILayer>;
|
|
}
|
|
|
|
export interface ITables {
|
|
viewPort: IViewPortTable;
|
|
lineType: ILayerTypesTable;
|
|
layer: ILayersTable;
|
|
}
|
|
|
|
export type ITable = IViewPortTable | ILayerTypesTable | ILayersTable;
|
|
|
|
export interface IDxf {
|
|
header: Record<string, IPoint | number>;
|
|
entities: IEntity[];
|
|
blocks: Record<string, IBlock>;
|
|
tables: ITables;
|
|
}
|
|
|
|
function registerDefaultEntityHandlers(dxfParser: DxfParser) {
|
|
// 这里支持的实体(一些实体代码仍然被重构到这个流中)
|
|
dxfParser.registerEntityHandler(Face);
|
|
dxfParser.registerEntityHandler(Arc);
|
|
dxfParser.registerEntityHandler(AttDef);
|
|
dxfParser.registerEntityHandler(Attribute);
|
|
dxfParser.registerEntityHandler(Circle);
|
|
dxfParser.registerEntityHandler(Dimension);
|
|
dxfParser.registerEntityHandler(Ellipse);
|
|
dxfParser.registerEntityHandler(Hatch);
|
|
dxfParser.registerEntityHandler(Insert);
|
|
dxfParser.registerEntityHandler(Line);
|
|
dxfParser.registerEntityHandler(LWPolyline);
|
|
dxfParser.registerEntityHandler(MText);
|
|
dxfParser.registerEntityHandler(Point);
|
|
dxfParser.registerEntityHandler(Polyline);
|
|
dxfParser.registerEntityHandler(Solid);
|
|
dxfParser.registerEntityHandler(Spline);
|
|
dxfParser.registerEntityHandler(Text);
|
|
dxfParser.registerEntityHandler(Vertex);
|
|
}
|
|
|
|
export default class DxfParser {
|
|
private _entityHandlers = {} as Record<EntityName, IGeometry>;
|
|
|
|
constructor() {
|
|
registerDefaultEntityHandlers(this);
|
|
}
|
|
|
|
public parse(source: string | Readable) {
|
|
if (typeof source === 'string') {
|
|
return this._parse(source);
|
|
} else {
|
|
log.error('无法读取dxf源的类型: `' + typeof (source));
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public registerEntityHandler(handlerType: new () => IGeometry) {
|
|
const instance = new handlerType();
|
|
this._entityHandlers[instance.ForEntityName] = instance;
|
|
}
|
|
|
|
public parseSync(source: string) {
|
|
return this.parse(source);
|
|
}
|
|
|
|
public parseStream(stream: Readable) {
|
|
let dxfString = "";
|
|
const self = this;
|
|
return new Promise<IDxf>((res, rej) => {
|
|
|
|
stream.on('data', (chunk) => {
|
|
dxfString += chunk;
|
|
});
|
|
stream.on('end', () => {
|
|
try {
|
|
res(self._parse(dxfString));
|
|
} catch (err) {
|
|
rej(err);
|
|
}
|
|
});
|
|
stream.on('error', (err) => {
|
|
rej(err);
|
|
});
|
|
});
|
|
}
|
|
|
|
private _parse(dxfString: string) {
|
|
const dxf = {} as IDxf;
|
|
let lastHandle = 0;
|
|
const dxfLinesArray = dxfString.split(/\r\n|\r|\n/g);
|
|
|
|
const scanner = new DxfArrayScanner(dxfLinesArray);
|
|
if (!scanner.hasNext()) {
|
|
log.error('当前 CAD 文件为空文件');
|
|
return dxf;
|
|
}
|
|
|
|
const self = this;
|
|
let curr: IGroup;
|
|
|
|
function parseAll() {
|
|
curr = scanner.next();
|
|
while (!scanner.isEOF()) {
|
|
if (curr.code === 0 && curr.value === 'SECTION') {
|
|
curr = scanner.next();
|
|
|
|
// 确保我们读的是段代码
|
|
if (curr.code !== 2) {
|
|
log.error(`Unexpected code ${debugCode(curr) } after 0:SECTION`);
|
|
curr = scanner.next();
|
|
continue;
|
|
}
|
|
|
|
if (curr.value === 'HEADER') {
|
|
dxf.header = parseHeader();
|
|
} else if (curr.value === 'BLOCKS') {
|
|
dxf.blocks = parseBlocks();
|
|
} else if (curr.value === 'ENTITIES') {
|
|
dxf.entities = parseEntities(false);
|
|
} else if (curr.value === 'TABLES') {
|
|
dxf.tables = parseTables();
|
|
} else if (curr.value === 'EOF') {
|
|
log.debug('EOF');
|
|
} else {
|
|
log.warn('Skipping section ' + curr.value);
|
|
}
|
|
} else {
|
|
curr = scanner.next();
|
|
}
|
|
// If is a new section
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return {object} header
|
|
*/
|
|
function parseHeader() {
|
|
// 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 as null | string;
|
|
let currVarValue = null as null | IPoint | number;
|
|
const header = {} as Record<string, IPoint | number>;
|
|
// loop through header variables
|
|
curr = scanner.next();
|
|
|
|
while (true) {
|
|
if (groupIs(curr, 0, 'ENDSEC')) {
|
|
if (currVarName) header[currVarName as string] = currVarValue!;
|
|
break;
|
|
} else if (curr.code === 9) {
|
|
if (currVarName) header[currVarName as string] = currVarValue!;
|
|
currVarName = curr.value as string;
|
|
// Filter here for particular variables we are interested in
|
|
} else {
|
|
if (curr.code === 10) {
|
|
currVarValue = {x: curr.value as number} as IPoint;
|
|
} else if (curr.code === 20) {
|
|
(currVarValue as IPoint).y = curr.value as number;
|
|
} else if (curr.code === 30) {
|
|
(currVarValue as IPoint).z = curr.value as number;
|
|
} else {
|
|
currVarValue = curr.value as number;
|
|
}
|
|
}
|
|
curr = scanner.next();
|
|
}
|
|
// console.log(util.inspect(header, { colors: true, depth: null }));
|
|
curr = scanner.next(); // swallow up ENDSEC
|
|
return header;
|
|
}
|
|
|
|
function parseBlocks() {
|
|
const blocks = {} as Record<string, IBlock>;
|
|
|
|
curr = scanner.next();
|
|
|
|
while (curr.value !== 'EOF') {
|
|
if (groupIs(curr, 0, 'ENDSEC')) {
|
|
break;
|
|
}
|
|
|
|
if (groupIs(curr, 0, 'BLOCK')) {
|
|
const block = parseBlock();
|
|
ensureHandle(block);
|
|
if (!block.name) {
|
|
// log.error('block with handle "' + block.handle + '" is missing a name.');
|
|
// block.name = 'InvalidBlockName-' + block.ownerHandle;
|
|
}else{
|
|
blocks[block.name] = block;
|
|
}
|
|
} else {
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
}
|
|
}
|
|
return blocks;
|
|
}
|
|
|
|
function parseBlock() {
|
|
const block = {} as IBlock;
|
|
curr = scanner.next();
|
|
|
|
while (curr.value !== 'EOF') {
|
|
switch (curr.code) {
|
|
case 1:
|
|
block.xrefPath = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 2:
|
|
block.name = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 3:
|
|
block.name2 = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 5:
|
|
block.handle = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 8:
|
|
block.layer = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 10:
|
|
block.position = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 67:
|
|
block.paperSpace = (curr.value && curr.value == 1) ? true : false;
|
|
curr = scanner.next();
|
|
break;
|
|
case 70:
|
|
if (curr.value != 0) {
|
|
//if(curr.value & BLOCK_ANONYMOUS_FLAG) console.log(' Anonymous block');
|
|
//if(curr.value & BLOCK_NON_CONSTANT_FLAG) console.log(' Non-constant attributes');
|
|
//if(curr.value & BLOCK_XREF_FLAG) console.log(' Is xref');
|
|
//if(curr.value & BLOCK_XREF_OVERLAY_FLAG) console.log(' Is xref overlay');
|
|
//if(curr.value & BLOCK_EXTERNALLY_DEPENDENT_FLAG) console.log(' Is externally dependent');
|
|
//if(curr.value & BLOCK_RESOLVED_OR_DEPENDENT_FLAG) console.log(' Is resolved xref or dependent of an xref');
|
|
//if(curr.value & BLOCK_REFERENCED_XREF) console.log(' This definition is a referenced xref');
|
|
block.type = curr.value as number;
|
|
}
|
|
curr = scanner.next();
|
|
break;
|
|
case 100:
|
|
// ignore class markers
|
|
curr = scanner.next();
|
|
break;
|
|
case 330:
|
|
block.ownerHandle = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
if (curr.value == 'ENDBLK')
|
|
break;
|
|
block.entities = parseEntities(true);
|
|
break;
|
|
default:
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
}
|
|
|
|
if (groupIs(curr, 0, 'ENDBLK')) {
|
|
curr = scanner.next();
|
|
break;
|
|
}
|
|
}
|
|
return block;
|
|
}
|
|
|
|
/**
|
|
* parseTables
|
|
* @return {Object} Object representing tables
|
|
*/
|
|
function parseTables() {
|
|
const tables = {} as ITables;
|
|
curr = scanner.next();
|
|
while (curr.value !== 'EOF') {
|
|
if (groupIs(curr, 0, 'ENDSEC'))
|
|
break;
|
|
|
|
if (groupIs(curr, 0, 'TABLE')) {
|
|
curr = scanner.next();
|
|
|
|
const tableDefinition = tableDefinitions[curr.value as keyof ITableDefinitions];
|
|
if (tableDefinition) {
|
|
tables[tableDefinitions[curr.value as keyof ITableDefinitions].tableName] = parseTable(curr);
|
|
} else {
|
|
// log.debug('Unhandled Table ' + curr.value);
|
|
}
|
|
} else {
|
|
// else ignored
|
|
curr = scanner.next();
|
|
}
|
|
}
|
|
|
|
curr = scanner.next();
|
|
return tables;
|
|
}
|
|
|
|
const END_OF_TABLE_VALUE = 'ENDTAB';
|
|
|
|
function parseTable<T extends IBaseTable = ITable>(group: IGroup) {
|
|
const tableDefinition = tableDefinitions[group.value as keyof ITableDefinitions];
|
|
const table = {} as T;
|
|
let expectedCount = 0;
|
|
|
|
curr = scanner.next();
|
|
while (!groupIs(curr, 0, END_OF_TABLE_VALUE)) {
|
|
switch (curr.code) {
|
|
case 5:
|
|
table.handle = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 330:
|
|
table.ownerHandle = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 100:
|
|
if (curr.value === 'AcDbSymbolTable') {
|
|
// ignore
|
|
curr = scanner.next();
|
|
} else {
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
}
|
|
break;
|
|
case 70:
|
|
expectedCount = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
if (curr.value === tableDefinition.dxfSymbolName) {
|
|
table[tableDefinition.tableRecordsProperty] = tableDefinition.parseTableRecords();
|
|
} else {
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
}
|
|
break;
|
|
default:
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
}
|
|
}
|
|
const tableRecords = table[tableDefinition.tableRecordsProperty];
|
|
if (tableRecords) {
|
|
let actualCount = (() => {
|
|
if (tableRecords.constructor === Array) {
|
|
return tableRecords.length;
|
|
} else if (typeof (tableRecords) === 'object') {
|
|
return Object.keys(tableRecords).length;
|
|
}
|
|
return undefined;
|
|
})();
|
|
if (expectedCount !== actualCount) log.warn('Parsed ' + actualCount + ' ' + tableDefinition.dxfSymbolName + '\'s but expected ' + expectedCount);
|
|
}
|
|
curr = scanner.next();
|
|
return table;
|
|
}
|
|
|
|
function parseViewPortRecords() {
|
|
const viewPorts = [] as IViewPort[]; // 多个表项可以具有相同的名称，表示多个视区配置
|
|
let viewPort = {} as IViewPort;
|
|
|
|
curr = scanner.next();
|
|
while (!groupIs(curr, 0, END_OF_TABLE_VALUE)) {
|
|
|
|
switch (curr.code) {
|
|
case 2: // 视口名
|
|
viewPort.name = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 10: // 视口的左下角
|
|
viewPort.lowerLeftCorner = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 11: // 视口右上角
|
|
viewPort.upperRightCorner = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 12: // 视口中心点（在 DCS 中）
|
|
viewPort.center = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 13: // 捕捉基点（在 DCS 中）
|
|
viewPort.snapBasePoint = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 14: // 捕捉间距 X 和 Y
|
|
viewPort.snapSpacing = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 15: // 栅格间距 X 和 Y
|
|
viewPort.gridSpacing = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 16: // 相对于目标点的观察方向（在 WCS 中）
|
|
viewPort.viewDirectionFromTarget = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 17: //观察目标点（在 WCS 中）
|
|
viewPort.viewTarget = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 42: // 焦距
|
|
viewPort.lensLength = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 43: //前向剪裁平面（距目标点的偏移）
|
|
viewPort.frontClippingPlane = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 44: // 后向剪裁平面（距目标点的偏移）
|
|
viewPort.backClippingPlane = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 45: // 视图高度
|
|
viewPort.viewHeight = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 50: // 捕捉旋转角度
|
|
viewPort.snapRotationAngle = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 51: // 视图扭转角度
|
|
viewPort.viewTwistAngle = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 71: // 视图模式（参见 VIEWMODE 系统变量）
|
|
viewPort.viewMode = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 79: // UCS 的正交类型 0 = UCS 不正交 1 = 俯视图；2 = 仰视图 3 = 主视图；4 = 后视图 5 = 左视图；6 = 右视图
|
|
viewPort.orthographicType = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 110: // UCS 原点（在 DCS 中）
|
|
viewPort.ucsOrigin = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 111: // UCS X 轴
|
|
viewPort.ucsXAxis = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 112: // UCS Y 轴
|
|
viewPort.ucsYAxis = parsePoint(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
case 281:
|
|
/*
|
|
* 渲染模式： 0 = 二维优化（传统二维） 1 = 线框图 2 = 隐藏线 3 = 平面着色 4 = 体着色 5 = 带线框平面着色 6 = 带线框体着色
|
|
* 所有非二维优化渲染模式均使用新三维图形管道。这些值直接与 SHADEMODE 命令和 AcDbAbstractViewTableRecord::RenderMode 枚举相对应
|
|
*/
|
|
viewPort.renderMode = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 292:
|
|
viewPort.defaultLightingOn = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 330:
|
|
viewPort.ownerHandle = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 63: // These are all ambient color. Perhaps should be a gradient when multiple are set.
|
|
case 421:
|
|
case 431:
|
|
viewPort.ambientColor = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
// New ViewPort
|
|
if (curr.value === 'VPORT') {
|
|
viewPorts.push(viewPort);
|
|
viewPort = {} as IViewPort;
|
|
curr = scanner.next();
|
|
}
|
|
break;
|
|
default:
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
}
|
|
}
|
|
// Note: do not call scanner.next() here,
|
|
// parseTable() needs the current group
|
|
viewPorts.push(viewPort);
|
|
|
|
return viewPorts;
|
|
}
|
|
|
|
function parseLineTypes() {
|
|
const ltypes = {} as Record<string, ILineType>;
|
|
let ltype = {} as ILineType;
|
|
let length = 0;
|
|
let ltypeName: string;
|
|
|
|
curr = scanner.next();
|
|
while (!groupIs(curr, 0, 'ENDTAB')) {
|
|
|
|
switch (curr.code) {
|
|
case 2:
|
|
ltype.name = curr.value as string;
|
|
ltypeName = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 3:
|
|
ltype.description = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 73: // Number of elements for this line type (dots, dashes, spaces);
|
|
length = curr.value as number;
|
|
if (length > 0) ltype.pattern = [];
|
|
curr = scanner.next();
|
|
break;
|
|
case 40: // total pattern length
|
|
ltype.patternLength = curr.value as number;
|
|
curr = scanner.next();
|
|
break;
|
|
case 49:
|
|
ltype.pattern.push(curr.value as string);
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
if (length > 0 && length !== ltype.pattern.length) log.warn('lengths do not match on LTYPE pattern');
|
|
ltypes[ltypeName!] = ltype;
|
|
ltype = {} as ILineType;
|
|
curr = scanner.next();
|
|
break;
|
|
default:
|
|
curr = scanner.next();
|
|
}
|
|
}
|
|
|
|
ltypes[ltypeName!] = ltype;
|
|
return ltypes;
|
|
}
|
|
|
|
function parseLayers() {
|
|
const layers = {} as Record<string, ILayer>;
|
|
let layer = {} as ILayer;
|
|
let layerName: string | undefined;
|
|
|
|
curr = scanner.next();
|
|
while (!groupIs(curr, 0, 'ENDTAB')) {
|
|
|
|
switch (curr.code) {
|
|
case 2: // layer name
|
|
layer.name = curr.value as string;
|
|
layerName = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 62: // color, visibility
|
|
// @ts-ignore
|
|
layer.visible = curr.value >= 0;
|
|
// TODO 0 and 256 are BYBLOCK and BYLAYER respectively. Need to handle these values for layers?.
|
|
layer.colorIndex = Math.abs(curr.value as number);
|
|
layer.color = getAcadColor(layer.colorIndex as number);
|
|
curr = scanner.next();
|
|
break;
|
|
case 70: // frozen layer
|
|
layer.frozen = (((curr.value as number) & 1) != 0 || ((curr.value as number) & 2) != 0);
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
// New Layer
|
|
if (curr.value === 'LAYER') {
|
|
layers[layerName!] = layer;
|
|
layer = {} as ILayer;
|
|
layerName = undefined;
|
|
curr = scanner.next();
|
|
}
|
|
break;
|
|
default:
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
}
|
|
}
|
|
// Note: do not call scanner.next() here,
|
|
// parseLayerTable() needs the current group
|
|
layers[layerName!] = layer;
|
|
|
|
return layers;
|
|
}
|
|
|
|
function parseDimStyles() {
|
|
let dimStyles = {},
|
|
styleName: string | undefined,
|
|
style: any = {};
|
|
|
|
curr = scanner.next();
|
|
while (!groupIs(curr, 0, 'ENDTAB')) {
|
|
if (dimStyleCodes.has(curr.code)) {
|
|
style[dimStyleCodes.get(curr.code) as string] = curr.value
|
|
curr = scanner.next();
|
|
} else {
|
|
switch (curr.code) {
|
|
case 2: // style name
|
|
style.name = curr.value;
|
|
styleName = curr.value as string;
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
// New style
|
|
if (curr.value === 'DIMSTYLE') {
|
|
// @ts-ignore
|
|
dimStyles[styleName] = style;
|
|
style = {};
|
|
styleName = undefined;
|
|
curr = scanner.next();
|
|
}
|
|
break;
|
|
default:
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Note: do not call scanner.next() here,
|
|
// parseLayerTable() needs the current group
|
|
dimStyles[styleName as string] = style;
|
|
|
|
return dimStyles;
|
|
}
|
|
|
|
const parseStyles = function () {
|
|
const styles = {};
|
|
let style: any = {};
|
|
let styleName;
|
|
|
|
curr = scanner.next();
|
|
while (!groupIs(curr, 0, END_OF_TABLE_VALUE)) {
|
|
switch (curr.code) {
|
|
case 100:
|
|
style.subClassMarker = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 2:
|
|
style.styleName = curr.value;
|
|
styleName = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 70:
|
|
style.standardFlag = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 40:
|
|
style.fixedTextHeight = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 41:
|
|
style.widthFactor = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 50:
|
|
style.obliqueAngle = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 71:
|
|
style.textGenerationFlag = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 42:
|
|
style.lastHeight = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 3:
|
|
style.font = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 4:
|
|
style.bigFont = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 1071:
|
|
style.extendedFont = curr.value;
|
|
curr = scanner.next();
|
|
break;
|
|
case 0:
|
|
if (curr.value === 'STYLE') {
|
|
styles[styleName] = style;
|
|
style = {};
|
|
styleName = undefined;
|
|
curr = scanner.next();
|
|
}
|
|
break;
|
|
default:
|
|
logUnhandledGroup(curr);
|
|
curr = scanner.next();
|
|
break;
|
|
}
|
|
}
|
|
styles[styleName] = style;
|
|
return styles;
|
|
};
|
|
|
|
const tableDefinitions = {
|
|
VPORT: {
|
|
tableRecordsProperty: 'viewPorts',
|
|
tableName: 'viewPort',
|
|
dxfSymbolName: 'VPORT',
|
|
parseTableRecords: parseViewPortRecords
|
|
},
|
|
LTYPE: {
|
|
tableRecordsProperty: 'lineTypes',
|
|
tableName: 'lineType',
|
|
dxfSymbolName: 'LTYPE',
|
|
parseTableRecords: parseLineTypes
|
|
},
|
|
LAYER: {
|
|
tableRecordsProperty: 'layers',
|
|
tableName: 'layer',
|
|
dxfSymbolName: 'LAYER',
|
|
parseTableRecords: parseLayers
|
|
},
|
|
DIMSTYLE: {
|
|
tableRecordsProperty: 'dimStyles',
|
|
tableName: 'dimstyle',
|
|
dxfSymbolName: 'DIMSTYLE',
|
|
parseTableRecords: parseDimStyles
|
|
},
|
|
STYLE: {
|
|
tableRecordsProperty: 'styles',
|
|
tableName: 'style',
|
|
dxfSymbolName: 'STYLE',
|
|
parseTableRecords: parseStyles,
|
|
},
|
|
} as ITableDefinitions;
|
|
|
|
/**
|
|
* 在解析器首次读取0:ENTITIES组后调用。扫描器应该已经在第一个实体的开始。
|
|
* @return {Array} the resulting entities
|
|
*/
|
|
function parseEntities(forBlock: boolean) {
|
|
const entities = [] as IEntity[];
|
|
|
|
const endingOnValue = forBlock ? 'ENDBLK' : 'ENDSEC';
|
|
|
|
if (!forBlock) {
|
|
curr = scanner.next();
|
|
}
|
|
while (true) {
|
|
if (curr.code === 0) {
|
|
if (curr.value === endingOnValue) {
|
|
break;
|
|
}
|
|
|
|
const handler = self._entityHandlers[curr.value as EntityName];
|
|
if (handler != null) {
|
|
const entity = handler.parseEntity(scanner, curr);
|
|
curr = scanner.lastReadGroup!;
|
|
ensureHandle(entity);
|
|
entities.push(entity);
|
|
} else {
|
|
// log.debug('Unhandled entity ' + curr.value);
|
|
curr = scanner.next();
|
|
continue;
|
|
}
|
|
} else {
|
|
// ignored lines from unsupported entity
|
|
curr = scanner.next();
|
|
}
|
|
}
|
|
if (endingOnValue == 'ENDSEC') curr = scanner.next(); // swallow up ENDSEC, but not ENDBLK
|
|
return entities;
|
|
}
|
|
|
|
/**
|
|
* 解析一个2D或3D点.
|
|
* 如果它是3D的，将其作为具有x， y和（有时）z属性的对象返回。
|
|
* 假定当前组是被读入点的x，并且scanner.next（）将返回y。
|
|
* 解析器将自动确定是否存在z点。
|
|
* @return {Object} 二维或三维点作为具有 x、y[,z] 的对象
|
|
*/
|
|
function parsePoint(curr: IGroup) {
|
|
const point = {} as IPoint;
|
|
let code = curr.code;
|
|
|
|
point.x = curr.value as number;
|
|
|
|
code += 10;
|
|
curr = scanner.next();
|
|
if (curr.code != code)
|
|
throw new Error('Expected code for point value to be ' + code +
|
|
' but got ' + curr.code + '.');
|
|
point.y = curr.value as number;
|
|
|
|
code += 10;
|
|
curr = scanner.next();
|
|
if (curr.code != code) {
|
|
scanner.rewind();
|
|
return point;
|
|
}
|
|
point.z = curr.value as number;
|
|
|
|
return point;
|
|
}
|
|
|
|
function ensureHandle(entity: IEntity | IBlock) {
|
|
if (!entity) throw new TypeError('entity cannot be undefined or null');
|
|
|
|
if (!entity.handle) entity.handle = lastHandle++;
|
|
}
|
|
|
|
parseAll();
|
|
return dxf;
|
|
}
|
|
}
|
|
|
|
function groupIs(group: IGroup, code: number, value: string | number | boolean) {
|
|
return group.code === code && group.value === value;
|
|
}
|
|
|
|
// @ts-ignore
|
|
function logUnhandledGroup(curr: IGroup) {
|
|
// log.debug('unhandled group ' + debugCode(curr));
|
|
}
|
|
|
|
|
|
function debugCode(curr: IGroup) {
|
|
return curr.code + ':' + curr.value;
|
|
}
|
|
|
|
/**
|
|
* Returns the truecolor value of the given AutoCad color index value
|
|
* @return {Number} truecolor value as a number
|
|
*/
|
|
function getAcadColor(index: number) {
|
|
return AUTO_CAD_COLOR_INDEX[index];
|
|
}
|
|
|
|
// const BLOCK_ANONYMOUS_FLAG = 1;
|
|
// const BLOCK_NON_CONSTANT_FLAG = 2;
|
|
// const BLOCK_XREF_FLAG = 4;
|
|
// const BLOCK_XREF_OVERLAY_FLAG = 8;
|
|
// const BLOCK_EXTERNALLY_DEPENDENT_FLAG = 16;
|
|
// const BLOCK_RESOLVED_OR_DEPENDENT_FLAG = 32;
|
|
// const BLOCK_REFERENCED_XREF = 64;
|
|
|
|
|
|
/* Notes */
|
|
// Code 6 of an entity indicates inheritance of properties (eg. color).
|
|
// BYBLOCK means inherits from block
|
|
// BYLAYER (default) mean inherits from layer
|