Schalter -i für infos über die Umbenennung der Symbole. Pfad jetzt auch work per default. Sortierfunktion für die Nummerierung überarbeitet

lib/create_numbers.py

@@ -250,28 +250,67 @@ def find_symbols_in_boundary(doc, msp, boundary, target_layers, attributes, erro
 def sort_symbols_by_direction(symbols, direction):
     """
     Sortiert die Symbole nach der angegebenen Richtung.
-        TOP_BOTTOM/LEFT_RIGHT: nach Y absteigend, dann X aufsteigend
-        TOP_BOTTOM/RIGHT_LEFT: nach Y absteigend, dann X absteigend
-        BOTTOM_TOP/RIGHT_LEFT: nach Y aufsteigend, dann X absteigend
-        BOTTOM_TOP/LEFT_RIGHT: nach Y aufsteigend, dann X aufsteigend
 
-    default ist von links nach rechts wenn keine Angabe gemacht wird. Oder von oben nach unten
+    Unterstützte Richtungen (erste Angabe = Hauptsortierung):
-        TOP_BOTTOM: TOP_BOTTOM/LEFT_RIGHT
+        TOP_BOTTOM/LEFT_RIGHT: Zeilenweise von oben nach unten, dann links nach rechts (primär Y, sekundär X)
-        BOTTOM_TOP: BOTTOM_TOP/LEFT_RIGHT
+        TOP_BOTTOM/RIGHT_LEFT: Zeilenweise von oben nach unten, dann rechts nach links (primär Y, sekundär -X)
-        LEFT_RIGHT: TOP_BOTTOM/LEFT_RIGHT
+        BOTTOM_TOP/LEFT_RIGHT: Zeilenweise von unten nach oben, dann links nach rechts (primär Y, sekundär X)
-        RIGHT_LEFT: TOP_BOTTOM/RIGHT_LEFT 
+        BOTTOM_TOP/RIGHT_LEFT: Zeilenweise von unten nach oben, dann rechts nach links (primär Y, sekundär -X)
+
+        LEFT_RIGHT/TOP_BOTTOM: Spaltenweise von links nach rechts, dann oben nach unten (primär X, sekundär -Y)
+        LEFT_RIGHT/BOTTOM_TOP: Spaltenweise von links nach rechts, dann unten nach oben (primär X, sekundär Y)
+        RIGHT_LEFT/TOP_BOTTOM: Spaltenweise von rechts nach links, dann oben nach unten (primär -X, sekundär -Y)
+        RIGHT_LEFT/BOTTOM_TOP: Spaltenweise von rechts nach links, dann unten nach oben (primär -X, sekundär Y)
+
+    Einfache Richtungen:
+        TOP_BOTTOM → TOP_BOTTOM/LEFT_RIGHT (zeilenweise von oben nach unten)
+        BOTTOM_TOP → BOTTOM_TOP/LEFT_RIGHT (zeilenweise von unten nach oben)
+        LEFT_RIGHT: Spaltenweise von links nach rechts (sortiert nach X, dann Y)
+        RIGHT_LEFT: Spaltenweise von rechts nach links (sortiert nach -X, dann Y)
+
+    Args:
+        symbols: Liste von Symbol-Dictionaries mit 'position' (x, y)
+        direction: DIRECTION-Attribut (z.B. "LEFT_RIGHT", "TOP_BOTTOM/LEFT_RIGHT", "LEFT_RIGHT/TOP_BOTTOM")
+
+    Returns:
+        Sortierte Liste von Symbolen
     """
-    if direction == "TOP_BOTTOM/LEFT_RIGHT" or direction == "TOP_BOTTOM" or direction == "LEFT_RIGHT":
+    # Kombinierte Richtungen (vollständig spezifiziert) - Y/X Reihenfolge
+    if direction == "TOP_BOTTOM/LEFT_RIGHT"  or direction == "TOP_BOTTOM":
+        # Von oben nach unten (-Y), in jeder Zeile von links nach rechts (X)
         return sorted(symbols, key=lambda s: (-s['position'][1], s['position'][0]))
-    elif direction == "TOP_BOTTOM/RIGHT_LEFT" or direction == "RIGHT_LEFT":
+    elif direction == "LEFT_RIGHT/TOP_BOTTOM" :
-        return sorted(symbols, key=lambda s: (-s['position'][1], s['position'][0]))
+        # Von links nach rechts (X), in jeder Spalte von oben nach unten (Y)
-    elif direction == "BOTTOM_TOP/RIGHT_LEFT":
+        return sorted(symbols, key=lambda s: (s['position'][0], -s['position'][1]))
-        return sorted(symbols, key=lambda s: (s['position'][1], s['position'][0]))
+    elif direction == "LEFT_RIGHT/BOTTOM_TOP":
-    elif direction == "BOTTOM_TOP/LEFT_RIGHT"or direction == "BOTTOM_TOP":
+        # Von links nach rechts (X), in jeder Spalte von unten nach oben (Y)
-        return sorted(symbols, key=lambda s: (s['position'][1], s['position'][0]))
-    else:
-        # Fallback: LEFT_RIGHT
         return sorted(symbols, key=lambda s: (s['position'][0], s['position'][1]))
+    elif direction == "TOP_BOTTOM/RIGHT_LEFT":
+        # Von oben nach unten (-Y), in jeder Zeile von rechts nach links (-X)
+        return sorted(symbols, key=lambda s: (-s['position'][1], -s['position'][0]))
+    elif direction == "BOTTOM_TOP/LEFT_RIGHT" or direction == "BOTTOM_TOP":
+        # Von unten nach oben (Y), in jeder Zeile von links nach rechts (X)
+        return sorted(symbols, key=lambda s: (s['position'][1], s['position'][0]))
+    elif direction == "BOTTOM_TOP/RIGHT_LEFT":
+        # Von unten nach oben (Y), in jeder Zeile von rechts nach links (-X)
+        return sorted(symbols, key=lambda s: (s['position'][1], -s['position'][0]))
+    elif direction == "RIGHT_LEFT/BOTTOM_TOP":
+        # Von unten nach oben (Y), in jeder Zeile von rechts nach links (-X)
+        return sorted(symbols, key=lambda s: (-s['position'][0], s['position'][1]))
+    elif direction == "RIGHT_LEFT/TOP_BOTTOM":
+        # Von rechts nach links (-X), in jeder Spalte von oben nach unten (Y)
+        return sorted(symbols, key=lambda s: (-s['position'][0], -s['position'][1]))
+
+    # Einfache Richtungen
+    elif direction == "LEFT_RIGHT":
+        # Spaltenweise von links nach rechts: Sortiere nach X, dann Y
+        return sorted(symbols, key=lambda s: (s['position'][0], s['position'][1]))
+    elif direction == "RIGHT_LEFT":
+        # Spaltenweise von rechts nach links: Sortiere nach -X, dann Y
+        return sorted(symbols, key=lambda s: (-s['position'][0], s['position'][1]))
+    else:
+        # Fallback: TOP_BOTTOM/LEFT_RIGHT
+        return sorted(symbols, key=lambda s: (-s['position'][1], s['position'][0]))
 
 
 def enumerate_symbols(symbols, attributes):
@@ -405,8 +444,13 @@ def validate_direction_with_geometry(direction, is_rectangle):
     polyline_path_directions = ["POLYLINE_PATH"]
 
     # Rechteck/Standard-Richtungen erwarten einfache Rechtecke
-    rectangle_directions = ["TOP_BOTTOM", "BOTTOM_TOP", "LEFT_RIGHT", "RIGHT_LEFT", 
+    rectangle_directions = [
-        "TOP_BOTTOM/LEFT_RIGHT", "TOP_BOTTOM/RIGHT_LEFT", "BOTTOM_TOP/RIGHT_LEFT", "BOTTOM_TOP/LEFT_RIGHT"]
+        "TOP_BOTTOM", "BOTTOM_TOP", "LEFT_RIGHT", "RIGHT_LEFT",
+        "TOP_BOTTOM/LEFT_RIGHT", "TOP_BOTTOM/RIGHT_LEFT",
+        "BOTTOM_TOP/RIGHT_LEFT", "BOTTOM_TOP/LEFT_RIGHT",
+        "LEFT_RIGHT/TOP_BOTTOM", "RIGHT_LEFT/TOP_BOTTOM",
+        "LEFT_RIGHT/BOTTOM_TOP", "RIGHT_LEFT/BOTTOM_TOP"
+    ]
 
     if direction in polyline_path_directions:
         if is_rectangle:
@@ -1006,13 +1050,37 @@ if __name__ == '__main__':
 
     # Schreibe JSON-Ausgabe wenn gewünscht
     if args.info:
+        # Formatiere die Ausgabe für bessere Lesbarkeit in JSON
+        formatted_symbols = []
+        for symbol in renamed_symbols:
+            formatted_symbols.append({
+                'old_value': symbol['old_value'],
+                'new_value': symbol['new_value'],
+                'layer': symbol['layer'],
+                'position': {
+                    'x': symbol['position'][0],
+                    'y': symbol['position'][1]
+                }
+            })
+
         output_data = {
-            'renamed_symbols': renamed_symbols,
+            'renamed_symbols': formatted_symbols,
-            'total_count': len(renamed_symbols)
+            'total_count': len(formatted_symbols)
         }
-        output_path = Path(args.info)
+
-        write_json_file(output_data, output_path.parent, output_path.name)
+        info_path = Path(args.info)
-        print(f"Ergebnisse in JSON gespeichert: {args.info}")
+
+        # Wenn nur ein Dateiname ohne Pfad angegeben wurde, speichere im work-Ordner
+        if info_path.parent == Path('.'):
+            output_dir = dxf_path.parent
+            output_filename = info_path.name
+        else:
+            # Absoluter oder relativer Pfad mit Verzeichnis angegeben
+            output_dir = info_path.parent
+            output_filename = info_path.name
+
+        write_json_file(output_data, output_dir, output_filename)
+        print(f"Ergebnisse in JSON gespeichert: {output_dir / output_filename}")
 
     # Schreibe Fehler-Datei nur wenn Fehler oder Warnungen vorhanden sind
     if error_collector.has_errors_or_warnings():

lib/getpositions_test.py

@@ -11,7 +11,7 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent))
 
 from getpositions import check_rack_z_coordinates
-from errorhandler import ErrorCollector
+from error_collector import ErrorCollector
 
 def test_no_deviation():
     """Test mit Racks ohne starke Abweichung (< 2000mm)"""