Paar namens änderung rotation ausgegleicht falls nur as es element da ist man die rotation von dieser passt

doc/plant2dxf_code_explained.md

@@ -1,12 +1,25 @@
 ## Wichtige Ezdxf Methoden
+
 1. block.add_blockref(blockname,(kordinaten)dxfattribute={"rotation": rotation,"layer": layer})
+
 - Fügt inserts in ein block hinzu
+
 2. msp.add_blockref(blockname,(kordinaten)dxfattribute={"rotation": rotation,"layer": layer})
+
 - Fügt insert ins Modelspace hinzu
+
 3. doc.blocks.new(blockname, base_point=(0,0,0))
+
 - Fügt einen neune Block ins Document hinzu(gleichen Block kann man nur einmal machen if abrage wär if blockname in doc.blocks)
+
 4. msp.query("DXFOBJEKT)
+
 - Holle jedes spezifische dxfobjekt von dem Modelspace, wird meistens für Inserts verwendet
 
 ## Plant2dxf handle Gefällestrecke
+
+1.Definiere Attribute und entnehme die Attribute von den Nachbarn falls nötig.
+2.Abarbeitung fall nur mit einem Kreisel verbunden.
+3. Korektur der rotation und austausch der Höhe falls nötig, wird gemact für die Konsistenz der Erstellung
+
 ## Main line

lib/Elemente/Bt_element.py

@@ -2,6 +2,7 @@ from pydantic import BaseModel, Field, field_validator
 from typing import Optional
 
 class Bt_element(BaseModel):
+    """Das sind beide BTMT Elemente"""
     teileid: str
     drehung: Optional [float] = Field(default=0.0,description="Rotation des Elements")
     hoehe: Optional [float] = Field(default=0.0,description="Hoehe des Elements")

lib/Elemente/VarioFoerderer.py

@@ -305,6 +305,30 @@ 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 horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_kreisel, y0_kreisel):
+        mit_horizontal_verbunden = "None"
+        if voerder_richtung == "Horizontal":
+            if rotation == 0.0:
+                if y> y0_kreisel:
+                    mit_horizontal_verbunden = "unten_drehung_0_or_-90"
+                else:
+                    mit_horizontal_verbunden = "oben_drehung_0_or_-90"
+            if rotation == -180.0:
+                if y> y0_kreisel:
+                    mit_horizontal_verbunden = "unten_drehung_-180_or_-270"
+                else:
+                    mit_horizontal_verbunden = "oben_drehung_-180_or_-270"
+            if rotation == -90.0:
+                if x> x0_kreisel:
+                    mit_horizontal_verbunden = "unten_drehung_0_or_-90"
+                else:
+                    mit_horizontal_verbunden = "oben_drehung_0_or_-90"
+            if rotation == -270.0:
+                if x> x0_kreisel:
+                    mit_horizontal_verbunden = "unten_drehung_-180_or_-270"
+                else:
+                    mit_horizontal_verbunden = "oben_drehung_-180_or_-270"
+        return mit_horizontal_verbunden
     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

lib/as_es_methoden.py

@@ -4,7 +4,7 @@ import plant2dxf
 import block_methoden
 
 RADIUS = 400
-def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge,blockname,config, hight = None,  block_vario = None, vario_richtung = None, verbunden_höher = None,gefaelle_block=None,start = None,ende = None,mit_horizontal_verbunden = None):
+def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge,blockname,config, hight = None,  block_vario = None, vario_richtung = None, verbunden_höher = None,gefaelle_block=None,start = None,ende = None,mit_horizontal_verbunden = None,as_es_rotation= None):
     halbe_laenge = laenge / 2
     dy = halbe_laenge * math.cos(0)
     asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset"))
@@ -54,7 +54,7 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper
             block_vario.add_blockref(block_as,(start[0]-x  ,start[1]+asoffset_y -y,start[2] -hoehe_gefaehlle + asoffset_z),dxfattribs={"layer":layer,"color":color})
             return start,ende
 
-        if laenge > asoffset:
+        if laenge >= asoffset:
             start[1] = start[1] - asoffset_y
             start[2] = start[2] - asoffset_z
             line = Line.new(dxfattribs={"start": start, "end": ende})
@@ -65,7 +65,7 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper
             gefaelle_block.add_blockref(block_as,(start[0]-x  ,start[1]+asoffset_y -y,start[2] -hoehe_gefaehlle + asoffset_z),dxfattribs={"layer":layer,"color":color})
             return False
         else:
-            msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle),dxfattribs={"layer":layer,"color":color})
+            msp.add_blockref(block_as,(start[0],start[1]+asoffset_y,upper_hoehe_gefaehlle),dxfattribs={"layer":layer,"color":color})
             return True
     elif block_es != None:
         block_es = block_methoden.dreh_block(block_es,doc,lib_doc,math.radians(winkel_es))
@@ -77,10 +77,10 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper
         elif vario_richtung == "Ab":
             start = (x , y + dy ,upper_hoehe_gefaehlle)
             ende  = (x , y - dy + esoffset_y,lower_hoehe_gefaehlle + esoffset_z)
-            block_vario.add_blockref(block_es, (ende[0]-x  ,ende[1]-esoffset_y -y,ende[2] - hoehe_gefaehlle -esoffset_z),dxfattribs={"layer":layer,"color":color})
+            block_vario.add_blockref(block_es, (ende[0]-x  ,ende[1]-esoffset_y -y,ende[2] - hoehe_gefaehlle -esoffset_z),dxfattribs={"rotation": as_es_rotation,"layer":layer,"color":color})
             return start,ende
 
-        if laenge > esoffset:
+        if laenge >= esoffset:
             ende[1]  = ende[1] + esoffset_y
             ende[2]  = ende[2] + esoffset_z
             line = Line.new(dxfattribs={"start": start, "end": ende})
@@ -91,7 +91,7 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper
             gefaelle_block.add_blockref(block_es, (ende[0]-x  ,ende[1]-esoffset_y -y,ende[2] - hoehe_gefaehlle -esoffset_z),dxfattribs={"layer":layer,"color":color})
             return False
         else:
-            msp.add_blockref(block_es,(x,y,lower_hoehe_gefaehlle),dxfattribs={"layer":layer,"color":color})
+            msp.add_blockref(block_es,(ende[0],ende[1]+esoffset_y,lower_hoehe_gefaehlle),dxfattribs={"rotation": as_es_rotation,"layer":layer,"color":color})
             return True
 
 def gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle,richtung2, drehung0, drehung1, laenge, hight_position, blockname,config, block_vario = None,voerder_richtung = None, am_kreisel = None, erster_kreisel_höher = None,y1=None,z1 =None):
@@ -113,7 +113,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_h
         middle_hoehe = upper_hoehe_gefaehlle
         upper_hoehe_gefaehlle = lower_hoehe_gefaehlle
         lower_hoehe_gefaehlle = middle_hoehe
-
+    # Entnehmung welches as/es element man braucht wenn es mit zwei Kreisel verbunden ist aber ein Kreisel direkt am Kopf hängt
     if richtung2!= "DEFAULT" or am_kreisel != None:
         # Schaut bei gleicher Orentierung
         if ((drehung0 == "GUZS" and drehung1 == "GUZS" and hight_position == "higher") or
@@ -159,7 +159,7 @@ def gefaellegerade_erstellung(x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_h
             block_methoden.import_block(block_as,lib_doc,doc)
             layer, color = block_methoden.get_insert_color_layer(lib_doc,block_as)
 
-        
+        # Erstellt den Block
         if block_es != None:
             block_es = block_methoden.dreh_block(block_es,doc,lib_doc,math.radians(winkel_es))
             if voerder_richtung == "Auf":

lib/plant2dxf.py

@@ -62,7 +62,6 @@ def get_shape_cfg(teileart, cfg_path, logger=None):
 # --------------------------------------------------------- Konstante Parameter
 ATTR_TAG = "TeileId"     # Attributtag im Block
 RADIUS   = 400           # Radius der Kreiselkreise (mm)
-
 # --------------------------------------------------------- Hilfsfunktionen
 def extract_coords(planquadrat: str) -> tuple[float, float]:
     """Extrahiert X/Y Koordinaten aus PlanquadratString."""
@@ -131,6 +130,7 @@ def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, s
     eckrad_rechts = "eckrad_UZS"
     eckrad_links = "eckrad_GUZS"
     hight = float(merkmale.get("Höhe in m")) * 1000
+    # Erstellung der Richtungung Blöcke der Eckrads 
     if  eckrad_rechts not in doc.blocks:
         block_rechts = doc.blocks.new(name= eckrad_rechts,base_point=(0,0,0))
         block_links = doc.blocks.new(name= eckrad_links,base_point=(0,0,0))
@@ -151,7 +151,6 @@ def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, s
 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"""
     #Vorbereitung der attributen
-
     gefaelle_objekt = Gefaehllestrecke.Gefaellestrecke.from_merkmale(teileid,x,y,merkmale)
     asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset"))
     esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset"))
@@ -173,14 +172,14 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
 
     richtung2 ="DEFAULT"
     unterschiedlich = False
-
     anzahl_seperatoren_oder_scan(msp, x, y, doc, lib_doc, gefaelle_objekt, hoehe_gefaehlle, rotation)
     for nachbarn in strecken_nachbarn:
         if teileid == nachbarn.get("Id"):
             gefaellestrecke_nachbarn = nachbarn
             break
+    # Fall verbunden mit exakt einem Kreisel
     if "Drehung0" in gefaellestrecke_nachbarn and "Drehung1" not in gefaellestrecke_nachbarn:
-        
+        # Entnehmen der Attribute der Nacharn
         drehung0 =gefaellestrecke_nachbarn.get("Drehung0")
         x0_kreisel = float(gefaellestrecke_nachbarn.get("x0"))
         y0_kreisel = float(gefaellestrecke_nachbarn.get("y0"))
@@ -190,6 +189,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
         richtung_rad0= math.radians(richtung0)
         abstand0 = float(gefaellestrecke_nachbarn.get("abstand0")) * 1000
 
+        #Austauch der höhen und dementsprechende Koorekur falls nötig, dieser Schritt ist notwendig für die Konsistzenz der Blockerstellung
         if upper_hoehe_gefaehlle < lower_hoehe_gefaehlle:
             hoehe2 = upper_hoehe_gefaehlle
             upper_hoehe_gefaehlle = lower_hoehe_gefaehlle
@@ -199,6 +199,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
             rotation = rotation -180
             gefaelle_objekt.drehung = rotation
 
+        # Übrerprüfung ob die Gefällestrecke einen Motor oder Umlenkstation braucht, wenn es mit einer angetriebenen Kurve verbunden ist
         block_Vario_Umlenkstation_500mm, block_Vario_Motorstation_500mm, blockname_motor_links, blockname_umlenk_links = block_methoden.rotatate_and_left_motor_umlenk(doc, lib_doc,config)
         hat_zusatz = Gefaehllestrecke.Gefaellestrecke.hat_motor_umlenk_station (gefaelle_objekt, gefaellestrecke_nachbarn)
         hat_motor_0 = hat_zusatz.get("hat_motor_0")
@@ -210,7 +211,9 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
         umlenk_gerade = hat_zusatz.get("umlenk_gerade")
         motor_gerade = hat_zusatz.get("motor_gerade")
         verbunden_am_einen = True
+        # Überprüfung ist die Gefällestrecke direkt mit dem Kreisel verbunden, anstelle des Stahlbandes 
         am_kreisel, kreisel_verbunden =as_es_methoden.am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None)
+        # Bearbeitung der Gefälle Strecke falls dies der Fall ist
         if am_kreisel == 1:
             if hat_motor_0 == False and hat_umlenk_0 == False:
                 dx = halbe_laenge *math.sin(winkel * -1)
@@ -220,8 +223,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
                 line =msp.add_line(start,ende)
                 line.dxf.layer = "6-SP"
                 return
+            #Bearbeitung der Gefällestrecke die direkt am Kreisel hängt und eine Motor- Umlenkstation besitzt
             else:    
-                
                 dy = halbe_laenge * math.cos(0)
                 start = [x , y + dy ,upper_hoehe_gefaehlle]
                 ende  = [x , y - dy ,lower_hoehe_gefaehlle]
@@ -238,10 +241,12 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
                     block.add_entity(line)
                 msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation,"layer": gefaelle_layer})
                 return
+        # Schauen ob die Gefällestrecke mit dem Höheren oder unterm Teil a, Kreisel Verbunden ist
         if  upper_hoehe_gefaehlle == hoehe0:
             hight ="higher"
-        elif lower_hoehe_gefaehlle == hoehe0 and winkel != 0:
+        else:
             hight = "lower"
+        # Erstelle den Block
         if hat_motor_0 == False and hat_umlenk_0 == False:
             blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}"
         else: 
@@ -265,8 +270,23 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
         start = [x , y + dy ,upper_hoehe_gefaehlle]
         ende  = [x , y - dy ,lower_hoehe_gefaehlle]
         start, ende = Gefaehllestrecke.Gefaellestrecke.ein_motor_oder_eine_umlenk(x, y, start,ende,doc, lib_doc, hoehe_gefaehlle, block_Vario_Umlenkstation_500mm, block_Vario_Motorstation_500mm, blockname_motor_links, blockname_umlenk_links, hat_motor_0, hat_umlenk_0, tefkurve_0, block,umlenk_gerade,motor_gerade)
+        #Füge die AS- Eselemente ein, falls die Gefällestrecke größer ist als das jeweilige Element
+        if richtung0 == 0.0 or richtung0 == -180:
+            rotation_ersatz = "V"
+        else:
+            rotation_ersatz = "H"
+        if rotation_ersatz == "H":
+            if x> x0_kreisel:
+                as_es_rotation= -90
+            else:
+                as_es_rotation= -270
+        else:
+            if y> y0_kreisel:
+                as_es_rotation= 0
+            else:
+                as_es_rotation= -180
         
-        only_es_or_as = as_es_methoden.erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,config,hight,None,None,None,block,start,ende)
+        only_es_or_as = as_es_methoden.erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,config,hight,None,None,None,block,start,ende,None,as_es_rotation)
 
         if only_es_or_as == False:
             bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation,"layer": gefaelle_layer})
@@ -276,8 +296,9 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
                 insert = (x,y)
             )
             a.is_invisible = True
-
+    #Abarbeitung der Gefallestrecke falls es mit 2 Kreiseln verbunden ist
     elif "Drehung0" in gefaellestrecke_nachbarn and "Drehung1" in gefaellestrecke_nachbarn:
+        #Hollen der nötigen Atributte
         dx = halbe_laenge *math.sin(winkel * -1)
         dy = halbe_laenge * math.cos(winkel)
         drehung0 =gefaellestrecke_nachbarn.get("Drehung0")
@@ -297,9 +318,9 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
         abstand1 = float(gefaellestrecke_nachbarn.get("abstand1"))  * 1000
         rotation = float(merkmale.get("Drehung"))
 
-        #ausrechnung position kreisel
+        # Überprüfung ist die Gefällestrecke direkt mit eimen Kreisel verbunden, anstelle des Stahlbandes und wenn ja wie viele
         am_kreisel, kreisel_verbunden= 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)
-        # falls gefälle strecke mit zwei kreiseln verbunden zeichne eine einfache linie (später braucht man hier auch eine logik sobald man die richtigen es und as elemente hat)
+        # falls beide enden direkt mit dem Kreisel verbunden sind zeichnen einfacher Linie
         if kreisel_verbunden == 2:
             start = x +dx, y + dy,upper_hoehe_gefaehlle
             ende  = x -dx, y - dy,lower_hoehe_gefaehlle
@@ -396,7 +417,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
                     hight_position = "lower"
                 else:
                     hight_position = "higher"
-
+        # Erstellung der Rotation 
         if gefaelle == "oben":
             rotation = 0
         elif gefaelle == "unten" :
@@ -433,7 +454,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
             gefaelle_objekt.h0 = lower_hoehe_gefaehlle
             rotation = rotation -180
             gefaelle_objekt.drehung = rotation
-
+        # Schauen ob die Gefällestruktur mit einer Kurve verbunden ist und deswegen ein Motor und oder eine Umlenkstation braucht
         block_Vario_Umlenkstation_500mm, block_Vario_Motorstation_500mm, blockname_motor_links, blockname_umlenk_links = block_methoden.rotatate_and_left_motor_umlenk(doc, lib_doc,config)
         hat_zusatz = Gefaehllestrecke.Gefaellestrecke.hat_motor_umlenk_station(gefaelle_objekt, gefaellestrecke_nachbarn)
         hat_motor_0 = hat_zusatz.get("hat_motor_0")
@@ -446,7 +467,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
         motor_gerade = hat_zusatz.get("motor_gerade")
 
         blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{hoehe_gefaehlle}_{hat_motor_0}_{hat_umlenk_0}_{tefkurve_0}_{hat_motor_1}_{hat_umlenk_1}_{tefkurve_1}_{umlenk_gerade}_{motor_gerade}"
-
+        # behandlung der Gefällestrecke falls es keine Vario Kurve hat
         if hat_motor_0 == False or hat_umlenk_0 == False or hat_motor_1 == False or hat_umlenk_1 == False:
             dx = halbe_laenge *math.sin(winkel * -1)
             dy = halbe_laenge * math.cos(winkel)
@@ -455,6 +476,7 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
             a= msp.add_line(start,ende)
             a.dxf.layer = "6-SP"
             return
+        # Behandlung falls es mit einer odr zwei Vario kurve verbunden ist
         if blockname not in doc.blocks:
             block = doc.blocks.new(name=blockname,base_point = (0,0,0))
             dy = halbe_laenge * math.cos(0)
@@ -472,6 +494,7 @@ def anzahl_seperatoren_oder_scan(msp, x, y, doc, lib_doc, klassen_objekt, hoehe,
     """Importiert alle seperatoren und/oder scanner für das nötige objekt"""
     separatoren = klassen_objekt.anzahl_separatoren
     scanner = klassen_objekt.anzahl_scanner
+    # Schauen welche Ausrichtung das Objekt hat, damit man die Separtoren unbd Scanner nicht in das Objekt tut
     if rotation == 0 or rotation == -180: 
         ausrichtung = "V"
     else:
@@ -573,7 +596,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
             ein_kreisel_höher = True
         else:
             ein_kreisel_höher = False
-        mit_horizontal_verbunden = horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_eckrad, y0_eckrad)
+        mit_horizontal_verbunden = VarioFoerderer.VarioFoerderer.horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_eckrad, y0_eckrad)
         blockname =  (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_{ein_kreisel_höher}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}_{mit_horizontal_verbunden}")
         block_name_links =  (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_links_{ein_kreisel_höher}_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}_{mit_horizontal_verbunden}")
         if blockname not in doc.blocks:
@@ -629,7 +652,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
         # 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
 
         # None als string für späteren vergleich
-        mit_horizontal_verbunden = horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_kreisel, y0_kreisel)
+        mit_horizontal_verbunden = VarioFoerderer.VarioFoerderer.horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_kreisel, y0_kreisel)
         am_kreisel,kreseil_verbunden =as_es_methoden.am_kreisel_direct_verbunden(x, y, upper_hoehe_vario, lower_hoehe_vario, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None )
         if am_kreisel == 1:
             # Erstellung der blockname für wenn die Motorstation rechts und links
@@ -847,30 +870,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
         if merkmale.get("Motorseite")== "rechts":
             msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation})
 
-def horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_kreisel, y0_kreisel):
+
-    mit_horizontal_verbunden = "None"
-    if voerder_richtung == "Horizontal":
-        if rotation == 0.0:
-            if y> y0_kreisel:
-                mit_horizontal_verbunden = "unten_drehung_0_or_-90"
-            else:
-                mit_horizontal_verbunden = "oben_drehung_0_or_-90"
-        if rotation == -180.0:
-            if y> y0_kreisel:
-                mit_horizontal_verbunden = "unten_drehung_-180_or_-270"
-            else:
-                mit_horizontal_verbunden = "oben_drehung_-180_or_-270"
-        if rotation == -90.0:
-            if x> x0_kreisel:
-                mit_horizontal_verbunden = "unten_drehung_0_or_-90"
-            else:
-                mit_horizontal_verbunden = "oben_drehung_0_or_-90"
-        if rotation == -270.0:
-            if x> x0_kreisel:
-                mit_horizontal_verbunden = "unten_drehung_-180_or_-270"
-            else:
-                mit_horizontal_verbunden = "oben_drehung_-180_or_-270"
-    return mit_horizontal_verbunden
 
 def handle_ils_2_0_kurve_angetrieben(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
     """Erstellt eine Angetriebene Kurve (Förderer Kurve) in der neuen Dxf"""