From 2dce965a934899db75447d5eb892052ea36e9eee Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 10 Nov 2025 10:10:27 +0100 Subject: [PATCH] =?UTF-8?q?Kommentare=20Hinzugef=C3=BCgt=20f=C3=BCr=20den?= =?UTF-8?q?=20f=C3=B6rderer?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/plant2dxf.py | 1405 ++++++++++++++++++++++------------------------ 1 file changed, 657 insertions(+), 748 deletions(-) diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index afa6efb..2d694fd 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -93,6 +93,7 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: src = from_doc.blocks[block_name] att_def = {} if ((block_name in to_doc.blocks)): + # speichern der attdef elemente in eine Liste falks diese verhanden sind und gibt diese zurück for ent in src: copy = ent.copy() @@ -138,7 +139,7 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: except Exception: pass - + # kopiert die elemente von dem element aus dem block und speichert diese in den block für dass Modelspace auf und # speichern der attdef elemente in eine Liste falks diese verhanden sind und gibt diese zurück for ent in src: copy = ent.copy() @@ -152,11 +153,8 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: return att_def def dreh_block(block_name: str, to_doc, winkel) : - """Importiert Blockdefinition block_name von from_doc nach to_doc. - - - Kopiert alle Entities des Blocks - - Stellt sicher, dass benutzte Layer im Ziel existieren (mit Eigenschaften) - - Übernimmt Basis­punkt und Block-Layer, falls vorhanden + """Nimmt ein schon importierten Block und erstellt einen neuen der an der y_axis gedreht wird + hauptsächlich für vario Bogen aktuell verwendet """ dreh_block_name = block_name +f"_{math.degrees(winkel)}" @@ -205,7 +203,7 @@ def berechne_hoehe(csv_path, logger=None): def transform_coords(x: float, y: float, height: float) -> tuple[float, float]: """Transformiert Bildschirmkoordinaten (0,0 oben links) ins DXF-KoSy (0,0 unten links).""" - return x, y + return x, y -height def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config): abstand_m = merkmale.get( @@ -445,6 +443,7 @@ 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 + rotation = float(merkmale.get("Drehung")) @@ -615,7 +614,7 @@ def add_attributes_to_block(block, attributes): attributes – Liste von Tupeln [(tag, value), ...] """ for tag, value in attributes.items(): - test = 3 + tag = tag value = value a =block.add_attrib( @@ -625,7 +624,14 @@ def add_attributes_to_block(block, attributes): a.is_invisible = True def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config): - + # für spätere Namens benenung der Vario forderer + motor_vorhanden = merkmale.get("Motor") + umlenk_vorhanden = merkmale.get("Umlenk") + + gefahellewinkel =float(merkmale.get("Gefahellewinkel")) + + gefaelle = float(merkmale.get("Gefällestrecke")) + # Offsets für die Vario Linie für ab 3 bogen, da es in diesem Fall keine bögen hat die sich mit den nachbarn Bögen für andere Vario Förderer verbinden kann winkel_VP_offset_vorne = None winkel_VP_offset_hinten = None # erstellung des Layers falls nicht vorhanden @@ -666,9 +672,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve break laenge = float(merkmale.get("Länge in Meter")) *1000 +# Ausrechnung der nötigen Offset falls der Vario Förderer ab mit drei grad mit einem anderen Verbunden ist if gefaellestrecke_vario.get("Winkel") != None and winkel == 3 and voerder_richtung == "Ab": + # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung if float(gefaellestrecke_vario.get("h0")) == lower_hoehe_vario: if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): + # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) @@ -676,9 +685,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve att_vorne =import_block(blockname,lib_doc,doc) SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) + # Ausrechnen des Offsets winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(-winkel_vorne)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(-winkel_vorne)) else: + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) @@ -686,11 +698,14 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve att_vorne =import_block(blockname,lib_doc,doc) SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"])) VP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"])) + # Ausrechnung des Offsets winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) elif float(gefaellestrecke_vario.get("h1")) == upper_hoehe_vario: if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): + # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) @@ -698,9 +713,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve att_hinten =import_block(blockname,lib_doc,doc) SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_0"])) VP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_0"])) + # Ausrechnung des Offsets winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(3)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(3)) else: + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) @@ -708,13 +726,18 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve att_hinten =import_block(blockname,lib_doc,doc) SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"])) VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) + # Ausrechnung des Offsets winkel_VP_offset_hinten = (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten)), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) - + # Das gleiche falls der 3 grad Förderer mit zwei Förderer Verbunden ist if (gefaellestrecke_vario.get("Winkel_2") != None): + # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung + if float(gefaellestrecke_vario.get("h0_2")) == lower_hoehe_vario: if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) @@ -722,9 +745,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve att_vorne =import_block(blockname,lib_doc,doc) SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) + # Ausrechnung des Offsets winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(-winkel_vorne)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(-winkel_vorne)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(-winkel_vorne)) else: + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel_2")) -3 winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) @@ -732,30 +758,33 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve att_vorne =import_block(blockname,lib_doc,doc) SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"])) VP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"])) + # Ausrechnung des Offsets winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) elif float(gefaellestrecke_vario.get("h1_2")) == upper_hoehe_vario: if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 - - blockname = (f"Vario_Bogen_auf_{winkel_hinten_plusbogen}°") att_hinten =import_block(blockname,lib_doc,doc) SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_0"])) VP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_0"])) + # Ausrechnung des Offsets winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(3)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(3)) else: + # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte + winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 winkel_hinten = int(gefaellestrecke_vario.get("Winkel_2")) - - blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°") att_hinten =import_block(blockname,lib_doc,doc) SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"])) VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) + # Ausrechnung des Offsets winkel_VP_offset_hinten = ((SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten))), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) @@ -782,8 +811,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}_True_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_True_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": @@ -847,8 +876,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Abschnitt falls der Vario nur mit einem Kreisel verbunden ist und nicht an dem Kreisel direkt verbunden ist # Erstellung der blockname für wenn die Motorstation rechts und links - blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}") - block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{drehung0}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{drehung0}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": @@ -905,8 +934,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # 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}") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{drehung0}_{drehung1}_{kreisel_verbunden}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{drehung0}_{drehung1}_{kreisel_verbunden}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": @@ -974,8 +1003,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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}") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{am_kreisel}_{erster_kreisel_höher}_{drehung0}_{drehung1}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{am_kreisel}_{erster_kreisel_höher}_{drehung0}_{drehung1}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: @@ -1049,8 +1078,8 @@ 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}") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{drehung0}_{drehung1}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + block_name_links = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{drehung0}_{drehung1}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: @@ -1079,8 +1108,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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") + blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") + block_name_links =(f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") # Falls der Block bereits in dem doc ist platziere diesen einfach if blockname in doc.blocks: if merkmale.get("Motorseite")== "links": @@ -1114,62 +1143,65 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ): + # Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss motor_vorhanden = merkmale.get("Motor") umlenk_vorhanden = merkmale.get("Umlenk") - # Falls auf der Vario Förderer auf ist + + gefahellewinkel =float(merkmale.get("Gefahellewinkel")) + gefaelle = float(merkmale.get("Gefällestrecke")) + # Aktueller offset des motors und Umlenkungstation, wird wahrscheinlich später einfach berechnet (sobald man entschieden hat ob wir nur 3 grad neigung erlauben oder nicht) umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) - # gefahellewinkel =float(merkmale.get("Gefahellewinkel")) - - # gefaelle = float(merkmale.get("Gefällestrecke")) - # if motor_vorhanden == "True": - # gefaelle = gefaelle - umlenk_motor_offset[0] - # if umlenk_vorhanden == "True": - # gefaelle = gefaelle - umlenk_motor_offset[0] - + # Berechnung des Gefälles + if motor_vorhanden == "True": + gefaelle = gefaelle - umlenk_motor_offset[0] + if umlenk_vorhanden == "True": + gefaelle = gefaelle - umlenk_motor_offset[0] + #Erstellung des Förderes falls er auf ist oder Horizontal da diese gleich aufgebaut werden if voerder_richtung== "Auf" or voerder_richtung== "Horizontal": - - # if gefaelle > 0: - # halbesgefaelle = gefaelle/2 - # if motor_vorhanden == "True" and umlenk_vorhanden == "True": - # halbesgefaelle = gefaelle/2 - # gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* halbesgefaelle - # line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) - # line_ende_gefaelle.dxf.layer = "6-SP" - # copy_ende = line_ende_gefaelle.copy() - # copy_ende.translate(-x,-y,-hoehe_vario) - # block.add_entity(copy_ende) - # ende = gefaelle_ende + # erstellung des gefälles falls es nicht null ist (also keins angegeben ist oder es durch andere Sachen wie Motor ersetzt wird) + if gefaelle > 0: + # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird + halbesgefaelle = gefaelle/2 + if motor_vorhanden == "True" and umlenk_vorhanden == "True": + halbesgefaelle = gefaelle/2 + gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* halbesgefaelle + line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) + line_ende_gefaelle.dxf.layer = "6-SP" + copy_ende = line_ende_gefaelle.copy() + copy_ende.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_ende) + ende = gefaelle_ende - # gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * halbesgefaelle - # line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) - # line_start_gefaelle.dxf.layer = "6-SP" - # copy_start = line_start_gefaelle.copy() - # copy_start.translate(-x,-y,-hoehe_vario) - # block.add_entity(copy_start) - # start = gefaelle_start + gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * halbesgefaelle + line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) + line_start_gefaelle.dxf.layer = "6-SP" + copy_start = line_start_gefaelle.copy() + copy_start.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_start) + start = gefaelle_start - # elif motor_vorhanden== "True": - # gefaelle_start = start[0], start[1] -gefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * gefaelle - # line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) - # line_start_gefaelle.dxf.layer = "6-SP" - # copy_start = line_start_gefaelle.copy() - # copy_start.translate(-x,-y,-hoehe_vario) - # block.add_entity(copy_start) - # start = gefaelle_start + elif motor_vorhanden== "True": + gefaelle_start = start[0], start[1] -gefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * gefaelle + line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) + line_start_gefaelle.dxf.layer = "6-SP" + copy_start = line_start_gefaelle.copy() + copy_start.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_start) + start = gefaelle_start - # elif umlenk_vorhanden== "True": - # gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* gefaelle - # line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) - # line_ende_gefaelle.dxf.layer = "6-SP" - # copy_ende = line_ende_gefaelle.copy() - # copy_ende.translate(-x,-y,-hoehe_vario) - # block.add_entity(copy_ende) - # ende = gefaelle_ende + elif umlenk_vorhanden== "True": + gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* gefaelle + line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) + line_ende_gefaelle.dxf.layer = "6-SP" + copy_ende = line_ende_gefaelle.copy() + copy_ende.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_ende) + ende = gefaelle_ende - # Den Motorstaton und Umlenkstation auf die richtige position in block einfügen + # Den Motorstaton und Umlenkstation auf die richtige position in block einfügen falls nötig block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block(block_Vario_Motorstation_500mm, lib_doc, doc) @@ -1184,7 +1216,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_51 = "Vario_Bogen_auf_51°" block_Vario_Bogen_ab_51 = "Vario_Bogen_ab_51°" @@ -1207,56 +1239,37 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + for i, wert in enumerate(Vario_Bogen_auf_51_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_51_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_51_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_51_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_51_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_51_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_51_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_51_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_51_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_51_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_51_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_51_Delta_VP_0[i] = abs(wert) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_51,(ende[0] -x ,ende[1] +Vario_Bogen_auf_51_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_51_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_51_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_51_Delta_VP_1[0]+Vario_Bogen_auf_51_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_51_Delta_VP_1[2]- Vario_Bogen_auf_51_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_51_Delta_SP_1[0] + Vario_Bogen_auf_51_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_51_Delta_SP_1[2] - Vario_Bogen_auf_51_Delta_SP_0[2]) - # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_51 ,(start[0]-x,start[1] - Vario_Bogen_ab_51_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_51_Delta_SP_1[2]),dxfattribs={"rotation": 90}) 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] @@ -1277,6 +1290,9 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_ab_51,(x,y,0)) # msp.add_line((x+1000,y + 50,0),(x-1000,y +50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -1285,7 +1301,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 36: - # Einfügen der 39 Bogen und deren notwendigen Werten von dem config nehmen + # Einfügen der 39 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_39 = "Vario_Bogen_auf_39°" block_Vario_Bogen_ab_39 = "Vario_Bogen_ab_39°" auf_39_attrib =import_block(block_Vario_Bogen_auf_39, lib_doc, doc) @@ -1307,60 +1323,41 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + for i, wert in enumerate(Vario_Bogen_auf_39_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_39_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_39_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_39_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_39_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_39_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_39_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_39_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_39_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_39_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_39_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_39_Delta_VP_0[i] = abs(wert) + + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_39,(ende[0] -x ,ende[1] +Vario_Bogen_auf_39_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_39_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_39_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_39_Delta_VP_1[0]+Vario_Bogen_auf_39_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_39_Delta_VP_1[2]- Vario_Bogen_auf_39_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_39_Delta_SP_1[0] + Vario_Bogen_auf_39_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_39_Delta_SP_1[2] -Vario_Bogen_auf_39_Delta_SP_0[2]) - # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_39 ,(start[0]-x,start[1] - Vario_Bogen_ab_39_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_39_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_39_Delta_VP_0[1],start[1]-Vario_Bogen_ab_39_Delta_VP_0[0] - Vario_Bogen_ab_39_Delta_SP_1[0] ,start[2]+ Vario_Bogen_ab_39_Delta_VP_0[2] - Vario_Bogen_ab_39_Delta_SP_1[2] @@ -1370,7 +1367,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 @@ -1381,6 +1377,10 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_ab_39,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -1389,7 +1389,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 24: - # Einfügen der 27 Bogen und deren notwendigen Werten von dem config nehmen + # Einfügen der 27 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_27 = "Vario_Bogen_auf_27°" block_Vario_Bogen_ab_27 = "Vario_Bogen_ab_27°" auf_27_attrib =import_block(block_Vario_Bogen_auf_27, lib_doc, doc) @@ -1411,61 +1411,42 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_27_Delta_VP_0[i] = abs(wert) - # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_27,(ende[0] -x ,ende[1] +Vario_Bogen_auf_27_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_27_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_27_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_27_Delta_VP_1[0]+Vario_Bogen_auf_27_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_27_Delta_VP_1[2]- Vario_Bogen_auf_27_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_27_Delta_SP_1[0] + Vario_Bogen_auf_27_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_27_Delta_SP_1[2] - Vario_Bogen_auf_27_Delta_SP_0[2]) - # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_27 ,(start[0]-x,start[1] - Vario_Bogen_ab_27_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_27_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_27_Delta_VP_0[1],start[1]-Vario_Bogen_ab_27_Delta_VP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_27_Delta_VP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2] start = start[0] ,start[1] - Vario_Bogen_ab_27_Delta_SP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0],start[2] +Vario_Bogen_ab_27_Delta_SP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2] @@ -1486,6 +1467,9 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -1494,7 +1478,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 15: - # Einfügen der 18 Bogen und deren notwendigen Werten von dem config nehmen + # Einfügen der 18 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_ab_18 = "Vario_Bogen_ab_18°" block_Vario_Bogen_auf_18 = "Vario_Bogen_auf_18°" auf_18_attrib =import_block(block_Vario_Bogen_auf_18, lib_doc, doc) @@ -1515,60 +1499,39 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + for i, wert in enumerate(Vario_Bogen_auf_18_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_18_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_18_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_18_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_18_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_18_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_18_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_18_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_18_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_18_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_18_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_18_Delta_VP_0[i] = abs(wert) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_18,(ende[0] -x ,ende[1] +Vario_Bogen_auf_18_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_18_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_18_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_18_Delta_VP_1[0]+Vario_Bogen_auf_18_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_18_Delta_VP_1[2]- Vario_Bogen_auf_18_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_18_Delta_SP_1[0] + Vario_Bogen_auf_18_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_18_Delta_SP_1[2] - Vario_Bogen_auf_18_Delta_SP_0[2]) - # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_18 ,(start[0]-x,start[1] - Vario_Bogen_ab_18_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_18_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_18_Delta_VP_0[1],start[1]-Vario_Bogen_ab_18_Delta_VP_0[0] - Vario_Bogen_ab_18_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_18_Delta_VP_0[2] - Vario_Bogen_ab_18_Delta_SP_1[2] @@ -1590,6 +1553,9 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_ab_18,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -1598,6 +1564,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 12: + # Einfügen der 15 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_Bogen_ab_15 = "Vario_Bogen_ab_15°" block_Vario_Bogen_auf_15 = "Vario_Bogen_auf_15°" auf_15_attrib =import_block(block_Vario_Bogen_auf_15, lib_doc, doc) @@ -1619,65 +1587,52 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_15_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_15_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_15_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_15_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_15_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_15_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_15_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_15_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_15_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_15_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_15_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_15_Delta_VP_0[i] = abs(wert) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_15,(ende[0] -x ,ende[1] +Vario_Bogen_auf_15_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_15_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_15_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_15_Delta_VP_1[0]+Vario_Bogen_auf_15_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_15_Delta_VP_1[2]- Vario_Bogen_auf_15_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_15_Delta_SP_1[0] + Vario_Bogen_auf_15_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_15_Delta_SP_1[2] - Vario_Bogen_auf_15_Delta_SP_0[2]) + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_15 ,(start[0]-x,start[1] - Vario_Bogen_ab_15_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_15_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_15_Delta_VP_0[1],start[1]-Vario_Bogen_ab_15_Delta_VP_0[0] - Vario_Bogen_ab_15_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_15_Delta_VP_0[2] - Vario_Bogen_ab_15_Delta_SP_1[2] start = start[0] ,start[1] - Vario_Bogen_ab_15_Delta_SP_0[0] - Vario_Bogen_ab_15_Delta_SP_1[0],start[2] +Vario_Bogen_ab_15_Delta_SP_0[2] - Vario_Bogen_ab_15_Delta_SP_1[2] + + # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() + # Erstellung der zwischen Line + copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) line = Line.new(dxfattribs={"start": start, "end": ende}) @@ -1687,6 +1642,9 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_auf_15,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -1696,6 +1654,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 9: + # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_Bogen_ab_12 = "Vario_Bogen_ab_12°" block_Vario_Bogen_auf_12 = "Vario_Bogen_auf_12°" auf_12_attrib =import_block(block_Vario_Bogen_auf_12, lib_doc, doc) @@ -1717,65 +1677,48 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_0): + if i< 2 and wert < 0: + Vario_Bogen_auf_12_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_12_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_12_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_12_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_12_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_12_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_12_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_12_Delta_VP_0[i] = abs(wert) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_12,(ende[0] -x ,ende[1] +Vario_Bogen_auf_12_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_12_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_12_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_12_Delta_VP_1[0]+Vario_Bogen_auf_12_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_12_Delta_VP_1[2]- Vario_Bogen_auf_12_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_12_Delta_SP_1[0] + Vario_Bogen_auf_12_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_12_Delta_SP_1[2] - Vario_Bogen_auf_12_Delta_SP_0[2]) + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_Bogen_ab_12 ,(start[0]-x,start[1] - Vario_Bogen_ab_12_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_12_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_12_Delta_VP_0[1],start[1]-Vario_Bogen_ab_12_Delta_VP_0[0] - Vario_Bogen_ab_12_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_12_Delta_VP_0[2] - Vario_Bogen_ab_12_Delta_SP_1[2] start = start[0] ,start[1] - Vario_Bogen_ab_12_Delta_SP_0[0] - Vario_Bogen_ab_12_Delta_SP_1[0],start[2] +Vario_Bogen_ab_12_Delta_SP_0[2] - Vario_Bogen_ab_12_Delta_SP_1[2] + + # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() @@ -1783,6 +1726,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) + # Erstellung der zwischen Line line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" @@ -1790,15 +1734,16 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_ab_12,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_12_attrib) - - - - elif winkel == 3: + # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_6 = "Vario_Bogen_ab_6°" block_Vario_auf_6 = "Vario_Bogen_auf_6°" ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc) @@ -1820,60 +1765,47 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_6_Delta_VP_1 = [Vario_Bogen_auf_6_Delta_VP_1 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_VP_1[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_VP_1[1],-Vario_Bogen_auf_6_Delta_VP_1[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_VP_1[2] * math.cos(math.radians(-3)) ] Vario_Bogen_ab_6_Delta_VP_0 = [Vario_Bogen_ab_6_Delta_VP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_VP_0[1],-Vario_Bogen_ab_6_Delta_VP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_0[2] * math.cos(math.radians(3)) ] - i = 0 - - 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_1: - if i<2: - if negativ < 0: - negativ = negativ*-1 - Vario_Bogen_auf_6_Delta_VP_1[i] = negativ - i = i + 1 - i = 0 - for negativ in Vario_Bogen_ab_6_Delta_VP_0: - if i <2: - if negativ < 0: - negativ = negativ*-1 - - Vario_Bogen_ab_6_Delta_VP_0[i] = negativ - i = i + 1 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + for i, wert in enumerate(Vario_Bogen_auf_6_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_6_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_6_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_6_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_6_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_6_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_6_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_6_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_6_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_6_Delta_VP_0[i] = abs(wert) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie + block.add_blockref(block_Vario_auf_6,(ende[0] -x ,ende[1] +Vario_Bogen_auf_6_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_6_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_6_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_6_Delta_VP_1[0]+Vario_Bogen_auf_6_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_6_Delta_VP_1[2]- Vario_Bogen_auf_6_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_6_Delta_SP_1[0] + Vario_Bogen_auf_6_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_6_Delta_SP_1[2] - Vario_Bogen_auf_6_Delta_SP_0[2]) + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_ab_6 ,(start[0]-x,start[1] - Vario_Bogen_ab_6_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_6_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_6_Delta_VP_0[1],start[1]-Vario_Bogen_ab_6_Delta_VP_0[0] - Vario_Bogen_ab_6_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_6_Delta_VP_0[2] - Vario_Bogen_ab_6_Delta_SP_1[2] start = start[0] ,start[1] - Vario_Bogen_ab_6_Delta_SP_0[0] - Vario_Bogen_ab_6_Delta_SP_1[0],start[2] +Vario_Bogen_ab_6_Delta_SP_0[2] - Vario_Bogen_ab_6_Delta_SP_1[2] + + # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() @@ -1881,6 +1813,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) + # Erstellung der zwischen Line line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" @@ -1888,11 +1821,16 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_ab_6,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_6_attrib) elif winkel == 0: + # Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_Bogen_auf_3 = "Vario_Bogen_auf_3°" block_Vario_Bogen_ab_3 = "Vario_Bogen_ab_3°" auf_3_attrib =import_block(block_Vario_Bogen_auf_3, lib_doc, doc) @@ -1914,61 +1852,40 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + for i, wert in enumerate(Vario_Bogen_auf_3_Delta_SP_0): + if i< 2 and wert < 0: - # einfügen des auf blockes und erstellung des ende_VP für die VARIO lineie + Vario_Bogen_auf_3_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_3_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_3_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_3_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_3_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_3_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_3_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_3_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_3_Delta_VP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_3_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_3_Delta_VP_0[i] = abs(wert) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_3,(ende[0] -x ,ende[1] +Vario_Bogen_auf_3_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_3_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) ende_VP = (ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_3_Delta_VP_1[0]+Vario_Bogen_auf_3_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_3_Delta_VP_1[2]- Vario_Bogen_auf_3_Delta_SP_0[2]) ende = (ende[0] ,ende[1] +Vario_Bogen_auf_3_Delta_SP_1[0] + Vario_Bogen_auf_3_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_3_Delta_SP_1[2] - Vario_Bogen_auf_3_Delta_SP_0[2]) - # einfügen des ab blockes und erstellung des start_VP für die VARIO lineie + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_3 ,(start[0]-x,start[1] - Vario_Bogen_ab_3_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_3_Delta_SP_1[2]),dxfattribs={"rotation": 90}) start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1]-Vario_Bogen_ab_3_Delta_VP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_3_Delta_VP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] start = start[0] ,start[1] - Vario_Bogen_ab_3_Delta_SP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0],start[2] +Vario_Bogen_ab_3_Delta_SP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2] @@ -1989,6 +1906,9 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_Bogen_ab_3,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -1996,23 +1916,44 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif voerder_richtung == "Ab": - # if gefaelle > 0: - # halbesgefaelle = gefaelle/2 - # gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* halbesgefaelle - # line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) - # line_ende_gefaelle.dxf.layer = "6-SP" - # copy_ende = line_ende_gefaelle.copy() - # copy_ende.translate(-x,-y,-hoehe_vario) - # block.add_entity(copy_ende) - # ende = gefaelle_ende - - # gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * halbesgefaelle - # line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) - # line_start_gefaelle.dxf.layer = "6-SP" - # copy_start = line_start_gefaelle.copy() - # copy_start.translate(-x,-y,-hoehe_vario) - # block.add_entity(copy_start) - # start = gefaelle_start + # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird + + if gefaelle > 0: + if motor_vorhanden == "True" and umlenk_vorhanden == "True": + halbesgefaelle = gefaelle/2 + gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* halbesgefaelle + line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) + line_ende_gefaelle.dxf.layer = "6-SP" + copy_ende = line_ende_gefaelle.copy() + copy_ende.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_ende) + ende = gefaelle_ende + + gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * halbesgefaelle + line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) + line_start_gefaelle.dxf.layer = "6-SP" + copy_start = line_start_gefaelle.copy() + copy_start.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_start) + start = gefaelle_start + elif motor_vorhanden == "True": + gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* gefaelle + line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende}) + line_ende_gefaelle.dxf.layer = "6-SP" + copy_ende = line_ende_gefaelle.copy() + copy_ende.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_ende) + ende = gefaelle_ende + elif umlenk_vorhanden == "True": + gefaelle_start = start[0], start[1] -gefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * gefaelle + line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start}) + line_start_gefaelle.dxf.layer = "6-SP" + copy_start = line_start_gefaelle.copy() + copy_start.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_start) + start = gefaelle_start + + # Importieren und setzen der UMlenkungstation oder Motorstation falls nötig block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block( block_Vario_Motorstation_500mm, lib_doc, doc) @@ -2034,6 +1975,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var ende_Motor_VP = ende[0] - 66.5, ende[1]+ winkel_VP_offset_hinten[0] ,ende[2] - winkel_VP_offset_vorne[2] if winkel == 48: + # Einfügen der 45 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_45 = "Vario_Bogen_ab_45°" block_Vario_auf_45 = "Vario_Bogen_auf_45°" ab_45_attrib =import_block( block_Vario_ab_45 , lib_doc, doc) @@ -2054,63 +1997,47 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_45_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_45_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_45_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_45_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_45_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_45_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_45_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_45_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_45_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_45_Delta_VP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_45_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_45_Delta_VP_1[i] = abs(wert) + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_45_Delta_VP_1[1],start[1]- Vario_Bogen_ab_45_Delta_VP_1[0]- Vario_Bogen_ab_45_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_45_Delta_VP_1[2]-Vario_Bogen_ab_45_Delta_SP_0[2] start =(start[0], start[1]- Vario_Bogen_ab_45_Delta_SP_0[0]- Vario_Bogen_ab_45_Delta_SP_1[0],start[2]-Vario_Bogen_ab_45_Delta_SP_0[2]+Vario_Bogen_ab_45_Delta_SP_1[2]) + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270}) 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]) + # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" @@ -2118,6 +2045,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) + # Erstellung der zwischen Line line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" @@ -2125,12 +2053,17 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_ab_45,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_45_attrib) elif winkel == 36: + # Einfügen der 33 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_33 = "Vario_Bogen_ab_33°" block_Vario_auf_33 = "Vario_Bogen_auf_33°" ab_33_attrib =import_block( block_Vario_ab_33 , lib_doc, doc) @@ -2151,59 +2084,46 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_33_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_33_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_33_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_33_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_33_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_33_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_33_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_33_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_33_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_33_Delta_VP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_33_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_33_Delta_VP_1[i] = abs(wert) + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_ab_33, (start[0]-x,start[1]-y- Vario_Bogen_ab_33_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_33_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_33_Delta_VP_1[1],start[1]- Vario_Bogen_ab_33_Delta_VP_1[0]- Vario_Bogen_ab_33_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_33_Delta_VP_1[2]-Vario_Bogen_ab_33_Delta_SP_0[2] start =(start[0], start[1]- Vario_Bogen_ab_33_Delta_SP_0[0]- Vario_Bogen_ab_33_Delta_SP_1[0],start[2]-Vario_Bogen_ab_33_Delta_SP_0[2]+Vario_Bogen_ab_33_Delta_SP_1[2]) + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie + block.add_blockref(block_Vario_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_33_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_33_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_33_Delta_VP_0[0]+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_33_Delta_VP_0[2]- Vario_Bogen_auf_33_Delta_SP_1[2]) ende = (ende[0],ende[1]+ Vario_Bogen_auf_33_Delta_SP_0[0]+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_33_Delta_SP_0[2]- Vario_Bogen_auf_33_Delta_SP_1[2]) + # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() @@ -2211,17 +2131,23 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) + # Erstellung der zwischen Line line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_ab_33,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_33_attrib) elif winkel == 24: + # Einfügen der 21 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_21 = "Vario_Bogen_ab_21°" block_Vario_auf_21 = "Vario_Bogen_auf_21°" ab_21_attrib =import_block( block_Vario_ab_21 , lib_doc, doc) @@ -2242,78 +2168,71 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 - - 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_21_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_21_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_21_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_21_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_21_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_21_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_21_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_21_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_21_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_21_Delta_VP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_21_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_21_Delta_VP_1[i] = abs(wert) + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_21_Delta_VP_1[1],start[1]- Vario_Bogen_ab_21_Delta_VP_1[0]- Vario_Bogen_ab_21_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_21_Delta_VP_1[2]-Vario_Bogen_ab_21_Delta_SP_0[2] start =(start[0], start[1]- Vario_Bogen_ab_21_Delta_SP_0[0]- Vario_Bogen_ab_21_Delta_SP_1[0],start[2]-Vario_Bogen_ab_21_Delta_SP_0[2]+Vario_Bogen_ab_21_Delta_SP_1[2]) + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_21_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_21_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_21_Delta_VP_0[0]+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_21_Delta_VP_0[2]- Vario_Bogen_auf_21_Delta_SP_1[2]) ende = (ende[0],ende[1]+ Vario_Bogen_auf_21_Delta_SP_0[0]+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_21_Delta_SP_0[2]- Vario_Bogen_auf_21_Delta_SP_1[2]) + + # Erstellung der VARIO Line line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) + # Erstellung der zwischen Line line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_ab_21,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_21_attrib) elif winkel == 15: + # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_12 = "Vario_Bogen_ab_12°" block_Vario_auf_12 = "Vario_Bogen_auf_12°" ab_12_attrib =import_block( block_Vario_ab_12 , lib_doc, doc) @@ -2334,79 +2253,75 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 - - 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_12_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_12_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_12_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_12_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_12_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_12_Delta_VP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_12_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_12_Delta_VP_1[i] = abs(wert) + + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_12_Delta_VP_1[1],start[1]- Vario_Bogen_ab_12_Delta_VP_1[0]- Vario_Bogen_ab_12_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_12_Delta_VP_1[2]-Vario_Bogen_ab_12_Delta_SP_0[2] start =(start[0], start[1]- Vario_Bogen_ab_12_Delta_SP_0[0]- Vario_Bogen_ab_12_Delta_SP_1[0],start[2]-Vario_Bogen_ab_12_Delta_SP_0[2]+Vario_Bogen_ab_12_Delta_SP_1[2]) + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie + block.add_blockref(block_Vario_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_12_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_12_Delta_VP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_VP_0[2]- Vario_Bogen_auf_12_Delta_SP_1[2]) ende = (ende[0],ende[1]+ Vario_Bogen_auf_12_Delta_SP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_SP_0[2]- Vario_Bogen_auf_12_Delta_SP_1[2]) + + # Erstellung der VARIO Line + line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) - + # Erstellung der zwischen Line + line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_ab_12,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_12_attrib) elif winkel == 12: + # Einfügen der 9 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_9 = "Vario_Bogen_ab_9°" block_Vario_auf_9 = "Vario_Bogen_auf_9°" ab_9_attrib =import_block( block_Vario_ab_9 , lib_doc, doc) @@ -2427,71 +2342,67 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 - - 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_9_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_9_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_9_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_9_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_9_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_9_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_9_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_9_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_9_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_9_Delta_VP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_9_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_9_Delta_VP_1[i] = abs(wert) + + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_9_Delta_VP_1[1],start[1]- Vario_Bogen_ab_9_Delta_VP_1[0]- Vario_Bogen_ab_9_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_9_Delta_VP_1[2]-Vario_Bogen_ab_9_Delta_SP_0[2] start =(start[0], start[1]- Vario_Bogen_ab_9_Delta_SP_0[0]- Vario_Bogen_ab_9_Delta_SP_1[0],start[2]-Vario_Bogen_ab_9_Delta_SP_0[2]+Vario_Bogen_ab_9_Delta_SP_1[2]) + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie + block.add_blockref(block_Vario_auf_9, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_9_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_9_Delta_VP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_VP_0[2]-Vario_Bogen_auf_9_Delta_SP_1[2]) ende = (ende[0],ende[1]+ Vario_Bogen_auf_9_Delta_SP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_SP_0[2]- Vario_Bogen_auf_9_Delta_SP_1[2]) + + # Erstellung der VARIO Line + line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) + + # Erstellung der zwischen Line + line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_ab_9,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) @@ -2500,6 +2411,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var elif winkel == 9: + # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + block_Vario_ab_6 = "Vario_Bogen_ab_6°" block_Vario_auf_6 = "Vario_Bogen_auf_6°" ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc) @@ -2521,76 +2434,69 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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 - - 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 + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_6_Delta_SP_0): + if i< 2 and wert < 0: + + Vario_Bogen_auf_6_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_6_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_6_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_6_Delta_SP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_6_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_6_Delta_SP_1[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_auf_6_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_6_Delta_VP_0[i] = abs(wert) + + for i, wert in enumerate(Vario_Bogen_ab_6_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_6_Delta_VP_1[i] = abs(wert) + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_6_Delta_VP_1[1],start[1]- Vario_Bogen_ab_6_Delta_VP_1[0]- Vario_Bogen_ab_6_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_6_Delta_VP_1[2]-Vario_Bogen_ab_6_Delta_SP_0[2] - start =(start[0], start[1]- Vario_Bogen_ab_6_Delta_SP_0[0]- Vario_Bogen_ab_6_Delta_SP_1[0],start[2]-Vario_Bogen_ab_6_Delta_SP_0[2]+Vario_Bogen_ab_6_Delta_SP_1[2]) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_6_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_6_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_6_Delta_VP_0[0]+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_6_Delta_VP_0[2]- Vario_Bogen_auf_6_Delta_SP_1[2]) ende = (ende[0],ende[1]+ Vario_Bogen_auf_6_Delta_SP_0[0]+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_6_Delta_SP_0[2]- Vario_Bogen_auf_6_Delta_SP_1[2]) + + # Erstellung der VARIO Line + line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) - + + # Erstellung der zwischen Line line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + + #Hilfmethode zur ausmessen der bogen + # a = msp.add_blockref(block_Vario_auf_6,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, auf_6_attrib) elif winkel == 3: + # Nur erstellung der zwischen und Vario linie weil der Bogen hier nicht nötig ist line_VP = Line.new(dxfattribs={"start": start_Umlenkstation_VP,"end": ende_Motor_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() @@ -2604,8 +2510,11 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + +# Erstellung einer Spiegelung an der y achse (hier wird es ausgeführt durch -x) für die erstellung des Förderers mit den vario stationen links matrix = Matrix44.scale(-1,1,1) block_links = doc.blocks.new(block_name_links, base_point=(0,0,0)) + #spiegelung aller elemente außer es und as elemente falls diese vorhanden sind um die logik wie die platziert werden nicht zu zerstören for entity in block: clone= entity.copy() if entity.dxftype() == "INSERT":