From c97b36254d0127333802fd43f8046f6f866f7f82 Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 3 Nov 2025 12:01:37 +0100 Subject: [PATCH] =?UTF-8?q?Die=20Sp=20werte=20von=20den=20blocken=20selber?= =?UTF-8?q?=20werden=20jetzt=20benutzt=20um=20die=20offsets=20auszurechnen?= =?UTF-8?q?=20und=20die=20Offsets=20aus=20dem=20shape=20liste=20gel=C3=B6s?= =?UTF-8?q?cht=20als=20resultat?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cfg/shapes.cfg | 105 --- lib/plant2dxf.py | 1720 +++++++++++++++++++++++++++++++++++----------- 2 files changed, 1322 insertions(+), 503 deletions(-) diff --git a/cfg/shapes.cfg b/cfg/shapes.cfg index 9615172..8ecad5a 100644 --- a/cfg/shapes.cfg +++ b/cfg/shapes.cfg @@ -19,111 +19,6 @@ esoffset = 479.95 Umlenkstation = 499.3148,0,26.1680 -Vario_Bogen_auf_51_Delta_SP_0= 629.34, 0, 32.98 -Vario_Bogen_auf_51_Delta_SP_1 = 433.90, 0, 481.89 - -Vario_Bogen_ab_51_Delta_SP_0 = 408.68, 0, 453.89 -Vario_Bogen_ab_51_Delta_SP_1 =591.71, 0, 31.01 - -Vario_Bogen_auf_51_Delta_VP_1 = 30.77, 51.3653,28.59 -Vario_Bogen_ab_51_Delta_VP_0 = 32.97,51.3653,26.6341 - -Vario_Bogen_ab_45_Delta_SP_0 = 438.6149, 0, 75.3228 -Vario_Bogen_ab_45_Delta_SP_1 =293.89, 0, 326.4 - -Vario_Bogen_auf_45_Delta_SP_0 = 471.2929, 0, 24.6994 -Vario_Bogen_auf_45_Delta_SP_1 =315.7893, 0, 350.7195 - -Vario_Bogen_auf_39_Delta_SP_0= 489.1281, 0, 25.6341 -Vario_Bogen_auf_39_Delta_SP_1 = 358.3992, 0, 260.3923 - -Vario_Bogen_ab_39_Delta_SP_0 = 335.7703, 0, 243.9534 -Vario_Bogen_ab_39_Delta_SP_1 =461.1878, 0, 24.1747 - -Vario_Bogen_auf_39_Delta_VP_1 = 335.3992, 51.3653, 35.5535 -Vario_Bogen_ab_39_Delta_VP_0 = 364.86,51.3653,25.6341 - -Vario_Bogen_ab_33_Delta_SP_0 = 464.52, 0, 76.86 -Vario_Bogen_ab_33_Delta_SP_1 = 331.83, 0, 241.09 - -Vario_Bogen_auf_33_Delta_SP_0 = 487.8932, 0, 25.5694 -Vario_Bogen_auf_33_Delta_SP_1 = 350.7617, 0, 254.8433 - -Vario_Bogen_auf_33_Delta_VP_1 = 335.3992, 51.3653, 35.5535 -Vario_Bogen_ab_33_Delta_VP_0 = 364.86,51.3653,25.6341 - - -Vario_Bogen_auf_27_Delta_SP_0 =320.5894, 0, 16.8014 -Vario_Bogen_auf_27_Delta_SP_1= 262.5433,0,116.8918 - -Vario_Bogen_ab_27_Delta_SP_0 =245.2168, 0, 109.1776 -Vario_Bogen_ab_27_Delta_SP_1 = 301.6492,0,15.8088 - -Vario_Bogen_auf_27_Delta_VP_1 = 15.4583, 50, 38.66 -Vario_Bogen_ab_27_Delta_VP_0= 18.928,50, 37.988 - -Vario_Bogen_ab_21_Delta_SP_0 =308.9830, 0,68.5291 -Vario_Bogen_ab_21_Delta_SP_1 = 243.2899,0,108.3196 - -Vario_Bogen_auf_21_Delta_SP_0 =323.6047, 0, 16.9594 -Vario_Bogen_auf_21_Delta_SP_1= 256.67,0,114.27 -Vario_Bogen_auf_18_Delta_SP_0 = 301.4561, 0,16.96 -Vario_Bogen_auf_18_Delta_SP_1 = 291.5838, 0,78.1296 - -Vario_Bogen_ab_18_Delta_SP_0 = 279.4978, 0,74.8912 -Vario_Bogen_ab_18_Delta_SP_1 = 288.9608, 0,15.1438 - - -Vario_Bogen_auf_18_Delta_VP_1 = 11.62, 50, 40.37 -Vario_Bogen_ab_18_Delta_VP_0 = 10.53,50, 40.59 - - -Vario_Bogen_auf_15_Delta_SP_0 = 149.7944, 0,7.8504 -Vario_Bogen_auf_15_Delta_SP_1= 146.7221, 0,31.1868 - -Vario_Bogen_ab_15_Delta_SP_0 = 136.55, 0,29.02 -Vario_Bogen_ab_15_Delta_SP_1 = 139.41, 0,7.31 - -Vario_Bogen_auf_15_Delta_VP_1 = 8.28, 50, 41.18 -Vario_Bogen_ab_15_Delta_VP_0 = 9.15,50, 40.99 - -Vario_Bogen_auf_12_Delta_SP_0_auf= 149.7944, 0,7.8504 -Vario_Bogen_auf_12_Delta_SP_1_auf = 148.1533, 0,23.4652 - -Vario_Bogen_ab_12_Delta_SP_0_auf = 139.95, 0,22.17 -Vario_Bogen_ab_12_Delta_SP_1_auf = 141.5026, 0,7.4158 - -Vario_Bogen_auf_12_Delta_VP_1_auf= 5.5, 50, 41.49 -Vario_Bogen_ab_12_Delta_VP_0_auf = 7.23,50, 41.38 - -Vario_Bogen_ab_12_Delta_SP_0_ab = 141.5026, 0,59.7518 -Vario_Bogen_ab_12_Delta_SP_1_ab = 136.8686, 0,36.6738 - -Vario_Bogen_auf_12_Delta_SP_0_ab= 149.7944, 0,7.8504 -Vario_Bogen_auf_12_Delta_SP_1_ab = 144.8889, 0,38.8229 - -Vario_Bogen_auf_12_Delta_VP_1_ab = 5.5, 50, 41.49 -Vario_Bogen_ab_12_Delta_VP_0_ab= 7.23,50, 41.38 - -Vario_Bogen_ab_9_Delta_SP_0 = 143.5855, 0,59.8610 -Vario_Bogen_ab_9_Delta_SP_1 = 140.6406, 0,29.8941 - -Vario_Bogen_auf_9_Delta_SP_0= 149.7944, 0,7.8504 -Vario_Bogen_auf_9_Delta_SP_1 = 146.72, 0,31.19 - -Vario_Bogen_auf_9_Delta_VP_1 = 5.5, 50, 41.49 -Vario_Bogen_ab_9_Delta_VP_0= 7.23,50, 41.38 - - -Vario_Bogen_ab_6_Delta_SP_0 = 195.7284, 0,62.5937 -Vario_Bogen_ab_6_Delta_SP_1 = 193.5840, 0,30.6607 - -Vario_Bogen_auf_6_Delta_SP_0= 199.8629, 0,10.4744 -Vario_Bogen_auf_6_Delta_SP_1 = 197.6732, 0,31.3084 - -Vario_Bogen_auf_6_Delta_VP_1 = 5.5, 50, 41.49 -Vario_Bogen_ab_6_Delta_VP_0= 7.23,50, 41.38 - diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index 9074c98..983a104 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -16,8 +16,9 @@ from ezdxf.entities import Line from ezdxf.math import Matrix44, X_AXIS,Y_AXIS,Z_AXIS from pathlib import Path import math +import re from utils import check_environment_var, setup_logger -import copy + # --------------------------------------------------------- CFG-Leser für shapes.cfg @@ -89,7 +90,7 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: - Stellt sicher, dass benutzte Layer im Ziel existieren (mit Eigenschaften) - Übernimmt Basis­punkt und Block-Layer, falls vorhanden """ - + if ((block_name in to_doc.blocks)): return if block_name not in from_doc.blocks: @@ -114,6 +115,7 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: to_doc.layers.add(name=layer_name) except Exception: pass + tgt = to_doc.blocks.new(name=block_name) # Basis­punkt/Layer des Blocks übernehmen, wenn vorhanden try: @@ -124,13 +126,21 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: tgt.block.dxf.layer = src.block.dxf.layer except Exception: pass - + + att_def = {} for ent in src: copy = ent.copy() - + if ent.dxftype() == "ATTDEF": + if ent.dxf.tag == "DELTA_SP_0": + test = 3 + if ent.dxftype() == "ATTDEF": + att_def[ent.dxf.tag] =ent.dxf.text if ent.dxftype() == "INSERT": + import_block(ent.dxf.name,from_doc, to_doc,None) tgt.add_entity(copy) + if att_def != []: + return att_def def dreh_block(block_name: str, to_doc, winkel) : """Importiert Blockdefinition block_name von from_doc nach to_doc. @@ -153,9 +163,9 @@ def dreh_block(block_name: str, to_doc, winkel) : copy.transform(rotation_matrix) block.add_entity(copy) return dreh_block_name - - + + def berechne_hoehe(csv_path, logger=None): y_werte = [] try: @@ -311,13 +321,13 @@ def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose): def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config): #Vorbereitung der attributen - - + + if "6-SP" not in doc.layers: doc.layers.add(name="6-SP", color=7) verbunden_am_einen = False - - + + richtung2 ="DEFAULT" unterschiedlich = False asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) @@ -330,11 +340,11 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v gefaellestrecke_nachbarn = nachbarn break if "Drehung0" in gefaellestrecke_nachbarn and "Drehung1" not in gefaellestrecke_nachbarn: - drehung0 =gefaellestrecke_nachbarn.get("Drehung0") + drehung0 =gefaellestrecke_nachbarn.get("Drehung0") x0_kreisel = float(gefaellestrecke_nachbarn.get("x0")) y0_kreisel = float(gefaellestrecke_nachbarn.get("y0")) - - hoehe0 = float(gefaellestrecke_nachbarn.get("Hoehe0")) + + hoehe0 = float(gefaellestrecke_nachbarn.get("Hoehe0")) richtung0 = float(gefaellestrecke_nachbarn.get("rotation0")) richtung_rad0= math.radians(richtung0) abstand0 = float(gefaellestrecke_nachbarn.get("abstand0")) * 1000 @@ -342,16 +352,16 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v try: laenge = float(laenge_m) * 1000 # Meter → mm except ValueError: - laenge = 10000 - + laenge = 10000 - halbe_laenge = laenge / 2 + + 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 @@ -359,7 +369,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v lower_hoehe_gefaehlle = hoehe2 winkel = winkel -180 - + am_kreisel, kreisel_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None) if am_kreisel == 1: start = x +dx, y + dy,upper_hoehe_gefaehlle @@ -374,7 +384,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v hight ="higher" else: hight = "lower" - + blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}" erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,hight) @@ -384,8 +394,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v tag= "NAME", text= merkmale.get("bezeichner"), insert = (x,y) - ) - a.is_invisible = True + ) + a.is_invisible = True @@ -400,13 +410,13 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v try: laenge = float(laenge_m) * 1000 # Meter → mm except ValueError: - laenge = 10000 - halbe_laenge = laenge / 2 + laenge = 10000 + halbe_laenge = laenge / 2 dx = halbe_laenge *math.sin(winkel * -1) dy = halbe_laenge * math.cos(winkel) - drehung0 =gefaellestrecke_nachbarn.get("Drehung0") + drehung0 =gefaellestrecke_nachbarn.get("Drehung0") drehung1 = gefaellestrecke_nachbarn.get("Drehung1") - hoehe0 = gefaellestrecke_nachbarn.get("Hoehe0") + hoehe0 = gefaellestrecke_nachbarn.get("Hoehe0") hoehe1 = gefaellestrecke_nachbarn.get("Hoehe1") x0_kreisel = float(gefaellestrecke_nachbarn.get("x0")) y0_kreisel = float(gefaellestrecke_nachbarn.get("y0")) @@ -419,9 +429,9 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v richtung_rad1 = math.radians(richtung1) abstand0 = float(gefaellestrecke_nachbarn.get("abstand0")) * 1000 abstand1 = float(gefaellestrecke_nachbarn.get("abstand1")) * 1000 - - - + + + #ausrechnung position kreisel @@ -484,8 +494,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v hight_position = "lower" else: hight_position = "higher" - - # austausch der werte damit immer davon ausgehen dass der 1 kreisel in unserer Liste am Kreisel verbuden ist + + # austausch der werte damit immer davon ausgehen dass der 1 kreisel in unserer Liste am Kreisel verbuden ist if kreisel_verbunden == 1 and am_kreisel ==2: am_kreisel == 1 @@ -496,7 +506,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v hight_position = "lower" else: hight_position = "higher" - + else: if richtung2 == "Vertikal": if x0_kreisel < x1_kreisel: @@ -519,7 +529,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v gefaelle = "oben" else: gefaelle = "unten" - # austausch der werte damit immer davon ausgehen dass der 1 kreisel in unserer Liste am Kreisel verbuden ist + # austausch der werte damit immer davon ausgehen dass der 1 kreisel in unserer Liste am Kreisel verbuden ist if am_kreisel == 2: am_kreisel = 1 @@ -531,7 +541,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v else: hight_position = "higher" - + if gefaelle == "oben": rotation = 0 elif gefaelle == "unten" : @@ -552,8 +562,8 @@ 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}_{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) blockref_layer = get_layer(doc, lib_doc, blockname) - - + + bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer }) a = bref.add_attrib( tag= "NAME", @@ -567,10 +577,10 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v try: laenge = float(laenge_m) * 1000 # Meter → mm except ValueError: - laenge = 10000 + laenge = 10000 winkel = math.radians(float(merkmale.get("Drehung"))) - halbe_laenge = laenge / 2 + halbe_laenge = laenge / 2 dx = halbe_laenge *math.sin(winkel * -1) dy = halbe_laenge * math.cos(winkel) start = x +dx, y + dy,upper_hoehe_gefaehlle @@ -583,9 +593,10 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config): - + # erstellung des Layers falls nicht vorhanden if "VARIO" not in doc.layers: doc.layers.add(name="VARIO", color=3) + # Vorbereitung der Werte voerder_richtung = merkmale.get("Förderrichtung") winkel = int(merkmale.get("Winkel")) verbunden_am_einen = False @@ -598,39 +609,48 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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 + lower_hoehe_vario = float(merkmale.get("Höhe Anfang")) *1000 + # 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 upper_hoehe_vario = lower_hoehe_vario lower_hoehe_vario = hight + # Korrektur der rotation mit der Umstellung der Höhe rotation = rotation -180 - hoehe_vario= (upper_hoehe_vario + lower_hoehe_vario)/2 + 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"): gefaellestrecke_vario = nachbarn break laenge = float(merkmale.get("Länge in Meter")) *1000 + # Für spätere berechnung schauen ob der erste Kreis in der Liste höher ist if upper_hoehe_vario == gefaellestrecke_vario.get("Hoehe0"): ein_kreisel_höher = True + # Aufruf falls nur mit einem Kreisel verbunden if "Drehung0" in gefaellestrecke_vario and "Drehung1" not in gefaellestrecke_vario: - halbe_laenge = laenge / 2 + # Vorbereitund der Daten des Kreisel + halbe_laenge = laenge / 2 zwischen_winkel = float(merkmale.get("Drehung")) richtung_rad = math.radians(zwischen_winkel) dx = halbe_laenge * math.sin(-1 *richtung_rad) dy = halbe_laenge * math.cos(richtung_rad) drehung0 = gefaellestrecke_vario.get("Drehung0") - + abstand0 = float(gefaellestrecke_vario.get("abstand0")) * 1000 x0_kreisel = float(gefaellestrecke_vario.get("x0")) y0_kreisel = float(gefaellestrecke_vario.get("y0")) 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 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") block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_True") + # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -638,10 +658,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block_vario = doc.blocks.new(blockname, base_point=(0,0,0)) dy_true = halbe_laenge * math.cos (0) 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 : l = (start[0],start[1],upper_hoehe_vario) @@ -657,11 +679,11 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve line = Line.new(dxfattribs={"start": l,"end":m }) - copy= line.copy() + copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) - - + + else: l = (ende[0],ende[1],lower_hoehe_vario) if voerder_richtung =="Auf": @@ -670,25 +692,28 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif voerder_richtung == "Ab": m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3))) ende = m - else: - m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) + else: + m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) ende = m line = Line.new(dxfattribs={"start": l,"end":m }) - copy= line.copy() + 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 ) + # reintuen des förderes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return - - - + # 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}") block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}") + # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -696,19 +721,24 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block_vario = doc.blocks.new(blockname, base_point=(0,0,0)) dy_true = halbe_laenge * math.cos (0) - msp.add_line((x , y -dy_true,upper_hoehe_vario),(x,y+dy_true,lower_hoehe_vario)) - + # 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(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) + # 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 ) + # reintuen des förderes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) if merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) - + + # Erstellung einer Vario förderes wenn es mit zwei Kreisel verbunden ist elif "Drehung0" in gefaellestrecke_vario and "Drehung1" in gefaellestrecke_vario: - halbe_laenge = laenge / 2 + # Vorbereitung der Werte für beide Kreisel + halbe_laenge = laenge / 2 zwischen_winkel = float(merkmale.get("Drehung")) richtung_rad = math.radians(zwischen_winkel) dx = halbe_laenge * math.sin(-1 *richtung_rad) @@ -728,17 +758,20 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve richtung1 = float(gefaellestrecke_vario.get("rotation1")) richtung_rad1= math.radians(richtung1) kreisel_hoehe1= float(gefaellestrecke_vario.get("Hoehe1")) + # Anpassung der Kreisel, damit der Höhere Kreisel immer zuerst ist if kreisel_hoehe0< kreisel_hoehe1: drehung2 = drehung0 drehung0 = drehung1 drehung1 = drehung2 - if(teileid == "shape_b804092f-b609-619c-2588-2b3944f060a6"): - test = 3 + + # Schauen ob der Förderer direkt am Kreisel verbunden ist am_kreisel,kreisel_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_vario, lower_hoehe_vario, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, x1_kreisel, y1_kreisel, richtung_rad1, abstand1) - + # Falls der Förder mit beiden Kreisel verbunden ist if kreisel_verbunden == 2: + # Erstellung der blockname für wenn die Motorstation rechts und links blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{drehung0}_{drehung1}_{kreisel_verbunden}") block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{drehung0}_{drehung1}_{kreisel_verbunden}") + # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -746,12 +779,13 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block_vario = doc.blocks.new(blockname, base_point=(0,0,0)) dy_true = halbe_laenge * math.cos (0) start = (x, y + dy_true,upper_hoehe_vario) ende = (x,y -dy_true,lower_hoehe_vario) l = (start[0],start[1],upper_hoehe_vario) - + # Eine 500 mm gefällestrecke an anfang und am ende reintuen if voerder_richtung =="Auf": m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario +500* math.sin(math.radians(3))) start = m @@ -766,7 +800,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve line = Line.new(dxfattribs={"start": l,"end":m }) - copy= line.copy() + copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) @@ -778,29 +812,34 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif voerder_richtung == "Ab": m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3))) ende = m - else: - m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) + else: + m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) ende = m line = Line.new(dxfattribs={"start": l,"end":m }) - copy= line.copy() + copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) + # Die Vario erstellung selber vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ) + # reintuen des förderes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + # Falls der Förderer nur mit einem Kreisel direkt verbunden ist if am_kreisel != 0: + #schauen ob der erste Kreisel höher ist if upper_hoehe_vario == kreisel_hoehe0: erster_kreisel_höher = True else: erster_kreisel_höher = False + # Erstellung der blockname für wenn die Motorstation rechts und links blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{am_kreisel}_{erster_kreisel_höher}_{drehung0}_{drehung1}") block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{am_kreisel}_{erster_kreisel_höher}_{drehung0}_{drehung1}") - - + + # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -808,9 +847,11 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block_vario = doc.blocks.new(blockname, base_point=(0,0,0)) dy_true = halbe_laenge * math.cos(0) - + + # schauen ob der Förderer mit welchen Kreisel der Förderer verbunden ist, und dem entsprechend eine Gefällestrecke dort reintuern if (am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False): start = (x, y + dy_true,upper_hoehe_vario) ende = (x,y -dy_true,lower_hoehe_vario) @@ -821,17 +862,17 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif voerder_richtung == "Ab": m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario -500* math.sin(math.radians(3))) z1 = m[2] - else: + else: m= (x,y -dy_true,lower_hoehe_vario) z1 = m[2] line = Line.new(dxfattribs={"start": l,"end":m }) - copy= line.copy() + copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) - y1 = start[1] - math.cos(math.radians(3)) *500 - + y1 = start[1] - math.cos(math.radians(3)) *500 + else: start = (x, y + dy_true,upper_hoehe_vario) ende = (x,y -dy_true,lower_hoehe_vario) @@ -842,18 +883,22 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif voerder_richtung == "Ab": m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3))) z1 = m[2] - else: - m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) + else: + m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) z1 = m[2] line = Line.new(dxfattribs={"start": l,"end":m }) - copy= line.copy() + copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) - y1 = ende[1] + math.cos(math.radians(3)) *500 - + y1 = ende[1] + math.cos(math.radians(3)) *500 + + # 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) + # 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 ) + # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) elif merkmale.get("Motorseite")== "rechts": @@ -861,12 +906,13 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve - + # Falls es nicht mit dem Kreisel direkt verbunden ist else: + # Erstellung der blockname für wenn die Motorstation rechts und links blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{drehung0}_{drehung1}") block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{drehung0}_{drehung1}") - - + + # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -875,19 +921,27 @@ 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}) return + # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht 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) - if blockname not in doc.blocks or block_name_links not in doc.blocks: - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,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 ) + # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + + # Erstellung des Varios falls es nicht mit einem Kreisel verbunden ist else: halbe_laenge = laenge/2 dy = halbe_laenge * math.cos(0) + # Erstellung der blockname für wenn die Motorstation rechts und links blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts") block_name_links =(f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links") + # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -895,24 +949,35 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + + # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block = doc.blocks.new(blockname, base_point=(0,0,0)) - + # Erstellung von start und ende start = (x,y +dy, upper_hoehe_vario) ende = (x ,y -dy, lower_hoehe_vario) - - - if blockname not in doc.blocks or block_name_links not in doc.blocks: - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung ) + + + # Erstellung des Förderes selber + vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung ) + # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": - msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + insert = msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) if merkmale.get("Motorseite")== "rechts": - msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + insert =msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + attrib_values = {} + + + + def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung ): - if voerder_richtung== "Auf": + # Falls auf der Vario Förderer auf ist + if voerder_richtung== "Auf" or voerder_richtung== "Horizontal": + + # Den Motorstaton und Umlenkstation auf die richtige position in block einfügen umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" @@ -922,254 +987,710 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(3)) - 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}) + 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]) block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - umlenk_motor_offset[0]/2 -y ,start[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 90}) start = start[0] , start[1] - umlenk_motor_offset[0],start[2] +umlenk_motor_offset[2] if winkel == 48: + # Einfügen der 51 Bogen und deren notwendigen Werten von dem config nehmen block_Vario_Bogen_auf_51 = "Vario_Bogen_auf_51°" block_Vario_Bogen_ab_51 = "Vario_Bogen_ab_51°" - Vario_Bogen_auf_51_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_51_Delta_SP_0")).split(",")) - Vario_Bogen_auf_51_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_51_Delta_SP_1")).split(",")) - Vario_Bogen_ab_51_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_51_Delta_SP_0")).split(",")) - Vario_Bogen_ab_51_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_51_Delta_SP_1")).split(",")) - Vario_Bogen_auf_51_Delta_VP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_51_Delta_VP_1")).split(",")) - Vario_Bogen_ab_51_Delta_VP_0= tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_51_Delta_VP_0")).split(",")) - import_block(block_Vario_Bogen_auf_51, lib_doc, doc) - import_block(block_Vario_Bogen_ab_51, lib_doc, doc) + + 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)) - - - 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 = (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]) - ende_VP = (ende[0] +Vario_Bogen_auf_51_Delta_VP_1[1], ende[1]-Vario_Bogen_auf_51_Delta_VP_1[0],ende[2] + Vario_Bogen_auf_51_Delta_VP_1[2]) - + 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"])) - 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}) - - 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_51_Delta_VP_0[1],start[1]+Vario_Bogen_ab_51_Delta_VP_0[0] ,start[2]-Vario_Bogen_ab_51_Delta_VP_0[2] + 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)) ] + + i = 0 + + for negativ in Vario_Bogen_auf_51_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_51_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_51_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_51_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_51_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_51_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_51_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_51_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_51_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_51_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_51_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_51_Delta_VP_0[i] = negativ + i = i + 1 + #einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + 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]) + # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + 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}) + + 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] + + # 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}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_Bogen_auf_51,(x,y,0)) + # msp.add_line((x+1000,y,0),(x-1000,y,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + - elif winkel == 36: + # Einfügen der 39 Bogen und deren notwendigen Werten von dem config nehmen block_Vario_Bogen_auf_39 = "Vario_Bogen_auf_39°" block_Vario_Bogen_ab_39 = "Vario_Bogen_ab_39°" - Vario_Bogen_auf_39_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_39_Delta_SP_0")).split(",")) - Vario_Bogen_auf_39_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_39_Delta_SP_1")).split(",")) - Vario_Bogen_ab_39_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_39_Delta_SP_0")).split(",")) - Vario_Bogen_ab_39_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_39_Delta_SP_1")).split(",")) - Vario_Bogen_auf_39_Delta_VP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_39_Delta_VP_1")).split(",")) - Vario_Bogen_ab_39_Delta_VP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_39_Delta_VP_0")).split(",")) - import_block(block_Vario_Bogen_auf_39, lib_doc, doc) - import_block(block_Vario_Bogen_ab_39, lib_doc, doc) + 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)) - - - 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 = (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]) - ende_VP = (ende[0] +Vario_Bogen_auf_39_Delta_VP_1[1], ende[1] +Vario_Bogen_auf_39_Delta_SP_1[0]-Vario_Bogen_auf_39_Delta_VP_1[0],ende[2] - Vario_Bogen_auf_39_Delta_VP_1[2]) - + 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"])) - 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 = 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] - - 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_0[0],start[2]-Vario_Bogen_ab_39_Delta_VP_0[2] + + 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)) ] + + + i = 0 + + for negativ in Vario_Bogen_auf_39_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_39_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_39_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_39_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_39_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_39_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_39_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_39_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_39_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_39_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_39_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_39_Delta_VP_0[i] = negativ + i = i + 1 + + # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + 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 ab blockes und erstellung des start_VP für die VARIO lineie + 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}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_Bogen_ab_39,(x,y,0)) + # msp.add_line((x+267.49,y-66.5,0),(x-267.49,y-66.5,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + - elif winkel == 24: + # Einfügen der 27 Bogen und deren notwendigen Werten von dem config nehmen block_Vario_Bogen_auf_27 = "Vario_Bogen_auf_27°" - block_Vario_Bogen_ab_27 = "Vario_Bogen_ab_27°" - Vario_Bogen_auf_27_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_27_Delta_SP_0")).split(",")) - Vario_Bogen_auf_27_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_27_Delta_SP_1")).split(",")) - Vario_Bogen_ab_27_Delta_SP_0= tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_27_Delta_SP_0")).split(",")) - Vario_Bogen_ab_27_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_27_Delta_SP_1")).split(",")) - Vario_Bogen_auf_27_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_27_Delta_VP_1")).split(",")) - Vario_Bogen_ab_27_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_27_Delta_VP_0")).split(",")) - import_block(block_Vario_Bogen_auf_27, lib_doc, doc) - import_block(block_Vario_Bogen_ab_27, lib_doc, doc) + block_Vario_Bogen_ab_27 = "Vario_Bogen_ab_27°" + auf_27_attrib =import_block(block_Vario_Bogen_auf_27, lib_doc, doc) + ab_27_attrib = import_block(block_Vario_Bogen_ab_27, lib_doc, doc) block_Vario_Bogen_auf_27= dreh_block(block_Vario_Bogen_auf_27, doc,math.radians(3)) block_Vario_Bogen_ab_27 = dreh_block(block_Vario_Bogen_ab_27, doc,math.radians(-24)) + Vario_Bogen_auf_27_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_27_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_27_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_27_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_27_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_VP_1"])) + Vario_Bogen_ab_27_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_VP_0"])) + + + 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)) ] + + + i = 0 + + for negativ in Vario_Bogen_auf_27_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_27_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_27_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_27_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_27_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_27_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_27_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_27_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_27_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_27_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_27_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_27_Delta_VP_0[i] = negativ + i = i + 1 + + # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie 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]) - ende_VP = (ende[0] +Vario_Bogen_auf_27_Delta_VP_1[1], ende[1] +Vario_Bogen_auf_27_Delta_VP_1[0],ende[2] - Vario_Bogen_auf_27_Delta_VP_1[2]) - 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 = start[0] ,start[1] - Vario_Bogen_ab_27_Delta_SP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0],start[2] -Vario_Bogen_ab_27_Delta_SP_0[2] + Vario_Bogen_ab_27_Delta_SP_1[2] - start_VP = start[0] +Vario_Bogen_ab_27_Delta_VP_0[1],start[1]+Vario_Bogen_ab_27_Delta_VP_0[0] ,start[2]-Vario_Bogen_ab_27_Delta_VP_0[2] + # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + 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}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - - + # msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0)) + # msp.add_line((x+1000,y,0),(x-1000,y,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + + elif winkel == 15: + # Einfügen der 18 Bogen und deren notwendigen Werten von dem config nehmen block_Vario_Bogen_ab_18 = "Vario_Bogen_ab_18°" block_Vario_Bogen_auf_18 = "Vario_Bogen_auf_18°" - Vario_Bogen_auf_18_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_18_Delta_SP_0")).split(",")) - Vario_Bogen_auf_18_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_18_Delta_SP_1")).split(",")) - Vario_Bogen_ab_18_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_18_Delta_SP_0")).split(",")) - Vario_Bogen_ab_18_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_18_Delta_SP_1")).split(",")) - Vario_Bogen_auf_18_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_18_Delta_VP_1")).split(",")) - Vario_Bogen_ab_18_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_18_Delta_VP_0")).split(",")) - import_block(block_Vario_Bogen_auf_18, lib_doc, doc) - import_block(block_Vario_Bogen_ab_18, lib_doc, doc,math.radians(-15)) + 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)) ] + + + i = 0 + + for negativ in Vario_Bogen_auf_18_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_18_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_18_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_18_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_18_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_18_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_18_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_18_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_18_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_18_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_18_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_18_Delta_VP_0[i] = negativ + i = i + 1 + # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie 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 = (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]) - ende_VP = (ende[0] +Vario_Bogen_auf_18_Delta_VP_1[1], ende[1] +Vario_Bogen_auf_18_Delta_VP_1[0],ende[2] - Vario_Bogen_auf_18_Delta_VP_1[2]) + 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]) - 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 = 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] - start_VP = start[0] +Vario_Bogen_ab_18_Delta_VP_0[1],start[1]+Vario_Bogen_ab_18_Delta_VP_0[0] ,start[2]-Vario_Bogen_ab_18_Delta_VP_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 ab blockes und erstellung des start_VP für die VARIO lineie + 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}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - + elif winkel == 12: block_Vario_Bogen_ab_15 = "Vario_Bogen_ab_15°" block_Vario_Bogen_auf_15 = "Vario_Bogen_auf_15°" - Vario_Bogen_auf_15_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_15_Delta_SP_0")).split(",")) - Vario_Bogen_auf_15_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_15_Delta_SP_1")).split(",")) - Vario_Bogen_ab_15_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_15_Delta_SP_0")).split(",")) - Vario_Bogen_ab_15_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_15_Delta_SP_1")).split(",")) - Vario_Bogen_auf_15_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_15_Delta_VP_1")).split(",")) - Vario_Bogen_ab_15_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_15_Delta_VP_0")).split(",")) - import_block(block_Vario_Bogen_auf_15, lib_doc, doc) - import_block(block_Vario_Bogen_ab_15, lib_doc, doc) + 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)) ] + + + i = 0 + + for negativ in Vario_Bogen_auf_15_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_15_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_15_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_15_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_15_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_15_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_15_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_15_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_15_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_15_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_15_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_15_Delta_VP_0[i] = negativ + i = i + 1 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]) - ende_VP = (ende[0] +Vario_Bogen_auf_15_Delta_VP_1[1], ende[1] +Vario_Bogen_auf_15_Delta_VP_1[0],ende[2] - Vario_Bogen_auf_15_Delta_VP_1[2]) - 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 = 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] - start_VP = start[0] +Vario_Bogen_ab_15_Delta_VP_0[1],start[1]+Vario_Bogen_ab_15_Delta_VP_0[0] ,start[2]-Vario_Bogen_ab_15_Delta_VP_0[2] + 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] 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) line = Line.new(dxfattribs={"start": start, "end": ende}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - + elif winkel == 9: - block_Vario_Bogen_ab_12 = "Vario_Bogen_ab_12_°" + block_Vario_Bogen_ab_12 = "Vario_Bogen_ab_12°" block_Vario_Bogen_auf_12 = "Vario_Bogen_auf_12°" - Vario_Bogen_auf_12_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_12_Delta_SP_0_auf")).split(",")) - Vario_Bogen_auf_12_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_12_Delta_SP_1_auf")).split(",")) - Vario_Bogen_ab_12_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_12_Delta_SP_0_auf")).split(",")) - Vario_Bogen_ab_12_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_12_Delta_SP_1_auf")).split(",")) - Vario_Bogen_auf_12_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_12_Delta_VP_1_auf")).split(",")) - Vario_Bogen_ab_12_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_12_Delta_VP_0_auf")).split(",")) - import_block(block_Vario_Bogen_auf_12, lib_doc, doc) - import_block(block_Vario_Bogen_ab_12, lib_doc, doc) + 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)) ] + + + i = 0 + + for negativ in Vario_Bogen_auf_12_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_12_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_12_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_12_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_12_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_12_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_12_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_12_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_12_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_12_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_12_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_12_Delta_VP_0[i] = negativ + i = i + 1 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]) - ende_VP = (ende[0] +Vario_Bogen_auf_12_Delta_VP_1[1], ende[1] +Vario_Bogen_auf_12_Delta_VP_1[0],ende[2] - Vario_Bogen_auf_12_Delta_VP_1[2]) - 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 = 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] - start_VP = start[0] +Vario_Bogen_ab_12_Delta_VP_0[1],start[1]+Vario_Bogen_ab_12_Delta_VP_0[0] ,start[2]-Vario_Bogen_ab_12_Delta_VP_0[2] + 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] 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) - + line = Line.new(dxfattribs={"start": start, "end": ende}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_Bogen_auf_12,(x,y,0)) + # msp.add_line((x+1000,y,0),(x-1000,y,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + - elif winkel == 3: line = Line.new(dxfattribs={"start": start, "end": ende}) copy= line.copy() - + + copy.translate(-x,-y,-hoehe_vario) + block.add_entity(copy) + elif winkel == 0: + block_Vario_Bogen_auf_3 = "Vario_Bogen_auf_3°" + block_Vario_Bogen_ab_3 = "Vario_Bogen_ab_3°" + auf_3_attrib =import_block(block_Vario_Bogen_auf_3, lib_doc, doc) + ab_3_attrib = import_block(block_Vario_Bogen_ab_3, lib_doc, doc) + block_Vario_Bogen_auf_3= dreh_block(block_Vario_Bogen_auf_3, doc,math.radians(3)) + block_Vario_Bogen_ab_3 = dreh_block(block_Vario_Bogen_ab_3, doc,math.radians(0)) + Vario_Bogen_auf_3_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_3_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_3_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_VP_1"])) + Vario_Bogen_ab_3_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_VP_0"])) + + + Vario_Bogen_auf_3_Delta_SP_0 = [Vario_Bogen_auf_3_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_0[1],-Vario_Bogen_auf_3_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2] * math.cos(math.radians(3)) ] + Vario_Bogen_auf_3_Delta_SP_1 = [Vario_Bogen_auf_3_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_1[1],-Vario_Bogen_auf_3_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2] * math.cos(math.radians(3)) ] + Vario_Bogen_ab_3_Delta_SP_0 = [Vario_Bogen_ab_3_Delta_SP_0 [0] ,Vario_Bogen_ab_3_Delta_SP_0[1],Vario_Bogen_ab_3_Delta_SP_0[2] ] + Vario_Bogen_ab_3_Delta_SP_1 =[ Vario_Bogen_ab_3_Delta_SP_1 [0] ,Vario_Bogen_ab_3_Delta_SP_1[1],Vario_Bogen_ab_3_Delta_SP_1[2] ] + Vario_Bogen_auf_3_Delta_VP_1 = [Vario_Bogen_auf_3_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_VP_1[1],-Vario_Bogen_auf_3_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2] * math.cos(math.radians(3)) ] + Vario_Bogen_ab_3_Delta_VP_0 = [Vario_Bogen_ab_3_Delta_VP_0 [0],Vario_Bogen_ab_3_Delta_VP_0[1],Vario_Bogen_ab_3_Delta_VP_0[2] ] + + + i = 0 + + for negativ in Vario_Bogen_auf_3_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_3_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_3_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_3_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_3_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_3_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_3_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_3_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_3_Delta_VP_1: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_3_Delta_VP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_3_Delta_VP_0: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_3_Delta_VP_0[i] = negativ + i = i + 1 + + + # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + block.add_blockref(block_Vario_Bogen_auf_3,(ende[0] -x ,ende[1] +Vario_Bogen_auf_3_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_3_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) + + ende_VP = (ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_3_Delta_VP_1[0]+Vario_Bogen_auf_3_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_3_Delta_VP_1[2]- Vario_Bogen_auf_3_Delta_SP_0[2]) + ende = (ende[0] ,ende[1] +Vario_Bogen_auf_3_Delta_SP_1[0] + Vario_Bogen_auf_3_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_3_Delta_SP_1[2] - Vario_Bogen_auf_3_Delta_SP_0[2]) + + # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + block.add_blockref(block_Vario_Bogen_ab_3 ,(start[0]-x,start[1] - Vario_Bogen_ab_3_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_3_Delta_SP_1[2]),dxfattribs={"rotation": 90}) + start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1]-Vario_Bogen_ab_3_Delta_VP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_3_Delta_VP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] + start = start[0] ,start[1] - Vario_Bogen_ab_3_Delta_SP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0],start[2] +Vario_Bogen_ab_3_Delta_SP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] + + # 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}) + + copy= line.copy() + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) elif voerder_richtung == "Ab": - - umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" @@ -1177,98 +1698,366 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc) block_Vario_Motorstation_500mm = dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(3)) block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(3)) - 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 = (start[0] ,start[1] - umlenk_motor_offset[0],start[2] +umlenk_motor_offset[2]) + 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 = (start[0] ,start[1] - umlenk_motor_offset[0],start[2] -umlenk_motor_offset[2]) 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 = ende[0] , ende[1] + umlenk_motor_offset[0],ende[2] +umlenk_motor_offset[2] if winkel == 48: block_Vario_ab_45 = "Vario_Bogen_ab_45°" block_Vario_auf_45 = "Vario_Bogen_auf_45°" - import_block( block_Vario_ab_45 , lib_doc, doc) - import_block( block_Vario_auf_45 , lib_doc, doc) + ab_45_attrib =import_block( block_Vario_ab_45 , lib_doc, doc) + auf_45_attrib =import_block( block_Vario_auf_45 , lib_doc, doc) block_Vario_ab_45 = dreh_block( block_Vario_ab_45 , doc, math.radians(3)) block_Vario_auf_45 = dreh_block( block_Vario_auf_45 , doc, math.radians(48)) - Vario_Bogen_auf_45_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_45_Delta_SP_0")).split(",")) - Vario_Bogen_auf_45_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_45_Delta_SP_1")).split(",")) - Vario_Bogen_ab_45_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_45_Delta_SP_0")).split(",")) - Vario_Bogen_ab_45_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_45_Delta_SP_1")).split(",")) - # Vario_Bogen_auf_45_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_45_Delta_VP_1")).split(",")) - # Vario_Bogen_ab_45_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_45_Delta_VP_0")).split(",")) + 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"])) + + 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)) ] + + + i = 0 + + for negativ in Vario_Bogen_auf_45_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_45_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_45_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_45_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_45_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_45_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_45_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_45_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_45_Delta_VP_0: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_45_Delta_VP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_45_Delta_VP_1: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_45_Delta_VP_1[i] = negativ + i = i + 1 + + block.add_blockref(block_Vario_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + start_VP = start[0] -Vario_Bogen_ab_45_Delta_VP_1[1],start[1]- Vario_Bogen_ab_45_Delta_VP_1[0]- Vario_Bogen_ab_45_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_45_Delta_VP_1[2]-Vario_Bogen_ab_45_Delta_SP_0[2] + + start =(start[0], start[1]- Vario_Bogen_ab_45_Delta_SP_0[0]- Vario_Bogen_ab_45_Delta_SP_1[0],start[2]-Vario_Bogen_ab_45_Delta_SP_0[2]+Vario_Bogen_ab_45_Delta_SP_1[2]) + + + block.add_blockref(block_Vario_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + 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]) + + + 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) - block.add_blockref(block_Vario_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) - block.add_blockref(block_Vario_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_0[0],ende[2]-hoehe_vario +Vario_Bogen_auf_45_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - ende = (ende[0],ende[1]+ Vario_Bogen_auf_45_Delta_SP_0[0]+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_45_Delta_SP_0[2]+ Vario_Bogen_auf_45_Delta_SP_1[2]) line = Line.new(dxfattribs={"start":start,"end":ende }) copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + msp.add_blockref(block_Vario_ab_45,(x,y,0)) + msp.add_line((x+442.08,y-66.5,0),(x-630.21,y-66.5,0)) + msp.add_line((x,y+1000,0),(x,y-1000,0)) + elif winkel == 36: block_Vario_ab_33 = "Vario_Bogen_ab_33°" block_Vario_auf_33 = "Vario_Bogen_auf_33°" - import_block( block_Vario_ab_33 , lib_doc, doc) - import_block( block_Vario_auf_33 , lib_doc, doc) + ab_33_attrib =import_block( block_Vario_ab_33 , lib_doc, doc) + auf_33_attrib =import_block( block_Vario_auf_33 , lib_doc, doc) block_Vario_ab_33 = dreh_block( block_Vario_ab_33 , doc, math.radians(3)) block_Vario_auf_33 = dreh_block( block_Vario_auf_33 , doc, math.radians(36)) - Vario_Bogen_auf_33_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_33_Delta_SP_0")).split(",")) - Vario_Bogen_auf_33_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_33_Delta_SP_1")).split(",")) - Vario_Bogen_ab_33_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_33_Delta_SP_0")).split(",")) - Vario_Bogen_ab_33_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_33_Delta_SP_1")).split(",")) - # Vario_Bogen_auf_33_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_33_Delta_VP_1")).split(",")) - # Vario_Bogen_ab_33_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_33_Delta_VP_0")).split(",")) - + 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)) ] + + i = 0 + + for negativ in Vario_Bogen_auf_33_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_33_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_33_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_33_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_33_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_33_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_33_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_33_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_33_Delta_VP_0: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_33_Delta_VP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_33_Delta_VP_1: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_33_Delta_VP_1[i] = negativ + i = i + 1 block.add_blockref(block_Vario_ab_33, (start[0]-x,start[1]-y- Vario_Bogen_ab_33_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_33_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) - block.add_blockref(block_Vario_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_0[0],ende[2]-hoehe_vario +Vario_Bogen_auf_33_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) + 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]) + + block.add_blockref(block_Vario_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_33_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + 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]) + + 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) + + line = Line.new(dxfattribs={"start":start,"end":ende }) copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_ab_33,(x,y,0)) + # msp.add_line((x+1000,y,0),(x-630.21,y,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) elif winkel == 24: block_Vario_ab_21 = "Vario_Bogen_ab_21°" block_Vario_auf_21 = "Vario_Bogen_auf_21°" - import_block( block_Vario_ab_21 , lib_doc, doc) - import_block( block_Vario_auf_21 , lib_doc, doc) + ab_21_attrib =import_block( block_Vario_ab_21 , lib_doc, doc) + auf_21_attrib =import_block( block_Vario_auf_21 , lib_doc, doc) block_Vario_ab_21 = dreh_block( block_Vario_ab_21 , doc, math.radians(3)) block_Vario_auf_21 = dreh_block( block_Vario_auf_21 , doc, math.radians(24)) - Vario_Bogen_auf_21_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_21_Delta_SP_0")).split(",")) - Vario_Bogen_auf_21_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_21_Delta_SP_1")).split(",")) - Vario_Bogen_ab_21_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_21_Delta_SP_0")).split(",")) - Vario_Bogen_ab_21_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_21_Delta_SP_1")).split(",")) - # Vario_Bogen_auf_21_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_21_Delta_VP_1")).split(",")) - # Vario_Bogen_ab_21_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_21_Delta_VP_0")).split(",")) - - block.add_blockref(block_Vario_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) - block.add_blockref(block_Vario_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_0[0],ende[2]-hoehe_vario +Vario_Bogen_auf_21_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + 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)) ] + + i = 0 - 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]) + for negativ in Vario_Bogen_auf_21_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_21_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_21_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_21_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_21_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_21_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_21_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_21_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_21_Delta_VP_0: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_21_Delta_VP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_21_Delta_VP_1: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_21_Delta_VP_1[i] = negativ + i = i + 1 + block.add_blockref(block_Vario_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + + 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]) + + block.add_blockref(block_Vario_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_21_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + 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]) + 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) + line = Line.new(dxfattribs={"start":start,"end":ende }) copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_ab_21,(x,y,0)) elif winkel == 15: block_Vario_ab_12 = "Vario_Bogen_ab_12°" block_Vario_auf_12 = "Vario_Bogen_auf_12°" - import_block( block_Vario_ab_12 , lib_doc, doc) - import_block( block_Vario_auf_12 , lib_doc, doc) + ab_12_attrib =import_block( block_Vario_ab_12 , lib_doc, doc) + auf_12_attrib =import_block( block_Vario_auf_12 , lib_doc, doc) block_Vario_ab_12 = dreh_block( block_Vario_ab_12, doc, math.radians(3)) block_Vario_auf_12 = dreh_block( block_Vario_auf_12 , doc, math.radians(15)) - Vario_Bogen_auf_12_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_12_Delta_SP_0_ab")).split(",")) - Vario_Bogen_auf_12_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_12_Delta_SP_1_ab")).split(",")) - Vario_Bogen_ab_12_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_12_Delta_SP_0_ab")).split(",")) - Vario_Bogen_ab_12_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_12_Delta_SP_1_ab")).split(",")) - Vario_Bogen_auf_12_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_12_Delta_VP_1_ab")).split(",")) - Vario_Bogen_ab_12_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_12_Delta_VP_0_ab")).split(",")) - - block.add_blockref(block_Vario_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) - block.add_blockref(block_Vario_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_0[0],ende[2]-hoehe_vario +Vario_Bogen_auf_12_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + 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)) ] + + i = 0 - 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]) + for negativ in Vario_Bogen_auf_12_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_12_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_12_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_12_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_12_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_12_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_12_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_12_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_12_Delta_VP_0: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_12_Delta_VP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_12_Delta_VP_1: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_12_Delta_VP_1[i] = negativ + i = i + 1 + block.add_blockref(block_Vario_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + 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]) + + block.add_blockref(block_Vario_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + + 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]) + 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) + line = Line.new(dxfattribs={"start":start,"end":ende }) copy = line.copy() copy.translate(-x,-y,-hoehe_vario) @@ -1277,56 +2066,191 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 12: block_Vario_ab_9 = "Vario_Bogen_ab_9°" block_Vario_auf_9 = "Vario_Bogen_auf_9°" - import_block( block_Vario_ab_9 , lib_doc, doc) - import_block( block_Vario_auf_9 , lib_doc, doc) + ab_9_attrib =import_block( block_Vario_ab_9 , lib_doc, doc) + auf_9_attrib =import_block( block_Vario_auf_9 , lib_doc, doc) block_Vario_ab_9 = dreh_block( block_Vario_ab_9, doc, math.radians(3)) block_Vario_auf_9 = dreh_block( block_Vario_auf_9 , doc, math.radians(12)) - Vario_Bogen_auf_9_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_9_Delta_SP_0")).split(",")) - Vario_Bogen_auf_9_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_9_Delta_SP_1")).split(",")) - Vario_Bogen_ab_9_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_9_Delta_SP_0")).split(",")) - Vario_Bogen_ab_9_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_9_Delta_SP_1")).split(",")) - Vario_Bogen_auf_9_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_9_Delta_VP_1")).split(",")) - Vario_Bogen_ab_9_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_9_Delta_VP_0")).split(",")) + 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"])) - block.add_blockref(block_Vario_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) - block.add_blockref(block_Vario_auf_9, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_0[0],ende[2]-hoehe_vario +Vario_Bogen_auf_9_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + 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)) ] + + i = 0 - 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]) + for negativ in Vario_Bogen_auf_9_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_9_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_9_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_9_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_9_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_9_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_9_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_9_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_9_Delta_VP_0: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_9_Delta_VP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_9_Delta_VP_1: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_9_Delta_VP_1[i] = negativ + i = i + 1 + block.add_blockref(block_Vario_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + + 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]) + + block.add_blockref(block_Vario_auf_9, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + 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]) + 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) line = Line.new(dxfattribs={"start":start,"end":ende }) copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_auf_9,(x,y,0)) + # msp.add_line((x+1000,y -66.5,45),(x-150.23,y -66.5, 45)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + + elif winkel == 9: block_Vario_ab_6 = "Vario_Bogen_ab_6°" block_Vario_auf_6 = "Vario_Bogen_auf_6°" - import_block( block_Vario_ab_6 , lib_doc, doc) - import_block( block_Vario_auf_6 , lib_doc, doc) + ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc) + auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc) block_Vario_ab_6 = dreh_block( block_Vario_ab_6, doc, math.radians(3)) block_Vario_auf_6 = dreh_block( block_Vario_auf_6 , doc, math.radians(9)) - Vario_Bogen_auf_6_Delta_SP_0 = tuple(float(x)for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_6_Delta_SP_0")).split(",")) - Vario_Bogen_auf_6_Delta_SP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_6_Delta_SP_1")).split(",")) - Vario_Bogen_ab_6_Delta_SP_0 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_6_Delta_SP_0")).split(",")) - Vario_Bogen_ab_6_Delta_SP_1 = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_6_Delta_SP_1")).split(",")) - Vario_Bogen_auf_6_Delta_VP_1 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_auf_6_Delta_VP_1")).split(",")) - Vario_Bogen_ab_6_Delta_VP_0 = tuple(float(x) for x in (config.get("ILS 2.0 Variofoerderer","Vario_Bogen_ab_6_Delta_VP_0")).split(",")) - - block.add_blockref(block_Vario_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - 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]) - block.add_blockref(block_Vario_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_0[0],ende[2]-hoehe_vario +Vario_Bogen_auf_6_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + 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)) ] + + i = 0 - 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]) + for negativ in Vario_Bogen_auf_6_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_auf_6_Delta_SP_0[i] = negativ + i = i + 1 + + i = 0 + for negativ in Vario_Bogen_auf_6_Delta_SP_1: + if i< 2: + if negativ< 0: + negativ= negativ*-1 + Vario_Bogen_auf_6_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_6_Delta_SP_0: + if i< 2: + if negativ< 0: + negativ = negativ*-1 + Vario_Bogen_ab_6_Delta_SP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_6_Delta_SP_1: + if i< 2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_ab_6_Delta_SP_1[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_auf_6_Delta_VP_0: + if i<2: + if negativ < 0: + negativ = negativ*-1 + Vario_Bogen_auf_6_Delta_VP_0[i] = negativ + i = i + 1 + i = 0 + for negativ in Vario_Bogen_ab_6_Delta_VP_1: + if i <2: + if negativ < 0: + negativ = negativ*-1 + + Vario_Bogen_ab_6_Delta_VP_1[i] = negativ + i = i + 1 + block.add_blockref(block_Vario_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + 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]) + block.add_blockref(block_Vario_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_6_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + 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]) + 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) + line = Line.new(dxfattribs={"start":start,"end":ende }) copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # msp.add_blockref(block_Vario_auf_6,(x,y,0)) + # msp.add_line((x+500,y,45),(x-500,y,45)) + # msp.add_line((x,y+500,0),(x,y-500,0)) + elif winkel == 3: line = Line.new(dxfattribs={"start": start, "end": ende}) copy= line.copy() - + copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + matrix = Matrix44.scale(-1,1,1) block_links = doc.blocks.new(block_name_links, base_point=(0,0,0)) for entity in block: @@ -1359,11 +2283,11 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, winkel = float(merkmale.get("Drehung")) except Exception: winkel = 0.0 - + winkel_rad = math.radians(winkel) halbe_laenge = laenge / 2 # Man muss bei sin -1 machen wegen des links koordinaten system - dx = halbe_laenge * math.sin(winkel_rad * -1) + dx = halbe_laenge * math.sin(winkel_rad * -1) dy = halbe_laenge * math.cos(winkel_rad) start = (x + dx, y + dy, float(merkmale.get("Höhe oben")) ) ende = (x - dx, y - dy, float(merkmale.get("Höhe unten"))) @@ -1389,16 +2313,16 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, return import_block(blockname, lib_doc, doc) blockref_layer = get_layer(doc, lib_doc, blockname) - drehung = merkmale.get("Drehung") - + drehung = merkmale.get("Drehung") + bref = msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"xscale": 1.0, "yscale":1.0,"rotation": drehung, "layer": blockref_layer}) - + a =bref.add_attrib( tag= "NAME", text= merkmale.get("bezeichner"), insert = (x,y) - - + + ) a.is_invisible = True bref.add_auto_attribs({ATTR_TAG: teileid}) @@ -1408,16 +2332,16 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, def erstellung_gefaelle_block_verbunenden_am_einen(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): - - halbe_laenge = laenge / 2 + + halbe_laenge = laenge / 2 dy = halbe_laenge * math.cos(0) - + if ((blockname not in doc.blocks and 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") ): if hight != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) block_as = "200000241_AS-Element_90_rechts" import_block(block_as,lib_doc,doc) - + if vario_richtung == "Auf": start = (x , y + dy ,upper_hoehe_gefaehlle) ende = (x , y - dy + asoffset ,lower_hoehe_gefaehlle) @@ -1439,24 +2363,24 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, 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_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) elif ((blockname not in doc.blocks and 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")): block_es = "200000146_ES-Element_90_rechts" import_block(block_es,lib_doc,doc) if hight != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - + if vario_richtung == "Auf": 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}) return start, ende - elif vario_richtung == "Ab": + 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)) @@ -1464,28 +2388,28 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, elif vario_richtung =="Horizontal": # TODO return start, ende - + start = (x , y + dy,upper_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)) elif ((blockname not in doc.blocks and 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")): block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) if hight != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - + if vario_richtung == "Auf": start = (x , y + dy ,upper_hoehe_gefaehlle) ende = (x , y - dy + asoffset,lower_hoehe_gefaehlle) @@ -1507,7 +2431,7 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, 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) @@ -1535,38 +2459,38 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, start = (x , y + dy ,upper_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),dxfattribs={"rotation": 180}) 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): - #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 + #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 if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: middle_hoehe = upper_hoehe_gefaehlle upper_hoehe_gefaehlle = lower_hoehe_gefaehlle lower_hoehe_gefaehlle = middle_hoehe - + if richtung2!= "DEFAULT" or am_kreisel != None: - if ((blockname not in doc.blocks and drehung0 == "GUZS" and drehung1 == "GUZS" and hight_position == "higher") or + if ((blockname not in doc.blocks and drehung0 == "GUZS" and drehung1 == "GUZS" and hight_position == "higher") or (voerder_richtung == "Auf" and((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel== 2 and erster_kreisel_höher == True)) and drehung0 == "GUZS" and drehung1== "GUZS") or (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) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y+ dy - esoffset,upper_hoehe_gefaehlle) @@ -1583,20 +2507,20 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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)) 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: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 + halbe_laenge = laenge / 2 block_as = "200000241_AS-Element_90_rechts" import_block(block_as,lib_doc,doc) - + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y1 ,z1) @@ -1608,7 +2532,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh ende = (x , y1 ,z1) block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) return start, ende - + start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) @@ -1616,11 +2540,11 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) elif ((blockname not in doc.blocks and (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "higher"))or (voerder_richtung == "Auf" and((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True))and (drehung0 == "UZS" and drehung1 == "GUZS")) or @@ -1630,8 +2554,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh import_block(block_es,lib_doc,doc) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) @@ -1649,7 +2573,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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) @@ -1657,14 +2581,14 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh block.add_blockref(block_es,(ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle), dxfattribs={"rotation": 180}) elif (blockname not in doc.blocks and (drehung0 == "UZS" and drehung1 == "GUZS" and hight_position == "lower")or (voerder_richtung == "Auf" and((am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False))and (drehung0 == "UZS" and drehung1 == "GUZS")) or - (voerder_richtung == "Ab"and ((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True))and (drehung0 == "GUZS" and drehung1 == "UZS"))): + (voerder_richtung == "Ab"and ((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True))and (drehung0 == "GUZS" and drehung1 == "UZS"))): block_as = "200000241_AS-Element_90_rechts" import_block(block_as,lib_doc,doc) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y1,z1) @@ -1683,7 +2607,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line.dxf.layer = "6-SP" copy= line.copy() - + copy.translate(-x,-y,-hoehe_gefaehlle) block.add_entity(copy) @@ -1693,12 +2617,12 @@ 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 == "UZS" and drehung1== "UZS")): if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 + halbe_laenge = laenge / 2 block_es = "400102632_ES-Element_90_links" import_block(block_es,lib_doc,doc) dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": - + 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)) @@ -1715,23 +2639,23 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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),dxfattribs={"rotation": 180}) - - elif (((blockname not in doc.blocks and drehung0 == "UZS" and drehung1 == "UZS")or + + elif (((blockname not in doc.blocks and drehung0 == "UZS" and drehung1 == "UZS")or (am_kreisel!= None and drehung0 == "UZS" and drehung1 == "UZS"))): block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y1,z1) @@ -1750,7 +2674,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line.dxf.layer = "6-SP" copy= line.copy() - + copy.translate(-x ,-y,-hoehe_gefaehlle) block.add_entity(copy) @@ -1765,8 +2689,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh import_block(block_es,lib_doc,doc) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) @@ -1774,35 +2698,35 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start, ende elif voerder_richtung == "Ab": - + start = (x , y1,z1) 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 - + start = (x , y + dy,upper_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)) elif (blockname not in doc.blocks and (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "lower")or (voerder_richtung == "Auf"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 == "UZS")) or - (voerder_richtung == "Ab" and((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True))and (drehung0 == "UZS" and drehung1 == "GUZS"))): + (voerder_richtung == "Ab" and((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True))and (drehung0 == "UZS" and drehung1 == "GUZS"))): block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y1,z1) @@ -1819,15 +2743,15 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh ende = (x , y - dy ,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_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) - #erstellung von den normalen gefällestrecken + #erstellung von den normalen gefällestrecken else: if ((blockname not in doc.blocks and drehung0 == "GUZS" and drehung1 == "GUZS") or (voerder_richtung != None and drehung0 == "GUZS" and drehung1 == "GUZS")): block_as = "200000241_AS-Element_90_rechts" @@ -1836,8 +2760,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh import_block(block_es,lib_doc,doc) if hight_position != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) @@ -1856,9 +2780,9 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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_as = "200000241_AS-Element_90_rechts" @@ -1868,7 +2792,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[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 == "UZS" and hight_position == "higher")or (drehung0 == "UZS" and drehung1 == "GUZS" and hight_position == "lower")) or + elif (blockname not in doc.blocks and((drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "higher")or (drehung0 == "UZS" and drehung1 == "GUZS" and hight_position == "lower")) or (voerder_richtung == "Auf" and drehung0 == "UZS"and drehung1 == "GUZS") or (voerder_richtung == "Ab" and drehung0 == "GUZS" and drehung1 == "UZS")) : block_as = "200000241_AS-Element_90_rechts" @@ -1877,8 +2801,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh import_block(block_es,lib_doc,doc) if hight_position != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) @@ -1896,9 +2820,9 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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) @@ -1913,8 +2837,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh import_block(block_es,lib_doc,doc) if hight_position !=None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) @@ -1925,7 +2849,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh elif voerder_richtung == "Ab": start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) - block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) + block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle) ,dxfattribs={"rotation": 180}) return start, ende @@ -1933,43 +2857,43 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) - + block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle) ,dxfattribs={"rotation": 180}) - + elif ((blockname not in doc.blocks and ((drehung0 == "UZS" and drehung1 == "GUZS" and hight_position== "higher")or (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "lower")))or (voerder_richtung == "Auf" and drehung0 == "GUZS" and drehung1 == "UZS") or (voerder_richtung == "Ab" and drehung0 == "UZS"and drehung1 == "GUZS")) : - - + + block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) block_es = "200000146_ES-Element_90_rechts" import_block(block_es,lib_doc,doc) if hight_position != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - halbe_laenge = laenge / 2 - + halbe_laenge = laenge / 2 + dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) ende = (x , y - dy + asoffset,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_as, (ende[0]-x ,ende[1]-asoffset -y,ende[2] - hoehe_gefaehlle)) return start,ende elif voerder_richtung == "Ab": start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) - + block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle)) return start,ende @@ -1977,16 +2901,16 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh 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_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) - + block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle)) def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, x1_kreisel, y1_kreisel, richtung_rad1, abstand1,kreisel_verbunden= None, richtung0 = None, richtung1 = None, richtung2 = None): if kreisel_verbunden == None: @@ -2008,14 +2932,14 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl pos1_1_floor = (math.floor(x1_kreisel - dx1), math.floor(y1_kreisel - dy1)) pos1_0_round = (round(x1_kreisel + dx1), round(y1_kreisel + dy1)) pos1_1_round = (round(x1_kreisel - dx1), round(y1_kreisel - dy1)) - + # berechnung der geraden einmal abgerunden und einmal gerunden zur negirung des offsets start_floor = (math.floor(x +dx ), math.floor(y + dy ),upper_hoehe_gefaehlle) ende_floor = (math.floor(x -dx), math.floor(y - dy ) ,lower_hoehe_gefaehlle) start_round = (round(x +dx ), round(y + dy ),upper_hoehe_gefaehlle) ende_round= (round(x -dx), round(y - dy ) ,lower_hoehe_gefaehlle) - # verschiebund der endpunkte der gerade in richtung von dem potentiellen Kreisel für den vergleich wieder mit floor und rundung + # verschiebund der endpunkte der gerade in richtung von dem potentiellen Kreisel für den vergleich wieder mit floor und rundung abstand_fuer_kreis_start_x_floor = start_floor[0] +RADIUS, start_floor[1] abstand_gegen_kreis_start_x_floor = start_floor[0] -RADIUS, start_floor[1] abstand_fuer_kreis_start_y_floor = start_floor[0], start_floor[1] + RADIUS @@ -2046,15 +2970,15 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_gegen_kreis_ende_y_floor == pos0_1_floor) or (abstand_fuer_kreis_start_y_round == pos0_0_round)or (abstand_fuer_kreis_start_y_round == pos0_1_round) or - (abstand_gegen_kreis_start_y_round == pos0_0_round) or + (abstand_gegen_kreis_start_y_round == pos0_0_round) or (abstand_gegen_kreis_start_y_round == pos0_1_round) or (abstand_fuer_kreis_ende_y_round == pos0_0_round) or (abstand_fuer_kreis_ende_y_round == pos0_1_round) or (abstand_gegen_kreis_ende_y_round == pos0_0_round) or (abstand_gegen_kreis_ende_y_round == pos0_1_round) or - - + + (abstand_fuer_kreis_start_y_floor == pos1_0_floor) or (abstand_fuer_kreis_start_y_floor == pos1_1_floor) or (abstand_gegen_kreis_start_y_floor == pos1_0_floor) or @@ -2063,7 +2987,7 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_fuer_kreis_ende_y_floor == pos1_1_floor) or (abstand_gegen_kreis_ende_y_floor == pos1_0_floor) or (abstand_gegen_kreis_ende_y_floor == pos1_1_floor) or - + (abstand_fuer_kreis_start_y_round == pos1_0_round) or (abstand_fuer_kreis_start_y_round == pos1_1_round) or (abstand_gegen_kreis_start_y_round == pos1_0_round) or @@ -2071,13 +2995,13 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_fuer_kreis_ende_y_round == pos1_0_round) or (abstand_fuer_kreis_ende_y_round == pos1_1_round) or (abstand_gegen_kreis_ende_y_round == pos1_0_round) or - (abstand_gegen_kreis_ende_y_round == pos1_1_round) + (abstand_gegen_kreis_ende_y_round == pos1_1_round) ): richtung2= "Vertikal" unterschiedlich = True - + else: - richtung2 = "Horinzontal" + richtung2 = "Horinzontal" unterschiedlich = True return richtung2, unterschiedlich return richtung2, unterschiedlich @@ -2114,7 +3038,7 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_fuer_kreis_ende_y_round == pos0_0_round) or (abstand_fuer_kreis_ende_y_round == pos0_1_round) or (abstand_gegen_kreis_ende_y_round == pos0_0_round) or - (abstand_gegen_kreis_ende_y_round == pos0_1_round) + (abstand_gegen_kreis_ende_y_round == pos0_1_round) ): kreisel_verbunden = kreisel_verbunden +1 # setzung auf kreisel 1 für spätere ausrechnung der geraden form @@ -2155,7 +3079,7 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_fuer_kreis_ende_y_round == pos1_0_round) or (abstand_fuer_kreis_ende_y_round == pos1_1_round) or (abstand_gegen_kreis_ende_y_round == pos1_0_round) or - (abstand_gegen_kreis_ende_y_round == pos1_1_round) + (abstand_gegen_kreis_ende_y_round == pos1_1_round) ): kreisel_verbunden = kreisel_verbunden +1 am_kreisel = 2 @@ -2218,7 +3142,7 @@ def get_libfile_cfg(teileart, cfg_path): def get_rotations_of_strecken(csv_path:Path) -> dict: - geraden = [] + geraden = [] kreisel =[] strecken_nachbarn = [] anweisungen = 0 @@ -2230,7 +3154,7 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: if bezeichner == "ILS 2.0 Gefällestrecke" or bezeichner =="ILS 2.0 VarioFoerderer": Id = row["TeileId"].strip() NachbarIds = row["NachbarIds"].strip() - + geraden.append({"Id": Id, "NachbarIds": NachbarIds}) if bezeichner == "ILS 2.0 Kreisel": Id = row["TeileId"].strip() @@ -2244,8 +3168,8 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: "Abstand (Kreiselachse A - Kreiselachse) in Meter", "20" ).replace(",", ".") kreisel.append({"Id":Id, "drehung":drehung, "höhe":hight,"x": x, "y": y, "rotation": rotation,"abstand":abstand_m}) - - + + for gerade in geraden: anweisungen = 0 eintrag = {"Id": gerade["Id"]} @@ -2268,7 +3192,7 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: eintrag["abstand1"] = kreis.get("abstand") break strecken_nachbarn.append(eintrag) - + return strecken_nachbarn