m.stangl/kabellaengen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Toleranz Schritte entfernt, da nicht mehr benötigt. Errors_routing umbenannt. Weitere Kleinigkeiten im kommentierungen, etc.

Browse Source
This commit is contained in:
lertlmaier
2025-05-28 10:54:06 +02:00
parent 192c7361c1
commit f5d5a1f52c
2 changed files with 25 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/plant.py
+14 -16
View File
@@ -81,12 +81,12 @@ class NodeIDs():
def get_id(self, point:Point) -> int: def get_id(self, point:Point) -> int:
if f"{point.x} {point.y}" not in self._cord2id: if f"{point.x} {point.y}" not in self._cord2id:
raise Exception(f"Punkt nicht vorhanden!, {point.x},{point.y}") raise Exception(f"Point not found!, {point.x},{point.y}")
return self._cord2id[f"{point.x} {point.y}"] return self._cord2id[f"{point.x} {point.y}"]
def get_point(self, nid:int) -> Point: def get_point(self, nid:int) -> Point:
if nid not in self._id2cord: if nid not in self._id2cord:
raise Exception(f"NodeID nicht vorhanden! {nid}") raise Exception(f"NodeID nnot found! {nid}")
return self._id2cord[nid] return self._id2cord[nid]
def get_ids(self, points:list[Point]) -> list[int]: def get_ids(self, points:list[Point]) -> list[int]:
@@ -279,7 +279,7 @@ class Anlage():
""" """
def __init__(self, tol_snap=200.0, snap_step=10.0, tol_connect=5000.0, tol_connect_step=50.0): def __init__(self, tol_snap=200.0, tol_connect=5000.0):
# Container für alle Racks # Container für alle Racks
self._racks = RackIDs(tol_snap=tol_snap) self._racks = RackIDs(tol_snap=tol_snap)
# zuordnung zwischen KnotenID und Punkt # zuordnung zwischen KnotenID und Punkt
@@ -298,10 +298,8 @@ class Anlage():
self._sensor2dist = dict() self._sensor2dist = dict()
# Toleranzen zur Rack anbindung aneinander (Rack Snap) # Toleranzen zur Rack anbindung aneinander (Rack Snap)
self._tol_snap = tol_snap self._tol_snap = tol_snap
self._snap_step = snap_step
# Toleranzen zur Anbindung von Sensoren / Verteilern zu Racks # Toleranzen zur Anbindung von Sensoren / Verteilern zu Racks
self._tol_connect = tol_connect self._tol_connect = tol_connect
self._connect_step = tol_connect_step
# Infos zum zeichnen des Graphen # Infos zum zeichnen des Graphen
self._node_positions = dict() self._node_positions = dict()
@@ -412,7 +410,7 @@ class Anlage():
def get_tunnel_length(self, tname: str): def get_tunnel_length(self, tname: str):
if tname in self._tunnels: if tname in self._tunnels:
return float(self._tunnel_lengths[tname]) return float(self._tunnel_lengths[tname])
raise Exception("Tunnel not found") raise Exception("Tunnel-Length not found")
def add_tunnels(self, tunnels:dict): def add_tunnels(self, tunnels:dict):
for tname,pos in tunnels.items(): for tname,pos in tunnels.items():
@@ -454,11 +452,11 @@ class Anlage():
def join_racks(self): def join_racks(self):
self._racks.join_racks_str() self._racks.join_racks_str()
def find_nearest_rack_from_point_STR_bbox(self, max_dist, sensor:Point) -> tuple[Point, str]: def find_nearest_rack_from_point_STR_bbox(self, max_dist, pt:Point) -> tuple[Point, str]:
if self._racks._rack_tree is None: if self._racks._rack_tree is None:
self._racks._build_rack_strtree() self._racks._build_rack_strtree()
minx, miny, maxx, maxy = sensor.x - max_dist, sensor.y - max_dist, sensor.x + max_dist, sensor.y + max_dist minx, miny, maxx, maxy = pt.x - max_dist, pt.y - max_dist, pt.x + max_dist, pt.y + max_dist
bbox = box(minx, miny, maxx, maxy) bbox = box(minx, miny, maxx, maxy)
candidates = self._racks._rack_tree.query(bbox) candidates = self._racks._rack_tree.query(bbox)
@@ -469,19 +467,19 @@ class Anlage():
best_dist = max_dist best_dist = max_dist
best_line = candidates[0] best_line = candidates[0]
for line in candidates: for line in candidates:
dist = sensor.distance(line) dist = pt.distance(line)
if dist < best_dist: if dist < best_dist:
best_dist = dist best_dist = dist
best_line = line best_line = line
rack_name = self._racks._rack_map[best_line] rack_name = self._racks._rack_map[best_line]
nearest_point = best_line.interpolate(best_line.project(sensor)) nearest_point = best_line.interpolate(best_line.project(pt))
return nearest_point, rack_name return nearest_point, rack_name
def connect_equipment_to_racks(self, equipment: dict, onpoints: dict) -> list: def connect_equipment_to_racks(self, equipment: dict, onpoints: dict) -> list:
'''Verbindet Peripherie (Sensoren / Aktoren/ Unterverteiler) mit dem nächsten Rack. '''Verbindet Peripherie (Sensoren / Aktoren / Unterverteiler) mit dem nächsten Rack.
Eingabe: Dict des Equipments (Sensoren o. Dists), Dict der Aufpunkte von Sensoren o. Dists Eingabe: Dict des Equipments ({'Name': Point}), Dict der Aufpunkte von Sensoren o. Dists (zu Beginn leer)
Rückgabe: Liste der nicht zugeordneten Geräte Rückgabe: Liste der nicht mit Racks verbundenen Geräte (z.B. Entfernung zu groß)
''' '''
errors = [] errors = []
for name, pos in equipment.items(): for name, pos in equipment.items():
@@ -489,7 +487,7 @@ class Anlage():
onpoint, rackname = self.find_nearest_rack_from_point_STR_bbox(self._tol_connect, pos) onpoint, rackname = self.find_nearest_rack_from_point_STR_bbox(self._tol_connect, pos)
onpoints[name] = (onpoint, rackname) onpoints[name] = (onpoint, rackname)
except LookupError: except LookupError:
errors.append((name, pos)) errors.append((name, (pos.x, pos.y))) # Name des fehlgeschlagenenen und Position als Koodinaten zurückgeben
continue continue
self.add_point_to_rack(onpoint, rackname) self.add_point_to_rack(onpoint, rackname)
@@ -584,12 +582,12 @@ class Anlage():
def create_cable_paths(self, G) -> dict: def create_cable_paths(self, G) -> dict:
pfade = dict() pfade = dict()
pfade["kabel"] = list() pfade["kabel"] = list()
pfade["errors"] = list() pfade["errors_routing"] = list() # Fehler Liste für fehlgeschlagene Kabelverbindungen
for sname, dname in self._sensor2dist.items(): for sname, dname in self._sensor2dist.items():
try: try:
pfad_nodes, pfad_length = self.create_cable_path(G, sname, dname) pfad_nodes, pfad_length = self.create_cable_path(G, sname, dname)
except: except:
pfade["errors"].append((sname, dname)) pfade["errors_routing"].append((sname, dname))
continue continue
pfad_coords = self._nodeids.get_points(pfad_nodes) pfad_coords = self._nodeids.get_points(pfad_nodes)
#tuplecoords = [(p.x, p.y) for p in pfad_coords] #tuplecoords = [(p.x, p.y) for p in pfad_coords]
lib/routing.py
+11 -12
View File
@@ -52,13 +52,13 @@ def create_plant(racks:dict, sensors:dict, distributors:dict, mapping:dict, tunn
# "FC0062" # "FC0062"
# ] # ]
# } # }
# Einlesen der Toleranzen zur Verbindung von Rack zueinander und Peripherie zu Racks aus Config
tol_snap = config.getfloat("Racks", "SnapTolerances") tol_snap = config.getfloat("Racks", "SnapTolerances")
snap_step = config.getfloat("Racks", "SnapStep")
tol_connect = config.getfloat("Sensoren", "ConnectionTolerances") tol_connect = config.getfloat("Sensoren", "ConnectionTolerances")
tol_connect_step = config.getfloat("Sensoren", "ConnectSnap")
an = Anlage(tol_snap=tol_snap, snap_step=snap_step, tol_connect=tol_connect, tol_connect_step=tol_connect_step) an = Anlage(tol_snap=tol_snap, tol_connect=tol_connect)
# Füge racks aus Daten hinzu # Füge racks aus Daten hinzu
an.set_racks(racks) an.set_racks(racks)
# Verbinde Racks miteinander (ggf. verlängere ungenaue Racks) # Verbinde Racks miteinander (ggf. verlängere ungenaue Racks)
@@ -71,10 +71,10 @@ def create_plant(racks:dict, sensors:dict, distributors:dict, mapping:dict, tunn
an.add_distributors(distributors) an.add_distributors(distributors)
# Verbinde UV mit deren naheliegendsten Racks # Verbinde UV mit deren naheliegendsten Racks
errors_dists = an.connect_distributor_to_racks() errors_dists = an.connect_distributor_to_racks()
# Füge Tunnel hinzu # Füge Tunnel hinzu und speichere Länge des Tunnels
an.add_tunnels(tunnels) an.add_tunnels(tunnels)
an.set_tunnel_length(tunlength) an.set_tunnel_length(tunlength)
# Verbinde Tunnel mit deren naheliegendsten Racks # Verbinde Tunnel mit deren naheliegendsten Racks und Tunnel zu sich selbst
errors_tunnels = an.connect_tunnels() errors_tunnels = an.connect_tunnels()
# Verknüpfe Sensoren mit zugehörigem UV # Verknüpfe Sensoren mit zugehörigem UV
@@ -90,9 +90,11 @@ def create_plant(racks:dict, sensors:dict, distributors:dict, mapping:dict, tunn
if args.graph: if args.graph:
draw_graph(G,an) draw_graph(G,an)
paths['errors_sensors'] = errors_sensors paths['errors_sensors'] = errors_sensors # Sensoren die nicht zu Racks verbunden werden konnten
paths['errors_dists'] = errors_dists paths['errors_dists'] = errors_dists # Distributoren, die nicht zu Racks verbunden werden konnten
paths['errors_tunnels'] = errors_tunnels paths['errors_tunnels'] = errors_tunnels # Tunnel, die nicht zu Racks verbunden werden konnten
# paths['errors_routing'] # Knoten des Graphen, die nicht verbunden werden konnten (Ausgabe wird in create_vable_paths() erstellt)
return paths return paths
def draw_graph(G:nx.Graph, an:Anlage): def draw_graph(G:nx.Graph, an:Anlage):
@@ -118,9 +120,6 @@ def prepare_data(rawdata:dict):
racks = rawdata["racks"] racks = rawdata["racks"]
dracks = dict() dracks = dict()
for rname,lp in racks.items(): for rname,lp in racks.items():
# if rname not in dracks:
# dracks[rname] = list()
# dracks[rname].append(Point(lp))
ltemp = list() ltemp = list()
for p in lp: for p in lp:
ltemp.append(Point(p)) ltemp.append(Point(p))