habe die Bogen namen ins cofig eingefügt und habe denn namen der layer für die automatisiereung im config geändert um zu verdeutlichen was es tatsächlich ist

cfg/allgemein.cfg

@@ -32,4 +32,4 @@ blocks_per_row = 20
 # Vertikaler Abstand zwischen Zeilen im Raster (in DXF-Einheiten)
 block_spacing_y = 500
 # Nicht in die MittelPunkt Berechnung erlaubt
-not_allowed_in_center = ("A-GRUPPE","B-GRUPPE")
+automation_layer = ("A-GRUPPE","B-GRUPPE")

cfg/shapes.cfg

@@ -5,6 +5,13 @@ offset_symb2 = 0,0
 rot_symb1 = 0.0
 rot_symb2 = 0.0
 
+[ILS 2.0 Kreisel mit Pin]
+items = SP8, AN8
+offset_symb1 = 0,0
+offset_symb2 = 0,0
+rot_symb1 = 0.0
+rot_symb2 = 0.0
+
 [ILS 2.0 Gefällestrecke]
 items = EE DS, AE DS
 offset_symb1 = 0,-330
@@ -18,7 +25,24 @@ esoffset = 479.95
 [ILS 2.0 Variofoerderer]
 Umlenkstation = 499.3148,0,26.1680
 
-
+[ILS 2.0 Variofoerderer_Bogen_block_namen]
-
+bogen_51_auf = Vario_Bogen_auf_51°
-
+bogen_51_ab = Vario_Bogen_ab_51°
-
+bogen_45_auf = Vario_Bogen_auf_45°
+bogen_45_ab = Vario_Bogen_ab_45°
+bogen_39_auf = Vario_Bogen_auf_39°
+bogen_39_ab = Vario_Bogen_ab_39°
+bogen_33_auf = Vario_Bogen_auf_33°
+bogen_33_ab = Vario_Bogen_ab_33°
+bogen_27_auf = Vario_Bogen_auf_27°
+bogen_27_ab = Vario_Bogen_ab_27°
+bogen_21_auf = Vario_Bogen_auf_21°
+bogen_21_ab = Vario_Bogen_ab_21°
+bogen_15_auf = Vario_Bogen_auf_15°
+bogen_15_ab = Vario_Bogen_ab_15°
+bogen_12_auf = Vario_Bogen_auf_12°
+bogen_12_ab = Vario_Bogen_ab_12°
+bogen_6_auf = Vario_Bogen_auf_6°
+bogen_6_ab = Vario_Bogen_ab_6°
+bogen_3_auf = Vario_Bogen_auf_3°
+bogen_3_ab = Vario_Bogen_ab_3°

lib/dxf2lib.py

@@ -44,8 +44,7 @@ def create_block_library(input_dir, output_file, config, logger=None):
     max_blockspacing_y = 0
     
     for filename in os.listdir(input_dir):
-        if filename =='821104043.dxf':
+
-            test = 2
         if not filename.lower().endswith(".dxf"):
             continue
 
@@ -57,7 +56,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", "INSERT"}
+            allowed_types = {"LINE", "LWPOLYLINE", "POLYLINE", "SPLINE", "CIRCLE", "ARC", "INSERT","ATTDEF"}
             filtered_entities = []
             
             for e in entities:
@@ -477,17 +476,17 @@ def get_entity_bounding_box(e, doc,src_doc,filename,config, transform_matrix=Non
             if sampled:
                 bbox.extend(sampled)
                 
-        elif e.dxftype() == 'TEXT':
+        elif e.dxftype() == 'ATTDEF':
             # Vereinfachung: Nur Insert-Point berücksichtigen
             insert_point = Vec3(e.dxf.insert)
             if transform_matrix:
                 insert_point = transform_matrix.transform(insert_point)
-            bbox.extend([insert_point])
+          
             
         elif e.dxftype() == 'INSERT':
             # INSERT: Block-Inhalt mit Transformation berücksichtigen
             insert_bbox = calculate_insert_bounding_box(e, doc,src_doc,filename,config, transform_matrix)
-            if insert_bbox and insert_bbox.has_data and e.dxf.layer not in config.get("dxf2lib","not_allowed_in_center"):
+            if insert_bbox and insert_bbox.has_data and e.dxf.layer not in config.get("dxf2lib","automation_layer"):
                 bbox.extend(insert_bbox)
                 
     except Exception as e:

lib/plant2dxf.py

@@ -13,6 +13,7 @@ import configparser
 import ezdxf
 from ezdxf import units
 from ezdxf.entities import Line
+from ezdxf.addons import importer
 from ezdxf.math import Matrix44, X_AXIS,Y_AXIS,Z_AXIS
 from pathlib import Path
 import math
@@ -20,7 +21,7 @@ import re
 from utils import check_environment_var, setup_logger
 
 
-
+global_zaehler = 0
 # --------------------------------------------------------- CFG-Leser für shapes.cfg
 def get_shape_cfg(teileart, cfg_path, logger=None):
     parser = configparser.ConfigParser()
@@ -90,8 +91,14 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None:
     - Stellt sicher, dass benutzte Layer im Ziel existieren (mit Eigenschaften)
     - Übernimmt Basis­punkt und Block-Layer, falls vorhanden
     """
+ 
     src = from_doc.blocks[block_name]
     att_def = {}
+    if block_name == "Pinbereich":
+        imp = importer.Importer(from_doc, to_doc)
+
+        # Alle Linientypen importieren
+        imp.import_table("linetypes")
     if ((block_name in to_doc.blocks)):
         # speichern der attdef elemente in eine Liste falks diese verhanden sind und gibt diese zurück
         for ent in src:
@@ -103,9 +110,10 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None:
 
                 import_block(ent.dxf.name,from_doc, to_doc,None)
 
-        if att_def != []:
+        if att_def != {}:
             return att_def
         return
+
     if block_name not in from_doc.blocks:
         raise ValueError(f"Block '{block_name}' nicht in Bibliothek gefunden.")
     # Sicherstellen, dass alle verwendeten Layer existieren
@@ -149,9 +157,10 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None:
 
             import_block(ent.dxf.name,from_doc, to_doc,None)
         tgt.add_entity(copy)
-    if att_def != []:
+    if att_def != {}:
         return att_def
  
+
 def dreh_block(block_name: str, to_doc, winkel) :
     """Nimmt ein schon importierten Block und erstellt einen neuen der an der y_axis gedreht wird
       hauptsächlich für vario Bogen aktuell verwendet
@@ -205,7 +214,34 @@ def transform_coords(x: float, y: float, height: float) -> tuple[float, float]:
     """Transformiert Bildschirmkoordinaten (0,0 oben links) ins DXF-KoSy (0,0 unten links)."""
     return x, y -height
 
-def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config):
+def handle_ils_2_0_kreisel_mit_pin(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein):
+    merkmale["pin"] = "True"
+    handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein)
+
+
+def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein):
+    
+    scanner = float(merkmale.get("Anzahl der Scanner"))
+    separatoren = float(merkmale.get("Anzahl der Separatoren"))
+    block_scanner = "SCAN"
+    block_separatoren = "S-LP"
+    scanner_x = x
+    scanner_y = y
+    separatoren_x = x
+    separatoren_y = y + 160
+    import_block(block_scanner,lib_doc,doc)
+    import_block(block_separatoren,lib_doc,doc)
+    i = 0
+    while i < scanner:
+        msp.add_blockref(block_scanner, (scanner_x,scanner_y,float(merkmale.get("Höhe in m"))* 1000))
+        scanner_x = scanner_x + 300
+        i = i+1
+    
+    i = 0
+    while i < separatoren:
+        msp.add_blockref(block_separatoren, (separatoren_x,separatoren_y,float(merkmale.get("Höhe in m"))* 1000))
+        separatoren_x = separatoren_x + 300
+        i = i +1
     abstand_m = merkmale.get(
         "Abstand (Kreiselachse A - Kreiselachse) in Meter", "20"
     ).replace(",", ".")
@@ -242,11 +278,15 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose,
                 print(f"[INFO] Block '{blockname}' (Kreisel) → {teileid} "
                       f"({pos[0]:.1f}, {pos[1]:.1f}), rot={rotation}")
     # Linien zeichnen
-    draw_kreisel_lines(msp, pos1, pos2)
+    
+    import_block("Pinbereich",lib_doc,doc)
+    draw_kreisel_lines(msp, pos1, pos2,merkmale)
     draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc, verbose)
 
-def draw_kreisel_lines(msp, pos1, pos2):
+def draw_kreisel_lines(msp, pos1, pos2,merkmale):
     """Zeichnet tangentiale Linien zwischen zwei Kreiselblöcken, unabhängig vom Winkel."""
+    
+    
     x1, y1, z1 = pos1
     x2, y2, z1 = pos2
     # Verbindungsvektor
@@ -257,6 +297,7 @@ def draw_kreisel_lines(msp, pos1, pos2):
     if length == 0:
         return  # keine Linie bei identischen Punkten
     # Normalenvektor (senkrecht, normiert, Länge = RADIUS)
+
     nx = -dy / length * RADIUS
     ny = dx / length * RADIUS
     # Tangentialpunkte
@@ -264,10 +305,21 @@ def draw_kreisel_lines(msp, pos1, pos2):
     p1b = (x1 - nx, y1 - ny,z1)
     p2a = (x2 + nx, y2 + ny,z1)
     p2b = (x2 - nx, y2 - ny,z1)
+    if merkmale.get("Kreiselart") == "Pin":
+        
+        p1a2 = p1a[0] + RADIUS + 50, p1a[1] - 50, z1
+        p1b2 = p1b[0] + RADIUS + 50, p1b[1] + 50, z1
+        p2a2 = p2a[0] - RADIUS - 50, p2a[1] - 50, z1
+        p2b2 = p2b[0] - RADIUS - 50, p2b[1] + 50, z1
+        Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"})
+        Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"})
+        msp.add_entity(Line1)
+        msp.add_entity(Line2)
     # Linien zeichnen
     msp.add_line(p1a, p2a)
     msp.add_line(p1b, p2b)
     
+
 def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc, verbose):
     drehrichtung = merkmale.get("Drehrichtung", "").upper()
     if drehrichtung not in ("UZS", "GUZS"):
@@ -296,11 +348,11 @@ def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc
         rotation = math.degrees(math.atan2(p2_oben[1] - p1_oben[1], p2_oben[0] - p1_oben[0]))
         if drehrichtung == "GUZS":
             rotation += 180
-        import_block("S-LP", lib_doc, doc)
+        import_block("Richtungspfeil", lib_doc, doc)
-        blockref_layer = get_layer(doc, lib_doc, "S-LP")
+        blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil")
-        bref = msp.add_blockref("S-LP", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer})
+        bref = msp.add_blockref("Richtungspfeil", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer})
         if verbose:
-            print(f"[INFO] Drehrichtung '{drehrichtung}': S-LP oben bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
+            print(f"[INFO] Drehrichtung '{drehrichtung}': Richtungspfeil oben bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
     # S-LP auf unterer Linie (Drehrichtung invertiert)
     for i in range(1, 4):
         t = i / 4
@@ -309,11 +361,11 @@ def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc
         rotation = math.degrees(math.atan2(p2_unten[1] - p1_unten[1], p2_unten[0] - p1_unten[0]))
         if drehrichtung == "UZS":
             rotation += 180
-        import_block("S-LP", lib_doc, doc)
+        import_block("Richtungspfeil", lib_doc, doc)
-        blockref_layer = get_layer(doc, lib_doc, "S-LP")
+        blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil")
-        bref = msp.add_blockref("S-LP", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer})
+        bref = msp.add_blockref("Richtungspfeil", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer})
         if verbose:
-            print(f"[INFO] Drehrichtung '{drehrichtung}': S-LP unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
+            print(f"[INFO] Drehrichtung '{drehrichtung}':Richtungspfeil unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
 
 def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose):
     for blockname in blocknames:
@@ -326,15 +378,16 @@ def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose):
                   f"({x:.1f}, {y:.1f})")
 
 
-def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
+def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     import_block("AN8",lib_doc,doc)
     hight = float(merkmale.get("Höhe in m"))* 1000
     msp.add_blockref("AN8",(x,y,hight))
 
-def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
+def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     #Vorbereitung der attributen
 
-
+    if teileid == "shape_19c7aab6-f39d-ea60-24e2-e2a7ea7af5ba":
+        test = 3
     if "6-SP" not in doc.layers:
             doc.layers.add(name="6-SP", color=7)
     verbunden_am_einen = False
@@ -379,7 +432,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
             hoehe2 = upper_hoehe_gefaehlle
             upper_hoehe_gefaehlle = lower_hoehe_gefaehlle
             lower_hoehe_gefaehlle = hoehe2
-            winkel = winkel -180
+            rotation = rotation -180
+
 
 
         am_kreisel, kreisel_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None)
@@ -398,7 +452,16 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
             hight = "lower"
 
         blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}"
-
+        if blockname in doc.blocks:
+            blockref_layer = get_layer(doc, lib_doc, blockname)
+            bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer})
+            a =bref.add_attrib(
+                tag= "NAME",
+                text= merkmale.get("bezeichner"),
+                insert = (x,y)
+            )
+            a.is_invisible = True
+            return
         only_es_or_as = erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,hight)
         
         if only_es_or_as == False:
@@ -623,14 +686,17 @@ def add_attributes_to_block(block, attributes):
         )
         a.is_invisible = True
         
-def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
+def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     # für spätere Namens benenung der Vario forderer
-    motor_vorhanden = merkmale.get("Motor")
+    motor_vorhanden = bool(merkmale.get("hatMotor"))
-    umlenk_vorhanden = merkmale.get("Umlenk")
+    umlenk_vorhanden = bool(merkmale.get("hatUmlenkung"))
+    if merkmale.get("Laenge_Gefaellestrecke") != None:
+        gefahellewinkel =float(merkmale.get("Laenge_Gefaellestrecke"))
         
-    gefahellewinkel =float(merkmale.get("Gefahellewinkel"))
+        gefaelle = float(merkmale.get("Winkel_Gefaellestrecke"))
-     
+    else:
-    gefaelle = float(merkmale.get("Gefällestrecke"))
+        gefahellewinkel = 0.0
+        gefaelle = 0.0
     # Offsets für die Vario Linie für ab 3 bogen, da es in diesem Fall keine bögen hat die sich mit den nachbarn Bögen für andere Vario Förderer verbinden kann 
     winkel_VP_offset_vorne = None
     winkel_VP_offset_hinten = None
@@ -1144,17 +1210,20 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
 
 def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ):
     # Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss
-    motor_vorhanden = merkmale.get("Motor")
+    motor_vorhanden = bool(merkmale.get("hatMotor"))
-    umlenk_vorhanden = merkmale.get("Umlenk")
+    umlenk_vorhanden = bool(merkmale.get("hatUmlenkung"))
-   
+    if merkmale.get("Winkel_Gefaellestrecke") != None:
-    gefahellewinkel =float(merkmale.get("Gefahellewinkel"))
+        gefahellewinkel =float(merkmale.get("Winkel_Gefaellestrecke"))
-    gefaelle = float(merkmale.get("Gefällestrecke"))
+        gefaelle = float(merkmale.get("Laenge_Gefaellestrecke"))
+    else:
+        gefahellewinkel = 0.0
+        gefaelle = 0.0
     # Aktueller offset des motors und Umlenkungstation, wird wahrscheinlich später einfach berechnet (sobald man entschieden hat ob wir nur 3 grad neigung erlauben oder nicht)
     umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(","))
     # Berechnung des Gefälles
-    if motor_vorhanden  == "True":
+    if motor_vorhanden  == True:
         gefaelle = gefaelle - umlenk_motor_offset[0]
-    if umlenk_vorhanden == "True":
+    if umlenk_vorhanden == True:
         gefaelle = gefaelle - umlenk_motor_offset[0]
 
 
@@ -1165,7 +1234,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         if gefaelle > 0:
             # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird
             halbesgefaelle = gefaelle/2
-            if motor_vorhanden == "True" and umlenk_vorhanden == "True":
+            if motor_vorhanden == True and umlenk_vorhanden == True:
                 halbesgefaelle = gefaelle/2
                 gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* halbesgefaelle
                 line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
@@ -1183,7 +1252,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
                 block.add_entity(copy_start)
                 start = gefaelle_start
 
-            elif motor_vorhanden== "True":
+            elif motor_vorhanden== True:
                 gefaelle_start = start[0], start[1] -gefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * gefaelle
                 line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
                 line_start_gefaelle.dxf.layer = "6-SP"
@@ -1192,7 +1261,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
                 block.add_entity(copy_start)
                 start = gefaelle_start
 
-            elif umlenk_vorhanden== "True":
+            elif umlenk_vorhanden== True:
                 gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* gefaelle
                 line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
                 line_ende_gefaelle.dxf.layer = "6-SP"
@@ -1208,17 +1277,17 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc)
         block_Vario_Motorstation_500mm = dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(3))
         block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(3))
-        if umlenk_vorhanden == "True":
+        if umlenk_vorhanden == True:
             block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0]  -x,ende[1] -y + umlenk_motor_offset[0]/2,ende[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 90})
             ende = (ende[0] ,ende[1] + umlenk_motor_offset[0],ende[2] -umlenk_motor_offset[2])
-        if motor_vorhanden == "True":
+        if motor_vorhanden == True:
             block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - umlenk_motor_offset[0]/2 -y ,start[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 90})
             start = start[0]  , start[1] - umlenk_motor_offset[0],start[2] +umlenk_motor_offset[2]
             
         if winkel == 48:
             # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
-            block_Vario_Bogen_auf_51 = "Vario_Bogen_auf_51°"
+            block_Vario_Bogen_auf_51 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_51_auf"))
-            block_Vario_Bogen_ab_51 = "Vario_Bogen_ab_51°"
+            block_Vario_Bogen_ab_51 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_51_ab"))
            
             auf_51_attrib =import_block(block_Vario_Bogen_auf_51, lib_doc, doc)
             ab_51_attrib =import_block(block_Vario_Bogen_ab_51, lib_doc, doc)
@@ -1302,8 +1371,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
         elif winkel == 36:
             # Einfügen der 39 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
-            block_Vario_Bogen_auf_39 = "Vario_Bogen_auf_39°"
+            block_Vario_Bogen_auf_39 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_39_auf"))
-            block_Vario_Bogen_ab_39 = "Vario_Bogen_ab_39°"
+            block_Vario_Bogen_ab_39 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_39_ab"))
             auf_39_attrib =import_block(block_Vario_Bogen_auf_39, lib_doc, doc)
             ab_39_attrib =import_block(block_Vario_Bogen_ab_39, lib_doc, doc)
             block_Vario_Bogen_auf_39= dreh_block(block_Vario_Bogen_auf_39, doc,math.radians(3))
@@ -1390,97 +1459,97 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
         elif winkel == 24:
             # Einfügen der 27 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
-                block_Vario_Bogen_auf_27 = "Vario_Bogen_auf_27°"
+            block_Vario_Bogen_auf_27 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_27_auf"))
-                block_Vario_Bogen_ab_27 = "Vario_Bogen_ab_27°"
+            block_Vario_Bogen_ab_27 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_27_ab"))
-                auf_27_attrib =import_block(block_Vario_Bogen_auf_27, lib_doc, doc)
+            auf_27_attrib =import_block(block_Vario_Bogen_auf_27, lib_doc, doc)
-                ab_27_attrib = import_block(block_Vario_Bogen_ab_27, lib_doc, doc)
+            ab_27_attrib = import_block(block_Vario_Bogen_ab_27, lib_doc, doc)
-                block_Vario_Bogen_auf_27= dreh_block(block_Vario_Bogen_auf_27, doc,math.radians(3))
+            block_Vario_Bogen_auf_27= dreh_block(block_Vario_Bogen_auf_27, doc,math.radians(3))
-                block_Vario_Bogen_ab_27 = dreh_block(block_Vario_Bogen_ab_27, doc,math.radians(-24))
+            block_Vario_Bogen_ab_27 = dreh_block(block_Vario_Bogen_ab_27, doc,math.radians(-24))
-                Vario_Bogen_auf_27_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_0"]))
+            Vario_Bogen_auf_27_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_0"]))
-                Vario_Bogen_auf_27_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_1"]))
+            Vario_Bogen_auf_27_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_1"]))
-                Vario_Bogen_ab_27_Delta_SP_0  = list(float(att) for att in  re.split(r"[;,]", ab_27_attrib["DELTA_SP_0"]))
+            Vario_Bogen_ab_27_Delta_SP_0  = list(float(att) for att in  re.split(r"[;,]", ab_27_attrib["DELTA_SP_0"]))
-                Vario_Bogen_ab_27_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_1"]))
+            Vario_Bogen_ab_27_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_1"]))
-                Vario_Bogen_auf_27_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_VP_1"]))
+            Vario_Bogen_auf_27_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_VP_1"]))
-                Vario_Bogen_ab_27_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_VP_0"]))
+            Vario_Bogen_ab_27_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_VP_0"]))
         
             
-                Vario_Bogen_auf_27_Delta_SP_0 = [Vario_Bogen_auf_27_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_0[1],-Vario_Bogen_auf_27_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2] * math.cos(math.radians(3)) ]
+            Vario_Bogen_auf_27_Delta_SP_0 = [Vario_Bogen_auf_27_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_0[1],-Vario_Bogen_auf_27_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2] * math.cos(math.radians(3)) ]
-                Vario_Bogen_auf_27_Delta_SP_1 = [Vario_Bogen_auf_27_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_1[1],-Vario_Bogen_auf_27_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2] * math.cos(math.radians(3)) ]
+            Vario_Bogen_auf_27_Delta_SP_1 = [Vario_Bogen_auf_27_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_1[1],-Vario_Bogen_auf_27_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2] * math.cos(math.radians(3)) ]
-                Vario_Bogen_ab_27_Delta_SP_0 = [Vario_Bogen_ab_27_Delta_SP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_0[1],-Vario_Bogen_ab_27_Delta_SP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2] * math.cos(math.radians(-24)) ]
+            Vario_Bogen_ab_27_Delta_SP_0 = [Vario_Bogen_ab_27_Delta_SP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_0[1],-Vario_Bogen_ab_27_Delta_SP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2] * math.cos(math.radians(-24)) ]
-                Vario_Bogen_ab_27_Delta_SP_1 =[ Vario_Bogen_ab_27_Delta_SP_1 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_1[1],-Vario_Bogen_ab_27_Delta_SP_1[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2] * math.cos(math.radians(-24)) ]
+            Vario_Bogen_ab_27_Delta_SP_1 =[ Vario_Bogen_ab_27_Delta_SP_1 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_1[1],-Vario_Bogen_ab_27_Delta_SP_1[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2] * math.cos(math.radians(-24)) ]
-                Vario_Bogen_auf_27_Delta_VP_1 = [Vario_Bogen_auf_27_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_VP_1[1],-Vario_Bogen_auf_27_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2] * math.cos(math.radians(3)) ]
+            Vario_Bogen_auf_27_Delta_VP_1 = [Vario_Bogen_auf_27_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_VP_1[1],-Vario_Bogen_auf_27_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2] * math.cos(math.radians(3)) ]
-                Vario_Bogen_ab_27_Delta_VP_0 = [Vario_Bogen_ab_27_Delta_VP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_VP_0[1],-Vario_Bogen_ab_27_Delta_VP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2] * math.cos(math.radians(-24)) ]
+            Vario_Bogen_ab_27_Delta_VP_0 = [Vario_Bogen_ab_27_Delta_VP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_VP_0[1],-Vario_Bogen_ab_27_Delta_VP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2] * math.cos(math.radians(-24)) ]
             
-                # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss)
+            # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss)
 
-                for i, wert  in enumerate(Vario_Bogen_auf_27_Delta_SP_0):
+            for i, wert  in enumerate(Vario_Bogen_auf_27_Delta_SP_0):
-                    if i< 2 and wert < 0:
+                if i< 2 and wert < 0:
 
-                        Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert)
+                    Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert)
 
-                for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1):
+            for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1):
-                    if i< 2 and  wert< 0:
+                if i< 2 and  wert< 0:
-                        Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert)
+                    Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert)
                 
-                for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0):
+            for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0):
-                    if i< 2 and  wert< 0:
+                if i< 2 and  wert< 0:
-                        Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert)
+                    Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert)
 
-                for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1):
+            for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1):
-                    if i< 2 and  wert< 0:
+                if i< 2 and  wert< 0:
-                        Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert)
+                    Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert)
 
-                for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1):
+            for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1):
-                    if i< 2 and  wert< 0:
+                if i< 2 and  wert< 0:
-                        Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert)
+                    Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert)
                 
-                for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0):
+            for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0):
-                    if i< 2 and  wert< 0:
+                if i< 2 and  wert< 0:
-                        Vario_Bogen_ab_27_Delta_VP_0[i] = abs(wert)
+                    Vario_Bogen_ab_27_Delta_VP_0[i] = abs(wert)
 
 
 
-            #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
+        #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
-                block.add_blockref(block_Vario_Bogen_auf_27,(ende[0] -x ,ende[1] +Vario_Bogen_auf_27_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_27_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
+            block.add_blockref(block_Vario_Bogen_auf_27,(ende[0] -x ,ende[1] +Vario_Bogen_auf_27_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_27_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
             
-                ende_VP = (ende[0] +Vario_Bogen_auf_27_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_27_Delta_VP_1[0]+Vario_Bogen_auf_27_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_27_Delta_VP_1[2]- Vario_Bogen_auf_27_Delta_SP_0[2])
+            ende_VP = (ende[0] +Vario_Bogen_auf_27_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_27_Delta_VP_1[0]+Vario_Bogen_auf_27_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_27_Delta_VP_1[2]- Vario_Bogen_auf_27_Delta_SP_0[2])
-                ende = (ende[0]  ,ende[1] +Vario_Bogen_auf_27_Delta_SP_1[0] + Vario_Bogen_auf_27_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_27_Delta_SP_1[2] - Vario_Bogen_auf_27_Delta_SP_0[2])
+            ende = (ende[0]  ,ende[1] +Vario_Bogen_auf_27_Delta_SP_1[0] + Vario_Bogen_auf_27_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_27_Delta_SP_1[2] - Vario_Bogen_auf_27_Delta_SP_0[2])
 
-            #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
+        #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
-                block.add_blockref(block_Vario_Bogen_ab_27 ,(start[0]-x,start[1]  - Vario_Bogen_ab_27_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_27_Delta_SP_1[2]),dxfattribs={"rotation": 90})
+            block.add_blockref(block_Vario_Bogen_ab_27 ,(start[0]-x,start[1]  - Vario_Bogen_ab_27_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_27_Delta_SP_1[2]),dxfattribs={"rotation": 90})
-                start_VP = start[0] +Vario_Bogen_ab_27_Delta_VP_0[1],start[1]-Vario_Bogen_ab_27_Delta_VP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_27_Delta_VP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
+            start_VP = start[0] +Vario_Bogen_ab_27_Delta_VP_0[1],start[1]-Vario_Bogen_ab_27_Delta_VP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_27_Delta_VP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
-                start = start[0] ,start[1] - Vario_Bogen_ab_27_Delta_SP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0],start[2] +Vario_Bogen_ab_27_Delta_SP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
+            start = start[0] ,start[1] - Vario_Bogen_ab_27_Delta_SP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0],start[2] +Vario_Bogen_ab_27_Delta_SP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
             
-                # Erstellung der VARIO Line
+            # Erstellung der VARIO Line
-                line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
+            line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
-                line_VP.dxf.layer = "VARIO"
+            line_VP.dxf.layer = "VARIO"
-                copy_VP = line_VP.copy()
+            copy_VP = line_VP.copy()
 
-                copy_VP.translate(-x,-y,-hoehe_vario)
+            copy_VP.translate(-x,-y,-hoehe_vario)
-                block.add_entity(copy_VP)
+            block.add_entity(copy_VP)
         
-                # Erstellung der zwischen Line
+            # Erstellung der zwischen Line
-                line = Line.new(dxfattribs={"start": start, "end": ende})
+            line = Line.new(dxfattribs={"start": start, "end": ende})
-                line.dxf.layer = "6-SP"
+            line.dxf.layer = "6-SP"
 
-                copy= line.copy()
+            copy= line.copy()
 
-                copy.translate(-x,-y,-hoehe_vario)
+            copy.translate(-x,-y,-hoehe_vario)
-                block.add_entity(copy)
+            block.add_entity(copy)
 
-                #Hilfmethode zur ausmessen der bogen
+            #Hilfmethode zur ausmessen der bogen
 
-                # a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0))
+            # a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0))
-                # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0))
+            # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0))
-                # msp.add_line((x,y+1000,0),(x,y-1000,0))
+            # msp.add_line((x,y+1000,0),(x,y-1000,0))
-                # add_attributes_to_block(a, ab_27_attrib)
+            # add_attributes_to_block(a, ab_27_attrib)
 
 
 
         elif winkel == 15:
                 # Einfügen der 18 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
-                block_Vario_Bogen_ab_18 = "Vario_Bogen_ab_18°"
+                block_Vario_Bogen_auf_18 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_18_auf"))
-                block_Vario_Bogen_auf_18 = "Vario_Bogen_auf_18°"
+                block_Vario_Bogen_ab_18 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_18_ab"))
                 auf_18_attrib =import_block(block_Vario_Bogen_auf_18, lib_doc, doc)
                 ab_18_attrib = import_block(block_Vario_Bogen_ab_18, lib_doc, doc,)
                 block_Vario_Bogen_auf_18 = dreh_block(block_Vario_Bogen_auf_18,  doc,math.radians(3))
@@ -1566,8 +1635,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 12:
             # Einfügen der 15 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_Bogen_ab_15 = "Vario_Bogen_ab_15°"
+            block_Vario_Bogen_auf_15 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_15_auf"))
-            block_Vario_Bogen_auf_15 = "Vario_Bogen_auf_15°"
+            block_Vario_Bogen_ab_15 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_15_ab"))
             auf_15_attrib =import_block(block_Vario_Bogen_auf_15, lib_doc, doc)
             ab_15_attrib =import_block(block_Vario_Bogen_ab_15, lib_doc, doc)
             block_Vario_Bogen_auf_15=  dreh_block(block_Vario_Bogen_auf_15, doc,math.radians(3))
@@ -1656,8 +1725,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 9:
             # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_Bogen_ab_12 = "Vario_Bogen_ab_12°"
+            block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf"))
-            block_Vario_Bogen_auf_12 = "Vario_Bogen_auf_12°"
+            block_Vario_Bogen_ab_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_ab"))
             auf_12_attrib =import_block(block_Vario_Bogen_auf_12, lib_doc, doc)
             ab_12_attrib =import_block(block_Vario_Bogen_ab_12, lib_doc, doc)
             block_Vario_Bogen_auf_12 = dreh_block(block_Vario_Bogen_auf_12, doc,math.radians(3))
@@ -1744,12 +1813,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 3:
             # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_ab_6 = "Vario_Bogen_ab_6°"
+            block_Vario_Bogen_auf_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf"))
-            block_Vario_auf_6 = "Vario_Bogen_auf_6°"
+            block_Vario_Bogen_ab_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_ab"))
-            ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc)
+            ab_6_attrib =import_block( block_Vario_Bogen_ab_6 , lib_doc, doc)
-            auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc)
+            auf_6_attrib =import_block( block_Vario_Bogen_auf_6 , lib_doc, doc)
-            block_Vario_ab_6 = dreh_block( block_Vario_ab_6, doc, math.radians(3))
+            block_Vario_Bogen_ab_6 = dreh_block( block_Vario_Bogen_ab_6, doc, math.radians(3))
-            block_Vario_auf_6 = dreh_block( block_Vario_auf_6 , doc, math.radians(-3))
+            block_Vario_Bogen_auf_6 = dreh_block( block_Vario_Bogen_auf_6 , doc, math.radians(-3))
             Vario_Bogen_auf_6_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_6_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_6_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_0"]))
@@ -1793,14 +1862,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
 
-            block.add_blockref(block_Vario_auf_6,(ende[0] -x ,ende[1] +Vario_Bogen_auf_6_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_6_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
+            block.add_blockref(block_Vario_Bogen_auf_6,(ende[0] -x ,ende[1] +Vario_Bogen_auf_6_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_6_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
 
             ende_VP = (ende[0] +Vario_Bogen_auf_6_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_6_Delta_VP_1[0]+Vario_Bogen_auf_6_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_6_Delta_VP_1[2]- Vario_Bogen_auf_6_Delta_SP_0[2])
             ende = (ende[0]  ,ende[1] +Vario_Bogen_auf_6_Delta_SP_1[0] + Vario_Bogen_auf_6_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_6_Delta_SP_1[2] - Vario_Bogen_auf_6_Delta_SP_0[2])
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_6 ,(start[0]-x,start[1]  - Vario_Bogen_ab_6_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_6_Delta_SP_1[2]),dxfattribs={"rotation": 90})
+            block.add_blockref(block_Vario_Bogen_ab_6 ,(start[0]-x,start[1]  - Vario_Bogen_ab_6_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_6_Delta_SP_1[2]),dxfattribs={"rotation": 90})
             
             start_VP = start[0] +Vario_Bogen_ab_6_Delta_VP_0[1],start[1]-Vario_Bogen_ab_6_Delta_VP_0[0] - Vario_Bogen_ab_6_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_6_Delta_VP_0[2] - Vario_Bogen_ab_6_Delta_SP_1[2]
             start = start[0] ,start[1] - Vario_Bogen_ab_6_Delta_SP_0[0] - Vario_Bogen_ab_6_Delta_SP_1[0],start[2] +Vario_Bogen_ab_6_Delta_SP_0[2] - Vario_Bogen_ab_6_Delta_SP_1[2]
@@ -1831,8 +1900,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 0:
             # Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_Bogen_auf_3 = "Vario_Bogen_auf_3°"
+            block_Vario_Bogen_auf_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_auf"))
-            block_Vario_Bogen_ab_3 = "Vario_Bogen_ab_3°"
+            block_Vario_Bogen_ab_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_ab"))
             auf_3_attrib =import_block(block_Vario_Bogen_auf_3, lib_doc, doc)
             ab_3_attrib = import_block(block_Vario_Bogen_ab_3, lib_doc, doc)
             block_Vario_Bogen_auf_3= dreh_block(block_Vario_Bogen_auf_3, doc,math.radians(3))
@@ -1919,7 +1988,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird
 
         if gefaelle > 0:
-            if motor_vorhanden == "True" and umlenk_vorhanden == "True":
+            if motor_vorhanden == True and umlenk_vorhanden == True:
                 halbesgefaelle = gefaelle/2
                 gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* halbesgefaelle
                 line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
@@ -1936,7 +2005,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
                 copy_start.translate(-x,-y,-hoehe_vario)
                 block.add_entity(copy_start)
                 start = gefaelle_start
-            elif motor_vorhanden == "True":
+            elif motor_vorhanden == True:
                 gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* gefaelle
                 line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
                 line_ende_gefaelle.dxf.layer = "6-SP"
@@ -1944,7 +2013,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
                 copy_ende.translate(-x,-y,-hoehe_vario)
                 block.add_entity(copy_ende)
                 ende = gefaelle_ende
-            elif umlenk_vorhanden == "True":
+            elif umlenk_vorhanden == True:
                 gefaelle_start = start[0], start[1] -gefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * gefaelle
                 line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
                 line_start_gefaelle.dxf.layer = "6-SP"
@@ -1960,13 +2029,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc)
         block_Vario_Motorstation_500mm =  dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(3))
         block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm ,  doc,math.radians(3))
-        if umlenk_vorhanden == "True":
+        if umlenk_vorhanden == True:
             block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0]  -x,start[1] -y - umlenk_motor_offset[0]/2, start[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 270})
             start_Umlenkstation_VP = start[0] - 66.5, start[1] -500 *math.cos(math.radians(-3))+ math.sin(math.radians(-3))* -45,start[2] + math.sin(math.radians(-3))*500+ math.cos(math.radians(-3))*-45
             start = (start[0] ,start[1] - umlenk_motor_offset[0],start[2] -umlenk_motor_offset[2])
         elif winkel == 3:
             start_Umlenkstation_VP = start[0] - 66.5, start[1]+ winkel_VP_offset_vorne[0],start[2] -winkel_VP_offset_hinten[2]
-        if motor_vorhanden == "True":
+        if motor_vorhanden == True:
             block.add_blockref(block_Vario_Motorstation_500mm, (ende[0]-x , ende[1] + umlenk_motor_offset[0]/2 -y ,ende[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 270})
             ende_Motor_VP = ende[0] - 66.5, ende[1] +500 *math.cos(math.radians(-3))+ math.sin(math.radians(-3))* -45,ende[2] - math.sin(math.radians(-3))*500+ math.cos(math.radians(-3))*-45
 
@@ -1976,13 +2045,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
         if winkel == 48:
             # Einfügen der 45 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
-
+            block_Vario_Bogen_auf_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_auf"))
-            block_Vario_ab_45 = "Vario_Bogen_ab_45°"
+            block_Vario_Bogen_ab_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_ab"))
-            block_Vario_auf_45 = "Vario_Bogen_auf_45°"
+            ab_45_attrib =import_block( block_Vario_Bogen_ab_45 , lib_doc, doc)
-            ab_45_attrib =import_block( block_Vario_ab_45 , lib_doc, doc)
+            auf_45_attrib =import_block( block_Vario_Bogen_auf_45, lib_doc, doc)
-            auf_45_attrib =import_block( block_Vario_auf_45 , lib_doc, doc)
+            block_Vario_Bogen_ab_45 = dreh_block( block_Vario_Bogen_ab_45, doc, math.radians(3))
-            block_Vario_ab_45 = dreh_block( block_Vario_ab_45 , doc, math.radians(3))
+            block_Vario_Bogen_auf_45= dreh_block( block_Vario_Bogen_auf_45, doc, math.radians(48))
-            block_Vario_auf_45 = dreh_block( block_Vario_auf_45 , doc, math.radians(48))
             Vario_Bogen_auf_45_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_45_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_45_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_45_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_45_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_45_attrib["DELTA_SP_0"]))
@@ -2026,14 +2094,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270})
             start_VP = start[0] -Vario_Bogen_ab_45_Delta_VP_1[1],start[1]- Vario_Bogen_ab_45_Delta_VP_1[0]- Vario_Bogen_ab_45_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_45_Delta_VP_1[2]-Vario_Bogen_ab_45_Delta_SP_0[2]
 
             start =(start[0], start[1]- Vario_Bogen_ab_45_Delta_SP_0[0]- Vario_Bogen_ab_45_Delta_SP_1[0],start[2]-Vario_Bogen_ab_45_Delta_SP_0[2]+Vario_Bogen_ab_45_Delta_SP_1[2])
             
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
 
-            block.add_blockref(block_Vario_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270})
             ende_VP = (ende[0] -Vario_Bogen_auf_45_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_45_Delta_VP_0[0]+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_45_Delta_VP_0[2]- Vario_Bogen_auf_45_Delta_SP_1[2])
             ende = (ende[0],ende[1]+ Vario_Bogen_auf_45_Delta_SP_1[0]+ Vario_Bogen_auf_45_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_45_Delta_SP_1[2]+ Vario_Bogen_auf_45_Delta_SP_0[2])
            
@@ -2064,12 +2132,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 36:
             # Einfügen der 33 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_ab_33 = "Vario_Bogen_ab_33°"
+            block_Vario_Bogen_auf_33 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_33_auf"))
-            block_Vario_auf_33 = "Vario_Bogen_auf_33°"
+            block_Vario_Bogen_ab_33 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_33_ab"))
-            ab_33_attrib =import_block( block_Vario_ab_33 , lib_doc, doc)
+            ab_33_attrib =import_block( block_Vario_Bogen_ab_33  , lib_doc, doc)
-            auf_33_attrib =import_block( block_Vario_auf_33 , lib_doc, doc)
+            auf_33_attrib =import_block(block_Vario_Bogen_auf_33, lib_doc, doc)
-            block_Vario_ab_33 = dreh_block( block_Vario_ab_33 , doc, math.radians(3))
+            block_Vario_Bogen_ab_33 = dreh_block(block_Vario_Bogen_ab_33 , doc, math.radians(3))
-            block_Vario_auf_33 = dreh_block( block_Vario_auf_33 , doc, math.radians(36))
+            block_Vario_Bogen_auf_33= dreh_block(block_Vario_Bogen_auf_33 , doc, math.radians(36))
             Vario_Bogen_auf_33_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_33_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_33_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_33_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_33_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_33_attrib["DELTA_SP_0"]))
@@ -2113,13 +2181,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_33, (start[0]-x,start[1]-y- Vario_Bogen_ab_33_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_33_Delta_SP_0[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_ab_33, (start[0]-x,start[1]-y- Vario_Bogen_ab_33_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_33_Delta_SP_0[2]),dxfattribs={"rotation": 270})
             start_VP = start[0] -Vario_Bogen_ab_33_Delta_VP_1[1],start[1]- Vario_Bogen_ab_33_Delta_VP_1[0]- Vario_Bogen_ab_33_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_33_Delta_VP_1[2]-Vario_Bogen_ab_33_Delta_SP_0[2]
             start =(start[0], start[1]- Vario_Bogen_ab_33_Delta_SP_0[0]- Vario_Bogen_ab_33_Delta_SP_1[0],start[2]-Vario_Bogen_ab_33_Delta_SP_0[2]+Vario_Bogen_ab_33_Delta_SP_1[2])
 
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
 
-            block.add_blockref(block_Vario_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_33_Delta_SP_1[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_33_Delta_SP_1[2]),dxfattribs={"rotation": 270})
             ende_VP = (ende[0] -Vario_Bogen_auf_33_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_33_Delta_VP_0[0]+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_33_Delta_VP_0[2]- Vario_Bogen_auf_33_Delta_SP_1[2])
             ende = (ende[0],ende[1]+ Vario_Bogen_auf_33_Delta_SP_0[0]+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_33_Delta_SP_0[2]- Vario_Bogen_auf_33_Delta_SP_1[2])
             
@@ -2148,12 +2216,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 24:
             # Einfügen der 21 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_ab_21 = "Vario_Bogen_ab_21°"
+            block_Vario_Bogen_auf_21 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_auf"))
-            block_Vario_auf_21 = "Vario_Bogen_auf_21°"
+            block_Vario_Bogen_ab_21 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_ab"))
-            ab_21_attrib =import_block( block_Vario_ab_21 , lib_doc, doc)
+            ab_21_attrib =import_block(block_Vario_Bogen_ab_21, lib_doc, doc)
-            auf_21_attrib =import_block( block_Vario_auf_21 , lib_doc, doc)
+            auf_21_attrib =import_block(block_Vario_Bogen_auf_21 , lib_doc, doc)
-            block_Vario_ab_21 = dreh_block( block_Vario_ab_21 , doc, math.radians(3))
+            block_Vario_Bogen_ab_21= dreh_block(block_Vario_Bogen_ab_21 , doc, math.radians(3))
-            block_Vario_auf_21 = dreh_block( block_Vario_auf_21 , doc, math.radians(24))
+            block_Vario_Bogen_auf_21 = dreh_block(block_Vario_Bogen_auf_21 , doc, math.radians(24))
             Vario_Bogen_auf_21_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_21_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_21_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_21_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_21_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_21_attrib["DELTA_SP_0"]))
@@ -2197,14 +2265,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270})
            
             start_VP = start[0] -Vario_Bogen_ab_21_Delta_VP_1[1],start[1]- Vario_Bogen_ab_21_Delta_VP_1[0]- Vario_Bogen_ab_21_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_21_Delta_VP_1[2]-Vario_Bogen_ab_21_Delta_SP_0[2]
 
             start =(start[0], start[1]- Vario_Bogen_ab_21_Delta_SP_0[0]- Vario_Bogen_ab_21_Delta_SP_1[0],start[2]-Vario_Bogen_ab_21_Delta_SP_0[2]+Vario_Bogen_ab_21_Delta_SP_1[2])
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
 
-            block.add_blockref(block_Vario_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_21_Delta_SP_1[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_21_Delta_SP_1[2]),dxfattribs={"rotation": 270})
             ende_VP = (ende[0] -Vario_Bogen_auf_21_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_21_Delta_VP_0[0]+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_21_Delta_VP_0[2]- Vario_Bogen_auf_21_Delta_SP_1[2])
 
             ende = (ende[0],ende[1]+ Vario_Bogen_auf_21_Delta_SP_0[0]+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_21_Delta_SP_0[2]- Vario_Bogen_auf_21_Delta_SP_1[2])
@@ -2233,12 +2301,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 15:
             # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_ab_12 = "Vario_Bogen_ab_12°"
+            block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf"))
-            block_Vario_auf_12 = "Vario_Bogen_auf_12°"
+            block_Vario_Bogen_ab_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_ab"))
-            ab_12_attrib =import_block( block_Vario_ab_12 , lib_doc, doc)
+            ab_12_attrib =import_block(block_Vario_Bogen_ab_12, lib_doc, doc)
-            auf_12_attrib =import_block( block_Vario_auf_12 , lib_doc, doc)
+            auf_12_attrib =import_block( block_Vario_Bogen_auf_12 , lib_doc, doc)
-            block_Vario_ab_12 = dreh_block( block_Vario_ab_12, doc, math.radians(3))
+            block_Vario_Bogen_ab_12 = dreh_block(block_Vario_Bogen_ab_12, doc, math.radians(3))
-            block_Vario_auf_12 = dreh_block( block_Vario_auf_12 , doc, math.radians(15))
+            block_Vario_Bogen_auf_12 = dreh_block(block_Vario_Bogen_auf_12 , doc, math.radians(15))
             Vario_Bogen_auf_12_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_12_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_12_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_12_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_12_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_SP_0"]))
@@ -2283,14 +2351,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270})
             start_VP = start[0] -Vario_Bogen_ab_12_Delta_VP_1[1],start[1]- Vario_Bogen_ab_12_Delta_VP_1[0]- Vario_Bogen_ab_12_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_12_Delta_VP_1[2]-Vario_Bogen_ab_12_Delta_SP_0[2]
 
             start =(start[0], start[1]- Vario_Bogen_ab_12_Delta_SP_0[0]- Vario_Bogen_ab_12_Delta_SP_1[0],start[2]-Vario_Bogen_ab_12_Delta_SP_0[2]+Vario_Bogen_ab_12_Delta_SP_1[2])
 
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
 
-            block.add_blockref(block_Vario_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270})
 
             ende_VP = (ende[0] -Vario_Bogen_auf_12_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_12_Delta_VP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_VP_0[2]- Vario_Bogen_auf_12_Delta_SP_1[2])
 
@@ -2321,13 +2389,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
         elif winkel == 12:
             # Einfügen der 9 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
-
+            block_Vario_Bogen_auf_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_auf"))
-            block_Vario_ab_9 = "Vario_Bogen_ab_9°"
+            block_Vario_Bogen_ab_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_ab"))
-            block_Vario_auf_9 = "Vario_Bogen_auf_9°"
+            ab_9_attrib =import_block( block_Vario_Bogen_ab_9 , lib_doc, doc)
-            ab_9_attrib =import_block( block_Vario_ab_9 , lib_doc, doc)
+            auf_9_attrib =import_block(block_Vario_Bogen_auf_9  , lib_doc, doc)
-            auf_9_attrib =import_block( block_Vario_auf_9 , lib_doc, doc)
+            block_Vario_Bogen_ab_9 = dreh_block( block_Vario_Bogen_ab_9, doc, math.radians(3))
-            block_Vario_ab_9 = dreh_block( block_Vario_ab_9, doc, math.radians(3))
+            block_Vario_Bogen_auf_9  = dreh_block(block_Vario_Bogen_auf_9, doc, math.radians(12))
-            block_Vario_auf_9 = dreh_block( block_Vario_auf_9 , doc, math.radians(12))
             Vario_Bogen_auf_9_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_9_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_9_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_9_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_9_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_9_attrib["DELTA_SP_0"]))
@@ -2372,14 +2439,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270})
             
             start_VP = start[0] -Vario_Bogen_ab_9_Delta_VP_1[1],start[1]- Vario_Bogen_ab_9_Delta_VP_1[0]- Vario_Bogen_ab_9_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_9_Delta_VP_1[2]-Vario_Bogen_ab_9_Delta_SP_0[2]
             start =(start[0], start[1]- Vario_Bogen_ab_9_Delta_SP_0[0]- Vario_Bogen_ab_9_Delta_SP_1[0],start[2]-Vario_Bogen_ab_9_Delta_SP_0[2]+Vario_Bogen_ab_9_Delta_SP_1[2])
 
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
 
-            block.add_blockref(block_Vario_auf_9, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_auf_9 , (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270})
             ende_VP = (ende[0] -Vario_Bogen_auf_9_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_9_Delta_VP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_VP_0[2]-Vario_Bogen_auf_9_Delta_SP_1[2])
 
             ende = (ende[0],ende[1]+ Vario_Bogen_auf_9_Delta_SP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_SP_0[2]- Vario_Bogen_auf_9_Delta_SP_1[2])
@@ -2413,12 +2480,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
         elif winkel == 9:
             # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
 
-            block_Vario_ab_6 = "Vario_Bogen_ab_6°"
+            block_Vario_Bogen_auf_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf"))
-            block_Vario_auf_6 = "Vario_Bogen_auf_6°"
+            block_Vario_Bogen_ab_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_ab"))
-            ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc)
+            ab_6_attrib =import_block(block_Vario_Bogen_ab_6 , lib_doc, doc)
-            auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc)
+            auf_6_attrib =import_block(block_Vario_Bogen_auf_6, lib_doc, doc)
-            block_Vario_ab_6 = dreh_block( block_Vario_ab_6, doc, math.radians(3))
+            block_Vario_Bogen_ab_6 = dreh_block(block_Vario_Bogen_ab_6, doc, math.radians(3))
-            block_Vario_auf_6 = dreh_block( block_Vario_auf_6 , doc, math.radians(9))
+            block_Vario_Bogen_auf_6 = dreh_block(block_Vario_Bogen_auf_6 , doc, math.radians(9))
             Vario_Bogen_auf_6_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_0"]))
             Vario_Bogen_auf_6_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_1"]))
             Vario_Bogen_ab_6_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_0"]))
@@ -2463,12 +2530,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
 
             #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
 
-            block.add_blockref(block_Vario_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270})
             start_VP = start[0] -Vario_Bogen_ab_6_Delta_VP_1[1],start[1]- Vario_Bogen_ab_6_Delta_VP_1[0]- Vario_Bogen_ab_6_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_6_Delta_VP_1[2]-Vario_Bogen_ab_6_Delta_SP_0[2]
             start =(start[0], start[1]- Vario_Bogen_ab_6_Delta_SP_0[0]- Vario_Bogen_ab_6_Delta_SP_1[0],start[2]-Vario_Bogen_ab_6_Delta_SP_0[2]+Vario_Bogen_ab_6_Delta_SP_1[2])
             
             #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie            
-            block.add_blockref(block_Vario_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_6_Delta_SP_1[2]),dxfattribs={"rotation": 270})
+            block.add_blockref(block_Vario_Bogen_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_6_Delta_SP_1[2]),dxfattribs={"rotation": 270})
             ende_VP = (ende[0] -Vario_Bogen_auf_6_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_6_Delta_VP_0[0]+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_6_Delta_VP_0[2]- Vario_Bogen_auf_6_Delta_SP_1[2])
 
             ende = (ende[0],ende[1]+ Vario_Bogen_auf_6_Delta_SP_0[0]+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_6_Delta_SP_0[2]- Vario_Bogen_auf_6_Delta_SP_1[2])
@@ -2530,12 +2597,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
             block_links.add_entity(clone)
 
 
-def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
+def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     """
     Für Omniflo Gerade: zeichnet eine Linie (Mitte = Koordinate, Länge und Winkel aus Merkmale).
     Für alle anderen Omniflo-Typen: Block mit SivasNummer an den Koordinaten.
     """
     # Prüfen, ob es sich um eine Gerade handelt
+    global global_zaehler
     if merkmale.get("Länge in Meter") is not None and merkmale.get("Winkel") is not None:
         try:
             laenge = float(merkmale.get("Länge in Meter", "0").replace(",", ".")) * 1000  # Meter → mm
@@ -2573,23 +2641,25 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,
     if blockname not in lib_doc.blocks:
         print(f"[WARN] Omniflo-Block '{blockname}' nicht in Bibliothek {lib_doc.filename}. Überspringe {teileid}.")
         return
-    import_block(blockname, lib_doc, doc)
+    blockname = blockname
-    blockref_layer = get_layer(doc, lib_doc, blockname)
     drehung = merkmale.get("Drehung")
 
-    bref = msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"xscale": 1.0, "yscale":1.0,"rotation": drehung, "layer": blockref_layer})
         
-    a =bref.add_attrib(
+    import_block(blockname, lib_doc, doc)
-        tag= "NAME",
+    
-        text= merkmale.get("bezeichner"),
+    # blockref_layer = get_layer(doc, lib_doc, blockname)
-        insert = (x,y)
+    symblos_layers = config_allgemein.get("dxf2lib","automation_layer")
+
+    drehung = merkmale.get("Drehung")
+
+    bref = msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"rotation": drehung})
+          # Layer, auf dem der Insert liegt
+
+
+
+
 
 
-       )
-    a.is_invisible = True
-    bref.add_auto_attribs({ATTR_TAG: teileid})
-    if verbose:
-        print(f"[INFO] Block '{blockname}' (Omniflo) → {teileid} ({x:.1f}, {y:.1f})")
 
 
 
@@ -2704,8 +2774,10 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff
             copy.translate(-x ,-y,-hoehe_gefaehlle)
             block.add_entity(copy)
             block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180})
+            return False
         else:
             msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle),dxfattribs={"rotation": 180})
+            return True
 
     elif (( blockname not in doc.blocks and hight == "lower" and drehung0 == "UZS") or (vario_richtung == "Auf" and verbungden_höher == True and drehung0 == "UZS")  or (vario_richtung == "Ab" and verbungden_höher == False and drehung0 == "UZS")):
         if hight != None:
@@ -3426,7 +3498,7 @@ def get_rotations_of_strecken(csv_path:Path) -> dict:
                 Id = row["TeileId"].strip()
                 NachbarIds = row["NachbarIds"].strip()
                 geraden.append({"Id": Id, "NachbarIds": NachbarIds})
-            if bezeichner == "ILS 2.0 Kreisel":
+            if bezeichner == "ILS 2.0 Kreisel" or bezeichner == "ILS 2.0 Kreisel mit Pin":
                 Id = row["TeileId"].strip()
                 planquadrat = row["Planquadrat"]
                 x, y = extract_coords(planquadrat)
@@ -3501,20 +3573,28 @@ def get_rotations_of_strecken(csv_path:Path) -> dict:
 
 
 # --------------------------------------------------------- Hauptfunktion
-def main(csv_path: Path, lib_path: Path, cfg_path: Path,
+def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Path,
          output_path: Path, verbose=False, logger=None):
 
     # Bibliothek nur laden, wenn Datei existiert
     check_dxflibrary_path(lib_path, verbose, logger)
-    parser = configparser.ConfigParser()
+    parser_cfg_path = configparser.ConfigParser()
     try:
         with open(cfg_path, encoding='utf-8') as f:
-            parser.read_file(f)
+            parser_cfg_path.read_file(f)
     except Exception as e:
         msg = f"Fehler beim Lesen der Config-Datei {cfg_path}: {e}"
     # Neue Ziel­zeichnung (DXF R2018)
-    config =parser
+    config =parser_cfg_path
-    doc = ezdxf.new(dxfversion="R2018")
+    parser_allgemein_path = configparser.ConfigParser()
+    try:
+        with open(allgemein_cfg_path, encoding='utf-8') as f:
+            parser_allgemein_path.read_file(f)
+    except Exception as e:
+        msg = f"Fehler beim Lesen der Config-Datei {cfg_path}: {e}"
+    # Neue Ziel­zeichnung (DXF R2018)
+    config_allgemein =parser_allgemein_path
+    doc = ezdxf.new(dxfversion="R2018", setup=True)
     doc.units = units.M
     doc.header['$INSUNITS'] = 4  # Millimeter
     msp = doc.modelspace()
@@ -3538,6 +3618,8 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path,
     # rot_of_gf["shape_3ae53a7b-efb8-f66b-eadc-20b99f949ef1"] = ('UZ', 'GUZ')
 
     # Verarbeitung der Blöcke
+   
+
     with csv_path.open(newline="", encoding="utf-8") as fh:
         reader = csv.DictReader(fh, delimiter=';')
         for row in reader:
@@ -3590,7 +3672,7 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path,
             if func_name.startswith('handle_omniflo'):
                 handler = globals().get('handle_omniflo')
             if handler:
-                handler(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn, config)
+                handler(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn, config,config_allgemein)
             else:
                 msg = f"[WARN] Keine Routine für TeileArt '{teileart}'. Überspringe '{teileid}'."
                 if logger:
@@ -3600,6 +3682,19 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path,
                 continue
 
     # DXF speichern
+    for insert in msp.query("INSERT"):
+        name = insert.dxf.name              # Name des referenzierten Blocks
+        position = insert.dxf.insert
+        if name == "834372115":
+            symbol_att = import_block("834372115_symbol",lib_doc,doc)   
+            block = doc.blocks["834372115_symbol"]
+            for e in block:
+                if e.dxftype() != "INSERT":
+                    block.delete_entity(e)
+            att =msp.add_blockref("834372115_symbol",(position[0],position[1],position[2]))   # Einfügepunkt (x, y, z)
+            
+        rotation = insert.dxf.rotation      # Drehung in Grad (optional)
+        layer = insert.dxf.layer  
     doc.saveas(output_path)
     if logger:
         logger.info(f"[DONE] DXF gespeichert unter: {output_path}")
@@ -3658,6 +3753,6 @@ if __name__ == "__main__":
     default_lib_path = Path(args.lib)    if args.lib    else data_dir   / "blocks.dxf"
     output_path = Path(args.output) if args.output else (work_dir / f"{csv_path.stem}.dxf")
 
-    main(csv_path, default_lib_path, cfg_path, output_path, verbose=args.verbose, logger=logger)
+    main(csv_path, default_lib_path, cfg_path,allgemein_cfg_path, output_path, verbose=args.verbose, logger=logger)
     logger.info("=== plant2dxf Verarbeitung abgeschlossen ===")