Agent Zero
308 lines
9.1 KiB
TypeScript
308 lines
9.1 KiB
TypeScript
/**
|
||
* DXF Writer – converts CADElement[] to DXF string
|
||
* Zielversionen: AC1009 (R12, Default) und AC1015 (AutoCAD 2000).
|
||
*
|
||
* Task F6: BLOCKS+INSERTS mit Name-Mapping/Sanitizing, ATTDEF in
|
||
* Blockdefinitionen, ATTRIB/SEQEND an Instanzen mit attrValues,
|
||
* R12-korrektes POLYLINE+VERTEX+SEQEND statt LWPOLYLINE sowie die
|
||
* Center-/Winkel-Konventionen der App (el.x/el.y = Zentrum, Grad-Winkel).
|
||
*/
|
||
import type { CADElement, CADLayer, ProjectData } from '../types/cad.types';
|
||
|
||
export interface DXFWriterOptions {
|
||
/** Zielversion: AC1009 (R12, Default) oder AC1015. */
|
||
version?: 'AC1009' | 'AC1015';
|
||
}
|
||
|
||
interface Pt { x: number; y: number }
|
||
type Write = (code: number, value: string | number) => void;
|
||
|
||
/**
|
||
* Generate a DXF string from project data (R12-kompatibel).
|
||
*/
|
||
export function writeDXF(data: ProjectData, options: DXFWriterOptions = {}): string {
|
||
const version = options.version ?? 'AC1009';
|
||
const lines: string[] = [];
|
||
const w: Write = (code, value) => {
|
||
lines.push(String(code));
|
||
lines.push(String(value));
|
||
};
|
||
|
||
// ─── Name-Mapping: Block-ID → sanitierter DXF-Blockname ───
|
||
const usedNames = new Set<string>(['0']); // '0' ist in DXF reserviert
|
||
const nameMap = new Map<string, string>();
|
||
for (const block of data.blocks) {
|
||
nameMap.set(block.id, sanitizeBlockName(block.name || block.id, usedNames));
|
||
}
|
||
|
||
// Header
|
||
w(0, 'SECTION');
|
||
w(2, 'HEADER');
|
||
w(9, '$ACADVER'); w(1, version);
|
||
w(9, '$INSBASE'); w(10, 0); w(20, 0); w(30, 0);
|
||
w(9, '$EXTMIN'); w(10, 0); w(20, 0);
|
||
w(9, '$EXTMAX'); w(10, 1000); w(20, 1000);
|
||
w(0, 'ENDSEC');
|
||
|
||
// Tables section
|
||
w(0, 'SECTION');
|
||
w(2, 'TABLES');
|
||
w(0, 'TABLE');
|
||
w(2, 'LAYER');
|
||
w(70, data.layers.length);
|
||
for (const layer of data.layers) {
|
||
w(0, 'LAYER');
|
||
w(2, layer.name);
|
||
w(70, 0);
|
||
w(62, hexToACI(layer.color));
|
||
w(6, lineTypeToDXF(layer.lineType));
|
||
}
|
||
w(0, 'ENDTAB');
|
||
w(0, 'ENDSEC');
|
||
|
||
// ─── BLOCKS section (Task F6) ───
|
||
w(0, 'SECTION');
|
||
w(2, 'BLOCKS');
|
||
for (const block of data.blocks) {
|
||
const dxfName = nameMap.get(block.id)!;
|
||
w(0, 'BLOCK');
|
||
w(2, dxfName);
|
||
w(70, 0);
|
||
w(10, 0); w(20, 0); w(30, 0);
|
||
w(3, dxfName);
|
||
w(1, block.description || '');
|
||
for (const el of block.elements) {
|
||
writeEntity(w, el, getLayerName(data.layers, el.layerId), nameMap, true);
|
||
}
|
||
w(0, 'ENDBLK');
|
||
}
|
||
w(0, 'ENDSEC');
|
||
|
||
// Entities section
|
||
w(0, 'SECTION');
|
||
w(2, 'ENTITIES');
|
||
for (const el of data.elements) {
|
||
const layerName = getLayerName(data.layers, el.layerId);
|
||
writeEntity(w, el, layerName, nameMap, false);
|
||
}
|
||
w(0, 'ENDSEC');
|
||
|
||
// EOF
|
||
w(0, 'EOF');
|
||
|
||
return lines.join('\n');
|
||
}
|
||
|
||
/** Blocknamen für DXF sanitizen: nur [A-Za-z0-9_$-], Kollisionen deduplizieren. */
|
||
function sanitizeBlockName(name: string, used: Set<string>): string {
|
||
const base = (name.replace(/[^\w$-]/g, '_') || 'BLOCK');
|
||
let candidate = base;
|
||
let i = 2;
|
||
while (used.has(candidate.toUpperCase())) {
|
||
candidate = `${base}_${i++}`;
|
||
}
|
||
used.add(candidate.toUpperCase());
|
||
return candidate;
|
||
}
|
||
|
||
/** R12-korrektes POLYLINE+VERTEX+SEQEND (LWPOLYLINE erst ab R13). */
|
||
function writePolylineR12(
|
||
w: Write,
|
||
layerName: string,
|
||
aci: number,
|
||
pts: Pt[],
|
||
closed: boolean,
|
||
): void {
|
||
w(0, 'POLYLINE');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(66, 1); // Vertices folgen
|
||
w(70, closed ? 1 : 0);
|
||
w(10, 0); w(20, 0); w(30, 0);
|
||
for (const pt of pts) {
|
||
w(0, 'VERTEX');
|
||
w(8, layerName);
|
||
w(10, pt.x); w(20, pt.y); w(30, 0);
|
||
}
|
||
w(0, 'SEQEND');
|
||
}
|
||
|
||
/** BBox-Fallback für Elemente ohne native DXF-Repräsentation. */
|
||
function writeBBoxPolyline(w: Write, el: CADElement, layerName: string, aci: number): void {
|
||
const x0 = el.x;
|
||
const y0 = el.y;
|
||
writePolylineR12(w, layerName, aci, [
|
||
{ x: x0, y: y0 },
|
||
{ x: x0 + el.width, y: y0 },
|
||
{ x: x0 + el.width, y: y0 + el.height },
|
||
{ x: x0, y: y0 + el.height },
|
||
], true);
|
||
}
|
||
|
||
function writeEntity(
|
||
w: Write,
|
||
el: CADElement,
|
||
layerName: string,
|
||
nameMap: Map<string, string>,
|
||
inBlockDefinition: boolean,
|
||
): void {
|
||
const p = el.properties;
|
||
const stroke = (p.stroke as string) || '#ffffff';
|
||
const aci = hexToACI(stroke);
|
||
|
||
switch (el.type) {
|
||
case 'line': {
|
||
w(0, 'LINE');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(10, p.x1 ?? el.x); w(20, p.y1 ?? el.y); w(30, 0);
|
||
w(11, p.x2 ?? el.x + el.width); w(21, p.y2 ?? el.y + el.height); w(31, 0);
|
||
break;
|
||
}
|
||
case 'circle': {
|
||
// App-Konvention: el.x/el.y IST das Zentrum (beide Renderer lesen es direkt)
|
||
w(0, 'CIRCLE');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(10, el.x); w(20, el.y); w(30, 0);
|
||
w(40, p.radius ?? el.width / 2);
|
||
break;
|
||
}
|
||
case 'arc': {
|
||
w(0, 'ARC');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(10, el.x); w(20, el.y); w(30, 0);
|
||
w(40, p.radius ?? el.width / 2);
|
||
// App-Konvention: Winkel in Grad (0° = 3 Uhr, CCW) — direkt schreiben
|
||
w(50, p.startAngle ?? 0);
|
||
w(51, p.endAngle ?? 360);
|
||
break;
|
||
}
|
||
case 'rect': {
|
||
// App-Konvention: rect x/y = Zentrum der BBox
|
||
const x0 = el.x - el.width / 2;
|
||
const y0 = el.y - el.height / 2;
|
||
writePolylineR12(w, layerName, aci, [
|
||
{ x: x0, y: y0 },
|
||
{ x: x0 + el.width, y: y0 },
|
||
{ x: x0 + el.width, y: y0 + el.height },
|
||
{ x: x0, y: y0 + el.height },
|
||
], true);
|
||
break;
|
||
}
|
||
case 'polygon':
|
||
case 'polyline': {
|
||
const pts = (p.points as Pt[] | undefined) ?? [];
|
||
if (pts.length >= 2) {
|
||
writePolylineR12(w, layerName, aci, pts.map((pt) => ({ x: pt.x, y: pt.y })), el.type === 'polygon');
|
||
}
|
||
break;
|
||
}
|
||
case 'text': {
|
||
// ATTDEF: Text-Element als Attribut-Definition in Blockdefinitionen (Task F6)
|
||
if (inBlockDefinition && p.attdef === true && typeof p.tag === 'string' && p.tag) {
|
||
w(0, 'ATTDEF');
|
||
w(8, layerName);
|
||
w(10, el.x); w(20, el.y); w(30, 0);
|
||
w(40, p.fontSize ?? 12);
|
||
w(1, (p.text as string) ?? '');
|
||
w(2, p.tag);
|
||
w(3, (p.prompt as string) ?? '');
|
||
w(70, 0);
|
||
break;
|
||
}
|
||
w(0, 'TEXT');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(10, el.x); w(20, el.y); w(30, 0);
|
||
w(40, p.fontSize ?? 12);
|
||
w(1, (p.text as string) ?? '');
|
||
break;
|
||
}
|
||
case 'dimension': {
|
||
const pts = (p.points as Pt[] | undefined) ?? [];
|
||
if (pts.length >= 2) {
|
||
w(0, 'LINE');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(10, pts[0].x); w(20, pts[0].y); w(30, 0);
|
||
w(11, pts[1].x); w(21, pts[1].y); w(31, 0);
|
||
const midX = (pts[0].x + pts[1].x) / 2;
|
||
const midY = (pts[0].y + pts[1].y) / 2;
|
||
const dist = Math.hypot(pts[1].x - pts[0].x, pts[1].y - pts[0].y);
|
||
w(0, 'TEXT');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(10, midX); w(20, midY); w(30, 0);
|
||
w(40, 12);
|
||
w(1, dist.toFixed(2));
|
||
}
|
||
break;
|
||
}
|
||
case 'block_instance': {
|
||
const mapped = nameMap.get(String(p.blockId ?? ''));
|
||
if (!mapped) {
|
||
writeBBoxPolyline(w, el, layerName, aci);
|
||
break;
|
||
}
|
||
w(0, 'INSERT');
|
||
w(8, layerName);
|
||
w(62, aci);
|
||
w(2, mapped);
|
||
w(10, el.x); w(20, el.y); w(30, 0);
|
||
const sx = typeof p.scaleX === 'number' ? p.scaleX : (typeof p.scale === 'number' ? p.scale : 1);
|
||
const sy = typeof p.scaleY === 'number' ? p.scaleY : (typeof p.scale === 'number' ? p.scale : 1);
|
||
w(41, sx);
|
||
w(42, sy);
|
||
w(50, p.rotation ?? 0); // Grad, direkt (keine radToDeg-Doppelkonvertierung)
|
||
// Attributwerte der Instanz → ATTRIB/SEQEND (Task F6)
|
||
const attrValues = p.attrValues as Record<string, string> | undefined;
|
||
if (attrValues && Object.keys(attrValues).length > 0) {
|
||
w(66, 1); // Attribute folgen
|
||
for (const [tag, value] of Object.entries(attrValues)) {
|
||
w(0, 'ATTRIB');
|
||
w(8, layerName);
|
||
w(10, el.x); w(20, el.y); w(30, 0);
|
||
w(40, 12);
|
||
w(1, value);
|
||
w(2, tag);
|
||
w(70, 0);
|
||
}
|
||
w(0, 'SEQEND');
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
// chair, seating-row, table, stage, revcloud, leader, image, … → BBox
|
||
writeBBoxPolyline(w, el, layerName, aci);
|
||
break;
|
||
}
|
||
}
|
||
|
||
function getLayerName(layers: CADLayer[], layerId: string): string {
|
||
return layers.find(l => l.id === layerId)?.name ?? '0';
|
||
}
|
||
|
||
function hexToACI(hex: string): number {
|
||
const h = hex.replace('#', '');
|
||
const r = parseInt(h.substring(0, 2), 16);
|
||
const g = parseInt(h.substring(2, 4), 16);
|
||
const b = parseInt(h.substring(4, 6), 16);
|
||
if (r > 200 && g < 100 && b < 100) return 1; // red
|
||
if (r > 200 && g > 200 && b < 100) return 2; // yellow
|
||
if (r < 100 && g > 200 && b < 100) return 3; // green
|
||
if (r < 100 && g > 200 && b > 200) return 4; // cyan
|
||
if (r < 100 && g < 100 && b > 200) return 5; // blue
|
||
if (r > 200 && g < 100 && b > 200) return 6; // magenta
|
||
if (r > 200 && g > 200 && b > 200) return 7; // white
|
||
if (r < 100 && g < 100 && b < 100) return 8; // gray
|
||
return 7;
|
||
}
|
||
|
||
function lineTypeToDXF(lt: string): string {
|
||
if (lt === 'dashed') return 'DASHED';
|
||
if (lt === 'dotted') return 'DOT';
|
||
return 'CONTINUOUS';
|
||
}
|