From b59bed3c385a534e33ff0b563cde782505d04b86 Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 17 Nov 2025 08:26:04 +0100 Subject: [PATCH] entfernung von doppelten Leerzeichen --- lib/plant2dxf.py | 381 +++++------------------------------------------ 1 file changed, 35 insertions(+), 346 deletions(-) diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index abf8c06..08a7842 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -20,8 +20,7 @@ import math import re from utils import check_environment_var, setup_logger - -global_zaehler = 0 +# global_zaehler = 0 # --------------------------------------------------------- CFG-Leser für shapes.cfg def get_shape_cfg(teileart, cfg_path, logger=None): parser = configparser.ConfigParser() @@ -63,7 +62,6 @@ def get_shape_cfg(teileart, cfg_path, logger=None): "rotation": rot }) return symbols - # --------------------------------------------------------- Konstante Parameter ATTR_TAG = "TeileId" # Attributtag im Block RADIUS = 400 # Radius der Kreiselkreise (mm) @@ -117,7 +115,6 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: if block_name not in from_doc.blocks: raise ValueError(f"Block '{block_name}' nicht in Bibliothek gefunden.") # Sicherstellen, dass alle verwendeten Layer existieren - try: used_layer_names = {e.dxf.layer for e in src if hasattr(e.dxf, "layer")} for layer_name in used_layer_names: @@ -135,7 +132,6 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: to_doc.layers.add(name=layer_name) except Exception: pass - tgt = to_doc.blocks.new(name=block_name) # Basis­punkt/Layer des Blocks übernehmen, wenn vorhanden try: @@ -146,7 +142,6 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: tgt.block.dxf.layer = src.block.dxf.layer 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() @@ -160,12 +155,10 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None: if att_def != {}: return att_def - def dreh_block(block_name: str, to_doc, winkel) : """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)}" if (dreh_block_name in to_doc.blocks): return dreh_block_name @@ -180,8 +173,6 @@ def dreh_block(block_name: str, to_doc, winkel) : block.add_entity(copy) return dreh_block_name - - def berechne_hoehe(csv_path, logger=None): y_werte = [] try: @@ -218,9 +209,7 @@ def handle_ils_2_0_kreisel_mit_pin(msp, teileid, merkmale, x, y, doc, lib_doc, v merkmale["pin"] = "True" handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein) - def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein): - scanner = float(merkmale.get("Anzahl der Scanner")) separatoren = float(merkmale.get("Anzahl der Separatoren")) block_scanner = "SCAN" @@ -278,7 +267,6 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, print(f"[INFO] Block '{blockname}' (Kreisel) → {teileid} " f"({pos[0]:.1f}, {pos[1]:.1f}), rot={rotation}") # Linien zeichnen - import_block("Pinbereich",lib_doc,doc) draw_kreisel_lines(msp, pos1, pos2,merkmale) draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc, verbose) @@ -286,7 +274,6 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, def draw_kreisel_lines(msp, pos1, pos2,merkmale): """Zeichnet tangentiale Linien zwischen zwei Kreiselblöcken, unabhängig vom Winkel.""" - x1, y1, z1 = pos1 x2, y2, z1 = pos2 # Verbindungsvektor @@ -319,7 +306,6 @@ def draw_kreisel_lines(msp, pos1, pos2,merkmale): msp.add_line(p1a, p2a) msp.add_line(p1b, p2b) - def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc, verbose): drehrichtung = merkmale.get("Drehrichtung", "").upper() if drehrichtung not in ("UZS", "GUZS"): @@ -377,7 +363,6 @@ def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose): print(f"[INFO] Block '{blockname}' (Standard) → {teileid} " f"({x:.1f}, {y:.1f})") - def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): import_block("AN8",lib_doc,doc) hight = float(merkmale.get("Höhe in m"))* 1000 @@ -392,7 +377,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v doc.layers.add(name="6-SP", color=7) verbunden_am_einen = False - richtung2 ="DEFAULT" unterschiedlich = False asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) @@ -419,23 +403,18 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v except ValueError: laenge = 10000 - - halbe_laenge = laenge / 2 rotation= float(merkmale.get("Drehung")) winkel = math.radians(float(rotation)) dx = halbe_laenge *math.sin(winkel * -1) dy = halbe_laenge * math.cos(winkel) - if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: hoehe2 = upper_hoehe_gefaehlle upper_hoehe_gefaehlle = lower_hoehe_gefaehlle lower_hoehe_gefaehlle = hoehe2 rotation = rotation -180 - - am_kreisel, kreisel_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None) if am_kreisel == 1: start = x +dx, y + dy,upper_hoehe_gefaehlle @@ -474,12 +453,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v ) a.is_invisible = True - - - - - - elif "Drehung0" in gefaellestrecke_nachbarn and "Drehung1" in gefaellestrecke_nachbarn: winkel = math.radians(float(merkmale.get("Drehung"))) @@ -508,13 +481,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v abstand1 = float(gefaellestrecke_nachbarn.get("abstand1")) * 1000 rotation = float(merkmale.get("Drehung")) - - - - #ausrechnung position kreisel am_kreisel, kreisel_verbunden= am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, x1_kreisel, y1_kreisel, richtung_rad1, abstand1) - # falls gefälle strecke mit zwei kreiseln verbunden zeichne eine einfache linie (später braucht man hier auch eine logik sobald man die richtigen es und as elemente hat) if kreisel_verbunden == 2: start = x +dx, y + dy,upper_hoehe_gefaehlle @@ -523,7 +491,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v line.dxf.layer = "6-SP" return - #umbezeichnung von den geraden zu strings ob es Vertikal oder Horizontal ist if richtung0 == 90.0 or richtung0 ==270: richtung0= "Vertikal" @@ -534,9 +501,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v else: richtung1 = "Horinzontal" richtung2,unterschiedlich = am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, x1_kreisel, y1_kreisel, richtung_rad1, abstand1,kreisel_verbunden, richtung0 , richtung1 , richtung2 ) - #Berechnung des Gefälles - if hoehe0 > hoehe1: hight_position = "higher" else: @@ -576,7 +541,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v # austausch der werte damit immer davon ausgehen dass der 1 kreisel in unserer Liste am Kreisel verbuden ist if kreisel_verbunden == 1 and am_kreisel ==2: am_kreisel == 1 - drehung_2 = drehung0 drehung0 = drehung1 drehung1= drehung_2 @@ -584,7 +548,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v hight_position = "lower" else: hight_position = "higher" - else: if richtung2 == "Vertikal": if x0_kreisel < x1_kreisel: @@ -609,7 +572,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v gefaelle = "unten" # austausch der werte damit immer davon ausgehen dass der 1 kreisel in unserer Liste am Kreisel verbuden ist if am_kreisel == 2: - am_kreisel = 1 drehung_2 = drehung0 drehung0 = drehung1 @@ -619,7 +581,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v else: hight_position = "higher" - if gefaelle == "oben": rotation = 0 elif gefaelle == "unten" : @@ -629,7 +590,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v elif gefaelle == "rechts" : rotation = 270 - #geben der richtung2 eines wertes außer default wenn beide kreisel die gleiche richung haben if (kreisel_verbunden == 1 and richtung2 =="DEFAULT"): richtung2 = richtung0 @@ -641,7 +601,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2,drehung0, drehung1, laenge, hight_position,blockname) blockref_layer = get_layer(doc, lib_doc, blockname) - bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer }) a = bref.add_attrib( tag= "NAME", @@ -656,7 +615,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v laenge = float(laenge_m) * 1000 # Meter → mm except ValueError: laenge = 10000 - winkel = math.radians(float(merkmale.get("Drehung"))) halbe_laenge = laenge / 2 dx = halbe_laenge *math.sin(winkel * -1) @@ -709,14 +667,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Vorbereitung der Werte voerder_richtung = merkmale.get("Förderrichtung") winkel = int(merkmale.get("Winkel")) - erster_kreisel_höher = False ein_kreisel_höher = False richtung2 ="DEFAULT" asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset")) esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset")) rotation = float(merkmale.get("Drehung")) - upper_hoehe_vario= float(merkmale.get("Höhe Ende")) *1000 lower_hoehe_vario = float(merkmale.get("Höhe Anfang")) *1000 @@ -728,8 +684,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Korrektur der rotation mit der Umstellung der Höhe rotation = rotation -180 - - hoehe_vario= (upper_hoehe_vario + lower_hoehe_vario)/2 # Hollen der Information der Nachbarn strukturen ob diese Kreisel sind for nachbarn in strecken_nachbarn: @@ -737,7 +691,6 @@ 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 - # 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 @@ -746,7 +699,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3 winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) - blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°") att_vorne =import_block(blockname,lib_doc,doc) SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"])) @@ -756,7 +708,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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")) @@ -767,7 +718,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Ausrechnung des Offsets winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) - elif float(gefaellestrecke_vario.get("h1")) == 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 @@ -784,7 +734,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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")) @@ -795,7 +744,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # 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 @@ -827,7 +775,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Ausrechnung des Offsets winkel_VP_offset_vorne = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3)) - elif float(gefaellestrecke_vario.get("h1_2")) == upper_hoehe_vario: if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf" or gefaellestrecke_vario.get("Foerderrichtung_2") == "Horizontal"): # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte @@ -839,13 +786,10 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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"])) @@ -853,7 +797,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Ausrechnung des Offsets winkel_VP_offset_hinten = ((SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten))), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten)) - # Für spätere berechnung schauen ob der erste Kreis in der Liste höher ist if upper_hoehe_vario == gefaellestrecke_vario.get("Hoehe0"): ein_kreisel_höher = True @@ -866,13 +809,11 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve dx = halbe_laenge * math.sin(-1 *richtung_rad) dy = halbe_laenge * math.cos(richtung_rad) drehung0 = gefaellestrecke_vario.get("Drehung0") - abstand0 = float(gefaellestrecke_vario.get("abstand0")) * 1000 x0_kreisel = float(gefaellestrecke_vario.get("x0")) y0_kreisel = float(gefaellestrecke_vario.get("y0")) richtung0 = float(gefaellestrecke_vario.get("rotation0")) richtung_rad0= math.radians(richtung0) - # Herausfinden ob der Förderere direkt mit dem Kreisel verbunden ist, die Werte für den Zweiten Kreisel wird auf None gesetzt weil diese nicht existieren am_kreisel,kreseil_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_vario, lower_hoehe_vario, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None ) if am_kreisel == 1: @@ -906,7 +847,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario) start = m - line = Line.new(dxfattribs={"start": l,"end":m }) line.dxf.layer = "6-SP" copy= line.copy() @@ -1029,7 +969,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario ) start = m - line = Line.new(dxfattribs={"start": l,"end":m }) line.dxf.layer = "6-SP" copy= line.copy() @@ -1139,8 +1078,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) - - # Falls es nicht mit dem Kreisel direkt verbunden ist else: # Erstellung der blockname für wenn die Motorstation rechts und links @@ -1188,13 +1125,9 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block = doc.blocks.new(blockname, base_point=(0,0,0)) - # Erstellung von start und ende start = (x,y +dy, upper_hoehe_vario) ende = (x ,y -dy, lower_hoehe_vario) - - - # 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 ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # Reintuen des endblockes in den Modelspace @@ -1203,11 +1136,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve if merkmale.get("Motorseite")== "rechts": 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,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 = bool(merkmale.get("hatMotor")) @@ -1226,8 +1154,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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": # erstellung des gefälles falls es nicht null ist (also keins angegeben ist oder es durch andere Sachen wie Motor ersetzt wird) @@ -1311,25 +1237,19 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # 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) - + 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) @@ -1361,14 +1281,11 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy) #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_51,(x,y,0)) # msp.add_line((x+1000,y + 50,0),(x-1000,y +50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_51_attrib) - - elif winkel == 36: # Einfügen der 39 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_39 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_39_auf")) @@ -1384,7 +1301,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_39_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_39_attrib["DELTA_VP_1"])) Vario_Bogen_ab_39_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_39_attrib["DELTA_VP_0"])) - Vario_Bogen_auf_39_Delta_SP_0 = [Vario_Bogen_auf_39_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_39_Delta_SP_0[1],-Vario_Bogen_auf_39_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_0[2] * math.cos(math.radians(3)) ] Vario_Bogen_auf_39_Delta_SP_1 = [Vario_Bogen_auf_39_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_39_Delta_SP_1[1],-Vario_Bogen_auf_39_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_39_Delta_SP_1[2] * math.cos(math.radians(3)) ] Vario_Bogen_ab_39_Delta_SP_0 = [Vario_Bogen_ab_39_Delta_SP_0 [0] * math.cos(math.radians(-36))+ Vario_Bogen_ab_39_Delta_SP_0[2]* math.sin(math.radians(-36)) ,Vario_Bogen_ab_39_Delta_SP_0[1],-Vario_Bogen_ab_39_Delta_SP_0[0] * math.sin(math.radians(-36))+ Vario_Bogen_ab_39_Delta_SP_0[2] * math.cos(math.radians(-36)) ] @@ -1396,30 +1312,23 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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}) @@ -1441,22 +1350,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) - #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_39,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_39_attrib) - - elif winkel == 24: # Einfügen der 27 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_27 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_27_auf")) @@ -1472,7 +1375,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_27_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_VP_1"])) Vario_Bogen_ab_27_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_VP_0"])) - Vario_Bogen_auf_27_Delta_SP_0 = [Vario_Bogen_auf_27_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_0[1],-Vario_Bogen_auf_27_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2] * math.cos(math.radians(3)) ] Vario_Bogen_auf_27_Delta_SP_1 = [Vario_Bogen_auf_27_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_1[1],-Vario_Bogen_auf_27_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2] * math.cos(math.radians(3)) ] Vario_Bogen_ab_27_Delta_SP_0 = [Vario_Bogen_ab_27_Delta_SP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_0[1],-Vario_Bogen_ab_27_Delta_SP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2] * math.cos(math.radians(-24)) ] @@ -1481,34 +1383,25 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_ab_27_Delta_VP_0 = [Vario_Bogen_ab_27_Delta_VP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_VP_0[1],-Vario_Bogen_ab_27_Delta_VP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2] * math.cos(math.radians(-24)) ] # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0): if i< 2 and wert< 0: Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1): if i< 2 and wert< 0: Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0): if i< 2 and wert< 0: Vario_Bogen_ab_27_Delta_VP_0[i] = abs(wert) - - #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie block.add_blockref(block_Vario_Bogen_auf_27,(ende[0] -x ,ende[1] +Vario_Bogen_auf_27_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_27_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) @@ -1538,14 +1431,11 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy) #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_27_attrib) - - elif winkel == 15: # Einfügen der 18 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_18 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_18_auf")) @@ -1572,29 +1462,22 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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]) @@ -1624,14 +1507,11 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy) #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_18,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_18_attrib) - - elif winkel == 12: # Einfügen der 15 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block @@ -1648,7 +1528,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_15_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_15_attrib["DELTA_VP_1"])) Vario_Bogen_ab_15_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_15_attrib["DELTA_VP_0"])) - Vario_Bogen_auf_15_Delta_SP_0 = [Vario_Bogen_auf_15_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_15_Delta_SP_0[1],-Vario_Bogen_auf_15_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_0[2] * math.cos(math.radians(3)) ] Vario_Bogen_auf_15_Delta_SP_1 = [Vario_Bogen_auf_15_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_15_Delta_SP_1[1],-Vario_Bogen_auf_15_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_15_Delta_SP_1[2] * math.cos(math.radians(3)) ] Vario_Bogen_ab_15_Delta_SP_0 = [Vario_Bogen_ab_15_Delta_SP_0 [0] * math.cos(math.radians(-12))+ Vario_Bogen_ab_15_Delta_SP_0[2]* math.sin(math.radians(-12)) ,Vario_Bogen_ab_15_Delta_SP_0[1],-Vario_Bogen_ab_15_Delta_SP_0[0] * math.sin(math.radians(-12))+ Vario_Bogen_ab_15_Delta_SP_0[2] * math.cos(math.radians(-12)) ] @@ -1657,28 +1536,21 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_ab_15_Delta_VP_0 = [Vario_Bogen_ab_15_Delta_VP_0 [0] * math.cos(math.radians(-12))+ Vario_Bogen_ab_15_Delta_VP_0[2]* math.sin(math.radians(-12)) ,Vario_Bogen_ab_15_Delta_VP_0[1],-Vario_Bogen_ab_15_Delta_VP_0[0] * math.sin(math.radians(-12))+ Vario_Bogen_ab_15_Delta_VP_0[2] * math.cos(math.radians(-12)) ] # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - for i, wert in enumerate(Vario_Bogen_auf_15_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_15_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_15_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_auf_15_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_15_Delta_SP_0): if i< 2 and wert< 0: Vario_Bogen_ab_15_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_15_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_ab_15_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_15_Delta_VP_1): if i< 2 and wert< 0: - Vario_Bogen_auf_15_Delta_VP_1[i] = abs(wert) - + 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) @@ -1691,7 +1563,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var #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] @@ -1701,7 +1572,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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}) @@ -1713,18 +1583,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy) #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_auf_15,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, auf_15_attrib) - - - elif winkel == 9: # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf")) block_Vario_Bogen_ab_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_ab")) auf_12_attrib =import_block(block_Vario_Bogen_auf_12, lib_doc, doc) @@ -1738,7 +1603,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_12_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_12_attrib["DELTA_VP_1"])) Vario_Bogen_ab_12_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_VP_0"])) - Vario_Bogen_auf_12_Delta_SP_0 = [Vario_Bogen_auf_12_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_12_Delta_SP_0[1],-Vario_Bogen_auf_12_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_0[2] * math.cos(math.radians(3)) ] Vario_Bogen_auf_12_Delta_SP_1 = [Vario_Bogen_auf_12_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_12_Delta_SP_1[1],-Vario_Bogen_auf_12_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_12_Delta_SP_1[2] * math.cos(math.radians(3)) ] Vario_Bogen_ab_12_Delta_SP_0 = [Vario_Bogen_ab_12_Delta_SP_0 [0] * math.cos(math.radians(-9))+ Vario_Bogen_ab_12_Delta_SP_0[2]* math.sin(math.radians(-9)) ,Vario_Bogen_ab_12_Delta_SP_0[1],-Vario_Bogen_ab_12_Delta_SP_0[0] * math.sin(math.radians(-9))+ Vario_Bogen_ab_12_Delta_SP_0[2] * math.cos(math.radians(-9)) ] @@ -1750,31 +1614,24 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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) - + 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]) @@ -1786,7 +1643,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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" @@ -1812,7 +1668,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # add_attributes_to_block(a, ab_12_attrib) elif winkel == 3: # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - block_Vario_Bogen_auf_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf")) block_Vario_Bogen_ab_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_ab")) ab_6_attrib =import_block( block_Vario_Bogen_ab_6 , lib_doc, doc) @@ -1825,8 +1680,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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)) ] @@ -1837,25 +1691,19 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # 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) @@ -1878,7 +1726,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) @@ -1892,7 +1739,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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)) @@ -1913,7 +1759,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_3_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_VP_1"])) Vario_Bogen_ab_3_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_VP_0"])) - Vario_Bogen_auf_3_Delta_SP_0 = [Vario_Bogen_auf_3_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_0[1],-Vario_Bogen_auf_3_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2] * math.cos(math.radians(3)) ] Vario_Bogen_auf_3_Delta_SP_1 = [Vario_Bogen_auf_3_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_1[1],-Vario_Bogen_auf_3_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2] * math.cos(math.radians(3)) ] Vario_Bogen_ab_3_Delta_SP_0 = [Vario_Bogen_ab_3_Delta_SP_0 [0] ,Vario_Bogen_ab_3_Delta_SP_0[1],Vario_Bogen_ab_3_Delta_SP_0[2] ] @@ -1925,25 +1770,19 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var for i, wert in enumerate(Vario_Bogen_auf_3_Delta_SP_0): if i< 2 and wert < 0: - 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) @@ -1977,13 +1816,11 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy) #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_Bogen_ab_3,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_3_attrib) - elif voerder_richtung == "Ab": # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird @@ -2069,38 +1906,30 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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_Bogen_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_45_Delta_VP_1[1],start[1]- Vario_Bogen_ab_45_Delta_VP_1[0]- Vario_Bogen_ab_45_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_45_Delta_VP_1[2]-Vario_Bogen_ab_45_Delta_SP_0[2] 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_Bogen_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_45_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_45_Delta_VP_0[0]+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_45_Delta_VP_0[2]- Vario_Bogen_auf_45_Delta_SP_1[2]) ende = (ende[0],ende[1]+ Vario_Bogen_auf_45_Delta_SP_1[0]+ Vario_Bogen_auf_45_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_45_Delta_SP_1[2]+ Vario_Bogen_auf_45_Delta_SP_0[2]) @@ -2121,9 +1950,7 @@ 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)) @@ -2156,25 +1983,19 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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) - + 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) @@ -2215,7 +2036,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var # add_attributes_to_block(a, ab_33_attrib) elif winkel == 24: # Einfügen der 21 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - block_Vario_Bogen_auf_21 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_auf")) block_Vario_Bogen_ab_21 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_ab")) ab_21_attrib =import_block(block_Vario_Bogen_ab_21, lib_doc, doc) @@ -2237,28 +2057,21 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_ab_21_Delta_VP_1 = [Vario_Bogen_ab_21_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_21_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_21_Delta_VP_1[1],-Vario_Bogen_ab_21_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_21_Delta_VP_1[2] * math.cos(math.radians(3)) ] # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - for i, wert in enumerate(Vario_Bogen_auf_21_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_21_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_21_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_auf_21_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_21_Delta_SP_0): if i< 2 and wert< 0: Vario_Bogen_ab_21_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_21_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_ab_21_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_21_Delta_VP_0): if i< 2 and wert< 0: - Vario_Bogen_auf_21_Delta_VP_0[i] = abs(wert) - + 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) @@ -2293,14 +2106,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_entity(copy) #Hilfmethode zur ausmessen der bogen - # a = msp.add_blockref(block_Vario_ab_21,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_21_attrib) elif winkel == 15: # Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf")) block_Vario_Bogen_ab_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_ab")) ab_12_attrib =import_block(block_Vario_Bogen_ab_12, lib_doc, doc) @@ -2322,38 +2133,28 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_ab_12_Delta_VP_1 = [Vario_Bogen_ab_12_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_12_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_12_Delta_VP_1[1],-Vario_Bogen_ab_12_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_12_Delta_VP_1[2] * math.cos(math.radians(3)) ] # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_12_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_auf_12_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_0): if i< 2 and wert< 0: Vario_Bogen_ab_12_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_SP_1): if i< 2 and wert< 0: Vario_Bogen_ab_12_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_12_Delta_VP_0): if i< 2 and wert< 0: Vario_Bogen_auf_12_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_12_Delta_VP_1): if i< 2 and wert< 0: Vario_Bogen_ab_12_Delta_VP_1[i] = abs(wert) - #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie - block.add_blockref(block_Vario_Bogen_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270}) start_VP = start[0] -Vario_Bogen_ab_12_Delta_VP_1[1],start[1]- Vario_Bogen_ab_12_Delta_VP_1[0]- Vario_Bogen_ab_12_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_12_Delta_VP_1[2]-Vario_Bogen_ab_12_Delta_SP_0[2] - start =(start[0], start[1]- Vario_Bogen_ab_12_Delta_SP_0[0]- Vario_Bogen_ab_12_Delta_SP_1[0],start[2]-Vario_Bogen_ab_12_Delta_SP_0[2]+Vario_Bogen_ab_12_Delta_SP_1[2]) #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie @@ -2361,11 +2162,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_blockref(block_Vario_Bogen_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_12_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_12_Delta_VP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_VP_0[2]- Vario_Bogen_auf_12_Delta_SP_1[2]) - ende = (ende[0],ende[1]+ Vario_Bogen_auf_12_Delta_SP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_SP_0[2]- Vario_Bogen_auf_12_Delta_SP_1[2]) - # Erstellung der VARIO Line - line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() @@ -2373,20 +2171,16 @@ 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_12,(x,y,0)) # msp.add_line((x+1000,y +50,0),(x-1000,y+50,0)) # msp.add_line((x,y+1000,0),(x,y-1000,0)) # add_attributes_to_block(a, ab_12_attrib) - elif winkel == 12: # Einfügen der 9 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block block_Vario_Bogen_auf_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_auf")) @@ -2410,37 +2204,28 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_ab_9_Delta_VP_1 = [Vario_Bogen_ab_9_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_9_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_9_Delta_VP_1[1],-Vario_Bogen_ab_9_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_9_Delta_VP_1[2] * math.cos(math.radians(3)) ] # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - for i, wert in enumerate(Vario_Bogen_auf_9_Delta_SP_0): if i< 2 and wert < 0: - Vario_Bogen_auf_9_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_9_Delta_SP_1): if i< 2 and wert< 0: - Vario_Bogen_auf_9_Delta_SP_1[i] = abs(wert) - + 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) - + Vario_Bogen_auf_9_Delta_VP_0[i] = abs(wert) for i, wert in enumerate(Vario_Bogen_ab_9_Delta_VP_1): if i< 2 and wert< 0: Vario_Bogen_ab_9_Delta_VP_1[i] = abs(wert) - #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - start_VP = start[0] -Vario_Bogen_ab_9_Delta_VP_1[1],start[1]- Vario_Bogen_ab_9_Delta_VP_1[0]- Vario_Bogen_ab_9_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_9_Delta_VP_1[2]-Vario_Bogen_ab_9_Delta_SP_0[2] start =(start[0], start[1]- Vario_Bogen_ab_9_Delta_SP_0[0]- Vario_Bogen_ab_9_Delta_SP_1[0],start[2]-Vario_Bogen_ab_9_Delta_SP_0[2]+Vario_Bogen_ab_9_Delta_SP_1[2]) @@ -2448,20 +2233,16 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var block.add_blockref(block_Vario_Bogen_auf_9 , (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270}) ende_VP = (ende[0] -Vario_Bogen_auf_9_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_9_Delta_VP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_VP_0[2]-Vario_Bogen_auf_9_Delta_SP_1[2]) - ende = (ende[0],ende[1]+ Vario_Bogen_auf_9_Delta_SP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_SP_0[2]- Vario_Bogen_auf_9_Delta_SP_1[2]) # Erstellung der VARIO Line - line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) line_VP.dxf.layer = "VARIO" copy_VP = line_VP.copy() - copy_VP.translate(-x,-y,-hoehe_vario) block.add_entity(copy_VP) # Erstellung der zwischen Line - line = Line.new(dxfattribs={"start":start,"end":ende }) line.dxf.layer = "6-SP" copy = line.copy() @@ -2469,14 +2250,11 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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)) # add_attributes_to_block(a, ab_9_attrib) - - elif winkel == 9: # Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block @@ -2493,7 +2271,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var Vario_Bogen_auf_6_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_VP_0"])) Vario_Bogen_ab_6_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_VP_1"])) - Vario_Bogen_auf_6_Delta_SP_0 = [Vario_Bogen_auf_6_Delta_SP_0 [0] * math.cos(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_0[2]* math.sin(math.radians(9)) ,Vario_Bogen_auf_6_Delta_SP_0[1],-Vario_Bogen_auf_6_Delta_SP_0[0] * math.sin(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_0[2] * math.cos(math.radians(9)) ] Vario_Bogen_auf_6_Delta_SP_1 = [Vario_Bogen_auf_6_Delta_SP_1 [0] * math.cos(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_1[2]* math.sin(math.radians(9)) ,Vario_Bogen_auf_6_Delta_SP_1[1],-Vario_Bogen_auf_6_Delta_SP_1[0] * math.sin(math.radians(9))+ Vario_Bogen_auf_6_Delta_SP_1[2] * math.cos(math.radians(9)) ] Vario_Bogen_ab_6_Delta_SP_0 = [Vario_Bogen_ab_6_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_ab_6_Delta_SP_0[1],-Vario_Bogen_ab_6_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_6_Delta_SP_0[2] * math.cos(math.radians(3)) ] @@ -2505,29 +2282,22 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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) - + Vario_Bogen_auf_6_Delta_VP_0[i] = abs(wert) for i, wert in enumerate(Vario_Bogen_ab_6_Delta_VP_1): if i< 2 and wert< 0: Vario_Bogen_ab_6_Delta_VP_1[i] = abs(wert) - #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie block.add_blockref(block_Vario_Bogen_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270}) @@ -2557,7 +2327,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var 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)) @@ -2577,7 +2346,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - # 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)) @@ -2596,7 +2364,6 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var clone.transform(matrix) block_links.add_entity(clone) - def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): """ Für Omniflo Gerade: zeichnet eine Linie (Mitte = Koordinate, Länge und Winkel aus Merkmale). @@ -2626,7 +2393,6 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, linie=msp.add_line(start, ende) linie.dxf.layer = "A-2" - if verbose: print(f"[INFO] Omniflo Gerade → {teileid} Linie von ({start[0]:.1f}, {start[1]:.1f}) nach ({ende[0]:.1f}, {ende[1]:.1f})") return @@ -2643,26 +2409,13 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, return blockname = blockname drehung = merkmale.get("Drehung") - - import_block(blockname, lib_doc, doc) # blockref_layer = get_layer(doc, lib_doc, blockname) symblos_layers = config_allgemein.get("dxf2lib","automation_layer") - drehung = merkmale.get("Drehung") - bref = msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"rotation": drehung}) # Layer, auf dem der Insert liegt - - - - - - - - - def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge,blockname, hight = None, block_vario = None, vario_richtung = None, verbungden_höher = None): halbe_laenge = laenge / 2 @@ -2677,7 +2430,6 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff if vario_richtung == "Auf": start = (x , y + dy ,upper_hoehe_gefaehlle) ende = (x , y - dy + asoffset ,lower_hoehe_gefaehlle) - block_vario.add_blockref(block_as,(ende[0]-x ,ende[1]-asoffset -y,ende[2] -hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start, ende elif vario_richtung == "Ab": @@ -2691,15 +2443,11 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff 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)) return False else: @@ -2711,7 +2459,6 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff import_block(block_es,lib_doc,doc) if hight != None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) - if vario_richtung == "Auf": start = (x , y + dy-esoffset,upper_hoehe_gefaehlle) ende = (x , y - dy ,lower_hoehe_gefaehlle) @@ -2767,7 +2514,6 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff 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() @@ -2801,21 +2547,17 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff 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() - 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}) 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): #erstellung des blockes falls die gefaelle strecke mit einem kreisel verbunden ist, mehrere variation von selben weil diese nötig sind sobald man die richtigen inserts bekommen if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle: @@ -2832,7 +2574,6 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) halbe_laenge = laenge / 2 - dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": start = (x , y+ dy - esoffset,upper_hoehe_gefaehlle) @@ -2849,11 +2590,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" copy= line.copy() - copy.translate(-x,-y,-hoehe_gefaehlle) block.add_entity(copy) - - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset-y ,ende[2] -hoehe_gefaehlle)) elif ((blockname not in doc.blocks and drehung0 == "GUZS" and drehung1 == "GUZS") or (am_kreisel != None and drehung0 == "GUZS" and drehung1 == "GUZS")): @@ -2862,8 +2600,8 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh halbe_laenge = laenge / 2 block_as = "200000241_AS-Element_90_rechts" import_block(block_as,lib_doc,doc) - dy = halbe_laenge * math.cos(0) + if voerder_richtung == "Auf": start = (x , y1 ,z1) ende = (x , y - dy + asoffset,lower_hoehe_gefaehlle) @@ -2874,19 +2612,16 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh ende = (x , y1 ,z1) block_vario.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] -hoehe_gefaehlle)) return start, ende - - - + start = (x , y + dy - asoffset,upper_hoehe_gefaehlle) 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)) elif ((blockname not in doc.blocks and (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "higher"))or (voerder_richtung == "Auf" and((am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True))and (drehung0 == "UZS" and drehung1 == "GUZS")) or @@ -2964,7 +2699,6 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh import_block(block_es,lib_doc,doc) dy = halbe_laenge * math.cos(0) if voerder_richtung == "Auf": - start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) ende = (x , y1,z1) block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset -y,start[2] - hoehe_gefaehlle)) @@ -2975,30 +2709,26 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start, ende - - start = (x , y + dy ,upper_hoehe_gefaehlle) ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" copy= line.copy() - copy.translate(-x ,-y,-hoehe_gefaehlle) - block.add_entity(copy) + block.add_entity(copy) block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) elif (((blockname not in doc.blocks and drehung0 == "UZS" and drehung1 == "UZS")or - (am_kreisel!= None and drehung0 == "UZS" and drehung1 == "UZS"))): - + (am_kreisel!= None and drehung0 == "UZS" and drehung1 == "UZS"))): block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) halbe_laenge = laenge / 2 - dy = halbe_laenge * math.cos(0) + if voerder_richtung == "Auf": start = (x , y1,z1) ende = (x , y - dy + asoffset,lower_hoehe_gefaehlle) @@ -3016,14 +2746,10 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line.dxf.layer = "6-SP" copy= line.copy() - copy.translate(-x ,-y,-hoehe_gefaehlle) block.add_entity(copy) - - 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 ((drehung0 == "UZS" and drehung1 == "GUZS" and hight_position== "higher"))or (voerder_richtung == "Auf"and ((am_kreisel == 1 and erster_kreisel_höher == False) or (am_kreisel ==2 and erster_kreisel_höher ==True))and (drehung0 == "GUZS" and drehung1 == "UZS")) or (voerder_richtung == "Ab" and((am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False))and (drehung0 == "UZS" and drehung1 == "GUZS"))): @@ -3032,15 +2758,14 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh if am_kreisel == None: block = doc.blocks.new(name=blockname, base_point=(0,0,0)) halbe_laenge = laenge / 2 - dy = halbe_laenge * math.cos(0) + if voerder_richtung == "Auf": start = (x , y + dy - esoffset,upper_hoehe_gefaehlle) ende = (x , y1 ,z1) block_vario.add_blockref(block_es, (start[0]-x ,start[1]+esoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) return start, ende elif voerder_richtung == "Ab": - start = (x , y1,z1) ende = (x , y - dy + esoffset,lower_hoehe_gefaehlle) block_vario.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle)) @@ -3051,14 +2776,10 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line = Line.new(dxfattribs={"start": start, "end": ende}) line.dxf.layer = "6-SP" - copy= line.copy() - copy.translate(-x ,-y,-hoehe_gefaehlle) + block.add_entity(copy) - - - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle)) elif (blockname not in doc.blocks and (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "lower")or (voerder_richtung == "Auf"and((am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False))and (drehung0 == "GUZS" and drehung1 == "UZS")) or @@ -3087,11 +2808,9 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line.dxf.layer = "6-SP" copy= line.copy() - copy.translate(-x ,-y,-hoehe_gefaehlle) + block.add_entity(copy) - - block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) #erstellung von den normalen gefällestrecken else: @@ -3171,7 +2890,6 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle)) block.add_blockref(block_es, (ende[0]-x ,ende[1]- esoffset-y,ende[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) - elif ((blockname not in doc.blocks and drehung0 == "UZS" and drehung1 == "UZS") or (voerder_richtung != None and drehung0 == "UZS" and drehung1 == "UZS")): block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) @@ -3201,21 +2919,16 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh line.dxf.layer = "6-SP" copy= line.copy() - copy.translate(-x ,-y,-hoehe_gefaehlle) + block.add_entity(copy) - - block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle) ,dxfattribs={"rotation": 180}) - elif ((blockname not in doc.blocks and ((drehung0 == "UZS" and drehung1 == "GUZS" and hight_position== "higher")or (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "lower")))or (voerder_richtung == "Auf" and drehung0 == "GUZS" and drehung1 == "UZS") or (voerder_richtung == "Ab" and drehung0 == "UZS"and drehung1 == "GUZS")) : - block_as = "200000217_AS-Element_90_links" import_block(block_as,lib_doc,doc) block_es = "200000146_ES-Element_90_rechts" @@ -3248,11 +2961,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, asoffset, esoffset, upper_hoeh copy.translate(-x ,-y,-hoehe_gefaehlle) block.add_entity(copy) - - - block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180}) - block.add_blockref(block_es, (ende[0]-x ,ende[1]-esoffset -y,ende[2] - hoehe_gefaehlle)) def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, x1_kreisel, y1_kreisel, richtung_rad1, abstand1,kreisel_verbunden= None, richtung0 = None, richtung1 = None, richtung2 = None): if kreisel_verbunden == None: @@ -3275,7 +2984,6 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl pos1_0_round = (round(x1_kreisel + dx1), round(y1_kreisel + dy1)) pos1_1_round = (round(x1_kreisel - dx1), round(y1_kreisel - dy1)) - # berechnung der geraden einmal abgerunden und einmal gerunden zur negirung des offsets start_floor = (math.floor(x +dx ), math.floor(y + dy ),upper_hoehe_gefaehlle) ende_floor = (math.floor(x -dx), math.floor(y - dy ) ,lower_hoehe_gefaehlle) @@ -3319,8 +3027,6 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl (abstand_gegen_kreis_ende_y_round == pos0_0_round) or (abstand_gegen_kreis_ende_y_round == pos0_1_round) or - - (abstand_fuer_kreis_start_y_floor == pos1_0_floor) or (abstand_fuer_kreis_start_y_floor == pos1_1_floor) or (abstand_gegen_kreis_start_y_floor == pos1_0_floor) or @@ -3388,8 +3094,6 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl if (x1_kreisel == None): return am_kreisel,kreisel_verbunden - - if( (abstand_fuer_kreis_start_x_floor == pos1_0_floor )or (abstand_fuer_kreis_start_x_floor == pos1_1_floor) or (abstand_gegen_kreis_start_x_floor == pos1_0_floor) or @@ -3482,7 +3186,6 @@ def get_libfile_cfg(teileart, cfg_path): return parser.get(section, "libfile", fallback=None) return None - def get_rotations_of_strecken(csv_path:Path) -> dict: geraden = [] kreisel =[] @@ -3520,10 +3223,6 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: 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 @@ -3562,16 +3261,11 @@ def get_rotations_of_strecken(csv_path:Path) -> dict: eintrag["h1_2"] = vario_gerade.get("h1") eintrag["Foerderrichtung_2"] = vario_gerade.get("Foerderrichtung") break - - strecken_nachbarn.append(eintrag) return strecken_nachbarn - - - # --------------------------------------------------------- Hauptfunktion def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Path, output_path: Path, verbose=False, logger=None): @@ -3619,7 +3313,6 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat # Verarbeitung der Blöcke - with csv_path.open(newline="", encoding="utf-8") as fh: reader = csv.DictReader(fh, delimiter=';') for row in reader: @@ -3629,8 +3322,6 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat planquadrat = row["Planquadrat"] merkmale = parse_merkmale(row.get("Merkmale", "")) merkmale["bezeichner"] = bezeichner - - try: x_screen, y_screen = extract_coords(planquadrat) x, y = transform_coords(x_screen, y_screen, height) @@ -3680,21 +3371,21 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat else: print(msg) continue + # for insert in msp.query("INSERT"): + # name = insert.dxf.name # Name des referenzierten Blocks + # position = insert.dxf.insert + # if name == "834372115": + # symbol_att = import_block("834372115_symbol",lib_doc,doc) + # block = doc.blocks["834372115_symbol"] + # for e in block: + # if e.dxftype() != "INSERT": + # block.delete_entity(e) + # att =msp.add_blockref("834372115_symbol",(position[0],position[1],position[2])) # Einfügepunkt (x, y, z) + + # rotation = insert.dxf.rotation # Drehung in Grad (optional) + # layer = insert.dxf.layer # DXF speichern - for insert in msp.query("INSERT"): - name = insert.dxf.name # Name des referenzierten Blocks - position = insert.dxf.insert - if name == "834372115": - symbol_att = import_block("834372115_symbol",lib_doc,doc) - block = doc.blocks["834372115_symbol"] - for e in block: - if e.dxftype() != "INSERT": - block.delete_entity(e) - att =msp.add_blockref("834372115_symbol",(position[0],position[1],position[2])) # Einfügepunkt (x, y, z) - - rotation = insert.dxf.rotation # Drehung in Grad (optional) - layer = insert.dxf.layer doc.saveas(output_path) if logger: logger.info(f"[DONE] DXF gespeichert unter: {output_path}") @@ -3752,7 +3443,5 @@ if __name__ == "__main__": allgemein_cfg_path = config_dir / "allgemein.cfg" default_lib_path = Path(args.lib) if args.lib else data_dir / "blocks.dxf" output_path = Path(args.output) if args.output else (work_dir / f"{csv_path.stem}.dxf") - main(csv_path, default_lib_path, cfg_path,allgemein_cfg_path, output_path, verbose=args.verbose, logger=logger) - logger.info("=== plant2dxf Verarbeitung abgeschlossen ===") - + logger.info("=== plant2dxf Verarbeitung abgeschlossen ===") \ No newline at end of file