From 0680bad028b14e7c917f5c8a64927e0fc0710c7c Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Wed, 3 Dec 2025 10:23:17 +0100 Subject: [PATCH] Refactoring vom foerderer --- cfg/shapes.cfg | 2 +- lib/plant2dxf.py | 1167 +++++++++++++++++++++++----------------------- 2 files changed, 582 insertions(+), 587 deletions(-) diff --git a/cfg/shapes.cfg b/cfg/shapes.cfg index 160febf..6752496 100644 --- a/cfg/shapes.cfg +++ b/cfg/shapes.cfg @@ -30,7 +30,7 @@ vario_abstand = 66.5 bogen_3_auf = Vario_Bogen_auf_3° bogen_3_ab = Vario_Bogen_ab_3° [Ils 2.0 core winkel] -winkel_boegen = 3.0 +winkel_boegen = 3 winkel_motor = 3.0 winkel_umlenk = 3.0 winkel_as = 3.0 diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index 467e4f9..b118218 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -139,7 +139,6 @@ class Kreisel(BaseModel): dx = self.halbabstand * math.cos(self.winkel_rad) dy = self.halbabstand * math.sin(self.winkel_rad) return (self.x + dx, self.y + dy, self.hoehe) - return (self.x + dx, self.y + dy, self.hoehe) @property def z(self) -> float: @@ -188,6 +187,557 @@ class Kreisel(BaseModel): anzahl_scanner=anzahl_scanner, anzahl_separatoren=anzahl_separatoren ) + + def draw_kreisel_lines(msp, pos1, pos2, kreisel): + """Zeichnet tangentiale Linien zwischen zwei Kreiselblöcken, unabhängig vom Winkel.""" + rotation = kreisel.drehung + x1, y1, z1 = pos1 + x2, y2, z1 = pos2 + # Verbindungsvektor + dx = x2 - x1 + dy = y2 - y1 + # Länge + length = math.hypot(dx, dy) + if length == 0: + return # keine Linie bei identischen Punkten + # Normalenvektor (senkrecht, normiert, Länge = RADIUS) + + nx = -dy / length * RADIUS + ny = dx / length * RADIUS + # Tangentialpunkte + p1a = (x1 + nx, y1 + ny,z1) + p1b = (x1 - nx, y1 - ny,z1) + p2a = (x2 + nx, y2 + ny,z1) + p2b = (x2 - nx, y2 - ny,z1) + if kreisel.kreiselart == "Pin": + if rotation == 0.0: + p1a2 = p1a[0] - RADIUS - 50, p1a[1] + 50, z1 + p1b2 = p1b[0] - RADIUS - 50, p1b[1] - 50, z1 + p2a2 = p2a[0] + RADIUS + 50, p2a[1] + 50, z1 + p2b2 = p2b[0] + RADIUS + 50, p2b[1] - 50, z1 + Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) + Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) + msp.add_entity(Line1) + msp.add_entity(Line2) + elif rotation == 180.0: + p1a2 = p1a[0] + RADIUS + 50, p1a[1] - 50, z1 + p1b2 = p1b[0] + RADIUS + 50, p1b[1] + 50, z1 + p2a2 = p2a[0] - RADIUS - 50, p2a[1] - 50, z1 + p2b2 = p2b[0] - RADIUS - 50, p2b[1] + 50, z1 + Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) + Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) + msp.add_entity(Line1) + msp.add_entity(Line2) + elif rotation == 90.0: + p1a2 = p1a[0] + 50, p1a[1] - 50 + RADIUS , z1 + p1b2 = p1b[0] - 50, p1b[1] - 50 + RADIUS, z1 + p2a2 = p2a[0] + 50, p2a[1] + 50 - RADIUS, z1 + p2b2 = p2b[0] - 50, p2b[1] + 50 - RADIUS, z1 + Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) + Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) + msp.add_entity(Line1) + msp.add_entity(Line2) + elif rotation == 270.0: + p1a2 = p1a[0] - 50, p1a[1] + 50 - RADIUS , z1 + p1b2 = p1b[0] + 50, p1b[1] + 50 - RADIUS, z1 + p2a2 = p2a[0] - 50, p2a[1] - 50 + RADIUS, z1 + p2b2 = p2b[0] + 50, p2b[1] - 50 + RADIUS, z1 + Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) + Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) + msp.add_entity(Line1) + msp.add_entity(Line2) + + # Linien zeichnen + msp.add_line(p1a, p2a) + msp.add_line(p1b, p2b) + + def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, kreisel, lib_doc, doc, verbose): + drehrichtung = (kreisel.drehrichtung or "").upper() + if drehrichtung not in ("UZS", "GUZS"): + return + x1, y1,z1= pos1 + x2, y2,z2 = pos2 + dx = x2 - x1 + dy = y2 - y1 + length = math.hypot(dx, dy) + if length == 0: + return + # Normalenvektor (senkrecht, normiert, Länge = RADIUS) + nx = -dy / length * RADIUS + ny = dx / length * RADIUS + # Obere Linie + p1_oben = (x1 + nx, y1 + ny) + p2_oben = (x2 + nx, y2 + ny) + # Untere Linie + p1_unten = (x1 - nx, y1 - ny) + p2_unten = (x2 - nx, y2 - ny) + # S-LP auf oberer Linie (Drehrichtung wie angegeben) + for i in range(1, 4): + t = i / 4 # 1/4, 2/4, 3/4 + px = p1_oben[0] + t * (p2_oben[0] - p1_oben[0]) + py = p1_oben[1] + t * (p2_oben[1] - p1_oben[1]) + rotation = math.degrees(math.atan2(p2_oben[1] - p1_oben[1], p2_oben[0] - p1_oben[0])) + if drehrichtung == "GUZS": + rotation += 180 + import_block("Richtungspfeil", lib_doc, doc) + blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil") + bref = msp.add_blockref("Richtungspfeil", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer}) + if verbose: + print(f"[INFO] Drehrichtung '{drehrichtung}': Richtungspfeil oben bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}") + # S-LP auf unterer Linie (Drehrichtung invertiert) + for i in range(1, 4): + t = i / 4 + px = p1_unten[0] + t * (p2_unten[0] - p1_unten[0]) + py = p1_unten[1] + t * (p2_unten[1] - p1_unten[1]) + rotation = math.degrees(math.atan2(p2_unten[1] - p1_unten[1], p2_unten[0] - p1_unten[0])) + if drehrichtung == "UZS": + rotation += 180 + import_block("Richtungspfeil", lib_doc, doc) + blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil") + bref = msp.add_blockref("Richtungspfeil", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer}) + if verbose: + print(f"[INFO] Drehrichtung '{drehrichtung}':Richtungspfeil unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}") + + +class VarioFoerderer(BaseModel): + teileid: str + x: float = Field(description="X-Koordinate des Foerder-Zentrums") + y: float = Field(description="Y-Koordinate des Foerder-Zentrums") + laenge:float = Field(description = "Länge des Förderers") + winkel: float = Field(description = "Winkel des Färderers") + h0: float = Field(description="Höhe Anfang in Merkmale") + h1: float = Field(description="Höhe Ende in Merkmale") + hat_motor: bool = Field(description="Überprüft ob der Vörderer ein Motor hat") + hat_umlenk: bool = Field(description="Überprüft ob der Vörderer eine Umlenkstation hat") + drehung: float = Field(default=0.0, description="Drehung/Winkel in Grad") + foerderer_richtung : str= Field(description="In welche richtung geförderd wird") + gefaelle_laenge: Optional [float] = Field(default=0.0,description="Länge der zusätzlichen Gefälle Strecke falls vorhanden") + gefaelle_winkel: Optional [float] = Field(default=0.0,description="Winkel der Gefällestrecke, falls diese Vorhanden ist") + anzahl_scanner: float = Field(default=0.0, description="Anzahl der Scanner") + anzahl_separatoren: float = Field(default=0.0, description="Anzahl der Separatoren") + + @property + def hight_zwischen(self): + return ((self.h0 + self.h1) /2) + + + @classmethod + def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'VarioFoerderer': + + h0 = float(merkmale.get("Höhe Anfang")) * 1000 + h1 = float(merkmale.get("Höhe Ende")) * 1000 + laenge = float(merkmale.get("Länge in Meter")) * 1000 + return cls( + teileid = teileid, + laenge = laenge, + x = x, + y = y, + foerderer_richtung =merkmale.get("Förderrichtung"), + winkel = float(merkmale.get("Winkel")), + hat_motor = bool(merkmale.get("hatMotor")), + hat_umlenk = bool(merkmale.get("hatUmlenkung")), + h0 = h0, + h1 =h1, + drehung = float(merkmale.get("Drehung")), + gefaelle_laenge = float(merkmale.get("Laenge_Gefaellestrecke")), + gefalle_winkel = float(merkmale.get("Winkel_Gefaellestrecke")) + + ) + + def vario_erstellung(foerderer, doc, lib_doc, config, block, block_name_links, start, ende, voerder_richtung, winkel_VP_offset_vorne, winkel_VP_offset_hinten ): + # Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss + winkel_motor = float(config.get("Ils 2.0 core winkel","winkel_motor")) + winkel_umlenk = float(config.get("Ils 2.0 core winkel","winkel_umlenk")) + umlenk_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) + motor_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Motorstation")).split(",")) + + vario_abstand = float(config.get("ILS 2.0 Variofoerderer","vario_abstand")) + motor_vorhanden = foerderer.hat_motor + umlenk_vorhanden = foerderer.hat_umlenk + gefahellewinkel =foerderer.gefaelle_winkel + gefaelle = foerderer.gefaelle_laenge + x = foerderer.x + y = foerderer.y + hoehe_vario = foerderer.hight_zwischen + winkel = int(foerderer.winkel) + # 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) + + motor_offset_x = umlenk_laenge[0]* math.cos(math.radians(winkel_motor)) + motor_offset_z = umlenk_laenge[0]* math.sin(math.radians(winkel_motor)) + umlenk_offset_x = motor_laenge[0]* math.cos(math.radians(winkel_umlenk)) + umlenk_offset_z = motor_laenge[0]* math.sin(math.radians(winkel_umlenk)) + # Berechnung des Gefälles + if motor_vorhanden == True: + gefaelle = gefaelle - motor_offset_x + if umlenk_vorhanden == True: + gefaelle = gefaelle - umlenk_offset_x + + #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) + 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 + + 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 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) + import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc) + block_Vario_Motorstation_500mm = dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(winkel_motor)) + block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(winkel_umlenk)) + if umlenk_vorhanden == True: + block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0] -x,ende[1] -y + umlenk_offset_x/2,ende[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 90}) + ende = (ende[0] ,ende[1] + umlenk_offset_x,ende[2] - umlenk_offset_z) + if motor_vorhanden == True: + block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - motor_offset_x/2 -y ,start[2] - hoehe_vario +motor_offset_z/2),dxfattribs={"rotation": 90}) + start = start[0] , start[1] - motor_offset_x,start[2] + motor_offset_z + + if voerder_richtung== "Auf": + # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen")) + winkel_plus = winkel + winkel_core + block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_plus}°") + block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_plus}°") + + auf_attrib =import_block(block_Vario_Bogen_auf, lib_doc, doc) + ab_attrib =import_block(block_Vario_Bogen_ab, lib_doc, doc) + block_Vario_Bogen_auf = dreh_block(block_Vario_Bogen_auf, doc,math.radians(winkel_core)) + block_Vario_Bogen_ab = dreh_block(block_Vario_Bogen_ab, doc,math.radians(-winkel)) + + Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_1"])) + Vario_Bogen_ab_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_0"])) + + Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(-winkel)) ] + Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(-winkel)) ] + Vario_Bogen_auf_Delta_VP_1 = [Vario_Bogen_auf_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_VP_1[1],-Vario_Bogen_auf_Delta_VP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_ab_Delta_VP_0 = [Vario_Bogen_ab_Delta_VP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_VP_0[1],-Vario_Bogen_ab_Delta_VP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2] * math.cos(math.radians(-winkel)) ] + + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_0): + if i< 2 and wert < 0: + Vario_Bogen_auf_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_Delta_VP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_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,(ende[0] -x ,ende[1] +Vario_Bogen_auf_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) + ende_VP = (ende[0] +Vario_Bogen_auf_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_Delta_VP_1[0]+Vario_Bogen_auf_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_Delta_VP_1[2]- Vario_Bogen_auf_Delta_SP_0[2]) + ende = (ende[0] ,ende[1] +Vario_Bogen_auf_Delta_SP_1[0] + Vario_Bogen_auf_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_Delta_SP_1[2] - Vario_Bogen_auf_Delta_SP_0[2]) + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + block.add_blockref(block_Vario_Bogen_ab ,(start[0]-x,start[1] - Vario_Bogen_ab_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_Delta_SP_1[2]),dxfattribs={"rotation": 90}) + + start_VP = start[0] +Vario_Bogen_ab_Delta_VP_0[1],start[1]-Vario_Bogen_ab_Delta_VP_0[0] - Vario_Bogen_ab_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_Delta_VP_0[2] - Vario_Bogen_ab_Delta_SP_1[2] + start = start[0] ,start[1] - Vario_Bogen_ab_Delta_SP_0[0] - Vario_Bogen_ab_Delta_SP_1[0],start[2] - Vario_Bogen_ab_Delta_SP_1[2]+ Vario_Bogen_ab_Delta_SP_0[2] + + # Erstellung der VARIO Line + line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) + 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) + + else: + # Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + + block_Vario_Bogen_auf_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_auf")) + block_Vario_Bogen_ab_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_ab")) + auf_3_attrib =import_block(block_Vario_Bogen_auf_3, lib_doc, doc) + ab_3_attrib = import_block(block_Vario_Bogen_ab_3, lib_doc, doc) + block_Vario_Bogen_auf_3= dreh_block(block_Vario_Bogen_auf_3, doc,math.radians(3)) + block_Vario_Bogen_ab_3 = dreh_block(block_Vario_Bogen_ab_3, doc,math.radians(0)) + Vario_Bogen_auf_3_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_3_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_3_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_VP_1"])) + Vario_Bogen_ab_3_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_VP_0"])) + + Vario_Bogen_auf_3_Delta_SP_0 = [Vario_Bogen_auf_3_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_0[1],-Vario_Bogen_auf_3_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2] * math.cos(math.radians(3)) ] + Vario_Bogen_auf_3_Delta_SP_1 = [Vario_Bogen_auf_3_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_1[1],-Vario_Bogen_auf_3_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2] * math.cos(math.radians(3)) ] + Vario_Bogen_ab_3_Delta_SP_0 = [Vario_Bogen_ab_3_Delta_SP_0 [0] ,Vario_Bogen_ab_3_Delta_SP_0[1],Vario_Bogen_ab_3_Delta_SP_0[2] ] + Vario_Bogen_ab_3_Delta_SP_1 =[ Vario_Bogen_ab_3_Delta_SP_1 [0] ,Vario_Bogen_ab_3_Delta_SP_1[1],Vario_Bogen_ab_3_Delta_SP_1[2] ] + Vario_Bogen_auf_3_Delta_VP_1 = [Vario_Bogen_auf_3_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_VP_1[1],-Vario_Bogen_auf_3_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2] * math.cos(math.radians(3)) ] + Vario_Bogen_ab_3_Delta_VP_0 = [Vario_Bogen_ab_3_Delta_VP_0 [0],Vario_Bogen_ab_3_Delta_VP_0[1],Vario_Bogen_ab_3_Delta_VP_0[2] ] + + # 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: + 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 + if motor_vorhanden == True: + 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]) + else: + ende_VP = ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1] ,ende[1] , ende[2] + + #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie + if umlenk_vorhanden == True: + 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] + else: + start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1] , start[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) + + 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 + + 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) + import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc) + block_Vario_Motorstation_500mm = dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(winkel_motor)) + block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(winkel_umlenk)) + if umlenk_vorhanden == True: + block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0] -x,start[1] -y - umlenk_offset_x/2, start[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 270}) + start_Umlenkstation_VP = start[0] - vario_abstand, start[1] -500 *math.cos(math.radians(-winkel_umlenk))+ math.sin(math.radians(-winkel_umlenk))* -45,start[2] + math.sin(math.radians(-winkel_umlenk))*500+ math.cos(math.radians(-winkel_umlenk))*-45 + start = (start[0] ,start[1] - umlenk_offset_x,start[2] -umlenk_offset_z) + elif winkel == 3: + start_Umlenkstation_VP = start[0] - vario_abstand, 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] + motor_offset_x/2 -y ,ende[2] - hoehe_vario + motor_offset_z/2),dxfattribs={"rotation": 270}) + ende_Motor_VP = ende[0] - vario_abstand, ende[1] +500 *math.cos(math.radians(-winkel_motor))+ math.sin(math.radians(-winkel_motor))* -45,ende[2] - math.sin(math.radians(-winkel_motor))*500+ math.cos(math.radians(-winkel_motor))*-45 + + ende = ende[0] , ende[1] + motor_offset_x,ende[2] +motor_offset_z + elif winkel == 3: + ende_Motor_VP = ende[0] - vario_abstand, ende[1]+ winkel_VP_offset_hinten[0] ,ende[2] - winkel_VP_offset_vorne[2] + + if winkel != 3: + winkel_core = float(config.get("Ils 2.0 core winkel","winkel_boegen")) + winkel_minus = winkel - winkel_core + block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_minus}°") + block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_minus}°") + ab_attrib =import_block( block_Vario_Bogen_ab , lib_doc, doc) + auf_attrib =import_block( block_Vario_Bogen_auf, lib_doc, doc) + block_Vario_Bogen_ab = dreh_block( block_Vario_Bogen_ab, doc, math.radians(winkel_core)) + block_Vario_Bogen_auf= dreh_block( block_Vario_Bogen_auf, doc, math.radians(winkel)) + Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) + Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) + Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) + Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) + Vario_Bogen_auf_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_0"])) + Vario_Bogen_ab_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_1"])) + + Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel)) ] + Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel)) ] + Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] + Vario_Bogen_auf_Delta_VP_0 = [Vario_Bogen_auf_Delta_VP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_VP_0[1],-Vario_Bogen_auf_Delta_VP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2] * math.cos(math.radians(winkel)) ] + Vario_Bogen_ab_Delta_VP_1 = [Vario_Bogen_ab_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_VP_1[1],-Vario_Bogen_ab_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ] + + # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) + + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_0): + if i< 2 and wert < 0: + Vario_Bogen_auf_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0): + if i< 2 and wert< 0: + Vario_Bogen_ab_Delta_SP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_Delta_SP_1[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_0): + if i< 2 and wert< 0: + Vario_Bogen_auf_Delta_VP_0[i] = abs(wert) + for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_1): + if i< 2 and wert< 0: + Vario_Bogen_ab_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, (start[0]-x,start[1]-y- Vario_Bogen_ab_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_Delta_SP_0[2]),dxfattribs={"rotation": 270}) + start_VP = start[0] -Vario_Bogen_ab_Delta_VP_1[1],start[1]- Vario_Bogen_ab_Delta_VP_1[0]- Vario_Bogen_ab_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_Delta_VP_1[2]-Vario_Bogen_ab_Delta_SP_0[2] + + start =(start[0], start[1]- Vario_Bogen_ab_Delta_SP_0[0]- Vario_Bogen_ab_Delta_SP_1[0],start[2]-Vario_Bogen_ab_Delta_SP_0[2]+Vario_Bogen_ab_Delta_SP_1[2]) + + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie + block.add_blockref(block_Vario_Bogen_auf, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_Delta_SP_1[2]),dxfattribs={"rotation": 270}) + ende_VP = (ende[0] -Vario_Bogen_auf_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_Delta_VP_0[0]+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_Delta_VP_0[2]- Vario_Bogen_auf_Delta_SP_1[2]) + ende = (ende[0],ende[1]+ Vario_Bogen_auf_Delta_SP_1[0]+ Vario_Bogen_auf_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_Delta_SP_1[2]+ Vario_Bogen_auf_Delta_SP_0[2]) + + # Erstellung der VARIO Line + + 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) + + 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() + 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) + + # 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": + if (entity.dxf.name.startswith("400102632_ES-Element_90_links") or entity.dxf.name.startswith("200000146_ES-Element_90_rechts") or + entity.dxf.name.startswith("200000241_AS-Element_90_rechts") or entity.dxf.name.startswith("200000217_AS-Element_90_links") + ): + block_links.add_entity(clone) + else: + clone.transform(matrix) + block_links.add_entity(clone) + else: + clone.transform(matrix) + block_links.add_entity(clone) # --------------------------------------------------------- Hilfsfunktionen def extract_coords(planquadrat: str) -> tuple[float, float]: @@ -327,12 +877,6 @@ def berechne_hoehe(csv_path, logger=None): raise ValueError(msg) return max(y_werte) -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 - -def handle_ils_2_0_kreisel_mit_pin(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein): - 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): # Erstelle Kreisel-Objekt aus merkmale @@ -377,118 +921,8 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, f"({pos[0]:.1f}, {pos[1]:.1f}), rot={rotation}") # Linien zeichnen import_block("Pinbereich",lib_doc,doc) - draw_kreisel_lines(msp, pos1, pos2, kreisel) - draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, kreisel, lib_doc, doc, verbose) - -def draw_kreisel_lines(msp, pos1, pos2, kreisel: Kreisel): - """Zeichnet tangentiale Linien zwischen zwei Kreiselblöcken, unabhängig vom Winkel.""" - rotation = kreisel.drehung - x1, y1, z1 = pos1 - x2, y2, z1 = pos2 - # Verbindungsvektor - dx = x2 - x1 - dy = y2 - y1 - # Länge - length = math.hypot(dx, dy) - if length == 0: - return # keine Linie bei identischen Punkten - # Normalenvektor (senkrecht, normiert, Länge = RADIUS) - - nx = -dy / length * RADIUS - ny = dx / length * RADIUS - # Tangentialpunkte - p1a = (x1 + nx, y1 + ny,z1) - p1b = (x1 - nx, y1 - ny,z1) - p2a = (x2 + nx, y2 + ny,z1) - p2b = (x2 - nx, y2 - ny,z1) - if kreisel.kreiselart == "Pin": - if rotation == 0.0: - p1a2 = p1a[0] - RADIUS - 50, p1a[1] + 50, z1 - p1b2 = p1b[0] - RADIUS - 50, p1b[1] - 50, z1 - p2a2 = p2a[0] + RADIUS + 50, p2a[1] + 50, z1 - p2b2 = p2b[0] + RADIUS + 50, p2b[1] - 50, z1 - Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) - Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) - msp.add_entity(Line1) - msp.add_entity(Line2) - elif rotation == 180.0: - p1a2 = p1a[0] + RADIUS + 50, p1a[1] - 50, z1 - p1b2 = p1b[0] + RADIUS + 50, p1b[1] + 50, z1 - p2a2 = p2a[0] - RADIUS - 50, p2a[1] - 50, z1 - p2b2 = p2b[0] - RADIUS - 50, p2b[1] + 50, z1 - Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) - Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) - msp.add_entity(Line1) - msp.add_entity(Line2) - elif rotation == 90.0: - p1a2 = p1a[0] + 50, p1a[1] - 50 + RADIUS , z1 - p1b2 = p1b[0] - 50, p1b[1] - 50 + RADIUS, z1 - p2a2 = p2a[0] + 50, p2a[1] + 50 - RADIUS, z1 - p2b2 = p2b[0] - 50, p2b[1] + 50 - RADIUS, z1 - Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) - Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) - msp.add_entity(Line1) - msp.add_entity(Line2) - elif rotation == 270.0: - p1a2 = p1a[0] - 50, p1a[1] + 50 - RADIUS , z1 - p1b2 = p1b[0] + 50, p1b[1] + 50 - RADIUS, z1 - p2a2 = p2a[0] - 50, p2a[1] - 50 + RADIUS, z1 - p2b2 = p2b[0] + 50, p2b[1] - 50 + RADIUS, z1 - Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"}) - Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"}) - msp.add_entity(Line1) - msp.add_entity(Line2) - - # Linien zeichnen - msp.add_line(p1a, p2a) - msp.add_line(p1b, p2b) - -def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, kreisel: Kreisel, lib_doc, doc, verbose): - drehrichtung = (kreisel.drehrichtung or "").upper() - if drehrichtung not in ("UZS", "GUZS"): - return - x1, y1,z1= pos1 - x2, y2,z2 = pos2 - dx = x2 - x1 - dy = y2 - y1 - length = math.hypot(dx, dy) - if length == 0: - return - # Normalenvektor (senkrecht, normiert, Länge = RADIUS) - nx = -dy / length * RADIUS - ny = dx / length * RADIUS - # Obere Linie - p1_oben = (x1 + nx, y1 + ny) - p2_oben = (x2 + nx, y2 + ny) - # Untere Linie - p1_unten = (x1 - nx, y1 - ny) - p2_unten = (x2 - nx, y2 - ny) - # S-LP auf oberer Linie (Drehrichtung wie angegeben) - for i in range(1, 4): - t = i / 4 # 1/4, 2/4, 3/4 - px = p1_oben[0] + t * (p2_oben[0] - p1_oben[0]) - py = p1_oben[1] + t * (p2_oben[1] - p1_oben[1]) - rotation = math.degrees(math.atan2(p2_oben[1] - p1_oben[1], p2_oben[0] - p1_oben[0])) - if drehrichtung == "GUZS": - rotation += 180 - import_block("Richtungspfeil", lib_doc, doc) - blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil") - bref = msp.add_blockref("Richtungspfeil", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer}) - if verbose: - print(f"[INFO] Drehrichtung '{drehrichtung}': Richtungspfeil oben bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}") - # S-LP auf unterer Linie (Drehrichtung invertiert) - for i in range(1, 4): - t = i / 4 - px = p1_unten[0] + t * (p2_unten[0] - p1_unten[0]) - py = p1_unten[1] + t * (p2_unten[1] - p1_unten[1]) - rotation = math.degrees(math.atan2(p2_unten[1] - p1_unten[1], p2_unten[0] - p1_unten[0])) - if drehrichtung == "UZS": - rotation += 180 - import_block("Richtungspfeil", lib_doc, doc) - blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil") - bref = msp.add_blockref("Richtungspfeil", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer}) - if verbose: - print(f"[INFO] Drehrichtung '{drehrichtung}':Richtungspfeil unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}") + Kreisel.draw_kreisel_lines(msp, pos1, pos2, kreisel) + Kreisel.draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, kreisel, lib_doc, doc, verbose) def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose): for blockname in blocknames: @@ -1043,17 +1477,15 @@ 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,config_allgemein): - + foerderer = VarioFoerderer.from_merkmale(teileid,x,y,merkmale) # für spätere Namens benenung der Vario forderer - motor_vorhanden = bool(merkmale.get("hatMotor")) - umlenk_vorhanden = bool(merkmale.get("hatUmlenkung")) - if merkmale.get("Laenge_Gefaellestrecke") != None: - gefahellewinkel =float(merkmale.get("Laenge_Gefaellestrecke")) - - gefaelle = float(merkmale.get("Winkel_Gefaellestrecke")) - else: - gefahellewinkel = 0.0 - gefaelle = 0.0 + motor_vorhanden = foerderer.hat_motor + umlenk_vorhanden = foerderer.hat_umlenk + + gefahellewinkel = foerderer.gefaelle_winkel + + gefaelle = foerderer.gefaelle_laenge + # 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 @@ -1064,18 +1496,18 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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")) + voerder_richtung = foerderer.foerderer_richtung + winkel = int(foerderer.winkel) erster_kreisel_höher = False ein_kreisel_höher = False richtung2 ="DEFAULT" - rotation = float(merkmale.get("Drehung")) - upper_hoehe_vario= float(merkmale.get("Höhe Ende")) *1000 - lower_hoehe_vario = float(merkmale.get("Höhe Anfang")) *1000 - hoehe_vario= (upper_hoehe_vario + lower_hoehe_vario)/2 - separatoren =float(merkmale.get("Anzahl der Separatoren")) - scanner = float(merkmale.get("Anzahl der Scanner")) + rotation = foerderer.drehung + upper_hoehe_vario= foerderer.h1 + lower_hoehe_vario = foerderer.h0 + hoehe_vario= foerderer.hight_zwischen + separatoren = foerderer.anzahl_separatoren + scanner = foerderer.anzahl_scanner if rotation == 0 or rotation == -180: ausrichtung = "V" else: @@ -1129,7 +1561,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve if teileid == nachbarn.get("Id"): gefaellestrecke_vario = nachbarn break - laenge = float(merkmale.get("Länge in Meter")) *1000 + laenge = foerderer.laenge # 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 or gefaellestrecke_vario.get("Kurvenrichtung") != None) and ((winkel == 3 and voerder_richtung == "Ab")or voerder_richtung == "Horizontal"): # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung @@ -1358,7 +1790,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve block_vario.add_entity(copy) # Erstellung des Vario_förderes selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) + VarioFoerderer.vario_erstellung(foerderer, doc, lib_doc, config, 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}) @@ -1387,7 +1819,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve start, ende =erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario, drehung0, laenge, blockname,config,None ,block_vario, voerder_richtung, ein_kreisel_höher,None,None,None,mit_horizontal_verbunden) # Erstellung des Varios selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) + VarioFoerderer.vario_erstellung(foerderer, doc, lib_doc, config, 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}) @@ -1480,7 +1912,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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 ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) + VarioFoerderer.vario_erstellung(foerderer,doc, lib_doc, config, 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}) @@ -1559,7 +1991,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, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,config,block_vario,voerder_richtung, am_kreisel,erster_kreisel_höher,y1,z1) # Erstellung der Vario gefälle selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) + VarioFoerderer.vario_erstellung(foerderer, doc, lib_doc, config, 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}) @@ -1588,7 +2020,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve start, ende =gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_vario, lower_hoehe_vario, hoehe_vario,richtung2, drehung0, drehung1, laenge, None, blockname,config,block_vario,voerder_richtung) # Erstellung des Vario selber - vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block_vario,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ) + VarioFoerderer.vario_erstellung(foerderer, doc, lib_doc, config, 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}) @@ -1618,7 +2050,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve 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) + + VarioFoerderer.vario_erstellung(foerderer, doc, lib_doc, config, 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": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) @@ -2218,400 +2651,6 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl am_kreisel = 2 return am_kreisel,kreisel_verbunden -def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ): - # Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss - winkel_motor = float(config.get("Ils 2.0 core winkel","winkel_motor")) - winkel_umlenk = float(config.get("Ils 2.0 core winkel","winkel_umlenk")) - umlenk_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(",")) - motor_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Motorstation")).split(",")) - vario_abstand = float(config.get("ILS 2.0 Variofoerderer","vario_abstand")) - motor_vorhanden = bool(merkmale.get("hatMotor")) - umlenk_vorhanden = bool(merkmale.get("hatUmlenkung")) - if merkmale.get("Winkel_Gefaellestrecke") != None: - gefahellewinkel =float(merkmale.get("Winkel_Gefaellestrecke")) - gefaelle = float(merkmale.get("Laenge_Gefaellestrecke")) - else: - gefahellewinkel = 0.0 - gefaelle = 0.0 - # 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) - - motor_offset_x = umlenk_laenge[0]* math.cos(math.radians(winkel_motor)) - motor_offset_z = umlenk_laenge[0]* math.sin(math.radians(winkel_motor)) - umlenk_offset_x = motor_laenge[0]* math.cos(math.radians(winkel_umlenk)) - umlenk_offset_z = motor_laenge[0]* math.sin(math.radians(winkel_umlenk)) - # Berechnung des Gefälles - if motor_vorhanden == True: - gefaelle = gefaelle - motor_offset_x - if umlenk_vorhanden == True: - gefaelle = gefaelle - umlenk_offset_x - - #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) - 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 - - 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 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) - import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc) - block_Vario_Motorstation_500mm = dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(winkel_motor)) - block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(winkel_umlenk)) - if umlenk_vorhanden == True: - block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0] -x,ende[1] -y + umlenk_offset_x/2,ende[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 90}) - ende = (ende[0] ,ende[1] + umlenk_offset_x,ende[2] - umlenk_offset_z) - if motor_vorhanden == True: - block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - motor_offset_x/2 -y ,start[2] - hoehe_vario +motor_offset_z/2),dxfattribs={"rotation": 90}) - start = start[0] , start[1] - motor_offset_x,start[2] + motor_offset_z - - if voerder_richtung== "Auf": - # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - winkel_core = float(config.get("Ils 2.0 core winkel","winkel_boegen")) - winkel_plus = winkel + winkel_core - block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_plus}°") - block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_plus}°") - - auf_attrib =import_block(block_Vario_Bogen_auf, lib_doc, doc) - ab_attrib =import_block(block_Vario_Bogen_ab, lib_doc, doc) - block_Vario_Bogen_auf = dreh_block(block_Vario_Bogen_auf, doc,math.radians(winkel_core)) - block_Vario_Bogen_ab = dreh_block(block_Vario_Bogen_ab, doc,math.radians(-winkel)) - - Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] - Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] - Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(-winkel)) ] - Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(-winkel)) ] - Vario_Bogen_auf_Delta_VP_1 = [Vario_Bogen_auf_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_VP_1[1],-Vario_Bogen_auf_Delta_VP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ] - Vario_Bogen_ab_Delta_VP_0 = [Vario_Bogen_ab_Delta_VP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_VP_0[1],-Vario_Bogen_ab_Delta_VP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2] * math.cos(math.radians(-winkel)) ] - - # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_Delta_VP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_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,(ende[0] -x ,ende[1] +Vario_Bogen_auf_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90}) - ende_VP = (ende[0] +Vario_Bogen_auf_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_Delta_VP_1[0]+Vario_Bogen_auf_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_Delta_VP_1[2]- Vario_Bogen_auf_Delta_SP_0[2]) - ende = (ende[0] ,ende[1] +Vario_Bogen_auf_Delta_SP_1[0] + Vario_Bogen_auf_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_Delta_SP_1[2] - Vario_Bogen_auf_Delta_SP_0[2]) - #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie - block.add_blockref(block_Vario_Bogen_ab ,(start[0]-x,start[1] - Vario_Bogen_ab_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_Delta_SP_1[2]),dxfattribs={"rotation": 90}) - - start_VP = start[0] +Vario_Bogen_ab_Delta_VP_0[1],start[1]-Vario_Bogen_ab_Delta_VP_0[0] - Vario_Bogen_ab_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_Delta_VP_0[2] - Vario_Bogen_ab_Delta_SP_1[2] - start = start[0] ,start[1] - Vario_Bogen_ab_Delta_SP_0[0] - Vario_Bogen_ab_Delta_SP_1[0],start[2] - Vario_Bogen_ab_Delta_SP_1[2]+ Vario_Bogen_ab_Delta_SP_0[2] - - # Erstellung der VARIO Line - line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP}) - 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) - - else: - # Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block - - block_Vario_Bogen_auf_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_auf")) - block_Vario_Bogen_ab_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_ab")) - auf_3_attrib =import_block(block_Vario_Bogen_auf_3, lib_doc, doc) - ab_3_attrib = import_block(block_Vario_Bogen_ab_3, lib_doc, doc) - block_Vario_Bogen_auf_3= dreh_block(block_Vario_Bogen_auf_3, doc,math.radians(3)) - block_Vario_Bogen_ab_3 = dreh_block(block_Vario_Bogen_ab_3, doc,math.radians(0)) - Vario_Bogen_auf_3_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_3_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_3_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_VP_1"])) - Vario_Bogen_ab_3_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_VP_0"])) - - Vario_Bogen_auf_3_Delta_SP_0 = [Vario_Bogen_auf_3_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_0[1],-Vario_Bogen_auf_3_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2] * math.cos(math.radians(3)) ] - Vario_Bogen_auf_3_Delta_SP_1 = [Vario_Bogen_auf_3_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_1[1],-Vario_Bogen_auf_3_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_3_Delta_SP_0 = [Vario_Bogen_ab_3_Delta_SP_0 [0] ,Vario_Bogen_ab_3_Delta_SP_0[1],Vario_Bogen_ab_3_Delta_SP_0[2] ] - Vario_Bogen_ab_3_Delta_SP_1 =[ Vario_Bogen_ab_3_Delta_SP_1 [0] ,Vario_Bogen_ab_3_Delta_SP_1[1],Vario_Bogen_ab_3_Delta_SP_1[2] ] - Vario_Bogen_auf_3_Delta_VP_1 = [Vario_Bogen_auf_3_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_VP_1[1],-Vario_Bogen_auf_3_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2] * math.cos(math.radians(3)) ] - Vario_Bogen_ab_3_Delta_VP_0 = [Vario_Bogen_ab_3_Delta_VP_0 [0],Vario_Bogen_ab_3_Delta_VP_0[1],Vario_Bogen_ab_3_Delta_VP_0[2] ] - - # 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: - 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 - if motor_vorhanden == True: - 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]) - else: - ende_VP = ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1] ,ende[1] , ende[2] - - #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie - if umlenk_vorhanden == True: - 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] - else: - start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1] , start[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) - - 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 - - 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) - import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc) - block_Vario_Motorstation_500mm = dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(winkel_motor)) - block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(winkel_umlenk)) - if umlenk_vorhanden == True: - block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0] -x,start[1] -y - umlenk_offset_x/2, start[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 270}) - start_Umlenkstation_VP = start[0] - vario_abstand, start[1] -500 *math.cos(math.radians(-winkel_umlenk))+ math.sin(math.radians(-winkel_umlenk))* -45,start[2] + math.sin(math.radians(-winkel_umlenk))*500+ math.cos(math.radians(-winkel_umlenk))*-45 - start = (start[0] ,start[1] - umlenk_offset_x,start[2] -umlenk_offset_z) - elif winkel == 3: - start_Umlenkstation_VP = start[0] - vario_abstand, 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] + motor_offset_x/2 -y ,ende[2] - hoehe_vario + motor_offset_z/2),dxfattribs={"rotation": 270}) - ende_Motor_VP = ende[0] - vario_abstand, ende[1] +500 *math.cos(math.radians(-winkel_motor))+ math.sin(math.radians(-winkel_motor))* -45,ende[2] - math.sin(math.radians(-winkel_motor))*500+ math.cos(math.radians(-winkel_motor))*-45 - - ende = ende[0] , ende[1] + motor_offset_x,ende[2] +motor_offset_z - elif winkel == 3: - ende_Motor_VP = ende[0] - vario_abstand, ende[1]+ winkel_VP_offset_hinten[0] ,ende[2] - winkel_VP_offset_vorne[2] - - if winkel != 3: - winkel_core = float(config.get("Ils 2.0 core winkel","winkel_boegen")) - winkel_minus = winkel - winkel_core - block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_minus}°") - block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_minus}°") - ab_attrib =import_block( block_Vario_Bogen_ab , lib_doc, doc) - auf_attrib =import_block( block_Vario_Bogen_auf, lib_doc, doc) - block_Vario_Bogen_ab = dreh_block( block_Vario_Bogen_ab, doc, math.radians(winkel_core)) - block_Vario_Bogen_auf= dreh_block( block_Vario_Bogen_auf, doc, math.radians(winkel)) - Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) - Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) - Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) - Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) - Vario_Bogen_auf_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_0"])) - Vario_Bogen_ab_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_1"])) - - Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel)) ] - Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel)) ] - Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] - Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] - Vario_Bogen_auf_Delta_VP_0 = [Vario_Bogen_auf_Delta_VP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_VP_0[1],-Vario_Bogen_auf_Delta_VP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2] * math.cos(math.radians(winkel)) ] - Vario_Bogen_ab_Delta_VP_1 = [Vario_Bogen_ab_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_VP_1[1],-Vario_Bogen_ab_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ] - - # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss) - - for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_0): - if i< 2 and wert < 0: - Vario_Bogen_auf_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0): - if i< 2 and wert< 0: - Vario_Bogen_ab_Delta_SP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_Delta_SP_1[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_0): - if i< 2 and wert< 0: - Vario_Bogen_auf_Delta_VP_0[i] = abs(wert) - for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_1): - if i< 2 and wert< 0: - Vario_Bogen_ab_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, (start[0]-x,start[1]-y- Vario_Bogen_ab_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_Delta_SP_0[2]),dxfattribs={"rotation": 270}) - start_VP = start[0] -Vario_Bogen_ab_Delta_VP_1[1],start[1]- Vario_Bogen_ab_Delta_VP_1[0]- Vario_Bogen_ab_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_Delta_VP_1[2]-Vario_Bogen_ab_Delta_SP_0[2] - - start =(start[0], start[1]- Vario_Bogen_ab_Delta_SP_0[0]- Vario_Bogen_ab_Delta_SP_1[0],start[2]-Vario_Bogen_ab_Delta_SP_0[2]+Vario_Bogen_ab_Delta_SP_1[2]) - - #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie - block.add_blockref(block_Vario_Bogen_auf, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_Delta_SP_1[2]),dxfattribs={"rotation": 270}) - ende_VP = (ende[0] -Vario_Bogen_auf_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_Delta_VP_0[0]+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_Delta_VP_0[2]- Vario_Bogen_auf_Delta_SP_1[2]) - ende = (ende[0],ende[1]+ Vario_Bogen_auf_Delta_SP_1[0]+ Vario_Bogen_auf_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_Delta_SP_1[2]+ Vario_Bogen_auf_Delta_SP_0[2]) - - # Erstellung der VARIO Line - - 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) - - 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() - 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) - -# 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": - if (entity.dxf.name.startswith("400102632_ES-Element_90_links") or entity.dxf.name.startswith("200000146_ES-Element_90_rechts") or - entity.dxf.name.startswith("200000241_AS-Element_90_rechts") or entity.dxf.name.startswith("200000217_AS-Element_90_links") - ): - block_links.add_entity(clone) - else: - clone.transform(matrix) - block_links.add_entity(clone) - else: - clone.transform(matrix) - block_links.add_entity(clone) - def get_layer(doc, lib_doc, blockname): if blockname in lib_doc.blocks: src = lib_doc.blocks[blockname] @@ -2836,8 +2875,8 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat 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) + x, y = extract_coords(planquadrat) + except Exception as e: msg = f"[WARN] {teileid}: {e}" if logger: @@ -2875,6 +2914,8 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat # Mapping für Omniflo-Typen if func_name.startswith('handle_omniflo') or func_name.startswith('handle_tef'): handler = globals().get('handle_omniflo') + if func_name.startswith("handle_ils_2_0_kreisel"): + handler = globals().get("handle_ils_2_0_kreisel") if handler: handler(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn, config,config_allgemein) else: @@ -2887,46 +2928,6 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat for insert in msp.query("INSERT"): basepoint = insert.dxf.insert - # data = [] - # for e in msp.query("INSERT"): - - # ents = list(e.virtual_entities()) - # # Bounding Box des Blocks berechnen - # bb = bbox.extents(ents) - # if bb: - # x_min, y_min, z_min = bb.extmin - # x_max, y_max, z_max = bb.extmax - # width = (x_max - x_min) * e.dxf.xscale - # height_block = (y_max - y_min) * e.dxf.yscale - - # x, y, hoehe = e.dxf.insert - # data.append({ - # "blockname" : e.dxf.name, - # "x": x, - # "y": y, - # "höhe": hoehe, - # "rotation": e.dxf.rotation, - # "width": width, - # "height_block": height_block - # }) - - # with open(output_path_jason, "w", encoding="utf-8") as datei: - # json.dump(data, datei, ensure_ascii=False, indent=4) - - # 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 - # layer = insert.dxf.layer - doc.saveas(output_path) if logger: @@ -2934,12 +2935,6 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Pat else: print(f"[DONE] DXF gespeichert unter: {output_path}") -# def change_layer(doc, insert): -# src = doc.blocks[insert.dxf.name] -# for e in src: -# e.dxf.layer = "Motor" -# if e.dxftype() == "INSERT": -# change_layer(doc,e) def check_dxflibrary_path(lib_path, verbose, logger): lib_doc = None