# -*- coding: utf-8 -*- # Absichtlich ohne Shebang: der Windows-py-Launcher wuerde daraus "python3" # ableiten und scheitert, wenn keine PythonCore-Installation registriert ist. """ tro_annotate.py - TRO-Informationen in die BricsCAD-Zeichnung einblenden. Nimmt die Originalzeichnung (DXF), den CSV-Export und die daraus ermittelten TROs und schreibt eine **Kopie** der Zeichnung mit zusaetzlicher Beschriftung: * je TRO ein farbiger Marker als Block mit Attributen * TRO-Kennung, TRO-Typ, optional der Siemens-Funktionsbaustein * optional Pfeile fuer den gerichteten Materialfluss zwischen den TROs * optional eine Legende Die Zeichnung ist eine **Ansicht** zur Sichtkontrolle, keine Datenquelle: die TRO-JSON fuer scl_skeleton.py schreibt tro_flow.py --json direkt aus dem CSV. tro_annotate leitet die TROs mit genau demselben Aufruf ab wie tro_flow, damit Zeichnung und JSON uebereinstimmen. (tro_extract.py, der Rueckweg Zeichnung -> JSON, ist geparkt.) Die Originalzeichnung wird nie veraendert. Alle Ergaenzungen liegen auf eigenen Layern (Vorgabe: Praefix "TRO_") und tragen XDATA der Anwendungskennung SPS_SKEL_TRO. Ein erneuter Lauf entfernt genau diese Objekte und baut sie neu - gelaeuscht wird nach XDATA, nicht nach Layername, damit eigene Objekte auf denselben Layern unangetastet bleiben. Marker als Block mit Attributen ------------------------------- Je TRO-Typ wird eine Blockdefinition angelegt (TRO_SYM_) und an der Anlagenkoordinate eingefuegt. **Jeder Typ hat seine eigene Form** (Kreis, Dreieck, Rechteck, Raute ...; siehe TroSymbol in tro_catalog), sodass sich die Typen auch ohne Farbe unterscheiden. Die Daten stehen als Attribute am Block: ID TRO03 sichtbar, im Dialog bearbeitbar TYPE 1Sep sichtbar, im Dialog bearbeitbar FB_BLOCK FB_ILS_... sichtbar nur mit --fb UID 0062 unsichtbar, dauerhafte interne Nummer KEY TRO03 unsichtbar, Schluessel in tro_overrides.ini (ID der ID-Datei; leer bei einem mit TRO_INSERT gesetzten) ITEMS 1x Separator unsichtbar, reine Daten CONFIDENCE mittel unsichtbar SLOTS separator1=0010;switch1=0061 unsichtbar, Bauteil je Slot (TeileId; Lagerlinien als lines=0066,0069,...), im Dialog TRO_EDIT bearbeitbar Handkorrekturen (--read-tros) ----------------------------- Im Dialog TRO_EDIT (dxfmakros) aendern die SPS-Programmierer Typ, Kennung und die Bauteile je Slot; TRO_INSERT setzt neue Marker, geloeschte Marker fallen weg. Fuer "Im Plan waehlen" legt die Beschriftung die Bauteile des Exports (TeileId, Art, Lage in der Zeichnung) als XRECORD SPS_SKEL_PARTS in das Named Object Dictionary. --read-tros vergleicht die Marker mit der Ableitung und schreibt die Abweichungen als Abschnitte edit/edit_add nach cfg/tro_overrides.ini; tro_flow und tro_annotate wenden sie beim naechsten Lauf an (tro_flow.apply_edits). Zwei Kennungen, mit Absicht: ID die sprechende Kennung (TRO03). Darf sich aendern - der Dialog TRO_EDIT und TRO_INSERT in dxfmakros arbeiten damit. UID die eindeutige, dauerhafte interne Nummer. Vierstellig wie die TeileId des CSV-Exports und wie das ID-Attribut von SSG_LIB (dxfmakros/Lisp/ssg_id.lsp), damit sie im selben Nummernraum liegt und nicht mit bestehenden Nummern kollidiert; vergeben wird oberhalb der hoechsten schon belegten Nummer aus Zeichnung *und* CSV. Bewusst ein eigenes Tag und nicht ID: in dieser Zeichnung steht in ID schon die sprechende Kennung, und IDSCHECK wuerde sie beim Pruefen auf Dubletten ueberschreiben. Verbindungen ------------ Mit --flow wird je Kante zusaetzlich ein Block CONNECTION_ARROW in die Mitte des Pfeils gesetzt. Er haelt die Beziehung ueber die **UIDs** fest (FROM_UID/TO_UID, dazu FROM_TRO/TO_TRO als Klartext), sodass sie im DXF-Export eindeutig lesbar bleibt, auch wenn ein Marker verschoben oder seine sprechende Kennung geaendert wird. Damit sind die Daten in BricsCAD auswertbar und aenderbar. Zum Bearbeiten gibt es die Dialoge in dxfmakros: TRO_EDIT (dcl/tro_edit.dcl) und CONNECTION_EDIT (dcl/connection_edit.dcl); die Liste der gueltigen Typen dafuer schreibt --emit-lisp aus dem Katalog nach DXFM_LISP. Lagebezug --------- CSV und Zeichnung stehen in verschiedenen Koordinatensystemen. Der Versatz wird von lib/dxf_registration.py ermittelt, nachgewiesen und in SKEL_CFG abgelegt; spaetere Laeufe verwenden den abgelegten Wert. --re-register erzwingt eine neue Ermittlung, --offset setzt ihn von Hand. Ausgabe (in SKEL_RESULTS) ------------------------- _annotated.dxf Kopie der Zeichnung mit Beschriftung _registration.json verwendeter Lagebezug samt Nachweis Aufruf ueber bin/tro_annotate.bat bzw. bin/tro_annotate.sh. Benoetigt ezdxf (siehe requirements.txt). DWG wird nicht unterstuetzt - die Zeichnung muss als DXF vorliegen. """ from __future__ import annotations import argparse import collections import configparser import csv as csv_module import fnmatch import json import math import os import sys from pathlib import Path import ezdxf from ezdxf.enums import TextEntityAlignment from dxf_registration import ( ANCHOR_BLOCKS, RegistrationError, Transform, derive_from_ids, derive_transform, load_transform, save_transform, verify_transform, ) from material_flow import build_graph, env_dir, read_elements, resolve_input from tro_catalog import STYLES, TRO_CATALOG, TroSymbol, get_tro from model import Analysis from parameter import get_float from tro_flow import ( BOUNDARY_ENTRY, BOUNDARY_EXIT, STATION_FARBE, _station_positionen, analyse_tros, find_sibling_raw_json, load_sepliste_counts, resolve_ids_file, ) from tro_ids import TroIds from model import ( ANLAGE_SCHEMA, SLOT_PART_KINDS, AnlageDocument, DerivedTro, JamArea, derive_slots, has_lines, slot_kind, slot_names, ) from tro_ids import id_problem from tro_overrides import PartRef, TroEdit, load_overrides, override_path, save_edits from scl_context import ( JAM_NAMES_SUFFIX, HwSource, flow_order, jam_key, jam_label, jam_numbers, load_jam_overrides, save_jam_overrides, ) # --------------------------------------------------------------------------- # Konstanten # --------------------------------------------------------------------------- APPID = "SPS_SKEL_TRO" LAYER_PREFIX = "TRO_" BLOCK_PREFIX = "TRO_SYM_" # Verbindungsblock. Der Name beginnt mit CONNECTION_, damit der Dispatcher # SSG_BLOCKEDIT in dxfmakros ihn ueber "CONNECTION_*" erkennt. CONNECTION_BLOCK = "CONNECTION_ARROW" # Staubereich (--anlage). Der Name beginnt mit JAM_, damit SSG_BLOCKEDIT ihn # ueber "JAM_*" an den Dialog JAM_EDIT (dxfmakros/Lisp/Jam_Edit.lsp) gibt. JAM_BLOCK = "JAM_AREA" # Bauteile des Exports fuer "Im Plan waehlen" im Dialog TRO_EDIT: XRECORD im # Named Object Dictionary, je Bauteil (1 . TeileId) (3 . Art) (10 . Lage) # (40 . halbe Breite) (41 . halbe Hoehe) in Zeichnungskoordinaten. PARTS_XRECORD = "SPS_SKEL_PARTS" # Unsichtbare Attribute der Marker (build_symbol) HIDDEN_TAGS = ("UID", "KEY", "ITEMS", "CONFIDENCE", "SLOTS") # Anzeige eines Staubereichs ohne Foerderer (Nummer nicht ableitbar) JAM_OFFEN = "Jam????_?" # Zeichnungsgroessen und Restfehler-Grenze des Lagebezugs aus cfg/parameter.ini, # Abschnitt [tro_annotate] (lib/parameter.py) DEFAULT_MARKER = get_float("tro_annotate", "default_marker") DEFAULT_TEXT = get_float("tro_annotate", "default_text") DEFAULT_MAX_RESIDUAL = get_float("tro_annotate", "default_max_residual") JAM_ABSTAND = get_float("tro_annotate", "jam_abstand") # Staubereich als stehendes Rechteck, Masse relativ zur Texthoehe: halbe # Breite / halbe Hoehe, Name senkrecht darin (Jam0054_3 passt hinein). JAM_HALB_BREITE = 0.5 JAM_HALB_HOEHE = 2.6 JAM_TEXT = 0.6 # Fuellung und Rand (ACI 8 = grau) und Schrift (ACI 250 = fast schwarz) JAM_FUELLUNG = "#d0d0d0" def hex_to_rgb(value: str) -> tuple[int, int, int]: """'#e8d4f0' -> (232, 212, 240)""" text = value.lstrip("#") return (int(text[0:2], 16), int(text[2:4], 16), int(text[4:6], 16)) def lisp_dir() -> Path: """ Zielordner fuer die erzeugte LISP-Typliste. Bevorzugt DXFM_LISP - dort liegen die SSG_LIB-Module in dxfmakros, die den Dialog TRO_EDIT bereitstellen. Ohne die Variable landet die Datei in /cad, damit der Lauf auch ohne dxfmakros funktioniert. """ env = os.environ.get("DXFM_LISP") if env: return Path(env) return Path(__file__).resolve().parent.parent / "cad" def emit_lisp(cad_dir: Path) -> Path: """ Typliste fuer den DCL-Dialog schreiben. Der Dialog TRO_EDIT (dxfmakros/Lisp/Tro_Edit.lsp) bietet TYPE als Auswahlliste an. Damit sie nicht von der Typdefinition abweicht, wird sie hier aus TRO_CATALOG erzeugt statt in der LISP-Datei gepflegt. """ cad_dir.mkdir(parents=True, exist_ok=True) path = cad_dir / "tro_types.lsp" types = " ".join(f'"{d.get_name()}"' for d in TRO_CATALOG) def lisp_list(values) -> str: return " ".join(f'"{v}"' for v in values) # Je Typ die Slots in der Reihenfolge von model.derive_slots, dazu die # Vorgabe der Lagerlinien (0 = keine): ("PinStore_Auto" 19 "separator1" ...) slots = "\n".join( " (" + " ".join([f'"{d.get_name()}"', str(has_lines(d.get_name()))] + [f'"{s}"' for s in slot_names(d.get_name())]) + ")" for d in TRO_CATALOG) kinds = "\n".join(f' ("{k}" {lisp_list(v)})' for k, v in SLOT_PART_KINDS.items()) path.write_text( ";; Automatisch erzeugt von lib/tro_annotate.py --emit-lisp\n" ";; Quelle: TRO_CATALOG in lib/tro_catalog.py, Slots aus lib/model.py\n" ";; (slot_names, SLOT_PART_KINDS) - nicht manuell aendern.\n" f"(setq *TRO-TYPES* (list {types}))\n" ";; (Typ Lagerlinien-Vorgabe Slot ...) - Lagerlinien heissen line1..lineN\n" f"(setq *TRO-SLOTS* '(\n{slots}\n))\n" ";; (Slot-Art Bauteilart ...) - Pruefung beim Waehlen im Plan\n" f"(setq *TRO-SLOT-KINDS* '(\n{kinds}\n))\n" "(princ)\n", encoding="utf-8", ) return path # --------------------------------------------------------------------------- # Lagebezug # --------------------------------------------------------------------------- def anchor_points_csv(elements) -> dict[str, list[tuple[float, float]]]: """Punktartige CSV-Objekte je Rolle (Separator, Scanner).""" points: dict[str, list[tuple[float, float]]] = collections.defaultdict(list) for element in elements: if element.kind in ANCHOR_BLOCKS and element.position: points[element.kind].append((element.x, element.y)) return dict(points) def anchor_points_dxf(msp) -> dict[str, list[tuple[float, float]]]: """Einfuegepunkte der Anker-Bloecke je Rolle. ANCHOR_BLOCKS enthaelt Namensmuster, keine festen Namen - die von den Makros erzeugten Zeichnungen haengen an jeden Blocknamen ein `_2D`/`_3D` an (Separator_SP_3D statt S-SP). """ points: dict[str, list[tuple[float, float]]] = collections.defaultdict(list) for ref in msp.query("INSERT"): name = ref.dxf.name.upper() for role, patterns in ANCHOR_BLOCKS.items(): if any(fnmatch.fnmatchcase(name, p.upper()) for p in patterns): points[role].append((ref.dxf.insert.x, ref.dxf.insert.y)) break return dict(points) def _role_of(block_name: str) -> str: """Rolle eines Blocks nach ANCHOR_BLOCKS ("" wenn keine).""" name = block_name.upper() for role, patterns in ANCHOR_BLOCKS.items(): if any(fnmatch.fnmatchcase(name, p.upper()) for p in patterns): return role return "" def id_points_csv(elements) -> dict[str, tuple[str, float, float]]: """TeileId -> (Rolle, x, y) der punktartigen CSV-Objekte.""" return {e.teile_id: (e.kind, e.x, e.y) for e in elements if e.kind in ANCHOR_BLOCKS and e.position and e.teile_id} def id_points_dxf(msp) -> dict[str, tuple[str, float, float]]: """ID-Attribut -> (Rolle, x, y) der Anker-Bloecke im Modellbereich. Nur Bloecke einer Rolle aus ANCHOR_BLOCKS mit einer Ziffern-ID; eine ID, die zweimal vorkommt, ist nicht eindeutig und faellt weg. """ found: dict[str, tuple[str, float, float]] = {} doppelt: set[str] = set() for ref in msp.query("INSERT"): role = _role_of(ref.dxf.name) if not role: continue uid = next(((a.dxf.text or "").strip() for a in ref.attribs if a.dxf.tag.upper() == "ID"), "") if not uid.isdigit(): continue if uid in found: doppelt.add(uid) found[uid] = (role, ref.dxf.insert.x, ref.dxf.insert.y) return {k: v for k, v in found.items() if k not in doppelt} def resolve_transform( args, elements, msp, cfg_dir: Path, csv_name: str, dxf_name: str, warnings: list[str], ) -> Transform: """Lagebezug bestimmen: Kommandozeile, TeileId, Konfiguration oder Ermittlung. Die TeileId (derive_from_ids) geht vor dem abgelegten und dem ermittelten Bezug: sie ordnet eindeutig zu und gilt auch fuer eine verschobene Kopie der Zeichnung. Sie wird jedes Mal neu gerechnet, nicht abgelegt. """ csv_points = anchor_points_csv(elements) dxf_points = anchor_points_dxf(msp) if not args.offset: by_ids = derive_from_ids(id_points_csv(elements), id_points_dxf(msp), csv_name, dxf_name) if by_ids is not None: verify_transform(by_ids, csv_points, dxf_points) return by_ids if args.offset: try: dx, dy = (float(v) for v in args.offset.split(",")) except ValueError: raise RegistrationError( f"--offset '{args.offset}' nicht lesbar, erwartet 'dx,dy'" ) from None transform = Transform(dx=dx, dy=dy, source="cli", csv_file=csv_name, dxf_file=dxf_name, anchor="von Hand gesetzt") verify_transform(transform, csv_points, dxf_points) return transform if not args.re_register: stored = load_transform(cfg_dir, csv_name, dxf_name) if stored: # Auch der abgelegte Bezug wird gegen die Zeichnung nachgerechnet verify_transform(stored, csv_points, dxf_points) return stored transform = derive_transform(csv_points, dxf_points, csv_name, dxf_name) saved = save_transform(cfg_dir, transform) warnings.append(f"Lagebezug neu ermittelt und abgelegt: {saved}") return transform # --------------------------------------------------------------------------- # Zeichnung vorbereiten # --------------------------------------------------------------------------- def ensure_appid(doc) -> None: if APPID not in doc.appids: doc.appids.add(APPID) def remove_previous(msp) -> int: """Objekte frueherer Laeufe entfernen - erkannt an ihren XDATA.""" doomed = [] for entity in msp: try: if entity.get_xdata(APPID): doomed.append(entity) except (ezdxf.DXFValueError, ezdxf.DXFTypeError): continue for entity in doomed: msp.delete_entity(entity) return len(doomed) def tag(entity, tro_id: str = "") -> None: """Objekt als von diesem Programm erzeugt kennzeichnen.""" entity.set_xdata(APPID, [(1000, "tro_annotate"), (1000, tro_id or "-")]) def format_internal_id(number: int) -> str: """Vierstellige interne Nummer, wie (ssg-id-format n) in dxfmakros.""" return f"{number:04d}" def next_internal_id(msp, elements=None) -> int: """ Naechste freie interne ID. SSG_LIB vergibt jedem eingefuegten Baustein im Attribut ID eine eindeutige vierstellige Nummer (Lisp/ssg_id.lsp); dieselbe Nummer erscheint im CSV-Export als TeileId. Beides ist **derselbe** ID-Raum. Deshalb wird das Maximum aus zwei Quellen gebildet: * ID-Attribute der Bloecke in der Zeichnung * TeileId aller Objekte des CSV-Exports Die zweite Quelle ist der wichtigere Fall: eine mechanische Zeichnung, die nicht mit SSG_LIB gebaut wurde, hat gar keine ID-Attribute (im Mubea-Plan tragen nur 10 von 669 Bloecken ueberhaupt Attribute). Ohne die TeileIds wuerde die Beschriftung bei 0001 anfangen und damit Nummern belegen, die im CSV schon Bauteile bezeichnen - IDSCHECK saehe spaeter Dubletten. """ highest = 0 for ref in msp.query("INSERT"): try: attribs = ref.attribs except AttributeError: continue for attrib in attribs: if attrib.dxf.tag.upper() != "ID": continue text = (attrib.dxf.text or "").strip() if text.isdigit(): highest = max(highest, int(text)) for element in elements or (): teile_id = (element.teile_id or "").strip() if teile_id.isdigit(): highest = max(highest, int(teile_id)) return highest + 1 def build_layers(doc, prefix: str) -> dict[str, str]: """Layer je Farbgruppe plus Label-, Fluss- und Legendenlayer.""" names: dict[str, str] = {} for style in STYLES: name = f"{prefix}MARKER_{style.group}" names[style.group] = name if name not in doc.layers: # Strichfarbe, nicht Fuellfarbe: im CAD ist das Symbol eine Linie. # Die pastelligen Fuellfarben waeren als Linien kaum zu sehen. doc.layers.add(name, dxfattribs={ "true_color": ezdxf.rgb2int(hex_to_rgb(style.stroke)), }) # Kantenfarben wie im TRO-Fluss-SVG (tro_flow.render_dot): Uebergabe blau, # Weiche orange, Materialeingang gruen, Materialausgang rot. for key, colour in (("label", "#404040"), ("flow", "#2f5597"), ("weiche", "#cc8800"), ("eingang", STATION_FARBE[BOUNDARY_ENTRY]), ("ausgang", STATION_FARBE[BOUNDARY_EXIT]), ("jam", "#808080"), ("legend", "#808080")): name = f"{prefix}{key.upper()}" names[key] = name if name not in doc.layers: doc.layers.add(name, dxfattribs={ "true_color": ezdxf.rgb2int(hex_to_rgb(colour)), }) return names def _polygon(sides: int, radius: float, start_deg: float) -> list[tuple[float, float]]: """Eckpunkte eines regelmaessigen Vielecks um den Ursprung.""" return [ (radius * math.cos(math.radians(start_deg + i * 360 / sides)), radius * math.sin(math.radians(start_deg + i * 360 / sides))) for i in range(sides) ] def shape_outline(symbol: str, r: float) -> list[tuple[float, float]]: """Aeussere Kontur eines Symbols als Polygon - Rand der Fuellflaeche (Kreise als 48-Eck angenaehert).""" if symbol in (TroSymbol.CIRCLE, TroSymbol.DOUBLE_CIRCLE): return _polygon(48, r, 0) if symbol == TroSymbol.TRIANGLE: return _polygon(3, r, 90) if symbol in (TroSymbol.TRIANGLE_DOWN, TroSymbol.DOUBLE_TRIANGLE_DOWN): return _polygon(3, r, 270) if symbol == TroSymbol.SQUARE: return _polygon(4, r, 45) if symbol == TroSymbol.DIAMOND: return _polygon(4, r, 90) if symbol == TroSymbol.PENTAGON: return _polygon(5, r, 90) if symbol == TroSymbol.HEXAGON: return _polygon(6, r, 0) if symbol == TroSymbol.RECT: w, h = r * 1.45, r * 0.72 return [(-w, -h), (w, -h), (w, h), (-w, h)] if symbol == TroSymbol.ARROW: return [(-r * 0.55, -r), (r, 0), (-r * 0.55, r), (-r * 0.55, r * 0.35), (-r, r * 0.35), (-r, -r * 0.35), (-r * 0.55, -r * 0.35)] return _polygon(48, r, 0) def draw_fill(blk, symbol: str, r: float, fill_hex: str) -> None: """Typ-eigene Fuellfarbe (wie im TRO-Fluss-SVG) als Solid-Hatch unter der Kontur. Feste Farbe statt BYLAYER: der Layer traegt die Randfarbe der Gruppe, die Fuellung unterscheidet den einzelnen Typ.""" hatch = blk.add_hatch(dxfattribs={"true_color": ezdxf.rgb2int(hex_to_rgb(fill_hex))}) hatch.paths.add_polyline_path(shape_outline(symbol, r), is_closed=True) def draw_shape(blk, symbol: str, r: float) -> None: """ Symbolgeometrie in eine Blockdefinition zeichnen. Farbe 256 = BYLAYER, damit die Farbe des INSERT-Layers (Farbgruppe des Typs) durchschlaegt. Alle Formen liegen um den Ursprung, damit der Einfuegepunkt des Blocks die Anlagenkoordinate ist. """ attr = {"color": 256} if symbol == TroSymbol.CIRCLE: blk.add_circle((0, 0), r, dxfattribs=attr) elif symbol == TroSymbol.DOUBLE_CIRCLE: blk.add_circle((0, 0), r, dxfattribs=attr) blk.add_circle((0, 0), r * 0.6, dxfattribs=attr) elif symbol == TroSymbol.TRIANGLE: blk.add_lwpolyline(_polygon(3, r, 90), close=True, dxfattribs=attr) elif symbol == TroSymbol.TRIANGLE_DOWN: blk.add_lwpolyline(_polygon(3, r, 270), close=True, dxfattribs=attr) elif symbol == TroSymbol.DOUBLE_TRIANGLE_DOWN: blk.add_lwpolyline(_polygon(3, r, 270), close=True, dxfattribs=attr) blk.add_lwpolyline(_polygon(3, r * 0.55, 270), close=True, dxfattribs=attr) elif symbol == TroSymbol.SQUARE: blk.add_lwpolyline(_polygon(4, r, 45), close=True, dxfattribs=attr) elif symbol == TroSymbol.DIAMOND: blk.add_lwpolyline(_polygon(4, r, 90), close=True, dxfattribs=attr) elif symbol == TroSymbol.PENTAGON: blk.add_lwpolyline(_polygon(5, r, 90), close=True, dxfattribs=attr) elif symbol == TroSymbol.HEXAGON: blk.add_lwpolyline(_polygon(6, r, 0), close=True, dxfattribs=attr) elif symbol == TroSymbol.RECT: w, h = r * 1.45, r * 0.72 blk.add_lwpolyline([(-w, -h), (w, -h), (w, h), (-w, h)], close=True, dxfattribs=attr) elif symbol == TroSymbol.ARROW: blk.add_lwpolyline( [(-r * 0.55, -r), (r, 0), (-r * 0.55, r), (-r * 0.55, r * 0.35), (-r, r * 0.35), (-r, -r * 0.35), (-r * 0.55, -r * 0.35)], close=True, dxfattribs=attr) else: # unbekanntes Symbol: Kreis mit Kreuz, faellt auf blk.add_circle((0, 0), r, dxfattribs=attr) blk.add_line((-r, -r), (r, r), dxfattribs=attr) blk.add_line((-r, r), (r, -r), dxfattribs=attr) def build_symbol(doc, type_name: str, marker: float, text: float, show_fb: bool) -> str: """ Blockdefinition fuer einen TRO-Typ anlegen: Symbol + Attributdefinitionen. Je Typ eine eigene Form (siehe TroSymbol), damit sich die Typen in der Zeichnung auch ohne Farbe unterscheiden. Attribute (Tags nach der Konvention von dxfmakros/Lisp/ssg_id.lsp): ID unsichtbar - die eindeutige, dauerhafte interne Nummer im ID-Raum von SSG_LIB (vierstellig, wie die TeileId im CSV). IDSCHECK prueft und korrigiert sie zeichnungsweit. TRO_ID sichtbar - der sprechende Name (TRO01), vom Dialog aenderbar TYPE sichtbar - TRO-Typ, vom Dialog aenderbar """ name = f"{BLOCK_PREFIX}{type_name}" if name in doc.blocks: # Blockdefinition aus einem frueheren Lauf (bleibt, weil von Hand # gesetzte Marker sie benutzen): fehlende Datenattribute nachtragen, # sonst haetten die neuen Marker z. B. kein KEY/SLOTS. blk = doc.blocks.get(name) vorhanden = {a.dxf.tag.upper() for a in blk.query("ATTDEF")} offset = min((a.dxf.insert.y for a in blk.query("ATTDEF")), default=0.0) for tag_name in HIDDEN_TAGS: if tag_name not in vorhanden: offset -= text blk.add_attdef(tag_name, insert=(marker * 1.5, offset), height=text * 0.7, dxfattribs={"style": "Standard", "color": 256, "text": "", "invisible": 1}) return name blk = doc.blocks.new(name=name) definition = get_tro(type_name) symbol = definition.get_symbol() if definition else "" if definition: draw_fill(blk, symbol, marker, definition.get_fill()) draw_shape(blk, symbol, marker) gap = marker * 1.5 rows = [("ID", "TRO??", text * 1.35), ("TYPE", type_name, text)] if show_fb: rows.append(("FB_BLOCK", "FB", text * 0.85)) offset = 0.0 for tag_name, default, height in rows: blk.add_attdef( tag_name, insert=(gap, offset), height=height, dxfattribs={"style": "Standard", "color": 256, "text": default}, ) offset -= height * 1.55 # nicht sichtbare Attribute: reine Daten; KEY und SLOTS liest der Dialog # TRO_EDIT. ID zuerst - gleiche Reihenfolge wie *strecke-attr-front* in dxfmakros. for tag_name in HIDDEN_TAGS: blk.add_attdef( tag_name, insert=(gap, offset), height=text * 0.7, dxfattribs={"style": "Standard", "color": 256, "text": "", "invisible": 1}, ) offset -= text return name # --------------------------------------------------------------------------- # Beschriftung zeichnen # --------------------------------------------------------------------------- def place_markers( msp, doc, analysis: Analysis, transform: Transform, layers: dict[str, str], marker: float, text: float, show_fb: bool, warnings: list[str], next_id: int = 1, ) -> tuple[dict[str, tuple[float, float]], dict[str, str]]: """ Je TRO einen Blockmarker mit Attributen einfuegen. Rueckgabe: (Position je TRO, interne ID je TRO). Die interne ID wird ab `next_id` fortlaufend vergeben, damit sie mit den bereits in der Zeichnung vorhandenen IDs nicht kollidiert. """ placed: dict[str, tuple[float, float]] = {} internal: dict[str, str] = {} for tro in analysis.tros: if not tro.position: warnings.append(f"{tro.tro_id}: keine Koordinate - nicht beschriftet") continue x, y = transform.to_dxf(tro.position[0], tro.position[1]) placed[tro.tro_id] = (x, y) internal[tro.tro_id] = format_internal_id(next_id) next_id += 1 definition = get_tro(tro.type_name) group = definition.get_group() if definition else "ext" block = build_symbol(doc, tro.type_name, marker, text, show_fb) values = { "ID": tro.tro_id, "UID": internal[tro.tro_id], "KEY": analysis.edit_key(tro.tro_id), "TYPE": tro.type_name, "ITEMS": ", ".join(f"{c}x {i}" for i, c in sorted(tro.items.items())), "CONFIDENCE": tro.confidence, "SLOTS": format_slots(*tro_slots(tro)), } if show_fb: values["FB_BLOCK"] = tro.fb_block or "-" ref = msp.add_blockref(block, (x, y), dxfattribs={ "layer": layers.get(group, layers["ext"]), }) ref.add_auto_attribs(values) tag(ref, tro.tro_id) return placed, internal def place_stations( msp, analysis: Analysis, placed: dict[str, tuple[float, float]], layers: dict[str, str], text: float, ) -> dict[str, tuple[float, float]]: """Be-/Entladestationen wie im TRO-Fluss-SVG: kein Symbol, nur der Name in Gruen (Eingang) bzw. Rot (Ausgang) am Ende des Zu-/Ablaufpfeils. Lage wie dort (tro_flow._station_positionen): feste Pfeillaenge ab dem angehaengten TRO, Richtung von dessen Kanten weg.""" positionen = _station_positionen(analysis, placed) for station in analysis.boundaries: if station.tro_id not in positionen: continue x, y = positionen[station.tro_id] layer = layers["eingang" if station.type_name == BOUNDARY_ENTRY else "ausgang"] label = msp.add_text(station.label, height=text, dxfattribs={"layer": layer, "style": "Standard"}) label.set_placement((x, y), align=TextEntityAlignment.MIDDLE_CENTER) tag(label, station.tro_id) return positionen def build_connection_symbol(doc, marker: float, text: float) -> str: """ Blockdefinition fuer eine Verbindung anlegen. Der Block sitzt in der Mitte des Pfeils und traegt die Beziehung als Attribute; Schaft und Spitze sind eigene Geometrie auf dem Fluss-Layer. Grund fuer diese Trennung: ein Block mit fester Geometrie kann nicht zwei beliebige Punkte verbinden - ihn in X zu skalieren wuerde die Pfeilspitze verzerren. Der Mittelpunkt-Marker ist anklickbar (Doppelklick -> Dialog) und bleibt beim Zoomen gleich gross. Attribute: UID unsichtbar - eindeutige interne Nummer, dauerhaft FROM_UID unsichtbar - interne UID des Quell-TRO TO_UID unsichtbar - interne UID des Ziel-TRO FROM_TRO unsichtbar - sprechender Name der Quelle (TRO01) TO_TRO unsichtbar - sprechender Name des Ziels (TRO09) KIND unsichtbar - flow | weiche | colocated """ name = CONNECTION_BLOCK if name in doc.blocks: return name blk = doc.blocks.new(name=name) # Kleiner Doppelpfeil-Winkel als Griff, entlang +X ausgerichtet size = marker * 0.55 blk.add_lwpolyline([(-size, size * 0.7), (size, 0), (-size, -size * 0.7)], dxfattribs={"color": 256}) blk.add_circle((0, 0), size * 0.12, dxfattribs={"color": 256}) # FROM_TRO/TO_TRO unsichtbar: an jeder Kante sichtbar machten sie die # Zeichnung unruhig, im TRO-Fluss-SVG stehen sie auch nicht (Review # 2026-10-02). Die Daten bleiben am Block, CONNECTION_EDIT zeigt sie. offset = size * 1.4 for tag_name in ("FROM_TRO", "TO_TRO"): blk.add_attdef( tag_name, insert=(size * 1.3, offset), height=text * 0.8, dxfattribs={"style": "Standard", "color": 256, "text": "", "invisible": 1}, ) offset -= text * 1.2 for tag_name in ("UID", "FROM_UID", "TO_UID", "KIND"): blk.add_attdef( tag_name, insert=(size * 1.3, offset), height=text * 0.7, dxfattribs={"style": "Standard", "color": 256, "text": "", "invisible": 1}, ) offset -= text return name def draw_connections( msp, doc, analysis: Analysis, placed: dict[str, tuple[float, float]], internal: dict[str, str], layers: dict[str, str], marker: float, text: float, next_id: int = 1, ) -> int: """ Verbindungen zwischen den TROs zeichnen. Je Verbindung: Schaft und Pfeilspitze als Geometrie plus ein CONNECTION_ARROW-Block in der Mitte, der Quelle und Ziel ueber die **internen IDs** festhaelt. Damit bleibt die Beziehung im DXF-Export lesbar, auch wenn ein Marker verschoben oder umbenannt wird. """ head = marker * 0.9 block = build_connection_symbol(doc, marker, text) stationen = {b.tro_id for b in analysis.boundaries} drawn = 0 for src, dst in analysis.edges: if src not in placed or dst not in placed: continue # Farbe/Layer wie im TRO-Fluss-SVG if src in stationen: layer, kind = layers["eingang"], "eingang" elif dst in stationen: layer, kind = layers["ausgang"], "ausgang" elif analysis.edge_kinds.get((src, dst)) == "weiche": layer, kind = layers["weiche"], "weiche" else: layer, kind = layers["flow"], "flow" x1, y1 = placed[src] x2, y2 = placed[dst] length = math.dist((x1, y1), (x2, y2)) if length < 1e-6: continue ux, uy = (x2 - x1) / length, (y2 - y1) / length # An beiden Enden um den Marker kuerzen, damit der Pfeil ihn nicht # deckt; das Stationsende ist nur eine Beschriftung, dort weniger. kurz_a = marker * (0.3 if src in stationen else 1.1) kurz_b = marker * (0.3 if dst in stationen else 1.1) # Zu kurz fuer einen gekuerzten Pfeil (Marker liegen dicht beieinander, # z.B. HundM05 TRO03->TRO04 mit 500 mm): NICHT weglassen - sonst fehlt # die Verbindung in tro_extract.py und damit in der SCL. Stattdessen # Mitte-zu-Mitte ohne Kuerzung zeichnen. kurz = length <= kurz_a + kurz_b + head if kurz: kurz_a = kurz_b = 0.0 sx, sy = x1 + ux * kurz_a, y1 + uy * kurz_a ex, ey = x2 - ux * kurz_b, y2 - uy * kurz_b shaft = msp.add_lwpolyline([(sx, sy), (ex, ey)], dxfattribs={"layer": layer}) tag(shaft, f"{src}->{dst}") # Pfeilspitze als gefuellte Flaeche (bei kurzer Verbindung in der Mitte, # damit sie nicht im Zielmarker verschwindet) hx, hy = ((x1 + x2) / 2 + ux * head / 2, (y1 + y2) / 2 + uy * head / 2) \ if kurz else (ex, ey) bx, by = hx - ux * head, hy - uy * head px, py = -uy * head * 0.38, ux * head * 0.38 point = msp.add_solid( [(hx, hy), (bx + px, by + py), (bx - px, by - py)], dxfattribs={"layer": layer}, ) tag(point, f"{src}->{dst}") if kind in ("eingang", "ausgang"): # Stationspfeile ohne Verbindungsblock: keine TRO-TRO-Beziehung drawn += 1 continue # Traeger der Beziehung: Block in der Pfeilmitte, entlang des Pfeils ref = msp.add_blockref( block, ((sx + ex) / 2, (sy + ey) / 2), dxfattribs={"layer": layers["flow"], "rotation": math.degrees(math.atan2(uy, ux))}, ) ref.add_auto_attribs({ "UID": format_internal_id(next_id), "FROM_UID": internal.get(src, ""), "TO_UID": internal.get(dst, ""), "FROM_TRO": src, "TO_TRO": dst, "KIND": kind, }) tag(ref, f"{src}->{dst}") next_id += 1 drawn += 1 return drawn def build_jam_symbol(doc, text: float) -> str: """ Blockdefinition fuer einen Staubereich: stehendes graues Rechteck, der Name senkrecht mittig darin. Attribute: NAME sichtbar - Jam0054_3 (Foerderer + laufende Nummer) CONVEYOR unsichtbar - Foerderer NNNN (Kreisel-/Vario-Motor), im Dialog NUMBER unsichtbar - laufende Nummer k auf dem Foerderer, im Dialog TRO unsichtbar - TRO, in den der Staubereich fuehrt (TRO17) ENTRY unsichtbar - Eingang des TRO (1, bei 2Sep-Typen auch 2) AREA unsichtbar - Kennung der TRO-JSON (J0039) AUTO unsichtbar - abgeleitete Nummer NNNN_k; --read-jams schreibt nur, was davon abweicht TRO + ENTRY ist der stabile Schluessel (scl_context.jam_key). """ if JAM_BLOCK in doc.blocks: # Form aus einem frueheren Lauf (liegendes Rechteck) ersetzen; die # Attributdefinitionen bleiben, damit vorhandene Bloecke gueltig sind. blk = doc.blocks.get(JAM_BLOCK) for e in list(blk): if e.dxftype() != "ATTDEF": blk.delete_entity(e) _jam_form(blk, text) for a in blk.query("ATTDEF"): if a.dxf.tag.upper() == "NAME": _jam_name(a, text) return JAM_BLOCK blk = doc.blocks.new(name=JAM_BLOCK) _jam_form(blk, text) w, h = text * JAM_HALB_BREITE, text * JAM_HALB_HOEHE name = blk.add_attdef("NAME", insert=(0, 0), height=text * JAM_TEXT, dxfattribs={"style": "Standard", "text": JAM_OFFEN}) _jam_name(name, text) offset = -h - text for tag_name in ("CONVEYOR", "NUMBER", "TRO", "ENTRY", "AREA", "AUTO"): blk.add_attdef(tag_name, insert=(-w, offset), height=text * 0.7, dxfattribs={"style": "Standard", "color": 256, "text": "", "invisible": 1}) offset -= text return JAM_BLOCK def _jam_form(blk, text: float) -> None: """Stehendes Rechteck: graue Fuellung, grauer Rand.""" w, h = text * JAM_HALB_BREITE, text * JAM_HALB_HOEHE ecken = [(-w, -h), (w, -h), (w, h), (-w, h)] hatch = blk.add_hatch(dxfattribs={"true_color": ezdxf.rgb2int(hex_to_rgb(JAM_FUELLUNG))}) hatch.paths.add_polyline_path(ecken, is_closed=True) blk.add_lwpolyline(ecken, close=True, dxfattribs={"color": 8}) def _jam_name(attdef, text: float) -> None: """Name senkrecht (90 Grad) mittig ins Rechteck.""" attdef.dxf.height = text * JAM_TEXT attdef.dxf.rotation = 90.0 attdef.dxf.color = 250 attdef.set_placement((0, 0), align=TextEntityAlignment.MIDDLE_CENTER) def _jam_position(area: JamArea, anlage: AnlageDocument, marker: float, text: float) -> tuple[float, float] | None: """Lage eines Staubereichs (CSV-Koordinaten): direkt vor seinem TRO. Ausgangspunkt ist der TRO-Marker (die TRO-Position, nicht der Separator: bei Speichern und 2Sep-Typen liegt der weit vom Marker). Das Rechteck sitzt gerade so weit davon, dass es den Marker nicht beruehrt (Markerradius + JAM_ABSTAND + halbe Breite), ein zweiter Eingang direkt daneben - in Richtung des ersten Vorgaenger-TRO, gegen den Fluss, wo die Traeger warten. Ohne Vorgaenger mit Lage (Station) gegen die Richtung zum Nachfolger. Liegt der Nachbar naeher, hoechstens die halbe Strecke. Nur Lage - Verbindungen und Fliessrichtung bleiben unberuehrt. """ layout = anlage.layout tro = layout.by_id(area.tro) if tro is not None and tro.position: x, y = tro.position[0], tro.position[1] elif area.position is not None: x, y = area.position[0], area.position[1] else: return None breite = 2 * text * JAM_HALB_BREITE abstand = marker + JAM_ABSTAND + breite / 2 + (area.entry - 1) * (breite + JAM_ABSTAND) def richtung(ids: list[str], vorzeichen: float): for other_id in ids: other = layout.by_id(other_id) if other is None or not other.position: continue vx, vy = other.position[0] - x, other.position[1] - y dist = math.hypot(vx, vy) if dist > 1e-6: schritt = min(abstand, dist / 2) return (x + vorzeichen * vx / dist * schritt, y + vorzeichen * vy / dist * schritt) return None lage = richtung(area.predecessors or (tro.predecessors if tro else []), 1.0) if lage is None and tro is not None: lage = richtung(tro.successors, -1.0) return lage if lage is not None else (x - abstand, y) def place_jams( msp, doc, anlage: AnlageDocument, overrides: dict[str, tuple[str, int]], transform: Transform, layers: dict[str, str], text: float, warnings: list[str], marker: float = DEFAULT_MARKER, ) -> int: """ Je Staubereich der Anlagen-JSON einen JAM_AREA-Block einfuegen. Die Nummern sind dieselben wie in der SCL (scl_context.jam_numbers, dann die Korrekturen aus _jam_names.ini). Ein Staubereich ohne Foerderer zeigt Jam????_? - im Dialog nachtragen. """ layout = anlage.layout geordnet, _grund = flow_order(layout.tros) automatisch = jam_numbers(layout, geordnet, HwSource(anlage=anlage)) block = build_jam_symbol(doc, text) gezeichnet = 0 for area in layout.jam_areas_or_derived(): lage = _jam_position(area, anlage, marker, text) if lage is None: warnings.append(f"Staubereich {area.jam_id} ({area.tro}): keine Lage - " f"nicht gezeichnet") continue auto = automatisch.get(area.jam_id) nr, k = overrides.get(jam_key(area), auto or ("", 0)) ref = msp.add_blockref(block, transform.to_dxf(*lage), dxfattribs={"layer": layers["jam"]}) ref.add_auto_attribs({ "NAME": jam_label(nr, k) if nr else JAM_OFFEN, "CONVEYOR": nr, "NUMBER": str(k) if nr else "", "TRO": area.tro, "ENTRY": str(area.entry), "AREA": area.jam_id, "AUTO": f"{auto[0]}_{auto[1]}" if auto else "", }) tag(ref, area.tro) gezeichnet += 1 return gezeichnet def read_jams(dxf_file: Path, ini_file: Path) -> tuple[dict[str, tuple[str, int]], list[str]]: """Im Dialog JAM_EDIT geaenderte Staubereichs-Nummern uebernehmen. Liest die JAM_AREA-Bloecke der beschrifteten Zeichnung. Weicht CONVEYOR_NUMBER von AUTO ab, kommt der Staubereich in die Korrekturdatei ``_jam_names.ini``; stimmt er (wieder) mit AUTO ueberein, faellt sein Eintrag heraus. Eintraege zu Staubereichen, die nicht in der Zeichnung stehen, bleiben. Rueckgabe: (Korrekturen danach, Meldungen). """ meldungen: list[str] = [] overrides = load_jam_overrides(ini_file) doc = ezdxf.readfile(str(dxf_file)) namen: dict[str, str] = {} for ref in doc.modelspace().query(f'INSERT[name=="{JAM_BLOCK}"]'): a = {att.dxf.tag.upper(): (att.dxf.text or "").strip() for att in ref.attribs} key = f"{a.get('TRO', '')}.{a.get('ENTRY', '')}" nr, k = a.get("CONVEYOR", ""), a.get("NUMBER", "") if not a.get("TRO") or not a.get("ENTRY"): meldungen.append(f"Staubereich ohne TRO/ENTRY ({a.get('NAME', '?')}) - uebersprungen") continue if not nr and not k: continue if not (nr.isdigit() and len(nr) == 4 and k.isdigit() and int(k) > 0): meldungen.append(f"{key} ({a.get('AREA', '')}): Foerderer '{nr}' / Nummer '{k}' " f"ungueltig (erwartet NNNN und k >= 1) - uebersprungen") continue wert = f"{nr}_{int(k)}" if wert in namen.values(): andere = next(s for s, w in namen.items() if w == wert) meldungen.append(f"{key}: Jam{wert} ist schon {andere} - doppelt vergeben") namen[key] = wert alt = overrides.get(key) if wert == a.get("AUTO", ""): if alt is not None: del overrides[key] meldungen.append(f"{key}: wieder abgeleitet (Jam{wert}) - Korrektur entfernt") elif alt != (nr, int(k)): overrides[key] = (nr, int(k)) meldungen.append(f"{key}: Jam{wert} (abgeleitet: Jam{a.get('AUTO') or '-'})") save_jam_overrides(ini_file, overrides) return overrides, meldungen # --------------------------------------------------------------------------- # Handkorrekturen an den TROs (Dialog TRO_EDIT, --read-tros) # --------------------------------------------------------------------------- def tro_slots(tro: DerivedTro) -> tuple[dict[str, str], list[str]]: """Bauteile je Slot (ohne Lagerlinien) und die Lagerlinien in Reihenfolge.""" slots: dict[str, str] = {} lines: list[str] = [] for slot in derive_slots(tro): if slot_kind(slot.slot) == "line": lines.append(slot.layout_id) else: slots[slot.slot] = slot.layout_id return slots, lines def format_slots(slots: dict[str, str], lines: list[str]) -> str: """Attribut SLOTS: 'separator1=0010;switch1=;lines=0066,0069'.""" text = ";".join(f"{k}={v}" for k, v in slots.items()) if lines: text += (";" if text else "") + "lines=" + ",".join(lines) return text def parse_slots(text: str) -> tuple[dict[str, str], list[str] | None]: """Gegenstueck zu format_slots; lines ist None, wenn das Attribut keine nennt.""" slots: dict[str, str] = {} lines: list[str] | None = None for part in text.split(";"): key, sep, value = (t.strip() for t in part.partition("=")) if not sep or not key: continue if key.lower() == "lines": lines = [v.strip() for v in value.split(",") if v.strip()] else: slots[key.lower()] = value return slots, lines def write_parts(doc, elements, transform: Transform) -> int: """Bauteile, die in einen Slot passen, als XRECORD in die Zeichnung legen.""" kinds = {k for v in SLOT_PART_KINDS.values() for k in v} tags: list[tuple[int, object]] = [] for e in elements: if e.kind not in kinds or e.position is None or not e.teile_id: continue x, y = transform.to_dxf(e.x, e.y) w, h = (e.bbox[0] / 2, e.bbox[1] / 2) if e.bbox else (0.0, 0.0) tags += [(1, e.teile_id), (3, e.kind), (10, (x, y, 0.0)), (40, w), (41, h)] root = doc.rootdict if PARTS_XRECORD in root: root.remove(PARTS_XRECORD) xrecord = root.add_xrecord(PARTS_XRECORD) xrecord.reset(tags) return len(tags) // 5 def read_markers(dxf_file: Path) -> list[dict[str, str]]: """Attribute aller TRO-Marker (Bloecke TRO_SYM_*) der Zeichnung.""" doc = ezdxf.readfile(str(dxf_file)) markers = [] for ref in doc.modelspace().query("INSERT"): if not ref.dxf.name.upper().startswith(BLOCK_PREFIX): continue a = {att.dxf.tag.upper(): (att.dxf.text or "").strip() for att in ref.attribs} a["_BLOCK"] = ref.dxf.name markers.append(a) return markers def read_tros(markers: list[dict[str, str]], raw: Analysis, elements, csv_name: str, cfg_dir: Path | None = None, write: bool = True) -> tuple[list[TroEdit], list[str]]: """Marker der Zeichnung mit der Ableitung vergleichen -> Handkorrekturen. ``raw`` ist die Ableitung OHNE Handkorrekturen (IDs aus der ID-Datei). Je Marker mit KEY eines abgeleiteten TRO entsteht ein edit-Abschnitt, wenn Typ, Kennung oder Bauteile abweichen; ein Marker ohne passenden KEY ist ein neuer TRO (edit_add); ein abgeleiteter TRO mit Lage, zu dem kein Marker mehr da ist, wurde geloescht. Die Abschnitte ersetzen alle bisherigen edit-/edit_add-Abschnitte der CSV in tro_overrides.ini (Begruendungen bleiben). Rueckgabe: (Korrekturen, Meldungen). """ meldungen: list[str] = [] by_id = {e.teile_id: e for e in elements} alt = {(e.section_kind, e.key): e for e in load_overrides(csv_name, cfg_dir).edits} def ref(teile_id: str) -> PartRef: if not teile_id: return PartRef() element = by_id.get(teile_id.split("-", 1)[0]) if element is None or element.position is None: return PartRef(teile_id=teile_id) return PartRef(teile_id=teile_id, x=element.x, y=element.y) def pruefen(where: str, type_name: str, slots: dict[str, str], lines: list[str]) -> None: for slot in slot_names(type_name): teile_id = slots.get(slot, "") if not teile_id: if slot.startswith("separator"): meldungen.append(f"{where}: {slot} ist leer") continue element = by_id.get(teile_id.split("-", 1)[0]) kinds = SLOT_PART_KINDS[slot_kind(slot)] if element is None: meldungen.append(f"{where}: {slot} = {teile_id} steht nicht im Export") elif element.kind not in kinds: meldungen.append(f"{where}: {slot} = {teile_id} ist ein {element.kind}, " f"erwartet {'/'.join(kinds)}") if has_lines(type_name) and not lines: meldungen.append(f"{where}: Speicher ohne Lagerlinie") raw_by_id = {t.tro_id: t for t in raw.tros} edits: list[TroEdit] = [] gesehen: set[str] = set() vergeben: dict[str, str] = {} ids: dict[str, str] = {} for m in markers: tro_id, key = m.get("ID", ""), m.get("KEY", "") type_name = m.get("TYPE", "") or m["_BLOCK"][len(BLOCK_PREFIX):] where = f"Marker {tro_id or '?'}" if not tro_id: meldungen.append(f"{where} ({m['_BLOCK']}): ohne ID - uebersprungen") continue if get_tro(type_name) is None: meldungen.append(f"{where}: Typ '{type_name}' steht nicht im Katalog - " f"uebersprungen") continue if problem := id_problem(tro_id): meldungen.append(f"{where}: {problem} - uebersprungen") continue if tro_id in ids: meldungen.append(f"{where}: Kennung doppelt (auch {ids[tro_id]})") ids[tro_id] = key or tro_id slots, lines = parse_slots(m.get("SLOTS", "")) if key in gesehen: # kopierter Marker: gleicher KEY wie ein schon gelesener meldungen.append(f"{where}: KEY {key} doppelt (Marker kopiert?) - als " f"neuer TRO gelesen") key = "" derived = raw_by_id.get(key) if derived is not None: gesehen.add(key) raw_slots, raw_lines = tro_slots(derived) else: raw_slots, raw_lines = {}, [] if lines is None: lines = raw_lines if has_lines(type_name) else [] pruefen(where, type_name, slots, lines) for teile_id in [v for v in slots.values() if v] + lines: if teile_id in vergeben and vergeben[teile_id] != tro_id: meldungen.append(f"{where}: Bauteil {teile_id} steckt auch in " f"{vergeben[teile_id]}") vergeben[teile_id] = tro_id names = slot_names(type_name) if derived is None: edit = TroEdit(key=tro_id, add=True, type_name=type_name, slots={s: ref(slots.get(s, "")) for s in names}, lines=[ref(t) for t in lines] if has_lines(type_name) else None) else: edit = TroEdit(key=key) if type_name != derived.type_name: edit.type_name = type_name if tro_id != key: edit.name = tro_id if any(slots.get(s, "") != raw_slots.get(s, "") for s in names): edit.slots = {s: ref(slots.get(s, "")) for s in names} if has_lines(type_name) and lines != raw_lines: edit.lines = [ref(t) for t in lines] if edit.is_empty(): continue if (vorher := alt.get((edit.section_kind, edit.key))) is not None: edit.reason = vorher.reason edits.append(edit) meldungen.append(_describe_edit(edit)) for tro in raw.tros: if tro.tro_id in gesehen or not tro.position: continue edit = TroEdit(key=tro.tro_id, delete=True) if (vorher := alt.get(("edit", tro.tro_id))) is not None: edit.reason = vorher.reason edits.append(edit) meldungen.append(_describe_edit(edit)) if write: save_edits(csv_name, edits, cfg_dir) return edits, meldungen def _describe_edit(edit: TroEdit) -> str: if edit.delete: return f"{edit.key}: geloescht" teile = [] if edit.add: teile.append(f"neu ({edit.type_name})") elif edit.type_name: teile.append(f"Typ -> {edit.type_name}") if edit.name: teile.append(f"Kennung -> {edit.name}") if edit.slots is not None and not edit.add: teile.append("Bauteile " + ", ".join( f"{k}={r.teile_id or '-'}" for k, r in edit.slots.items())) if edit.lines is not None: teile.append(f"{len(edit.lines)} Lagerlinien") return f"{edit.key}: {'; '.join(teile)}" def draw_legend( msp, analysis: Analysis, placed: dict[str, tuple[float, float]], layers: dict[str, str], marker: float, text: float, source: str, ) -> None: """Legende links unterhalb der beschrifteten Objekte.""" if not placed: return x0 = min(p[0] for p in placed.values()) - marker * 12 y0 = min(p[1] for p in placed.values()) - marker * 6 row = text * 2.2 title = msp.add_text( f"TRO-Beschriftung - {source}", height=text * 1.5, dxfattribs={"layer": layers["legend"], "style": "Standard"}, ) title.set_placement((x0, y0 + row)) tag(title) # Wie die Legende im TRO-Fluss-SVG: je vorkommendem Typ Fuellfarbe, Rand # der Gruppe und Form, danach die Kantenfarben. used = {t.type_name for t in analysis.tros} zeilen: list[tuple[str, str | None, str | None]] = [] for definition in TRO_CATALOG: if definition.get_name() in used: zeilen.append((f"{definition.get_name()} - {definition.describe_symbol()}", definition.get_fill(), layers.get(definition.get_group(), layers["ext"]))) pfeile = [("eingang", "Materialeingang (Beladung / Eingang)"), ("ausgang", "Materialausgang (Entladung / Ausgang)"), ("flow", "Uebergabe / Ein-Ausschleusung"), ("weiche", "Weiche (Kreisel-Uebergang)")] y = y0 for beschriftung, fill, rand_layer in zeilen: quadrat = [(x0, y), (x0 + text, y), (x0 + text, y - text), (x0, y - text)] box = msp.add_hatch(dxfattribs={"layer": layers["legend"], "true_color": ezdxf.rgb2int(hex_to_rgb(fill))}) box.paths.add_polyline_path(quadrat, is_closed=True) tag(box) rand = msp.add_lwpolyline(quadrat, close=True, dxfattribs={"layer": rand_layer}) tag(rand) label = msp.add_text(beschriftung, height=text, dxfattribs={"layer": layers["legend"], "style": "Standard"}) label.set_placement((x0 + text * 1.8, y - text)) tag(label) y -= row for key, beschriftung in pfeile: mitte = y - text / 2 linie = msp.add_lwpolyline([(x0 - text * 0.5, mitte), (x0 + text * 0.9, mitte)], dxfattribs={"layer": layers[key]}) tag(linie) spitze = msp.add_solid([(x0 + text * 1.4, mitte), (x0 + text * 0.9, mitte + text * 0.3), (x0 + text * 0.9, mitte - text * 0.3)], dxfattribs={"layer": layers[key]}) tag(spitze) label = msp.add_text(beschriftung, height=text, dxfattribs={"layer": layers[key], "style": "Standard"}) label.set_placement((x0 + text * 1.8, y - text)) tag(label) y -= row # --------------------------------------------------------------------------- # Bericht # --------------------------------------------------------------------------- def report( analysis: Analysis, transform: Transform, csv_file: Path, dxf_file: Path, out_file: Path | None, reg_file: Path | None, counts: dict, warnings: list[str], ) -> None: print("") print("================================================================") print("TRO-BESCHRIFTUNG") print("================================================================") print(f"CSV = {csv_file}") print(f"Zeichnung = {dxf_file}") print(f"Lagebezug = {transform.describe()}") print(f" Herkunft = {transform.source}" + (f", ermittelt {transform.created}" if transform.created else "")) print(f" Nachweis = {transform.anchor}") print(f" Restfehler = max {transform.residual_max:.1f} mm, " f"mittel {transform.residual_mean:.1f} mm " f"({transform.matched}/{transform.candidates} Punkte)") print(f"TROs = {len(analysis.tros)}, beschriftet: {counts['marker']}" + (f" (Handkorrekturen: {len(analysis.renamed)} umbenannt, " f"{len(analysis.added)} neu)" if analysis.renamed or analysis.added else "")) if counts.get("parts"): print(f"Bauteile = {counts['parts']} (XRECORD {PARTS_XRECORD}, fuer " f"TRO_EDIT 'Im Plan waehlen'; uebernehmen mit --read-tros)") print(f"Verbindungen = {counts['flow']}" + (" (Block CONNECTION_ARROW mit FROM_UID/TO_UID)" if counts["flow"] else "")) if counts.get("jams"): print(f"Staubereiche = {counts['jams']} (Block {JAM_BLOCK}, Doppelklick -> " f"JAM_EDIT; uebernehmen mit --read-jams)") if counts.get("first_id"): print(f"Interne IDs ab = {format_internal_id(counts['first_id'])} " f"(ID-Raum von SSG_LIB, siehe IDSCHECK)") print(f"Entfernte Objekte= {counts['removed']} (aus frueherem Lauf)") print(f"Layer = {counts['layers']}, Bloecke: {counts['blocks']}") print(f"DXF = {out_file if out_file else '- (--check)'}") print(f"Lagebezug-Datei = {reg_file if reg_file else '-'}") print("================================================================") if warnings: print("") print(f"Hinweise ({len(warnings)}):") for warning in warnings: print(f" ! {warning}") print("") # --------------------------------------------------------------------------- # CLI # --------------------------------------------------------------------------- def parse_args(argv: list[str] | None = None) -> argparse.Namespace: parser = argparse.ArgumentParser( prog="tro_annotate", description="Blendet die ermittelten TROs in eine Kopie der " "BricsCAD-Zeichnung ein (DXF).", formatter_class=argparse.RawDescriptionHelpFormatter, epilog="Beispiele:\n" " tro_annotate.bat --file mubea.csv --dxf 500573_60_1.dxf --check\n" " tro_annotate.bat --file mubea.csv --dxf 500573_60_1.dxf --flow --fb\n" " tro_annotate.bat --file dematic_merge.csv --dxf dematic_merge..dxf --flow " "--anlage dematic_merge_anlage.json\n" " tro_annotate.bat --file dematic_merge.csv --read-jams\n" " tro_annotate.bat --file mubea.csv --read-tros --check\n" "\n" "Exit-Codes:\n" " 0 ok\n" " 1 Eingabe- oder Aufruffehler\n" " 4 Lagebezug nicht nachweisbar\n", ) parser.add_argument("--file", default="export.csv", metavar="NAME", help="CSV-Export in %%SKEL_DATA%% oder ein Pfad. " "Standard: %(default)s") parser.add_argument("--dxf", metavar="NAME", help="Originalzeichnung als DXF (Pfad oder Name in " "%%SKEL_DATA%%). Ausser bei --emit-lisp erforderlich.") parser.add_argument("--out", metavar="NAME", help="Name der Ausgabedatei in %%SKEL_RESULTS%%. " "Standard: _annotated.dxf") parser.add_argument("--flow", action="store_true", help="Pfeile fuer den Materialfluss zwischen den TROs " "zeichnen.") parser.add_argument("--fb", action="store_true", help="Den Siemens-Funktionsbaustein als sichtbares " "Attribut am Marker anzeigen.") parser.add_argument("--legend", action="store_true", help="Legende der Farbgruppen einzeichnen.") parser.add_argument("--marker-size", type=float, default=DEFAULT_MARKER, metavar="MM", help="Markerradius in mm. Standard: %(default)s") parser.add_argument("--text-height", type=float, default=DEFAULT_TEXT, metavar="MM", help="Texthoehe in mm. Standard: %(default)s") parser.add_argument("--ids", metavar="DATEI", help="ID-Datei der TROs wie bei tro_flow (nur gelesen). " "Standard: _tro_ids.ini in %%SKEL_CFG%%.") parser.add_argument("--offset", metavar="DX,DY", help="Lagebezug von Hand setzen statt ermitteln.") parser.add_argument("--re-register", action="store_true", help="Lagebezug neu ermitteln, auch wenn in %%SKEL_CFG%% " "einer abgelegt ist.") parser.add_argument("--anlage", metavar="NAME", help="Anlagen-JSON (_anlage.json aus merge_hw_layout, in " "%%SKEL_RESULTS%% oder ein Pfad): zusaetzlich die " "Staubereiche als JAM_AREA-Bloecke einzeichnen " "(Jam_, Doppelklick -> Dialog JAM_EDIT).") parser.add_argument("--read-jams", nargs="?", const="", default=None, metavar="DXF", help="Im Dialog JAM_EDIT geaenderte Staubereichs-Nummern aus der " "beschrifteten Zeichnung uebernehmen (Standard: " "_annotated.dxf in %%SKEL_RESULTS%%) und nach " "%%SKEL_CFG%%\\_jam_names.ini schreiben, dann beenden. " "scl_skeleton liest die Datei.") parser.add_argument("--read-tros", nargs="?", const="", default=None, metavar="DXF", help="Im Dialog TRO_EDIT/TRO_INSERT geaenderte, neue und " "geloeschte TRO-Marker aus der beschrifteten Zeichnung " "uebernehmen (Standard: _annotated.dxf in " "%%SKEL_RESULTS%%) und als Abschnitte edit/edit_add nach " "%%SKEL_CFG%%\\tro_overrides.ini schreiben, dann beenden. " "tro_flow und tro_annotate wenden sie an.") parser.add_argument("--check", action="store_true", help="Nur pruefen und berichten, keine Datei schreiben.") parser.add_argument("--emit-lisp", action="store_true", help="cad/tro_types.lsp aus dem Typkatalog neu schreiben " "(Auswahlliste des Dialogs TROEDIT) und beenden.") return parser.parse_args(argv) def _main_read_jams(args, csv_file: Path) -> int: """--read-jams: Nummern aus der beschrifteten Zeichnung -> _jam_names.ini.""" results = env_dir("SKEL_RESULTS", "results") name = args.read_jams or args.out or f"{csv_file.stem}_annotated.dxf" dxf_file = Path(name) if not dxf_file.is_absolute() and dxf_file.parent == Path("."): dxf_file = results / name if not dxf_file.is_file(): print(f"FEHLER: beschriftete Zeichnung nicht gefunden: {dxf_file}", file=sys.stderr) print(" In BricsCAD als DXF speichern (Dateiname wie beim Beschriften).", file=sys.stderr) return 1 ini_file = env_dir("SKEL_CFG", "cfg") / f"{csv_file.stem}{JAM_NAMES_SUFFIX}" try: overrides, meldungen = read_jams(dxf_file, ini_file) except (OSError, ValueError, configparser.Error, ezdxf.DXFError) as exc: print(f"FEHLER: {exc}", file=sys.stderr) return 1 print("") print("================================================================") print("STAUBEREICHE UEBERNEHMEN") print("================================================================") print(f"Zeichnung = {dxf_file}") print(f"Korrekturen = {len(overrides)} -> {ini_file if overrides else '- (keine, Datei entfernt)'}") for m in meldungen: print(f" {m}") print("Danach: scl_skeleton mit der Anlagen-JSON neu laufen lassen.") print("================================================================") print("") return 0 def _derive(args, csv_file: Path, edits: list[TroEdit] | None): """CSV lesen und die TROs ableiten - (Elemente, Analysis) oder None. Derselbe Aufruf wie in tro_flow.main (mit der Separator-Gegenprobe aus _raw.json, der ID-Datei und den Handkorrekturen), damit die Zeichnung genau die TROs der TRO-JSON zeigt - sie ist nur Ansicht, keine Datenquelle. --read-tros vergleicht mit der Ableitung ohne Korrekturen (edits=None). """ read_warnings: list[str] = [] try: elements = read_elements(csv_file, read_warnings) except (OSError, ValueError, csv_module.Error) as exc: print(f"FEHLER: {csv_file} nicht lesbar: {exc}", file=sys.stderr) return None graph = build_graph(elements, csv_file.name, read_warnings) raw_json_file = find_sibling_raw_json(csv_file) sepliste_counts = (load_sepliste_counts(raw_json_file, read_warnings) if raw_json_file is not None else {}) # Dieselbe ID-Datei wie tro_flow, aber nur lesen: neue TROs bekommen # dieselbe vorlaeufige ID, die tro_flow anhaengen wuerde. ids_file = resolve_ids_file(args.ids, csv_file) try: tro_ids = TroIds.load(ids_file) if ids_file.is_file() else None except (OSError, ValueError) as exc: print(f"FEHLER: ID-Datei nicht lesbar: {exc}", file=sys.stderr) return None analysis = analyse_tros(graph, elements, sepliste_counts=sepliste_counts, tro_ids=tro_ids, edits=edits) if not analysis.tros: print(f"FEHLER: keine TROs aus {csv_file} ableitbar.", file=sys.stderr) return None return elements, analysis def _main_read_tros(args, csv_file: Path) -> int: """--read-tros: Marker der beschrifteten Zeichnung -> tro_overrides.ini.""" results = env_dir("SKEL_RESULTS", "results") cfg_dir = env_dir("SKEL_CFG", "cfg") name = args.read_tros or args.out or f"{csv_file.stem}_annotated.dxf" dxf_file = Path(name) if not dxf_file.is_absolute() and dxf_file.parent == Path("."): dxf_file = results / name if not dxf_file.is_file(): print(f"FEHLER: beschriftete Zeichnung nicht gefunden: {dxf_file}", file=sys.stderr) print(" In BricsCAD als DXF speichern (Dateiname wie beim Beschriften).", file=sys.stderr) return 1 if not csv_file.is_file(): print(f"FEHLER: CSV nicht gefunden: {csv_file}", file=sys.stderr) return 1 try: markers = read_markers(dxf_file) except (OSError, ezdxf.DXFError) as exc: print(f"FEHLER: {dxf_file} nicht lesbar: {exc}", file=sys.stderr) return 1 derived = _derive(args, csv_file, None) if derived is None: return 1 elements, raw = derived # Schutz: eine falsche Zeichnung (ohne oder mit fremden Markern) wuerde # sonst alle TROs als geloescht eintragen. keys = {m.get("KEY", "") for m in markers} if not markers or not keys & {t.tro_id for t in raw.tros}: print(f"FEHLER: {dxf_file.name} enthaelt keine Marker zu den TROs aus " f"{csv_file.name} ({len(markers)} Marker) - nichts geschrieben. Zeichnung " f"mit dem aktuellen tro_annotate neu beschriften?", file=sys.stderr) return 1 try: edits, meldungen = read_tros(markers, raw, elements, csv_file.name, cfg_dir, write=not args.check) except (OSError, configparser.Error) as exc: print(f"FEHLER: {exc}", file=sys.stderr) return 1 print("") print("================================================================") print("TRO-HANDKORREKTUREN UEBERNEHMEN") print("================================================================") print(f"Zeichnung = {dxf_file} ({len(markers)} Marker)") ziel = override_path(cfg_dir) print(f"Korrekturen = {len(edits)} -> " f"{'- (--check, nichts geschrieben)' if args.check else ziel}") for m in meldungen: print(f" {m}") print("Danach: tro_flow --json (und tro_annotate) neu laufen lassen.") print("================================================================") print("") return 0 def main(argv: list[str] | None = None) -> int: args = parse_args(argv) warnings: list[str] = [] if args.emit_lisp: path = emit_lisp(lisp_dir()) print(f"Typliste geschrieben: {path} ({len(TRO_CATALOG)} Typen)") if not os.environ.get("DXFM_LISP"): print("HINWEIS: DXFM_LISP nicht gesetzt - die Datei gehoert neben die " "SSG_LIB-Module (dxfmakros/Lisp), damit TRO_EDIT sie findet.") return 0 csv_file = resolve_input(args.file) if csv_file.suffix.lower() != ".csv": print(f"FEHLER: --file erwartet eine CSV-Datei, keine '{csv_file.suffix}'-Datei: " f"{csv_file}", file=sys.stderr) return 1 if args.read_jams is not None: return _main_read_jams(args, csv_file) if args.read_tros is not None: return _main_read_tros(args, csv_file) if not args.dxf: print("FEHLER: --dxf fehlt (nur --emit-lisp, --read-jams und --read-tros gehen " "ohne Zeichnung).", file=sys.stderr) return 1 if not csv_file.is_file(): print(f"FEHLER: CSV nicht gefunden: {csv_file}", file=sys.stderr) return 1 dxf_file = Path(args.dxf) if not dxf_file.is_absolute() and dxf_file.parent == Path("."): dxf_file = env_dir("SKEL_DATA", "data") / args.dxf if not dxf_file.is_file(): print(f"FEHLER: Zeichnung nicht gefunden: {dxf_file}", file=sys.stderr) return 1 if dxf_file.suffix.lower() == ".dwg": print("FEHLER: DWG wird nicht unterstuetzt - bitte als DXF exportieren.", file=sys.stderr) return 1 results = env_dir("SKEL_RESULTS", "results") cfg_dir = env_dir("SKEL_CFG", "cfg") results.mkdir(parents=True, exist_ok=True) # Anlagen-JSON fuer die Staubereiche (optional) anlage = None jam_overrides: dict[str, tuple[str, int]] = {} if args.anlage: anlage_file = Path(args.anlage) if not anlage_file.is_absolute() and anlage_file.parent == Path("."): anlage_file = results / args.anlage try: text = anlage_file.read_text(encoding="utf-8") if json.loads(text).get("schema") != ANLAGE_SCHEMA: raise ValueError(f"kein Schema '{ANLAGE_SCHEMA}' - erwartet wird die " f"Anlagen-JSON aus merge_hw_layout") anlage = AnlageDocument.from_json(text) jam_overrides = load_jam_overrides( cfg_dir / f"{csv_file.stem}{JAM_NAMES_SUFFIX}") except (OSError, ValueError, configparser.Error) as exc: print(f"FEHLER: Anlagen-JSON {anlage_file} nicht lesbar: {exc}", file=sys.stderr) return 1 if Path(anlage.layout.source).name != csv_file.name: print(f"FEHLER: {anlage_file.name} gehoert zu '{anlage.layout.source}', " f"nicht zu '{csv_file.name}'.", file=sys.stderr) return 1 # TROs aus dem CSV, mit den Handkorrekturen aus tro_overrides.ini overrides = load_overrides(csv_file.name, cfg_dir) warnings += [w for w in overrides.warnings if ".edit" in w] derived = _derive(args, csv_file, overrides.edits) if derived is None: return 1 elements, analysis = derived # Zeichnung try: doc = ezdxf.readfile(str(dxf_file)) except (OSError, ezdxf.DXFError) as exc: print(f"FEHLER: {dxf_file} nicht lesbar: {exc}", file=sys.stderr) return 1 msp = doc.modelspace() # Lagebezug try: transform = resolve_transform(args, elements, msp, cfg_dir, csv_file.name, dxf_file.name, warnings) except RegistrationError as exc: print(f"FEHLER: Lagebezug nicht bestimmbar: {exc}", file=sys.stderr) return 4 if transform.residual_max > DEFAULT_MAX_RESIDUAL: print(f"FEHLER: Restfehler des Lagebezugs {transform.residual_max:.1f} mm " f"ueber der Grenze von {DEFAULT_MAX_RESIDUAL:.1f} mm.", file=sys.stderr) print(f" {transform.describe()}", file=sys.stderr) print(" Mit --offset von Hand setzen.", file=sys.stderr) return 4 counts = {"marker": 0, "flow": 0, "removed": 0, "layers": 0, "blocks": 0, "first_id": 0, "jams": 0} if anlage is not None: aus_csv = {t.tro_id for t in analysis.tros} aus_json = {t.tro_id for t in anlage.layout.tros} if aus_csv != aus_json: warnings.append( f"TROs der Zeichnung und der Anlagen-JSON weichen ab (nur CSV: " f"{', '.join(sorted(aus_csv - aus_json)) or '-'}; nur JSON: " f"{', '.join(sorted(aus_json - aus_csv)) or '-'}) - tro_flow --json und " f"merge_hw_layout neu laufen lassen") if args.check: counts["marker"] = sum(1 for t in analysis.tros if t.position) report(analysis, transform, csv_file, dxf_file, None, None, counts, warnings) return 0 ensure_appid(doc) counts["removed"] = remove_previous(msp) layers = build_layers(doc, LAYER_PREFIX) counts["layers"] = len({v for v in layers.values()}) # Interne IDs erst NACH remove_previous suchen: die Marker des letzten Laufs # sind dann weg und ihre Nummern wieder frei. next_id = next_internal_id(msp, elements) placed, internal = place_markers( msp, doc, analysis, transform, layers, args.marker_size, args.text_height, args.fb, warnings, next_id=next_id, ) counts["marker"] = len(placed) counts["blocks"] = sum(1 for b in doc.blocks if b.name.startswith(BLOCK_PREFIX)) counts["first_id"] = next_id counts["parts"] = write_parts(doc, elements, transform) if args.flow: # Stationen nur mit --flow: sie bestehen aus ihrem Zu-/Ablaufpfeil stationen = place_stations(msp, analysis, placed, layers, args.text_height) counts["flow"] = draw_connections( msp, doc, analysis, {**placed, **stationen}, internal, layers, args.marker_size, args.text_height, next_id=next_id + len(placed), ) if anlage is not None: counts["jams"] = place_jams(msp, doc, anlage, jam_overrides, transform, layers, args.text_height, warnings, marker=args.marker_size) if args.legend: draw_legend(msp, analysis, placed, layers, args.marker_size, args.text_height, csv_file.name) out_file = results / (args.out or f"{csv_file.stem}_annotated.dxf") try: doc.saveas(str(out_file)) except PermissionError: print(f"FEHLER: {out_file} laesst sich nicht schreiben - ist die Zeichnung noch " f"in BricsCAD geoeffnet? Schliessen und neu starten, oder --out .", file=sys.stderr) return 1 reg_file = results / f"{csv_file.stem}_registration.json" reg_file.write_text( json.dumps(transform.model_dump(), indent=2, ensure_ascii=False) + "\n", encoding="utf-8", ) report(analysis, transform, csv_file, dxf_file, out_file, reg_file, counts, warnings) return 0 if __name__ == "__main__": sys.exit(main())