329 lines
11 KiB
JavaScript
329 lines
11 KiB
JavaScript
/**
|
||
* 文件 → 统一文档模型（Doc）。
|
||
*
|
||
* 两条互不依赖的解析路径：
|
||
* .dxf → dxf-parser （MIT，纯 JS，随页面一起加载）
|
||
* .dwg → libredwg-web WASM （GPL-3.0，只有真的打开 dwg 时才动态 import，
|
||
* 约 10MB，不打开 dwg 的用户完全不会下载）
|
||
*
|
||
* 这样拆分是为了让 GPL 依赖是可替换的一块：将来换成商业 SDK 或服务端转换，
|
||
* 只需要替换 loadDwg()，其余代码不受影响。
|
||
*
|
||
* 统一约定：Doc 里所有角度都是**弧度**。
|
||
*/
|
||
|
||
import { parseDxfHatches } from './dxfHatch.js'
|
||
|
||
const RAD = Math.PI / 180
|
||
|
||
/** @typedef {{name:string, format:string, layers:Map, lineTypes:Map, styles:Map, blocks:Map, modelEntities:Array, layouts:Array, header:object, license:string}} Doc */
|
||
|
||
export function extOf(name) {
|
||
const m = /\.([a-z0-9]+)$/i.exec(name || '')
|
||
return m ? m[1].toLowerCase() : ''
|
||
}
|
||
|
||
/**
|
||
* @param {string} name 文件名（用于判断格式）
|
||
* @param {ArrayBuffer} buffer
|
||
* @param {(msg:string)=>void} [onProgress]
|
||
*/
|
||
export async function loadDrawing(name, buffer, onProgress = () => {}) {
|
||
const ext = extOf(name)
|
||
if (ext === 'dwg') return loadDwg(name, buffer, onProgress)
|
||
if (ext === 'dxf') return loadDxf(name, buffer, onProgress)
|
||
// 没有扩展名时按内容嗅探：DWG 以 "AC10xx" 开头
|
||
const head = new TextDecoder('latin1').decode(new Uint8Array(buffer, 0, Math.min(6, buffer.byteLength)))
|
||
if (/^AC10\d\d/.test(head)) return loadDwg(name, buffer, onProgress)
|
||
return loadDxf(name, buffer, onProgress)
|
||
}
|
||
|
||
// ---------------------------------------------------------------- DWG
|
||
|
||
let libredwgPromise = null
|
||
|
||
/** 动态加载 GPL 模块；只在第一次打开 dwg 时触发 */
|
||
function getLibreDwg() {
|
||
if (!libredwgPromise) {
|
||
libredwgPromise = import('../libs/libredwg/dist/libredwg-web.js').then(async (mod) => {
|
||
const inst = await mod.LibreDwg.create()
|
||
return { mod, inst }
|
||
})
|
||
}
|
||
return libredwgPromise
|
||
}
|
||
|
||
async function loadDwg(name, buffer, onProgress) {
|
||
onProgress('正在加载 DWG 解析模块（首次约 10MB）...')
|
||
const { mod, inst } = await getLibreDwg()
|
||
onProgress('正在解析 DWG...')
|
||
const dwg = inst.dwg_read_data(buffer, mod.Dwg_File_Type.DWG)
|
||
if (!dwg) throw new Error('DWG 解析失败：文件可能已损坏或版本过新')
|
||
let db
|
||
try {
|
||
db = inst.convert(dwg)
|
||
} finally {
|
||
try { inst.dwg_free(dwg) } catch { /* 释放失败不影响已转换的数据 */ }
|
||
}
|
||
return normalizeDwg(name, db)
|
||
}
|
||
|
||
function tableEntries(db, key) {
|
||
const t = db.tables && db.tables[key]
|
||
if (!t) return []
|
||
const e = t.entries
|
||
if (Array.isArray(e)) return e
|
||
if (e && typeof e === 'object') return Object.values(e)
|
||
return []
|
||
}
|
||
|
||
function normalizeDwg(name, db) {
|
||
const layers = new Map()
|
||
for (const l of tableEntries(db, 'LAYER')) {
|
||
layers.set(l.name, {
|
||
name: l.name,
|
||
colorIndex: l.colorIndex,
|
||
trueColor: colorFieldToTrueColor(l),
|
||
lineType: l.lineType,
|
||
lineweight: l.lineweight,
|
||
off: !!l.off || (typeof l.colorIndex === 'number' && l.colorIndex < 0),
|
||
frozen: !!l.frozen,
|
||
locked: !!l.locked,
|
||
plot: l.plotFlag !== 0,
|
||
})
|
||
}
|
||
if (!layers.has('0')) layers.set('0', { name: '0', colorIndex: 7, lineType: 'Continuous', off: false, frozen: false })
|
||
|
||
const lineTypes = new Map()
|
||
for (const lt of tableEntries(db, 'LTYPE')) {
|
||
lineTypes.set(lt.name, {
|
||
name: lt.name,
|
||
patternLength: lt.totalPatternLength || 0,
|
||
pattern: normalizeLtPattern(lt.pattern),
|
||
})
|
||
}
|
||
|
||
const styles = new Map()
|
||
for (const s of tableEntries(db, 'STYLE')) {
|
||
styles.set(s.name, {
|
||
name: s.name,
|
||
font: s.font,
|
||
bigFont: s.bigFont,
|
||
widthFactor: s.widthFactor || 1,
|
||
obliqueAngle: s.obliqueAngle || 0,
|
||
fixedTextHeight: s.fixedTextHeight || 0,
|
||
})
|
||
}
|
||
|
||
// 块表：*Model_Space / *Paper_Space 是布局，其余是可被 INSERT 引用的块
|
||
const blocks = new Map()
|
||
let modelEntities = []
|
||
const layouts = []
|
||
for (const br of tableEntries(db, 'BLOCK_RECORD')) {
|
||
const ents = br.entities || []
|
||
const nm = br.name || ''
|
||
if (/^\*model_space$/i.test(nm)) modelEntities = ents
|
||
else if (/^\*paper_space/i.test(nm)) layouts.push({ name: nm, entities: ents })
|
||
blocks.set(nm, { name: nm, basePoint: br.basePoint || { x: 0, y: 0 }, entities: ents })
|
||
}
|
||
// 有些文件模型空间实体只出现在顶层 entities 里
|
||
if (!modelEntities.length && Array.isArray(db.entities)) modelEntities = db.entities
|
||
|
||
return {
|
||
name, format: 'DWG', license: 'GPL-3.0（LibreDWG）',
|
||
layers, lineTypes, styles, blocks, modelEntities, layouts,
|
||
header: db.header || {},
|
||
}
|
||
}
|
||
|
||
/** libredwg 用 0xFFFFFF 表示「没有真彩色」 */
|
||
function colorFieldToTrueColor(o) {
|
||
if (typeof o.trueColor === 'number') return o.trueColor & 0xffffff
|
||
if (typeof o.color === 'number' && o.color !== 16777215 && o.color !== -1) return o.color & 0xffffff
|
||
return undefined
|
||
}
|
||
|
||
function normalizeLtPattern(pattern) {
|
||
if (!Array.isArray(pattern)) return []
|
||
return pattern.map((p) => {
|
||
if (typeof p === 'number') return p
|
||
if (p && typeof p === 'object') return p.length != null ? p.length : (p.dashLength != null ? p.dashLength : 0)
|
||
return 0
|
||
}).filter((n) => isFinite(n))
|
||
}
|
||
|
||
// ---------------------------------------------------------------- DXF
|
||
|
||
async function loadDxf(name, buffer, onProgress) {
|
||
const bytes = new Uint8Array(buffer)
|
||
const head = new TextDecoder('latin1').decode(bytes.subarray(0, 22))
|
||
if (head.startsWith('AutoCAD Binary DXF')) {
|
||
throw new Error('这是二进制 DXF，请在 CAD 里另存为 ASCII DXF，或直接用 DWG')
|
||
}
|
||
onProgress('正在解析 DXF...')
|
||
const text = decodeDxfText(bytes)
|
||
const { default: DxfParser } = await import('../libs/dxf-parser/index.js')
|
||
const parsed = new DxfParser().parseSync(text)
|
||
const doc = normalizeDxf(name, parsed)
|
||
// dxf-parser 不支持 HATCH，用独立的扫描器补上剖面线
|
||
try {
|
||
parseDxfHatches(text, doc)
|
||
} catch (e) {
|
||
console.warn('HATCH 解析失败，已跳过：', e)
|
||
}
|
||
return doc
|
||
}
|
||
|
||
/** DXF 可能是 UTF-8，也可能是 GBK（国内图纸常见）。用 $DWGCODEPAGE 之外的启发式判断 */
|
||
function decodeDxfText(bytes) {
|
||
const utf8 = new TextDecoder('utf-8', { fatal: false }).decode(bytes)
|
||
// U+FFFD 过多说明不是 UTF-8，退回 GBK
|
||
let bad = 0
|
||
for (let i = 0; i < utf8.length; i += 97) if (utf8.charCodeAt(i) === 0xfffd) bad++
|
||
if (bad > 2) {
|
||
try { return new TextDecoder('gbk').decode(bytes) } catch { /* 浏览器不支持 gbk 就用 utf8 */ }
|
||
}
|
||
return utf8
|
||
}
|
||
|
||
function normalizeDxf(name, dxf) {
|
||
const layers = new Map()
|
||
const src = (dxf.tables && dxf.tables.layer && dxf.tables.layer.layers) || {}
|
||
for (const [k, l] of Object.entries(src)) {
|
||
layers.set(k, {
|
||
name: k,
|
||
colorIndex: l.colorIndex,
|
||
trueColor: typeof l.color === 'number' ? l.color : undefined,
|
||
lineType: l.lineType || l.lineTypeName,
|
||
lineweight: l.lineweight,
|
||
off: l.visible === false || (typeof l.colorIndex === 'number' && l.colorIndex < 0),
|
||
frozen: !!(l.frozen || (l.flags & 1)),
|
||
locked: !!(l.flags & 4),
|
||
plot: true,
|
||
})
|
||
}
|
||
if (!layers.has('0')) layers.set('0', { name: '0', colorIndex: 7, lineType: 'Continuous', off: false, frozen: false })
|
||
|
||
const lineTypes = new Map()
|
||
const lts = (dxf.tables && dxf.tables.lineType && dxf.tables.lineType.lineTypes) || {}
|
||
for (const [k, lt] of Object.entries(lts)) {
|
||
lineTypes.set(k, {
|
||
name: k,
|
||
patternLength: lt.patternLength || 0,
|
||
pattern: Array.isArray(lt.pattern) ? lt.pattern.filter((n) => typeof n === 'number') : [],
|
||
})
|
||
}
|
||
|
||
const styles = new Map()
|
||
const sts = (dxf.tables && dxf.tables.style && dxf.tables.style.styles) || {}
|
||
for (const [k, s] of Object.entries(sts)) {
|
||
styles.set(k, {
|
||
name: k, font: s.fontFileName || s.font, bigFont: s.bigFontFileName,
|
||
widthFactor: s.widthFactor || 1, obliqueAngle: (s.obliqueAngle || 0) * RAD,
|
||
fixedTextHeight: s.fixedTextHeight || 0,
|
||
})
|
||
}
|
||
|
||
const blocks = new Map()
|
||
for (const [k, b] of Object.entries(dxf.blocks || {})) {
|
||
const ents = (b.entities || []).map(dxfEntity)
|
||
blocks.set(k, { name: k, basePoint: b.position || { x: 0, y: 0 }, entities: ents })
|
||
}
|
||
const modelEntities = (dxf.entities || []).map(dxfEntity)
|
||
|
||
return {
|
||
name, format: 'DXF', license: 'MIT（dxf-parser）',
|
||
layers, lineTypes, styles, blocks, modelEntities, layouts: [],
|
||
header: dxf.header || {},
|
||
}
|
||
}
|
||
|
||
/**
|
||
* dxf-parser 的实体 → 内部约定。
|
||
* 主要做三件事：字段改名、角度统一成弧度、顶点结构统一。
|
||
*/
|
||
function dxfEntity(e) {
|
||
const o = { ...e }
|
||
o.colorIndex = e.colorIndex != null ? e.colorIndex : 256
|
||
if (typeof e.color === 'number' && e.colorIndex == null) o.trueColor = e.color
|
||
o.lineType = e.lineType
|
||
o.lineweight = e.lineweight
|
||
o.lineTypeScale = e.lineTypeScale || 1
|
||
o.isVisible = e.visible !== false
|
||
|
||
switch (e.type) {
|
||
case 'LINE':
|
||
o.startPoint = e.vertices && e.vertices[0]
|
||
o.endPoint = e.vertices && e.vertices[1]
|
||
break
|
||
case 'LWPOLYLINE':
|
||
case 'POLYLINE':
|
||
o.flag = (e.shape ? 1 : 0) | (e.flag || 0)
|
||
o.vertices = e.vertices || []
|
||
break
|
||
case 'SPLINE':
|
||
o.degree = e.degreeOfSplineCurve
|
||
o.knots = e.knotValues
|
||
o.controlPoints = e.controlPoints
|
||
o.fitPoints = e.fitPoints
|
||
o.flag = e.flag || (e.closed ? 1 : 0)
|
||
break
|
||
case 'ELLIPSE':
|
||
// dxf-parser 已把 startAngle/endAngle 转成弧度
|
||
break
|
||
case 'ARC':
|
||
case 'CIRCLE':
|
||
// 同上
|
||
break
|
||
case 'TEXT':
|
||
case 'ATTRIB':
|
||
case 'ATTDEF':
|
||
o.startPoint = e.startPoint
|
||
o.endPoint = e.endPoint
|
||
o.textHeight = e.textHeight
|
||
o.rotation = (e.rotation || 0) * RAD
|
||
o.obliqueAngle = (e.obliqueAngle || 0) * RAD
|
||
o.xScale = e.xScale || 1
|
||
o.styleName = e.styleName || e.textStyle
|
||
o.generationFlag = e.textGenerationFlag || 0
|
||
break
|
||
case 'MTEXT':
|
||
o.insertionPoint = e.position
|
||
o.textHeight = e.height
|
||
o.rectWidth = e.width
|
||
o.rotation = (e.rotation || 0) * RAD
|
||
o.attachmentPoint = e.attachmentPoint
|
||
o.styleName = e.styleName || e.textStyle
|
||
o.direction = e.directionVector
|
||
break
|
||
case 'INSERT':
|
||
o.insertionPoint = e.position
|
||
o.rotation = (e.rotation || 0) * RAD
|
||
o.xScale = e.xScale == null ? 1 : e.xScale
|
||
o.yScale = e.yScale == null ? 1 : e.yScale
|
||
o.columnCount = e.columnCount
|
||
o.rowCount = e.rowCount
|
||
o.columnSpacing = e.columnSpacing
|
||
o.rowSpacing = e.rowSpacing
|
||
o.attribs = (e.attributes || e.attribs || []).map(dxfEntity)
|
||
break
|
||
case 'DIMENSION':
|
||
o.name = e.block // 尺寸的实际图形所在的匿名块
|
||
o.rotation = (e.rotation || 0) * RAD
|
||
break
|
||
case 'SOLID':
|
||
case 'TRACE':
|
||
case '3DFACE': {
|
||
const p = e.points || e.vertices || []
|
||
o.corner1 = p[0]; o.corner2 = p[1]; o.corner3 = p[2]; o.corner4 = p[3]
|
||
break
|
||
}
|
||
case 'POINT':
|
||
o.position = e.position
|
||
break
|
||
default:
|
||
break
|
||
}
|
||
return o
|
||
}
|