Layer farben werden in plant2dxf angenommen (Layer selber nicht), dxf2lib wurde refrectored für die Leserlichkeit

lib/dxf2lib.py

@@ -112,16 +112,6 @@ def get_bbox(entities):
                         (x1, y1), (x2, y2) = box.extmin, box.extmax
                         min_x, min_y = min(min_x, x1), min(min_y, y1)
                         max_x, max_y = max(max_x, x2), max(max_y, y2)
-            
-                
-            else:
-                
-                # Für andere Entity-Typen: Standard bbox() verwenden
-                box = e.bbox()
-                if box:
-                    (x1, y1), (x2, y2) = box.extmin, box.extmax
-                    min_x, min_y = min(min_x, x1), min(min_y, y1)
-                    max_x, max_y = max(max_x, x2), max(max_y, y2)
         except Exception as err:
             print(f"    BBox Fehler für {e.dxftype()}: {err}")
             continue
@@ -148,7 +138,7 @@ def create_block_library(input_dir, output_file, config, logger=None):
         logger: Optionaler Logger für Logging-Ausgaben
         
     Note:
-        - Unterstützte Entity-Typen: LINE, LWPOLYLINE, POLYLINE, SPLINE, CIRCLE, ARC
+        - Unterstützte Entity-Typen: LINE, LWPOLYLINE, POLYLINE, SPLINE, CIRCLE, ARC, INSERT
         - Blöcke werden zentriert und in einem 20x20 Raster angeordnet
         - Erstellt eine Log-Datei mit Zeitstempel für fehlerhafte Dateien
         - Automatische Erstellung des Output-Verzeichnisses falls nötig
@@ -177,7 +167,7 @@ def create_block_library(input_dir, output_file, config, logger=None):
             src_doc = ezdxf.readfile(filepath)
             src_msp = src_doc.modelspace()
             entities = list(src_msp)
-            allowed_types = {"LINE", "LWPOLYLINE", "POLYLINE", "SPLINE", "CIRCLE", "ARC"}
+            allowed_types = {"LINE", "LWPOLYLINE", "POLYLINE", "SPLINE", "CIRCLE", "ARC", "INSERT"}
             filtered_entities = []
             
             for e in entities:
@@ -217,7 +207,7 @@ def create_block_library(input_dir, output_file, config, logger=None):
                         doc.layers.add(name=layer_name)
         except Exception:
             pass
-        # if filename == "834372100":
+       
         
         center, ausdehnung = get_bbox(entities)
         if center is None:
@@ -233,39 +223,26 @@ def create_block_library(input_dir, output_file, config, logger=None):
             doc.blocks.delete_block(name)
 
         blk = doc.blocks.new(name=name, base_point=(0,0))
-    
+      
         for e in entities:
-            try:
+            # Sicherstellen, dass referenzierte Blöcke für INSERT verfügbar sind
-                cp = e.copy()
+            if e.dxftype() == "INSERT":
-                # Geometrie verschieben!
+                handle_insert_entities(doc, src_doc, e)
-                cp.translate(-center.x, -center.y, 0)
+            cp = copy_entity(logger, error_files, filename, e, center)
-                # Ursprungs-Layer übernehmen
+            if cp:
-                if hasattr(e.dxf, "layer"):
-                    cp.dxf.layer = e.dxf.layer
-                if (hasattr(e.dxf, "color")):
-                    cp.dxf.color = e.dxf.color
                 blk.add_entity(cp)
-                
-            except Exception as err:
-                error_msg = f"Fehler beim Verarbeiten von Entity {e.dxftype()} in {filename}: {err}"
-                if logger:
-                    logger.error(error_msg)
-                else:
-                    print(error_msg)
-                error_files.append((filename, error_msg))
-
         # Platzierung in Reihen und Spalten
         # Attribut-Definition (ATTDEF) hinzufügen
         blk.add_attdef(
             tag="NAME",
             insert=(0.2, 0.2),   # Position relativ zum Blockursprung
-            text="Default Text"
+            
         )
     
-        # Blockreferenz-Layer bestimmen
+         # Blockreferenz-Layer bestimmen
         blockref_layer = None
         try:
-            # Konfiguration erlaubt expliziten Layernamen
+             #Konfiguration erlaubt expliziten Layernamen
             cfg_layer = None
             try:
                 cfg_layer = config.get("dxf2lib", "blockref_layer")
@@ -360,6 +337,48 @@ def create_block_library(input_dir, output_file, config, logger=None):
     doc.saveas(output_file)
 
 
+def copy_entity(logger, error_files, filename, e, center):
+    try:
+        cp = e.copy()
+        # Geometrie verschieben!
+        cp.translate(-center.x, -center.y, 0)
+        # Ursprungs-Layer übernehmen
+        if hasattr(e.dxf, "layer"):
+            cp.dxf.layer = e.dxf.layer
+        if (hasattr(e.dxf, "color")):
+            cp.dxf.color = e.dxf.color
+        return cp
+
+    except Exception as err:
+        error_msg = f"Fehler beim Verarbeiten von Entity {e.dxftype()} in {filename}: {err}"
+        if logger:
+            logger.error(error_msg)
+        else:
+            print(error_msg)
+        error_files.append((filename, error_msg))
+        return None
+    
+def handle_insert_entities(doc, src_doc, e):
+    
+        try:
+            ref_name = e.dxf.name
+            if ref_name not in doc.blocks and ref_name in src_doc.blocks:
+                src_blk = src_doc.blocks[ref_name]
+                dst_blk = doc.blocks.new(name=ref_name)
+                # Basis­punkt übernehmen, falls vorhanden
+                try:
+                    dst_blk.block.dxf.base_point = src_blk.block.dxf.base_point
+                                
+                except Exception:
+                    pass
+                for ent in src_blk:
+                    dst_blk.add_entity(ent.copy())
+           
+            
+        except Exception:
+            pass
+
+
 # Standardwerte (falls nicht in der Config)
 DEFAULTS = {
     "text_height": 20,         # Schriftgröße des Texts (in DXF-Einheiten)

lib/plant2dxf.py

@@ -78,13 +78,51 @@ def parse_merkmale(merkmale_str: str) -> dict:
         return {}
 
 def import_block(block_name: str, from_doc, to_doc) -> None:
-    """Importiert Blockdefinition block_name von from_doc nach to_doc."""
+    """Importiert Blockdefinition block_name von from_doc nach to_doc.
+
+    - Kopiert alle Entities des Blocks
+    - Stellt sicher, dass benutzte Layer im Ziel existieren (mit Eigenschaften)
+    - Übernimmt Basis­punkt und Block-Layer, falls vorhanden
+    """
     if block_name in to_doc.blocks:
         return
     if block_name not in from_doc.blocks:
         raise ValueError(f"Block '{block_name}' nicht in Bibliothek gefunden.")
     src = from_doc.blocks[block_name]
+
+    # Sicherstellen, dass alle verwendeten Layer existieren
+    try:
+        used_layers = set()
+        for ent in src:
+            ln = getattr(getattr(ent, "dxf", object()), "layer", None)
+            if ln:
+                used_layers.add(ln)
+        for layer_name in used_layers:
+            if layer_name not in to_doc.layers:
+                try:
+                    src_layer = from_doc.layers.get(layer_name)
+                    to_doc.layers.add(
+                        name=layer_name,
+                        color=getattr(src_layer.dxf, "color"),
+                        linetype=getattr(src_layer.dxf, "linetype"),
+                        lineweight=getattr(src_layer.dxf, "lineweight"),
+                    )
+                except Exception:
+                    to_doc.layers.add(name=layer_name)
+    except Exception:
+        pass
+
     tgt = to_doc.blocks.new(name=block_name)
+    # Basis­punkt/Layer des Blocks übernehmen, wenn vorhanden
+    try:
+        tgt.block.dxf.base_point = src.block.dxf.base_point
+    except Exception:
+        pass
+    try:
+        tgt.block.dxf.layer = src.block.dxf.layer
+    except Exception:
+        pass
+
     for ent in src:
         tgt.add_entity(ent.copy())
 
@@ -311,9 +349,6 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols)
             print(f"[INFO] Omniflo Gerade → {teileid} Linie von ({start[0]:.1f}, {start[1]:.1f}) nach ({ende[0]:.1f}, {ende[1]:.1f})")
         return
     # Sonst wie gehabt: Block mit SivasNummer
-
-           
-
     if not lib_doc:
         print("[WARN] lib_doc nicht verfügbar, Block wird nicht eingefügt.")
         return
@@ -329,19 +364,21 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols)
     imported_block = doc.blocks.get(blockname)
     if hasattr(lib_block.block.dxf, "base_point"):
         imported_block.block.dxf.base_point = lib_block.block.dxf.base_point
-
+    if hasattr(lib_block.block.dxf, "layer"):
+        imported_block.block.dxf.layer= lib_block.block.dxf.layer
     drehung = merkmale.get("Drehung") 
     if drehung not in (0.0, 180.0):
         drehung = drehung -180 
-    bref = msp.add_blockref(blockname, (x, y), dxfattribs={"xscale": 1.0, "yscale":1.0,"rotation": drehung })
+    bref = msp.add_blockref(blockname, (x, y), dxfattribs={"xscale": 1.0, "yscale":1.0,"rotation": drehung, "layer": imported_block.block.dxf.layer })
   
     bref.add_attrib(
         tag= "NAME",
         text= merkmale.get("bezeichner"),
         insert = (x,y),
-        invisible =True
+        
-       
+        
-    )
+        
+       )
     bref.add_auto_attribs({ATTR_TAG: teileid})
     if verbose:
         print(f"[INFO] Block '{blockname}' (Omniflo) → {teileid} ({x:.1f}, {y:.1f})")