Anpassung der Methoden auf Verwendung von Tunnels. launch.json angepasst, sodass easy_positions.json genommen wird.

.vscode/launch.json

@@ -110,15 +110,16 @@
             ]
         },
         {
-            "name": "routing for easy.json",
+            "name": "routing for easy_positions.json",
             "type": "debugpy",
             "request": "launch",
             "program": "${file}",
             "console": "integratedTerminal",
             "args": [
                 "--filename",
-                "easy.json",
-                "-g"
+                "easy_positions.json",
+                "-w"
+                "easy_todraw.json"
             ]
         },
         {

lib/plant.py

@@ -290,6 +290,10 @@ class Anlage():
         # Container für alle Unterverteiler
         self._distributors = dict()
         self._distributors_onpoints = dict()
+        # Container für alle Tunnel
+        self._tunnels = dict()
+        self._tunnel_onpoints = dict()
+        self._tunnel_lengths = dict()
         #Container für alle Wege
         self._sensor2dist = dict()
         # Toleranzen zur Rack anbindung aneinander (Rack Snap)
@@ -395,6 +399,36 @@ class Anlage():
         '''
         return self.connect_equipment_to_racks(self._distributors, self._distributors_onpoints)
 
+    def get_tunnel_onpoints(self):
+        return self._tunnel_onpoints.values()
+    
+    def add_tunnel(self, tname: str, pos:Point):
+        self._tunnels[tname] = pos
+
+    def set_tunnel_length(self, tunlength):
+        self._tunnel_lengths = tunlength
+
+    def add_tunnels(self, tunnels:dict):
+        for tname,pos in tunnels.items():
+            self.add_tunnel(tname, pos)
+
+    def get_tunnel_point(self, tname:str) -> Point:
+        if tname in self._tunnels:
+            return self._tunnels[tname]
+        raise Exception("Tunnel not found")
+
+    def connect_tunnels(self) -> list:
+        for tname, pos in self._tunnels.items():
+            tunbeg = pos[0]
+            tunend = pos[1]
+            trackname = f"t-Rack-{tname}"
+            self._racks.add_rack(tunbeg, tunend, trackname)
+        
+        return self.connect_equipment_to_racks(self._tunnels, self._tunnel_onpoints)
+
+        
+
+
     def join_racks(self):
         self._racks.join_racks_str()
    
@@ -481,17 +515,24 @@ class Anlage():
 
         for rname in self.get_rack_names():
             plist = self.get_points_from_rack(rname)
+
             for start, end in pairwise(plist):
                 nid_start = self._nodeids.get_id(start)
                 nid_end = self._nodeids.get_id(end)
 
+                weight=start.distance(end)
+
                 if re.match("v-.*", rname): 
                     color = "red"
                 elif re.match("d-.*", rname): 
                     color = "blue"
+                elif re.match("t-.*", rname): 
+                    color = "orange"
+                    weight = 3500   # !!! Wert muss noch validiert werden !!!
                 else:
                    color = "black"
-                G.add_edge(nid_start, nid_end, color=color, weight=start.distance(end))
+
+                G.add_edge(nid_start, nid_end, color=color, weight=weight)
         return self._node_positions
 
     def map_distributor_to_sensors(self, dname:str, snamen:list[str]):

lib/routing.py

@@ -28,7 +28,7 @@ def to_json(d, pretty: bool = True) -> str:
     return json.dumps(d, indent=2 if pretty else None, ensure_ascii=False, default=str) #ensure_ascii false für darstellung von "ue"
 
 
-def create_plant(racks:dict, sensors:dict, distributors:dict, mapping:dict) -> dict:
+def create_plant(racks:dict, sensors:dict, distributors:dict, mapping:dict, tunnels: dict, tunlength:dict ) -> dict:
 
     # racks = {'Rack_1-0': [Point(0, 0), Point(0, 10)], 
     #          'Rack_2-0': [Point(10, -2), Point(10, 5)], 
@@ -71,6 +71,12 @@ def create_plant(racks:dict, sensors:dict, distributors:dict, mapping:dict) -> d
     an.add_distributors(distributors)
     # Verbinde UV mit deren naheliegendsten Racks
     errors_dists = an.connect_distributor_to_racks()
+    # Füge Tunnel hinzu
+    an.add_tunnels(tunnels)
+    an.set_tunnel_length(tunlength)
+    # Verbinde Tunnel mit deren naheliegendsten Racks
+    errors_tunnels = an.connect_tunnels()
+
     # Verknüpfe Sensoren mit zugehörigem UV
     an.map_distributors_to_sensors(mapping)
     
@@ -119,10 +125,22 @@ def prepare_data(rawdata:dict):
             ltemp.append(Point(p))
         dracks[rname] = ltemp
         
-    mapping = rawdata["mappings"]
+    mapping = rawdata["mapping"]
+
+    tunnels = rawdata["tunnel"]
+    dtunnels = dict()
+    for tname,lp in tunnels.items():
+        if tname == "length":
+            continue
+        ltemp = list()
+        for p in lp:
+            ltemp.append(Point(p))
+        dtunnels[tname] = ltemp
+    
+    dtunlength = rawdata["tunnel"]["length"]
     
     
-    return (dracks, dsensors, dsubdists, mapping)
+    return (dracks, dsensors, dsubdists, mapping, dtunnels, dtunlength)
 
 
 if __name__ == "__main__":
@@ -144,7 +162,7 @@ if __name__ == "__main__":
 
     # Einlesen und Vorbereiten der Daten
     rawdata = load_json(sensors_path)
-    (racks, sensors, subdists, mapping) = prepare_data(rawdata)
+    (racks, sensors, subdists, mapping, tunnels, tunlength) = prepare_data(rawdata)
     
     config = configparser.ConfigParser(allow_no_value=True, delimiters=("="))
     config.optionxform = lambda option: option  # preserve case for letters
@@ -152,7 +170,7 @@ if __name__ == "__main__":
 
 
     # virtuelle Anlage erstellen 
-    cable_paths = create_plant(racks, sensors, subdists, mapping)
+    cable_paths = create_plant(racks, sensors, subdists, mapping, tunnels, tunlength)
     if args.console:
         print(to_json(cable_paths))
         print("failed sensor:")