Agent Zero
435 lines
14 KiB
TypeScript
435 lines
14 KiB
TypeScript
/**
|
||
* DXF Parser – converts DXF entities to CADElement[]
|
||
* Uses dxf-parser library.
|
||
*
|
||
* Task F5 erweitert die Entity-Abdeckung: ELLIPSE (Polyline-Approx), SPLINE
|
||
* (Grad<=3 → de-Boor-Approx), MTEXT (Formatcode-Cleanup), POINT, ATTDEF und
|
||
* INSERT mit MINSERT-Arrays. HATCH wird defensiv mapping-fähig gehalten
|
||
* (dxf-parser 1.1.x schickt echte HATCH-Entities noch nicht durch).
|
||
*
|
||
* Neben `warnings` liefert parseDXF einen strukturierten Fehlerreport
|
||
* (`skippedEntities`: type + reason je übersprungener Entity).
|
||
*/
|
||
import DxfParser from 'dxf-parser';
|
||
import type { CADElement, CADLayer, CADProperties, ElementType } from '../types/cad.types';
|
||
|
||
export interface SkippedEntity {
|
||
type: string;
|
||
reason: string;
|
||
}
|
||
|
||
export interface DXFImportResult {
|
||
elements: CADElement[];
|
||
layers: CADLayer[];
|
||
warnings: string[];
|
||
skippedEntities: SkippedEntity[];
|
||
}
|
||
|
||
let idCounter = 0;
|
||
const nextId = () => `dxf-${Date.now()}-${idCounter++}`;
|
||
|
||
interface Pt { x: number; y: number }
|
||
|
||
function bboxOf(pts: Pt[]): { x: number; y: number; width: number; height: number } {
|
||
const minX = Math.min(...pts.map((p) => p.x));
|
||
const minY = Math.min(...pts.map((p) => p.y));
|
||
const maxX = Math.max(...pts.map((p) => p.x));
|
||
const maxY = Math.max(...pts.map((p) => p.y));
|
||
return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
|
||
}
|
||
|
||
/**
|
||
* Parse a DXF string into CAD elements and layers.
|
||
*/
|
||
export function parseDXF(dxfString: string): DXFImportResult {
|
||
const parser = new DxfParser();
|
||
const dxf = parser.parseSync(dxfString) as any;
|
||
const empty: DXFImportResult = { elements: [], layers: [], warnings: [], skippedEntities: [] };
|
||
if (!dxf) return { ...empty, warnings: ['DXF parse returned null'] };
|
||
const warnings: string[] = [];
|
||
const skippedEntities: SkippedEntity[] = [];
|
||
const layerMap = new Map<string, CADLayer>();
|
||
const elements: CADElement[] = [];
|
||
|
||
// Build layers from DXF tables
|
||
if (dxf.tables?.layer?.layers) {
|
||
let sortOrder = 0;
|
||
for (const [layerName, layerData] of Object.entries(dxf.tables.layer.layers) as [string, any][]) {
|
||
const layer: CADLayer = {
|
||
id: `dxf-layer-${layerName}`,
|
||
name: layerName,
|
||
visible: true,
|
||
locked: false,
|
||
color: dxfColorToHex(layerData.color) ?? '#ffffff',
|
||
lineType: mapLineType(layerData.lineType),
|
||
transparency: 0,
|
||
sortOrder: sortOrder++,
|
||
parentId: null,
|
||
};
|
||
layerMap.set(layerName, layer);
|
||
}
|
||
}
|
||
|
||
// Ensure a default layer exists
|
||
if (layerMap.size === 0) {
|
||
layerMap.set('0', {
|
||
id: 'dxf-layer-0', name: '0', visible: true, locked: false,
|
||
color: '#ffffff', lineType: 'solid', transparency: 0, sortOrder: 0, parentId: null,
|
||
});
|
||
}
|
||
|
||
// Parse entities (INSERT expanded for MINSERT arrays)
|
||
if (dxf.entities) {
|
||
for (const entity of dxf.entities) {
|
||
if (entity?.type === 'INSERT') {
|
||
elements.push(...expandInsert(entity, layerMap));
|
||
continue;
|
||
}
|
||
const el = entityToCADElement(entity, layerMap);
|
||
if (el) {
|
||
elements.push(el);
|
||
} else {
|
||
const type = String(entity?.type ?? 'UNKNOWN');
|
||
const reason = skipReason(entity);
|
||
skippedEntities.push({ type, reason });
|
||
warnings.push(`Unsupported entity type: ${type} — ${reason}`);
|
||
}
|
||
}
|
||
}
|
||
|
||
return { elements, layers: Array.from(layerMap.values()), warnings, skippedEntities };
|
||
}
|
||
|
||
/** Grund, warum eine Entity übersprungen wurde (für den Fehlerreport). */
|
||
export function skipReason(entity: any): string {
|
||
switch (entity?.type) {
|
||
case 'ELLIPSE':
|
||
return 'Ellipse ohne center/majorAxisEndPoint nicht darstellbar';
|
||
case 'SPLINE':
|
||
if ((entity?.degreeOfSplineCurve ?? 0) > 3) return 'Spline-Grad > 3 (Approx limitiert auf Grad <= 3)';
|
||
return 'Spline ohne verwertbare Kontrollpunkte';
|
||
case 'LINE':
|
||
return 'Line unvollständig (Start-/Endpunkt fehlt)';
|
||
case 'HATCH':
|
||
return 'HATCH-Grenzen nicht lesbar';
|
||
case 'ATTDEF':
|
||
return 'ATTDEF ohne tag';
|
||
default:
|
||
return 'Nicht unterstützter Entity-Typ';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* INSERT → block_instance(s). MINSERT-Arrays (columnCount/rowCount > 1)
|
||
* erzeugen n-fache Instanzen mit Spacing-Offset.
|
||
*/
|
||
export function expandInsert(entity: any, layerMap?: Map<string, CADLayer>): CADElement[] {
|
||
const layerName = entity.layer || '0';
|
||
const layer = layerMap?.get(layerName) ?? layerMap?.get('0');
|
||
const layerId = layer?.id ?? `dxf-layer-${layerName}`;
|
||
const pos = entity.position;
|
||
if (!pos) return [];
|
||
const baseProps: CADProperties = {
|
||
stroke: entity.color ? (dxfColorToHex(entity.color) ?? layer?.color) : (layer?.color ?? '#ffffff'),
|
||
strokeWidth: 1,
|
||
blockId: entity.name,
|
||
scale: entity.scale || entity.xScale || 1,
|
||
scaleX: entity.xScale ?? 1,
|
||
scaleY: entity.yScale ?? 1,
|
||
rotation: entity.rotation || 0,
|
||
};
|
||
const cols = Math.max(1, Math.floor(entity.columnCount || 1));
|
||
const rows = Math.max(1, Math.floor(entity.rowCount || 1));
|
||
const colSpacing = entity.columnSpacing || 0;
|
||
const rowSpacing = entity.rowSpacing || 0;
|
||
const out: CADElement[] = [];
|
||
for (let r = 0; r < rows; r++) {
|
||
for (let c = 0; c < cols; c++) {
|
||
out.push({
|
||
id: nextId(), type: 'block_instance', layerId,
|
||
x: pos.x + c * colSpacing, y: pos.y + r * rowSpacing,
|
||
width: 0, height: 0,
|
||
properties: { ...baseProps },
|
||
});
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
/** ELLIPSE → Polyline-Approximation (64 Segmente bei Voll-Ellipse). */
|
||
function ellipseToPoints(entity: any): Pt[] | null {
|
||
const c = entity.center;
|
||
const major = entity.majorAxisEndPoint;
|
||
if (!c || !major) return null;
|
||
const a = Math.hypot(major.x ?? 0, major.y ?? 0);
|
||
if (!(a > 0)) return null;
|
||
const ratio = typeof entity.axisRatio === 'number' && entity.axisRatio > 0 ? entity.axisRatio : 1;
|
||
const b = a * ratio;
|
||
const phi = Math.atan2(major.y ?? 0, major.x ?? 0);
|
||
const cosP = Math.cos(phi), sinP = Math.sin(phi);
|
||
const FULL = Math.PI * 2;
|
||
let start = typeof entity.startAngle === 'number' ? entity.startAngle : 0;
|
||
let end = typeof entity.endAngle === 'number' ? entity.endAngle : start + FULL;
|
||
let span = end - start;
|
||
const closed = !(span > 0.000001) || Math.abs(span - FULL) < 1e-6;
|
||
if (span <= 0) { start = 0; span = FULL; }
|
||
const n = Math.max(2, Math.round(64 * (span / FULL)));
|
||
const pts: Pt[] = [];
|
||
for (let i = 0; i < n; i++) {
|
||
const t = closed ? start + (i * span) / n : start + (i * span) / (n - 1);
|
||
const ct = Math.cos(t), st = Math.sin(t);
|
||
pts.push({
|
||
x: c.x + a * ct * cosP - b * st * sinP,
|
||
y: c.y + a * ct * sinP + b * st * cosP,
|
||
});
|
||
}
|
||
return pts;
|
||
}
|
||
|
||
/** Cox-de-Boor: Punkt auf B-Spline (Grad <= 3). */
|
||
function bsplinePoint(degree: number, knots: number[], ctrl: Pt[], t: number): Pt {
|
||
const n = ctrl.length - 1;
|
||
let k = degree;
|
||
for (let i = degree; i <= n; i++) {
|
||
if (t >= knots[i] && t <= knots[i + 1]) { k = i; break; }
|
||
}
|
||
const d: Pt[] = [];
|
||
for (let j = 0; j <= degree; j++) d.push({ ...ctrl[k - degree + j] });
|
||
for (let r = 1; r <= degree; r++) {
|
||
for (let j = degree; j >= r; j--) {
|
||
const i = k - degree + j;
|
||
const denom = knots[i + degree - r + 1] - knots[i];
|
||
const alpha = denom === 0 ? 0 : (t - knots[i]) / denom;
|
||
d[j] = {
|
||
x: (1 - alpha) * d[j - 1].x + alpha * d[j].x,
|
||
y: (1 - alpha) * d[j - 1].y + alpha * d[j].y,
|
||
};
|
||
}
|
||
}
|
||
return d[degree];
|
||
}
|
||
|
||
/** SPLINE → Polyline-Approximation via de Boor (Grad <= 3). */
|
||
function splineToPoints(entity: any): Pt[] | null {
|
||
const degree = entity.degreeOfSplineCurve ?? 3;
|
||
const ctrl = (entity.controlPoints || []) as Pt[];
|
||
if (!Array.isArray(ctrl) || ctrl.length < degree + 1) return null;
|
||
const m = ctrl.length;
|
||
const total = m + degree + 1;
|
||
const knots: number[] = entity.knotValues && entity.knotValues.length === total
|
||
? entity.knotValues.slice()
|
||
: (() => {
|
||
const ks: number[] = [];
|
||
for (let j = 0; j < total; j++) {
|
||
if (j <= degree) ks.push(0);
|
||
else if (j >= total - 1 - degree) ks.push(1);
|
||
else ks.push((j - degree) / (total - 1 - 2 * degree));
|
||
}
|
||
return ks;
|
||
})();
|
||
const N = 40;
|
||
const t0 = knots[degree];
|
||
const t1 = knots[m];
|
||
const span = t1 - t0;
|
||
const pts: Pt[] = [];
|
||
for (let i = 0; i < N; i++) {
|
||
const t = t0 + (i * span) / (N - 1);
|
||
pts.push(bsplinePoint(degree, knots, ctrl, t));
|
||
}
|
||
return pts;
|
||
}
|
||
|
||
/** MTEXT-Formatcodes zerlegen: \P → Umbruch, Inline-Codes entfernen. */
|
||
function cleanMText(raw: string): string {
|
||
return raw
|
||
.replace(/\\P/gi, '\n')
|
||
.replace(/\\~/g, ' ')
|
||
.replace(/\\[A-Za-z][^;{}\\]{0,12};/g, '')
|
||
.replace(/[{}]/g, '');
|
||
}
|
||
|
||
/**
|
||
* Convert a single DXF entity into a CADElement (exported for unit tests).
|
||
*/
|
||
export function entityToCADElement(
|
||
entity: any,
|
||
layerMap: Map<string, CADLayer>,
|
||
): CADElement | null {
|
||
const layerName = entity.layer || '0';
|
||
const layer = layerMap.get(layerName) ?? layerMap.get('0')!;
|
||
const color = entity.color ? (dxfColorToHex(entity.color) ?? layer.color) : layer.color;
|
||
const baseProps: CADProperties = {
|
||
stroke: color,
|
||
strokeWidth: 1,
|
||
};
|
||
|
||
switch (entity.type) {
|
||
case 'LINE': {
|
||
const s = entity.vertices?.[0];
|
||
const e = entity.vertices?.[1];
|
||
if (!s || !e) return null;
|
||
return {
|
||
id: nextId(), type: 'line', layerId: layer.id,
|
||
x: Math.min(s.x, e.x), y: Math.min(s.y, e.y),
|
||
width: Math.abs(e.x - s.x), height: Math.abs(e.y - s.y),
|
||
properties: { ...baseProps, x1: s.x, y1: s.y, x2: e.x, y2: e.y },
|
||
};
|
||
}
|
||
case 'CIRCLE': {
|
||
const c = entity.center;
|
||
const r = entity.radius;
|
||
if (!c || r == null) return null;
|
||
return {
|
||
id: nextId(), type: 'circle', layerId: layer.id,
|
||
x: c.x - r, y: c.y - r, width: r * 2, height: r * 2,
|
||
properties: { ...baseProps, radius: r },
|
||
};
|
||
}
|
||
case 'ARC': {
|
||
const c = entity.center;
|
||
const r = entity.radius;
|
||
if (!c || r == null) return null;
|
||
return {
|
||
id: nextId(), type: 'arc', layerId: layer.id,
|
||
x: c.x - r, y: c.y - r, width: r * 2, height: r * 2,
|
||
properties: { ...baseProps, radius: r, startAngle: entity.startAngle, endAngle: entity.endAngle },
|
||
};
|
||
}
|
||
case 'ELLIPSE': {
|
||
const pts = ellipseToPoints(entity);
|
||
if (!pts || pts.length < 2) return null;
|
||
const bbox = bboxOf(pts);
|
||
return {
|
||
id: nextId(), type: 'polyline', layerId: layer.id,
|
||
...bbox,
|
||
properties: { ...baseProps, points: pts },
|
||
};
|
||
}
|
||
case 'SPLINE': {
|
||
const degree = entity.degreeOfSplineCurve ?? 3;
|
||
const ctrl = (entity.controlPoints || []) as Pt[];
|
||
if (degree < 1 || degree > 3) return null;
|
||
if (!Array.isArray(ctrl) || ctrl.length < degree + 1) return null;
|
||
const pts = splineToPoints(entity);
|
||
if (!pts || pts.length < 2) return null;
|
||
const bbox = bboxOf(pts);
|
||
return {
|
||
id: nextId(), type: 'polyline', layerId: layer.id,
|
||
...bbox,
|
||
properties: { ...baseProps, points: pts },
|
||
};
|
||
}
|
||
case 'LWPOLYLINE':
|
||
case 'POLYLINE': {
|
||
const pts = (entity.vertices || []).map((v: any) => ({ x: v.x, y: v.y }));
|
||
if (pts.length < 2) return null;
|
||
const bbox = bboxOf(pts);
|
||
const isClosed = entity.shape === true;
|
||
const type: ElementType = isClosed ? 'polygon' : 'polyline';
|
||
return {
|
||
id: nextId(), type, layerId: layer.id,
|
||
...bbox,
|
||
properties: { ...baseProps, points: pts },
|
||
};
|
||
}
|
||
case 'TEXT': {
|
||
const s = entity.startPoint;
|
||
if (!s) return null;
|
||
return {
|
||
id: nextId(), type: 'text', layerId: layer.id,
|
||
x: s.x, y: s.y, width: 0, height: 0,
|
||
properties: { ...baseProps, text: entity.text || '', fontSize: entity.height || 12 },
|
||
};
|
||
}
|
||
case 'MTEXT': {
|
||
const pos = entity.position;
|
||
if (!pos) return null;
|
||
const text = cleanMText(String(entity.text ?? ''));
|
||
if (!text) return null;
|
||
return {
|
||
id: nextId(), type: 'text', layerId: layer.id,
|
||
x: pos.x, y: pos.y, width: entity.width || 0, height: entity.height || 0,
|
||
properties: { ...baseProps, text, fontSize: entity.height || 12, rotation: entity.rotation || 0 },
|
||
};
|
||
}
|
||
case 'POINT': {
|
||
const pos = entity.position;
|
||
if (!pos) return null;
|
||
const r = 1.5;
|
||
return {
|
||
id: nextId(), type: 'circle', layerId: layer.id,
|
||
x: pos.x - r, y: pos.y - r, width: r * 2, height: r * 2,
|
||
properties: { ...baseProps, radius: r, fill: color, point: true },
|
||
};
|
||
}
|
||
case 'ATTDEF': {
|
||
const s = entity.startPoint;
|
||
if (!entity.tag || !s) return null;
|
||
return {
|
||
id: nextId(), type: 'text', layerId: layer.id,
|
||
x: s.x, y: s.y, width: 0, height: 0,
|
||
properties: {
|
||
...baseProps,
|
||
text: `${entity.tag}=${entity.text ?? ''}`,
|
||
fontSize: entity.textHeight || 12,
|
||
tag: entity.tag,
|
||
prompt: entity.prompt ?? '',
|
||
attdef: true,
|
||
},
|
||
};
|
||
}
|
||
case 'HATCH': {
|
||
const pts = (entity.boundaryPoints || []) as Pt[];
|
||
if (pts.length < 3) return null;
|
||
const bbox = bboxOf(pts);
|
||
return {
|
||
id: nextId(), type: 'polygon', layerId: layer.id,
|
||
...bbox,
|
||
properties: {
|
||
...baseProps,
|
||
points: pts,
|
||
hatchPattern: entity.patternName || 'SOLID',
|
||
fill: entity.isSolid ? color : undefined,
|
||
},
|
||
};
|
||
}
|
||
case 'INSERT': {
|
||
const [inst] = expandInsert(entity, layerMap);
|
||
return inst ?? null;
|
||
}
|
||
case 'DIMENSION': {
|
||
// Basic dimension support
|
||
const pts = entity.definitionPoint || entity.points;
|
||
if (!pts) return null;
|
||
return {
|
||
id: nextId(), type: 'dimension', layerId: layer.id,
|
||
x: 0, y: 0, width: 0, height: 0,
|
||
properties: { ...baseProps, points: Array.isArray(pts) ? pts.map((p: any) => ({ x: p.x, y: p.y })) : [] },
|
||
};
|
||
}
|
||
default:
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* DXF ACI color to hex string
|
||
*/
|
||
function dxfColorToHex(aci: number | undefined): string | null {
|
||
if (aci == null) return null;
|
||
const colors: Record<number, string> = {
|
||
0: '#ffffff', 1: '#ff0000', 2: '#ffff00', 3: '#00ff00',
|
||
4: '#00ffff', 5: '#0000ff', 6: '#ff00ff', 7: '#ffffff',
|
||
8: '#808080', 9: '#c0c0c0',
|
||
};
|
||
return colors[aci] ?? null;
|
||
}
|
||
|
||
function mapLineType(lt: string | undefined): 'solid' | 'dashed' | 'dotted' {
|
||
if (!lt) return 'solid';
|
||
const u = lt.toUpperCase();
|
||
if (u.includes('DASH')) return 'dashed';
|
||
if (u.includes('DOT')) return 'dotted';
|
||
return 'solid';
|
||
}
|