feat: initial commit web-cad-neu with docker-compose, frontend and backend

2026-06-26 10:50:24 +02:00
commit 4ec76fe406
102 changed files with 25722 additions and 0 deletions
@@ -0,0 +1,186 @@
+/**
+ * DXF Parser – converts DXF entities to CADElement[]
+ * Uses dxf-parser library
+ */
+import DxfParser from 'dxf-parser';
+import type { CADElement, CADLayer, CADProperties, ElementType } from '../types/cad.types';
+
+export interface DXFImportResult {
+  elements: CADElement[];
+  layers: CADLayer[];
+  warnings: string[];
+}
+
+let idCounter = 0;
+const nextId = () => `dxf-${Date.now()}-${idCounter++}`;
+
+/**
+ * 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;
+  if (!dxf) return { elements: [], layers: [], warnings: ['DXF parse returned null'] };
+  const warnings: string[] = [];
+  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
+  if (dxf.entities) {
+    for (const entity of dxf.entities) {
+      const el = entityToCADElement(entity, layerMap);
+      if (el) {
+        elements.push(el);
+      } else {
+        warnings.push(`Unsupported entity type: ${entity.type}`);
+      }
+    }
+  }
+
+  return { elements, layers: Array.from(layerMap.values()), warnings };
+}
+
+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;
+      const minX = Math.min(s.x, e.x);
+      const minY = Math.min(s.y, e.y);
+      const maxX = Math.max(s.x, e.x);
+      const maxY = Math.max(s.y, e.y);
+      return {
+        id: nextId(), type: 'line', layerId: layer.id,
+        x: minX, y: minY, width: maxX - minX, height: maxY - minY,
+        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 'LWPOLYLINE':
+    case 'POLYLINE': {
+      const pts = (entity.vertices || []).map((v: any) => ({ x: v.x, y: v.y }));
+      if (pts.length < 2) return null;
+      const minX = Math.min(...pts.map((p: any) => p.x));
+      const minY = Math.min(...pts.map((p: any) => p.y));
+      const maxX = Math.max(...pts.map((p: any) => p.x));
+      const maxY = Math.max(...pts.map((p: any) => p.y));
+      const isClosed = entity.shape === true;
+      const type: ElementType = isClosed ? 'polygon' : 'polyline';
+      return {
+        id: nextId(), type, layerId: layer.id,
+        x: minX, y: minY, width: maxX - minX, height: maxY - minY,
+        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 'INSERT': {
+      // Block reference — store as block_instance
+      const pos = entity.position;
+      if (!pos) return null;
+      return {
+        id: nextId(), type: 'block_instance', layerId: layer.id,
+        x: pos.x, y: pos.y, width: 0, height: 0,
+        properties: { ...baseProps, blockId: entity.name, scale: entity.scale || 1, rotation: entity.rotation || 0 },
+      };
+    }
+    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';
+}