From 4af894d7e93ecfda23bedeeb3d04134ca5c7158e Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Thu, 13 Nov 2025 10:12:15 +0100 Subject: [PATCH] =?UTF-8?q?habe=20die=20Bogen=20namen=20ins=20cofig=20eing?= =?UTF-8?q?ef=C3=BCgt=20und=20habe=20denn=20namen=20der=20layer=20f=C3=BCr?= =?UTF-8?q?=20die=20automatisiereung=20im=20config=20ge=C3=A4ndert=20um=20?= =?UTF-8?q?zu=20verdeutlichen=20was=20es=20tats=C3=A4chlich=20ist?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cfg/allgemein.cfg | 2 +- cfg/shapes.cfg | 32 ++- lib/dxf2lib.py | 11 +- lib/plant2dxf.py | 519 +++++++++++++++++++++++++++------------------- 4 files changed, 341 insertions(+), 223 deletions(-) diff --git a/cfg/allgemein.cfg b/cfg/allgemein.cfg index 57a18fc..76ed59e 100644 --- a/cfg/allgemein.cfg +++ b/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") \ No newline at end of file +automation_layer = ("A-GRUPPE","B-GRUPPE") \ No newline at end of file diff --git a/cfg/shapes.cfg b/cfg/shapes.cfg index 8ecad5a..9fedbf7 100644 --- a/cfg/shapes.cfg +++ b/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° \ No newline at end of file diff --git a/lib/dxf2lib.py b/lib/dxf2lib.py index 9764869..1013fb2 100644 --- a/lib/dxf2lib.py +++ b/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: diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index 2d694fd..abf8c06 100644 --- a/lib/plant2dxf.py +++ b/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,8 +157,9 @@ 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 @@ -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,9 +305,20 @@ 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() @@ -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) - blockref_layer = get_layer(doc, lib_doc, "S-LP") - bref = msp.add_blockref("S-LP", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer}) + import_block("Richtungspfeil", lib_doc, doc) + blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil") + 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) - blockref_layer = get_layer(doc, lib_doc, "S-LP") - bref = msp.add_blockref("S-LP", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer}) + import_block("Richtungspfeil", lib_doc, doc) + blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil") + 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") - umlenk_vorhanden = merkmale.get("Umlenk") - - gefahellewinkel =float(merkmale.get("Gefahellewinkel")) - - gefaelle = float(merkmale.get("Gefällestrecke")) + motor_vorhanden = bool(merkmale.get("hatMotor")) + umlenk_vorhanden = bool(merkmale.get("hatUmlenkung")) + if merkmale.get("Laenge_Gefaellestrecke") != None: + gefahellewinkel =float(merkmale.get("Laenge_Gefaellestrecke")) + + gefaelle = float(merkmale.get("Winkel_Gefaellestrecke")) + else: + 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") - umlenk_vorhanden = merkmale.get("Umlenk") - - gefahellewinkel =float(merkmale.get("Gefahellewinkel")) - gefaelle = float(merkmale.get("Gefällestrecke")) + motor_vorhanden = bool(merkmale.get("hatMotor")) + umlenk_vorhanden = bool(merkmale.get("hatUmlenkung")) + if merkmale.get("Winkel_Gefaellestrecke") != None: + gefahellewinkel =float(merkmale.get("Winkel_Gefaellestrecke")) + 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_ab_51 = "Vario_Bogen_ab_51°" + block_Vario_Bogen_auf_51 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_51_auf")) + 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_ab_39 = "Vario_Bogen_ab_39°" + block_Vario_Bogen_auf_39 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_39_auf")) + 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_ab_27 = "Vario_Bogen_ab_27°" - 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) - 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)) - 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_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_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"])) + block_Vario_Bogen_auf_27 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_27_auf")) + 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) + 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_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_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_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_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_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_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_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) - - for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_0): - if i< 2 and wert < 0: - - Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert) - - for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert) - - for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert) - - for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert) - - for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert) - - for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0): - if i< 2 and wert< 0: - 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 - 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 = (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 - 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 = 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 - line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) - line_VP.dxf.layer = "VARIO" - copy_VP = line_VP.copy() - - copy_VP.translate(-x,-y,-hoehe_vario) - block.add_entity(copy_VP) + 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_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_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)) ] - # Erstellung der zwischen Line - line = Line.new(dxfattribs={"start": start, "end": ende}) - line.dxf.layer = "6-SP" + # 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) - copy= line.copy() + for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_0): + if i< 2 and wert < 0: - copy.translate(-x,-y,-hoehe_vario) - block.add_entity(copy) + Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert) - #Hilfmethode zur ausmessen der bogen + for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert) - # 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,y+1000,0),(x,y-1000,0)) - # add_attributes_to_block(a, ab_27_attrib) + for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0): + if i< 2 and wert< 0: + 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 + 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 = (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 + 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 = 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 + line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) + line_VP.dxf.layer = "VARIO" + copy_VP = line_VP.copy() + + copy_VP.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_VP) + + # Erstellung der zwischen Line + line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" + + copy= line.copy() + + copy.translate(-x,-y,-hoehe_vario) + block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + + # 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,y+1000,0),(x,y-1000,0)) + # 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 = "Vario_Bogen_auf_18°" + block_Vario_Bogen_auf_18 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_18_auf")) + 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 = "Vario_Bogen_auf_15°" + block_Vario_Bogen_auf_15 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_15_auf")) + 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 = "Vario_Bogen_auf_12°" + block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf")) + 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_auf_6 = "Vario_Bogen_auf_6°" - ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc) - auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc) - block_Vario_ab_6 = dreh_block( block_Vario_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 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf")) + 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_Bogen_ab_6 , lib_doc, doc) + auf_6_attrib =import_block( block_Vario_Bogen_auf_6 , lib_doc, doc) + block_Vario_Bogen_ab_6 = dreh_block( block_Vario_Bogen_ab_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_ab_3 = "Vario_Bogen_ab_3°" + block_Vario_Bogen_auf_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_auf")) + 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_ab_45 = "Vario_Bogen_ab_45°" - block_Vario_auf_45 = "Vario_Bogen_auf_45°" - ab_45_attrib =import_block( block_Vario_ab_45 , lib_doc, doc) - auf_45_attrib =import_block( block_Vario_auf_45 , lib_doc, doc) - block_Vario_ab_45 = dreh_block( block_Vario_ab_45 , doc, math.radians(3)) - block_Vario_auf_45 = dreh_block( block_Vario_auf_45 , doc, math.radians(48)) + block_Vario_Bogen_auf_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_auf")) + block_Vario_Bogen_ab_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_ab")) + ab_45_attrib =import_block( block_Vario_Bogen_ab_45 , lib_doc, doc) + auf_45_attrib =import_block( block_Vario_Bogen_auf_45, lib_doc, doc) + block_Vario_Bogen_ab_45 = dreh_block( block_Vario_Bogen_ab_45, doc, math.radians(3)) + block_Vario_Bogen_auf_45= dreh_block( block_Vario_Bogen_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_auf_33 = "Vario_Bogen_auf_33°" - ab_33_attrib =import_block( block_Vario_ab_33 , lib_doc, doc) - auf_33_attrib =import_block( block_Vario_auf_33 , lib_doc, doc) - block_Vario_ab_33 = dreh_block( block_Vario_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 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_33_auf")) + 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_Bogen_ab_33 , lib_doc, doc) + auf_33_attrib =import_block(block_Vario_Bogen_auf_33, lib_doc, doc) + block_Vario_Bogen_ab_33 = dreh_block(block_Vario_Bogen_ab_33 , doc, math.radians(3)) + 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_auf_21 = "Vario_Bogen_auf_21°" - ab_21_attrib =import_block( block_Vario_ab_21 , lib_doc, doc) - auf_21_attrib =import_block( block_Vario_auf_21 , lib_doc, doc) - block_Vario_ab_21 = dreh_block( block_Vario_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 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_auf")) + 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_Bogen_ab_21, lib_doc, doc) + auf_21_attrib =import_block(block_Vario_Bogen_auf_21 , lib_doc, doc) + block_Vario_Bogen_ab_21= dreh_block(block_Vario_Bogen_ab_21 , doc, math.radians(3)) + 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_auf_12 = "Vario_Bogen_auf_12°" - ab_12_attrib =import_block( block_Vario_ab_12 , lib_doc, doc) - auf_12_attrib =import_block( block_Vario_auf_12 , lib_doc, doc) - block_Vario_ab_12 = dreh_block( block_Vario_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 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf")) + 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_Bogen_ab_12, lib_doc, doc) + auf_12_attrib =import_block( block_Vario_Bogen_auf_12 , lib_doc, doc) + block_Vario_Bogen_ab_12 = dreh_block(block_Vario_Bogen_ab_12, doc, math.radians(3)) + 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_ab_9 = "Vario_Bogen_ab_9°" - block_Vario_auf_9 = "Vario_Bogen_auf_9°" - ab_9_attrib =import_block( block_Vario_ab_9 , lib_doc, doc) - auf_9_attrib =import_block( block_Vario_auf_9 , lib_doc, doc) - block_Vario_ab_9 = dreh_block( block_Vario_ab_9, doc, math.radians(3)) - block_Vario_auf_9 = dreh_block( block_Vario_auf_9 , doc, math.radians(12)) + block_Vario_Bogen_auf_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_auf")) + block_Vario_Bogen_ab_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_ab")) + ab_9_attrib =import_block( block_Vario_Bogen_ab_9 , lib_doc, doc) + auf_9_attrib =import_block(block_Vario_Bogen_auf_9 , lib_doc, doc) + block_Vario_Bogen_ab_9 = dreh_block( block_Vario_Bogen_ab_9, doc, math.radians(3)) + block_Vario_Bogen_auf_9 = dreh_block(block_Vario_Bogen_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_auf_6 = "Vario_Bogen_auf_6°" - ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc) - auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc) - block_Vario_ab_6 = dreh_block( block_Vario_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 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf")) + 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_Bogen_ab_6 , lib_doc, doc) + auf_6_attrib =import_block(block_Vario_Bogen_auf_6, lib_doc, doc) + block_Vario_Bogen_ab_6 = dreh_block(block_Vario_Bogen_ab_6, doc, math.radians(3)) + 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) - blockref_layer = get_layer(doc, lib_doc, blockname) + blockname = 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}) + + import_block(blockname, lib_doc, doc) + + # blockref_layer = get_layer(doc, lib_doc, blockname) + 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 =bref.add_attrib( - tag= "NAME", - text= merkmale.get("bezeichner"), - insert = (x,y) - ) - 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 - doc = ezdxf.new(dxfversion="R2018") + config =parser_cfg_path + 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 ===")