diff --git a/CLAUDE.md b/CLAUDE.md index 0624f58..64a1533 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -105,7 +105,7 @@ Detaillierte Dokumentation aller Funktionen und Befehle: siehe `Lisp/README.md`. | `ssg_blocktools.lsp` | SSG_BLOCK_COUNT, SSG_BLOCK_DELETE, SSG_ATTR_ERSETZEN | Block-Werkzeuge fuer das aktuelle Layout (Ursprung ACADSST `TOOLS.LSP`/`ssg.lsp`): Einfuegungen zaehlen (Pick, wcmatch-Muster oder Statistik aller Bloecke), alle Einfuegungen loeschen (Rueckfrage, gesperrte Layer bleiben), Attributwerte zeichnungsweit/in Auswahl suchen+ersetzen (Vorschau mit Anzahl, Teilstring oder Gesamtwert). Wirksamer Blockname (dynamische Bloecke). Reine Kerne `ssg-bt-name-passt-p`, `ssg-bt-zaehle-namen`, `ssg-bt-wert-neu` in `tests/test_unit.lsp` getestet | | `ssg_texttools.lsp` | SSG_TEXT_ERSETZEN, SSG_TEXT_PARALLEL, SSG_TEXT_HOEHE, SSG_TEXT_STIL | Text-Werkzeuge (Ursprung ACADSST `CHGTEXT`/`PARTEXT`/`ALTHOEHE`/`ALTSTIL`): Suchen/Ersetzen in TEXT, MTEXT und Block-Attributen (nutzt `ssg-bt-*`, daher NACH `ssg_blocktools` laden), Text parallel zu Linie/Polylinie/Bogen (lesbar ausgerichtet, Abstand), Hoehe/Stil aendern. Arbeitet in der XY-Ebene des Welt-KS. Reine Kerne `ssg-tt-lesbarer-winkel`, `ssg-tt-versetzt` getestet | | `ssg_stueckliste.lsp` | SSG_FAEHNCHEN_STUECKLISTE | Positions-Faehnchen + Stuecklistentabelle, komplett AUS DER ZEICHNUNG - es wird keine Datei eingelesen. Der Benutzer waehlt die Elemente aus (`ssg-sl-erkannte-elemente`: `ssget`-Auswahl, Enter ohne Auswahl = alle erkannten im aktuellen Layout; der reine Filter `ssg-sl-elemente-aus-ss` laesst nicht erkannte Objekte still wegfallen, man darf also grosszuegig ein Fenster aufziehen). `ssg-sl-klasse` klassifiziert Blocknamen (`KREISEL_*`/`ECKRAD_*` -> "ILS Kreisel/Eckrad", `VF_*`/`GF_*` -> "ILS Streckengruppe", `GR_*` -> "Rohrgeruest", `AP60*`/`AP110*`/`AP_110*`/`APG110*` -> je eigene Omniflo-Geraden-Gruppe; wirksamer Blockname ueber `ssg-bt-effname`, also auch dynamische Bloecke). Jedes einzelne Element bekommt ein Faehnchen (`ssg-sl-faehnchen`, Rechteck/Kreis/Automation-Rahmen + Text) an der unteren linken Ecke seiner Bounding-Box (aus `csv:get-bbox` - liefert Zentrum+Abmessungen, NICHT Eckpunkte, die Ecke wird im Code daraus berechnet); die Tabelle (`ssg-sl-tabelle-zeichnen`) gruppiert GROB je Elementklasse (keine Sivas-Artikelaufloesung wie `export_sivas.py`) zu einer Zeile mit Anzahl + Laengensumme aus dem `LAENGE`-Attribut (`ssg-sl-gruppieren`/reiner Kern `ssg-sl-gruppieren-werte`), mehrere gleichartige Elemente tragen daher dieselbe Positionsnummer. **Bewusst KEIN Datei-Import wie bei Walz/Bihler**: dort vergab ein externes System die Positionsnummern und lieferte sie als Datei zurueck, die das CAD nur abzeichnete - bei Walz (`MENU/POSITION.LSP`) eine `.pos`/`.zei` aus einem Clipper-Warenwirtschaftssystem mit Koordinaten-Zuordnung, bei Bihler ITB (`Walz_und_Bihler/SBCADBib/ITB-Module_ori.lsp`, `c:bea_pos`) eine `.pos` mit Zuordnung ueber den Entity-Handle. Diese Umwege sind hier nicht nachgebaut (Entscheidung 2026-10): Nummern und Mengen entstehen in dieser Funktion, die Stuecklisten-AUSGABE liefern EXPORTSIVAS/EXPORTCSV aus denselben Block-Attributen. Der alte `c:stueckl` (Laengen-Summierung ueber hartcodierte Walz-Profillayer wie `L-2`=ST, `A-7`=AP110) hat ebenfalls kein Aequivalent im dxfmakros-Datenmodell (Block-Attribute statt Linien-Layer). Braucht `csv:get-bbox`/`csv:get-attrib` aus `export.lsp` und `ssg-bt-effname` aus `ssg_blocktools.lsp` - muss daher NACH beiden geladen werden (siehe `ssg-ensure`-Reihenfolge in `SSG_LIB.mnl`/`ssg_load.lsp`). Reine Kerne `ssg-sl-klasse`, `ssg-sl-gruppieren-werte` in `tests/test_unit.lsp` getestet | -| `KreiselInsert.lsp` | KreiselInsert, KreiselConnect, KreiselRedraw, KreiselQuick, KreiselEdit, KreiselParams, KreiselLabelSetup, KreiselLabelPos, KreiselLabelHoehe, ILS_Eckrad, EckradEdit, KREISEL_WEICHEN | ILS Kreisel und Eckrad komplett in AutoLISP. **Beruehrpunkte/Weichen** (`kreisel-bp-*`, Befehl KREISEL_WEICHEN, Menue Kreisel-Module -> Weichenpunkte ermitteln): ermittelt aus den Blockparametern (Einfuegepunkt, Drehung, ABSTAND - nicht aus der Geometrie, Modell wie `draw-module`) die Beruehrpunkte aller `KREISEL_*`/`ECKRAD_*` GLEICHER Hoehe (`toleranz_hoehe`): Rad/Rad (`Kreis/Kreis`) und Rad/Laufprofil (`Kreis/Tangente`), nur auf der freien Radseite (aeusserer Halbkreis inkl. Flanken; Eckrad ganz frei), Toleranz `toleranz_beruehrung` (component_defaults.json, Sektion kreisel). Kapsel-Mindestabstand < 2r - tol = KOLLISION (Ueberschneidung), Kreisel Seite an Seite (Beruehrung nur an Flanke/Profil) = KOLLISION `Tangente/Tangente` - beide werden gemeldet, aber nie zur Weiche. Ausgabe: Konsolenliste + Kreis-Marker (Layer `kreisel_weiche`/`kreisel_kollision` aus layer.cfg, XDATA `SSG_KR_WEICHE`, jeder Lauf ersetzt die alten). Der Export schreibt dieselben Punkte als `kreisel_weichen.json` neben `export_raw.json` (`csv:kreisel-weichen-schreiben`, export.lsp); `export_csv.py` uebernimmt sie (`export_neighbors.load_lisp_kreisel_weichen`/`lisp_touch_switches`, Rueckfall auf `compute_kreisel_touch_switches` nur ohne Datei), `export_sivas.py` setzt daraus Merkmal 4403 "Anzahl Weichen ILS". Reine Kerne `kreisel-bp-element`/`-paar`/`-berechnen` in `tests/test_unit.lsp` (`tu-tests-kreisel-bp`, u.a. mit den 11 Einfuegungen aus `tests/testdata/schnittspunkte_kreisel.dxf` -> 10 Beruehrungen) getestet. Eckrad: eigener Dialog `eckrad_edit.dcl` (`eckrad-dialog`, reiner Kern `eckrad-dialog-werte` getestet) beim Einfuegen (ILS_Eckrad, ohne GUI Konsolen-Rueckfall) und per Doppelklick (EckradEdit); kein Abstand/Typ, Drehung als freier Winkel statt fester Kreisel-Ausrichtung. `ils-eckrad-insert` behaelt eine vorhandene NUMMER (Edit -> gleicher Blockname `ECKRAD_n`). Kreiselname: `draw-module` setzt `Bezeichnung` nur noch bei leerem Wert auf die Vorgabe `KreiselN` (eigener Name aus KreiselEdit bleibt erhalten); Beschriftung `kreisel-label-text` = `KREISEL n: _` (ohne Namen bzw. bei Vorgabename wie bisher `KREISEL n: _`); da die Beschriftung als TEXT in der wiederverwendeten Blockdefinition `KREISEL_n_TYP_ABSTAND` steckt, setzt `kreisel-label-aktualisieren` sie dort per `entmod` neu (wirkt auf alle Referenzen der Definition) | +| `KreiselInsert.lsp` | KreiselInsert, KreiselConnect, KreiselRedraw, KreiselQuick, KreiselEdit, KreiselParams, KreiselLabelSetup, KreiselLabelPos, KreiselLabelHoehe, ILS_Eckrad, EckradEdit, KREISEL_WEICHEN | ILS Kreisel und Eckrad komplett in AutoLISP. **Drehrichtungspfeil**: `draw-module` fuegt `data/ils/Drehrichtungspfeil.dwg` auf AN8-Mitte (Block-KS 90 Grad, da die DWG fuer Kreisel Nord->Sued gezeichnet ist; cfg `kreisel.pfeil_winkel`) und SP8-Mitte (+180) mit in den KREISEL_n-Block ein, GUZ = X-Skalierung -1 (reiner Kern `kreisel-pfeil-params`, getestet); Eckrad: ein Pfeil auf der Radmitte mit dem AN8-Winkel (`eckrad-pfeil-params`); bei wiederverwendeter Blockdefinition (KREISEL_n bzw. ECKRAD_n) zieht `kreisel-pfeil-aktualisieren` die Spiegelung per `entmod` nach. **Beruehrpunkte/Weichen** (`kreisel-bp-*`, Befehl KREISEL_WEICHEN, Menue Kreisel-Module -> Weichenpunkte ermitteln): ermittelt aus den Blockparametern (Einfuegepunkt, Drehung, ABSTAND - nicht aus der Geometrie, Modell wie `draw-module`) die Beruehrpunkte aller `KREISEL_*`/`ECKRAD_*` GLEICHER Hoehe (`toleranz_hoehe`): Rad/Rad (`Kreis/Kreis`) und Rad/Laufprofil (`Kreis/Tangente`), nur auf der freien Radseite (aeusserer Halbkreis inkl. Flanken; Eckrad ganz frei), Toleranz `toleranz_beruehrung` (component_defaults.json, Sektion kreisel). Kapsel-Mindestabstand < 2r - tol = KOLLISION (Ueberschneidung), Kreisel Seite an Seite (Beruehrung nur an Flanke/Profil) = KOLLISION `Tangente/Tangente` - beide werden gemeldet, aber nie zur Weiche. Ausgabe: Konsolenliste + Kreis-Marker (Layer `kreisel_weiche`/`kreisel_kollision` aus layer.cfg, XDATA `SSG_KR_WEICHE`, jeder Lauf ersetzt die alten). Der Export schreibt dieselben Punkte als `kreisel_weichen.json` neben `export_raw.json` (`csv:kreisel-weichen-schreiben`, export.lsp); `export_csv.py` uebernimmt sie (`export_neighbors.load_lisp_kreisel_weichen`/`lisp_touch_switches`, Rueckfall auf `compute_kreisel_touch_switches` nur ohne Datei), `export_sivas.py` setzt daraus Merkmal 4403 "Anzahl Weichen ILS". Reine Kerne `kreisel-bp-element`/`-paar`/`-berechnen` in `tests/test_unit.lsp` (`tu-tests-kreisel-bp`, u.a. mit den 11 Einfuegungen aus `tests/testdata/schnittspunkte_kreisel.dxf` -> 10 Beruehrungen) getestet. Eckrad: eigener Dialog `eckrad_edit.dcl` (`eckrad-dialog`, reiner Kern `eckrad-dialog-werte` getestet) beim Einfuegen (ILS_Eckrad, ohne GUI Konsolen-Rueckfall) und per Doppelklick (EckradEdit); kein Abstand/Typ, Drehung als freier Winkel statt fester Kreisel-Ausrichtung. `ils-eckrad-insert` behaelt eine vorhandene NUMMER (Edit -> gleicher Blockname `ECKRAD_n`). Kreiselname: `draw-module` setzt `Bezeichnung` nur noch bei leerem Wert auf die Vorgabe `KreiselN` (eigener Name aus KreiselEdit bleibt erhalten); Beschriftung `kreisel-label-text` = `KREISEL n: _` (ohne Namen bzw. bei Vorgabename wie bisher `KREISEL n: _`); da die Beschriftung als TEXT in der wiederverwendeten Blockdefinition `KREISEL_n_TYP_ABSTAND` steckt, setzt `kreisel-label-aktualisieren` sie dort per `entmod` neu (wirkt auf alle Referenzen der Definition) | | `VarioFoerderer.lsp` (Wrapper fuer `vf_core.lsp`/`vf_standard.lsp`/`vf_etage.lsp`/`vf_linienzug.lsp`) | FOERDERANLAGE, VARIOFOERDERER_EDIT, VARIOFOERDERER_NACHRUESTEN, Vario_Kette_Merge, VF_SEKTION_RESTORE, VF_WIZARD_AN, VF_WIZARD_AUS | Vario-Foerderanlagen Generator (Typen Standard/Etage/Linienzug); Standard- UND Etage-Typ: Werteingabe per DCL-Dialog, inkl. der vorgelagerten Eingabemodus-Wahl 3D-Linie/Werte manuell (`vfc_eingabemodus`, `vfc-dialog-eingabemodus-waehlen`) - beide Modi laufen seitdem in denselben Basis-/Winkel-Dialog, der Konsolen-Pfad ist nur noch Rueckfall bei abgeschalteter GUI/anderer Sprache. Der Dialog-Ablauf ist zentral in vf_core (`vf-dialog-ablauf`/`vf-dialog-berechnen-einfuegen`, parametrisiert ueber Typ-Registry `*vf-typ-registry*` + Flag `horizontal-p`); `vfs-standard-dialog-ablauf`/`vfe-etage-dialog-ablauf` sind nur noch duenne Wrapper darauf. Beide nutzen dieselben Dialoge `vfs-dialog-eingabe-basis`/`vfs-dialog-winkel-verteilung` und den gemeinsamen L_GF/L_VF-Solve `vf-winkel-solve` (vf_core; berechne-alle-winkel/berechne-winkel-etage teilen ihn); Doppelklick auf VF_n-Block ruft VARIOFOERDERER_EDIT, das per SSG_VF_EDIT-XDATA-Marker ("standard"/"etage"/"linienzug") in den passenden Neuaufbau-Zweig dispatcht (`vfe-edit-ent` fuer Etage, `vfl-edit-ent` fuer Linienzug); Altbestand-Bloecke ohne Marker werden abgewiesen. Linienzug (Modus 1, `vf-linienzug-modus`) zeichnet jede interaktive Eingabe in einem Journal auf (`vfl-in-point`/`-string`/`-real`/`-int`) und schreibt es als XDATA auf den fertigen `VF_n`-Block; ein Abbruch (ESC) loescht dadurch nichts mehr, sondern wickelt die bis dahin gebaute Teil-Geometrie ebenso zu einem Block (`vfl-modus-abbruch-sichern`) - sie bleibt stehen und ist sofort per Doppelklick weiter editierbar/fortsetzbar. Der komplette Linienzug-Hauptstrang (Menue-Fragen von AS-Element bis Kettenende, inkl. GF-Bogen/Vario-Kurve/VF-Einheit-Fortsetzung) laeuft per Default ueber DCL-Dialoge statt Konsole (`*vfl-wizard-mode*`, Befehle VF_WIZARD_AN/VF_WIZARD_AUS): `vfl-in-string`/`-int`/`-real` zeigen bei aktivem Wizard-Modus generische Dialoge aus `dcl/vf_linienzug_wizard.dcl` (Zahl-Eingabe bzw. Mehrfachauswahl aus `vfl-menu`/`vfl-menu-int`) statt `getstring`/`getint`/`getreal` aufzurufen; die ORIGINALEN Konsolen-Fragen (princ + get*, de/en ueber ssg-text) bleiben unveraendert im Code (Fallback bei Fehlern via `vl-catch-all-apply`, siehe `doc/variofoerderer.md`). `vfl-edit-ent` liest das Journal, zeigt die Sektionen ueber einen DCL-Dialog (`vfl-dlg-position`, `dcl/vfl_edit.dcl`) an, kuerzt bei Bedarf auf eine gewaehlte Sektion (stummer Replay der behaltenen Eingaben, umgeht den Wizard-Zweig komplett) und baut danach interaktiv weiter. Linienzug Modus 2 (Pfad+Zielhoehe-Solver, `vf-linienzug-modus2`) nutzt dieselben Wrapper PLUS die neue Objektauswahl-Wrapper-Funktion `vfl-in-selection` (Pfad-Objekte als stabile Entity-Handles journalisiert, neue Journal-Art `"OBJS"`) und schreibt sein Journal unter dem eigenen XDATA-Marker `"linienzug2"`; Doppelklick baut hier NICHT abschnittsweise, sondern per vollem Reset 1:1 aus dem Journal neu auf (`vfl-edit-ent2`, dispatcht aus `vfl-edit-ent` per Marker) - Modus 3 (Vorwaerts-Nachbau) bleibt bewusst reine Konsole (im Code selbst als Legacy/"wird umgebaut" markiert). `Vario_Kette_Merge` (in vf_linienzug.lsp) fuehrt mehrere einzeln gebaute VF_n-Bloecke ab einem gewaehlten Start-Baustein ueber die reale KS_AUS->KS_EIN-Nachbarschaft zu einem Gesamt-Block zusammen (aggregierte Attribute, Luecken-Erkennung). Die interaktiven Editier-Pfade (`vfl-edit-ent` Sektions-Zweig, `vfl-edit-ent2`) rufen den Neuaufbau BEWUSST direkt auf, NICHT ueber `vl-catch-all-apply`: der alte Block ist beim Neuaufbau schon per `entdel` weg, und ein Catch faengt den Abbruch VOR `*error*` ab - der Abbruch-Wickler `vfl-modus-abbruch-sichern` kaeme nie zum Zug und die ganze Kette bliebe als lose Einzelteile ohne Block liegen (Fehlerbild "VF-Block aufgebrochen"). Nur der nicht-interaktive Batch-Konverter `vfl-konvertiere-ent` behaelt den Catch (die Batch-Schleife muss weiterlaufen) und meldet den betroffenen Block. Die Abbruch-Handler setzen zusaetzlich `*ssg-ils-dim*` zurueck, weil der Aufrufer, der das sonst tut, nach einem Abbruch nicht mehr erreicht wird. Recovery-Pfad fuer bereits aufgebrochene Ketten: `VF_SEKTION_RESTORE` (vf_linienzug.lsp) setzt das Ketten-Journal aus der XDATA der losen Objekte zusammen - `SSG_VF_EDIT_SEG` traegt pro Entity den Journal-Abschnitt DER ITERATION, in der es entstand (indiziert mit dem ersten Glied-Index darin; eine VF-Einheit mit eingebetteten Vario-Kurven erzeugt mehrere Glieder in einer Iteration), `SSG_VF_EDIT_PRE` auf den Entities des ersten Gliedes die Praeambel (Startpunkt/Starthoehe/AS). Die `.dbg`-Dateien sind reine AUSGABE und werden von keinem Befehl gelesen (dbgopen legt sie bei jedem Lauf neu an) - Wiederherstellungs-Daten gehoeren in die XDATA. `vf_konstanten.lsp` (von vf_core.lsp vor den drei Submodulen geladen) sammelt alle Laengen-/Winkel-/Toleranz-Magic-Numbers aus dem VarioFoerderer-Cluster als dokumentierte `*vfk-*`-Konstanten. Die Migration ist abgeschlossen: vf_core/vf_standard/vf_etage/vf_linienzug referenzieren durchgaengig die zentralen Konstanten statt roher Literale (Winkel, Stations-/Separator-Laengen, Mindestlaengen, AS/ES-Fallback-Versaetze, Text-/Label-Masse) - Ausnahmen sind in `vf_konstanten.lsp` selbst dokumentiert (Werte mit fuehrender Config-Anbindung via `ssg-cfg-or`, itoa-/Integer-Kontexte, Blocknamen-Strings, die 2000.0-mm/m-Umrechnung). `*vfk-gf-bogen-winkel*` (30/60/90, GF-Bogen + Vario-Kurve) und `*vfk-as-es-winkel*` ("30"/"90", AS/ES; bewusst STRING, da 2-wertig und im Journal als STR gefuehrt) sind Beispiele; vf_linienzug hat fuer beide einen Fallback, falls vf_konstanten nicht geladen wurde. **Nicht-interaktiver Betrieb**: `*vfl-headless*` (+ `vfl-headless-p`/`-abbruch`/`-notausgang`, Diagnose `*vfl-headless-fehler*`, optionaler Antwort-Hook `*vfl-headless-antwort-fn*`) verbietet jede Live-Eingabe - eine erschoepfte Replay-Queue ist damit ein harter Abbruch MIT Fundstelle (Art der Eingabe, Glied- und Eingabe-Nummer) statt eines stillen Rueckfalls auf `getpoint`/`getreal`; eingebaut in `vfl-in-value`/`-value-p`/`-selection`/`-abstand`. Die Bau-Pfade melden abgewiesene Sektionen ueber `vfl-meldung` (sammelt nach `*vfl-meldungen*` + `dbgmsg`, `alert` nur bei erlaubter GUI, sonst `princ`) statt per blockierendem `alert`; reine Interaktiv-Alerts (fehlendes DCL, "nicht editierbar", "kein Journal") bleiben `alert`. Genutzt von `tests/test_hm_recformat.lsp` (Replay der echten Aufzeichnungen) und von `vf_spec.lsp`; Fahrplan in `doc/todo/plan-vf-interactive.md`. Details/Entscheidungsbaum: `doc/variofoerderer.md` | | `vf_spec.lsp` (von vf_core.lsp NACH vf_linienzug.lsp geladen) | VF_SPEC_BAU | Linienzug-Ketten aus **Eingabedaten** bauen, ohne Dialog und ohne Konsolenfrage (Stufe 1 aus `doc/todo/plan-vf-interactive.md`). Eine **Spec** beschreibt eine Kette in Domaenenwerten (`"links"`, `"winkel"`, `"aussen"`, ja/nein) statt in Menue-Codes; `vsp-journal` uebersetzt sie in ein Eingabe-Journal, `vsp-bau-aus-spec` spielt es per `vfl-journal-replay-start` durch den UNVERAENDERTEN `vf-linienzug-modus` (Replay-Kern `vsp-bau-journal` - nimmt auch ein unveraendert uebernommenes, aufgezeichnetes Journal, z.B. aus `dxf_anlage_export.py`). Damit traegt der fertige Block dasselbe `SSG_VF_EDIT`-Journal wie eine handgebaute Kette und bleibt per Doppelklick editier- und 2D/3D-konvertierbar - kein Journal-Konsument muss etwas von Specs wissen. Wichtige Regeln, die der Uebersetzer kennt: der Menue-Code haengt am Frame (erste Sektion 4 Optionen ohne GF-Bogen, danach 5), `hz` steht nur beim ERSTEN Segment im Journal, und `erst-hor` unterscheidet den horizontalen Erstkoerper einer VF-Einheit (Separator-/Endpunktfragen vorab) vom gewinkelten (keine Frage). Fehlerverhalten: fail fast - `vsp-pruefen` sammelt ALLE Spec-Fehler, gebaut wird dann nichts (nichts wird geraten). Ergebnis-Record je Kette mit `status` (`executed`/`warnung`/`desync`/`abbruch`/`spec-fehler`), Block/Handle/Einfuegepunkt/Attributen, `prompts` (muss 0 sein), `glieder_soll` vs. `glieder_ist` (Desync-Detektor, der auch bei aufgehender Queue greift) und den gesammelten `meldungen`. Headless-Rahmen `vsp-headless-an`/`-aus` (Save/Restore von `*vfl-headless*`, `*vfl-wizard-mode*`, `*ssg-gui-aus*` + zaehlende Eingabe-Stubs). Spec-Datei flach als JSON (`ssg-load-json` liest zeilenweise), erzeugt von `lib/vf_spec_export.py`. Gegenstueck/Referenz in Python: derselbe Emitter, gegen die 5 echten HundM-Ketten rundlaufgeprueft | | `Gefaellestrecke.lsp` | GEFAELLESTRECKE, GEFAELLESTRECKE_EDIT | Gefaelle-Foerderanlage (AUS -> Staustrecke skaliert -> Separator -> EIN); Modus 1 per DCL-Dialog (Einfuegehoehe, Element-Winkel 30/90); Doppelklick auf GF_n-Block ruft GEFAELLESTRECKE_EDIT (Dialog vorbelegt, Neuaufbau; die Einfuegehoehe kommt aus der aktuellen Z des Einfuegepunkts statt aus XDATA/HOEHE_VON_mm, damit ein in Z verschobener Block per OK direkt auf der neuen Hoehe neu entsteht - gleiches gilt fuer die 2D/3D-Umschaltung `gf-konvertiere-ent`; der GF-Linienzug-Rebuild nutzt weiter die absoluten Segmentpunkte aus XDATA) | diff --git a/Lisp/KreiselInsert.lsp b/Lisp/KreiselInsert.lsp index f2b369f..94780ab 100644 --- a/Lisp/KreiselInsert.lsp +++ b/Lisp/KreiselInsert.lsp @@ -314,6 +314,77 @@ ) +;; --- Drehrichtungspfeil (data/ils/Drehrichtungspfeil.dwg) --- +;; Die DWG ist fuer einen Kreisel Nord -> Sued (AN oben, SP unten, also +;; Einfuegewinkel 270) und Drehrichtung im Uhrzeigersinn gezeichnet. +;; Im Block liegt der Kreisel entlang +X (Winkel 0); die Drehung des +;; Kreisels kommt ueber den Einfuegewinkel des KREISEL_n-Blocks automatisch +;; dazu. Der Pfeil wird daher im Block um 0 - 270 = 90 Grad gedreht. +(setq *kreisel-pfeil-block* "Drehrichtungspfeil") +(setq *kreisel-pfeil-winkel* (ssg-cfg-or "kreisel" "pfeil_winkel" 90.0)) + +;; X-Skalierung des Pfeils: UZS -> 1, GUZ -> -1 (Spiegelung an der eigenen +;; Y-Achse, die Pfeilspitze zeigt dann in die Gegenrichtung). +(defun kreisel-pfeil-xskal (drehrichtung) + (if (equal drehrichtung "GUZ") -1.0 1.0) +) + +;; Reiner Kern: Einfuegeparameter beider Pfeile im Block-KS des Kreisels. +;; Rueckgabe: ((punkt winkel xskal) (punkt winkel xskal)) - AN8, dann SP8 +;; (SP8 um 180 Grad gedreht). +(defun kreisel-pfeil-params (radius abstand drehrichtung / xs) + (setq xs (kreisel-pfeil-xskal drehrichtung)) + (list (list (list radius 0.0 0.0) *kreisel-pfeil-winkel* xs) + (list (list (+ radius abstand) 0.0 0.0) + (rem (+ *kreisel-pfeil-winkel* 180.0) 360.0) xs)) +) + +;; Reiner Kern fuers Eckrad: ein Pfeil auf der Radmitte (Block-Ursprung), +;; ausgerichtet wie der AN8-Pfeil eines Kreisels gleicher Drehung. +(defun eckrad-pfeil-params (drehrichtung) + (list (list (list 0.0 0.0 0.0) *kreisel-pfeil-winkel* + (kreisel-pfeil-xskal drehrichtung))) +) + +;; Einen Pfeil einfuegen. Ab dem zweiten Mal per Blockname, damit INSERT +;; nicht nach dem Neudefinieren der bestehenden Definition fragt. +(defun kreisel-pfeil-einfuegen (pt winkel xs) + (command "_.INSERT" + (if (tblsearch "BLOCK" *kreisel-pfeil-block*) + *kreisel-pfeil-block* + (strcat *block-path* *kreisel-pfeil-block* ".dwg")) + pt xs 1.0 winkel) +) + +;; Alle Pfeile einer Parameterliste ((punkt winkel xskal) ...) einfuegen +;; (beim Aufbau der Blockdefinition). Fehlt die DWG, wird ohne Pfeil gebaut. +(defun kreisel-pfeile-einfuegen (params) + (if (findfile (strcat *block-path* *kreisel-pfeil-block* ".dwg")) + (foreach p params + (kreisel-pfeil-einfuegen (car p) (cadr p) (caddr p)) + ) + (princ (ssg-textf "kreisel-warn-pfeil-fehlt" (list *kreisel-pfeil-block*))) + ) +) + +;; Spiegelung der Pfeile in einer BESTEHENDEN Blockdefinition KREISEL_n_... +;; nachziehen (Edit/Redraw mit geaenderter DREHRICHTUNG - der Blockname +;; enthaelt die Drehrichtung nicht, die Definition wird wiederverwendet). +;; Wirkt wie kreisel-label-aktualisieren auf alle Referenzen der Definition. +(defun kreisel-pfeil-aktualisieren (bname drehrichtung / e ed xs) + (setq xs (kreisel-pfeil-xskal drehrichtung)) + (setq e (tblobjname "BLOCK" bname)) + (while (setq e (entnext e)) + (setq ed (entget e)) + (if (and (= (cdr (assoc 0 ed)) "INSERT") + (= (strcase (cdr (assoc 2 ed))) (strcase *kreisel-pfeil-block*)) + (not (equal (cdr (assoc 41 ed)) xs 1e-9))) + (entmod (subst (cons 41 xs) (assoc 41 ed) ed)) + ) + ) +) + + ;; Attribut-Funktionen: ssg-attrib-read, ssg-attrib-merge, ;; ssg-attrib-defaults, ssg-attrib-make-defs aus ssg_core.lsp @@ -439,6 +510,11 @@ ;; SP8 Kreis (Spannstation) bei (radius+abstand, 0) - Dim-Suffix im Dateinamen (command "_.INSERT" (strcat *block-path* "SP8_" *ki-dxfm-dim* ".dwg") (list (+ radius abstand) 0.0 0.0) 1 1 0) + ;; Drehrichtungspfeile auf AN8- und SP8-Mitte (SP8 um 180 Grad gedreht, + ;; GUZ gespiegelt). Fehlt die DWG, wird der Kreisel ohne Pfeil gebaut. + (kreisel-pfeile-einfuegen + (kreisel-pfeil-params radius abstand (cdr (assoc "DREHRICHTUNG" attribs)))) + ;; Tangenten-Layer: bevorzugt aus cfg/layer.cfg (Baugruppe ;; "kreisel_tangente"), sonst der bisherige Hartwert S_LP. (if (null (ssg-layer-anlegen "kreisel_tangente" T)) @@ -506,6 +582,8 @@ (kreisel-label-aktualisieren bname (kreisel-label-text kreisel-nummer (cdr (assoc "Bezeichnung" attribs)) (if is-pin "PIN" "STANDARD") abstand)) + ;; ebenso die Spiegelung der Drehrichtungspfeile + (kreisel-pfeil-aktualisieren bname (cdr (assoc "DREHRICHTUNG" attribs))) ) ) @@ -561,87 +639,89 @@ ;; KreiselInsert: Manuell Position + Parameter ;; -------------------------------------------- +;; Reiner Kern: Abstand und Rotation aus Basispunkt und gezeigtem Punkt der +;; Abstands-Abfrage (Gummiband-Linie, 2D in der XY-Ebene). +;; Ohne Punkt (Enter) -> Vorgabe-Abstand, Rotation 0. +;; Rueckgabe: (abstand rotation-in-grad), Rotation in [0, 360) +(defun kreisel-insert-richtung (pt p2 vorgabe / a) + (if (and p2 (> (distance (list (car pt) (cadr pt)) (list (car p2) (cadr p2))) 1e-6)) + (progn + (setq a (* (/ 180.0 pi) (angle (list (car pt) (cadr pt)) (list (car p2) (cadr p2))))) + (list (distance (list (car pt) (cadr pt)) (list (car p2) (cadr p2))) + (if (>= a 359.9999999) 0.0 a)) + ) + (list vorgabe 0.0) + ) +) + ;; -------------------------------------------- ;; KreiselInsert: Manuell Position + Parameter +;; Abfrage: 1. Basispunkt (AN-Seite), 2. Abstand als Gummiband-Linie - die +;; Richtung der Linie ist zugleich die Rotation (Wert tippen = direkte +;; Distanzeingabe in Zeigerichtung), 3. Hoehe (Vorgabe aus angeklicktem +;; Block bzw. Z des Basispunkts), 4. Kreiselart. ;; -------------------------------------------- -(defun c:KreiselInsert ( / pt abstand typ rotation rotStr hoehe +(defun c:KreiselInsert ( / pt p2 erg abstand typ rotation hoehe hoehe-vorgabe selectedEnt blockAttribs oldOsmode) (ssg-start (ssg-text "kreisel-start-insert") '(("OSMODE") ("CECOLOR"))) - + ;; Temporär Osnap für Blockerkennung setzen (setq oldOsmode (getvar "OSMODE")) (setvar "OSMODE" (logior oldOsmode 512)) ;; 512 = INS (Block-Einfügepunkt) - - ;; 1. Einfuegepunkt + + ;; 1. Basispunkt (AN-Seite) (setq pt (getpoint (ssg-text "kreisel-prompt-basispunkt"))) - (if (null pt) - (progn - (setvar "OSMODE" oldOsmode) - (ssg-end) - (princ (ssg-text "kreisel-abbruch-befehl")) - (princ) - (return) - ) - ) - + ;; Osnap zurücksetzen auf den ursprünglichen Wert (setvar "OSMODE" oldOsmode) - - ;; 2. Prüfen ob ein Block getroffen wurde - (setq selectedEnt (nentselp pt)) - - ;; --- HÖHE BESTIMMEN --- - (cond - ;; Fall 1: Auf einem Kreisel-Block geklickt - ((and selectedEnt - (setq selectedEnt (car selectedEnt)) - (setq blockAttribs (ssg-attrib-read selectedEnt)) - (assoc "HOEHE" blockAttribs)) - (setq hoehe (atof (cdr (assoc "HOEHE" blockAttribs)))) - (princ (ssg-textf "kreisel-hoehe-von-bestehendem" (list (rtos hoehe 2 0)))) - ) - ;; Fall 2: Punkt hat Z-Koordinate > 0 - ((and (> (length pt) 2) (> (caddr pt) 0)) - (setq hoehe (caddr pt)) - (princ (ssg-textf "kreisel-hoehe-aus-3dpunkt" (list (rtos hoehe 2 0)))) - ) - ;; Fall 3: Sonst separat abfragen - (t - (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos *kreisel-default-hoehe* 2 0))))) - (if (null hoehe) (setq hoehe *kreisel-default-hoehe*)) + + (if (null pt) + (princ (ssg-text "kreisel-abbruch-befehl")) + (progn + ;; Hoehen-Vorgabe: angeklickter Block mit HOEHE, sonst Z des Punkts, + ;; sonst Default (abgefragt wird erst nach dem Abstand) + (setq selectedEnt (nentselp pt)) + (setq hoehe-vorgabe + (cond + ((and selectedEnt + (setq selectedEnt (car selectedEnt)) + (setq blockAttribs (ssg-attrib-read selectedEnt)) + (assoc "HOEHE" blockAttribs)) + (atof (cdr (assoc "HOEHE" blockAttribs)))) + ((and (> (length pt) 2) (> (caddr pt) 0)) + (caddr pt)) + (t *kreisel-default-hoehe*) + ) + ) + + ;; 2. Abstand (Tangentenlaenge) - Linie gibt auch den Winkel vor + (setq p2 (getpoint pt (ssg-textf "kreisel-prompt-abstand" + (list (rtos *kreisel-default-laenge* 2 0))))) + (setq erg (kreisel-insert-richtung pt p2 *kreisel-default-laenge*) + abstand (car erg) + rotation (cadr erg)) + (princ (ssg-textf "kreisel-abstand-ausgabe" (list (rtos abstand 2 0)))) + + ;; 3. Hoehe (Z-Koordinate) + (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos hoehe-vorgabe 2 0))))) + (if (null hoehe) (setq hoehe hoehe-vorgabe)) + + ;; 4. Kreiselart + (setq typ (kreisel-ask-typ)) + + (princ (ssg-textf "kreisel-insert-zusammenfassung" + (list (rtos rotation 2 1) (rtos hoehe 2 0) typ))) + + ;; Modul einfuegen + (draw-module (list (car pt) (cadr pt) hoehe) abstand rotation + (list (cons "KREISELART" typ) + (cons "HOEHE" (rtos hoehe 2 0)))) + + (princ (ssg-text "kreisel-insert-fertig")) ) ) - - ;; 3. Abstand - (initget 6) - (setq abstand (getdist (list (car pt) (cadr pt)) - (ssg-textf "kreisel-prompt-abstand" (list (rtos *kreisel-default-laenge* 2 0))))) - (if (null abstand) (setq abstand *kreisel-default-laenge*)) - (princ (ssg-textf "kreisel-abstand-ausgabe" (list (rtos abstand 2 0)))) - - ;; 4. Rotation - (setq rotStr (getstring (ssg-text "kreisel-prompt-rotation"))) - (if (= rotStr "") - (setq rotation 0.0) - (setq rotation (atof rotStr)) - ) - - ;; 5. Kreiselart - (setq typ (kreisel-ask-typ)) - - (princ (ssg-textf "kreisel-insert-zusammenfassung" - (list (rtos rotation 2 1) (rtos hoehe 2 0) typ))) - - ;; 6. Modul einfuegen - (draw-module (list (car pt) (cadr pt) hoehe) abstand rotation - (list (cons "KREISELART" typ) - (cons "HOEHE" (rtos hoehe 2 0)))) - - ;; KEIN weiteres (setvar "OSMODE" ...) mehr nötig! - ;; ssg-end stellt nur CLAYER und CMDECHO wieder her, nicht OSMODE - - (princ (ssg-text "kreisel-insert-fertig")) (ssg-end) + (princ) ) @@ -1429,6 +1509,9 @@ (dbgp (strcat "INSERT Block: " *block-path* "AN8_" *ki-dxfm-dim* ".dwg")) (command "_.INSERT" (strcat *block-path* "AN8_" *ki-dxfm-dim* ".dwg") (list 0.0 0.0 0.0) 1 1 0) + ;; Drehrichtungspfeil auf die Radmitte (GUZ gespiegelt) + (kreisel-pfeile-einfuegen (eckrad-pfeil-params (cdr (assoc "DREHRICHTUNG" attribs)))) + ;; Unsichtbare Attribut-Definitionen erzeugen (dbgp (strcat "Erzeuge " (itoa (length *eckrad-attrib-defs*)) " Attribut-Definitionen")) (ssg-attrib-make-defs *eckrad-attrib-defs* 50.0) @@ -1461,6 +1544,8 @@ (progn (princ (ssg-textf "kreisel-bestehende-blockdef" (list bname))) (dbgp (strcat "Verwende bestehende Blockdefinition: " bname)) + ;; EckradEdit behaelt ECKRAD_n - Spiegelung des Pfeils nachziehen + (kreisel-pfeil-aktualisieren bname (cdr (assoc "DREHRICHTUNG" attribs))) ) ) diff --git a/Lisp/README.md b/Lisp/README.md index 14846ce..68091b0 100644 --- a/Lisp/README.md +++ b/Lisp/README.md @@ -675,7 +675,7 @@ AutoLISP-Implementierung fuer ILS Kreisel und Eckrad. Enthaelt alle Befehle fuer | Befehl | Beschreibung | | --- | --- | -| `c:KreiselInsert` | Kreisel-Block an Punkt einfuegen (mit Dialog fuer Parameter) | +| `c:KreiselInsert` | Kreisel-Block einfuegen: Basispunkt (AN-Seite), Abstand als Gummiband-Linie (deren Richtung = Rotation), Hoehe, Kreiselart | | `c:KreiselConnect` | Zwei Punkte waehlen, Kreisel dazwischen einfuegen | | `c:KreiselRedraw` | Bestehenden Kreisel mit neuen Parametern neu zeichnen | | `c:KreiselQuick` | Schnelleinfuegung mit Standardwerten | diff --git a/cfg/stueckliste.json b/cfg/stueckliste.json new file mode 100644 index 0000000..3c0cba8 --- /dev/null +++ b/cfg/stueckliste.json @@ -0,0 +1,29 @@ +{ + "_kommentar": "Konfiguration fuer SSG_FAEHNCHEN_STUECKLISTE (Lisp/ssg_stueckliste.lsp). Vorgaben fuer den Startdialog, Darstellung von Fuehrung und Tabelle (Walz-Layout, siehe tests/testdata/positionierung_nach_walz.dxf) und Regeln je Bauteiltyp.", + "startnummer": 100, + "alle_positionen_in_fahne": false, + "pos_layer": { + "modus": "suffix", + "suffix": "-POS", + "fest": "POS" + }, + "tabellen_layer": "D-1-POS", + "fuehrung": { + "textstil": "Pos", + "font": "arial.ttf", + "texthoehe": 75, + "landung": [105, 159], + "landing_gap": 15, + "rahmen": true + }, + "tabelle": { + "textstil": "Standard", + "texthoehe": 100, + "spalten": [300, 500, 500, 900, 4866], + "zeilenhoehe": 136 + }, + "regeln": [ + { "block": "GR_Traeger_*", "marker": "mitte" }, + { "block": "GR_Fahrstrecke_*", "marker": "mitte" } + ] +} diff --git a/data/ils/Drehrichtungspfeil.dwg b/data/ils/Drehrichtungspfeil.dwg new file mode 100644 index 0000000..8d8c7f8 Binary files /dev/null and b/data/ils/Drehrichtungspfeil.dwg differ diff --git a/lang/de_DE.json b/lang/de_DE.json index 91e78a9..2ed8a48 100644 --- a/lang/de_DE.json +++ b/lang/de_DE.json @@ -284,7 +284,6 @@ "kreisel-hoehe-aus-3dpunkt": "\n-> Hoehe aus 3D-Punkt uebernommen: %1", "kreisel-hoehe-aus-basispunkt": "\n-> Höhe aus Basispunkt übernommen: %1", "kreisel-hoehe-aus-startpunkt": "\n-> Hoehe aus Startpunkt uebernommen: %1", - "kreisel-hoehe-von-bestehendem": "\n-> Höhe von bestehendem Kreisel übernommen: %1", "kreisel-insert-zusammenfassung": "\n-> Rotation: %1 Höhe: %2 Kreiselart: %3", "kreisel-labelsetup-fertig": "\nNeue Einstellungen: Höhe=%1, Farbe=%2, Y-Versatz=%3, Schriftart=Arial", "kreisel-neue-beschriftungsposition": "\nNeue Beschriftungsposition: X=%1 Y=%2", @@ -471,7 +470,6 @@ "kreisel-prompt-basispunkt": "\nBasispunkt (AN-Seite): ", "kreisel-prompt-block-auswaehlen": "\nKreisel-Block auswaehlen: ", "kreisel-prompt-endpunkt": "\nEndpunkt (SP-Seite aussen): ", - "kreisel-prompt-rotation": "\nRotation in Grad <0>: ", "kreisel-prompt-startpunkt": "\nStartpunkt (AN-Seite aussen): ", "kreisel-quick-fertig": "\nSchnell Einfuegen fertig.", "kreisel-start-connect": "Kreisel Smart Connect", @@ -490,6 +488,7 @@ "kreisel-typ-opt-pin": "\n[2] PIN", "kreisel-typ-opt-standard": "\n[1] STANDARD (ohne PIN)", "kreisel-warn-blockpfad": "\n[KreiselInsert] WARNUNG: Block-Pfad nicht ermittelbar!", + "kreisel-warn-pfeil-fehlt": "\n[KreiselInsert] WARNUNG: %1.dwg nicht gefunden - Kreisel ohne Drehrichtungspfeil.", "kreisel-warn-core-fehlt": "\n[KreiselInsert] WARNUNG: ssg_core.lsp nicht gefunden - Standardwerte.", "omni-abbruch": "\nAbgebrochen.", "omni-abbruch-bogen": "\n[BOGEN] Abgebrochen.", diff --git a/lang/en_GB.json b/lang/en_GB.json index 8520834..238f66b 100644 --- a/lang/en_GB.json +++ b/lang/en_GB.json @@ -284,7 +284,6 @@ "kreisel-hoehe-aus-3dpunkt": "\n-> Height taken from 3D point: %1", "kreisel-hoehe-aus-basispunkt": "\n-> Height taken from base point: %1", "kreisel-hoehe-aus-startpunkt": "\n-> Height taken from start point: %1", - "kreisel-hoehe-von-bestehendem": "\n-> Height taken from existing Kreisel: %1", "kreisel-insert-zusammenfassung": "\n-> Rotation: %1 Height: %2 Kreisel type: %3", "kreisel-labelsetup-fertig": "\nNew settings: Height=%1, Colour=%2, Y offset=%3, Font=Arial", "kreisel-neue-beschriftungsposition": "\nNew label position: X=%1 Y=%2", @@ -471,7 +470,6 @@ "kreisel-prompt-basispunkt": "\nBase point (AN side): ", "kreisel-prompt-block-auswaehlen": "\nSelect Kreisel block: ", "kreisel-prompt-endpunkt": "\nEnd point (SP side, outer): ", - "kreisel-prompt-rotation": "\nRotation in degrees <0>: ", "kreisel-prompt-startpunkt": "\nStart point (AN side, outer): ", "kreisel-quick-fertig": "\nQuick insert done.", "kreisel-start-connect": "Kreisel Smart Connect", @@ -490,6 +488,7 @@ "kreisel-typ-opt-pin": "\n[2] PIN", "kreisel-typ-opt-standard": "\n[1] STANDARD (without PIN)", "kreisel-warn-blockpfad": "\n[KreiselInsert] WARNING: block path not determinable!", + "kreisel-warn-pfeil-fehlt": "\n[KreiselInsert] WARNING: %1.dwg not found - carousel without direction arrow.", "kreisel-warn-core-fehlt": "\n[KreiselInsert] WARNING: ssg_core.lsp not found - using defaults.", "omni-abbruch": "\nCancelled.", "omni-abbruch-bogen": "\n[ARC] Cancelled.", diff --git a/tests/test_unit.lsp b/tests/test_unit.lsp index 5ed48a4..78a235e 100644 --- a/tests/test_unit.lsp +++ b/tests/test_unit.lsp @@ -803,6 +803,27 @@ (defun tu-tests-kreisel ( / _e) (princ "\n[KreiselInsert]") + ;; Drehrichtungspfeil: AN8-Mitte 90 Grad, SP8-Mitte 270 Grad, GUZ gespiegelt + (tu-eqf "kreisel-pfeil-params/uzs" + '(((400.0 0.0 0.0) 90.0 1.0) ((2700.0 0.0 0.0) 270.0 1.0)) + (kreisel-pfeil-params 400.0 2300.0 "UZS")) + (tu-eqf "kreisel-pfeil-params/guz" + '(((400.0 0.0 0.0) 90.0 -1.0) ((2700.0 0.0 0.0) 270.0 -1.0)) + (kreisel-pfeil-params 400.0 2300.0 "GUZ")) + (tu-eqf "kreisel-pfeil-xskal/nil-ist-uzs" 1.0 (kreisel-pfeil-xskal nil)) + (tu-eqf "eckrad-pfeil-params/guz" + '(((0.0 0.0 0.0) 90.0 -1.0)) (eckrad-pfeil-params "GUZ")) + + ;; KreiselInsert: Abstand + Rotation aus der Gummiband-Linie + (tu-eqf "kreisel-insert-richtung/ost" + '(2300.0 0.0) (kreisel-insert-richtung '(100.0 100.0 0.0) '(2400.0 100.0 0.0) 2300.0)) + (tu-eqf "kreisel-insert-richtung/sued" + '(1500.0 270.0) (kreisel-insert-richtung '(0.0 0.0 0.0) '(0.0 -1500.0 0.0) 2300.0)) + (tu-eqf "kreisel-insert-richtung/z-ignoriert" + '(1000.0 90.0) (kreisel-insert-richtung '(0.0 0.0 2000.0) '(0.0 1000.0 0.0) 2300.0)) + (tu-eqf "kreisel-insert-richtung/enter-vorgabe" + '(2300.0 0.0) (kreisel-insert-richtung '(0.0 0.0 0.0) nil 2300.0)) + ;; Projektion eines Punktes auf eine Gerade (tu-eqf "kreisel-project-point/lot" '(0.0 0.0) (kreisel-project-point '(0.0 5.0) '(0.0 0.0) '(10.0 0.0)))