From c2722d0bd055b80a013fb1e225c0aa2aa08f7ccb Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Mon, 8 Dec 2025 13:06:20 +0100 Subject: [PATCH] Refactoring --- lib/Elemente/Angetriebene_Kurve.py | 48 ++++++++ lib/Elemente/Bt_element.py | 26 +++++ lib/Elemente/VarioFoerderer.py | 175 ++++++++++++----------------- lib/plant2dxf.py | 96 +++------------- 4 files changed, 162 insertions(+), 183 deletions(-) create mode 100644 lib/Elemente/Angetriebene_Kurve.py create mode 100644 lib/Elemente/Bt_element.py diff --git a/lib/Elemente/Angetriebene_Kurve.py b/lib/Elemente/Angetriebene_Kurve.py new file mode 100644 index 0000000..f311d0e --- /dev/null +++ b/lib/Elemente/Angetriebene_Kurve.py @@ -0,0 +1,48 @@ + +from pydantic import BaseModel, Field, field_validator + +class Angetriebene_Kurve(BaseModel): + teileid: str + x: float + y:float + drehung: float = Field(default=0.0,description="Rotation der Kurve") + hoehe0: float = Field(default=0.0,description="Hoehe Anfang der Kurve") + hoehe1: float = Field(default=0.0,description="Hoehe Ende der Kurve") + kurvenrichtung: str = Field(description="Kurvenrichtung der Kurve") + antriebNebenStrecke: str =Field(description="wo die Angetriebene Strecke ist abhängig von der kurvenrichtung") + winkel: int = Field(description="Der Winkel der Kurve") + + @property + def antrieb(self): + if self.antriebNebenStrecke == "Aussen": + self.antriebNebenStrecke = "außen" + elif self.antriebNebenStrecke == "Innen": + self.antriebNebenStrecke = "innen" + return self.antriebNebenStrecke + @property + def hight_zwischen(self): + return ((self.hoehe0 + self.hoehe1) /2) + @classmethod + def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'Angetriebene_Kurve': + hoehe0 = float(merkmale.get("Höhe Anfang")) * 1000 + hoehe1 = float(merkmale.get("Höhe Ende")) * 1000 + winkel = int(merkmale.get("Kurvenwinkel")) + kurvenrichtung = merkmale.get("Kurvenrichtung") + antriebNebenstrecke = merkmale.get("AntriebNebenStrecke") + try: + drehung = float(merkmale.get("Drehung")) + except Exception as e: + drehung = 0.0 + + return cls( + teileid = teileid, + x = x, + y = y, + drehung = drehung, + hoehe0 = hoehe0, + hoehe1 = hoehe1, + kurvenrichtung = kurvenrichtung, + antriebNebenStrecke = antriebNebenstrecke, + winkel = winkel + + ) \ No newline at end of file diff --git a/lib/Elemente/Bt_element.py b/lib/Elemente/Bt_element.py new file mode 100644 index 0000000..ae1f203 --- /dev/null +++ b/lib/Elemente/Bt_element.py @@ -0,0 +1,26 @@ +from pydantic import BaseModel, Field, field_validator +from typing import Optional + +class Bt_element(BaseModel): + teileid: str + drehung: Optional [float] = Field(default=0.0,description="Rotation des Elements") + hoehe: Optional [float] = Field(default=0.0,description="Hoehe des Elements") + + @classmethod + def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'Bt_element': + try: + hoehe = float(merkmale.get("Höhe in Meter")) + except Exception as e: + hoehe = 0.0 + try: + drehung = float(merkmale.get("Drehung")) + except Exception as e: + drehung = 0.0 + + return cls( + teileid = teileid, + x = x, + y = y, + hoehe = hoehe, + drehung = drehung + ) \ No newline at end of file diff --git a/lib/Elemente/VarioFoerderer.py b/lib/Elemente/VarioFoerderer.py index 912dc3c..a2ed50f 100644 --- a/lib/Elemente/VarioFoerderer.py +++ b/lib/Elemente/VarioFoerderer.py @@ -136,67 +136,72 @@ class VarioFoerderer(BaseModel): block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" plant2dxf.import_block(block_Vario_Motorstation_500mm, lib_doc, doc) plant2dxf.import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc) + layer_motor, color_motor = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Motorstation_500mm) + layer_umlenk, color_umlenk = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Umlenkstation_500mm) block_Vario_Motorstation_500mm = plant2dxf.dreh_block(block_Vario_Motorstation_500mm,doc,lib_doc,math.radians(winkel_motor)) block_Vario_Umlenkstation_500mm = plant2dxf.dreh_block( block_Vario_Umlenkstation_500mm, doc,lib_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}) + 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, "layer":layer_umlenk,"color": color_umlenk}) 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}) + 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, "layer":layer_motor,"color": color_motor}) 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}°") + # 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 =plant2dxf.import_block(block_Vario_Bogen_auf, lib_doc, doc) + ab_attrib =plant2dxf.import_block(block_Vario_Bogen_ab, lib_doc, doc) + layer_auf,color_auf = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_auf) + layer_ab,color_ab =plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_ab) + block_Vario_Bogen_auf = plant2dxf.dreh_block(block_Vario_Bogen_auf, doc,lib_doc,math.radians(winkel_core)) + block_Vario_Bogen_ab = plant2dxf.dreh_block(block_Vario_Bogen_ab, doc,lib_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"])) - auf_attrib =plant2dxf.import_block(block_Vario_Bogen_auf, lib_doc, doc) - ab_attrib =plant2dxf.import_block(block_Vario_Bogen_ab, lib_doc, doc) - block_Vario_Bogen_auf = plant2dxf.dreh_block(block_Vario_Bogen_auf, doc,lib_doc,math.radians(winkel_core)) - block_Vario_Bogen_ab = plant2dxf.dreh_block(block_Vario_Bogen_ab, doc,lib_doc,math.radians(-winkel)) + 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) - 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}) + #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie + if voerder_richtung == "Auf": + 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,"layer": layer_auf,"color": color_auf}) 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}) + 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,"layer": layer_ab,"color": color_ab}) 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] @@ -218,64 +223,20 @@ class VarioFoerderer(BaseModel): 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 =plant2dxf.import_block(block_Vario_Bogen_auf_3, lib_doc, doc) - ab_3_attrib = plant2dxf.import_block(block_Vario_Bogen_ab_3, lib_doc, doc) - block_Vario_Bogen_auf_3= plant2dxf.dreh_block(block_Vario_Bogen_auf_3, doc,lib_doc,math.radians(3)) - block_Vario_Bogen_ab_3 = plant2dxf.dreh_block(block_Vario_Bogen_ab_3, doc,lib_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]) + 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,"layer": layer_auf,"color": color_auf}) + 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]) else: - ende_VP = ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1] ,ende[1] , ende[2] + ende_VP = ende[0] +Vario_Bogen_auf_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] + 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,"layer": layer_ab,"color": color_ab}) + 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_0[2] - Vario_Bogen_ab_Delta_SP_1[2] else: - start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1] , start[2] + start_VP = start[0] +Vario_Bogen_ab_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" @@ -336,16 +297,18 @@ class VarioFoerderer(BaseModel): block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm" plant2dxf.import_block( block_Vario_Motorstation_500mm, lib_doc, doc) plant2dxf.import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc) + layer_motor, color_motor = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Motorstation_500mm) + layer_umlenk, color_umlenk = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Umlenkstation_500mm) block_Vario_Motorstation_500mm = plant2dxf.dreh_block( block_Vario_Motorstation_500mm, doc,lib_doc,math.radians(winkel_motor)) block_Vario_Umlenkstation_500mm = plant2dxf.dreh_block( block_Vario_Umlenkstation_500mm , doc,lib_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}) + 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,"layer": layer_umlenk,"color": color_umlenk}) 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}) + 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,"layer": layer_motor,"color": color_motor}) 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 @@ -359,6 +322,8 @@ class VarioFoerderer(BaseModel): block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_minus}°") ab_attrib =plant2dxf.import_block( block_Vario_Bogen_ab , lib_doc, doc) auf_attrib =plant2dxf.import_block( block_Vario_Bogen_auf, lib_doc, doc) + layer_auf,color_auf = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_auf) + layer_ab,color_ab =plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_ab) block_Vario_Bogen_ab = plant2dxf.dreh_block( block_Vario_Bogen_ab, doc,lib_doc, math.radians(winkel_core)) block_Vario_Bogen_auf= plant2dxf.dreh_block( block_Vario_Bogen_auf, doc,lib_doc, math.radians(winkel)) Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) @@ -397,13 +362,13 @@ class VarioFoerderer(BaseModel): 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}) + 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,"layer": layer_ab,"color": color_ab}) 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}) + 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,"layer": layer_auf,"color": color_auf}) 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]) diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index 360966c..e10bddd 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -21,79 +21,11 @@ import math from pydantic import BaseModel, Field, field_validator from typing import Optional from utils import check_environment_var, setup_logger -from Elemente import Kreisel, VarioFoerderer,Gefaehllestrecke +from Elemente import Kreisel, VarioFoerderer,Gefaehllestrecke,Angetriebene_Kurve,Bt_element import as_es_methoden -class Bt_element(BaseModel): - teileid: str - drehung: Optional [float] = Field(default=0.0,description="Rotation des Elements") - hoehe: Optional [float] = Field(default=0.0,description="Hoehe des Elements") - @classmethod - def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'Bt_element': - try: - hoehe = float(merkmale.get("Höhe in Meter")) - except Exception as e: - hoehe = 0.0 - try: - drehung = float(merkmale.get("Drehung")) - except Exception as e: - drehung = 0.0 - - return cls( - teileid = teileid, - x = x, - y = y, - hoehe = hoehe, - drehung = drehung - ) - -class Angetriebene_Kurve(BaseModel): - teileid: str - x: float - y:float - drehung: float = Field(default=0.0,description="Rotation der Kurve") - hoehe0: float = Field(default=0.0,description="Hoehe Anfang der Kurve") - hoehe1: float = Field(default=0.0,description="Hoehe Ende der Kurve") - kurvenrichtung: str = Field(description="Kurvenrichtung der Kurve") - antriebNebenStrecke: str =Field(description="wo die Angetriebene Strecke ist abhängig von der kurvenrichtung") - winkel: int = Field(description="Der Winkel der Kurve") - - @property - def antrieb(self): - if self.antriebNebenStrecke == "Aussen": - self.antriebNebenStrecke = "außen" - elif self.antriebNebenStrecke == "Innen": - self.antriebNebenStrecke = "innen" - return self.antriebNebenStrecke - @property - def hight_zwischen(self): - return ((self.hoehe0 + self.hoehe1) /2) - @classmethod - def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'Angetriebene_Kurve': - hoehe0 = float(merkmale.get("Höhe Anfang")) * 1000 - hoehe1 = float(merkmale.get("Höhe Ende")) * 1000 - winkel = int(merkmale.get("Kurvenwinkel")) - kurvenrichtung = merkmale.get("Kurvenrichtung") - antriebNebenstrecke = merkmale.get("AntriebNebenStrecke") - try: - drehung = float(merkmale.get("Drehung")) - except Exception as e: - drehung = 0.0 - - return cls( - teileid = teileid, - x = x, - y = y, - drehung = drehung, - hoehe0 = hoehe0, - hoehe1 = hoehe1, - kurvenrichtung = kurvenrichtung, - antriebNebenStrecke = antriebNebenstrecke, - winkel = winkel - - ) # --------------------------------------------------------- CFG-Leser für shapes.cfg def get_shape_cfg(teileart, cfg_path, logger=None): parser = configparser.ConfigParser() @@ -745,7 +677,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # für spätere Namens benenung der Vario forderer motor_vorhanden = foerderer.hat_motor umlenk_vorhanden = foerderer.hat_umlenk - + gefahellewinkel = foerderer.gefaelle_winkel gefaelle = foerderer.gefaelle_laenge @@ -1279,11 +1211,12 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Reintuen des endblockes in den Modelspace if merkmale.get("Motorseite")== "links": msp.add_blockref(block_name_links,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) + if merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) def handle_ils_2_0_kurve_angetrieben(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): - voerder_kurve = Angetriebene_Kurve.from_merkmale(teileid,x,y,merkmale) + voerder_kurve = Angetriebene_Kurve.Angetriebene_Kurve.from_merkmale(teileid,x,y,merkmale) kurvenwinkel = voerder_kurve.winkel h_zwischen = voerder_kurve.hight_zwischen antriebNebenStrecke = voerder_kurve.antrieb @@ -1291,7 +1224,8 @@ def handle_ils_2_0_kurve_angetrieben(msp, teileid, merkmale, x, y, doc, lib_doc, rotation = voerder_kurve.drehung blockname = (f"Vario_Kurve_{kurvenrichtung}_{kurvenwinkel}°_TEF_{antriebNebenStrecke}") import_block(blockname,lib_doc,doc) - msp.add_blockref(blockname,(x,y,h_zwischen),dxfattribs={"rotation": rotation}) + layer, color = get_insert_color_layer(lib_doc, blockname) + msp.add_blockref(blockname,(x,y,h_zwischen),dxfattribs={"rotation": rotation,"layer": layer, "color":color}) def handle_ils_2_0_kurve(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): @@ -1306,7 +1240,7 @@ def handle_ils_2_0_kurve(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, sy msp.add_blockref("AN8",(x,y,hz),dxfattribs={"rotation": rotation}) def handle_bt___beladung(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): - bt_element = Bt_element.from_merkmale(teileid,x,y,merkmale) + bt_element = Bt_element.Bt_element.from_merkmale(teileid,x,y,merkmale) rotation = bt_element.drehung hight = bt_element.hoehe blockname = "AN8" @@ -1314,14 +1248,21 @@ def handle_bt___beladung(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, sy msp.add_blockref(blockname,(x,y,hight),dxfattribs={"rotation": rotation}) def handle_bt___entladung(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): - bt_element = Bt_element.from_merkmale(teileid,x,y,merkmale) + bt_element = Bt_element.Bt_element.from_merkmale(teileid,x,y,merkmale) rotation = bt_element.drehung hight = bt_element.hoehe blockname = "AN8" import_block(blockname,lib_doc,doc) msp.add_blockref(blockname,(x,y,hight),dxfattribs={"rotation": rotation}) - +class Omniflo(BaseModel): + teileid:str + sivasnummer:str + laenge: Optional [float] + drehung: float + hoehe : Optional[float] + h0: Optional[float] = Field(description="Höhe unten im CSV") + h0: Optional[float] = Field(description="Höhe Oben im CSV") 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). @@ -1406,10 +1347,9 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, 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 + msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"rotation": drehung}) + def get_insert_color_layer(lib_doc, blockname):