Update test dxf, refactorn von direkt am Kreisel bei Vario Förderer

lib/Elemente/Eckrad.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional
+
+class Eckrad(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")
+    drehrichtung: Optional [str] =Field(default=None,description="Richtung des Eckrads")
+
+    @classmethod
+    def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'Eckrad':
+        try:
+            hoehe = float(merkmale.get("Höhe in Meter")) * 1000
+        except Exception as e:
+            hoehe = 0.0
+        try:
+            drehung = float(merkmale.get("Drehung"))
+        except Exception as e:
+            drehung = 0.0
+        try:
+            drehrichtung = merkmale.get("Drehrichtung")
+        except Exception as e:
+            drehrichtung = None
+        return cls(
+            teileid = teileid,
+            x = x,
+            y = y,
+            hoehe = hoehe,
+            drehung = drehung
+        )

lib/Elemente/VarioFoerderer.py

@@ -305,6 +305,79 @@ class VarioFoerderer(BaseModel):
                     winkel_VP_offset_vorne = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
            
         return winkel_VP_offset_vorne,winkel_VP_offset_hinten
+    def vario_verbuden_am_kreisel(foerderer, block_vario, start, ende, mit_horizontal_verbunden = None,kreisel_verbunden = None,am_kreisel = None,erster_kreisel_höher = None):
+        lower_hoehe_vario = foerderer.h0
+        upper_hoehe_vario = foerderer.h1
+        voerder_richtung = foerderer.foerderer_richtung
+        hoehe_vario = foerderer.hight_zwischen
+        x = foerderer.x
+        y = foerderer.y
+        if (kreisel_verbunden == 2 or (am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False))and voerder_richtung != "Horizontal":
+            l = (start[0],start[1],upper_hoehe_vario)
+                        # Eine 500 mm gefällestrecke an anfang und am ende reintuen
+            if voerder_richtung =="Auf":
+                m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario +500* math.sin(math.radians(3)))
+                start = m
+
+            elif voerder_richtung == "Ab":
+                m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario -500* math.sin(math.radians(3)))
+                start = m
+
+            else:
+                m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario )
+                start = m
+            if kreisel_verbunden == 1:
+                z1 = m[2]
+                y1 =  start[1] 
+
+            line = Line.new(dxfattribs={"start": l,"end":m })
+            line.dxf.layer = "6-SP"
+            copy= line.copy()
+            copy.translate(-x,-y,-hoehe_vario)
+            block_vario.add_entity(copy)
+        if (kreisel_verbunden == 2 or (am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True)) and voerder_richtung != "Horizontal":
+            l = (ende[0],ende[1],lower_hoehe_vario)
+            if voerder_richtung =="Auf":
+                m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario - 500* math.sin(math.radians(3)))
+                ende = m
+
+            elif voerder_richtung == "Ab":
+                m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3)))
+                ende = m
+            else:
+                m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario )
+                ende = m
+            line = Line.new(dxfattribs={"start": l,"end":m })
+            line.dxf.layer = "6-SP"
+            copy= line.copy()
+            copy.translate(-x,-y,-hoehe_vario)
+            block_vario.add_entity(copy)
+            if kreisel_verbunden == 1:
+                z1 = m[2]
+                y1 =  ende[1] 
+        elif voerder_richtung == "Horizontal":
+            if mit_horizontal_verbunden == "oben_drehung_0_or_-90" or mit_horizontal_verbunden == "unten_drehung_-180_or_-270":
+                l = (start[0],start[1],upper_hoehe_vario)
+                m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario)
+                start = m
+                line = Line.new(dxfattribs={"start": l,"end":m })
+                line.dxf.layer = "6-SP"
+                copy= line.copy()
+                copy.translate(-x,-y,-hoehe_vario)
+                block_vario.add_entity(copy)
+            else:
+                end = (ende[0],ende[1],lower_hoehe_vario)
+                en = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario )
+                ende = en
+                line = Line.new(dxfattribs={"start": end,"end":en })
+                line.dxf.layer = "6-SP"
+                copy= line.copy()
+                copy.translate(-x,-y,-hoehe_vario)
+                block_vario.add_entity(copy) 
+        if kreisel_verbunden == 1 and mit_horizontal_verbunden == None:
+            return y1,z1
+        else:
+            return start, ende
     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"))
@@ -663,4 +736,5 @@ class VarioFoerderer(BaseModel):
                     block_links.add_entity(clone)
             else:
                 clone.transform(matrix)
-                block_links.add_entity(clone)
+                block_links.add_entity(clone)
+    

lib/as_es_methoden.py

@@ -361,7 +361,7 @@ def am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehl
                 unterschiedlich = True
 
             else:
-                richtung2 = "Horinzontal"
+                richtung2 = "Horizontal"
             unterschiedlich = True
             return richtung2, unterschiedlich
         return richtung2, unterschiedlich

lib/block_methoden.py

@@ -146,4 +146,22 @@ def turn_two_blocks_left(doc, block_1_name_zwischen, block_2_name_zwischen, bloc
         for e in block1_zwischen:
             copy = e.copy()
             copy.transform(matrix)
-            block_1_left_name.add_entity(copy)
+            block_1_left_name.add_entity(copy)
+
+def add_attributes_to_block(block, attributes):
+    
+    """
+    Fügt einem bestehenden ezdxf-Block Attribut-Definitionen hinzu.
+    
+    Parameter:
+        block       – ein ezdxf.blocks.BlockLayout Objekt
+        attributes  – Liste von Tupeln [(tag, value), ...]
+    """
+    for tag, value in attributes.items():
+        tag = tag
+        value = value
+        a =block.add_attrib(
+            tag=tag,
+            text=value,
+        )
+        a.is_invisible = True

lib/plant2dxf.py

@@ -85,7 +85,6 @@ def parse_merkmale(merkmale_str: str) -> dict:
     except json.JSONDecodeError:
         return {}
 
- 
 def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein):
     """Erstellt ein Kreisel in der neuen Dxf"""
     kreisel = Kreisel.Kreisel.from_merkmale(teileid, x, y, merkmale)
@@ -153,7 +152,7 @@ def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, s
     elif merkmale.get("Drehrichtung") == "GUZS":
         msp.add_blockref(eckrad_links,(x,y,hight))
     else:
-        msp.add("AN8",x,y,hight)
+        msp.add_blockref("AN8",(x,y,hight))
 
 def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     """Erstellt eine Gefällestrecke in der neuen Dxf"""
@@ -318,11 +317,11 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
         if richtung0 == 90.0 or richtung0 ==270:
             richtung0= "Vertikal"
         else:
-            richtung0 = "Horinzontal"
+            richtung0 = "Horizontal"
         if richtung1 == 90.0 or richtung1 ==270:
             richtung1= "Vertikal"
         else:
-            richtung1 = "Horinzontal"
+            richtung1 = "Horizontal"
         richtung2,unterschiedlich = as_es_methoden.am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, x1_kreisel, y1_kreisel, richtung_rad1, abstand1,kreisel_verbunden, richtung0 , richtung1 , richtung2 )
         #Berechnung des Gefälles
         if hoehe0 > hoehe1:
@@ -346,7 +345,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
                     gefaelle = "links"
                 else:
                     gefaelle = "rechts"
-            elif richtung0 == "Horinzontal":
+            elif richtung0 == "Horizontal":
                     if position == "lower_lower" or position == "higher_higher":
                         gefaelle = "oben"
                     else:
@@ -388,7 +387,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
                     gefaelle = "links"
                 else:
                     gefaelle = "rechts"
-            elif richtung2 == "Horinzontal":
+            elif richtung2 == "Horizontal":
                     if position == "lower_lower" or position == "higher_higher":
                         gefaelle = "oben"
                     else:
@@ -518,27 +517,6 @@ def anzahl_seperatoren_oder_scan(msp, x, y, doc, lib_doc, klassen_objekt, hoehe,
             einsatz_zwischen = einsatz_fest.copy()
         else:
             einsatz_zwischen[0] = einsatz_zwischen[0]+ 300
-
-
-        
-def add_attributes_to_block(block, attributes):
-    
-    """
-    Fügt einem bestehenden ezdxf-Block Attribut-Definitionen hinzu.
-    
-    Parameter:
-        block       – ein ezdxf.blocks.BlockLayout Objekt
-        attributes  – Liste von Tupeln [(tag, value), ...]
-    """
-    for tag, value in attributes.items():
-
-        tag = tag
-        value = value
-        a =block.add_attrib(
-            tag=tag,
-            text=value,
-        )
-        a.is_invisible = True
         
 def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     """Erstellt ein Vario Förderer in der neuen Dxf"""
@@ -608,7 +586,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
         richtung_rad0= math.radians(richtung0)
         # Herausfinden ob der Förderere direkt mit dem Kreisel verbunden ist, die Werte für den Zweiten Kreisel wird auf None gesetzt weil diese nicht existieren
 
-        mit_horizontal_verbunden = None
+        # None als string für späteren vergleich
+        mit_horizontal_verbunden = "None"
         if voerder_richtung == "Horizontal":
             if rotation == 0.0:
                 if y> y0_kreisel:
@@ -649,65 +628,8 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
             start = (x, y + dy_true,upper_hoehe_vario)
             ende = (x,y -dy_true,lower_hoehe_vario)
             # Erstellung einer Gefällestrecke von 500 mm in der Vario rein, wo es verbunden ist
-            if ein_kreisel_höher == True and voerder_richtung != "Horizontal":
-
-                l = (start[0],start[1],upper_hoehe_vario)
-                if voerder_richtung =="Auf":
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario +500* math.sin(math.radians(3)))
-                    start = m
-                elif voerder_richtung == "Ab":
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario - 500* math.sin(math.radians(3)))
-                    start = m
-                else:
-                    if mit_horizontal_verbunden == "unten_drehung_0_or_-90" or mit_horizontal_verbunden == "oben_drehung_-180_or_-270":
-                        m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario+500* math.sin(math.radians(3)))
-                        start = m
-                    else:
-                        en = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario- 500* math.sin(math.radians(3)) )
-                        ende = en
-
-                line = Line.new(dxfattribs={"start": l,"end":m })
-                line.dxf.layer = "6-SP"
-                copy= line.copy()
-                copy.translate(-x,-y,-hoehe_vario)
-                block_vario.add_entity(copy)
-
-
-            elif ein_kreisel_höher == False and voerder_richtung != "Horizontal":
-                l = (ende[0],ende[1],lower_hoehe_vario)
-                if voerder_richtung =="Auf":
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario - 500* math.sin(math.radians(3)))
-                    ende = m
-                elif voerder_richtung == "Ab":
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3)))
-                    ende = m
-                else:
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario )
-                    ende = m
-                line = Line.new(dxfattribs={"start": l,"end":m })
-                line.dxf.layer = "6-SP"
-                copy= line.copy()
-                copy.translate(-x,-y,-hoehe_vario)
-                block_vario.add_entity(copy)
-            elif voerder_richtung == "Horizontal":
-                if mit_horizontal_verbunden == "oben_drehung_0_or_-90" or mit_horizontal_verbunden == "unten_drehung_-180_or_-270":
-                    l = (start[0],start[1],upper_hoehe_vario)
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario)
-                    start = m
-                    line = Line.new(dxfattribs={"start": l,"end":m })
-                    line.dxf.layer = "6-SP"
-                    copy= line.copy()
-                    copy.translate(-x,-y,-hoehe_vario)
-                    block_vario.add_entity(copy)
-                else:
-                    end = (ende[0],ende[1],lower_hoehe_vario)
-                    en = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario )
-                    ende = en
-                    line = Line.new(dxfattribs={"start": end,"end":en })
-                    line.dxf.layer = "6-SP"
-                    copy= line.copy()
-                    copy.translate(-x,-y,-hoehe_vario)
-                    block_vario.add_entity(copy)
+            start, ende =  VarioFoerderer.VarioFoerderer.vario_verbuden_am_kreisel(foerderer, block_vario, start, ende, mit_horizontal_verbunden,kreseil_verbunden,am_kreisel,ein_kreisel_höher)
+            
         
             # Erstellung des Vario_förderes selber
             VarioFoerderer.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)
@@ -795,42 +717,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
                 dy_true = halbe_laenge * math.cos (0)
                 start = (x, y + dy_true,upper_hoehe_vario)
                 ende = (x,y -dy_true,lower_hoehe_vario)
-                l = (start[0],start[1],upper_hoehe_vario)
-                # Eine 500 mm gefällestrecke an anfang und am ende reintuen
-                if voerder_richtung =="Auf":
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario +500* math.sin(math.radians(3)))
-                    start = m
-
-                elif voerder_richtung == "Ab":
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario -500* math.sin(math.radians(3)))
-                    start = m
-
-                else:
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario )
-                    start = m
-
-                line = Line.new(dxfattribs={"start": l,"end":m })
-                line.dxf.layer = "6-SP"
-                copy= line.copy()
-                copy.translate(-x,-y,-hoehe_vario)
-                block_vario.add_entity(copy)
-
-                l = (ende[0],ende[1],lower_hoehe_vario)
-                if voerder_richtung =="Auf":
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario - 500* math.sin(math.radians(3)))
-                    ende = m
-
-                elif voerder_richtung == "Ab":
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3)))
-                    ende = m
-                else:
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario )
-                    ende = m
-                line = Line.new(dxfattribs={"start": l,"end":m })
-                line.dxf.layer = "6-SP"
-                copy= line.copy()
-                copy.translate(-x,-y,-hoehe_vario)
-                block_vario.add_entity(copy)
+                start, ende = VarioFoerderer.VarioFoerderer.vario_verbuden_am_kreisel(foerderer, block_vario, start, ende,None,kreisel_verbunden)
                 # Die Vario erstellung selber
                 VarioFoerderer.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
@@ -862,50 +749,10 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
             # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht
             block_vario = doc.blocks.new(blockname, base_point=(0,0,0))
             dy_true = halbe_laenge * math.cos(0)
-            
+            start = (x, y + dy_true,upper_hoehe_vario)
+            ende = (x,y -dy_true,lower_hoehe_vario)
             # schauen ob der Förderer mit welchen Kreisel der Förderer verbunden ist, und dem entsprechend eine Gefällestrecke dort reintuern
-            if (am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False):
-                start = (x, y + dy_true,upper_hoehe_vario)
-                ende = (x,y -dy_true,lower_hoehe_vario)
-                l = (start[0],start[1],upper_hoehe_vario)
-                if voerder_richtung == "Auf":
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario +500* math.sin(math.radians(3)))
-                    z1 = m[2]
-                elif voerder_richtung == "Ab":
-                    m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario -500* math.sin(math.radians(3)))
-                    z1 = m[2]
-                else:
-                    m= (x,y -dy_true,lower_hoehe_vario)
-                    z1 = m[2]
-
-
-                line = Line.new(dxfattribs={"start": l,"end":m })
-                line.dxf.layer = "6-SP"
-                copy= line.copy()
-                copy.translate(-x,-y,-hoehe_vario)
-                block_vario.add_entity(copy)
-                y1 =  start[1] - math.cos(math.radians(3)) *500
-
-            else:
-                start = (x, y + dy_true,upper_hoehe_vario)
-                ende = (x,y -dy_true,lower_hoehe_vario)
-                l = (ende[0],ende[1],lower_hoehe_vario)
-                if voerder_richtung =="Auf":
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario - 500* math.sin(math.radians(3)))
-                    z1 = m[2]
-                elif voerder_richtung == "Ab":
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3)))
-                    z1 = m[2]
-                else:
-                    m = (ende[0],ende[1] +  500*math.cos(math.radians(3)) ,lower_hoehe_vario )
-                    z1 = m[2]
-
-                line = Line.new(dxfattribs={"start": l,"end":m })
-                line.dxf.layer = "6-SP"
-                copy= line.copy()
-                copy.translate(-x,-y,-hoehe_vario)
-                block_vario.add_entity(copy)
-                y1 =  ende[1] + math.cos(math.radians(3)) *500
+            y1,z1 = VarioFoerderer.VarioFoerderer.vario_verbuden_am_kreisel(foerderer, block_vario, start, ende,None,kreisel_verbunden,am_kreisel,erster_kreisel_höher )
 
             # Schauen welche es oder as element man braucht man braucht und diese in den block einfügen
             # Entnehmen von start und end Werte für spätere vario erstellung
@@ -1140,6 +987,7 @@ def get_nachbar_information(csv_path:Path) -> dict:
                 tefkurve = kurve_angetrieben.antrieb
                 kurve_winkel = kurve_angetrieben.winkel
                 angetriebene_kurve.append({"Id": Id,"H0": h0,"H1":h1,"kurvenrichtung":kurvenrichtung,"Tefkurve": tefkurve,"Kurvenwinkel": kurve_winkel,"X_angetrieben":x,"Y_angetrieben":y})
+            
         for gerade in geraden:
             anweisungen = 0
             voerder_anweisung = 0