116 lines
4.7 KiB
Python
116 lines
4.7 KiB
Python
import json
|
|
from shapely.geometry import LineString, Point
|
|
from shapely.ops import nearest_points
|
|
|
|
# === Konfiguration ===
|
|
tol = 200
|
|
tol_step = 10
|
|
|
|
# === Lade JSON-Daten ===
|
|
with open("C:/10-Develop/kabellaengen/work/easy_positions.json", "r") as f:
|
|
data = json.load(f)
|
|
|
|
racks_json = data["racks"] #Suchen nach Racks in gesamter Json-Übergabe
|
|
|
|
# === 1. Racks in Segmente zerlegen ===
|
|
''' Hier werden Racks, die aus "echter" Polylinie bestehen (mehrere Nodes, z.B. Rack 2 in easy.dxf) in einzelne Segmente zerlegt (Node1 -> Node2, Node2 -> Node3)'''
|
|
rack_segments = []
|
|
for rack_id, nodes in racks_json.items():
|
|
# Sortiere Node_1, Node_2, ...
|
|
sorted_keys = sorted(nodes.keys(), key=lambda k: int(k.split("_")[1]))
|
|
coords = [tuple(nodes[k]) for k in sorted_keys]
|
|
|
|
for i in range(len(coords) - 1):
|
|
p1, p2 = coords[i], coords[i+1]
|
|
line = LineString([p1, p2])
|
|
rack_segments.append((rack_id, i, line))
|
|
|
|
|
|
# === 2. Alle Endpunkte sammeln ===
|
|
''' Alle Endpunkte aller Racks als Point gespeichert, um shapely funktionen verwenden zu können'''
|
|
segment_endpoints = []
|
|
for rack_id, idx, line in rack_segments:
|
|
for pt in [line.coords[0], line.coords[1]]:
|
|
segment_endpoints.append((rack_id, idx, Point(pt)))
|
|
|
|
|
|
# === 3. Verbindungen suchen ===
|
|
verbindungen = []
|
|
endpoint_pinned = []
|
|
|
|
# === A: Echte Schnittpunkte zwischen Linien finden ===
|
|
''' Alle Segmente mit allen überprüfen, um echte SP zu finden'''
|
|
for i, (rack_id1, idx1, line1) in enumerate(rack_segments):
|
|
print(f"\n=== Prüfe {rack_id1}_{idx1} auf echte Schnittpunkte")
|
|
for j, (rack_id2, idx2, line2) in enumerate(rack_segments):
|
|
if i >= j:
|
|
continue # keine Duplikate / sich selbst
|
|
|
|
if line1.intersects(line2):
|
|
inter = line1.intersection(line2)
|
|
if inter.geom_type == "Point":
|
|
print(f"✅ Exakter Schnittpunkt {inter} zwischen {rack_id1}_{idx1} und {rack_id2}_{idx2}")
|
|
verbindungen.append((rack_id1, idx1, rack_id2, idx2, inter))
|
|
|
|
|
|
# === B: Näherungsweise Verbindung durch Toleranz-Kreise ===
|
|
''' Entlanglaufen der Racks und Scan nach Endpunkten im Toleranzbereich'''
|
|
for rack_id, idx, line in rack_segments:
|
|
print(f"\n=== Prüfe {rack_id}_{idx1} auf Punkte im Toleranzbereich")
|
|
for other_rack_id, other_idx, pt in segment_endpoints:
|
|
if rack_id == other_rack_id:
|
|
continue # ignoriere eigene Endpunkte
|
|
|
|
# Exakte Schnittpunkte ignorieren
|
|
if line.intersects(pt):
|
|
continue
|
|
|
|
dist = line.distance(pt)
|
|
if dist < tol:
|
|
print(f"🔍 Punkt {pt} liegt {dist:.2f} von Linie {rack_id}_{idx} entfernt")
|
|
|
|
radius = tol_step
|
|
while radius <= tol:
|
|
circle = pt.buffer(radius)
|
|
if circle.intersects(line):
|
|
contact = circle.intersection(line)
|
|
if contact.geom_type == "Point":
|
|
nearest = contact
|
|
else:
|
|
nearest = nearest_points(pt, contact)[1]
|
|
print(f" 🟡 Kreisberührung bei {nearest} mit {rack_id}_{idx}")
|
|
verbindungen.append((rack_id, idx, other_rack_id, other_idx, nearest))
|
|
|
|
# Füge verschobenen Endpunkt zu Liste hinzu. [Punkt gehört zu Rack_Nr, alter Punkt, neuer Punkt, gepinnt an Target_Rack]
|
|
endpoint_pinned.append((other_rack_id, other_idx, pt, nearest, rack_id))
|
|
|
|
break
|
|
radius += tol_step
|
|
|
|
# === Endpunkte aktualisieren ===
|
|
# Dict erstellen, dass mit dem Key "Rack_id - index" dahinter die Koordinaten von Anfang und Endpunkt speichert
|
|
d_racks_segments = dict()
|
|
|
|
for rack_id, idx, linestring in rack_segments:
|
|
key = f"{rack_id}-{idx}"
|
|
d_racks_segments[key] = [Point(linestring.coords[0]), Point(linestring.coords[1])] #Alle Racks in ihrer eingelesenen Form zum Dict hinzufügen
|
|
|
|
for rack_id, idx, old_pt, new_pt, taget_rack in endpoint_pinned: #Durch verschobene Endpunkte laufen...
|
|
key = f"{rack_id}-{idx}"
|
|
coords = d_racks_segments.get(key)
|
|
|
|
if coords: #...und bei Übereinstimmung von Start oder Endkoordinate die ursprüngliche (eingelesene) mit der gepinnten überschreiben
|
|
# Vergleich mit Startpunkt
|
|
if Point(coords[0]).equals(old_pt):
|
|
coords[0] = Point(new_pt.x, new_pt.y) #.x bzw .y übergibt x bzw y Koordinate von Objekt POINT
|
|
# Vergleich mit Endpunkt
|
|
elif Point(coords[1]).equals(old_pt):
|
|
coords[1] = Point(new_pt.x, new_pt.y)
|
|
|
|
d_racks_segments[key] = coords # aktualisieren
|
|
|
|
# === Ausgabe-Verbindungen ===
|
|
print("\n=== Gefundene Verbindungen ===")
|
|
for v in verbindungen:
|
|
print(v)
|