from ezdxf.entities import Line import math from pydantic import BaseModel, Field, field_validator from typing import Optional import plant2dxf from ezdxf.math import Matrix44 import re 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: int = Field(default=0, description="Anzahl der Scanner") anzahl_separatoren: int = Field(default=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 gefaelle_laenge = merkmale.get("Laenge_Gefaellestrecke") if gefaelle_laenge == None: gefaelle_laenge = 0.0 gefaelle_winkel = 0.0 else: gefaelle_laenge = float(gefaelle_laenge) gefaelle_winkel = float(merkmale.get("Winkel_Gefaellestrecke")), 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 = gefaelle_laenge, gefalle_winkel = gefaelle_winkel, anzahl_scanner = int(merkmale.get("Anzahl der Scanner")), anzahl_separatoren = int(merkmale.get("Anzahl der Separatoren")) ) 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" plant2dxf.import_block(block_Vario_Motorstation_500mm, lib_doc, doc) plant2dxf.import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc) 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}) 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 =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 = 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 =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]) 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" plant2dxf.import_block( block_Vario_Motorstation_500mm, lib_doc, doc) plant2dxf.import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc) 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}) 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 = int(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 =plant2dxf.import_block( block_Vario_Bogen_ab , lib_doc, doc) auf_attrib =plant2dxf.import_block( block_Vario_Bogen_auf, lib_doc, doc) 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"])) 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)