From 22efec8148ba7a1364344ae09129f27be788e3ad Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 24 Nov 2025 14:38:07 +0100 Subject: [PATCH] Paar bugfixes. die Sivasnummer der tef und of gerade in die config getan --- cfg/shapes.cfg | 6 +- lib/plant2dxf.py | 239 +++++++++++++++++++++++++---------------------- 2 files changed, 134 insertions(+), 111 deletions(-) diff --git a/cfg/shapes.cfg b/cfg/shapes.cfg index 59ab6c2..02e747f 100644 --- a/cfg/shapes.cfg +++ b/cfg/shapes.cfg @@ -47,4 +47,8 @@ bogen_9_ab = Vario_Bogen_ab_9° 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 +bogen_3_ab = Vario_Bogen_ab_3° + +[Omniflo] +OFgeradesivas = 821106002 +Tefgeradesivas = 1 \ No newline at end of file diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index bb20d2e..adcd55e 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -241,11 +241,13 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, # Drehung (Winkel in Grad, Standard 0) aus Merkmale try: - winkel = float(merkmale.get("Drehung", 90)) + winkel = float(merkmale.get("Drehung")) except (ValueError, TypeError): winkel = 0.0 - winkel_rad = math.radians(winkel) - + if winkel== 270 or winkel == 90: + winkel_rad = math.radians(winkel) + else: + winkel_rad = math.radians(winkel -180) # Die Koordinaten (x, y) sind die Mitte zwischen den beiden Blöcken (bereits transformiert) halbabstand = abstand / 2 dx = halbabstand * math.cos(winkel_rad) @@ -261,7 +263,7 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, pos = (positions[i][0] + offset[0], positions[i][1] + offset[1],float(merkmale.get("Höhe in m"))*1000) import_block(blockname, lib_doc, doc) blockref_layer = get_layer(doc, lib_doc, blockname) - bref = msp.add_blockref(blockname, pos, dxfattribs={"rotation": merkmale.get("Drehung"), "layer" : blockref_layer}) + bref = msp.add_blockref(blockname, pos, dxfattribs={"layer" : blockref_layer}) bref.add_auto_attribs({ATTR_TAG: teileid}) if verbose: print(f"[INFO] Block '{blockname}' (Kreisel) → {teileid} " @@ -434,7 +436,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v lower_hoehe_gefaehlle = hoehe2 rotation = rotation -180 - if "kurvenrichtung" in gefaellestrecke_nachbarn: + if "Kurvenrichtung" in gefaellestrecke_nachbarn: vario_hoehe_0 = float(gefaellestrecke_nachbarn.get("vario_hoehe_0")) * 1000 vario_hoehe_1 = float(gefaellestrecke_nachbarn.get("vario_hoehe_1")) * 1000 block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" @@ -496,8 +498,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}_{hat_umlenk}_{hat_motor}" 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}) + bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation}) a =bref.add_attrib( tag= "NAME", text= merkmale.get("bezeichner"), @@ -505,7 +506,10 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v ) a.is_invisible = True return - block = doc.blocks.new(name=blockname,base_point= (0,0,0)) + if laenge > asoffset or laenge > esoffset: + block = doc.blocks.new(name=blockname,base_point= (0,0,0)) + else: + block = None dy = halbe_laenge * math.cos(0) start = [x , y + dy ,upper_hoehe_gefaehlle] @@ -523,8 +527,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v 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,None,None,None,block,start,ende) if only_es_or_as == False: - blockref_layer = get_layer(doc, lib_doc, blockname) - bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer}) + bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation}) a =bref.add_attrib( tag= "NAME", text= merkmale.get("bezeichner"), @@ -691,7 +694,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v rotation = rotation -180 - if "kurvenrichtung" in gefaellestrecke_nachbarn: + if "Kurvenrichtung" in gefaellestrecke_nachbarn: vario_hoehe_0 = float(gefaellestrecke_nachbarn.get("vario_hoehe_0")) * 1000 vario_hoehe_1 = float(gefaellestrecke_nachbarn.get("vario_hoehe_1")) * 1000 block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" @@ -710,7 +713,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v hat_motor = True else: hat_umlenk = True - if "kurvenrichtung_1" in gefaellestrecke_nachbarn: + if "Kurvenrichtung_1" in gefaellestrecke_nachbarn: vario_hoehe_0_1 = float(gefaellestrecke_nachbarn.get("vario_hoehe_0_1")) * 1000 vario_hoehe_1_1 = float(gefaellestrecke_nachbarn.get("vario_hoehe_1_1")) * 1000 if upper_hoehe_gefaehlle > lower_hoehe_gefaehlle: @@ -843,81 +846,25 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve break laenge = float(merkmale.get("Länge in Meter")) *1000 # Ausrechnung der nötigen Offset falls der Vario Förderer ab mit drei grad mit einem anderen Verbunden ist - if gefaellestrecke_vario.get("Winkel") != None and winkel == 3 and voerder_richtung == "Ab": + if (gefaellestrecke_vario.get("Winkel") != None or gefaellestrecke_vario.get("Kurvenrichtung") != None) and ((winkel == 3 and voerder_richtung == "Ab")or voerder_richtung == "Horizontal"): # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung - if float(gefaellestrecke_vario.get("h0")) == lower_hoehe_vario: - if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): - # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 - winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) - blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°") - att_vorne =import_block(blockname,lib_doc,doc) - SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) - VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) - # Ausrechnen des Offsets - winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(-winkel_vorne)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(-winkel_vorne)) - - else: - # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 - winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) - - blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°") - att_vorne =import_block(blockname,lib_doc,doc) - SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"])) - VP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"])) - # Ausrechnung des Offsets - winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) - - elif float(gefaellestrecke_vario.get("h1")) == upper_hoehe_vario: - if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): - # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - - winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 - winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) - - blockname = (f"Vario_Bogen_auf_{winkel_hinten_plusbogen}°") - att_hinten =import_block(blockname,lib_doc,doc) - SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_0"])) - VP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_0"])) - # Ausrechnung des Offsets - winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(3)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(3)) - - else: - # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 - winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) - - blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°") - att_hinten =import_block(blockname,lib_doc,doc) - SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"])) - VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) - # Ausrechnung des Offsets - winkel_VP_offset_hinten = (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten)), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) - - # Das gleiche falls der 3 grad Förderer mit zwei Förderer Verbunden ist - if (gefaellestrecke_vario.get("Winkel_2") != None): - # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung - - if float(gefaellestrecke_vario.get("h0_2")) == lower_hoehe_vario: - if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + if gefaellestrecke_vario.get("h0") != None: + if float(gefaellestrecke_vario.get("h0")) == lower_hoehe_vario: + if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - - winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 - winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) - + winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°") att_vorne =import_block(blockname,lib_doc,doc) SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) - # Ausrechnung des Offsets + # Ausrechnen des Offsets winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(-winkel_vorne)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(-winkel_vorne)) - else: - # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - - winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel_2")) -3 - winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) + elif gefaellestrecke_vario.get("Foerderrichtung") == "Ab": + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°") att_vorne =import_block(blockname,lib_doc,doc) @@ -926,28 +873,85 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Ausrechnung des Offsets winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) - elif float(gefaellestrecke_vario.get("h1_2")) == upper_hoehe_vario: - if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + elif float(gefaellestrecke_vario.get("h1")) == upper_hoehe_vario: + if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte - winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 + winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 + winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) + blockname = (f"Vario_Bogen_auf_{winkel_hinten_plusbogen}°") att_hinten =import_block(blockname,lib_doc,doc) SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_0"])) VP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_0"])) # Ausrechnung des Offsets - winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(3)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(3)) + winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(3)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(3)) + else: # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 - winkel_hinten = int(gefaellestrecke_vario.get("Winkel_2")) + winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) + blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°") att_hinten =import_block(blockname,lib_doc,doc) SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"])) - VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) + VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) # Ausrechnung des Offsets - winkel_VP_offset_hinten = ((SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten))), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) + winkel_VP_offset_hinten = (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten)), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) + # Das gleiche falls der 3 grad Förderer mit zwei Förderer Verbunden ist + if (gefaellestrecke_vario.get("Winkel_2") != None or gefaellestrecke_vario.get("Kurvenrichtung")!= None): + # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung + if gefaellestrecke_vario.get("h0_2") != None: + if float(gefaellestrecke_vario.get("h0_2")) == lower_hoehe_vario: + if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + + winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) + + blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°") + att_vorne =import_block(blockname,lib_doc,doc) + SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) + VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) + # Ausrechnung des Offsets + winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(-winkel_vorne)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(-winkel_vorne)) + + else: + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + + winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel_2")) -3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) + + blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°") + att_vorne =import_block(blockname,lib_doc,doc) + SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"])) + VP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"])) + # Ausrechnung des Offsets + winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) + + elif float(gefaellestrecke_vario.get("h1_2")) == upper_hoehe_vario: + if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + + winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 + blockname = (f"Vario_Bogen_auf_{winkel_hinten_plusbogen}°") + att_hinten =import_block(blockname,lib_doc,doc) + SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_0"])) + VP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_0"])) + # Ausrechnung des Offsets + winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(3)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(3)) + else: + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 + winkel_hinten = int(gefaellestrecke_vario.get("Winkel_2")) + blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°") + att_hinten =import_block(blockname,lib_doc,doc) + SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"])) + VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) + # Ausrechnung des Offsets + winkel_VP_offset_hinten = ((SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten))), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) + # Für spätere berechnung schauen ob der erste Kreis in der Liste höher ist if upper_hoehe_vario == gefaellestrecke_vario.get("Hoehe0"): ein_kreisel_höher = True @@ -1305,8 +1309,9 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, Für alle anderen Omniflo-Typen: Block mit SivasNummer an den Koordinaten. """ # Prüfen, ob es sich um eine Gerade handelt - - if merkmale.get("Länge in Meter") is not None and merkmale.get("Winkel") is not None: + omnisivas = config.get("Omniflo","OFgeradesivas") + tefsivas = config.get("Omniflo","Tefgeradesivas") + if merkmale.get("SivasNummer") == omnisivas or merkmale.get("SivasNummer") == tefsivas: try: laenge = float(merkmale.get("Länge in Meter", "0").replace(",", ".")) * 1000 # Meter → mm except Exception: @@ -1325,8 +1330,14 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, ende = (x - dx, y - dy, float(merkmale.get("Höhe unten"))) if "A-2" not in doc.layers: doc.layers.add(name="A-2", color=2) + if "F-1" not in doc.layers: + doc.layers.add(name="F-1", color =1) linie=msp.add_line(start, ende) - linie.dxf.layer = "A-2" + if merkmale.get("SivasNummer") == tefsivas: + linie.dxf.layer = "F-1" + else: + linie.dxf.layer = "A-2" + if verbose: print(f"[INFO] Omniflo Gerade → {teileid} Linie von ({start[0]:.1f}, {start[1]:.1f}) nach ({ende[0]:.1f}, {ende[1]:.1f})") @@ -1930,7 +1941,7 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl if(richtung0 != None and richtung0 != None): if (richtung0 != richtung1 and kreisel_verbunden ==1): if( - (abstand_fuer_kreis_start_y_floor == pos0_0_floor)or + (abstand_fuer_kreis_start_y_floor == pos0_0_floor) or (abstand_fuer_kreis_start_y_floor == pos0_1_floor) or (abstand_gegen_kreis_start_y_floor == pos0_0_floor) or (abstand_gegen_kreis_start_y_floor == pos0_1_floor) or @@ -1938,7 +1949,7 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_fuer_kreis_ende_y_floor == pos0_1_floor) or (abstand_gegen_kreis_ende_y_floor == pos0_0_floor) or (abstand_gegen_kreis_ende_y_floor == pos0_1_floor) or - (abstand_fuer_kreis_start_y_round == pos0_0_round)or + (abstand_fuer_kreis_start_y_round == pos0_0_round) or (abstand_fuer_kreis_start_y_round == pos0_1_round) or (abstand_gegen_kreis_start_y_round == pos0_0_round) or (abstand_gegen_kreis_start_y_round == pos0_1_round) or @@ -2703,16 +2714,20 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_ab_3_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_3,(ende[0] -x ,ende[1] +Vario_Bogen_auf_3_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_3_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - - ende_VP = (ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_3_Delta_VP_1[0]+Vario_Bogen_auf_3_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_3_Delta_VP_1[2]- Vario_Bogen_auf_3_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_3_Delta_SP_1[0] + Vario_Bogen_auf_3_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_3_Delta_SP_1[2] - Vario_Bogen_auf_3_Delta_SP_0[2]) + if motor_vorhanden == True: + block.add_blockref(block_Vario_Bogen_auf_3,(ende[0] -x ,ende[1] +Vario_Bogen_auf_3_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_3_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) + ende_VP = (ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_3_Delta_VP_1[0]+Vario_Bogen_auf_3_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_3_Delta_VP_1[2]- Vario_Bogen_auf_3_Delta_SP_0[2]) + ende = (ende[0] ,ende[1] +Vario_Bogen_auf_3_Delta_SP_1[0] + Vario_Bogen_auf_3_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_3_Delta_SP_1[2] - Vario_Bogen_auf_3_Delta_SP_0[2]) + else: + ende_VP = ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1] ,ende[1] , ende[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_3 ,(start[0]-x,start[1] - Vario_Bogen_ab_3_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_3_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1]-Vario_Bogen_ab_3_Delta_VP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_3_Delta_VP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] - start = start[0] ,start[1] - Vario_Bogen_ab_3_Delta_SP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0],start[2] +Vario_Bogen_ab_3_Delta_SP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] - + if umlenk_vorhanden == True: + block.add_blockref(block_Vario_Bogen_ab_3 ,(start[0]-x,start[1] - Vario_Bogen_ab_3_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_3_Delta_SP_1[2]),dxfattribs={"rotation": 90}) + start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1]-Vario_Bogen_ab_3_Delta_VP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_3_Delta_VP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] + start = start[0] ,start[1] - Vario_Bogen_ab_3_Delta_SP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0],start[2] +Vario_Bogen_ab_3_Delta_SP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] + else: + start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1] , start[2] # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" @@ -3388,12 +3403,12 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: if voerder_anweisung == 0: eintrag["vario_hoehe_0"] = foerderer.get("H0") eintrag["vario_hoehe_1"] = foerderer.get("H1") - eintrag["kurvenrichtung"] = foerderer.get("kurvenrichtung") + eintrag["Kurvenrichtung"] = foerderer.get("kurvenrichtung") voerder_anweisung = 1 elif voerder_anweisung ==1: eintrag["vario_hoehe_0_1"] = foerderer.get("H0") eintrag["vario_hoehe_1_1"] = foerderer.get("H1") - eintrag["kurvenrichtung_1"] = foerderer.get("kurvenrichtung") + eintrag["Kurvenrichtung_1"] = foerderer.get("kurvenrichtung") for kreis in kreisel: if kreis["Id"] in gerade["NachbarIds"]: @@ -3436,7 +3451,7 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: # --------------------------------------------------------- Hauptfunktion def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Path, - output_path: Path, output_path_jason: Path, verbose=False, logger=None): + output_path: Path, output_path_jason: Path, verbose=False, logger=None ): data_dir = check_environment_var("PROJECT_DATA") # Bibliothek nur laden, wenn Datei existiert check_dxflibrary_path(lib_path, verbose, logger) @@ -3461,6 +3476,7 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat doc.header['$INSUNITS'] = 4 # Millimeter msp = doc.modelspace() + # Höhe bestimmen für Koordinaten-Transformation try: height = berechne_hoehe(csv_path, logger=logger) @@ -3528,7 +3544,7 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat handler = globals().get(func_name) symbols = get_shape_cfg(teileart, cfg_path, logger=logger) # Mapping für Omniflo-Typen - if func_name.startswith('handle_omniflo'): + if func_name.startswith('handle_omniflo') or func_name.startswith('handle_tef'): handler = globals().get('handle_omniflo') if handler: handler(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn, config,config_allgemein) @@ -3541,11 +3557,10 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat continue # data = [] # for e in msp.query("INSERT"): - # block_name = e.dxf.name - # block = doc.blocks[block_name] + # ents = list(e.virtual_entities()) # # Bounding Box des Blocks berechnen - # bb = bbox.extents(block) + # bb = bbox.extents(ents) # if bb: # x_min, y_min, z_min = bb.extmin # x_max, y_max, z_max = bb.extmax @@ -3563,6 +3578,9 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat # "height_block": height_block # }) + # with open(output_path_jason, "w", encoding="utf-8") as datei: + # json.dump(data, datei, ensure_ascii=False, indent=4) + # for insert in msp.query("INSERT"): # name = insert.dxf.name # Name des referenzierten Blocks # position = insert.dxf.insert @@ -3574,12 +3592,10 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat # 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) + # rotation = insert.dxf.rotation # layer = insert.dxf.layer - # DXF speichern - # with open(output_path_jason, "w", encoding="utf-8") as datei: - # json.dump(data, datei, ensure_ascii=False, indent=4) + doc.saveas(output_path) if logger: logger.info(f"[DONE] DXF gespeichert unter: {output_path}") @@ -3616,8 +3632,11 @@ if __name__ == "__main__": parser.add_argument("-l", "--lib", help="DXF-Bibliothek mit Blöcken", metavar="bibliothek.dxf") parser.add_argument("-o", "--output", help="Ziel-DXF (Standard: PROJECT_WORK/anlage.dxf)", metavar="anlage.dxf") parser.add_argument("-v", "--verbose", action="store_true", help="mehr Ausgaben anzeigen") + + args = parser.parse_args() + # Verzeichnisse aus Umgebungs­variablen log_dir = check_environment_var("PROJECT_LOG") data_dir = check_environment_var("PROJECT_DATA")