From aa711c49d3a3f2df8c6efd5e0fa3bacaf0e6a2f5 Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Thu, 6 Nov 2025 10:50:22 +0100 Subject: [PATCH 1/2] Offset von 3 grad ab bogen minimiert wenn es mit was anderem Vorderer verbundem ist --- lib/plant2dxf.py | 621 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 507 insertions(+), 114 deletions(-) diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index 983a104..afa6efb 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -90,12 +90,23 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: - Stellt sicher, dass benutzte Layer im Ziel existieren (mit Eigenschaften) - Übernimmt Basis­punkt und Block-Layer, falls vorhanden """ - + src = from_doc.blocks[block_name] + att_def = {} if ((block_name in to_doc.blocks)): - return + for ent in src: + copy = ent.copy() + + if ent.dxftype() == "ATTDEF": + att_def[ent.dxf.tag] =ent.dxf.text + if ent.dxftype() == "INSERT": + + import_block(ent.dxf.name,from_doc, to_doc,None) + + if att_def != []: + return att_def + return if block_name not in from_doc.blocks: raise ValueError(f"Block '{block_name}' nicht in Bibliothek gefunden.") - src = from_doc.blocks[block_name] # Sicherstellen, dass alle verwendeten Layer existieren try: @@ -127,12 +138,10 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: except Exception: pass - att_def = {} + for ent in src: copy = ent.copy() - if ent.dxftype() == "ATTDEF": - if ent.dxf.tag == "DELTA_SP_0": - test = 3 + if ent.dxftype() == "ATTDEF": att_def[ent.dxf.tag] =ent.dxf.text if ent.dxftype() == "INSERT": @@ -319,6 +328,11 @@ def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose): f"({x:.1f}, {y:.1f})") +def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config): + import_block("AN8",lib_doc,doc) + hight = float(merkmale.get("Höhe in m"))* 1000 + msp.add_blockref("AN8",(x,y,hight)) + def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config): #Vorbereitung der attributen @@ -387,15 +401,17 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}" - erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,hight) - blockref_layer = get_layer(doc, lib_doc, blockname) - bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer}) - a =bref.add_attrib( - tag= "NAME", - text= merkmale.get("bezeichner"), - insert = (x,y) - ) - a.is_invisible = True + only_es_or_as = erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,hight) + + if only_es_or_as == False: + blockref_layer = get_layer(doc, lib_doc, blockname) + bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer}) + a =bref.add_attrib( + tag= "NAME", + text= merkmale.get("bezeichner"), + insert = (x,y) + ) + a.is_invisible = True @@ -590,20 +606,41 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v - +def add_attributes_to_block(block, attributes): + """ + Fügt einem bestehenden ezdxf-Block Attribut-Definitionen hinzu. + + Parameter: + block – ein ezdxf.blocks.BlockLayout Objekt + attributes – Liste von Tupeln [(tag, value), ...] + """ + for tag, value in attributes.items(): + test = 3 + tag = tag + value = value + a =block.add_attrib( + tag=tag, + text=value, + ) + a.is_invisible = True + def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config): - + + winkel_VP_offset_vorne = None + winkel_VP_offset_hinten = None # erstellung des Layers falls nicht vorhanden if "VARIO" not in doc.layers: doc.layers.add(name="VARIO", color=3) + + if "6-SP" not in doc.layers: + doc.layers.add(name="6-SP", color=7) # Vorbereitung der Werte voerder_richtung = merkmale.get("Förderrichtung") winkel = int(merkmale.get("Winkel")) - verbunden_am_einen = False + erster_kreisel_höher = False ein_kreisel_höher = False richtung2 ="DEFAULT" - unterschiedlich = False asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset")) rotation = float(merkmale.get("Drehung")) @@ -618,6 +655,9 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve lower_hoehe_vario = hight # Korrektur der rotation mit der Umstellung der Höhe rotation = rotation -180 + + + hoehe_vario= (upper_hoehe_vario + lower_hoehe_vario)/2 # Hollen der Information der Nachbarn strukturen ob diese Kreisel sind for nachbarn in strecken_nachbarn: @@ -625,6 +665,100 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve gefaellestrecke_vario = nachbarn break laenge = float(merkmale.get("Länge in Meter")) *1000 + + if gefaellestrecke_vario.get("Winkel") != None and winkel == 3 and voerder_richtung == "Ab": + if float(gefaellestrecke_vario.get("h0")) == lower_hoehe_vario: + if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung") == "Horizontal"): + winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) + + blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°") + att_vorne =import_block(blockname,lib_doc,doc) + SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) + VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) + 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: + winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) + + blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°") + att_vorne =import_block(blockname,lib_doc,doc) + SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"])) + VP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"])) + 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"): + winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 + winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) + + blockname = (f"Vario_Bogen_auf_{winkel_hinten_plusbogen}°") + att_hinten =import_block(blockname,lib_doc,doc) + SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_0"])) + VP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_0"])) + 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: + winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3 + winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) + + blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°") + att_hinten =import_block(blockname,lib_doc,doc) + SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"])) + VP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"])) + 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)) + + + + if (gefaellestrecke_vario.get("Winkel_2") != None): + if float(gefaellestrecke_vario.get("h0_2")) == lower_hoehe_vario: + if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): + winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) + + blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°") + att_vorne =import_block(blockname,lib_doc,doc) + SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) + VP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"])) + 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: + winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel_2")) -3 + winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) + + blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°") + att_vorne =import_block(blockname,lib_doc,doc) + SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"])) + VP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"])) + 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"): + 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"])) + 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: + 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"])) + winkel_VP_offset_hinten = ((SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten))), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) + + # Für spätere berechnung schauen ob der erste Kreis in der Liste höher ist if upper_hoehe_vario == gefaellestrecke_vario.get("Hoehe0"): ein_kreisel_höher = True @@ -679,6 +813,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) @@ -696,11 +831,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) ende = m line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) # Erstellung des Vario_förderes selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ) + vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # reintuen des förderes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -726,9 +862,9 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve dy_true = halbe_laenge * math.cos (0) # Schauen welches as oder es element man wo verbinden muss und bereits in den block tuen, der None wert ist ein Wert der für die Gefällestrecke notwendig ist # Entnehmen von start und end Werte für spätere vario erstellung - start, ende =erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario, drehung0, laenge, blockname,None ,block_vario, voerder_richtung, ein_kreisel_höher) + start, ende =erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario, drehung0, laenge, blockname,None ,block_vario, voerder_richtung, ein_kreisel_höher) # Erstellung des Varios selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ) + vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # reintuen des förderes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -800,6 +936,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) @@ -816,11 +953,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) ende = m line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) # Die Vario erstellung selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ) + vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # reintuen des förderes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -868,6 +1006,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) @@ -888,6 +1027,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve z1 = m[2] line = Line.new(dxfattribs={"start": l,"end":m }) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block_vario.add_entity(copy) @@ -897,7 +1037,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Entnehmen von start und end Werte für spätere vario erstellung start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,block_vario,voerder_richtung, am_kreisel,erster_kreisel_höher,y1,z1) # Erstellung der Vario gefälle selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ) + vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -927,7 +1067,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Entnehmen von start und end Werte für spätere vario erstellung start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,block_vario,voerder_richtung) # Erstellung des Vario selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ) + vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ) # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -961,36 +1101,88 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Erstellung des Förderes selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung ) + 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) # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": - insert = msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) if merkmale.get("Motorseite")== "rechts": - insert =msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) - attrib_values = {} + msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + -def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung ): +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 ): + motor_vorhanden = merkmale.get("Motor") + umlenk_vorhanden = merkmale.get("Umlenk") # Falls auf der Vario Förderer auf ist + 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] + + + + 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 + + # 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 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 - umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block(block_Vario_Motorstation_500mm, lib_doc, doc) - import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc,math.radians(3)) + import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc) block_Vario_Motorstation_500mm = dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(3)) block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(3)) - - - block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0] -x,ende[1] -y + umlenk_motor_offset[0]/2,ende[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 90}) - ende = (ende[0] ,ende[1] + umlenk_motor_offset[0],ende[2] -umlenk_motor_offset[2]) - block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - umlenk_motor_offset[0]/2 -y ,start[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 90}) - start = start[0] , start[1] - umlenk_motor_offset[0],start[2] +umlenk_motor_offset[2] + if umlenk_vorhanden == "True": + block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0] -x,ende[1] -y + umlenk_motor_offset[0]/2,ende[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 90}) + ende = (ende[0] ,ende[1] + umlenk_motor_offset[0],ende[2] -umlenk_motor_offset[2]) + if motor_vorhanden == "True": + block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - umlenk_motor_offset[0]/2 -y ,start[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 90}) + start = start[0] , start[1] - umlenk_motor_offset[0],start[2] +umlenk_motor_offset[2] + if winkel == 48: # Einfügen der 51 Bogen und deren notwendigen Werten von dem config nehmen block_Vario_Bogen_auf_51 = "Vario_Bogen_auf_51°" @@ -1079,14 +1271,16 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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) - # msp.add_blockref(block_Vario_Bogen_auf_51,(x,y,0)) - # msp.add_line((x+1000,y,0),(x-1000,y,0)) + # a = msp.add_blockref(block_Vario_Bogen_ab_51,(x,y,0)) + # msp.add_line((x+1000,y + 50,0),(x-1000,y +50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) + # add_attributes_to_block(a, ab_51_attrib) @@ -1181,14 +1375,17 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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) - # msp.add_blockref(block_Vario_Bogen_ab_39,(x,y,0)) - # msp.add_line((x+267.49,y-66.5,0),(x-267.49,y-66.5,0)) + # a = msp.add_blockref(block_Vario_Bogen_ab_39,(x,y,0)) + # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) + # add_attributes_to_block(a, ab_39_attrib) + elif winkel == 24: @@ -1283,14 +1480,16 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # 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) - # msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0)) - # msp.add_line((x+1000,y,0),(x-1000,y,0)) + # a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0)) + # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) + # add_attributes_to_block(a, ab_27_attrib) @@ -1385,11 +1584,16 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # 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) + # a = msp.add_blockref(block_Vario_Bogen_ab_18,(x,y,0)) + # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + # add_attributes_to_block(a, ab_18_attrib) @@ -1477,11 +1681,17 @@ 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) 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) + # a = msp.add_blockref(block_Vario_Bogen_auf_15,(x,y,0)) + # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + # add_attributes_to_block(a, auf_15_attrib) + @@ -1574,24 +1784,114 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy_VP) line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - # msp.add_blockref(block_Vario_Bogen_auf_12,(x,y,0)) - # msp.add_line((x+1000,y,0),(x-1000,y,0)) + # 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: + block_Vario_ab_6 = "Vario_Bogen_ab_6°" + block_Vario_auf_6 = "Vario_Bogen_auf_6°" + ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc) + auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc) + block_Vario_ab_6 = dreh_block( block_Vario_ab_6, doc, math.radians(3)) + block_Vario_auf_6 = dreh_block( block_Vario_auf_6 , doc, math.radians(-3)) + Vario_Bogen_auf_6_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_6_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_6_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_6_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_6_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_VP_1"])) + Vario_Bogen_ab_6_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_VP_0"])) + + + Vario_Bogen_auf_6_Delta_SP_0 = [Vario_Bogen_auf_6_Delta_SP_0 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_0[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_SP_0[1],-Vario_Bogen_auf_6_Delta_SP_0[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_0[2] * math.cos(math.radians(-3)) ] + Vario_Bogen_auf_6_Delta_SP_1 = [Vario_Bogen_auf_6_Delta_SP_1 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_1[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_SP_1[1],-Vario_Bogen_auf_6_Delta_SP_1[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_SP_1[2] * math.cos(math.radians(-3)) ] + Vario_Bogen_ab_6_Delta_SP_0 = [Vario_Bogen_ab_6_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_0[1],-Vario_Bogen_ab_6_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2] * math.cos(math.radians(3)) ] + Vario_Bogen_ab_6_Delta_SP_1 =[ Vario_Bogen_ab_6_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_1[1],-Vario_Bogen_ab_6_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_1[2] * math.cos(math.radians(3)) ] + Vario_Bogen_auf_6_Delta_VP_1 = [Vario_Bogen_auf_6_Delta_VP_1 [0] * math.cos(math.radians(-3))+ Vario_Bogen_auf_6_Delta_VP_1[2]* math.sin(math.radians(-3)) ,Vario_Bogen_auf_6_Delta_VP_1[1],-Vario_Bogen_auf_6_Delta_VP_1[0] * math.sin(math.radians(-3))+ Vario_Bogen_auf_6_Delta_VP_1[2] * math.cos(math.radians(-3)) ] + Vario_Bogen_ab_6_Delta_VP_0 = [Vario_Bogen_ab_6_Delta_VP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_VP_0[1],-Vario_Bogen_ab_6_Delta_VP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_VP_0[2] * math.cos(math.radians(3)) ] + + 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 + 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]) + + 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] + line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) + line_VP.dxf.layer = "VARIO" + copy_VP = line_VP.copy() + + copy_VP.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_VP) + line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" copy= line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # 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: block_Vario_Bogen_auf_3 = "Vario_Bogen_auf_3°" block_Vario_Bogen_ab_3 = "Vario_Bogen_ab_3°" @@ -1683,25 +1983,56 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # 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) + # a = msp.add_blockref(block_Vario_Bogen_ab_3,(x,y,0)) + # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) + # msp.add_line((x,y+1000,0),(x,y-1000,0)) + # add_attributes_to_block(a, ab_3_attrib) elif voerder_richtung == "Ab": - umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) + # 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 block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm" block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" import_block( block_Vario_Motorstation_500mm, lib_doc, doc) import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc) block_Vario_Motorstation_500mm = dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(3)) block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(3)) - block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0] -x,start[1] -y - umlenk_motor_offset[0]/2, start[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 270}) - start = (start[0] ,start[1] - umlenk_motor_offset[0],start[2] -umlenk_motor_offset[2]) - block.add_blockref(block_Vario_Motorstation_500mm, (ende[0]-x , ende[1] + umlenk_motor_offset[0]/2 -y ,ende[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 270}) - ende = ende[0] , ende[1] + umlenk_motor_offset[0],ende[2] +umlenk_motor_offset[2] + if umlenk_vorhanden == "True": + block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0] -x,start[1] -y - umlenk_motor_offset[0]/2, start[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 270}) + start_Umlenkstation_VP = start[0] - 66.5, start[1] -500 *math.cos(math.radians(-3))+ math.sin(math.radians(-3))* -45,start[2] + math.sin(math.radians(-3))*500+ math.cos(math.radians(-3))*-45 + start = (start[0] ,start[1] - umlenk_motor_offset[0],start[2] -umlenk_motor_offset[2]) + elif winkel == 3: + start_Umlenkstation_VP = start[0] - 66.5, start[1]+ winkel_VP_offset_vorne[0],start[2] -winkel_VP_offset_hinten[2] + if motor_vorhanden == "True": + block.add_blockref(block_Vario_Motorstation_500mm, (ende[0]-x , ende[1] + umlenk_motor_offset[0]/2 -y ,ende[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 270}) + ende_Motor_VP = ende[0] - 66.5, ende[1] +500 *math.cos(math.radians(-3))+ math.sin(math.radians(-3))* -45,ende[2] - math.sin(math.radians(-3))*500+ math.cos(math.radians(-3))*-45 + + ende = ende[0] , ende[1] + umlenk_motor_offset[0],ende[2] +umlenk_motor_offset[2] + elif winkel == 3: + ende_Motor_VP = ende[0] - 66.5, ende[1]+ winkel_VP_offset_hinten[0] ,ende[2] - winkel_VP_offset_vorne[2] + if winkel == 48: block_Vario_ab_45 = "Vario_Bogen_ab_45°" block_Vario_auf_45 = "Vario_Bogen_auf_45°" @@ -1789,13 +2120,15 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy_VP) line = Line.new(dxfattribs={"start":start,"end":ende }) + line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - msp.add_blockref(block_Vario_ab_45,(x,y,0)) - msp.add_line((x+442.08,y-66.5,0),(x-630.21,y-66.5,0)) - msp.add_line((x,y+1000,0),(x,y-1000,0)) + # 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: block_Vario_ab_33 = "Vario_Bogen_ab_33°" @@ -1880,13 +2213,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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) - # msp.add_blockref(block_Vario_ab_33,(x,y,0)) - # msp.add_line((x+1000,y,0),(x-630.21,y,0)) + # 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: block_Vario_ab_21 = "Vario_Bogen_ab_21°" block_Vario_auf_21 = "Vario_Bogen_auf_21°" @@ -1971,10 +2305,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy_VP) line = Line.new(dxfattribs={"start":start,"end":ende }) + line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - # msp.add_blockref(block_Vario_ab_21,(x,y,0)) + # 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: block_Vario_ab_12 = "Vario_Bogen_ab_12°" block_Vario_auf_12 = "Vario_Bogen_auf_12°" @@ -2059,9 +2397,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy_VP) line = Line.new(dxfattribs={"start":start,"end":ende }) + line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) + # 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: block_Vario_ab_9 = "Vario_Bogen_ab_9°" @@ -2145,12 +2488,15 @@ 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) 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) - # msp.add_blockref(block_Vario_auf_9,(x,y,0)) - # msp.add_line((x+1000,y -66.5,45),(x-150.23,y -66.5, 45)) + # 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)) + # add_attributes_to_block(a, ab_9_attrib) + elif winkel == 9: @@ -2236,15 +2582,22 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy_VP) line = Line.new(dxfattribs={"start":start,"end":ende }) + line.dxf.layer = "6-SP" copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - # msp.add_blockref(block_Vario_auf_6,(x,y,0)) - # msp.add_line((x+500,y,45),(x-500,y,45)) - # msp.add_line((x,y+500,0),(x,y-500,0)) - + # 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: + line_VP = Line.new(dxfattribs={"start": start_Umlenkstation_VP,"end": ende_Motor_VP}) + line_VP.dxf.layer = "VARIO" + copy_VP = line_VP.copy() + copy_VP.translate(-x,-y,-hoehe_vario) + block.add_entity(copy_VP) line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" copy= line.copy() @@ -2331,8 +2684,8 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, -def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge,blockname, hight = None, block_vario = None, vario_richtung = None, verbungden_höher = None): - +def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge,blockname, hight = None, block_vario = None, vario_richtung = None, verbungden_höher = None): + halbe_laenge = laenge / 2 dy = halbe_laenge * math.cos(0) @@ -2356,19 +2709,24 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, elif vario_richtung =="Horizontal": # TODO return start, ende + if laenge > asoffset: + start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) + ende = (x , y - dy ,lower_hoehe_gefaehlle) - start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) - ende = (x , y - dy ,lower_hoehe_gefaehlle) + line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" + copy= line.copy() - line = Line.new(dxfattribs={"start": start, "end": ende}) - line.dxf.layer = "6-SP" - copy= line.copy() - - copy.translate(-x,-y,-hoehe_gefaehlle) - block.add_entity(copy) + copy.translate(-x,-y,-hoehe_gefaehlle) + block.add_entity(copy) - block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) + block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) + return False + else: + msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle)) + return True + elif ((blockname not in doc.blocks and hight == "lower" and drehung0 == "GUZS") or (vario_richtung == "Auf"and verbungden_höher == True and drehung0 == "GUZS") or (vario_richtung == "Ab" and verbungden_höher == False and drehung0 == "GUZS")): block_es = "200000146_ES-Element_90_rechts" import_block(block_es,lib_doc,doc) @@ -2389,21 +2747,23 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, # TODO return start, ende + if laenge > esoffset: + start = (x , y + dy,upper_hoehe_gefaehlle) + ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) - start = (x , y + dy,upper_hoehe_gefaehlle) - ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) + line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" + copy= line.copy() + copy.translate(-x,-y,-hoehe_gefaehlle) + block.add_entity(copy) + block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) + return False + else: + msp.add_blockref(block_es,(x,y,lower_hoehe_gefaehlle)) + return True - line = Line.new(dxfattribs={"start": start, "end": ende}) - line.dxf.layer = "6-SP" - copy= line.copy() - - copy.translate(-x,-y,-hoehe_gefaehlle) - block.add_entity(copy) - - - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) elif ((blockname not in doc.blocks and hight == "higher" and drehung0 == "UZS")or (vario_richtung == "Auf"and verbungden_höher == False and drehung0 == "UZS") or (vario_richtung == "Ab" and verbungden_höher == True and drehung0 == "UZS")): block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) @@ -2424,19 +2784,20 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, elif vario_richtung =="Horizontal": # TODO return start, ende - start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) - ende = (x , y - dy ,lower_hoehe_gefaehlle) + + if laenge > asoffset: + start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) + ende = (x , y - dy ,lower_hoehe_gefaehlle) + line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" + copy= line.copy() + copy.translate(-x ,-y,-hoehe_gefaehlle) + block.add_entity(copy) + block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) + else: + msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle),dxfattribs={"rotation": 180}) - line = Line.new(dxfattribs={"start": start, "end": ende}) - line.dxf.layer = "6-SP" - copy= line.copy() - - copy.translate(-x ,-y,-hoehe_gefaehlle) - block.add_entity(copy) - - - block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) elif (( blockname not in doc.blocks and hight == "lower" and drehung0 == "UZS") or (vario_richtung == "Auf" and verbungden_höher == True and drehung0 == "UZS") or (vario_richtung == "Ab" and verbungden_höher == False and drehung0 == "UZS")): if hight != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) @@ -2456,22 +2817,22 @@ def erstellung_gefaelle_block_verbunenden_am_einen(x, y, doc, lib_doc, asoffset, elif vario_richtung =="Horizontal": # TODO return start, ende - start = (x , y + dy ,upper_hoehe_gefaehlle) - ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) + if laenge > esoffset: + start = (x , y + dy ,upper_hoehe_gefaehlle) + ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) + line = Line.new(dxfattribs={"start": start, "end": ende}) + line.dxf.layer = "6-SP" + copy= line.copy() - line = Line.new(dxfattribs={"start": start, "end": ende}) - line.dxf.layer = "6-SP" - copy= line.copy() + copy.translate(-x ,-y,-hoehe_gefaehlle) + block.add_entity(copy) - copy.translate(-x ,-y,-hoehe_gefaehlle) - block.add_entity(copy) - - - - - - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) + block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) + return False + else: + msp.add_blockref(block_es,(x,y,lower_hoehe_gefaehlle),dxfattribs={"rotation": 180}) + return True def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2, drehung0, drehung1, laenge, hight_position, blockname, block_vario = None,voerder_richtung = None, am_kreisel = None, erster_kreisel_höher = None,y1=None,z1 =None): @@ -3145,16 +3506,16 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: geraden = [] kreisel =[] strecken_nachbarn = [] + foerderernachbarn = [] anweisungen = 0 """Gib für jede gefällestrecke zurück welche Drehrichtung die benachbarten Kreisel haben """ with csv_path.open(newline="", encoding="utf-8") as fh: reader = csv.DictReader(fh, delimiter=';') for row in reader: bezeichner = row["TeileArt"].strip() - if bezeichner == "ILS 2.0 Gefällestrecke" or bezeichner =="ILS 2.0 VarioFoerderer": + if bezeichner == "ILS 2.0 Gefällestrecke": Id = row["TeileId"].strip() NachbarIds = row["NachbarIds"].strip() - geraden.append({"Id": Id, "NachbarIds": NachbarIds}) if bezeichner == "ILS 2.0 Kreisel": Id = row["TeileId"].strip() @@ -3168,10 +3529,23 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: "Abstand (Kreiselachse A - Kreiselachse) in Meter", "20" ).replace(",", ".") kreisel.append({"Id":Id, "drehung":drehung, "höhe":hight,"x": x, "y": y, "rotation": rotation,"abstand":abstand_m}) + if bezeichner =="ILS 2.0 VarioFoerderer": + Id = row["TeileId"].strip() + NachbarIds = row["NachbarIds"].strip() + merkmale = parse_merkmale(row.get("Merkmale", "")) + winkel = merkmale.get("Winkel") + h0 = float(merkmale.get("Höhe Anfang")) * 1000 + h1 = float(merkmale.get("Höhe Ende")) * 1000 + foerderrichtung = merkmale.get("Förderrichtung") + geraden.append({"Id": Id,"NachbarIds":NachbarIds, "Winkel":winkel, "h0": h0,"h1": h1,"Foerderrichtung":foerderrichtung }) + + + for gerade in geraden: anweisungen = 0 + geraden_anweisung = 0 eintrag = {"Id": gerade["Id"]} for kreis in kreisel: if kreis["Id"] in gerade["NachbarIds"]: @@ -3191,6 +3565,25 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: eintrag["rotation1"] = kreis.get("rotation") eintrag["abstand1"] = kreis.get("abstand") break + if(gerade.get("Winkel") != None ): + for vario_gerade in geraden: + + if vario_gerade["Id"] in gerade["NachbarIds"] and vario_gerade.get("Winkel") != None: + if geraden_anweisung == 0: + eintrag["Winkel"] = vario_gerade.get("Winkel") + eintrag["h0"] = vario_gerade.get("h0") + eintrag["h1"] = vario_gerade.get("h1") + eintrag["Foerderrichtung"] = vario_gerade.get("Foerderrichtung") + geraden_anweisung =1 + elif geraden_anweisung == 1: + eintrag["Winkel_2"] = vario_gerade.get("Winkel") + eintrag["h0_2"] = vario_gerade.get("h0") + eintrag["h1_2"] = vario_gerade.get("h1") + eintrag["Foerderrichtung_2"] = vario_gerade.get("Foerderrichtung") + break + + + strecken_nachbarn.append(eintrag) return strecken_nachbarn From 2dce965a934899db75447d5eb892052ea36e9eee Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 10 Nov 2025 10:10:27 +0100 Subject: [PATCH 2/2] =?UTF-8?q?Kommentare=20Hinzugef=C3=BCgt=20f=C3=BCr=20?= =?UTF-8?q?den=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":