From e67fa975aa217026c2b378e10ac2c2b934700fea Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 1 Dec 2025 14:42:26 +0100 Subject: [PATCH] =?UTF-8?q?Hinzuf=C3=BCgen=20der=20Seperatoren=20und=20Sca?= =?UTF-8?q?ner=20im=20Ils,=20verallgemeinerung=20vom=20Code,=20vorbereitun?= =?UTF-8?q?g=20f=C3=BCr=20die=20drehung=20der=20as=20es=20elemente?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cfg/shapes.cfg | 27 +- lib/plant2dxf.py | 1481 ++++++++++++++-------------------------------- 2 files changed, 444 insertions(+), 1064 deletions(-) diff --git a/cfg/shapes.cfg b/cfg/shapes.cfg index aaf8ac2..220b78f 100644 --- a/cfg/shapes.cfg +++ b/cfg/shapes.cfg @@ -26,29 +26,14 @@ esoffset = 479.95 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_9_auf = Vario_Bogen_auf_9° -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° - +[Ils 2.0 core winkel] +winkel_boegen = 3 +winkel_motor = 3 +winkel_umlenk = 3 +winkel_as = 3 +winkel_es = -3 [Omniflo] OFgeradesivas = 821106002 Tefgeradesivas = 1 diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index be4b1e8..3e9ab34 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -390,14 +390,6 @@ def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, s 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 "6-SP" not in doc.layers: - doc.layers.add(name="6-SP", color=7) - verbunden_am_einen = False - hat_motor = False - hat_umlenk =False - richtung2 ="DEFAULT" - unterschiedlich = False asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset")) upper_hoehe_gefaehlle= float(merkmale.get("Höhe oben")) *1000 @@ -408,6 +400,65 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v laenge = float(laenge_m) * 1000 # Meter → mm except ValueError: laenge = 10000 + halbe_laenge = laenge / 2 + rotation= float(merkmale.get("Drehung")) + + if "6-SP" not in doc.layers: + doc.layers.add(name="6-SP", color=7) + verbunden_am_einen = False + tefkurve_0 = None + tefkurve_1 = None + hat_motor_0 = False + hat_umlenk_0 =False + hat_motor_1 = False + hat_umlenk_1 =False + richtung2 ="DEFAULT" + unterschiedlich = False + + winkel = math.radians(float(rotation)) + dx = halbe_laenge *math.sin(winkel * -1) + dy = halbe_laenge * math.cos(winkel) + start = x +dx, y + dy,upper_hoehe_gefaehlle + + separatoren =float(merkmale.get("Anzahl der Separatoren")) + scanner = float(merkmale.get("Anzahl der Scanner")) + if rotation == 0 or rotation == -180: + ausrichtung = "V" + else: + ausrichtung = "H" + if ausrichtung == "V": + einsatz_fest = [x + 300, y,hoehe_gefaehlle] + modular = 2 + else: + einsatz_fest = [x,y - 150,hoehe_gefaehlle] + modular = 3 + block_scanner = "SCAN" + block_separatoren = "S-LP" + import_block(block_scanner,lib_doc,doc) + import_block(block_separatoren,lib_doc,doc) + einsatz_zwischen =[ einsatz_fest[0],einsatz_fest[1],einsatz_fest[2]] + anzahl =0 + while anzahl < separatoren: + anzahl = anzahl + 1 + msp.add_blockref(block_separatoren,einsatz_zwischen) + if anzahl % modular == 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + else: + einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 + + if anzahl % modular != 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + anzahl =0 + while anzahl < scanner: + anzahl = anzahl + 1 + msp.add_blockref(block_scanner,einsatz_zwischen) + if anzahl % modular == 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + else: + einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 for nachbarn in strecken_nachbarn: if teileid == nachbarn.get("Id"): gefaellestrecke_nachbarn = nachbarn @@ -422,13 +473,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v richtung0 = float(gefaellestrecke_nachbarn.get("rotation0")) richtung_rad0= math.radians(richtung0) abstand0 = float(gefaellestrecke_nachbarn.get("abstand0")) * 1000 - - - halbe_laenge = laenge / 2 - rotation= float(merkmale.get("Drehung")) - winkel = math.radians(float(rotation)) - dx = halbe_laenge *math.sin(winkel * -1) - dy = halbe_laenge * math.cos(winkel) if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: hoehe2 = upper_hoehe_gefaehlle @@ -439,26 +483,47 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v 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 + kurvenrichtung = gefaellestrecke_nachbarn.get("Kurvenrichtung") + tefkurve_0 = gefaellestrecke_nachbarn.get("Tefkurve") block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block(block_Vario_Umlenkstation_500mm,lib_doc,doc) import_block(block_Vario_Motorstation_500mm,lib_doc,doc) block_Vario_Umlenkstation_500mm =dreh_block(block_Vario_Umlenkstation_500mm,doc,math.radians(3)) block_Vario_Motorstation_500mm =dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(3)) + blockname_motor_links = block_Vario_Motorstation_500mm +"links" + blockname_umlenk_links = block_Vario_Umlenkstation_500mm + "links" + if blockname_motor_links not in doc.blocks: + matrix = Matrix44(1,-1,1) + block_motor_links = doc.blocks.new(name=blockname_motor_links,base_point=(0,0,0)) + block_umlenk_links = doc.blocks.new(name=blockname_umlenk_links,base_point=(0,0,0)) + block_motor_rechts = doc.blocks[block_Vario_Motorstation_500mm] + block_umlenk_rechts = doc.blocks[block_Vario_Umlenkstation_500mm] + for e in block_motor_rechts: + copy = e.copy() + copy.transform(matrix) + block_motor_links.add_entity(copy) + + for e in block_umlenk_rechts: + copy = e.copy() + copy.transform(matrix) + block_umlenk_links.add_entity(copy) + if upper_hoehe_gefaehlle > lower_hoehe_gefaehlle: if vario_hoehe_0 == upper_hoehe_gefaehlle or vario_hoehe_1 == upper_hoehe_gefaehlle: - hat_motor = True + hat_motor_0 = True + else: - hat_umlenk = True + hat_umlenk_0 = True if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: if vario_hoehe_0 == lower_hoehe_gefaehlle or vario_hoehe_1 == lower_hoehe_gefaehlle: - hat_motor = True + hat_motor_0 = True else: - hat_umlenk = True + hat_umlenk_0 = True verbunden_am_einen = True 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) if am_kreisel == 1: - if hat_motor == False and hat_umlenk == False: + if hat_motor_0 == False and hat_umlenk_0 == False: dx = halbe_laenge *math.sin(winkel * -1) dy = halbe_laenge * math.cos(winkel) start = x +dx, y + dy,upper_hoehe_gefaehlle @@ -472,15 +537,23 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v dy = halbe_laenge * math.cos(0) start = [x , y + dy ,upper_hoehe_gefaehlle] ende = [x , y - dy ,lower_hoehe_gefaehlle] - blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{hat_umlenk}_{hat_motor}" + blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{hat_umlenk_0}_{hat_motor_0}_{tefkurve_0}" if blockname not in doc.blocks: block = doc.blocks.new(name=blockname,base_point= (0,0,0)) - if hat_motor == True: - block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + if hat_motor_0 == True: + if tefkurve_0 == "rechts": + block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_motor_links, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + start [1]= start[1] - 500* math.cos(math.radians(3)) start[2] = start[2] - 500* math.sin(math.radians(3)) - if hat_umlenk == True: - block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + if hat_umlenk_0 == True: + if tefkurve_0 == "rechts": + block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_umlenk_links, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + ende [1]= ende[1] + 500* math.cos(math.radians(3)) ende[2] = ende[2] + 500* math.sin(math.radians(3)) line = Line.new(dxfattribs={"start":start,"end":ende}) @@ -492,10 +565,10 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v hight ="higher" else: hight = "lower" - if hat_motor == False and hat_umlenk == False: + if hat_motor_0 == False and hat_umlenk_0 == False: blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}" else: - blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}_{hat_umlenk}_{hat_motor}" + blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}_{hat_umlenk_0}_{hat_motor_0}_{tefkurve_0}" if blockname in doc.blocks: bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation}) @@ -514,17 +587,24 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v dy = halbe_laenge * math.cos(0) start = [x , y + dy ,upper_hoehe_gefaehlle] ende = [x , y - dy ,lower_hoehe_gefaehlle] - if hat_motor == True: - block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + if hat_motor_0 == True: + if tefkurve_0 == "rechts": + block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_motor_links, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + start [1]= start[1] - 500* math.cos(math.radians(3)) start[2] = start[2] - 500* math.sin(math.radians(3)) - if hat_umlenk == True: - block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + if hat_umlenk_0 == True: + if tefkurve_0 == "rechts": + block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] - 250* math.cos(math.radians(3))-y,ende[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_umlenk_links, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) ende [1]= ende[1] + 500* math.cos(math.radians(3)) ende[2] = ende[2] + 500* math.sin(math.radians(3)) - 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) + only_es_or_as = erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,config,hight,None,None,None,block,start,ende) if only_es_or_as == False: bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation}) @@ -674,7 +754,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{drehung0}_{drehung1}_{hight_position}_{verbunden_am_einen}" else: blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{drehung0}_{drehung1}_{hight_position}_{unterschiedlich}_{richtung2}_{verbunden_am_einen}" - gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2,drehung0, drehung1, laenge, hight_position,blockname) + gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2,drehung0, drehung1, laenge, hight_position,blockname,config) blockref_layer = get_layer(doc, lib_doc, blockname) bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer }) @@ -697,41 +777,62 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v 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 + kurvenrichtung = gefaellestrecke_nachbarn.get("Kurvenrichtung") + tefkurve_0 = gefaellestrecke_nachbarn.get("Tefkurve") block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block(block_Vario_Umlenkstation_500mm,lib_doc,doc) import_block(block_Vario_Motorstation_500mm,lib_doc,doc) block_Vario_Umlenkstation_500mm =dreh_block(block_Vario_Umlenkstation_500mm,doc,math.radians(3)) block_Vario_Motorstation_500mm =dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(3)) + blockname_motor_links = block_Vario_Motorstation_500mm +"links" + blockname_umlenk_links = block_Vario_Umlenkstation_500mm + "links" + if blockname_motor_links not in doc.blocks: + matrix = Matrix44.scale(1,-1,1) + block_motor_links = doc.blocks.new(name=blockname_motor_links,base_point=(0,0,0)) + block_umlenk_links = doc.blocks.new(name=blockname_umlenk_links,base_point=(0,0,0)) + block_motor_rechts = doc.blocks[block_Vario_Motorstation_500mm] + block_umlenk_rechts = doc.blocks[block_Vario_Umlenkstation_500mm] + for e in block_motor_rechts: + copy = e.copy() + copy.transform(matrix) + block_motor_links.add_entity(copy) + + for e in block_umlenk_rechts: + copy = e.copy() + copy.transform(matrix) + block_umlenk_links.add_entity(copy) + if upper_hoehe_gefaehlle > lower_hoehe_gefaehlle: if vario_hoehe_0 == upper_hoehe_gefaehlle or vario_hoehe_1 == upper_hoehe_gefaehlle: - hat_motor = True + hat_motor_0 = True else: - hat_umlenk = True + hat_umlenk_0 = True if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: if vario_hoehe_0 == lower_hoehe_gefaehlle or vario_hoehe_1 == lower_hoehe_gefaehlle: - hat_motor = True + hat_motor_0 = True else: - hat_umlenk = True + hat_umlenk_0 = True 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 + tefkurve_1 = gefaellestrecke_nachbarn.get("Tefkurve_1") if upper_hoehe_gefaehlle > lower_hoehe_gefaehlle: if vario_hoehe_0_1 == upper_hoehe_gefaehlle or vario_hoehe_1_1 == upper_hoehe_gefaehlle: - hat_motor = True + hat_motor_1 = True else: - hat_umlenk = True + hat_umlenk_1 = True if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: if vario_hoehe_0_1 == lower_hoehe_gefaehlle or vario_hoehe_1_1 == lower_hoehe_gefaehlle: - hat_motor = True + hat_motor_1 = True else: - hat_umlenk = True - blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{hat_motor}_{hat_umlenk}" + hat_umlenk_1 = True + blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{hat_motor_0}_{hat_umlenk_0}_{tefkurve_0}_{hat_motor_1}_{hat_umlenk_1}_{tefkurve_1}" halbe_laenge = laenge / 2 dy = halbe_laenge * math.cos(0) start = [x , y + dy ,upper_hoehe_gefaehlle] ende = [x , y - dy ,lower_hoehe_gefaehlle] - if hat_motor == False and hat_umlenk == False: + if hat_motor_0 == False and hat_umlenk_0 == False and hat_motor_1 == False and hat_umlenk_1 == False: laenge_m = merkmale.get("Länge in Meter", "10").replace(",", ".") try: laenge = float(laenge_m) * 1000 # Meter → mm @@ -745,34 +846,43 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v ende = x -dx, y - dy,lower_hoehe_gefaehlle line = msp.add_line(start,ende) line.dxf.layer = "6-SP" - elif hat_motor == True and hat_umlenk == False: + elif (hat_motor_0 == True and hat_umlenk_0 == False) and tefkurve_1 == None: if blockname not in doc.blocks: block = doc.blocks.new(name=blockname,base_point = (0,0,0)) - block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + if (hat_motor_0 == True and tefkurve_0 == "rechts") or (hat_motor_1 == True and tefkurve_1 == "rechts"): + block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_motor_links, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) start [1]= start[1] - 500* math.cos(math.radians(3)) start[2] = start[2] - 500* math.sin(math.radians(3)) line = Line.new(dxfattribs={"start":start,"end":ende}) line.translate(-x,-y,-hoehe_gefaehlle) block.add_entity(line) msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation}) - elif hat_motor == False and hat_umlenk == True: + elif hat_motor_0 == False and hat_umlenk_0 == True and tefkurve_1 == None: if blockname not in doc.blocks: block = doc.blocks.new(name=blockname,base_point = (0,0,0)) - block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) - ende [1]= ende[1] + 500* math.cos(math.radians(3)) + if (hat_umlenk_0 == True and tefkurve_0 == "rechts") or (hat_umlenk_1 == True and tefkurve_1 == "rechts"): + block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_umlenk_links, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) ende[2] = ende[2] + 500* math.sin(math.radians(3)) line = Line.new(dxfattribs={"start":start,"end":ende}) line.translate(-x,-y,-hoehe_gefaehlle) block.add_entity(line) msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation}) - elif hat_motor == True and hat_umlenk == True: + else: if blockname not in doc.blocks: block = doc.blocks.new(name=blockname,base_point = (0,0,0)) - block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) - start [1]= start[1] - 500* math.cos(math.radians(3)) + if (hat_motor_0 == True and tefkurve_0 == "rechts") or (hat_motor_1 == True and tefkurve_1 == "rechts"): + block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_motor_links, (start[0]-x,start[1] - 250* math.cos(math.radians(3))-y,start[2] - 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) start[2] = start[2] - 500* math.sin(math.radians(3)) - block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) - ende [1]= ende[1] + 500* math.cos(math.radians(3)) + if (hat_umlenk_0 == True and tefkurve_0 == "rechts") or (hat_umlenk_1 == True and tefkurve_1 == "rechts"): + block.add_blockref(block_Vario_Umlenkstation_500mm, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] -+250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) + else: + block.add_blockref(blockname_umlenk_links, (ende[0]-x,ende[1] + 250* math.cos(math.radians(3))-y,ende[2] + 250* math.sin(math.radians(3))-hoehe_gefaehlle),dxfattribs={"rotation": 270}) ende[2] = ende[2] + 500* math.sin(math.radians(3)) line = Line.new(dxfattribs={"start":start,"end":ende}) line.translate(-x,-y,-hoehe_gefaehlle) @@ -824,12 +934,52 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve erster_kreisel_höher = False ein_kreisel_höher = False richtung2 ="DEFAULT" - asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) - esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset")) + rotation = float(merkmale.get("Drehung")) upper_hoehe_vario= float(merkmale.get("Höhe Ende")) *1000 lower_hoehe_vario = float(merkmale.get("Höhe Anfang")) *1000 + hoehe_vario= (upper_hoehe_vario + lower_hoehe_vario)/2 + separatoren =float(merkmale.get("Anzahl der Separatoren")) + scanner = float(merkmale.get("Anzahl der Scanner")) + if rotation == 0 or rotation == -180: + ausrichtung = "V" + else: + ausrichtung = "H" + if ausrichtung == "V": + einsatz_fest = [x + 300,y,hoehe_vario] + modular = 2 + else: + einsatz_fest = [x,y - 150,hoehe_vario] + modular = 3 + block_scanner = "SCAN" + block_separatoren = "S-LP" + import_block(block_scanner,lib_doc,doc) + import_block(block_separatoren,lib_doc,doc) + einsatz_zwischen =[ einsatz_fest[0],einsatz_fest[1],einsatz_fest[2]] + anzahl =0 + while anzahl < separatoren: + anzahl = anzahl + 1 + msp.add_blockref(block_separatoren,einsatz_zwischen) + if anzahl % modular == 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + else: + einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 + + + if anzahl % modular != 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + anzahl =0 + while anzahl < scanner: + anzahl = anzahl + 1 + msp.add_blockref(block_scanner,einsatz_zwischen) + if anzahl % modular == 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + else: + einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 # Umstellung der Höhen falls nötig für die Konsistenz der spätere Erstellung, ist nur notwendig für ab Vario Förderer if upper_hoehe_vario< lower_hoehe_vario: hight = upper_hoehe_vario @@ -838,7 +988,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Korrektur der rotation mit der Umstellung der Höhe rotation = rotation -180 - hoehe_vario= (upper_hoehe_vario + lower_hoehe_vario)/2 + # Hollen der Information der Nachbarn strukturen ob diese Kreisel sind for nachbarn in strecken_nachbarn: if teileid == nachbarn.get("Id"): @@ -970,11 +1120,34 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve richtung0 = float(gefaellestrecke_vario.get("rotation0")) richtung_rad0= math.radians(richtung0) # Herausfinden ob der Förderere direkt mit dem Kreisel verbunden ist, die Werte für den Zweiten Kreisel wird auf None gesetzt weil diese nicht existieren + + mit_horizontal_verbunden = None + if voerder_richtung == "Horizontal": + if rotation == 0.0: + if y> y0_kreisel: + mit_horizontal_verbunden = "unten_drehung_0_or_-90" + else: + mit_horizontal_verbunden = "oben_drehung_0_or_-90" + if rotation == -180.0: + if y> y0_kreisel: + mit_horizontal_verbunden = "unten_drehung_-180_or_-270" + else: + mit_horizontal_verbunden = "oben_drehung_-180_or_-270" + if rotation == -90.0: + if x> x0_kreisel: + mit_horizontal_verbunden = "unten_drehung_0_or_-90" + else: + mit_horizontal_verbunden = "oben_drehung_0_or_-90" + if rotation == -270.0: + if x> x0_kreisel: + mit_horizontal_verbunden = "unten_drehung_-180_or_-270" + else: + mit_horizontal_verbunden = "oben_drehung_-180_or_-270" am_kreisel,kreseil_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_vario, lower_hoehe_vario, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None ) if am_kreisel == 1: # Erstellung der blockname für wenn die Motorstation rechts und links - blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}_True_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") - block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_True_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}_True_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}_{mit_horizontal_verbunden}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_True_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}_{mit_horizontal_verbunden}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": @@ -989,7 +1162,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve start = (x, y + dy_true,upper_hoehe_vario) ende = (x,y -dy_true,lower_hoehe_vario) # Erstellung einer Gefällestrecke von 500 mm in der Vario rein, wo es verbunden ist - if ein_kreisel_höher == True : + if ein_kreisel_höher == True and voerder_richtung != "Horizontal": l = (start[0],start[1],upper_hoehe_vario) if voerder_richtung =="Auf": @@ -999,8 +1172,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario - 500* math.sin(math.radians(3))) start = m else: - m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario) - start = m + if mit_horizontal_verbunden == "unten_drehung_0_or_-90" or mit_horizontal_verbunden == "oben_drehung_-180_or_-270": + m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario+500* math.sin(math.radians(3))) + start = m + else: + en = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario- 500* math.sin(math.radians(3)) ) + ende = en line = Line.new(dxfattribs={"start": l,"end":m }) line.dxf.layer = "6-SP" @@ -1009,7 +1186,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve block_vario.add_entity(copy) - else: + elif ein_kreisel_höher == False and voerder_richtung != "Horizontal": l = (ende[0],ende[1],lower_hoehe_vario) if voerder_richtung =="Auf": m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario - 500* math.sin(math.radians(3))) @@ -1025,6 +1202,26 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) + elif voerder_richtung == "Horizontal": + if mit_horizontal_verbunden == "oben_drehung_0_or_-90" or mit_horizontal_verbunden == "unten_drehung_-180_or_-270": + l = (start[0],start[1],upper_hoehe_vario) + m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario) + start = m + line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" + copy= line.copy() + copy.translate(-x,-y,-hoehe_vario) + block_vario.add_entity(copy) + else: + end = (ende[0],ende[1],lower_hoehe_vario) + en = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) + ende = en + line = Line.new(dxfattribs={"start": end,"end":en }) + line.dxf.layer = "6-SP" + copy= line.copy() + copy.translate(-x,-y,-hoehe_vario) + block_vario.add_entity(copy) + # Erstellung des Vario_förderes selber vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # reintuen des förderes in den Modelspace @@ -1037,8 +1234,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Abschnitt falls der Vario nur mit einem Kreisel verbunden ist und nicht an dem Kreisel direkt verbunden ist # Erstellung der blockname für wenn die Motorstation rechts und links - blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") - block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}_{mit_horizontal_verbunden}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}_{mit_horizontal_verbunden}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": @@ -1052,7 +1249,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve dy_true = halbe_laenge * math.cos (0) # Schauen welches as oder es element man wo verbinden muss und bereits in den block tuen, der None wert ist ein Wert der für die Gefällestrecke notwendig ist # Entnehmen von start und end Werte für spätere vario erstellung - start, ende =erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario, drehung0, laenge, blockname,None ,block_vario, voerder_richtung, ein_kreisel_höher) + + start, ende =erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario, drehung0, laenge, blockname,config,None ,block_vario, voerder_richtung, ein_kreisel_höher,None,None,None,mit_horizontal_verbunden) # Erstellung des Varios selber vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # reintuen des förderes in den Modelspace @@ -1224,7 +1422,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Schauen welche es oder as element man braucht man braucht und diese in den block einfügen # Entnehmen von start und end Werte für spätere vario erstellung - start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,block_vario,voerder_richtung, am_kreisel,erster_kreisel_höher,y1,z1) + start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,config,block_vario,voerder_richtung, am_kreisel,erster_kreisel_höher,y1,z1) # Erstellung der Vario gefälle selber vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # Reintuen des endblockes in den Modelspace @@ -1252,7 +1450,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve block_vario = doc.blocks.new(blockname, base_point=(0,0,0)) # Schauen welche es oder as element man braucht man braucht und diese in den block einfügen # Entnehmen von start und end Werte für spätere vario erstellung - start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,block_vario,voerder_richtung) + start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,cofig,block_vario,voerder_richtung) # Erstellung des Vario selber vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ) # Reintuen des endblockes in den Modelspace @@ -1292,16 +1490,29 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) def handle_ils_2_0_kurve_angetrieben(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): - # kurvenrichtung = merkmale.get("Kurvenrichtung") - # kurvenwinkel = float(merkmale.get("Kurvenwinkel")) - # h0 = float(merkmale.get("Höhe Anfang")) - # h1 = float(merkmale.get("Höhe Ende")) - # h_zwischen = (h0 +h1)/2 - # rotation = float(merkmale.get("Drehung")) - # blockname = (f"Kurve{h1}") - # import_block(blockname,lib_doc,doc) - # msp.add_blockref,(x,y,h_zwischen)) - test = 2 + kurvenrichtung = merkmale.get("Kurvenrichtung") + kurvenwinkel = int(merkmale.get("Kurvenwinkel")) + h0 = float(merkmale.get("Höhe Anfang"))* 1000 + h1 = float(merkmale.get("Höhe Ende")) * 1000 + h_zwischen = (h0 +h1)/2 + antriebNebenStrecke = merkmale.get("AntriebNebenStrecke") + if antriebNebenStrecke == "links": + if kurvenrichtung == "links": + antriebstecke = "innen" + else: + antriebstecke = "außen" + else: + if kurvenrichtung == "links": + antriebstecke = "außen" + else: + antriebstecke = "innen" + + + rotation = float(merkmale.get("Drehung")) + blockname = (f"Vario_Kurve_{kurvenrichtung}_{kurvenwinkel}°_TEF_{antriebstecke}") + import_block(blockname,lib_doc,doc) + msp.add_blockref(blockname,(x,y,h_zwischen),dxfattribs={"rotation": rotation}) + def handle_ils_2_0_kurve(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): import_block("AN8",lib_doc,doc) @@ -1400,58 +1611,75 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, 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 -def 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, block_vario = None, vario_richtung = None, verbungden_höher = None,gefaelle_block=None,start = None,ende = None): +def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge,blockname,config, hight = None, block_vario = None, vario_richtung = None, verbungden_höher = None,gefaelle_block=None,start = None,ende = None,mit_horizontal_verbunden = None): halbe_laenge = laenge / 2 dy = halbe_laenge * math.cos(0) - - if (( hight == "higher" and drehung0 == "GUZS" )or (vario_richtung == "Auf"and verbungden_höher == False and drehung0 == "GUZS")or (vario_richtung == "Ab" and verbungden_höher == True and drehung0 == "GUZS") ): + asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) + esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset")) + winkel_as = float(config.get("Ils 2.0 core winkel", "winkel_as")) + winkel_es = float(config.get("Ils 2.0 core winkel", "winkel_es")) + if (( hight == "higher" and drehung0 == "GUZS" )or (vario_richtung == "Auf"and verbungden_höher == False and drehung0 == "GUZS")or + (vario_richtung == "Ab" and verbungden_höher == True and drehung0 == "GUZS")or (vario_richtung == "Horizontal" and drehung0 == "GUZS" and (mit_horizontal_verbunden == "unten_drehung_0_or_-90" or mit_horizontal_verbunden == "oben_drehung_-180_or_-270"))): block_as = "200000241_AS-Element_90_rechts" import_block(block_as,lib_doc,doc) + # block_as = dreh_block(block_as,doc,math.radians(winkel_as)) + # asoffset_y = asoffset * math.cos(math.radians(winkel_as)) + # asoffset_z = asoffset * math.sin(math.radians(winkel_as)) if vario_richtung == "Auf": start = (x , y + dy ,upper_hoehe_gefaehlle) ende = (x , y - dy + asoffset ,lower_hoehe_gefaehlle) - block_vario.add_blockref(block_as,(ende[0]-x ,ende[1]-asoffset -y,ende[2] -hoehe_gefaehlle),dxfattribs={"rotation": 180}) + block_vario.add_blockref(block_as,(ende[0]-x ,ende[1]-asoffset -y,ende[2] -hoehe_gefaehlle ),dxfattribs={"rotation": 180}) return start, ende elif vario_richtung == "Ab": - start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) + start = (x , y + dy - asoffset,upper_hoehe_gefaehlle ) ende = (x , y - dy ,lower_hoehe_gefaehlle) - block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) + block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle )) return start,ende elif vario_richtung =="Horizontal": - # TODO + start = (x , y + dy ,upper_hoehe_gefaehlle) + ende = (x , y - dy + asoffset ,lower_hoehe_gefaehlle ) + block_vario.add_blockref(block_as,(ende[0]-x ,ende[1]-asoffset -y,ende[2] -hoehe_gefaehlle ),dxfattribs={"rotation": 180}) return start, ende if laenge > asoffset: start[1] = start[1] - asoffset + start[2] = start[2] line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_gefaehlle) gefaelle_block.add_entity(copy) - gefaelle_block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) + gefaelle_block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle )) return False else: msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle)) return True - elif ((hight == "lower" and drehung0 == "GUZS") or (vario_richtung == "Auf"and verbungden_höher == True and drehung0 == "GUZS") or (vario_richtung == "Ab" and verbungden_höher == False and drehung0 == "GUZS")): + elif ((hight == "lower" and drehung0 == "GUZS") or (vario_richtung == "Auf"and verbungden_höher == True and drehung0 == "GUZS") or + (vario_richtung == "Ab" and verbungden_höher == False and drehung0 == "GUZS")or (vario_richtung == "Horizontal" and drehung0 == "GUZS" and (mit_horizontal_verbunden == "oben_drehung_0_or_-90" or mit_horizontal_verbunden == "unten_drehung_-180_or_-270"))): block_es = "200000146_ES-Element_90_rechts" import_block(block_es,lib_doc,doc) + # block_es = dreh_block(block_es,doc,math.radians(winkel_es)) + # esoffset_y = asoffset * math.cos(math.radians(winkel_es)) + # esoffset_z = asoffset * math.sin(math.radians(winkel_es)) if vario_richtung == "Auf": - start = (x , y + dy-esoffset,upper_hoehe_gefaehlle) + start = (x , y + dy-esoffset,upper_hoehe_gefaehlle ) ende = (x , y - dy ,lower_hoehe_gefaehlle) - block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset-y ,start[2] -hoehe_gefaehlle),dxfattribs={"rotation": 180}) + block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset-y ,start[2] -hoehe_gefaehlle ),dxfattribs={"rotation": 180}) return start, ende elif vario_richtung == "Ab": start = (x , y + dy,upper_hoehe_gefaehlle) - ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) - block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) + ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle ) + block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle )) return start, ende elif vario_richtung =="Horizontal": - # TODO + start = (x , y + dy-esoffset_y,upper_hoehe_gefaehlle ) + ende = (x , y - dy ,lower_hoehe_gefaehlle) + block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset-y ,start[2] -hoehe_gefaehlle ),dxfattribs={"rotation": 180}) return start, ende if laenge > esoffset: ende[1] = ende[1] + esoffset + ende[2] = ende[2] line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" copy= line.copy() @@ -1459,13 +1687,15 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff copy.translate(-x,-y,-hoehe_gefaehlle) gefaelle_block.add_entity(copy) - gefaelle_block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) + gefaelle_block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset_y-y ,ende[2] -hoehe_gefaehlle - esoffset_z/2)) return False else: msp.add_blockref(block_es,(x,y,lower_hoehe_gefaehlle)) return True - elif ((hight == "higher" and drehung0 == "UZS")or (vario_richtung == "Auf"and verbungden_höher == False and drehung0 == "UZS") or (vario_richtung == "Ab" and verbungden_höher == True and drehung0 == "UZS")): + elif ((hight == "higher" and drehung0 == "UZS")or (vario_richtung == "Auf"and verbungden_höher == False and drehung0 == "UZS") or + (vario_richtung == "Ab" and verbungden_höher == True and drehung0 == "UZS")or (vario_richtung == "Horizontal" and drehung0 == "UZS" and (mit_horizontal_verbunden == "unten_drehung_0_or_-90" or mit_horizontal_verbunden == "oben_drehung_-180_or_-270"))): + block_as = "200000241_AS-Element_90_rechts" block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) if vario_richtung == "Auf": @@ -1480,7 +1710,10 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start, ende elif vario_richtung =="Horizontal": - # TODO + start = (x , y + dy ,upper_hoehe_gefaehlle) + ende = (x , y - dy + asoffset,lower_hoehe_gefaehlle) + + block_vario.add_blockref(block_as,(ende[0]-x ,ende[1]-asoffset -y,ende[2] - hoehe_gefaehlle)) return start, ende if laenge > asoffset: @@ -1496,7 +1729,8 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle),dxfattribs={"rotation": 180}) return True - elif (( 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")): + elif (( 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")or (vario_richtung == "Horizontal" and drehung0 == "UZS" and (mit_horizontal_verbunden == "oben_drehung_0_or_-90" or mit_horizontal_verbunden == "unten_drehung_-180_or_-270"))): block_es = "400102632_ES-Element_90_links" import_block(block_es,lib_doc,doc) @@ -1511,8 +1745,10 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start,ende elif vario_richtung =="Horizontal": - # TODO - return start, ende + start = (x , y + dy-esoffset ,upper_hoehe_gefaehlle) + ende = (x , y - dy,lower_hoehe_gefaehlle) + block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset -y,start[2] - hoehe_gefaehlle)) + return start, ende if laenge > esoffset: ende[1] = ende[1] + esoffset line = Line.new(dxfattribs={"start": start, "end": ende}) @@ -1526,8 +1762,11 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff msp.add_blockref(block_es,(x,y,lower_hoehe_gefaehlle),dxfattribs={"rotation": 180}) return True -def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2, drehung0, drehung1, laenge, hight_position, blockname, block_vario = None,voerder_richtung = None, am_kreisel = None, erster_kreisel_höher = None,y1=None,z1 =None): +def gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2, drehung0, drehung1, laenge, hight_position, blockname,config, block_vario = None,voerder_richtung = None, am_kreisel = None, erster_kreisel_höher = None,y1=None,z1 =None): #erstellung des blockes falls die gefaelle strecke mit einem kreisel verbunden ist, mehrere variation von selben weil diese nötig sind sobald man die richtigen inserts bekommen + + asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) + esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset")) if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: middle_hoehe = upper_hoehe_gefaehlle upper_hoehe_gefaehlle = lower_hoehe_gefaehlle @@ -1539,12 +1778,16 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh (voerder_richtung == "Ab"and ((am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel== 2 and erster_kreisel_höher == False)) and drehung0 == "GUZS" and drehung1== "GUZS")): block_es = "200000146_ES-Element_90_rechts" import_block(block_es,lib_doc,doc) + # block_es = dreh_block(block_es,doc,math.radians(3)) + # esoffset_y = esoffset * math.cos(math.radians(3)) + # esoffset_z = esoffset * math.sin(math.radians(3)) + if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) halbe_laenge = laenge / 2 dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": - start = (x , y+ dy - esoffset,upper_hoehe_gefaehlle) + start = (x , y+ dy - esoffset,upper_hoehe_gefaehlle) ende = (x , y1 ,z1) block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset-y ,start[2] -hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start,ende @@ -1554,13 +1797,13 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) return start, ende start = (x , y + dy,upper_hoehe_gefaehlle) - ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) + ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_gefaehlle) block.add_entity(copy) - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) + block.add_blockref(block_es, (ende[0]-x ,ende[1]- esoffset-y ,ende[2] -hoehe_gefaehlle )) elif ((blockname not in doc.blocks and drehung0 == "GUZS" and drehung1 == "GUZS") or (am_kreisel != None and drehung0 == "GUZS" and drehung1 == "GUZS")): if am_kreisel == None: @@ -1568,6 +1811,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh halbe_laenge = laenge / 2 block_as = "200000241_AS-Element_90_rechts" import_block(block_as,lib_doc,doc) + block_as = dreh_block(block_es,doc,math.radians(3)) dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": @@ -2102,6 +2346,8 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl 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 + winkel_motor = int(config.get("Ils 2.0 core winkel","winkel_motor")) + winkel_umlenk = int(config.get("Ils 2.0 core winkel","winkel_umlenk")) motor_vorhanden = bool(merkmale.get("hatMotor")) umlenk_vorhanden = bool(merkmale.get("hatUmlenkung")) if merkmale.get("Winkel_Gefaellestrecke") != None: @@ -2165,8 +2411,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block(block_Vario_Motorstation_500mm, lib_doc, doc) 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)) + block_Vario_Motorstation_500mm = dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(winkel_motor)) + block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(winkel_umlenk)) 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]) @@ -2174,59 +2420,61 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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: + if voerder_richtung== "Auf": # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - 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")) + winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen")) + winkel_plus = int(winkel) + winkel_core + block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_plus}°") + block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_plus}°") - 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) - block_Vario_Bogen_auf_51 = dreh_block(block_Vario_Bogen_auf_51, doc,math.radians(3)) - block_Vario_Bogen_ab_51 = dreh_block(block_Vario_Bogen_ab_51, doc,math.radians(-48)) + auf_attrib =import_block(block_Vario_Bogen_auf, lib_doc, doc) + ab_attrib =import_block(block_Vario_Bogen_ab, lib_doc, doc) + block_Vario_Bogen_auf = dreh_block(block_Vario_Bogen_auf, doc,math.radians(winkel_core)) + block_Vario_Bogen_ab = dreh_block(block_Vario_Bogen_ab, doc,math.radians(-winkel)) - Vario_Bogen_auf_51_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_51_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_51_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_51_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_51_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_51_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_51_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_51_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_51_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_51_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_51_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_51_attrib["DELTA_VP_0"])) + Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_1"])) + Vario_Bogen_ab_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_0"])) - Vario_Bogen_auf_51_Delta_SP_0 = [Vario_Bogen_auf_51_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_51_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_51_Delta_SP_0[1],-Vario_Bogen_auf_51_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_51_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_51_Delta_SP_1 = [Vario_Bogen_auf_51_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_51_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_51_Delta_SP_1[1],-Vario_Bogen_auf_51_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_51_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_51_Delta_SP_0 = [Vario_Bogen_ab_51_Delta_SP_0 [0] * math.cos(math.radians(-48))+ Vario_Bogen_ab_51_Delta_SP_0[2]* math.sin(math.radians(-48)) ,Vario_Bogen_ab_51_Delta_SP_0[1],-Vario_Bogen_ab_51_Delta_SP_0[0] * math.sin(math.radians(-48))+ Vario_Bogen_ab_51_Delta_SP_0[2] * math.cos(math.radians(-48)) ] - Vario_Bogen_ab_51_Delta_SP_1 =[ Vario_Bogen_ab_51_Delta_SP_1 [0] * math.cos(math.radians(-48))+ Vario_Bogen_ab_51_Delta_SP_1[2]* math.sin(math.radians(-48)) ,Vario_Bogen_ab_51_Delta_SP_1[1],-Vario_Bogen_ab_51_Delta_SP_1[0] * math.sin(math.radians(-48))+ Vario_Bogen_ab_51_Delta_SP_1[2] * math.cos(math.radians(-48)) ] - Vario_Bogen_auf_51_Delta_VP_1 = [Vario_Bogen_auf_51_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_51_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_51_Delta_VP_1[1],-Vario_Bogen_auf_51_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_51_Delta_VP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_51_Delta_VP_0 = [Vario_Bogen_ab_51_Delta_VP_0 [0] * math.cos(math.radians(-48))+ Vario_Bogen_ab_51_Delta_VP_0[2]* math.sin(math.radians(-48)) ,Vario_Bogen_ab_51_Delta_VP_0[1],-Vario_Bogen_ab_51_Delta_VP_0[0] * math.sin(math.radians(-48))+ Vario_Bogen_ab_51_Delta_VP_0[2] * math.cos(math.radians(-48)) ] + Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(-winkel)) ] + Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(-winkel)) ] + Vario_Bogen_auf_Delta_VP_1 = [Vario_Bogen_auf_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_VP_1[1],-Vario_Bogen_auf_Delta_VP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_ab_Delta_VP_0 = [Vario_Bogen_ab_Delta_VP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_VP_0[1],-Vario_Bogen_ab_Delta_VP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2] * math.cos(math.radians(-winkel)) ] # 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_51_Delta_SP_0): + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_51_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_51_Delta_SP_1): + Vario_Bogen_auf_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1): if i< 2 and wert< 0: - Vario_Bogen_auf_51_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_51_Delta_SP_0): + Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0): if i< 2 and wert< 0: - Vario_Bogen_ab_51_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_51_Delta_SP_1): + Vario_Bogen_ab_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1): if i< 2 and wert< 0: - Vario_Bogen_ab_51_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_51_Delta_VP_1): + Vario_Bogen_ab_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_1): if i< 2 and wert< 0: - Vario_Bogen_auf_51_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_51_Delta_VP_0): + Vario_Bogen_auf_Delta_VP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_0): if i< 2 and wert< 0: - Vario_Bogen_ab_51_Delta_VP_0[i] = abs(wert) + Vario_Bogen_ab_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_51,(ende[0] -x ,ende[1] +Vario_Bogen_auf_51_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_51_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - ende_VP = (ende[0] +Vario_Bogen_auf_51_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_51_Delta_VP_1[0]+Vario_Bogen_auf_51_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_51_Delta_VP_1[2]- Vario_Bogen_auf_51_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_51_Delta_SP_1[0] + Vario_Bogen_auf_51_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_51_Delta_SP_1[2] - Vario_Bogen_auf_51_Delta_SP_0[2]) + block.add_blockref(block_Vario_Bogen_auf,(ende[0] -x ,ende[1] +Vario_Bogen_auf_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) + ende_VP = (ende[0] +Vario_Bogen_auf_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_Delta_VP_1[0]+Vario_Bogen_auf_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_Delta_VP_1[2]- Vario_Bogen_auf_Delta_SP_0[2]) + ende = (ende[0] ,ende[1] +Vario_Bogen_auf_Delta_SP_1[0] + Vario_Bogen_auf_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_Delta_SP_1[2] - Vario_Bogen_auf_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_51 ,(start[0]-x,start[1] - Vario_Bogen_ab_51_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_51_Delta_SP_1[2]),dxfattribs={"rotation": 90}) + block.add_blockref(block_Vario_Bogen_ab ,(start[0]-x,start[1] - Vario_Bogen_ab_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - start_VP = start[0] +Vario_Bogen_ab_51_Delta_VP_0[1],start[1]-Vario_Bogen_ab_51_Delta_VP_0[0] - Vario_Bogen_ab_51_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_51_Delta_VP_0[2] - Vario_Bogen_ab_51_Delta_SP_1[2] - start = start[0] ,start[1] - Vario_Bogen_ab_51_Delta_SP_0[0] - Vario_Bogen_ab_51_Delta_SP_1[0],start[2] - Vario_Bogen_ab_51_Delta_SP_1[2]+ Vario_Bogen_ab_51_Delta_SP_0[2] + start_VP = start[0] +Vario_Bogen_ab_Delta_VP_0[1],start[1]-Vario_Bogen_ab_Delta_VP_0[0] - Vario_Bogen_ab_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_Delta_VP_0[2] - Vario_Bogen_ab_Delta_SP_1[2] + start = start[0] ,start[1] - Vario_Bogen_ab_Delta_SP_0[0] - Vario_Bogen_ab_Delta_SP_1[0],start[2] - Vario_Bogen_ab_Delta_SP_1[2]+ Vario_Bogen_ab_Delta_SP_0[2] # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) @@ -2243,471 +2491,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - - #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_51,(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_51_attrib) - - 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 = 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)) - block_Vario_Bogen_ab_39 = dreh_block(block_Vario_Bogen_ab_39, doc,math.radians(-36)) - Vario_Bogen_auf_39_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_39_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_39_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_39_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_39_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_39_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_39_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_39_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_39_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_39_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_39_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_39_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_39_Delta_SP_0 = [Vario_Bogen_auf_39_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_39_Delta_SP_0[1],-Vario_Bogen_auf_39_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_39_Delta_SP_1 = [Vario_Bogen_auf_39_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_39_Delta_SP_1[1],-Vario_Bogen_auf_39_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_39_Delta_SP_0 = [Vario_Bogen_ab_39_Delta_SP_0 [0] * math.cos(math.radians(-36))+ Vario_Bogen_ab_39_Delta_SP_0[2]* math.sin(math.radians(-36)) ,Vario_Bogen_ab_39_Delta_SP_0[1],-Vario_Bogen_ab_39_Delta_SP_0[0] * math.sin(math.radians(-36))+ Vario_Bogen_ab_39_Delta_SP_0[2] * math.cos(math.radians(-36)) ] - Vario_Bogen_ab_39_Delta_SP_1 =[ Vario_Bogen_ab_39_Delta_SP_1 [0] * math.cos(math.radians(-36))+ Vario_Bogen_ab_39_Delta_SP_1[2]* math.sin(math.radians(-36)) ,Vario_Bogen_ab_39_Delta_SP_1[1],-Vario_Bogen_ab_39_Delta_SP_1[0] * math.sin(math.radians(-36))+ Vario_Bogen_ab_39_Delta_SP_1[2] * math.cos(math.radians(-36)) ] - Vario_Bogen_auf_39_Delta_VP_1 = [Vario_Bogen_auf_39_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_39_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_39_Delta_VP_1[1],-Vario_Bogen_auf_39_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_39_Delta_VP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_39_Delta_VP_0 = [Vario_Bogen_ab_39_Delta_VP_0 [0] * math.cos(math.radians(-36))+ Vario_Bogen_ab_39_Delta_VP_0[2]* math.sin(math.radians(-36)) ,Vario_Bogen_ab_39_Delta_VP_0[1],-Vario_Bogen_ab_39_Delta_VP_0[0] * math.sin(math.radians(-36))+ Vario_Bogen_ab_39_Delta_VP_0[2] * math.cos(math.radians(-36)) ] - - # 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_39_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_39_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_39_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_39_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_39_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_39_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_39_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_39_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_39_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_39_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_39_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_39_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_39,(ende[0] -x ,ende[1] +Vario_Bogen_auf_39_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_39_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - - ende_VP = (ende[0] +Vario_Bogen_auf_39_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_39_Delta_VP_1[0]+Vario_Bogen_auf_39_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_39_Delta_VP_1[2]- Vario_Bogen_auf_39_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_39_Delta_SP_1[0] + Vario_Bogen_auf_39_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_39_Delta_SP_1[2] -Vario_Bogen_auf_39_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_39 ,(start[0]-x,start[1] - Vario_Bogen_ab_39_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_39_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - start_VP = start[0] +Vario_Bogen_ab_39_Delta_VP_0[1],start[1]-Vario_Bogen_ab_39_Delta_VP_0[0] - Vario_Bogen_ab_39_Delta_SP_1[0] ,start[2]+ Vario_Bogen_ab_39_Delta_VP_0[2] - Vario_Bogen_ab_39_Delta_SP_1[2] - - start = start[0] ,start[1] - Vario_Bogen_ab_39_Delta_SP_0[0] - Vario_Bogen_ab_39_Delta_SP_1[0],start[2] +Vario_Bogen_ab_39_Delta_SP_0[2] - Vario_Bogen_ab_39_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_39,(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_39_attrib) - - 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 = 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) - - # 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_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)) - block_Vario_Bogen_ab_18 = dreh_block(block_Vario_Bogen_ab_18, doc,math.radians(-15)) - Vario_Bogen_auf_18_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_18_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_18_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_18_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_18_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_18_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_18_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_18_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_18_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_18_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_18_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_18_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_18_Delta_SP_0 = [Vario_Bogen_auf_18_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_18_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_18_Delta_SP_0[1],-Vario_Bogen_auf_18_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_18_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_18_Delta_SP_1 = [Vario_Bogen_auf_18_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_18_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_18_Delta_SP_1[1],-Vario_Bogen_auf_18_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_18_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_18_Delta_SP_0 = [Vario_Bogen_ab_18_Delta_SP_0 [0] * math.cos(math.radians(-15))+ Vario_Bogen_ab_18_Delta_SP_0[2]* math.sin(math.radians(-15)) ,Vario_Bogen_ab_18_Delta_SP_0[1],-Vario_Bogen_ab_18_Delta_SP_0[0] * math.sin(math.radians(-15))+ Vario_Bogen_ab_18_Delta_SP_0[2] * math.cos(math.radians(-15)) ] - Vario_Bogen_ab_18_Delta_SP_1 =[ Vario_Bogen_ab_18_Delta_SP_1 [0] * math.cos(math.radians(-15))+ Vario_Bogen_ab_18_Delta_SP_1[2]* math.sin(math.radians(-15)) ,Vario_Bogen_ab_18_Delta_SP_1[1],-Vario_Bogen_ab_18_Delta_SP_1[0] * math.sin(math.radians(-15))+ Vario_Bogen_ab_18_Delta_SP_1[2] * math.cos(math.radians(-15)) ] - Vario_Bogen_auf_18_Delta_VP_1 = [Vario_Bogen_auf_18_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_18_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_18_Delta_VP_1[1],-Vario_Bogen_auf_18_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_18_Delta_VP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_18_Delta_VP_0 = [Vario_Bogen_ab_18_Delta_VP_0 [0] * math.cos(math.radians(-15))+ Vario_Bogen_ab_18_Delta_VP_0[2]* math.sin(math.radians(-15)) ,Vario_Bogen_ab_18_Delta_VP_0[1],-Vario_Bogen_ab_18_Delta_VP_0[0] * math.sin(math.radians(-15))+ Vario_Bogen_ab_18_Delta_VP_0[2] * math.cos(math.radians(-15)) ] - - # 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_18_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_18_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_18_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_18_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_18_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_18_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_18_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_18_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_18_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_18_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_18_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_18_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_18,(ende[0] -x ,ende[1] +Vario_Bogen_auf_18_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_18_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - ende_VP = (ende[0] +Vario_Bogen_auf_18_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_18_Delta_VP_1[0]+Vario_Bogen_auf_18_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_18_Delta_VP_1[2]- Vario_Bogen_auf_18_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_18_Delta_SP_1[0] + Vario_Bogen_auf_18_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_18_Delta_SP_1[2] - Vario_Bogen_auf_18_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_18 ,(start[0]-x,start[1] - Vario_Bogen_ab_18_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_18_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - - start_VP = start[0] +Vario_Bogen_ab_18_Delta_VP_0[1],start[1]-Vario_Bogen_ab_18_Delta_VP_0[0] - Vario_Bogen_ab_18_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_18_Delta_VP_0[2] - Vario_Bogen_ab_18_Delta_SP_1[2] - start = start[0] ,start[1] - Vario_Bogen_ab_18_Delta_SP_0[0] - Vario_Bogen_ab_18_Delta_SP_1[0],start[2] +Vario_Bogen_ab_18_Delta_SP_0[2] - Vario_Bogen_ab_18_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_18,(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_18_attrib) - - elif winkel == 12: - # Einfügen der 15 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - - 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)) - block_Vario_Bogen_ab_15 = dreh_block(block_Vario_Bogen_ab_15, doc,math.radians(-12)) - Vario_Bogen_auf_15_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_15_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_15_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_15_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_15_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_15_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_15_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_15_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_15_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_15_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_15_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_15_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_15_Delta_SP_0 = [Vario_Bogen_auf_15_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_15_Delta_SP_0[1],-Vario_Bogen_auf_15_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_15_Delta_SP_1 = [Vario_Bogen_auf_15_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_15_Delta_SP_1[1],-Vario_Bogen_auf_15_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_15_Delta_SP_0 = [Vario_Bogen_ab_15_Delta_SP_0 [0] * math.cos(math.radians(-12))+ Vario_Bogen_ab_15_Delta_SP_0[2]* math.sin(math.radians(-12)) ,Vario_Bogen_ab_15_Delta_SP_0[1],-Vario_Bogen_ab_15_Delta_SP_0[0] * math.sin(math.radians(-12))+ Vario_Bogen_ab_15_Delta_SP_0[2] * math.cos(math.radians(-12)) ] - Vario_Bogen_ab_15_Delta_SP_1 =[ Vario_Bogen_ab_15_Delta_SP_1 [0] * math.cos(math.radians(-12))+ Vario_Bogen_ab_15_Delta_SP_1[2]* math.sin(math.radians(-12)) ,Vario_Bogen_ab_15_Delta_SP_1[1],-Vario_Bogen_ab_15_Delta_SP_1[0] * math.sin(math.radians(-12))+ Vario_Bogen_ab_15_Delta_SP_1[2] * math.cos(math.radians(-12)) ] - Vario_Bogen_auf_15_Delta_VP_1 = [Vario_Bogen_auf_15_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_15_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_15_Delta_VP_1[1],-Vario_Bogen_auf_15_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_15_Delta_VP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_15_Delta_VP_0 = [Vario_Bogen_ab_15_Delta_VP_0 [0] * math.cos(math.radians(-12))+ Vario_Bogen_ab_15_Delta_VP_0[2]* math.sin(math.radians(-12)) ,Vario_Bogen_ab_15_Delta_VP_0[1],-Vario_Bogen_ab_15_Delta_VP_0[0] * math.sin(math.radians(-12))+ Vario_Bogen_ab_15_Delta_VP_0[2] * math.cos(math.radians(-12)) ] - - # 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_15_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_15_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_15_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_15_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_15_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_15_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_15_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_15_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_15_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_15_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_15_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_15_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_15,(ende[0] -x ,ende[1] +Vario_Bogen_auf_15_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_15_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - ende_VP = (ende[0] +Vario_Bogen_auf_15_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_15_Delta_VP_1[0]+Vario_Bogen_auf_15_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_15_Delta_VP_1[2]- Vario_Bogen_auf_15_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_15_Delta_SP_1[0] + Vario_Bogen_auf_15_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_15_Delta_SP_1[2] - Vario_Bogen_auf_15_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_15 ,(start[0]-x,start[1] - Vario_Bogen_ab_15_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_15_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - start_VP = start[0] +Vario_Bogen_ab_15_Delta_VP_0[1],start[1]-Vario_Bogen_ab_15_Delta_VP_0[0] - Vario_Bogen_ab_15_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_15_Delta_VP_0[2] - Vario_Bogen_ab_15_Delta_SP_1[2] - start = start[0] ,start[1] - Vario_Bogen_ab_15_Delta_SP_0[0] - Vario_Bogen_ab_15_Delta_SP_1[0],start[2] +Vario_Bogen_ab_15_Delta_SP_0[2] - Vario_Bogen_ab_15_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() - - # Erstellung der zwischen Line - copy_VP.translate(-x,-y,-hoehe_vario) - block.add_entity(copy_VP) - 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_auf_15,(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, auf_15_attrib) - - elif winkel == 9: - # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - 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)) - block_Vario_Bogen_ab_12 = dreh_block(block_Vario_Bogen_ab_12, doc,math.radians(-9)) - 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"])) - Vario_Bogen_ab_12_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_12_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_12_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_12_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_12_Delta_SP_0 = [Vario_Bogen_auf_12_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_12_Delta_SP_0[1],-Vario_Bogen_auf_12_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_12_Delta_SP_1 = [Vario_Bogen_auf_12_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_12_Delta_SP_1[1],-Vario_Bogen_auf_12_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_12_Delta_SP_0 = [Vario_Bogen_ab_12_Delta_SP_0 [0] * math.cos(math.radians(-9))+ Vario_Bogen_ab_12_Delta_SP_0[2]* math.sin(math.radians(-9)) ,Vario_Bogen_ab_12_Delta_SP_0[1],-Vario_Bogen_ab_12_Delta_SP_0[0] * math.sin(math.radians(-9))+ Vario_Bogen_ab_12_Delta_SP_0[2] * math.cos(math.radians(-9)) ] - Vario_Bogen_ab_12_Delta_SP_1 =[ Vario_Bogen_ab_12_Delta_SP_1 [0] * math.cos(math.radians(-9))+ Vario_Bogen_ab_12_Delta_SP_1[2]* math.sin(math.radians(-9)) ,Vario_Bogen_ab_12_Delta_SP_1[1],-Vario_Bogen_ab_12_Delta_SP_1[0] * math.sin(math.radians(-9))+ Vario_Bogen_ab_12_Delta_SP_1[2] * math.cos(math.radians(-9)) ] - Vario_Bogen_auf_12_Delta_VP_1 = [Vario_Bogen_auf_12_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_12_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_12_Delta_VP_1[1],-Vario_Bogen_auf_12_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_12_Delta_VP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_12_Delta_VP_0 = [Vario_Bogen_ab_12_Delta_VP_0 [0] * math.cos(math.radians(-9))+ Vario_Bogen_ab_12_Delta_VP_0[2]* math.sin(math.radians(-9)) ,Vario_Bogen_ab_12_Delta_VP_0[1],-Vario_Bogen_ab_12_Delta_VP_0[0] * math.sin(math.radians(-9))+ Vario_Bogen_ab_12_Delta_VP_0[2] * math.cos(math.radians(-9)) ] - - # 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_12_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_12_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_12_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_12_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_12_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_12_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_12_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_12,(ende[0] -x ,ende[1] +Vario_Bogen_auf_12_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_12_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - - ende_VP = (ende[0] +Vario_Bogen_auf_12_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_12_Delta_VP_1[0]+Vario_Bogen_auf_12_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_12_Delta_VP_1[2]- Vario_Bogen_auf_12_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_12_Delta_SP_1[0] + Vario_Bogen_auf_12_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_12_Delta_SP_1[2] - Vario_Bogen_auf_12_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_12 ,(start[0]-x,start[1] - Vario_Bogen_ab_12_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_12_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - - start_VP = start[0] +Vario_Bogen_ab_12_Delta_VP_0[1],start[1]-Vario_Bogen_ab_12_Delta_VP_0[0] - Vario_Bogen_ab_12_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_12_Delta_VP_0[2] - Vario_Bogen_ab_12_Delta_SP_1[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] - # 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_12,(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_12_attrib) - elif winkel == 3: - # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - 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"])) - Vario_Bogen_ab_6_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_6_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_6_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_6_Delta_SP_0 = [Vario_Bogen_auf_6_Delta_SP_0 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_0[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_SP_0[1],-Vario_Bogen_auf_6_Delta_SP_0[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_0[2] * math.cos(math.radians(-3)) ] - Vario_Bogen_auf_6_Delta_SP_1 = [Vario_Bogen_auf_6_Delta_SP_1 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_1[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_SP_1[1],-Vario_Bogen_auf_6_Delta_SP_1[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_1[2] * math.cos(math.radians(-3)) ] - Vario_Bogen_ab_6_Delta_SP_0 = [Vario_Bogen_ab_6_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_0[1],-Vario_Bogen_ab_6_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_6_Delta_SP_1 =[ Vario_Bogen_ab_6_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_1[1],-Vario_Bogen_ab_6_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_6_Delta_VP_1 = [Vario_Bogen_auf_6_Delta_VP_1 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_VP_1[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_VP_1[1],-Vario_Bogen_auf_6_Delta_VP_1[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_VP_1[2] * math.cos(math.radians(-3)) ] - Vario_Bogen_ab_6_Delta_VP_0 = [Vario_Bogen_ab_6_Delta_VP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_VP_0[1],-Vario_Bogen_ab_6_Delta_VP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_0[2] * math.cos(math.radians(3)) ] - - # 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_6_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_6_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_6_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_6_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_6_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_6_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_6_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_6_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_6_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_6_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_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_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] - - # 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_ab_6,(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_6_attrib) - elif winkel == 0: + else: # Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_auf")) @@ -2783,12 +2568,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_3,(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_3_attrib) - elif voerder_richtung == "Ab": # 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 @@ -2832,75 +2611,76 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block( block_Vario_Motorstation_500mm, lib_doc, doc) 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)) + block_Vario_Motorstation_500mm = dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(winkel_motor)) + block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(winkel_umlenk)) 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_Umlenkstation_VP = start[0] - 66.5, start[1] -500 *math.cos(math.radians(-winkel_umlenk))+ math.sin(math.radians(-winkel_umlenk))* -45,start[2] + math.sin(math.radians(-winkel_umlenk))*500+ math.cos(math.radians(-winkel_umlenk))*-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: 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 + ende_Motor_VP = ende[0] - 66.5, ende[1] +500 *math.cos(math.radians(-winkel_motor))+ math.sin(math.radians(-winkel_motor))* -45,ende[2] - math.sin(math.radians(-winkel_motor))*500+ math.cos(math.radians(-winkel_motor))*-45 ende = ende[0] , ende[1] + umlenk_motor_offset[0],ende[2] +umlenk_motor_offset[2] elif winkel == 3: ende_Motor_VP = ende[0] - 66.5, ende[1]+ winkel_VP_offset_hinten[0] ,ende[2] - winkel_VP_offset_vorne[2] - if winkel == 48: - # Einfügen der 45 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - block_Vario_Bogen_auf_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_auf")) - block_Vario_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"])) - Vario_Bogen_ab_45_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_45_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_45_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_45_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_45_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_45_attrib["DELTA_VP_1"])) + if winkel != 3: + winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen")) + winkel_minus = int(winkel) - winkel_core + block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_minus}°") + block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_minus}°") + ab_attrib =import_block( block_Vario_Bogen_ab , lib_doc, doc) + auf_attrib =import_block( block_Vario_Bogen_auf, lib_doc, doc) + block_Vario_Bogen_ab = dreh_block( block_Vario_Bogen_ab, doc, math.radians(winkel_core)) + block_Vario_Bogen_auf= dreh_block( block_Vario_Bogen_auf, doc, math.radians(winkel)) + Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_0"])) + Vario_Bogen_ab_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_1"])) - Vario_Bogen_auf_45_Delta_SP_0 = [Vario_Bogen_auf_45_Delta_SP_0 [0] * math.cos(math.radians(48))+ Vario_Bogen_auf_45_Delta_SP_0[2]* math.sin(math.radians(48)) ,Vario_Bogen_auf_45_Delta_SP_0[1],-Vario_Bogen_auf_45_Delta_SP_0[0] * math.sin(math.radians(48))+ Vario_Bogen_auf_45_Delta_SP_0[2] * math.cos(math.radians(48)) ] - Vario_Bogen_auf_45_Delta_SP_1 = [Vario_Bogen_auf_45_Delta_SP_1 [0] * math.cos(math.radians(48))+ Vario_Bogen_auf_45_Delta_SP_1[2]* math.sin(math.radians(48)) ,Vario_Bogen_auf_45_Delta_SP_1[1],-Vario_Bogen_auf_45_Delta_SP_1[0] * math.sin(math.radians(48))+ Vario_Bogen_auf_45_Delta_SP_1[2] * math.cos(math.radians(48)) ] - Vario_Bogen_ab_45_Delta_SP_0 = [Vario_Bogen_ab_45_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_45_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_45_Delta_SP_0[1],-Vario_Bogen_ab_45_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_45_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_45_Delta_SP_1 =[ Vario_Bogen_ab_45_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_45_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_45_Delta_SP_1[1],-Vario_Bogen_ab_45_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_45_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_45_Delta_VP_0 = [Vario_Bogen_auf_45_Delta_VP_0 [0] * math.cos(math.radians(48))+ Vario_Bogen_auf_45_Delta_VP_0[2]* math.sin(math.radians(48)) ,Vario_Bogen_auf_45_Delta_VP_0[1],-Vario_Bogen_auf_45_Delta_VP_0[0] * math.sin(math.radians(48))+ Vario_Bogen_auf_45_Delta_VP_0[2] * math.cos(math.radians(48)) ] - Vario_Bogen_ab_45_Delta_VP_1 = [Vario_Bogen_ab_45_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_45_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_45_Delta_VP_1[1],-Vario_Bogen_ab_45_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_45_Delta_VP_1[2] * math.cos(math.radians(3)) ] + Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel)) ] + Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel)) ] + Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_auf_Delta_VP_0 = [Vario_Bogen_auf_Delta_VP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_VP_0[1],-Vario_Bogen_auf_Delta_VP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2] * math.cos(math.radians(winkel)) ] + Vario_Bogen_ab_Delta_VP_1 = [Vario_Bogen_ab_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_VP_1[1],-Vario_Bogen_ab_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ] # 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_45_Delta_SP_0): + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_45_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_45_Delta_SP_1): + Vario_Bogen_auf_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1): if i< 2 and wert< 0: - Vario_Bogen_auf_45_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_45_Delta_SP_0): + Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0): if i< 2 and wert< 0: - Vario_Bogen_ab_45_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_45_Delta_SP_1): + Vario_Bogen_ab_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1): if i< 2 and wert< 0: - Vario_Bogen_ab_45_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_45_Delta_VP_0): + Vario_Bogen_ab_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_0): if i< 2 and wert< 0: - Vario_Bogen_auf_45_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_45_Delta_VP_1): + Vario_Bogen_auf_Delta_VP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_1): if i< 2 and wert< 0: - Vario_Bogen_ab_45_Delta_VP_1[i] = abs(wert) + Vario_Bogen_ab_Delta_VP_1[i] = abs(wert) #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_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] + block.add_blockref(block_Vario_Bogen_ab, (start[0]-x,start[1]-y- Vario_Bogen_ab_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + start_VP = start[0] -Vario_Bogen_ab_Delta_VP_1[1],start[1]- Vario_Bogen_ab_Delta_VP_1[0]- Vario_Bogen_ab_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_Delta_VP_1[2]-Vario_Bogen_ab_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]) + start =(start[0], start[1]- Vario_Bogen_ab_Delta_SP_0[0]- Vario_Bogen_ab_Delta_SP_1[0],start[2]-Vario_Bogen_ab_Delta_SP_0[2]+Vario_Bogen_ab_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_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]) + block.add_blockref(block_Vario_Bogen_auf, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + ende_VP = (ende[0] -Vario_Bogen_auf_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_Delta_VP_0[0]+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_Delta_VP_0[2]- Vario_Bogen_auf_Delta_SP_1[2]) + ende = (ende[0],ende[1]+ Vario_Bogen_auf_Delta_SP_1[0]+ Vario_Bogen_auf_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_Delta_SP_1[2]+ Vario_Bogen_auf_Delta_SP_0[2]) # Erstellung der VARIO Line @@ -2918,387 +2698,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_ab_45,(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_45_attrib) - - elif winkel == 36: - # Einfügen der 33 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - - 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"])) - Vario_Bogen_ab_33_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_33_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_33_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_33_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_33_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_33_attrib["DELTA_VP_1"])) - - Vario_Bogen_auf_33_Delta_SP_0 = [Vario_Bogen_auf_33_Delta_SP_0 [0] * math.cos(math.radians(36))+ Vario_Bogen_auf_33_Delta_SP_0[2]* math.sin(math.radians(36)) ,Vario_Bogen_auf_33_Delta_SP_0[1],-Vario_Bogen_auf_33_Delta_SP_0[0] * math.sin(math.radians(36))+ Vario_Bogen_auf_33_Delta_SP_0[2] * math.cos(math.radians(36)) ] - Vario_Bogen_auf_33_Delta_SP_1 = [Vario_Bogen_auf_33_Delta_SP_1 [0] * math.cos(math.radians(36))+ Vario_Bogen_auf_33_Delta_SP_1[2]* math.sin(math.radians(36)) ,Vario_Bogen_auf_33_Delta_SP_1[1],-Vario_Bogen_auf_33_Delta_SP_1[0] * math.sin(math.radians(36))+ Vario_Bogen_auf_33_Delta_SP_1[2] * math.cos(math.radians(36)) ] - Vario_Bogen_ab_33_Delta_SP_0 = [Vario_Bogen_ab_33_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_33_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_33_Delta_SP_0[1],-Vario_Bogen_ab_33_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_33_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_33_Delta_SP_1 =[ Vario_Bogen_ab_33_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_33_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_33_Delta_SP_1[1],-Vario_Bogen_ab_33_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_33_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_33_Delta_VP_0 = [Vario_Bogen_auf_33_Delta_VP_0 [0] * math.cos(math.radians(36))+ Vario_Bogen_auf_33_Delta_VP_0[2]* math.sin(math.radians(36)) ,Vario_Bogen_auf_33_Delta_VP_0[1],-Vario_Bogen_auf_33_Delta_VP_0[0] * math.sin(math.radians(36))+ Vario_Bogen_auf_33_Delta_VP_0[2] * math.cos(math.radians(36)) ] - Vario_Bogen_ab_33_Delta_VP_1 = [Vario_Bogen_ab_33_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_33_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_33_Delta_VP_1[1],-Vario_Bogen_ab_33_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_33_Delta_VP_1[2] * math.cos(math.radians(3)) ] - - # 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_33_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_33_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_33_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_33_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_33_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_33_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_33_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_33_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_33_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_auf_33_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_33_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_33_Delta_VP_1[i] = abs(wert) - - #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_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_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]) - - # 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_ab_33,(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_33_attrib) - elif winkel == 24: - # Einfügen der 21 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - 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"])) - Vario_Bogen_ab_21_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_21_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_21_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_21_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_21_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_21_attrib["DELTA_VP_1"])) - - Vario_Bogen_auf_21_Delta_SP_0 = [Vario_Bogen_auf_21_Delta_SP_0 [0] * math.cos(math.radians(24))+ Vario_Bogen_auf_21_Delta_SP_0[2]* math.sin(math.radians(24)) ,Vario_Bogen_auf_21_Delta_SP_0[1],-Vario_Bogen_auf_21_Delta_SP_0[0] * math.sin(math.radians(24))+ Vario_Bogen_auf_21_Delta_SP_0[2] * math.cos(math.radians(24)) ] - Vario_Bogen_auf_21_Delta_SP_1 = [Vario_Bogen_auf_21_Delta_SP_1 [0] * math.cos(math.radians(24))+ Vario_Bogen_auf_21_Delta_SP_1[2]* math.sin(math.radians(24)) ,Vario_Bogen_auf_21_Delta_SP_1[1],-Vario_Bogen_auf_21_Delta_SP_1[0] * math.sin(math.radians(24))+ Vario_Bogen_auf_21_Delta_SP_1[2] * math.cos(math.radians(24)) ] - Vario_Bogen_ab_21_Delta_SP_0 = [Vario_Bogen_ab_21_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_21_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_21_Delta_SP_0[1],-Vario_Bogen_ab_21_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_21_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_21_Delta_SP_1 =[ Vario_Bogen_ab_21_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_21_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_21_Delta_SP_1[1],-Vario_Bogen_ab_21_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_21_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_21_Delta_VP_0 = [Vario_Bogen_auf_21_Delta_VP_0 [0] * math.cos(math.radians(24))+ Vario_Bogen_auf_21_Delta_VP_0[2]* math.sin(math.radians(24)) ,Vario_Bogen_auf_21_Delta_VP_0[1],-Vario_Bogen_auf_21_Delta_VP_0[0] * math.sin(math.radians(24))+ Vario_Bogen_auf_21_Delta_VP_0[2] * math.cos(math.radians(24)) ] - Vario_Bogen_ab_21_Delta_VP_1 = [Vario_Bogen_ab_21_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_21_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_21_Delta_VP_1[1],-Vario_Bogen_ab_21_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_21_Delta_VP_1[2] * math.cos(math.radians(3)) ] - - # 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_21_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_21_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_21_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_21_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_21_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_21_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_21_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_21_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_21_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_auf_21_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_21_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_21_Delta_VP_1[i] = abs(wert) - - #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_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_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]) - - # 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_ab_21,(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_21_attrib) - elif winkel == 15: - # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - 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"])) - Vario_Bogen_ab_12_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_12_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_12_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_12_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_VP_1"])) - - Vario_Bogen_auf_12_Delta_SP_0 = [Vario_Bogen_auf_12_Delta_SP_0 [0] * math.cos(math.radians(15))+ Vario_Bogen_auf_12_Delta_SP_0[2]* math.sin(math.radians(15)) ,Vario_Bogen_auf_12_Delta_SP_0[1],-Vario_Bogen_auf_12_Delta_SP_0[0] * math.sin(math.radians(15))+ Vario_Bogen_auf_12_Delta_SP_0[2] * math.cos(math.radians(15)) ] - Vario_Bogen_auf_12_Delta_SP_1 = [Vario_Bogen_auf_12_Delta_SP_1 [0] * math.cos(math.radians(15))+ Vario_Bogen_auf_12_Delta_SP_1[2]* math.sin(math.radians(15)) ,Vario_Bogen_auf_12_Delta_SP_1[1],-Vario_Bogen_auf_12_Delta_SP_1[0] * math.sin(math.radians(15))+ Vario_Bogen_auf_12_Delta_SP_1[2] * math.cos(math.radians(15)) ] - Vario_Bogen_ab_12_Delta_SP_0 = [Vario_Bogen_ab_12_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_12_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_12_Delta_SP_0[1],-Vario_Bogen_ab_12_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_12_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_12_Delta_SP_1 =[ Vario_Bogen_ab_12_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_12_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_12_Delta_SP_1[1],-Vario_Bogen_ab_12_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_12_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_12_Delta_VP_0 = [Vario_Bogen_auf_12_Delta_VP_0 [0] * math.cos(math.radians(15))+ Vario_Bogen_auf_12_Delta_VP_0[2]* math.sin(math.radians(15)) ,Vario_Bogen_auf_12_Delta_VP_0[1],-Vario_Bogen_auf_12_Delta_VP_0[0] * math.sin(math.radians(15))+ Vario_Bogen_auf_12_Delta_VP_0[2] * math.cos(math.radians(15)) ] - Vario_Bogen_ab_12_Delta_VP_1 = [Vario_Bogen_ab_12_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_12_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_12_Delta_VP_1[1],-Vario_Bogen_ab_12_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_12_Delta_VP_1[2] * math.cos(math.radians(3)) ] - - # 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_12_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_12_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_12_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_12_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_12_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_auf_12_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_12_Delta_VP_1[i] = abs(wert) - - #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_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_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]) - ende = (ende[0],ende[1]+ Vario_Bogen_auf_12_Delta_SP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_SP_0[2]- Vario_Bogen_auf_12_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_ab_12,(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_12_attrib) - elif winkel == 12: - # Einfügen der 9 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - block_Vario_Bogen_auf_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_auf")) - block_Vario_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"])) - Vario_Bogen_ab_9_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_9_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_9_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_9_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_9_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_9_attrib["DELTA_VP_1"])) - - Vario_Bogen_auf_9_Delta_SP_0 = [Vario_Bogen_auf_9_Delta_SP_0 [0] * math.cos(math.radians(12))+ Vario_Bogen_auf_9_Delta_SP_0[2]* math.sin(math.radians(12)) ,Vario_Bogen_auf_9_Delta_SP_0[1],-Vario_Bogen_auf_9_Delta_SP_0[0] * math.sin(math.radians(12))+ Vario_Bogen_auf_9_Delta_SP_0[2] * math.cos(math.radians(12)) ] - Vario_Bogen_auf_9_Delta_SP_1 = [Vario_Bogen_auf_9_Delta_SP_1 [0] * math.cos(math.radians(12))+ Vario_Bogen_auf_9_Delta_SP_1[2]* math.sin(math.radians(12)) ,Vario_Bogen_auf_9_Delta_SP_1[1],-Vario_Bogen_auf_9_Delta_SP_1[0] * math.sin(math.radians(12))+ Vario_Bogen_auf_9_Delta_SP_1[2] * math.cos(math.radians(12)) ] - Vario_Bogen_ab_9_Delta_SP_0 = [Vario_Bogen_ab_9_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_9_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_9_Delta_SP_0[1],-Vario_Bogen_ab_9_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_9_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_9_Delta_SP_1 =[ Vario_Bogen_ab_9_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_9_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_9_Delta_SP_1[1],-Vario_Bogen_ab_9_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_9_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_9_Delta_VP_0 = [Vario_Bogen_auf_9_Delta_VP_0 [0] * math.cos(math.radians(12))+ Vario_Bogen_auf_9_Delta_VP_0[2]* math.sin(math.radians(12)) ,Vario_Bogen_auf_9_Delta_VP_0[1],-Vario_Bogen_auf_9_Delta_VP_0[0] * math.sin(math.radians(12))+ Vario_Bogen_auf_9_Delta_VP_0[2] * math.cos(math.radians(12)) ] - Vario_Bogen_ab_9_Delta_VP_1 = [Vario_Bogen_ab_9_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_9_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_9_Delta_VP_1[1],-Vario_Bogen_ab_9_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_9_Delta_VP_1[2] * math.cos(math.radians(3)) ] - - # 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_9_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_9_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_9_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_9_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_9_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_9_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_9_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_9_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_9_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_auf_9_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_9_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_9_Delta_VP_1[i] = abs(wert) - - #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_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_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]) - - # 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_9,(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_9_attrib) - - elif winkel == 9: - # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - - 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"])) - Vario_Bogen_ab_6_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_6_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_6_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_VP_1"])) - - Vario_Bogen_auf_6_Delta_SP_0 = [Vario_Bogen_auf_6_Delta_SP_0 [0] * math.cos(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_0[2]* math.sin(math.radians(9)) ,Vario_Bogen_auf_6_Delta_SP_0[1],-Vario_Bogen_auf_6_Delta_SP_0[0] * math.sin(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_0[2] * math.cos(math.radians(9)) ] - Vario_Bogen_auf_6_Delta_SP_1 = [Vario_Bogen_auf_6_Delta_SP_1 [0] * math.cos(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_1[2]* math.sin(math.radians(9)) ,Vario_Bogen_auf_6_Delta_SP_1[1],-Vario_Bogen_auf_6_Delta_SP_1[0] * math.sin(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_1[2] * math.cos(math.radians(9)) ] - Vario_Bogen_ab_6_Delta_SP_0 = [Vario_Bogen_ab_6_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_0[1],-Vario_Bogen_ab_6_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_6_Delta_SP_1 =[ Vario_Bogen_ab_6_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_1[1],-Vario_Bogen_ab_6_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_6_Delta_VP_0 = [Vario_Bogen_auf_6_Delta_VP_0 [0] * math.cos(math.radians(9))+ Vario_Bogen_auf_6_Delta_VP_0[2]* math.sin(math.radians(9)) ,Vario_Bogen_auf_6_Delta_VP_0[1],-Vario_Bogen_auf_6_Delta_VP_0[0] * math.sin(math.radians(9))+ Vario_Bogen_auf_6_Delta_VP_0[2] * math.cos(math.radians(9)) ] - Vario_Bogen_ab_6_Delta_VP_1 = [Vario_Bogen_ab_6_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_VP_1[1],-Vario_Bogen_ab_6_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_1[2] * math.cos(math.radians(3)) ] - - # 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_6_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_6_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_6_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_6_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_6_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_6_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_6_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_auf_6_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_6_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_6_Delta_VP_1[i] = abs(wert) - #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_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_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]) - - # 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_auf_6,(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, auf_6_attrib) elif winkel == 3: # Nur erstellung der zwischen und Vario linie weil der Bogen hier nicht nötig ist line_VP = Line.new(dxfattribs={"start": start_Umlenkstation_VP,"end": ende_Motor_VP}) @@ -3331,6 +2730,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var else: clone.transform(matrix) block_links.add_entity(clone) + def get_layer(doc, lib_doc, blockname): if blockname in lib_doc.blocks: src = lib_doc.blocks[blockname] @@ -3430,7 +2830,8 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: h0 = merkmale.get("Höhe Anfang") h1 = merkmale.get("Höhe Ende") kurvenrichtung = merkmale.get("Kurvenrichtung") - angetriebene_kurve.append({"Id": Id,"H0": h0,"H1":h1,"kurvenrichtung":kurvenrichtung}) + tefkurve = merkmale.get("AntriebNebenStrecke") + angetriebene_kurve.append({"Id": Id,"H0": h0,"H1":h1,"kurvenrichtung":kurvenrichtung,"Tefkurve": tefkurve}) for gerade in geraden: anweisungen = 0 voerder_anweisung = 0 @@ -3442,11 +2843,13 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: eintrag["vario_hoehe_0"] = foerderer.get("H0") eintrag["vario_hoehe_1"] = foerderer.get("H1") eintrag["Kurvenrichtung"] = foerderer.get("kurvenrichtung") + eintrag["Tefkurve"] = foerderer.get("Tefkurve") 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["Tefkurve_1"] = foerderer.get("Tefkurve") for kreis in kreisel: if kreis["Id"] in gerade["NachbarIds"]: @@ -3594,12 +2997,6 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat logger.warning(msg) else: print(msg) - continue - # if "Motor" not in doc.layers: - # doc.layers.add(name="Motor", color=2) - # for insert in msp.query("INSERT"): - # change_layer(doc, insert) - for insert in msp.query("INSERT"): basepoint = insert.dxf.insert @@ -3712,6 +3109,4 @@ if __name__ == "__main__": output_path = Path(args.output) if args.output else (work_dir / f"{csv_path.stem}.dxf") output_path_jason = Path(args.output) if args.output else (work_dir / f"{csv_path.stem}.jason") main(csv_path, default_lib_path, cfg_path,allgemein_cfg_path, output_path,output_path_jason, verbose=args.verbose, logger=logger) - logger.info("=== plant2dxf Verarbeitung abgeschlossen ===") - - + logger.info("=== plant2dxf Verarbeitung abgeschlossen ===") \ No newline at end of file