diff --git a/CLAUDE.md b/CLAUDE.md index 698128a..bce4e08 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -78,6 +78,7 @@ Die `start_briscad.bat` ruft `setenv.bat` auf und startet BricsCAD. | Geruest | `GeruestInsert` | GERUEST_SAEULEN, GERUEST_ROHRABHAENGER, GERUEST_WANDBEFESTIGUNG (derselbe Dialog, im jeweiligen Bereich geoeffnet), GERUEST_TRAEGER (eigener Dialog), GERUEST_TRAEGER_BESCHRIFTEN (Untermenue Geruest -> Funktionen -> Traeger beschriften; alle Traeger der Zeichnung neu beschriften); Gattertraeger noch Platzhalter auf GERUEST | | Connections | `Connection_Edit` + `SSG_LIB_Commands` | CONNECTION_INSERT, CONNECTION_EDIT, ILS_EINGANG_INSERT, ILS_AUSGANG_INSERT | | Export | `export` | EXPORTSIVAS, EXPORTCSV, CALLPYTHON | +| Werkzeuge | `ssg_blocktools`, `ssg_texttools` | SSG_BLOCK_COUNT, SSG_BLOCK_DELETE, SSG_ATTR_ERSETZEN, SSG_TEXT_ERSETZEN, SSG_TEXT_PARALLEL, SSG_TEXT_HOEHE, SSG_TEXT_STIL | | Konfiguration | `SSG_LIB_Commands` + `DrawPlanquadrate` | SSG_DIM_SWITCH, SSG_SPRACHE, PLANQUADRATE_TOGGLE (DRAW_PLANQUADRATE/DELETE_PLANQUADRATE) | | Doppelklick/Kontextmenue | `SSG_LIB_Commands` | SSG_BLOCKEDIT (dispatcht Kreisel->KreiselEdit, Omniflo->OMNI_EDIT, GF_*->GEFAELLESTRECKE_EDIT, VF_*->VARIOFOERDERER_EDIT) | @@ -99,9 +100,12 @@ Detaillierte Dokumentation aller Funktionen und Befehle: siehe `Lisp/README.md`. | `ssg_dbg.lsp` | - | Debug-Logging (dbgopen, dbgmsg, dbgflush, dbgclose) | | `ssg_dialog.lsp` | - | DCL-Dialog-Vorlagen und Hilfsfunktionen | | `ssg_layer.lsp` | - | Layer-Verwaltung. `ssg-layer-visible-p` (aus ODER gefroren), `ssg-layer-gefroren-p`/`ssg-ent-layer-gefroren-p` (NUR gefroren, fuer den Export) | +| `ssg_input.lsp` | - | Generische Eingabe-Wrapper `ssg-in-real/-int/-string/-point/-dist/-keyword/-yesno` (Vorgabe in `<..>`, Enter = Vorgabe, optionaler Hook `*ssg-in-hook*` fuer Journale). Steht NEBEN den VF-spezifischen `vfl-in-*` (diese bleiben unveraendert). `ssg-in-yesno` liefert T bei Ja (anders als `ssg-ques`, das T fuer die nicht vorgegebene Antwort liefert); Schluesselwoerter aus `ssg-text "in-yesno-keys"` | +| `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 | | `KreiselInsert.lsp` | KreiselInsert, KreiselConnect, KreiselRedraw, KreiselQuick, KreiselEdit, KreiselParams, KreiselLabelSetup, KreiselLabelPos, KreiselLabelHoehe, ILS_Eckrad | ILS Kreisel und Eckrad komplett in AutoLISP | -| `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. 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`. 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 | +| `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) | | `export.lsp` | EXPORTSIVAS, EXPORTCSV, OMNI_UPDATE_ATTRIBS, CSV_EXPORT_KONFIG | JSON-Sammlung und Python-Export (Omniflo-Merkmale/Sum-Zeile via lib/export_csv.py). **Gefrorene Layer**: `csv:collect-export-blocks` laesst Bloecke auf gefrorenen Layern aus (ausgeschaltete Layer zaehlen NICHT), Schalter `*csv-gefrorene-ausschliessen*` (Standard an, Toggle im Dialog CSV_EXPORT_KONFIG). Die Hilfsobjekte eines gefrorenen VF_n/GF_n (Separator-/Element-Kopien, Einheiten-/AS-ES-Marker) liegen auf eigenen Layern und werden darum ueber `*csv-ausschluss-enames*` mit ausgelassen (gesetzt in `csv:export-vorbereiten` per `csv:hilfskopien-ausschluss`); erzeugt und nummeriert werden sie trotzdem, damit IDs stabil bleiben. DrawPlanquadrate nutzt dieselbe Sammlung und folgt dem Filter | | `OmniModulInsert.lsp` | OMNI_LOAD, OMNI_APB_*, OMNI_W*_*, OMNI_AP60/AP110, OMNI_TEF_*, OMNI_TV_*, OMNI_APBW_*, OMNI_LADESCHLEIFE_AP110, OMNI_EDIT | Omniflo-Komponenten: Boegen, Weichen, Verbinder, Transferwagen, Ladeschleifen (`data/json/omniflo_ladeschleifen.json`, per `ssg-json-laden`, da die Beschreibungen Kommas enthalten; Blockdatei darf `.dwg` statt `.dxf` sein), Edit-Dialog | @@ -170,7 +174,7 @@ Werden via `bin/setenv.bat` gesetzt. Wichtigste: - Die **Farbe** wirkt nur bei der Neuanlage des Layers (`ssg-make-layer` laesst bestehende Layer unveraendert, damit Kundenzeichnungen nicht umgefaerbt werden). Layer, die eine Blockdatei aus `data/ils` selbst mitbringt (z.B. `ILS_SP`/`_3D_ILS_SP`), legt BricsCAD schon beim Einfuegen des Blocks mit der Farbe **aus der DWG** an - dort greift die cfg-Farbe nicht, wohl aber der Layername des Wrappers. Fuer Layer ohne Baugruppen-Key gibt es zusaetzlich den Abschnitt `[farben]` (Layername = Farbe), gelesen von `ssg-layer-farbe-fuer-name`. - Komponentendaten (Masse, Sivas-IDs) liegen als JSON in `data/json/` - Sprache im Code und Kommentaren: Deutsch -- **Benutzermeldungen sind ZWEISPRACHIG (de/en)**: Jede an den Anwender gerichtete Meldung (`princ`/`alert`/`getstring`/`getint`/`getreal`/`getkword`-Prompts, auch per `strcat` zusammengesetzte) laeuft ueber `(ssg-text "key")` bzw. `(ssg-textf "key" (list args))`. Die Texte stehen in `lang/de_DE.json` UND `lang/en_GB.json` unter `"texts"` und muessen key-fuer-key synchron bleiben (Paritaets-Check vor dem Commit). Konventionen: Key-Prefix je Modul (`vfc-` vf_core, `gf-` Gefaellestrecke), geteilte Prompts ohne Prefix (`prompt-wahl-1-2` usw.) - vor dem Anlegen eines neuen Keys erst die JSONs nach dem deutschen String grep'en und wiederverwenden. Sonderzeichen wie Grad `(chr 176)` / Delta `(chr 916)` als `%n`-Platzhalter uebergeben, nicht in die (ASCII-)JSON einbetten. **Untranslatiert bleiben** (bewusst): Bracket-Diagnosen (`[vf_core]` o.ae.), die VOR dem garantierten Laden von `ssg_lang.lsp` feuern (Bootstrap-Fallbacks am Dateikopf - `ssg-text` existiert dort noch nicht), Lade-Banner (`>>> ... geladen`), reine `====`/`---`-Trenner und reine Entwickler-Diagnosebefehle (nicht im Menue). Details und Entscheidungsbaum: `doc/translate.md`. +- **Benutzermeldungen sind ZWEISPRACHIG (de/en)**: Jede an den Anwender gerichtete Meldung (`princ`/`alert`/`getstring`/`getint`/`getreal`/`getkword`-Prompts, auch per `strcat` zusammengesetzte) laeuft ueber `(ssg-text "key")` bzw. `(ssg-textf "key" (list args))`. Die Texte stehen in `lang/de_DE.json` UND `lang/en_GB.json` unter `"texts"` und muessen key-fuer-key synchron bleiben (Paritaets-Check vor dem Commit). Konventionen: Key-Prefix je Modul (`vfc-` vf_core, `gf-` Gefaellestrecke), geteilte Prompts ohne Prefix (`prompt-wahl-1-2` usw.) - vor dem Anlegen eines neuen Keys erst die JSONs nach dem deutschen String grep'en und wiederverwenden. Sonderzeichen wie Grad `(chr 176)` / Delta `(chr 916)` als `%n`-Platzhalter uebergeben, nicht in die (ASCII-)JSON einbetten. **Untranslatiert bleiben** (bewusst): Bracket-Diagnosen (`[vf_core]` o.ae.), die VOR dem garantierten Laden von `ssg_lang.lsp` feuern (Bootstrap-Fallbacks am Dateikopf - `ssg-text` existiert dort noch nicht), Lade-Banner (`>>> ... geladen`), reine `====`/`---`-Trenner und reine Entwickler-Diagnosebefehle (nicht im Menue). Details und Entscheidungsbaum: `doc/plan/translate.md`. - **Subagenten** sollten von Claude nur mit Rückfrage an den Nutzer gestartet werden. Dabei sollten wenn möglich die leichteren Modelle gewählt werden, da es sich dabei in der Regel um Code recherche handelt. ## Python-Bibliotheken @@ -190,7 +194,8 @@ Abhaengigkeiten: `ezdxf`, Standard-Library. Benoetigen Umgebungsvariablen (`DXFM | `vf_journal_export.py` | Liest die Eingabe-Journale der `VF_n`-Bloecke (XDATA-App `SSG_VF_EDIT`, Marker `"linienzug"`) aus einer Zeichnung und schreibt sie als Frage-Antwort-Protokoll im Schema von `tests/testdata/linienzug_tests.json` (Gegenstueck zu `vfl-entry->string`; kein ezdxf, reine Gruppencode-Lesung). Optional `--csv ` fuer Strecken-ID und Erwartungswerte je Kette. Aufruf: `python vf_journal_export.py [--csv ...] [--kein-startpunkt-fix]` — erzeugt `tests/testdata/hm_recformat.json` aus `data/polylines.dxf` (die Aufzeichnung, aus der `tests/testdata/hundm05.json` als Spec abgeleitet wird) | | `dxf_vf_abbild.py` | Abbild der `VF_`/`GF_`-Wrapperbloecke einer Testzeichnung: Attribute UND Bausteinzusammensetzung je Kette, Ketten ueber den Einfuegepunkt der Spec zugeordnet (der Blockname taugt nicht - die VF-Nummer beginnt in jeder Zeichnung neu bei 1). Regressionsnetz fuer Umbauten am Bau-Ablauf: `--referenz` vergleicht gegen `tests/reference/hundm05_attribute.json` (Exit 1 bei Abweichung), `--schreibe-referenz` frischt sie nach einem GEPRUEFTEN Lauf auf. Faengt genau das, was der Ergebnis-Record nicht sieht - eine vertauschte `vfl-acc-*`-Reihenfolge (Komma-Listen `L_VF_m`/`L_GF_m`/`GF_WINKEL`, in der Zeichnung unsichtbar, im Sivas-Export falsch) und eine falsche Blockvariante. Liest ASCII-DXF streamend; binaere DXF kann `dxf_scan_components.py`. Genutzt von `tests/test_vf_geometrie.py` | | `vf_spec_export.py` | Uebersetzt ein Eingabe-Journal in eine **Spec** und zurueck (`spec_aus_journal` / `journal_aus_spec`) - Gegenstueck zu `vsp-journal` in `Lisp/vf_spec.lsp`, beide muessen dieselbe Tokenfolge liefern. Der Rundlauf `journal_aus_spec(spec_aus_journal(tok)) == tok` laeuft in `tests/test_vf_spec.py` gegen die 5 echten HundM-Ketten und beweist, dass die Spec das Journal verlustfrei abbildet. Schreibt das flache Spec-JSON (vom LISP-Parser lesbar). Objekte der Ziel-Datei, die keine Kette beschreiben (von Hand ergaenzte Anlagenteile mit `function`, z.B. Kreisel), werden beim Neuschreiben unveraendert ans Dateiende uebernommen - sonst waeren sie beim naechsten Lauf weg. Aufruf: `python vf_spec_export.py ` — erzeugt `tests/testdata/hundm05.json` (Spec, Eingabe fuer `TEST_HUNDM05`/`VF_SPEC_BAU`) aus `tests/testdata/hm_recformat.json` (Aufzeichnung) | -| `dxf_scan_components.py` | Erkennt ILS-/Omniflo-Komponenten in einer **fremden** Projektzeichnung (ohne unsere Wrapper-Bloecke) und schreibt sie im JSON-Schema aus `tests/testdata/object_data.md` — Grundlage fuer Nachbau-Testfaelle wie `tests/testdata/mubea.json`. Liest binaere DXF im GB-Bereich streamend per mmap (ezdxf-DOM waere zu gross), loest INSERTs inkl. OCS/Extrusionsrichtung rekursiv in Weltkoordinaten auf, paart AN8/SP8 zu Kreiseln und Antrieb/Umlenkung zu Foerderern. Aufruf: `python dxf_scan_components.py [--fenster X0 Y0 X1 Y1]` — ohne `--fenster` liefert eine Anlagenzeichnung leicht ueber 1300 Eintraege, zuviel fuer einen Testlauf | +| `dxf_anlage_export.py` | Gegenstueck zum Scanner: liest eine mit unseren Makros GEBAUTE (und von Hand nachbearbeitete) Anlage aus der Zeichnung zurueck in Nachbau-Testdaten - je Wrapper genau die Parameter, die auch dessen Edit-Befehl liest (KREISEL_n: Einfuegepunkt, `abstand` exakt aus der Blockdefinition, `drehrichtung` aus DREHRICHTUNG; GF_n: SSG_GF_EDIT + SEITE_AS/ES, endet die GF auf einer Kreisel-Kette, wird dessen Hoehe `hoehe_ende_mm`; VF_n `standard`/`etage`: mubea-Schema wie `vfs-edit-basis-lesen`; VF_n `linienzug`: Journal UNVERAENDERT als `"typ": "linienzug_journal"` - bewusst keine Spec, weil der Bau-Dialog neuer ist als die Spec-Grammatik; uebrige Bloecke als Einzel-Insert ohne `_2D`/`_3D`-Suffix). Reihenfolge Kreisel, VF, GF, Einzelbloecke (VF vor GF wie mubea). Aufruf: `python dxf_anlage_export.py [--projekt NAME]` — erzeugt `tests/testdata/dematic_arvato.json` aus `Dematic_TST.dxf`. Test `tests/test_dxf_anlage_export.py` | +| `dxf_scan_components.py` | Erkennt ILS-/Omniflo-Komponenten in einer **fremden** Projektzeichnung (ohne unsere Wrapper-Bloecke) und schreibt sie im JSON-Schema aus `tests/testdata/object_data.md` — Grundlage fuer Nachbau-Testfaelle wie `tests/testdata/mubea.json`. Liest binaere DXF im GB-Bereich streamend per mmap (ezdxf-DOM waere zu gross), loest INSERTs inkl. OCS/Extrusionsrichtung rekursiv in Weltkoordinaten auf, paart AN8/SP8 zu Kreiseln und Antrieb/Umlenkung zu Foerderern. Gefaellestrecken, die als 3D-LINE auf einem Staustrecken-Layer gezeichnet sind (`GF_LINIE_LAYER`, z.B. `6-SP`), werden in einem zweiten Lesedurchgang zu Modus-1-Eintraegen: Start/Ende werden auf die Ketten der anschliessenden Kreisel verlaengert (gezeichnet ist nur die Staustrecke; `deltaL` reicht von AS- bis ES-Ursprung), AS-Seite aus dem Ausschleuselement am oberen Ende; dieses und Separatoren auf der Achse entfallen als Einzel-Insert (die GF baut beide selbst). Sitzt der AS am UNTEREN Ende, ist es ein Steigfoerderer und wird nur gemeldet (`gf_eintraege_aus_linien`, Test `tests/test_dxf_scan_gf.py`). `--ohne-hoehen` setzt alle Z auf 0, `--kreisel-hoehe X Y Z` gibt einem Kreisel seine Hoehe - die daran haengenden GF bekommen daraus `start_mm.z`/`hoehe_ende_mm`, den Winkel rechnet der Treiber (`dematic_arvato:gf-geometrie`: atan ueber die HORIZONTALE Laenge, ES-Laenge UND -Abfall bei der Einlaufneigung gemessen und iteriert, Staustrecke daraus - die flache ES-Laenge liess steile GF ~144 mm vor der Kette enden - NICHT `gf-winkel-berechnen`, dessen asin bei steilen GF wie im Showroom ~50 statt ~37 Grad liefert; `dematic_arvato:gf-endhoehe-pruefen` meldet `warnung` bei > 5 mm Abweichung von HOEHE_BIS). Flache 2D-Plaene: `--flach` (waagrechte Staustrecke mit AS an genau einem Ende = GF, zerstueckelte Linien werden vereint, ES am unteren Ende wird verbraucht, AS/ES-Seite ohne Namensangabe aus der Lage zur Fahrtrichtung), `--kreisel-achse X1 Y1 X2 Y2` (Kreisel ohne AN8/SP8), Einzelteile auf einer Kreisel-Kette erben dessen Anwender-Hoehe (`sensor_hoehen_von_kreiseln`). Kreisel-Paarung mit Tausch-Nachbesserung auf minimale Abstandssumme (zwei Kreisel auf einer Achse). Genutzt fuer `tests/testdata/showroom_ils.json` (`TEST_SHOWROOM_ILS`). Aufruf: `python dxf_scan_components.py [--fenster X0 Y0 X1 Y1]` — ohne `--fenster` liefert eine Anlagenzeichnung leicht ueber 1300 Eintraege, zuviel fuer einen Testlauf | ### Entwickler-Tools (`lib/`) - kein ezdxf, reine Text-/AutoLISP-Verarbeitung @@ -206,7 +211,7 @@ Abhaengigkeiten: `ezdxf`, Standard-Library. Benoetigen Umgebungsvariablen (`DXFM ## Entwicklungsstand -Siehe `doc/Entwicklungsplan.md` fuer Meilensteinplanung und Aufwandsschaetzung. +Siehe `doc/plan/Entwicklungsplan.md` fuer Meilensteinplanung und Aufwandsschaetzung. Fertig (DONE): ILS Kreisel, ILS Eckrad, ILS Variofoerderer, ILS BTMT Be-/Entladung (Einfuegen), Omniflo Boegen, Omniflo Weichen. ## Debug diff --git a/Lisp/Gefaellestrecke.lsp b/Lisp/Gefaellestrecke.lsp index 162b30b..c03d27e 100644 --- a/Lisp/Gefaellestrecke.lsp +++ b/Lisp/Gefaellestrecke.lsp @@ -714,16 +714,161 @@ prev-hz ) +;; Dialog fuer Modus 3 (Linienzug), Teil 1: AUS-/EIN-Element Winkel+Seite - +;; ersetzt die vier Konsolenfragen (AUS-Winkel, AUS-Seite, EIN-Winkel, +;; EIN-Seite). Muss VOR der Segmentlaengen-Anpassung/Winkelberechnung +;; laufen (die braucht aus-dx/ein-dx aus vf-set-as-masse/-es-masse), darum +;; eigener, frueherer Dialog statt zusammen mit dem Winkel-Vorschlag. +;; prefill: Alist (("as-winkel" . "90"|"30") ("as-seite" . "links"|"rechts") +;; ("es-winkel" . ...) ("es-seite" . ...)) fuer den Edit-Nachbau, oder nil +;; fuer die Defaults (90/links) beim Neu-Bauen. +;; Rueckgabe: (as-winkel as-seite es-winkel es-seite) bei OK, 'ABBRUCH wenn +;; der Nutzer bewusst abbricht (Aufrufer bricht dann den GANZEN Befehl ab, +;; KEIN Rueckfall auf die Konsole), nil wenn der Dialog gar nicht gezeigt +;; werden konnte/durfte (GUI aus) - NUR dann Konsolen-Rueckfall. +(defun gf-dialog-linienzug-aus-ein (prefill / dcl-pfad dat ergebnis + dlg-aus-winkel dlg-aus dlg-ein-winkel dlg-ein + as-seite es-seite as-winkel es-winkel) + (if (or (not (car (atoms-family 1 '("SSG-GUI-P")))) (ssg-gui-p)) + (progn + (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/gefaellestrecke.dcl")) + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "gefaellestrecke_linienzug" dat)) + (progn (if (and dat (>= dat 0)) (unload_dialog dat)) nil) + (progn + (set_tile "zusammenfassung" (ssg-text "gf-dlg-linienzug-vorlauf")) + (mode_tile "winkel" 1) + + (start_list "aus_winkel") + (add_list "90") + (add_list "30") + (end_list) + (set_tile "aus_winkel" + (if (and prefill (equal (cdr (assoc "as-winkel" prefill)) "30")) "1" "0")) + (start_list "aus_seite") + (add_list (ssg-text "gf-dlg-links")) + (add_list (ssg-text "gf-dlg-rechts")) + (end_list) + (set_tile "aus_seite" + (if (and prefill (equal (cdr (assoc "as-seite" prefill)) "rechts")) "1" "0")) + + (start_list "ein_winkel") + (add_list "90") + (add_list "30") + (end_list) + (set_tile "ein_winkel" + (if (and prefill (equal (cdr (assoc "es-winkel" prefill)) "30")) "1" "0")) + (start_list "ein_seite") + (add_list (ssg-text "gf-dlg-links")) + (add_list (ssg-text "gf-dlg-rechts")) + (end_list) + (set_tile "ein_seite" + (if (and prefill (equal (cdr (assoc "es-seite" prefill)) "rechts")) "1" "0")) + + (action_tile "accept" + (strcat + "(setq dlg-aus-winkel (get_tile \"aus_winkel\"))" + "(setq dlg-aus (get_tile \"aus_seite\"))" + "(setq dlg-ein-winkel (get_tile \"ein_winkel\"))" + "(setq dlg-ein (get_tile \"ein_seite\"))" + "(done_dialog 1)" + ) + ) + (action_tile "cancel" "(done_dialog 0)") + (setq ergebnis (start_dialog)) + (unload_dialog dat) + + (cond + ((= ergebnis 1) + (setq as-winkel (if (= dlg-aus-winkel "1") "30" "90")) + (setq as-seite (if (= dlg-aus "1") "rechts" "links")) + (setq es-winkel (if (= dlg-ein-winkel "1") "30" "90")) + (setq es-seite (if (= dlg-ein "1") "rechts" "links")) + (list as-winkel as-seite es-winkel es-seite) + ) + (t 'ABBRUCH) + ) + ) + ) + ) + nil + ) +) + +;; Dialog fuer Modus 3, Teil 2: Gefaellewinkel-Bestaetigung VOR der +;; iterativen AS/ES-Korrekturschleife (die braucht den vom Nutzer +;; gewaehlten/bestaetigten Ausgangswinkel, berechnet selbst aber nicht +;; interaktiv weiter) - ersetzt die "Berechneten Winkel verwenden?"-Frage +;; samt optionalem manuellem Winkel. Ersetzt zugleich die SPAETERE finale +;; Einfuegen-Bestaetigung: nach diesem OK baut der Aufrufer direkt, ohne +;; weitere Rueckfrage (analog "dialog-bestaetigt" bei Modus 1/2) - die +;; Zusammenfassung mit dem Vorschlag genuegt als Entscheidungsgrundlage, +;; eine zweite Bestaetigung NACH der (rein automatischen) Korrekturschleife +;; waere redundant. Das AS/ES-Auswahlpaar wird hier nur noch ANGEZEIGT +;; (disabled), nicht erneut editierbar - es ist schon in die Segmentlaengen +;; eingerechnet. +;; zusammenfassung-zeilen: Liste bereits fertig formatierter Strings. +;; Rueckgabe: Gefaellewinkel (Grad) bei OK, 'ABBRUCH wenn der Nutzer bewusst +;; abbricht (Aufrufer bricht dann den GANZEN Befehl ab, KEIN Rueckfall auf +;; die Konsole), nil wenn der Dialog gar nicht gezeigt werden konnte/durfte +;; (GUI aus) - NUR dann Konsolen-Rueckfall (inkl. der spaeteren finalen +;; Einfuegen-Bestaetigung, die in diesem Fall unveraendert bleibt). +(defun gf-dialog-linienzug-winkel (zusammenfassung-zeilen winkel-vorschlag + as-winkel as-seite es-winkel es-seite / + dcl-pfad dat ergebnis dlg-winkel grade) + (if (or (not (car (atoms-family 1 '("SSG-GUI-P")))) (ssg-gui-p)) + (progn + (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/gefaellestrecke.dcl")) + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "gefaellestrecke_linienzug" dat)) + (progn (if (and dat (>= dat 0)) (unload_dialog dat)) nil) + (progn + (set_tile "zusammenfassung" (ssg-join zusammenfassung-zeilen " | ")) + + (start_list "aus_winkel") (add_list as-winkel) (end_list) + (set_tile "aus_winkel" "0") + (start_list "aus_seite") (add_list as-seite) (end_list) + (set_tile "aus_seite" "0") + (start_list "ein_winkel") (add_list es-winkel) (end_list) + (set_tile "ein_winkel" "0") + (start_list "ein_seite") (add_list es-seite) (end_list) + (set_tile "ein_seite" "0") + (mode_tile "aus_winkel" 1) (mode_tile "aus_seite" 1) + (mode_tile "ein_winkel" 1) (mode_tile "ein_seite" 1) + + (set_tile "winkel" (rtos winkel-vorschlag 2 3)) + + (action_tile "accept" + "(setq dlg-winkel (get_tile \"winkel\")) (done_dialog 1)") + (action_tile "cancel" "(done_dialog 0)") + (setq ergebnis (start_dialog)) + (unload_dialog dat) + + (cond + ((= ergebnis 1) + (setq grade (atof dlg-winkel)) + (if (<= grade 0) (setq grade winkel-vorschlag)) + grade + ) + (t 'ABBRUCH) + ) + ) + ) + ) + nil + ) +) + ;; Hauptfunktion Modus 3 (defun gf-linienzug-modus ( / ss n i j obj obj-liste kette segmente seg startpunkt endpunkt-ref deltaH grade antwort idx as-seite es-seite as-block es-block - gf-as-winkel gf-es-winkel + gf-as-winkel gf-es-winkel dlg-aus-ein dlg-winkel-erg entry-hz exit-hz first-idx last-idx neu-l aktuell-frame nach-aus-pt - gf-nummer last-ent + gf-nummer last-ent gf-lz-insert L-gf-str delta-l-gf laengen-liste first-l l-item bL90 bL60 bL30 bR90 bR60 bR30 ein-hz-as rad-h-as rad-v-as xu-entry @@ -787,29 +932,41 @@ (setq entry-hz (cadr (car segmente))) (setq exit-hz (gf-exit-hz segmente)) - ;; AUS-Element: 30/90 (vor Seite), dann Seite (vor Winkelberechnung, da die - ;; Laengenanpassung von der AS/ES-Masse abhaengt). Masse fuer Variante setzen. - (princ (ssg-text "vf-winkel-aus-header")) - (princ (ssg-text "vf-winkel-90")) - (princ (ssg-text "vf-winkel-30")) - (setq gf-as-winkel (vf-frage-element-winkel "vf-winkel-aus-header")) - (princ (ssg-text "gf-seite-aus-header")) - (princ (ssg-text "gf-seite-links")) - (princ (ssg-text "gf-seite-rechts")) - (setq antwort (getstring (ssg-text "prompt-wahl-1-2"))) - (setq as-seite (if (= antwort "2") "rechts" "links")) - (vf-set-as-masse gf-as-winkel as-seite) + ;; AUS-/EIN-Element: 30/90 + Seite, in EINEM Dialog (vor Winkelberechnung, + ;; da die Laengenanpassung von der AS/ES-Masse abhaengt). Rueckfall auf die + ;; alten Konsolenfragen, wenn der Dialog nicht gezeigt werden kann/darf. + (setq dlg-aus-ein (gf-dialog-linienzug-aus-ein nil)) + (if (eq dlg-aus-ein 'ABBRUCH) + (progn (princ (ssg-text "vfc-vorgang-abgebrochen")) (exit)) + ) + (if dlg-aus-ein + (setq gf-as-winkel (nth 0 dlg-aus-ein) + as-seite (nth 1 dlg-aus-ein) + gf-es-winkel (nth 2 dlg-aus-ein) + es-seite (nth 3 dlg-aus-ein)) + (progn + (princ (ssg-text "vf-winkel-aus-header")) + (princ (ssg-text "vf-winkel-90")) + (princ (ssg-text "vf-winkel-30")) + (setq gf-as-winkel (vf-frage-element-winkel "vf-winkel-aus-header")) + (princ (ssg-text "gf-seite-aus-header")) + (princ (ssg-text "gf-seite-links")) + (princ (ssg-text "gf-seite-rechts")) + (setq antwort (getstring (ssg-text "prompt-wahl-1-2"))) + (setq as-seite (if (= antwort "2") "rechts" "links")) - ;; EIN-Element: 30/90 + Seite - (princ (ssg-text "vf-winkel-ein-header")) - (princ (ssg-text "vf-winkel-90")) - (princ (ssg-text "vf-winkel-30")) - (setq gf-es-winkel (vf-frage-element-winkel "vf-winkel-ein-header")) - (princ (ssg-text "gf-seite-ein-header")) - (princ (ssg-text "gf-seite-links")) - (princ (ssg-text "gf-seite-rechts")) - (setq antwort (getstring (ssg-text "prompt-wahl-1-2"))) - (setq es-seite (if (= antwort "2") "rechts" "links")) + (princ (ssg-text "vf-winkel-ein-header")) + (princ (ssg-text "vf-winkel-90")) + (princ (ssg-text "vf-winkel-30")) + (setq gf-es-winkel (vf-frage-element-winkel "vf-winkel-ein-header")) + (princ (ssg-text "gf-seite-ein-header")) + (princ (ssg-text "gf-seite-links")) + (princ (ssg-text "gf-seite-rechts")) + (setq antwort (getstring (ssg-text "prompt-wahl-1-2"))) + (setq es-seite (if (= antwort "2") "rechts" "links")) + ) + ) + (vf-set-as-masse gf-as-winkel as-seite) (vf-set-es-masse gf-es-winkel es-seite) (setq as-block (strcat "AS_Element_" gf-as-winkel "_" as-seite)) @@ -881,14 +1038,30 @@ (princ (ssg-text "gf-status-berechne-winkel")) (setq grade (gf-winkel-berechnen segmente deltaH 1)) - ;; Manuelle Anpassung - (setq antwort - (getstring (ssg-textf "gf-prompt-winkel-verwenden" - (list (rtos grade 2 3) grad-zeichen)))) - (if (= (strcase antwort) "N") + ;; Manuelle Anpassung per Dialog (ersetzt zugleich die SPAETERE finale + ;; Einfuegen-Bestaetigung, siehe gf-dialog-linienzug-winkel) - Rueckfall + ;; auf die alten Konsolenfragen, wenn der Dialog nicht gezeigt werden + ;; kann/darf; dann bleibt auch die spaetere Einfuegen-Bestaetigung aktiv. + (setq dlg-winkel-erg + (gf-dialog-linienzug-winkel + (list (ssg-textf "gf-status-zus-segmente" (list (length segmente))) + (ssg-textf "gf-status-zus-deltah" (list delta-sym (rtos deltaH 2 2)))) + grade gf-as-winkel as-seite gf-es-winkel es-seite)) + (if (eq dlg-winkel-erg 'ABBRUCH) + (progn (princ (ssg-text "vfc-vorgang-abgebrochen")) (exit)) + ) + (if dlg-winkel-erg + (setq grade dlg-winkel-erg) (progn - (setq grade (getreal (ssg-text "gf-prompt-gefaellewinkel"))) - (if (or (null grade) (<= grade 0)) (setq grade 3.0)) + (setq antwort + (getstring (ssg-textf "gf-prompt-winkel-verwenden" + (list (rtos grade 2 3) grad-zeichen)))) + (if (= (strcase antwort) "N") + (progn + (setq grade (getreal (ssg-text "gf-prompt-gefaellewinkel"))) + (if (or (null grade) (<= grade 0)) (setq grade 3.0)) + ) + ) ) ) (setq grade (float grade)) @@ -953,8 +1126,9 @@ (princ (ssg-textf "gf-status-zus-ein-element" (list es-block))) (princ "\n=========================================") - ;; Bestaetigung - (setq antwort (getstring (ssg-text "gf-prompt-einfuegen"))) + ;; Bestaetigung - entfaellt, wenn der Dialog oben bereits bestaetigt hat + ;; (dlg-winkel-erg ist dann eine Zahl, kein nil/'ABBRUCH). + (setq antwort (if dlg-winkel-erg "1" (getstring (ssg-text "gf-prompt-einfuegen")))) (if (not (= antwort "2")) (progn ;; GF-Nummer und Entity-Grenze vor erster Einfuegung sichern. @@ -1004,15 +1178,20 @@ (- (sin rad-v-es)))) (setq sep-frame (make-frame-from-dir sep-endpunkt xu-exit)) - ;; EIN-Element: KS_EIN bleibt in X/Y auf dem Ketten-Pfad (sep-frame), - ;; seine eigene Achse verlaeuft damit trivial durch diesen Punkt. - ;; Die Z-Hoehe wird jedoch an KS_AUS gemessen, damit KS_AUS.Z exakt - ;; auf endpunkt-ref.Z landet (garantiert die gewuenschte DeltaH). + ;; EIN-Element: reine KS-zu-KS-Verkettung (wie bei Modus 1/2 in + ;; gefaellestrecke-einfuegen) statt insert-block-mixed-to-ks mit + ;; erzwungener Ziel-Z. sep-frame richtet KS_EIN des ES-Elements exakt + ;; am Ketten-Pfad (Position UND Neigung) aus; die Endhoehe ergibt sich + ;; danach von selbst aus KS_AUS, es wird nichts nachtraeglich + ;; verschoben. Zwei vorherige Versuche waren beide falsch: endpunkt-ref + ;; (Mausklick-Z, meist = Starthoehe) UND z-ref="KS_AUS" bei + ;; insert-block-mixed-to-ks (zwang den BLOCKAUSGANG statt -eingang auf + ;; die Zielhoehe, Rest-Versatz = Blockinnenhoehe KS_EIN<->KS_AUS, + ;; ~65mm). endpunkt-ref/der zweite Mausklick dient weiterhin nur zur + ;; groben deltaH-Schaetzung fuer den Winkel-Vorschlag im Dialog. + (setq es-aus-frame (insert-block-ks-to-ks es-block sep-frame)) (princ (ssg-textf "gf-status-ein-element-detail" - (list es-block (rtos (caddr endpunkt-ref) 2 1)))) - (setq es-aus-frame - (insert-block-mixed-to-ks es-block sep-frame - (caddr endpunkt-ref) "KS_EIN" "KS_AUS")) + (list es-block (rtos (caddr sep-endpunkt) 2 1)))) (princ (ssg-textf "gf-status-z-hoehe-ks-aus" (list (rtos (caddr (car es-aus-frame)) 2 1)))) ;; --- GF_N-Block erstellen --- @@ -1052,27 +1231,37 @@ ) ;; delta-l-gf bereits vor der Zusammenfassung berechnet - ;; Block mit allen Attributen erstellen. Geruest fuer Einzelmodul/ - ;; Geruestoption sind in diesem Linienzug-Ablauf (Modus 3, keine DCL- - ;; Eingabe) nicht abfragbar - bleiben auf Schema-Default. - (gf-block-erstellen - "gruppe" as-seite gf-nummer - (caddr startpunkt) - (caddr endpunkt-ref) - deltaH - delta-l-gf - L-gf-str - grade - ;; n-separator/n-scanner = 0: interne Ketten-Separatoren zaehlen nicht; - ;; die echte Anzahl setzt der Export aus platzierten Symbolen. - 0 - 0 - bL90 bL60 bL30 - bR90 bR60 bR30 - startpunkt last-ent nach-aus-pt entry-hz - (caddr (nth first-idx segmente)) - es-seite "0" "Schoenenberger Geruest" - gf-as-winkel gf-es-winkel) + ;; Block mit allen Attributen erstellen. HOEHE_BIS_mm kommt aus der + ;; TATSAECHLICH gebauten Endhoehe (es-aus-frame), nicht aus der + ;; geklickten endpunkt-ref.Z - sonst wiche das Attribut von der + ;; echten Geometrie ab (derselbe Bug wie bei der ES-Platzierung oben). + ;; Geruest fuer Einzelmodul/Geruestoption sind in diesem Linienzug- + ;; Ablauf (Modus 3, keine DCL-Eingabe) nicht abfragbar - bleiben auf + ;; Schema-Default. + (setq gf-lz-insert + (gf-block-erstellen + "gruppe" as-seite gf-nummer + (caddr startpunkt) + (caddr (car es-aus-frame)) + deltaH + delta-l-gf + L-gf-str + grade + ;; n-separator/n-scanner = 0: interne Ketten-Separatoren zaehlen nicht; + ;; die echte Anzahl setzt der Export aus platzierten Symbolen. + 0 + 0 + bL90 bL60 bL30 + bR90 bR60 bR30 + startpunkt last-ent nach-aus-pt entry-hz + (caddr (nth first-idx segmente)) + es-seite "0" "Schoenenberger Geruest" + gf-as-winkel gf-es-winkel)) + + ;; Segmentliste + Startpunkt fuer den Doppelklick-Nachbau sichern (siehe + ;; c:GEFAELLESTRECKE_EDIT) - ohne diese XDATA war eine per Linienzug + ;; gebaute Streckengruppe bisher nicht editierbar. + (gf-lz-xdata-schreiben gf-lz-insert segmente startpunkt) (princ "\n\n=========================================") (princ (ssg-text "gf-status-fertig")) @@ -1082,6 +1271,217 @@ ) ) +;; Doppelklick-Nachbau fuer eine per GEFAELLESTRECKE_LINIENZUG (Modus 3) +;; gebaute Streckengruppe - Gegenstueck zu gf-rebuild (Modus 1/2), aufgerufen +;; aus c:GEFAELLESTRECKE_EDIT. Anders als beim Neu-Bauen (gf-linienzug-modus) +;; sind die Segmentlaengen hier bereits FINAL (AS-/ES-dx und Separator- +;; Abzuege sind laengst eingerechnet, siehe gf-lz-xdata-schreiben) - die +;; Segmentlisten-Anpassungsschleife aus gf-linienzug-modus entfaellt darum +;; komplett, nur AS-/ES-Winkel+Seite und der Gefaellewinkel bleiben ueber +;; dieselben zwei Dialoge editierbar (gf-dialog-linienzug-aus-ein/-winkel, +;; diesmal mit Prefill aus den Block-Attributen). Baut am gleichen +;; startpunkt neu, loescht den alten Block NACH erfolgreichem Neuaufbau. +;; segmente/startpunkt: aus gf-lz-xdata-lesen. alt-ent: der zu ersetzende +;; GF_n-Block. prefill: Alist wie gf-dialog-linienzug-aus-ein (AS/ES aus den +;; aktuellen Attributen des Blocks). +(defun gf-linienzug-rebuild (segmente startpunkt alt-ent prefill / + deltaH entry-hz exit-hz as-seite es-seite + gf-as-winkel gf-es-winkel as-block es-block + dlg-aus-ein dlg-winkel-erg grade + first-idx j seg end-z endpunkt-ref delta-l-gf + aktuell-frame nach-aus-pt ein-hz-as rad-h-as xu-entry + sep-endpunkt rad-h-es rad-v-es xu-exit sep-frame es-aus-frame + gf-nummer last-ent gf-lz-insert + L-gf-str laengen-liste first-l l-item + bL90 bL60 bL30 bR90 bR60 bR30 + rad-v-korr ein-hz-as-k rad-h-as-k xu-as-meas + rad-h-es-k xu-es-meas dz-as-ist dz-es-ist + dH-korr grade-prev iter) + (if (or (null segmente) (< (length segmente) 1)) + (progn (alert (ssg-text "gf-alert-keine-kette")) (exit)) + ) + + (setq entry-hz (cadr (car segmente))) + (setq exit-hz (gf-exit-hz segmente)) + + ;; AUS-/EIN-Element, vorbelegt aus den aktuellen Attributen + (setq dlg-aus-ein (gf-dialog-linienzug-aus-ein prefill)) + (if (eq dlg-aus-ein 'ABBRUCH) + (progn (princ (ssg-text "vfc-vorgang-abgebrochen")) (exit)) + ) + (if (null dlg-aus-ein) + (progn (alert (ssg-text "gf-alert-lz-edit-kein-dialog")) (exit)) + ) + (setq gf-as-winkel (nth 0 dlg-aus-ein) + as-seite (nth 1 dlg-aus-ein) + gf-es-winkel (nth 2 dlg-aus-ein) + es-seite (nth 3 dlg-aus-ein)) + (vf-set-as-masse gf-as-winkel as-seite) + (vf-set-es-masse gf-es-winkel es-seite) + + (setq as-block (strcat "AS_Element_" gf-as-winkel "_" as-seite)) + (setq es-block (strcat "ES_Element_" gf-es-winkel "_" es-seite)) + + ;; Index des ersten "Linie"-Segments (fuer die Label-Laenge) - KEINE + ;; Laengenanpassung, die Segmentlaengen sind bereits final. + (setq first-idx -1 j 0) + (while (and (< j (length segmente)) (< first-idx 0)) + (if (= (car (nth j segmente)) "Linie") (setq first-idx j)) + (setq j (1+ j)) + ) + (if (< first-idx 0) (setq first-idx 0)) + + ;; Ziel-Endhoehe aus dem Z-Attribut HOEHE_BIS_mm des alten Blocks (X/Y des + ;; wirklichen Endpunkts wird erst NACH dem Bau aus der Geometrie selbst + ;; bestimmt, siehe unten - sie ist nicht separat in der XDATA gespeichert + ;; und nur fuer die Zusammenfassung/das Label relevant, nicht fuer den Bau + ;; selbst, der komplett der Segmentliste folgt). + (setq end-z (atof (cond ((cdr (assoc "HOEHE_BIS_mm" (ssg-attrib-read alt-ent)))) ("0")))) + (setq deltaH (abs (- (caddr startpunkt) end-z))) + + (princ (ssg-text "gf-status-berechne-winkel")) + (setq grade (gf-winkel-berechnen segmente deltaH 1)) + + (setq dlg-winkel-erg + (gf-dialog-linienzug-winkel + (list (ssg-textf "gf-status-zus-segmente" (list (length segmente))) + (ssg-textf "gf-status-zus-deltah" (list delta-sym (rtos deltaH 2 2)))) + grade gf-as-winkel as-seite gf-es-winkel es-seite)) + (if (eq dlg-winkel-erg 'ABBRUCH) + (progn (princ (ssg-text "vfc-vorgang-abgebrochen")) (exit)) + ) + (if (null dlg-winkel-erg) + (progn (alert (ssg-text "gf-alert-lz-edit-kein-dialog")) (exit)) + ) + (setq grade (float dlg-winkel-erg)) + + ;; Winkelkorrektur (identisch zu gf-linienzug-modus) + (if (and *gf-L-ohne-as-es* (> *gf-L-ohne-as-es* 0.1)) + (progn + (princ (ssg-text "gf-status-messe-absenkung")) + (setq grade-prev -999.0 iter 0) + (while (and (< iter 4) (> (abs (- grade grade-prev)) 0.001)) + (setq grade-prev grade) + (setq rad-v-korr (* grade (/ pi 180.0))) + (setq ein-hz-as-k (- entry-hz + (vf-element-plan-turn (strcat "AS_Element_" gf-as-winkel "_" as-seite)))) + (setq rad-h-as-k (* (float ein-hz-as-k) (/ pi 180.0))) + (setq xu-as-meas (list (cos rad-h-as-k) (sin rad-h-as-k) 0.0)) + (setq rad-h-es-k (* (float exit-hz) (/ pi 180.0))) + (setq xu-es-meas (list (* (cos rad-h-es-k)(cos rad-v-korr)) + (* (sin rad-h-es-k)(cos rad-v-korr)) + (- (sin rad-v-korr)))) + (setq dz-as-ist (gf-messe-dz-block as-block xu-as-meas)) + (setq dz-es-ist (gf-messe-dz-block es-block xu-es-meas)) + (setq dH-korr (- (float deltaH) dz-as-ist dz-es-ist (float *gf-sum-dz-bogen*))) + (if (and (> dH-korr 0.0) (< (/ dH-korr *gf-L-ohne-as-es*) 1.0)) + (setq grade (* (asin (/ dH-korr *gf-L-ohne-as-es*)) (/ 180.0 pi))) + (progn + (princ (ssg-text "gf-warnung-korrektur-bereich")) + (setq grade-prev grade) + ) + ) + (setq iter (1+ iter)) + ) + (princ (ssg-textf "gf-status-korrigierter-winkel" + (list (rtos grade 2 3) grad-zeichen (itoa iter)))) + ) + ) + ;; Alten Block ERST NACH erfolgreichem Neuaufbau loeschen (siehe unten) - + ;; die GF-Nummer/last-ent-Grenze muss aber VOR dem Neu-Einfuegen stehen. + (setq gf-nummer (gf-next-number)) + (setq last-ent (ssg-lastent-ohne-attribute)) + + (setq ein-hz-as (- entry-hz + (vf-element-plan-turn (strcat "AS_Element_" gf-as-winkel "_" as-seite)))) + (setq rad-h-as (* (float ein-hz-as) (/ pi 180.0))) + (setq xu-entry (list (cos rad-h-as) (sin rad-h-as) 0.0)) + (setq aktuell-frame + (insert-block-mixed-to-ks as-block (make-frame-from-dir startpunkt xu-entry) + (caddr startpunkt) nil "KS_EIN")) + (setq nach-aus-pt (car aktuell-frame)) + + (setq aktuell-frame (gf-linienzug-einfuegen segmente grade aktuell-frame)) + + (setq sep-endpunkt + (gf-insert-hz-with-ks "Staustrecke_Separator_SP_300_mm" + (car aktuell-frame) exit-hz grade 300 0)) + (setq rad-h-es (* (float exit-hz) (/ pi 180.0))) + (setq rad-v-es (* (float grade) (/ pi 180.0))) + (setq xu-exit (list (* (cos rad-h-es)(cos rad-v-es)) + (* (sin rad-h-es)(cos rad-v-es)) + (- (sin rad-v-es)))) + (setq sep-frame (make-frame-from-dir sep-endpunkt xu-exit)) + ;; Reine KS-zu-KS-Verkettung wie in gf-linienzug-modus (siehe dortiger + ;; Kommentar) - end-z (gespeicherte Soll-Endhoehe) wird nur zur + ;; deltaH-Schaetzung fuer die Winkelberechnung oben gebraucht, nicht hier. + (setq es-aus-frame (insert-block-ks-to-ks es-block sep-frame)) + + ;; Echter Endpunkt (fuer DELTA_L-Attribut/Label) erst jetzt aus der + ;; gebauten Geometrie bekannt - KS_AUS des ES-Elements. + (setq endpunkt-ref (car es-aus-frame)) + (setq delta-l-gf + (sqrt (+ (expt (- (car endpunkt-ref) (car startpunkt)) 2) + (expt (- (cadr endpunkt-ref) (cadr startpunkt)) 2)))) + + (setq laengen-liste '() first-l t) + (foreach seg segmente + (if (= (car seg) "Linie") + (setq laengen-liste + (append laengen-liste (list (rtos (/ (caddr seg) 1000.0) 2 3)))) + ) + ) + (setq L-gf-str "") + (foreach l-item laengen-liste + (if first-l + (progn (setq L-gf-str l-item) (setq first-l nil)) + (setq L-gf-str (strcat L-gf-str "," l-item)) + ) + ) + + (setq bL90 0 bL60 0 bL30 0 bR90 0 bR60 0 bR30 0) + (foreach seg segmente + (if (= (car seg) "Bogen") + (cond + ((and (= (nth 4 seg) "links") (= (nth 3 seg) 90)) (setq bL90 (1+ bL90))) + ((and (= (nth 4 seg) "links") (= (nth 3 seg) 60)) (setq bL60 (1+ bL60))) + ((and (= (nth 4 seg) "links") (= (nth 3 seg) 30)) (setq bL30 (1+ bL30))) + ((and (= (nth 4 seg) "rechts") (= (nth 3 seg) 90)) (setq bR90 (1+ bR90))) + ((and (= (nth 4 seg) "rechts") (= (nth 3 seg) 60)) (setq bR60 (1+ bR60))) + ((and (= (nth 4 seg) "rechts") (= (nth 3 seg) 30)) (setq bR30 (1+ bR30))) + ) + ) + ) + + (setq gf-lz-insert + (gf-block-erstellen + "gruppe" as-seite gf-nummer + (caddr startpunkt) + (caddr endpunkt-ref) + deltaH + delta-l-gf + L-gf-str + grade + 0 0 + bL90 bL60 bL30 + bR90 bR60 bR30 + startpunkt last-ent nach-aus-pt entry-hz + (caddr (nth first-idx segmente)) + es-seite "0" "Schoenenberger Geruest" + gf-as-winkel gf-es-winkel)) + + (gf-lz-xdata-schreiben gf-lz-insert segmente startpunkt) + + ;; Alten Block erst jetzt entfernen - der Neuaufbau ist bereits vollstaendig + ;; abgeschlossen, ein Fehler davor haette ihn stehen gelassen. + (if (and alt-ent (entget alt-ent)) (entdel alt-ent)) + + (princ "\n\n=========================================") + (princ (ssg-text "gf-status-fertig")) + (princ "\n=========================================") + gf-lz-insert +) + ;; ============================================================ ;; TEIL 4.5: GF-BLOCK-SYSTEM (Nummerierung, Label, Attribute) ;; ============================================================ @@ -1704,6 +2104,124 @@ ) ) +;; ============================================================ +;; XDATA fuer den Linienzug-Nachbau (Modus 3, App "SSG_GF_LZ"). +;; Die Segmentliste (gf-analysiere-kette) hat variable Laenge - anders als +;; gf-xdata-schreiben (feste Skalare fuer Modus 1/2) braucht sie ein eigenes +;; String-Format + Chunking (255-Byte-Limit je 1000-Gruppe), analog zur +;; Sepliste-XDATA in ssg_ks_insert.lsp (ssg-sepliste-chunk-string/-split-feld/ +;; -explode-chars werden von dort wiederverwendet statt dupliziert). +;; AS-/ES-Winkel+Seite stehen bereits als Attribute (WINKEL_AS/SEITE_AS/ +;; WINKEL_ES/SEITE_ES) auf dem Block - nur die Segmentliste UND der gebaute +;; Startpunkt (fuer den Neuaufbau-Ursprung) fehlen dort und muessen hier +;; gesichert werden. +;; ============================================================ +(if (null *gf-lz-xdata-app*) (setq *gf-lz-xdata-app* "SSG_GF_LZ")) + +;; Ein Segment "(Typ hz laenge winkel seite)" -> "Typ:hz:laenge:winkel:seite". +(defun gf-segment->string (seg) + (strcat (nth 0 seg) ":" (rtos (float (nth 1 seg)) 2 4) ":" + (rtos (float (nth 2 seg)) 2 4) ":" (itoa (fix (nth 3 seg))) ":" + (nth 4 seg)) +) + +;; Gegenstueck: "Typ:hz:laenge:winkel:seite" -> (Typ hz laenge winkel seite). +(defun gf-string->segment (s / feld) + (setq feld (ssg-sepliste-split-feld s ":")) + (if (= (length feld) 5) + (list (nth 0 feld) (atof (nth 1 feld)) (atof (nth 2 feld)) + (atoi (nth 3 feld)) (nth 4 feld)) + nil + ) +) + +;; Segmentliste -> ein einzelner kommagetrennter String. +(defun gf-segmente->string (segmente / out first) + (setq out "" first t) + (foreach seg segmente + (if first + (progn (setq out (gf-segment->string seg)) (setq first nil)) + (setq out (strcat out "," (gf-segment->string seg))) + ) + ) + out +) + +;; Gegenstueck zu gf-segmente->string - nutzt denselben Zeichen-Explode wie +;; die Sepliste (ssg_ks_insert.lsp), da Segment-Trenner "," mit dem inneren +;; Feld-Trenner ":" nicht kollidiert. +(defun gf-string->segmente (s / out teile eintraege seg) + (setq out '()) + (if (> (strlen s) 0) + (progn + (setq eintraege '() teile "") + (foreach c (ssg-sepliste-explode-chars s) + (if (= c ",") + (progn (setq eintraege (cons teile eintraege)) (setq teile "")) + (setq teile (strcat teile c)) + ) + ) + (setq eintraege (reverse (cons teile eintraege))) + (foreach eintrag eintraege + (if (setq seg (gf-string->segment eintrag)) (setq out (cons seg out))) + ) + ) + ) + (reverse out) +) + +;; Segmentliste + Nachbau-Startpunkt als XDATA schreiben. Marker "linienzug" +;; als erster Wert (Platz fuer kuenftige Varianten, analog SSG_VF_EDIT). +(defun gf-lz-xdata-schreiben (ent segmente startpunkt / chunks appentry) + (if (and ent segmente) + (progn + (regapp *gf-lz-xdata-app*) + (setq chunks + (ssg-sepliste-chunk-string + (strcat (rtos (car startpunkt) 2 4) ";" (rtos (cadr startpunkt) 2 4) ";" + (rtos (caddr startpunkt) 2 4) ";" (gf-segmente->string segmente)) + 250)) + (setq appentry + (cons *gf-lz-xdata-app* + (cons (cons 1000 "linienzug") + (mapcar (function (lambda (c) (cons 1000 c))) chunks)))) + (entmod (append (entget ent) (list (list -3 appentry)))) + ) + ) + ent +) + +;; XDATA lesen -> (startpunkt segmente) oder nil (kein/unbekanntes Linienzug- +;; XDATA am Entity). +(defun gf-lz-xdata-lesen (ent / xd app-data werte roh teile sp-x sp-y sp-z rest) + (setq xd (entget ent (list *gf-lz-xdata-app*))) + (setq app-data (cdr (assoc -3 xd))) + (if app-data + (progn + (setq werte (mapcar 'cdr (cdr (car app-data)))) + (if (and werte (= (car werte) "linienzug")) + (progn + (setq roh (apply 'strcat (cdr werte))) + (setq teile (ssg-sepliste-split-feld roh ";")) + (if (>= (length teile) 4) + (progn + (setq sp-x (atof (nth 0 teile)) sp-y (atof (nth 1 teile)) + sp-z (atof (nth 2 teile))) + ;; Rest nach dem 3. ";" wieder zusammenfuegen (Segmentliste + ;; selbst enthaelt kein ";"). + (setq rest (nth 3 teile)) + (list (list sp-x sp-y sp-z) (gf-string->segmente rest)) + ) + nil + ) + ) + nil + ) + ) + nil + ) +) + ;; ============================================================ ;; TEIL 6: HAUPTBEFEHL ;; ============================================================ @@ -1994,7 +2512,8 @@ (defun c:GEFAELLESTRECKE_EDIT ( / ss ent ed bname startpunkt attribs xd hz winkel as-winkel es-winkel z-start deltaL - as-seite hoehe-bis prefill dlg-werte) + as-seite hoehe-bis prefill dlg-werte + lz-xd lz-segmente lz-startpunkt lz-prefill) ;; Implied Selection VOR ssg-start pruefen (ssg-start hebt Selektion auf) (setq ss (ssget "I")) (if (and ss (= (sslength ss) 1) @@ -2022,9 +2541,37 @@ (setq startpunkt (cdr (assoc 10 ed))) (setq attribs (ssg-attrib-read ent)) + ;; Streckengruppe (mit Bogen) aus GEFAELLESTRECKE_LINIENZUG: eigener + ;; Rebuild-Pfad ueber die Segmentliste in SSG_GF_LZ-XDATA (siehe + ;; gf-linienzug-rebuild), NICHT ueber den einfachen gefaellestrecke-Dialog + ;; unten - der kennt keine Segmentliste/Boegen. Streckengruppe OHNE diese + ;; XDATA (Altbestand/VF-Kombi) bleibt wie bisher nicht editierbar. + (if (= (cond ((cdr (assoc "TYP" attribs))) ("")) "Streckengruppe") + (progn + (setq lz-xd (gf-lz-xdata-lesen ent)) + (cond + (lz-xd + (setq lz-startpunkt (nth 0 lz-xd)) + (setq lz-segmente (nth 1 lz-xd)) + (setq lz-prefill + (list (cons "as-winkel" (cond ((cdr (assoc "WINKEL_AS" attribs))) ("90"))) + (cons "as-seite" (cond ((cdr (assoc "SEITE_AS" attribs))) ("links"))) + (cons "es-winkel" (cond ((cdr (assoc "WINKEL_ES" attribs))) ("90"))) + (cons "es-seite" (cond ((cdr (assoc "SEITE_ES" attribs))) ("links"))))) + (gf-linienzug-rebuild lz-segmente lz-startpunkt ent lz-prefill) + ) + (t + (alert (ssg-textf "gf-edit-nur-einfach" + (list (cond ((cdr (assoc "TYP" attribs))) ("?"))))) + ) + ) + (ssg-end) + (exit) + ) + ) + ;; Nur einfache Gefaellestrecken (TYP "Gefaellestrecke") lassen sich ueber den - ;; Dialog verlustfrei nachbauen. Streckengruppen (mit Bogen / Linienzug / VF) - ;; wuerden beim Neuaufbau ihre Bogengeometrie verlieren -> abbrechen. + ;; Dialog verlustfrei nachbauen. (if (/= (cond ((cdr (assoc "TYP" attribs))) ("")) "Gefaellestrecke") (progn (alert (ssg-textf "gf-edit-nur-einfach" diff --git a/Lisp/KreiselInsert.lsp b/Lisp/KreiselInsert.lsp index a2b2c40..7625716 100644 --- a/Lisp/KreiselInsert.lsp +++ b/Lisp/KreiselInsert.lsp @@ -691,21 +691,25 @@ ;; ============================================================ ;; Kreisel per Script einfuegen (Insert) -;; pt : Einfuegepunkt (x y z) -;; abstand : Abstand in mm -;; rotation : Drehwinkel in Grad -;; typ : Kreiselart ("STANDARD", "PIN", ...) -;; hoehe : Hoehe in mm (oder nil fuer Z aus pt) +;; pt : Einfuegepunkt (x y z) +;; abstand : Abstand in mm +;; rotation : Drehwinkel in Grad +;; typ : Kreiselart ("STANDARD", "PIN", ...) +;; hoehe : Hoehe in mm (oder nil fuer Z aus pt) +;; drehrichtung : "GUZ"/"UZS" (optional, nil -> Default aus *kreisel-attrib-defs*) ;; Rueckgabe: Entity-Name des erzeugten Blocks oder nil -(defun kreisel-insert-script (pt abstand rotation typ hoehe / z blockEnt) +(defun kreisel-insert-script (pt abstand rotation typ hoehe drehrichtung + / z blockEnt attribs) (ssg-start (ssg-text "kreisel-start-script-insert") '(("OSMODE") ("CECOLOR"))) (if (null typ) (setq typ "STANDARD")) (setq z (if hoehe hoehe (if (and pt (caddr pt)) (caddr pt) *kreisel-default-hoehe*))) + (setq attribs (list (cons "KREISELART" typ) + (cons "HOEHE" (rtos z 2 0)))) + (if drehrichtung + (setq attribs (cons (cons "DREHRICHTUNG" drehrichtung) attribs))) (setq blockEnt - (draw-module (list (car pt) (cadr pt) z) abstand rotation - (list (cons "KREISELART" typ) - (cons "HOEHE" (rtos z 2 0))))) + (draw-module (list (car pt) (cadr pt) z) abstand rotation attribs)) (ssg-end) blockEnt ) diff --git a/Lisp/README.md b/Lisp/README.md index 1f38fb2..48c6d1f 100644 --- a/Lisp/README.md +++ b/Lisp/README.md @@ -15,14 +15,17 @@ _MENULOAD → menu/SSG_LIB.mnu auswaehlen ``` BricsCAD laedt daraufhin automatisch `SSG_LIB.mnl`, welches alle Module -per `ssg-ensure` initialisiert (Kern: ssg_core/lang/dbg/dialog/layer, dann -alle Feature-Module). Details: siehe `../CLAUDE.md` Abschnitt "Lademechanismus". +per `ssg-ensure` initialisiert. Kern-Reihenfolge (muss vor den Feature-Modulen +stehen): `ssg_core`, `ssg_lang`, `ssg_dbg`, `ssg_dialog`, `ssg_layer`, `ssg_id`, +`ssg_ks_insert` (Letzteres wird von Gefaellestrecke UND VarioFoerderer genutzt). +Details: siehe `../CLAUDE.md` Abschnitt "Lademechanismus". -**Manuell laden (Notfall / Entwicklung):** +**Manuell laden (Notfall / Entwicklung, z.B. fuer .scr-Testskripte):** ```lisp (load (strcat (getenv "DXFMAKRO") "/Lisp/ssg_load.lsp")) ``` -`ssg_load.lsp` laedt alle Module in der richtigen Reihenfolge ohne Menueabhaengigkeit. +`ssg_load.lsp` ist der Headless-Loader (genutzt von `tests/test_unit.scr` u.ae.) +und laedt dieselbe Kern-Reihenfolge wie `SSG_LIB.mnl`, ohne Menueabhaengigkeit. --- @@ -35,16 +38,22 @@ am Label-Anfang, bei Submenue-Schliessern hinter dem `<-` (`[<-~Label]`). | Menuebereich | Eintraege | Definiert in | | --- | --- | --- | -| ILS ▸ Foerderer | Durch TEF angetriebene Strecke; Kurven 90/60/30 links/rechts angetrieben Aussen + Innen (12) | `SSG_LIB_Commands.lsp` | -| ILS ▸ Gefaellestrecke | Kurven 90/60/30 links/rechts Gefaellestrecke (6) | `SSG_LIB_Commands.lsp` | -| Omniflo ▸ TEF Elemente | UmlenkR/L, AntriebL/R, TEF Gerade, KettenFoerderer (6) | `OmniModulInsert.lsp` | +| Omniflo ▸ Anbaugruppen | `OMNI_KettenFoerderer` | `OmniModulInsert.lsp` | | Omniflo ▸ Verbinder | alle `OMNI_TV_*` (18) | `OmniModulInsert.lsp` | | Omniflo ▸ Boegen fuer Weichen | alle `OMNI_APBW_*` (14) | `OmniModulInsert.lsp` | +| ILS ▸ Zusatzmodule/Kurven | `ILS_ETF_Etagenfoerderer`, `ILS_K{90,60,30}{L,R}{A,I}` (12), `ILS_Gefaellestrecke` | `SSG_LIB_Commands.lsp` | +| Geruest | `GERUEST` (Gattertraeger-Platzhalter, derselbe Befehl wie Saeulen/Rohrabhaenger/Wandbefestigung) | `GeruestInsert.lsp` | -Aktiv (implementiert) sind u.a.: Kreisel, Eckrad, VarioFoerderer, EtageVarioFoerderer, -Gefaellestrecke, BTMT Be-/Entladung, Scanner/Separator, Omniflo Boegen (APB), -Aluprofil-Geraden (AP), alle Weichen (W90/W45/WP/WK/WKomb), Export (Sivas/CSV) -und die Tests. +`OMNI_TEF_*` (UmlenkR/L, AntriebL/R, TEF Gerade) sind entgegen frueherem Stand +**implementiert** (echtes `omni:insert-dxf`), nur `OMNI_KettenFoerderer` ist +weiterhin Dummy. + +Aktiv (implementiert) sind u.a.: Kreisel, Eckrad, VarioFoerderer (Standard/Etage/ +Linienzug), Gefaellestrecke, Geruest (Saeulen/Rohrabhaenger/Wandbefestigung/ +Rohr-Geruest-Traeger), TRO-Marker, Connections, BTMT Be-/Entladung, Scanner/ +Separator, Omniflo Boegen (APB)/TEF-Elemente/Aluprofil-Geraden (AP)/alle Weichen +(W90/W45/WP/WK/WKomb)/Ladeschleifen, Export (Sivas/CSV), Werkzeuge (Block-/ +Text-Tools, Planquadrate) und die Tests. --- @@ -181,7 +190,7 @@ Interne Parser-Funktionen (nicht direkt aufrufen): ### `ssg_lang.lsp` – Sprachumschaltung (Deutsch/Englisch) -Zentrale Textverwaltung fuer benutzersichtbare Meldungen. Kern-Modul, wird direkt nach `ssg_core` geladen. Wird schrittweise auf weitere Module ausgerollt (siehe `doc/translate.md`). +Zentrale Textverwaltung fuer benutzersichtbare Meldungen. Kern-Modul, wird direkt nach `ssg_core` geladen. Wird schrittweise auf weitere Module ausgerollt (siehe `doc/plan/translate.md`). | Funktion | Beschreibung | | --- | --- | @@ -323,50 +332,155 @@ Benutzerfreundliche BricsCAD-Befehle für Layer-Operationen. Alle Befehle sicher --- -### `ssg_load.lsp` – Laderoutine +### `ssg_input.lsp` – Generische Eingabe-Wrapper -Lädt alle Module in der richtigen Reihenfolge. Ermittelt den Pfad automatisch über `findfile`. Ruft direkt nach `ssg_core.lsp` die Funktion `ssg-load-config` auf, damit die JSON-Konfiguration für alle nachfolgenden Module verfügbar ist. - ---- - -### `VarioFoerderer.lsp` – Vario-Förderer - -Kompatibilitäts-Wrapper, der `vf_core.lsp` lädt (Plugin-Dispatcher-Architektur; lädt seinerseits `vf_standard.lsp`, `vf_etage.lsp`, `vf_linienzug.lsp`). Parametrischer Generator für ILS Vario-Förderanlagen. Liest Block-Geometrie aus einer DWG-Bibliothek (`DXFM_BLOCKS`). Alle Konstanten (Abstände, Winkel, Skalierung) werden via `ssg-cfg-or` aus `component_defaults.json` (Sektion `vario`) gelesen. - -**Befehl:** `c:FOERDERANLAGE` / `c:VarioFoerderer` – wählt zuerst den Anlagen-Typ (Standard/Etage/Linienzug): - -- **Typ „standard“ + Werteingabe:** läuft über den DCL-Dialog - [`dcl/variofoerderer.dcl`](../dcl/variofoerderer.dcl) (zwei Dialoge, `vfs-standard-dialog-ablauf` - in `vf_standard.lsp`): Dialog 1 (`vfs-dialog-eingabe-basis`) erfasst deltaL, deltaH, - Förderrichtung (Auf/Ab), Einfügehöhe, Fahrtrichtung und Seite; anschließend berechnet - `berechne-standard` die gültigen Winkel-Varianten, und Dialog 2 - (`vfs-dialog-winkel-verteilung`) lässt Winkel und L_GF-Verteilung (vorne/hinten) wählen. - Startpunkt (X/Y) wird wie bei der Gefällestrecke vorher in der Zeichnung gepickt. -- **Typ „standard“ + 3D-Linie**, sowie **Typ „etage“** und **„linienzug“** bleiben - vollständig interaktiv (Kommandozeile), unverändert gegenüber dem bisherigen Ablauf. - -**Bearbeiten (`c:VARIOFOERDERER_EDIT`):** Doppelklick auf einen `VF_n`-Block – bzw. -Rechtsklick-Kontextmenü/`SSG_BLOCKEDIT` – öffnet dieselben Dialoge, vorbelegt mit den -aktuellen Parametern, und baut die Strecke bei OK am selben Startpunkt neu auf (neue -`VF_n`-Nummer). Da `VF_n`-Blöcke auch von Etage- und Linienzug-Anlagen erzeugt werden -(deren komplexere Geometrie ein einfacher Neuaufbau zerstören würde), markiert -`vfs-xdata-schreiben` nur per Standard-Dialog erstellte Blöcke mit XDATA (App -`SSG_VF_EDIT`, Fahrtrichtung `hz`); Blöcke ohne diese Markierung weist -`c:VARIOFOERDERER_EDIT` mit einer Meldung ab, statt sie zu verändern. Winkel und L_GF1 -werden aus den Sivas-Attributen (`VF_WINKEL`, `L_GF_m`) vorbelegt (Verteilung stets als -„Eigene Werte“ mit dem exakten aktuellen L_GF1). - -**Wichtige interne Funktionen** (werden auch von `Gefaellestrecke.lsp` genutzt): +Abfragen mit Vorgabewert (`<..>` im Prompt, Enter = Vorgabe). Steht neben den VF-spezifischen `vfl-in-*` (`vf_linienzug.lsp`); diese bleiben unveraendert. Kein Journal, aber ein optionaler Hook. ESC bricht wie ueblich ueber `*error*` ab. | Funktion | Beschreibung | | --- | --- | -| `init-bibliothek` | Block-Bibliothek aus DWG laden und Geometriedaten extrahieren | -| `ensure-block-loaded name` | Block aus Bibliothek in aktives Dokument laden (einmalig) | -| `insert-block-by-ks name ks-nr pt` | Block anhand Koordinatensystem-Punkt einfügen | -| `insert-inclined-scaled-block name laenge winkel pt` | Geneigten, skalierten Block einfügen | -| `insert-rotated-block-with-ks name rot pt` | Rotierten Block mit KS-Offset einfügen | -| `get-line-start-end-points ename` | Start- und Endpunkt einer LINE-Entity ermitteln | -| `punkt-differenz p1 p2` | Differenzvektor zweier Punkte | +| `ssg-in-real text default` | Reelle Zahl (`getreal`), Vorgabe ohne ueberfluessige Nullen angezeigt | +| `ssg-in-int text default` | Ganzzahl (`getint`) | +| `ssg-in-string text default` | String mit Leerzeichen; Enter ohne Eingabe liefert die Vorgabe (ohne Vorgabe `nil`) | +| `ssg-in-point text default base` | Punkt, `base` = Gummiband-Basispunkt oder `nil` | +| `ssg-in-dist text default base` | Abstand (`getdist`) | +| `ssg-in-keyword text schluessel default` | Schluesselwort im `initget`-Format, z.B. `"Alle Auswahl"` | +| `ssg-in-yesno text default` | Ja/Nein, **T = Ja**; `default` T = Enter bedeutet Ja. Woerter aus `ssg-text "in-yesno-keys"` | +| `ssg-in-default wert default`, `ssg-in-fmt-real`, `ssg-in-fmt-pt`, `ssg-in-prompt`, `ssg-in-first-word`, `ssg-in-second-word` | Reine Hilfsfunktionen (in `tests/test_unit.lsp` getestet) | + +Hook (z.B. fuer ein Eingabe-Journal): `(setq *ssg-in-hook* 'meine-funktion)` mit `(defun meine-funktion (art prompt wert) ...)`; `art` ist `"REAL"`, `"INT"`, `"STRING"`, `"POINT"`, `"DIST"`, `"KEYWORD"` oder `"YESNO"`. Ein Hook, der einen Fehler wirft, wird abgeschaltet. + +--- + +### `ssg_id.lsp` – Eindeutige Block-IDs + +Jedes exportierbare Element bekommt ein Attribut `ID` mit einer eindeutigen, +vierstelligen Nummer. Kern-Modul (nach `ssg_layer`, vor `ssg_ks_insert`). + +| Befehl / Funktion | Beschreibung | +| --- | --- | +| `c:IDGENERATE` | Weist dem zuletzt eingefuegten Block eine neue ID zu | +| `c:IDSCHECK` | Prueft alle Bloecke auf doppelte IDs und korrigiert sie | +| `ssg-id-format n` | Zahl als 4-stelligen String formatieren (`1` → `"0001"`) | +| `ssg-id-max` | Hoechste bereits vergebene ID in der Zeichnung | +| `ssg-id-generate ent` | Neue ID erzeugen und auf den Block setzen | +| `ssg-id-check-all` | Zeichnungsweit auf Doubletten pruefen und korrigieren | +| `ssg-id-collect-blocks` | Alle ID-faehigen INSERT-Entities sammeln (gleiche Muster wie `csv:collect-export-blocks`, inkl. Separator/Scanner/BTMT) | + +--- + +### `ssg_ks_insert.lsp` – KS-Extraktion und Block-Einfuegeprimitiven + +Gemeinsame Basis fuer VarioFoerderer (`vf_core.lsp`) UND Gefaellestrecke – +frueher in beiden Modulen dupliziert, jetzt einzige Quelle. Muss laut MNL **vor** +Gefaellestrecke/`vf_core` geladen sein; Kern-Modul. + +| Funktion | Beschreibung | +| --- | --- | +| `vec-length v` | Laenge eines 3er-Vektors | +| `ks-line-axis laenge` | Achsenkennung (X/Y/Z) aus Linienlaenge der KS-Hilfslinie | +| `ks-normalize-name nm` | Historische KS-Blocknamen (`KSYS_EIN`/`-AUS`) auf `KS_EIN`/`KS_AUS` normalisieren | +| `ks-relativize` / `ks-absolutize` | KS-Punkte zwischen relativem und Welt-Koordinatensystem umrechnen | +| `ensure-block-loaded name` | Block aus der Bibliothek einmalig ins aktive Dokument laden | +| `extract-ks-from-block[-raw] name` | KS_EIN/KS_AUS-Punkte eines Blocks ermitteln (Cache `*ks-cache*`) | +| `insert-block-by-ks name ks-nr pt` | Block anhand KS-Punkt einfuegen (nur Rz-Rotation) | +| `insert-inclined-scaled-block` / `insert-rotated-block-with-ks` | Geneigten/rotierten Block mit KS-Offset einfuegen (Rz*Ry) | + +--- + +### `ssg_blocktools.lsp` – Block-Werkzeuge + +Ursprung: ACADSST `TOOLS.LSP` (`BLKANZAHL`, `BLKENTF`), `DINGEN2` (`g-bli`), `ssg.lsp` (`suchen-aendern`). Arbeitet im **aktuellen Layout-Reiter**. Blocknamen werden ueber den wirksamen Namen verglichen (dynamische Bloecke); Muster mit `wcmatch` (`*`, `?`, `#`, ohne Gross-/Kleinschreibung). + +| Befehl | Beschreibung | +| --- | --- | +| `SSG_BLOCK_COUNT` | Block anklicken, `Name` fuer ein Muster, oder Enter fuer eine Statistik aller Bloecke | +| `SSG_BLOCK_DELETE` | Alle Einfuegungen eines Blocks/Musters loeschen; Rueckfrage (Vorgabe Nein), Einfuegungen auf gesperrten Layern bleiben stehen; eine Undo-Gruppe | +| `SSG_ATTR_ERSETZEN` | Attributwerte suchen/ersetzen: Bereich (Alle mit Blockname-Muster / Auswahl), Tag-Muster, Suchtext, Ersatz, Modus Teil (Teilstring) oder Gesamt (ganzer Wert). Zeigt vorab die Anzahl und fragt nach | + +| Funktion | Beschreibung | +| --- | --- | +| `ssg-bt-inserts muster` | Entity-Liste aller Einfuegungen im Layout (optional nach Muster) | +| `ssg-bt-statistik muster` | `((NAME . ANZAHL) ...)` alphabetisch | +| `ssg-bt-attr-ersetzen-ent ent tag suche ersatz teil-p probe-p` | Attribute EINER Einfuegung ersetzen bzw. nur zaehlen (`probe-p`); Rueckgabe Anzahl | +| `ssg-bt-attr-ersetzen-liste ents tag suche ersatz teil-p probe-p` | Dasselbe fuer eine Entity-Liste | +| `ssg-bt-wert-neu wert suche ersatz teil-p` | Reiner Kern: neuer Wert oder `nil` (unveraendert); beachtet Gross-/Kleinschreibung | +| `ssg-bt-name-passt-p`, `ssg-bt-zaehle-namen`, `ssg-bt-muster-escape` | Reine Hilfsfunktionen (getestet) | + +--- + +### `ssg_texttools.lsp` – Text-Werkzeuge + +Ursprung: ACADSST `CHGTEXT.LSP`, `PARTEXT.LSP`, `ALTHOEHE.LSP`, `ALTSTIL.LSP`. Laden **nach** `ssg_blocktools` (nutzt `ssg-bt-wert-neu` und `ssg-bt-attr-ersetzen-liste`). Arbeitet in der XY-Ebene des Welt-KS. + +| Befehl | Beschreibung | +| --- | --- | +| `SSG_TEXT_ERSETZEN` | Suchen/Ersetzen in TEXT, MTEXT **und** Block-Attributen; Bereich Alle (Layout) oder Auswahl; Vorschau mit Anzahl, Rueckfrage | +| `SSG_TEXT_PARALLEL` | Linie/Polylinie/Bogen anklicken, Text wird parallel (lesbar, nie auf dem Kopf) mit Abstand gesetzt; Hoehe, Abstand und letzter Text werden fuer die Sitzung gemerkt; Enter beendet | +| `SSG_TEXT_HOEHE` | Texthoehe gewaehlter TEXT/MTEXT aendern | +| `SSG_TEXT_STIL` | Textstil gewaehlter TEXT/MTEXT aendern (Stil muss existieren) | + +Reine Kerne (getestet): `ssg-tt-lesbarer-winkel` (Winkel 90 Grad bis 270 Grad um 180 Grad drehen, Ergebnis in [0, 2 pi)), `ssg-tt-versetzt`. + +Nicht uebernommen aus Walz: `Export`/`Import` von Texten (besser per Python/ezdxf), `KREISTXT`, `TXTBOXED`, `CHTEXT`/`ASCTEXT`/`PTEXT` (Autodesk 1990, durch BricsCAD-Standard ersetzt). + +--- + +### `ssg_load.lsp` – Laderoutine + +Headless-Loader fuer .scr-Testskripte (z.B. `tests/test_unit.scr`). Laedt alle +Kern- und Feature-Module in derselben Reihenfolge wie `SSG_LIB.mnl`, ohne +Menueabhaengigkeit. Ermittelt den Pfad automatisch über `findfile`. Ruft direkt +nach `ssg_core.lsp` die Funktion `ssg-load-config` auf, damit die JSON-Konfiguration +für alle nachfolgenden Module verfügbar ist. + +--- + +### `VarioFoerderer.lsp` – Vario-Förderer (Wrapper) + +Kompatibilitäts-Wrapper, der `vf_core.lsp` lädt (Plugin-Dispatcher-Architektur +über `*vf-typ-registry*`; lädt seinerseits `vf_konstanten.lsp`, `vf_standard.lsp`, +`vf_etage.lsp`, `vf_linienzug.lsp`, danach `vf_spec.lsp`). Parametrischer Generator +für ILS Vario-Förderanlagen (Typen Standard/Etage/Linienzug). Liest Block-Geometrie +aus einer DWG-Bibliothek (`DXFM_BLOCKS`) über die Primitiven aus `ssg_ks_insert.lsp`. +Alle Konstanten (Abstände, Winkel, Skalierung) werden über `ssg-cfg-or` +(`component_defaults.json`, Sektion `vario`) bzw. die zentralen `*vfk-*`-Konstanten +aus `vf_konstanten.lsp` gelesen. + +**Befehl:** `c:FOERDERANLAGE` / `c:VarioFoerderer` – wählt zuerst den Anlagen-Typ (Standard/Etage/Linienzug): + +- **Typ „standard“ und „etage“ + Werteingabe:** laufen über denselben, + typ-parametrisierten Dialog-Ablauf (`vf-dialog-ablauf` in `vf_core.lsp`; + `vfs-standard-dialog-ablauf`/`vfe-etage-dialog-ablauf` sind nur noch duenne + Wrapper darauf) mit den Dialogen `vfs-dialog-eingabe-basis`/ + `vfs-dialog-winkel-verteilung` ([`dcl/variofoerderer.dcl`](../dcl/variofoerderer.dcl)): + Dialog 1 erfasst deltaL, Förderrichtung, Einfügehöhe/deltaH, Fahrtrichtung und + Seite/Motorseite; Dialog 2 lässt Winkel und L_GF-Verteilung (vorne/hinten) wählen. + Startpunkt (X/Y) wird vorher in der Zeichnung gepickt. +- **Typ „standard“/„etage“ + 3D-Linie** laufen ueber denselben Basis-Dialog statt + rein interaktiv auf der Konsole. +- **Typ „linienzug“** (Streckengruppe, `vf-linienzug-modus` in `vf_linienzug.lsp`) + hat drei Modi (manuell/Wizard, 3D-Objekte+Zielhoehe, Vorwaerts-Nachbau) und + zeichnet jede Eingabe in einem Journal auf (XDATA `SSG_VF_EDIT` am `VF_n`-Block); + Standard laeuft per Default ueber DCL-Dialoge (`VF_WIZARD_AN`/`VF_WIZARD_AUS` + schalten um). Details, Journal-Format, Headless-Modus (`*vfl-headless*`) und + Spec-basierter Bau ohne Dialog (`vf_spec.lsp`, `VF_SPEC_BAU`): siehe + [`../doc/variofoerderer.md`](../doc/variofoerderer.md) und `../CLAUDE.md`. + +**Bearbeiten (`c:VARIOFOERDERER_EDIT`):** Doppelklick auf einen `VF_n`-Block – bzw. +Rechtsklick-Kontextmenü/`SSG_BLOCKEDIT` – dispatcht per XDATA-Marker +(`"standard"`/`"etage"`/`"linienzug"`) in den passenden Neuaufbau-Zweig +(`vfe-edit-ent` fuer Etage, `vfl-edit-ent` fuer Linienzug) und öffnet dieselben +Dialoge, vorbelegt mit den aktuellen Parametern; der Block wird am selben +Startpunkt neu aufgebaut (neue `VF_n`-Nummer). Altbestand-Blöcke ohne +Marker werden mit einer Meldung abgewiesen, statt sie zu verändern. Winkel und +L_GF1 werden aus den Sivas-Attributen (`VF_WINKEL`, `L_GF_m`) vorbelegt. + +Die Block-Einfuege-Primitiven (`ensure-block-loaded`, `insert-block-by-ks`, +`insert-inclined-scaled-block`, `insert-rotated-block-with-ks` u.a.) sind seit +der Konsolidierung zentral in [`ssg_ks_insert.lsp`](#ssg_ks_insertlsp--ks-extraktion-und-block-einfuegeprimitiven) +definiert (von `vf_core.lsp`, `Gefaellestrecke.lsp` und `TEFInsert.lsp` genutzt). +Weitere interne Helfer: `init-bibliothek` (Block-Bibliothek aus DWG laden), +`get-line-start-end-points ename`, `punkt-differenz p1 p2`. --- @@ -414,6 +528,19 @@ Der Neuaufbau läuft über `gf-rebuild` (nicht-interaktiv, ohne Konsolen-Rückfr --- +### `TEFInsert.lsp` – TEF-Geradenstuecke entlang einer Linie + +**Befehl:** `c:TEF_FOERDERER_LINIE`. Zeichnet eine Linie zwischen zwei gewaehlten +Punkten und reiht darauf 1000-mm-TEF-Geradenelemente (`0_B10030` aus +`DXFM_OMNIFLO`) aneinander; ist die Linienlaenge kein exaktes Vielfaches, +wird ein zusaetzliches, zurueckverschobenes Element eingefuegt, sodass der +Foerderer exakt am Linienende endet (keine Luecke, kein abgeschnittenes +Element). Die Linie darf geneigt sein (3D) – Elemente werden dann analog zu +`vf_core.lsp`/`ssg_ks_insert.lsp` (Rz*Ry-Rotation) gekippt eingefuegt. Nicht +zu verwechseln mit den einzelnen `OMNI_TEF_*`-Befehlen in `OmniModulInsert.lsp`. + +--- + ### `export.lsp` – Export-Funktionen Sammelt INSERT-Blöcke aus der Zeichnung und exportiert sie als JSON oder ruft Python-Skripte für den Sivas-Export auf. @@ -572,11 +699,16 @@ AutoLISP-Implementierung fuer alle Omniflo-Komponenten: Boegen, Weichen, Verbind | Weichen | `OMNI_W90_*`, `OMNI_W45_*`, `OMNI_WP_*`, `OMNI_WK_*`, `OMNI_WKomb_*` | Omniflo-Weichen (Einfach/Doppel/Dreiwege, Delta, Stern) | | Geraden | `OMNI_AP60`, `OMNI_AP110`, `OMNI_APG110` | Omniflo-Geradenstuecke | | Ladeschleifen | `OMNI_LADESCHLEIFE_AP110` | Ladeschleife aus `omniflo_ladeschleifen.json` ueber DCL-Dialog (`dcl/omniflo_ladeschleifen.dcl`) einfuegen; Daten per `ssg-json-laden` (Beschreibungen enthalten Kommas). Blockdatei `.dwg` unter `DXFM_OMNIFLO` (`omni:insert-dxf` faellt auf `.dwg` zurueck, wenn keine `.dxf` existiert). Per `OMNI_EDIT` editierbar | -| TEF ⚠️ | `OMNI_TEF_UmlenkR/L`, `OMNI_TEF_AntriebL/R`, `OMNI_TEF_Gerade`, `OMNI_KettenFoerderer` | **Dummy** (noch nicht implementiert, im Menue ausgegraut) | +| TEF Elemente | `OMNI_TEF_UmlenkR/L`, `OMNI_TEF_AntriebL/R`, `OMNI_TEF_Gerade` | Feste TEF-Bauteile ohne Sivas-Auswahl, direkt per `omni:insert-dxf` an gewaehltem Punkt eingefuegt (Dateien unter `DXFM_OMNIFLO`) | +| Anbaugruppen ⚠️ | `OMNI_KettenFoerderer` | **Dummy** (noch nicht implementiert, im Menue ausgegraut); `OMNI_STOPPER`/`OMNI_SCANNER`/`OMNI_BUERSTENBREMSE` sind implementiert | | Transferwagen ⚠️ | `OMNI_TV_*` | **Dummy** (noch nicht implementiert, im Menue ausgegraut) | | Bogenweichen ⚠️ | `OMNI_APBW_*` | **Dummy** (noch nicht implementiert, im Menue ausgegraut) | | Bearbeiten | `OMNI_EDIT` | Omniflo-Block selektieren und Attribute bearbeiten | +Daneben zeichnet [`TEFInsert.lsp`](#tefinsertlsp--tef-geradenstuecke-entlang-einer-linie) (`TEF_FOERDERER_LINIE`) eine +Kette von TEF-Geradenelementen (1000 mm) entlang einer frei gewaehlten Linie – +nicht zu verwechseln mit den einzelnen `OMNI_TEF_*`-Befehlen oben. + --- ### `SSG_LIB_Commands.lsp` – BTMT, Sensoren, Dummy-Befehle, Konfiguration und SSG_BLOCKEDIT @@ -623,6 +755,10 @@ Entladung" bzw. "BT - Beladung ..."/"Abwurf fuer Klammerbuegel ..."); im Sivas-Export zusaetzlich in den Summenzaehlern "Anzahl aller BTBeladung"/ "Anzahl aller Abwurfstationen" der ILS-Automation-Zeile. +**Eingang-/Ausgang-Symbol:** `ILS_EINGANG_INSERT`/`ILS_AUSGANG_INSERT` nutzen +dieselbe `ils-insert-station`-Routine wie BTMT Be-/Entladung (frei platzierbar, +Blöcke `Eingang_.dwg`/`Ausgang_.dwg` in `data/ils`). + Registrierte Dummy-Befehle: | Gruppe | Befehle | @@ -643,11 +779,86 @@ Registrierte Dummy-Befehle: **SSG_BLOCKEDIT** – Doppelklick/Kontextmenue-Dispatcher: -Erkennt den Blocktyp des selektierten INSERT-Blocks und ruft den passenden Bearbeitungsbefehl auf: +Erkennt den Blocktyp des selektierten INSERT-Blocks und ruft den passenden Bearbeitungsbefehl auf (Reihenfolge wichtig: `GR_*` **vor** dem Omniflo-Zweig, da Geruest-Bloecke ebenfalls ein TEILEART-Attribut tragen): | Blockmuster | Aktion | | --- | --- | | `KREISEL_*` | `KreiselEdit` | | `ECKRAD_*` | `BEDIT` (Block-Editor) | +| `GF_*` | `GEFAELLESTRECKE_EDIT` | +| `VF_*` | `VARIOFOERDERER_EDIT` | +| `GR_*` | Geruest – `BEDIT` (kein eigener Edit-Pfad; siehe `GeruestInsert.lsp`) | +| `TRO_*` | `TRO_EDIT` | | Omniflo (TEILEART-Attribut, AP110*, numerisch) | `OMNI_EDIT` | | Sonstige | `BEDIT` (Block-Editor) | + +--- + +### `GeruestInsert.lsp` – Geruest-Baugruppen + +Rohr-Geruest-Baugruppen (Saeulen, Rohrabhaenger, Wandbefestigung, Rohr-Geruest-Traeger) +aus [`data/json/geruest.json`](../data/json/geruest.json) bzw. +[`data/json/geruest_traeger.json`](../data/json/geruest_traeger.json) konfigurieren +und einfuegen. Die Dialogdefinition wird **zur Laufzeit erzeugt** +(`geruest-dcl-schreiben`, temporaere DCL-Datei) – es gibt keine feste +`dcl/geruest.dcl`, weil je Anbauteil ein eigenes Mengenfeld gebraucht wird. +Ausfuehrliche Beschreibung (Konfigurationen, Attribut-Schema, Querstreben/Muffe, +Traeger-Beschriftung): siehe `../CLAUDE.md` Abschnitt "AutoLISP-Module". + +| Befehl | Beschreibung | +| --- | --- | +| `c:GERUEST` | Dialog ohne Vorgabe-Bereich (Dropdown Rohrabhaenger/Saeulen/Wandbefestigung) | +| `c:GERUEST_SAEULEN` / `c:GERUEST_ROHRABHAENGER` / `c:GERUEST_WANDBEFESTIGUNG` | Dialog mit vorgewaehltem Bereich (derselbe Dialog wie `GERUEST`) | +| `c:GERUEST_TRAEGER` | Eigener fester Dialog (`dcl/geruest_traeger.dcl`): Rohr-Geruest-Traeger mit Linien-Logik (Start-/Endpunkt oder Laenge, Laengenabzuege, Querstreben/Muffe-Verteilung) | +| `c:GERUEST_TRAEGER_BESCHRIFTEN` | Alle Traeger der Zeichnung neu beschriften (eigenes TEXT-Objekt, verknuepft per XDATA `SSG_GR_BESCHR`) | + +Block-Praefix `GR__` – **nicht kosmetisch**: `SSG_BLOCKEDIT` muss +`GR_*` vor dem Omniflo-Zweig abfangen, da Geruest-Bloecke ebenfalls ein +TEILEART-Attribut tragen. Export-Pattern `pattern_geruest = GR_*` (`cfg/export.cfg`). + +--- + +### `Tro_Edit.lsp` – TRO-Marker + +TRO-Marker (Block `TRO_SYM_`) fuer `sps_skel`/`lib/tro_annotate.py`. + +| Befehl | Beschreibung | +| --- | --- | +| `c:TRO_INSERT` | Bestehende Blockdefinition an gewaehltem Punkt einfuegen, setzt ID/TYPE; bricht ab, wenn der Typ noch keine Blockdefinition in der Zeichnung hat (entsteht nur ueber `tro_annotate.py`) | +| `c:TRO_EDIT` | ID/TYPE eines bestehenden Markers per Dialog aendern | + +Typliste kommt aus [`tro_types.lsp`](../Lisp/tro_types.lsp) (von +`tro_annotate.py --emit-lisp` nach `DXFM_LISP` geschrieben). `SSG_BLOCKEDIT` +leitet Blocknamen `TRO_*` zu `TRO_EDIT`. + +--- + +### `Connection_Edit.lsp` – Verbindungen (SPS) + +Verbindungslinien zwischen zwei Punkten/Bausteinen fuer SPS-Dokumentation. + +| Befehl | Beschreibung | +| --- | --- | +| `c:CONNECTION_INSERT` | Verbindung zwischen zwei Punkten einfuegen (Laenge/Winkel/Mitte werden berechnet) | +| `c:CONNECTION_EDIT` | Bestehende Verbindung bearbeiten | + +--- + +### `DrawPlanquadrate.lsp` – Planquadrat-Raster + +Zeichnet auf Z=0 ein Planquadrat-Linienraster (senkrecht/waagerecht) im +Abstand/Zaehlschema der aktiven `[Planquadrate]`-Konfiguration aus +`cfg/export.cfg` – dieselbe Quelle wie `lib/export_planquadrat.py` fuer den +CSV-Export. Bereich und Ursprung kommen aus der **Bounding-Box** derselben +Blockmenge wie `EXPORTCSV` (`csv:collect-export-blocks`), nicht aus dem reinen +Einfuegepunkt oder den Zeichnungs-Extents. Lazy geladen ueber +`(ssg-ensure "DrawPlanquadrate")`, nicht Teil der Core-Ladereihenfolge. + +| Befehl | Beschreibung | +| --- | --- | +| `c:DRAW_PLANQUADRATE` | Raster neu aufbauen (entfernt zuerst einen evtl. vorhandenen Block) | +| `c:DELETE_PLANQUADRATE` | Raster-Block entfernen | +| `c:PLANQUADRATE_TOGGLE` | Dispatcht auf Zeichnen bzw. Loeschen, je nachdem ob der Block existiert | + +Das fertige Raster (Linien + Zaehl-Texte) wird zu einem einzigen Block +`ZZ_PLANQUADRATE` bei (0,0,0) zusammengefasst; Layer aus `cfg/layer.cfg`. diff --git a/Lisp/ssg_blocktools.lsp b/Lisp/ssg_blocktools.lsp new file mode 100644 index 0000000..7b5baa7 --- /dev/null +++ b/Lisp/ssg_blocktools.lsp @@ -0,0 +1,311 @@ +;; ============================================================ +;; SSG_BLOCKTOOLS.LSP - Block-Werkzeuge fuer die aktuelle Zeichnung +;; +;; Ursprung: ACADSST/MENU/TOOLS.LSP (BLKANZAHL, BLKENTF), DINGEN2 +;; (g-bli) und ssg.lsp (suchen-aendern) - neu geschrieben im ssg-Stil +;; (Undo-Gruppe, i18n, Ja/Nein-Rueckfrage, keine Globals). +;; +;; Befehle: +;; SSG_BLOCK_COUNT Einfuegungen zaehlen (ein Block, Namensmuster +;; oder Statistik aller Bloecke) +;; SSG_BLOCK_DELETE Alle Einfuegungen eines Blocks/Namensmusters +;; loeschen (mit Rueckfrage) +;; SSG_ATTR_ERSETZEN Attributwerte zeichnungsweit oder in einer +;; Auswahl suchen und ersetzen (mit Vorschau) +;; +;; Blocknamen werden ueber den WIRKSAMEN Namen verglichen (dynamische +;; Bloecke: EffectiveName statt "*U12"). Muster arbeiten mit wcmatch +;; (Platzhalter * ? #, ohne Beachtung der Gross-/Kleinschreibung). +;; Es wird nur der aktuelle Layout-Reiter (Modell ODER Papierbereich) +;; durchsucht. +;; +;; Setzt ssg_core.lsp, ssg_lang.lsp und ssg_input.lsp voraus. +;; ============================================================ + +(vl-load-com) + +;; ------------------------------------------------------------ +;; REINE HILFSFUNKTIONEN (in test_unit getestet) +;; ------------------------------------------------------------ + +;; T, wenn name auf das wcmatch-Muster passt (ohne Gross-/Kleinschreibung). +;; muster nil oder "" -> alle Namen passen. +(defun ssg-bt-name-passt-p (name muster) + (if (or (null muster) (= muster "")) + T + (if (wcmatch (strcase name) (strcase muster)) T nil) + ) +) + +;; Liste von Namen -> Alist ((NAME . ANZAHL) ...), alphabetisch sortiert +;; (ohne Beachtung der Gross-/Kleinschreibung). +(defun ssg-bt-zaehle-namen (namen / alist eintrag) + (foreach name namen + (setq eintrag (assoc name alist)) + (if eintrag + (setq alist (subst (cons name (1+ (cdr eintrag))) eintrag alist)) + (setq alist (cons (cons name 1) alist)) + ) + ) + (vl-sort alist '(lambda (a b) (< (strcase (car a)) (strcase (car b))))) +) + +;; Sonderzeichen eines Blocknamens fuer wcmatch maskieren (Backquote), damit +;; ein per Pick gewaehlter Name nur sich selbst trifft. +(defun ssg-bt-muster-escape (name / res i c) + (setq res "" i 1) + (while (<= i (strlen name)) + (setq c (substr name i 1)) + (if (vl-string-search c "#@.*?~[],`") + (setq res (strcat res "`")) + ) + (setq res (strcat res c) + i (1+ i)) + ) + res +) + +;; Muster ohne Maskier-Backquotes (fuer Meldungen) +(defun ssg-bt-muster-anzeige (muster) + (ssg-str-replace-all "" "`" muster) +) + +;; Neuer Attributwert oder nil, wenn der Wert unveraendert bleibt. +;; teil-p = T : suche wird als Teilstring ueberall ersetzt +;; teil-p = nil: nur ersetzen, wenn der GESAMTE Wert gleich suche ist +;; Leere suche aendert nichts. Gross-/Kleinschreibung wird beachtet. +(defun ssg-bt-wert-neu (wert suche ersatz teil-p) + (cond + ((or (null suche) (= suche "") (null wert)) nil) + (teil-p + (if (vl-string-search suche wert) + (ssg-str-replace-all ersatz suche wert) + nil + ) + ) + ((= wert suche) ersatz) + (t nil) + ) +) + +;; ------------------------------------------------------------ +;; ZEICHNUNGSZUGRIFF +;; ------------------------------------------------------------ + +;; Wirksamer Blockname einer Einfuegung (dynamische Bloecke beachten) +(defun ssg-bt-effname (ent / res) + (setq res (vl-catch-all-apply 'vla-get-effectivename + (list (vlax-ename->vla-object ent)))) + (if (vl-catch-all-error-p res) + (cdr (assoc 2 (entget ent))) + res + ) +) + +;; T, wenn der Layer der Entity gesperrt ist +(defun ssg-bt-layer-gesperrt-p (ent / lay) + (setq lay (tblsearch "LAYER" (cdr (assoc 8 (entget ent))))) + (and lay (= 4 (logand 4 (cdr (assoc 70 lay))))) +) + +;; Alle Einfuegungen im aktuellen Layout, optional gefiltert nach Namensmuster. +;; Rueckgabe: Liste von Entity-Namen (kann leer sein). +(defun ssg-bt-inserts (muster / ss i ent res) + (setq ss (ssget "_X" (list '(0 . "INSERT") (cons 410 (getvar "CTAB"))))) + (if ss + (progn + (setq i 0) + (while (setq ent (ssname ss i)) + (if (ssg-bt-name-passt-p (ssg-bt-effname ent) muster) + (setq res (cons ent res)) + ) + (setq i (1+ i)) + ) + ) + ) + (reverse res) +) + +;; Statistik: ((NAME . ANZAHL) ...) fuer alle Einfuegungen passend zum Muster +(defun ssg-bt-statistik (muster) + (ssg-bt-zaehle-namen (mapcar 'ssg-bt-effname (ssg-bt-inserts muster))) +) + +;; Block per Pick oder Namensmuster waehlen. +;; Rueckgabe: Namensmuster (String) oder nil bei Enter ("alle"). +(defun ssg-bt-muster-waehlen (text / sel ed) + (initget "Name") + (setq sel (entsel text)) + (cond + ((null sel) nil) + ((= (type sel) 'STR) + (setq sel (getstring T (ssg-text "bt-prompt-muster"))) + (if (= sel "") nil sel) + ) + (t + (setq ed (entget (car sel))) + (if (= (cdr (assoc 0 ed)) "INSERT") + (ssg-bt-muster-escape (ssg-bt-effname (car sel))) + (progn (prompt (ssg-text "bt-kein-block")) nil) + ) + ) + ) +) + +;; Attribute EINER Einfuegung ersetzen (oder nur zaehlen, wenn probe-p). +;; tag = wcmatch-Muster fuer den Attribut-Tag ("*" = alle). +;; Rueckgabe: Anzahl betroffener Attribute. +(defun ssg-bt-attr-ersetzen-ent (ent tag suche ersatz teil-p probe-p + / e ed neu n) + (setq n 0 + e (entnext ent)) + (while (and e + (= "ATTRIB" (cdr (assoc 0 (setq ed (entget e)))))) + (if (and (ssg-bt-name-passt-p (cdr (assoc 2 ed)) tag) + (setq neu (ssg-bt-wert-neu (cdr (assoc 1 ed)) suche ersatz teil-p))) + (progn + (setq n (1+ n)) + (if (not probe-p) + (entmod (subst (cons 1 neu) (assoc 1 ed) ed)) + ) + ) + ) + (setq e (entnext e)) + ) + (if (and (> n 0) (not probe-p)) (entupd ent)) + n +) + +;; Attribute einer Liste von Einfuegungen ersetzen. Rueckgabe: Anzahl. +(defun ssg-bt-attr-ersetzen-liste (ents tag suche ersatz teil-p probe-p / n) + (setq n 0) + (foreach ent ents + (setq n (+ n (ssg-bt-attr-ersetzen-ent ent tag suche ersatz teil-p probe-p))) + ) + n +) + +;; Auswahlsatz -> Liste von Entity-Namen (nur INSERT) +(defun ssg-bt-ss-inserts (ss / i ent res) + (if ss + (progn + (setq i 0) + (while (setq ent (ssname ss i)) + (if (= (cdr (assoc 0 (entget ent))) "INSERT") + (setq res (cons ent res)) + ) + (setq i (1+ i)) + ) + ) + ) + (reverse res) +) + +;; ------------------------------------------------------------ +;; BEFEHLE +;; ------------------------------------------------------------ + +(defun c:SSG_BLOCK_COUNT ( / muster stat summe) + (setq muster (ssg-bt-muster-waehlen (ssg-text "bt-prompt-waehlen-count"))) + (setq stat (ssg-bt-statistik muster)) + (cond + ((null stat) + (prompt (if muster + (ssg-textf "bt-count-keine" (list (ssg-bt-muster-anzeige muster))) + (ssg-text "bt-count-keine-alle"))) + ) + ((and muster (null (cdr stat))) + (prompt (ssg-textf "bt-count-ergebnis" (list (cdar stat) (caar stat)))) + ) + (t + (setq summe 0) + (foreach z stat + (prompt (ssg-textf "bt-count-zeile" (list (car z) (cdr z)))) + (setq summe (+ summe (cdr z))) + ) + (prompt (ssg-textf "bt-count-summe" (list summe (length stat)))) + ) + ) + (princ) +) + +(defun c:SSG_BLOCK_DELETE ( / muster ents frei gesperrt n) + (setq muster (ssg-bt-muster-waehlen (ssg-text "bt-prompt-waehlen-delete"))) + (if (null muster) + (prompt (ssg-text "bt-delete-kein-muster")) + (progn + (setq ents (ssg-bt-inserts muster)) + (foreach ent ents + (if (ssg-bt-layer-gesperrt-p ent) + (setq gesperrt (cons ent gesperrt)) + (setq frei (cons ent frei)) + ) + ) + (cond + ((null ents) + (prompt (ssg-textf "bt-count-keine" (list (ssg-bt-muster-anzeige muster))))) + ((null frei) + (prompt (ssg-textf "bt-delete-alle-gesperrt" (list (length gesperrt))))) + ((ssg-in-yesno (ssg-textf "bt-delete-frage" (list (length frei) (ssg-bt-muster-anzeige muster))) nil) + (ssg-start (ssg-text "bt-delete-titel") nil) + (setq n 0) + (foreach ent frei + (if (entdel ent) (setq n (1+ n))) + ) + (ssg-end) + (prompt (ssg-textf "bt-delete-ergebnis" (list n))) + (if gesperrt + (prompt (ssg-textf "bt-delete-gesperrt" (list (length gesperrt))))) + ) + (t (prompt (ssg-text "bt-abgebrochen"))) + ) + ) + ) + (princ) +) + +(defun c:SSG_ATTR_ERSETZEN ( / k-bereich k-modus bereich ents muster tag suche ersatz modus teil-p n) + (setq k-bereich (ssg-text "in-keys-bereich") + k-modus (ssg-text "in-keys-modus") + bereich (ssg-in-keyword (ssg-text "bt-attr-bereich") k-bereich + (ssg-in-first-word k-bereich))) + (if (= bereich (ssg-in-first-word k-bereich)) + (progn + (setq muster (ssg-in-string (ssg-text "bt-attr-muster") "*")) + (setq ents (ssg-bt-inserts muster)) + ) + (progn + (prompt (ssg-text "bt-attr-auswahl")) + (setq ents (ssg-bt-ss-inserts (ssget '((0 . "INSERT"))))) + ) + ) + (cond + ((null ents) (prompt (ssg-text "bt-attr-keine-bloecke"))) + (t + (setq tag (ssg-in-string (ssg-text "bt-attr-tag") "*") + suche (ssg-in-string (ssg-text "bt-attr-suche") nil)) + (if (or (null suche) (= suche "")) + (prompt (ssg-text "bt-abgebrochen")) + (progn + (setq ersatz (ssg-in-string (ssg-text "bt-attr-ersatz") "") + modus (ssg-in-keyword (ssg-text "bt-attr-modus") k-modus + (ssg-in-first-word k-modus)) + teil-p (= modus (ssg-in-first-word k-modus))) + (setq n (ssg-bt-attr-ersetzen-liste ents tag suche ersatz teil-p T)) + (cond + ((= n 0) (prompt (ssg-text "bt-attr-nichts"))) + ((ssg-in-yesno (ssg-textf "bt-attr-frage" (list n (length ents))) T) + (ssg-start (ssg-text "bt-attr-titel") nil) + (setq n (ssg-bt-attr-ersetzen-liste ents tag suche ersatz teil-p nil)) + (ssg-end) + (prompt (ssg-textf "bt-attr-ergebnis" (list n)))) + (t (prompt (ssg-text "bt-abgebrochen"))) + ) + ) + ) + ) + ) + (princ) +) + +(princ) diff --git a/Lisp/ssg_core.lsp b/Lisp/ssg_core.lsp index 298e43c..cfe95c8 100644 --- a/Lisp/ssg_core.lsp +++ b/Lisp/ssg_core.lsp @@ -1622,6 +1622,44 @@ ) +;; ------------------------------------------------------------ +;; DCL ZUR LAUFZEIT GENERIEREN +;; ------------------------------------------------------------ +;; Escaped Anfuehrungszeichen in einem DCL-Label-String ("->''), damit ein +;; Label mit Anfuehrungszeichen (z.B. aus Nutzerdaten oder Zoll-Angaben) die +;; DCL-Zeile nicht vorzeitig beendet. Fachlich identisch zu +;; geruest-dcl-label (GeruestInsert.lsp), aber hier als generischer +;; Kernel-Helfer fuer jeden Aufrufer, der DCL-Text zusammenbaut. +(defun ssg-dcl-label-escape (text / i c out) + (setq i 0 out "") + (while (< i (strlen text)) + (setq c (substr text (1+ i) 1)) + (setq out (strcat out (if (= c "\"") "''" c))) + (setq i (1+ i)) + ) + out +) + +;; Schreibt eine Liste von Textzeilen als temporaere DCL-Datei und liefert +;; deren Pfad zurueck (oder nil bei Fehler, z.B. wenn open scheitert). Der +;; Aufrufer ist fuer load_dialog/unload_dialog UND das Loeschen der Datei +;; (vl-file-delete) danach selbst verantwortlich - analog zum bestehenden +;; Muster in GeruestInsert.lsp (geruest-dcl-schreiben), hier nur als +;; generischer Baustein fuer WEITERE Aufrufer (GeruestInsert.lsp selbst +;; bleibt unveraendert, um dessen Code nicht anzufassen). +(defun ssg-dcl-temp-schreiben (praefix zeilen / pfad f) + (setq pfad (vl-filename-mktemp praefix nil ".dcl")) + (if (setq f (open pfad "w")) + (progn + (foreach zeile zeilen (write-line zeile f)) + (close f) + pfad + ) + nil + ) +) + + ;; ------------------------------------------------------------ ;; REKURSIVER JSON-PARSER ;; ------------------------------------------------------------ diff --git a/Lisp/ssg_input.lsp b/Lisp/ssg_input.lsp new file mode 100644 index 0000000..93c59dc --- /dev/null +++ b/Lisp/ssg_input.lsp @@ -0,0 +1,162 @@ +;; ============================================================ +;; SSG_INPUT.LSP - Generische Eingabe-Wrapper (ssg-in-*) +;; +;; Allgemeingueltige Abfragen mit Vorgabewert, Anzeige "" im +;; Prompt und Enter = Vorgabe (Idee von g_in/g_ky aus den ACADSST- +;; Makros). Steht NEBEN den VF-spezifischen vfl-in-* aus +;; vf_linienzug.lsp; diese bleiben unveraendert. +;; +;; Alle Funktionen liefern den eingegebenen Wert oder die Vorgabe. +;; ESC bricht wie ueblich ueber *error* ab (z.B. ssg-errhan). +;; Ist kein Wert eingegeben und keine Vorgabe da, ist die Rueckgabe nil. +;; +;; Optionaler Hook (z.B. fuer ein Eingabe-Journal): +;; (setq *ssg-in-hook* 'meine-funktion) +;; (defun meine-funktion (art prompt wert) ...) ;; art = "REAL" "INT" +;; ;; "STRING" "POINT" +;; ;; "DIST" "KEYWORD" +;; ;; "YESNO" +;; Ein Hook, der einen Fehler wirft, wird abgeschaltet. +;; +;; Setzt ssg_core.lsp (und fuer ssg-in-yesno ssg_lang.lsp) voraus. +;; ============================================================ + +(vl-load-com) + +;; ------------------------------------------------------------ +;; REINE HILFSFUNKTIONEN (ohne Zeichnung, in test_unit getestet) +;; ------------------------------------------------------------ + +;; Vorgabe einsetzen, wenn kein Wert eingegeben wurde +(defun ssg-in-default (wert default) + (if wert wert default) +) + +;; Reelle Zahl ohne ueberfluessige Nullen: 5.0 -> "5", 2.50 -> "2.5" +(defun ssg-in-fmt-real (v / s) + (setq s (rtos v 2 6)) + (if (vl-string-position 46 s) + (progn + (while (= (substr s (strlen s)) "0") + (setq s (substr s 1 (1- (strlen s)))) + ) + (if (= (substr s (strlen s)) ".") + (setq s (substr s 1 (1- (strlen s)))) + ) + ) + ) + s +) + +;; Punkt als "x,y,z" (fehlende Z-Werte als 0) +(defun ssg-in-fmt-pt (p) + (strcat (ssg-in-fmt-real (car p)) "," + (ssg-in-fmt-real (cadr p)) "," + (ssg-in-fmt-real (if (caddr p) (caddr p) 0.0))) +) + +;; Prompt aufbauen: " : " bzw. ": " ohne Vorgabe +(defun ssg-in-prompt (text default-str) + (strcat text + (if default-str (strcat " <" default-str ">") "") + ": ") +) + +;; Erstes Wort eines Schluesselwort-Strings: "Ja Nein" -> "Ja" +(defun ssg-in-first-word (schluessel / pos) + (if (setq pos (vl-string-search " " schluessel)) + (substr schluessel 1 pos) + schluessel + ) +) + +;; Zweites Wort: "Ja Nein" -> "Nein" +(defun ssg-in-second-word (schluessel / pos) + (if (setq pos (vl-string-search " " schluessel)) + (substr schluessel (+ pos 2)) + "" + ) +) + +;; ------------------------------------------------------------ +;; HOOK +;; ------------------------------------------------------------ +(defun ssg-in-notify (art text wert / res) + (if *ssg-in-hook* + (progn + (setq res (vl-catch-all-apply *ssg-in-hook* (list art text wert))) + (if (vl-catch-all-error-p res) (setq *ssg-in-hook* nil)) + ) + ) + wert +) + +;; ------------------------------------------------------------ +;; ABFRAGEN +;; text = Prompt ohne Doppelpunkt, z.B. "\nHoehe" +;; ------------------------------------------------------------ + +(defun ssg-in-real (text default / w) + (setq w (getreal (ssg-in-prompt text (if default (ssg-in-fmt-real default))))) + (ssg-in-notify "REAL" text (ssg-in-default w default)) +) + +(defun ssg-in-int (text default / w) + (setq w (getint (ssg-in-prompt text (if default (itoa default))))) + (ssg-in-notify "INT" text (ssg-in-default w default)) +) + +;; String (mit Leerzeichen). Enter ohne Eingabe -> Vorgabe. +(defun ssg-in-string (text default / w) + (setq w (getstring T (ssg-in-prompt text default))) + (if (= w "") (setq w nil)) + (ssg-in-notify "STRING" text (ssg-in-default w default)) +) + +;; Punkt. base = Gummiband-Basispunkt oder nil, default = Punkt oder nil. +(defun ssg-in-point (text default base / w) + (setq w (if base + (getpoint base (ssg-in-prompt text (if default (ssg-in-fmt-pt default)))) + (getpoint (ssg-in-prompt text (if default (ssg-in-fmt-pt default)))) + )) + (ssg-in-notify "POINT" text (ssg-in-default w default)) +) + +;; Abstand. base = Basispunkt oder nil. +(defun ssg-in-dist (text default base / w) + (setq w (if base + (getdist base (ssg-in-prompt text (if default (ssg-in-fmt-real default)))) + (getdist (ssg-in-prompt text (if default (ssg-in-fmt-real default)))) + )) + (ssg-in-notify "DIST" text (ssg-in-default w default)) +) + +;; Schluesselwort ohne Hook (intern, auch von ssg-in-yesno genutzt). +(defun ssg-in-keyword-raw (text schluessel default / w) + (initget 0 schluessel) + (setq w (getkword + (ssg-in-prompt + (strcat text " [" (vl-string-translate " " "/" schluessel) "]") + default))) + (ssg-in-default w default) +) + +;; Schluesselwort. schluessel im initget-Format, z.B. "Alle Auswahl". +;; Rueckgabe: gewaehltes Schluesselwort (volle Schreibweise) oder default. +(defun ssg-in-keyword (text schluessel default) + (ssg-in-notify "KEYWORD" text (ssg-in-keyword-raw text schluessel default)) +) + +;; Ja/Nein-Abfrage, Rueckgabe T bei Ja, nil bei Nein (anders als ssg-ques, +;; das T fuer die NICHT-vorgegebene Antwort liefert). +;; default = T -> Enter bedeutet Ja, nil -> Enter bedeutet Nein. +;; Die Schluesselwoerter kommen aus ssg-text "in-yesno-keys" (z.B. "Ja Nein"). +(defun ssg-in-yesno (text default / schluessel ja nein w) + (setq schluessel (ssg-text "in-yesno-keys") + ja (ssg-in-first-word schluessel) + nein (ssg-in-second-word schluessel)) + (setq w (ssg-in-keyword-raw text schluessel (if default ja nein))) + (ssg-in-notify "YESNO" text (= w ja)) +) + +(princ) diff --git a/Lisp/ssg_load.lsp b/Lisp/ssg_load.lsp index 9228d76..c806db1 100644 --- a/Lisp/ssg_load.lsp +++ b/Lisp/ssg_load.lsp @@ -28,6 +28,7 @@ (load (strcat base-path "ssg_dbg.lsp") "ssg_dbg.lsp nicht gefunden") (load (strcat base-path "ssg_dialog.lsp") "ssg_dialog.lsp nicht gefunden") (load (strcat base-path "ssg_layer.lsp") "ssg_layer.lsp nicht gefunden") + (load (strcat base-path "ssg_input.lsp") "ssg_input.lsp nicht gefunden") ;; Gemeinsame KS-Extraktion + Einfuegeprimitiven - MUSS vor VarioFoerderer ;; und Gefaellestrecke geladen werden (beide nutzen sie). (load (strcat base-path "ssg_ks_insert.lsp") "ssg_ks_insert.lsp nicht gefunden") @@ -39,7 +40,10 @@ (load (strcat base-path "Tro_Edit.lsp") "Tro_Edit.lsp nicht gefunden") (load (strcat base-path "Connection_Edit.lsp") "Connection_Edit.lsp nicht gefunden") (load (strcat base-path "SSG_LIB_Commands.lsp") "SSG_LIB_Commands.lsp nicht gefunden") - (prompt "\nSSG-Bibliotheken geladen: ssg_core, ssg_lang, ssg_dbg, ssg_dialog, ssg_layer, KreiselInsert, VarioFoerderer, Gefaellestrecke, export, OmniModulInsert, SSG_LIB_Commands") + ;; Werkzeuge: ssg_texttools nutzt ssg_blocktools, beide nutzen ssg_input + (load (strcat base-path "ssg_blocktools.lsp") "ssg_blocktools.lsp nicht gefunden") + (load (strcat base-path "ssg_texttools.lsp") "ssg_texttools.lsp nicht gefunden") + (prompt "\nSSG-Bibliotheken geladen: ssg_core, ssg_lang, ssg_dbg, ssg_dialog, ssg_layer, ssg_input, KreiselInsert, VarioFoerderer, Gefaellestrecke, export, OmniModulInsert, SSG_LIB_Commands, ssg_blocktools, ssg_texttools") (princ) ) diff --git a/Lisp/ssg_texttools.lsp b/Lisp/ssg_texttools.lsp new file mode 100644 index 0000000..7b8866b --- /dev/null +++ b/Lisp/ssg_texttools.lsp @@ -0,0 +1,285 @@ +;; ============================================================ +;; SSG_TEXTTOOLS.LSP - Text-Werkzeuge +;; +;; Ursprung: ACADSST/MENU/CHGTEXT.LSP (Suchen/Ersetzen), PARTEXT.LSP +;; (Tbpl: parallel beschriften), ALTHOEHE.LSP (Tsz), ALTSTIL.LSP (Ts). +;; Neu geschrieben im ssg-Stil (Undo-Gruppe, i18n, ssg-in-*). +;; +;; Befehle: +;; SSG_TEXT_ERSETZEN Zeichenketten in TEXT, MTEXT und Block- +;; Attributen suchen/ersetzen (mit Vorschau) +;; SSG_TEXT_PARALLEL Text parallel zu Linie/Polylinie/Bogen setzen +;; (lesbar ausgerichtet, mit Abstand zur Linie) +;; SSG_TEXT_HOEHE Texthoehe von TEXT/MTEXT aendern +;; SSG_TEXT_STIL Textstil von TEXT/MTEXT aendern +;; +;; Arbeitet in der XY-Ebene des Welt-KS (Textrotation = WKS-Winkel). +;; Setzt ssg_core.lsp, ssg_lang.lsp, ssg_input.lsp und ssg_blocktools.lsp +;; (ssg-bt-wert-neu, ssg-bt-attr-ersetzen-ent) voraus. +;; ============================================================ + +(vl-load-com) + +;; ------------------------------------------------------------ +;; REINE HILFSFUNKTIONEN (in test_unit getestet) +;; ------------------------------------------------------------ + +;; Winkel (Bogenmass) so drehen, dass ein Text lesbar bleibt: Winkel im +;; Bereich (90 Grad, 270 Grad] werden um 180 Grad gedreht. Ergebnis in +;; [0, 2*pi). +(defun ssg-tt-lesbarer-winkel (a) + (setq a (rem a (* 2.0 pi))) + (if (< a 0.0) (setq a (+ a (* 2.0 pi)))) + (if (and (> a (+ (/ pi 2.0) 1e-9)) + (<= a (+ (* 1.5 pi) 1e-9))) + (setq a (- a pi)) + ) + (if (< a 0.0) (setq a (+ a (* 2.0 pi)))) + a +) + +;; Punkt um abstand in Richtung winkel verschieben (2D, Z bleibt erhalten) +(defun ssg-tt-versetzt (p winkel abstand) + (list (+ (car p) (* abstand (cos winkel))) + (+ (cadr p) (* abstand (sin winkel))) + (if (caddr p) (caddr p) 0.0)) +) + +;; ------------------------------------------------------------ +;; AUSWAHL +;; ------------------------------------------------------------ + +;; Auswahlsatz der angegebenen Typen holen (z.B. "TEXT,MTEXT,INSERT"). +;; alle-p = T -> alle im aktuellen Layout, nil -> Benutzerwahl +(defun ssg-tt-ss-holen (alle-p typen) + (if alle-p + (ssget "_X" (list (cons 0 typen) (cons 410 (getvar "CTAB")))) + (ssget (list (cons 0 typen))) + ) +) + +;; Auswahlsatz -> Liste von Entity-Namen mit Typ-Filter ("TEXT" "MTEXT" ...) +(defun ssg-tt-ss-liste (ss typen / i ent res) + (if ss + (progn + (setq i 0) + (while (setq ent (ssname ss i)) + (if (member (cdr (assoc 0 (entget ent))) typen) + (setq res (cons ent res)) + ) + (setq i (1+ i)) + ) + ) + ) + (reverse res) +) + +;; ------------------------------------------------------------ +;; SUCHEN / ERSETZEN +;; ------------------------------------------------------------ + +;; TEXT/MTEXT-Inhalte ersetzen (oder nur zaehlen). Rueckgabe: Anzahl Texte. +(defun ssg-tt-text-ersetzen-liste (ents suche ersatz teil-p probe-p + / n obj alt neu) + (setq n 0) + (foreach ent ents + (setq obj (vlax-ename->vla-object ent) + alt (vla-get-textstring obj) + neu (ssg-bt-wert-neu alt suche ersatz teil-p)) + (if neu + (if probe-p + (setq n (1+ n)) + (if (not (vl-catch-all-error-p + (vl-catch-all-apply 'vla-put-textstring (list obj neu)))) + (setq n (1+ n)) + ) + ) + ) + ) + n +) + +;; Texte + Attribute in einem Auswahlsatz ersetzen/zaehlen. +;; Rueckgabe: (anzahl-texte . anzahl-attribute) +(defun ssg-tt-ersetzen-ss (ss suche ersatz teil-p probe-p) + (cons + (ssg-tt-text-ersetzen-liste + (ssg-tt-ss-liste ss '("TEXT" "MTEXT")) suche ersatz teil-p probe-p) + (ssg-bt-attr-ersetzen-liste + (ssg-tt-ss-liste ss '("INSERT")) "*" suche ersatz teil-p probe-p) + ) +) + +(defun c:SSG_TEXT_ERSETZEN ( / k-bereich k-modus alle-p ss suche ersatz modus teil-p z) + (setq k-bereich (ssg-text "in-keys-bereich") + k-modus (ssg-text "in-keys-modus") + alle-p (= (ssg-in-keyword (ssg-text "tt-bereich") k-bereich + (ssg-in-first-word k-bereich)) + (ssg-in-first-word k-bereich))) + (if (not alle-p) (prompt (ssg-text "tt-auswahl"))) + (setq ss (ssg-tt-ss-holen alle-p "TEXT,MTEXT,INSERT")) + (if (null ss) + (prompt (ssg-text "tt-keine-objekte")) + (progn + (setq suche (ssg-in-string (ssg-text "tt-suche") nil)) + (if (or (null suche) (= suche "")) + (prompt (ssg-text "tt-abgebrochen")) + (progn + (setq ersatz (ssg-in-string (ssg-text "tt-ersatz") "") + modus (ssg-in-keyword (ssg-text "tt-modus") k-modus + (ssg-in-first-word k-modus)) + teil-p (= modus (ssg-in-first-word k-modus))) + (setq z (ssg-tt-ersetzen-ss ss suche ersatz teil-p T)) + (cond + ((= 0 (+ (car z) (cdr z))) (prompt (ssg-text "tt-nichts"))) + ((ssg-in-yesno (ssg-textf "tt-frage" (list (car z) (cdr z))) T) + (ssg-start (ssg-text "tt-ersetzen-titel") nil) + (setq z (ssg-tt-ersetzen-ss ss suche ersatz teil-p nil)) + (ssg-end) + (prompt (ssg-textf "tt-ergebnis" (list (car z) (cdr z))))) + (t (prompt (ssg-text "tt-abgebrochen"))) + ) + ) + ) + ) + ) + (princ) +) + +;; ------------------------------------------------------------ +;; PARALLEL BESCHRIFTEN +;; ------------------------------------------------------------ + +;; Winkel der Kurve (Linie, Polylinie, Bogen, ...) am Punkt pt (WKS). +;; Rueckgabe: Winkel in Bogenmass oder nil, wenn nicht ermittelbar. +(defun ssg-tt-kurven-winkel (ent pt / obj cp param deriv) + (setq obj (vlax-ename->vla-object ent)) + (setq cp (vl-catch-all-apply 'vlax-curve-getclosestpointto (list obj pt))) + (if (or (vl-catch-all-error-p cp) (null cp)) + nil + (progn + (setq param (vl-catch-all-apply 'vlax-curve-getparamatpoint (list obj cp))) + (if (or (vl-catch-all-error-p param) (null param)) + nil + (progn + (setq deriv (vl-catch-all-apply 'vlax-curve-getfirstderiv (list obj param))) + (if (or (vl-catch-all-error-p deriv) (null deriv)) + nil + (list (atan (cadr deriv) (car deriv)) cp) + ) + ) + ) + ) + ) +) + +;; TEXT erzeugen (unten mittig, Gruppe 73 = 1 damit Gruppe 11 gilt) +(defun ssg-tt-text-machen (p hoehe string winkel) + (entmake (list '(0 . "TEXT") + (cons 8 (getvar "CLAYER")) + (cons 7 (getvar "TEXTSTYLE")) + (cons 10 p) + (cons 11 p) + (cons 40 hoehe) + (cons 1 string) + (cons 50 winkel) + (cons 72 1) + (cons 73 1))) +) + +(defun c:SSG_TEXT_PARALLEL ( / sel info a ar p text) + (ssg-start (ssg-text "tt-parallel-titel") nil) + (if (or (null *ssg-tt-hoehe*) (<= *ssg-tt-hoehe* 0.0)) + (setq *ssg-tt-hoehe* (if (> (getvar "TEXTSIZE") 0.0) (getvar "TEXTSIZE") 2.5)) + ) + (setq *ssg-tt-hoehe* (ssg-in-real (ssg-text "tt-hoehe") *ssg-tt-hoehe*)) + (if (null *ssg-tt-abstand*) + (setq *ssg-tt-abstand* (* 0.5 *ssg-tt-hoehe*)) + ) + (setq *ssg-tt-abstand* (ssg-in-real (ssg-text "tt-abstand") *ssg-tt-abstand*)) + (while (setq sel (entsel (ssg-text "tt-parallel-waehlen"))) + (setq info (ssg-tt-kurven-winkel (car sel) (trans (cadr sel) 1 0))) + (if (null info) + (prompt (ssg-text "tt-parallel-keine-kurve")) + (progn + (setq a (car info) + ar (ssg-tt-lesbarer-winkel a) + p (ssg-tt-versetzt (cadr info) (+ ar (/ pi 2.0)) *ssg-tt-abstand*) + text (ssg-in-string (ssg-text "tt-text") *ssg-tt-text*)) + (if (and text (/= text "")) + (progn + (setq *ssg-tt-text* text) + (if (not (ssg-tt-text-machen p *ssg-tt-hoehe* text ar)) + (prompt (ssg-text "tt-parallel-fehler")) + ) + ) + ) + ) + ) + ) + (ssg-end) + (princ) +) + +;; ------------------------------------------------------------ +;; HOEHE / STIL AENDERN +;; ------------------------------------------------------------ + +(defun c:SSG_TEXT_HOEHE ( / ents hoehe n) + (prompt (ssg-text "tt-auswahl")) + (setq ents (ssg-tt-ss-liste (ssget '((0 . "TEXT,MTEXT"))) '("TEXT" "MTEXT"))) + (if (null ents) + (prompt (ssg-text "tt-keine-objekte")) + (progn + (setq hoehe (ssg-in-real (ssg-text "tt-hoehe") + (if (> (getvar "TEXTSIZE") 0.0) (getvar "TEXTSIZE") nil))) + (if (or (null hoehe) (<= hoehe 0.0)) + (prompt (ssg-text "tt-abgebrochen")) + (progn + (ssg-start (ssg-text "tt-hoehe-titel") nil) + (setq n 0) + (foreach ent ents + (if (not (vl-catch-all-error-p + (vl-catch-all-apply 'vla-put-height + (list (vlax-ename->vla-object ent) hoehe)))) + (setq n (1+ n)) + ) + ) + (ssg-end) + (prompt (ssg-textf "tt-geaendert" (list n))) + ) + ) + ) + ) + (princ) +) + +(defun c:SSG_TEXT_STIL ( / ents stil n) + (prompt (ssg-text "tt-auswahl")) + (setq ents (ssg-tt-ss-liste (ssget '((0 . "TEXT,MTEXT"))) '("TEXT" "MTEXT"))) + (if (null ents) + (prompt (ssg-text "tt-keine-objekte")) + (progn + (setq stil (ssg-in-string (ssg-text "tt-stil") (getvar "TEXTSTYLE"))) + (cond + ((or (null stil) (null (tblsearch "STYLE" stil))) + (prompt (ssg-textf "tt-stil-fehlt" (list (if stil stil ""))))) + (t + (ssg-start (ssg-text "tt-stil-titel") nil) + (setq n 0) + (foreach ent ents + (if (not (vl-catch-all-error-p + (vl-catch-all-apply 'vla-put-stylename + (list (vlax-ename->vla-object ent) stil)))) + (setq n (1+ n)) + ) + ) + (ssg-end) + (prompt (ssg-textf "tt-geaendert" (list n)))) + ) + ) + ) + (princ) +) + +(princ) diff --git a/Lisp/vf_core.lsp b/Lisp/vf_core.lsp index ec18f05..4b6420e 100644 --- a/Lisp/vf_core.lsp +++ b/Lisp/vf_core.lsp @@ -80,6 +80,11 @@ ;; Von den Menue-Wrappern gesetzt, damit die Konsolen-/Dialog-Frage ;; entfaellt. nil = interaktiv fragen (Direktaufruf VarioFoerderer). (if (null *vf-vorauswahl-eingabemodus*) (setq *vf-vorauswahl-eingabemodus* nil)) +;; Vorauswahl des Linienzug-Modus (1-5): von jedem der fuenf Linienzug- +;; Menue-Wrapper (c:LinienzugVarioFoerdererManuell/-Zielhoehe/-Stueckweise, +;; c:QcLinieMitGf/-UForm) gesetzt - der frueher hier noetige Modus-Dialog/ +;; Konsolen-Fallback ist dadurch komplett entfallen (siehe c:VarioFoerderer). +(if (null *vf-vorauswahl-linienzug-modus*) (setq *vf-vorauswahl-linienzug-modus* nil)) ;; Registriert einen Foerderanlagen-Typ. ;; berechne-fn: '(lambda (deltaL deltaH richtung seite) ...) @@ -703,36 +708,23 @@ (setq i (1+ i))) eingabe) -(defun vf-eingabe-abfragen ( / eingabe-modus line-points startpunkt endpunkt differenz - deltaL deltaH deltaX deltaY richtung antwort hz-winkel) - ;; Eingabemodus: von einem Menue-Wrapper vorbelegt (dann keine Frage) oder - ;; interaktiv. Die Vorauswahl gilt nur EINMAL und wird hier verbraucht, - ;; damit ein spaeterer Direktaufruf wieder fragt. - (if *vf-vorauswahl-eingabemodus* - (setq antwort *vf-vorauswahl-eingabemodus* - *vf-vorauswahl-eingabemodus* nil) +;; 3D-Linie picken und daraus deltaL/deltaH/richtung/hz/startpunkt (inkl. Z) +;; ableiten - fuer den GUI-Ablauf (vf-dialog-ablauf): ersetzt dort die +;; separate Startpunkt-Auswahl UND liefert die Geometrie-Felder als Prefill +;; fuer den Basis-Dialog (vfs-dialog-eingabe-basis). Rueckgabe: (deltaL +;; deltaH richtung startpunkt hz) oder nil, wenn keine gueltige Linie +;; gewaehlt wurde (Aufrufer bricht dann ab, statt wie frueher per (exit) +;; die ganze Befehlssitzung zu beenden). +(defun vfc-3dlinie-erfassen ( / line-points startpunkt endpunkt differenz + deltaL deltaH deltaX deltaY richtung hz-winkel) + (princ (ssg-text "vfc-modus-3dlinie-header")) + (command "BKS" "W") + (princ (ssg-text "vfc-bks-weltkoordinaten")) + (setq line-points + (get-line-start-end-points (ssg-text "vfc-bitte-3dlinie-foerderstrecke"))) + (if (null line-points) + (progn (alert (ssg-text "vfc-alert-keine-gueltige-linie")) nil) (progn - (princ (ssg-text "vfc-eingabemodus-header")) - (princ (ssg-text "vfc-eingabemodus-3dlinie")) - (princ (ssg-text "vfc-eingabemodus-werte")) - (setq antwort (getstring (ssg-text "vfc-prompt-wahl-1-2-ohne-default"))) - ) - ) - (cond - ((= antwort "1") (setq eingabe-modus "Linie")) - ((= antwort "2") (setq eingabe-modus "Wert")) - (t (setq eingabe-modus "Linie") (princ (ssg-text "vfc-modus-3dlinie-fallback"))) - ) - (if (= eingabe-modus "Linie") - (progn - (princ (ssg-text "vfc-modus-3dlinie-header")) - (command "BKS" "W") - (princ (ssg-text "vfc-bks-weltkoordinaten")) - (setq line-points - (get-line-start-end-points (ssg-text "vfc-bitte-3dlinie-foerderstrecke"))) - (if (null line-points) - (progn (alert (ssg-text "vfc-alert-keine-gueltige-linie")) (exit)) - ) (setq startpunkt (car line-points) endpunkt (cadr line-points)) (setq differenz (punkt-differenz startpunkt endpunkt)) @@ -750,41 +742,14 @@ (progn (setq richtung "Ab") (setq deltaH (abs deltaH)) (princ (ssg-text "vfc-foerderrichtung-ab"))) ) - ) - (progn - (princ (ssg-text "vfc-modus-werteingabe-header")) - (setq deltaL (getreal (ssg-textf "vfc-prompt-delta-l" (list (chr 916))))) - (if (null deltaL) (setq deltaL 15000)) - (setq deltaH (getreal (ssg-textf "vfc-prompt-delta-h" (list (chr 916))))) - (if (null deltaH) (setq deltaH 3000)) - ;; Foerderrichtung bleibt eine einfache Auf/Ab-Frage - die horizontale - ;; Zwischenstrecke ist geometrisch NUR bei "Ab" ueberhaupt erreichbar - ;; (die festen 3-Grad-Elemente wirken immer absenkend) und wird daher - ;; erst SPAETER, nach Bibliotheks-Init, als Zusatzoption in der - ;; Winkel-Auswahl angeboten (siehe c:VarioFoerderer) - einheitlich fuer - ;; Werteingabe UND 3D-Linie. - (princ (ssg-text "vfc-foerderrichtung-menu")) - (setq antwort (getstring (ssg-text "vfc-prompt-wahl-1-2-ohne-default"))) - (if (= antwort "2") (setq richtung "Ab") (setq richtung "Auf")) - (setq startpunkt (getpoint (ssg-text "vfc-prompt-startpunkt-aus"))) - (if (null startpunkt) (setq startpunkt '(0 0 0))) - ;; Horizontale Fahrtrichtung waehlen (analog Gefaellestrecke Modus 1) - (princ (ssg-text "vfc-fahrtrichtung-header")) - (princ (ssg-textf "vfc-fahrtrichtung-0" (list grad-zeichen))) - (princ (ssg-textf "vfc-fahrtrichtung-90" (list grad-zeichen))) - (princ (ssg-textf "vfc-fahrtrichtung-180" (list grad-zeichen))) - (princ (ssg-textf "vfc-fahrtrichtung-270" (list grad-zeichen))) - (setq antwort (getstring (ssg-text "prompt-wahl-1-2-3-4"))) - (cond - ((= antwort "2") (setq hz-winkel 90.0)) - ((= antwort "3") (setq hz-winkel 180.0)) - ((= antwort "4") (setq hz-winkel 270.0)) - (t (setq hz-winkel 0.0)) - ) - (princ (ssg-textf "vfc-fahrtrichtung-ergebnis" (list (rtos hz-winkel 2 1) grad-zeichen))) + ;; Einfuegehoehe (Z des Startpunkts) wird NICHT mehr hier auf der + ;; Konsole abgefragt - sie geht als Prefill "einfuegehoehe" in den + ;; Basis-Dialog (vfs-dialog-eingabe-basis) ein, der dasselbe Feld + ;; ohnehin per GUI anzeigt und ueberschreibbar macht (Vorschlag = Z + ;; des Linien-Startpunkts, wie zuvor beim getreal-Prompt). + (list deltaL deltaH richtung startpunkt hz-winkel) ) ) - (list deltaL deltaH richtung startpunkt hz-winkel eingabe-modus) ) ;; ============================================================ @@ -1055,26 +1020,144 @@ (list vf-insert vf-endpunkt) ) -;; Neuanlage (Menue/Konsole -> Dialog) fuer einen Registry-Typ: Startpunkt -;; (X/Y) picken, Basis-Dialog, dann vf-dialog-berechnen-einfuegen. +;; Startpunkt der Anlage per Dialog waehlen (Punktwahl-Button + Anzeige, +;; dcl/variofoerderer.dcl Tile vfc_startpunkt) - dasselbe "Schliessen- +;; Picken-Neu-Zeigen"-Muster wie der Linienzug-Wizard +;; (vflw-gruppe-punkt-hoehe-impl, vf_linienzug.lsp:697), aber ohne dessen +;; Wizard-Pending-Queue: der Punkt wird direkt zurueckgegeben. kopf/ +;; pt_anzeige kommen per set_tile aus ssg-text - anders als +;; vfc-dialog-typ-waehlen also KEIN *ssg-lang*-Gate noetig, der Dialog +;; funktioniert in jeder Sprache. Rueckgabe: Punkt (Liste X Y Z) oder nil, +;; wenn kein Dialog gezeigt werden konnte/durfte (GUI aus) ODER abgebrochen +;; wurde - der Aufrufer (vf-dialog-ablauf) faellt dann auf den alten +;; Konsolen-getpoint zurueck. +(defun vfc-dialog-startpunkt-waehlen (kopf-key / dcl-pfad dat ergebnis gpunkt fertig) + (if (or (not (car (atoms-family 1 '("SSG-GUI-P")))) (ssg-gui-p)) + (progn + (setq fertig nil) + (while (not fertig) + (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/variofoerderer.dcl")) + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "vfc_startpunkt" dat)) + (progn + (if (and dat (>= dat 0)) (unload_dialog dat)) + (setq fertig t gpunkt nil) + ) + (progn + (set_tile "kopf" (ssg-text "vfc-dlg-startpunkt-kopf")) + (if gpunkt + (set_tile "pt_anzeige" + (strcat "X=" (rtos (car gpunkt) 2 1) + " Y=" (rtos (cadr gpunkt) 2 1) + " Z=" (rtos (caddr gpunkt) 2 1))) + ) + (action_tile "pick" "(done_dialog 2)") + (action_tile "accept" "(done_dialog 1)") + (action_tile "cancel" "(done_dialog 0)") + (setq ergebnis (start_dialog)) + (unload_dialog dat) + (cond + ((= ergebnis 2) (setq gpunkt (getpoint (ssg-text kopf-key)))) + ((= ergebnis 1) (setq fertig t)) + (t (setq fertig t gpunkt nil)) + ) + ) + ) + ) + gpunkt + ) + nil + ) +) + +;; Neuanlage (Menue/Konsole -> Dialog) fuer einen Registry-Typ. Zwei +;; Eingabemodi fuer die Geometrie (deltaL/deltaH/richtung/hz/Startpunkt): +;; "1" 3D-Linie: Linie picken (vfc-3dlinie-erfassen), die abgeleiteten +;; Werte gehen als Prefill in den Basis-Dialog - NUR Seite/ +;; Motorseite/Darstellung/Geruest bleiben dort fuer den Anwender offen. +;; "2" Werte: wie bisher Startpunkt (X/Y) picken, Basis-Dialog ohne +;; Geometrie-Prefill (Defaults). +;; Eingabemodus kommt per Vorauswahl (Menue-Wrapper c:StandardVarioFoerderer3D +;; / c:EtageVarioFoerderer3D setzen *vf-vorauswahl-eingabemodus* "1"/"2") oder +;; wird - wie zuvor im Konsolen-Ablauf - interaktiv erfragt; die Vorauswahl +;; gilt nur einmal. Ersetzt den frueheren Rueckfall auf den rein interaktiven +;; Konsolen-Ablauf (vf-eingabe-abfragen, entfernt) fuer die 3D-Linie: dieser +;; lief komplett an der GUI vorbei und fragte Seite/Fahrtrichtung/etc. erneut +;; auf der Kommandozeile ab, obwohl der Basis-Dialog dieselben Felder laengst +;; per GUI anbietet. (defun vf-dialog-ablauf (typ vf-nummer horizontal-p / eingabe deltaL deltaH richtung z-start hz seite startpunkt startpunkt-xy dim - geruest-einzelmodul geruest-typ motorseite) - (setq startpunkt-xy (getpoint (ssg-text "vfc-prompt-startpunkt-aus"))) - (if (null startpunkt-xy) (setq startpunkt-xy '(0 0 0))) - (setq eingabe (vfs-dialog-eingabe-basis nil)) - (if (null eingabe) + geruest-einzelmodul geruest-typ motorseite + antwort dlg-modus linie-erg basis-prefill abbruch) + (setq abbruch nil) + (if *vf-vorauswahl-eingabemodus* + (setq antwort *vf-vorauswahl-eingabemodus* + *vf-vorauswahl-eingabemodus* nil) + (progn + (setq dlg-modus (vfc-dialog-eingabemodus-waehlen)) + (cond + ((eq dlg-modus 'ABBRUCH) (setq antwort "2" abbruch t)) + (dlg-modus (setq antwort dlg-modus)) + (t + ;; Dialog nicht verfuegbar/nicht erlaubt (GUI aus, andere Sprache) + ;; - alte Konsolen-Abfrage unveraendert. + (princ (ssg-text "vfc-eingabemodus-header")) + (princ (ssg-text "vfc-eingabemodus-3dlinie")) + (princ (ssg-text "vfc-eingabemodus-werte")) + (setq antwort (getstring (ssg-text "vfc-prompt-wahl-1-2-ohne-default"))) + ) + ) + ) + ) + (if (not abbruch) + (if (= antwort "1") + (progn + (setq linie-erg (vfc-3dlinie-erfassen)) + (if (null linie-erg) + (setq abbruch t) + (progn + (setq deltaL (nth 0 linie-erg) + deltaH (nth 1 linie-erg) + richtung (nth 2 linie-erg) + startpunkt (nth 3 linie-erg) + hz (nth 4 linie-erg)) + (setq basis-prefill + (list (cons "deltaL" deltaL) (cons "deltaH" deltaH) (cons "richtung" richtung) + (cons "einfuegehoehe" (caddr startpunkt)) (cons "hz" hz))) + ) + ) + ) + (progn + (setq startpunkt-xy (vfc-dialog-startpunkt-waehlen "vfc-prompt-startpunkt-aus")) + (if (null startpunkt-xy) + (setq startpunkt-xy (getpoint (ssg-text "vfc-prompt-startpunkt-aus")))) + (if (null startpunkt-xy) (setq startpunkt-xy '(0 0 0))) + (setq startpunkt startpunkt-xy) + (setq basis-prefill nil) + ) + ) + ) + (if abbruch (princ (ssg-text "vfc-vorgang-abgebrochen")) (progn - (vf-basis-eingabe-entpacken eingabe) - (setq startpunkt (list (car startpunkt-xy) (cadr startpunkt-xy) z-start)) - ;; Gewaehlte Dimension (2D/3D) + Motorseite fuer den Bau erzwingen, danach zurueck. - (setq *ssg-ils-dim* dim) - (setq *vf-motorseite* motorseite) - (vf-dialog-berechnen-einfuegen typ vf-nummer deltaL deltaH richtung startpunkt hz seite nil - geruest-einzelmodul geruest-typ horizontal-p) - (setq *ssg-ils-dim* nil) - (setq *vf-motorseite* nil) + (setq eingabe (vfs-dialog-eingabe-basis basis-prefill)) + (if (null eingabe) + (princ (ssg-text "vfc-vorgang-abgebrochen")) + (progn + (vf-basis-eingabe-entpacken eingabe) + ;; X/Y kommen aus dem Linien-Startpunkt (Modus 1) oder der + ;; separaten Punktwahl (Modus 2); Z immer aus dem Basis-Dialog + ;; (dort vorbelegt, aber ueberschreibbar). + (setq startpunkt (list (car startpunkt) (cadr startpunkt) z-start)) + ;; Gewaehlte Dimension (2D/3D) + Motorseite fuer den Bau erzwingen, danach zurueck. + (setq *ssg-ils-dim* dim) + (setq *vf-motorseite* motorseite) + (vf-dialog-berechnen-einfuegen typ vf-nummer deltaL deltaH richtung startpunkt hz seite nil + geruest-einzelmodul geruest-typ horizontal-p) + (setq *ssg-ils-dim* nil) + (setq *vf-motorseite* nil) + ) + ) ) ) ) @@ -1108,14 +1191,14 @@ ) ;; ============================================================ -;; TEIL 11b: DIALOG-AUSWAHL FUER TYP/LINIENZUG-MODUS (Radio-Buttons) +;; TEIL 11b: DIALOG-AUSWAHL FUER TYP (Radio-Buttons) ;; ============================================================ -;; Ersetzen die beiden Konsolen-Listen am Anfang von c:VarioFoerderer durch -;; Radio-Button-Dialoge (dcl/variofoerderer.dcl, vfc_typ/vfc_linienzug_modus) -;; - alle Optionen sofort sichtbar statt Dropdown. WICHTIG: Radio-Button- +;; Ersetzt die Konsolen-Liste am Anfang von c:VarioFoerderer durch einen +;; Radio-Button-Dialog (dcl/variofoerderer.dcl, vfc_typ) - alle Optionen +;; sofort sichtbar statt Dropdown. WICHTIG: Radio-Button- ;; Labels sind im DCL fest auf Deutsch einprogrammiert (set_tile kann das ;; Label eines radio_button nicht setzen, nur den Zustand - siehe DCL- -;; Kommentar). Beide Funktionen geben deshalb nur dann etwas anderes als nil +;; Kommentar). Die Funktion gibt deshalb nur dann etwas anderes als nil ;; zurueck, wenn GUI erlaubt ist (Tests: ssg-gui-aus) UND Deutsch aktiv ist - ;; sonst faellt der Aufrufer automatisch auf die alte, vollstaendig ;; uebersetzte Konsolen-Liste zurueck (unveraendert im Code stehen @@ -1161,35 +1244,30 @@ ) ) -;; "Zurueck" springt zur Anlagen-Typ-Frage zurueck - Rueckgabe 'ZURUECK, vom -;; Aufrufer (c:VarioFoerderer) ausgewertet (dort erneuter Aufruf von -;; vfc-dialog-typ-waehlen statt hier lokal aufzuloesen). -(defun vfc-dialog-linienzug-modus-waehlen ( / dcl-pfad dat gmodus ergebnis) +;; Eingabemodus (3D-Linie / Werte manuell) per Dialog waehlen - ersetzt die +;; fruehere getstring-Konsolenabfrage in vf-dialog-ablauf. Gleiches Muster/ +;; gleiche Einschraenkung wie vfc-dialog-typ-waehlen: nur bei aktiver GUI und +;; Deutsch, sonst nil (Aufrufer faellt dann auf die alte Konsolen-Abfrage +;; zurueck). Keine "Zurueck"-Taste noetig (direkt nach der Typ-Wahl, die +;; selbst schon ein "Zurueck" hat). Rueckgabe: "1" (3D-Linie), "2" (Werte) +;; oder 'ABBRUCH. +(defun vfc-dialog-eingabemodus-waehlen ( / dcl-pfad dat gmodus ergebnis) (if (and (or (not (car (atoms-family 1 '("SSG-GUI-P")))) (ssg-gui-p)) (= *ssg-lang* "de_DE")) (progn (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/variofoerderer.dcl")) (setq dat (load_dialog dcl-pfad)) - (if (not (new_dialog "vfc_linienzug_modus" dat)) + (if (not (new_dialog "vfc_eingabemodus" dat)) (progn (if (and dat (>= dat 0)) (unload_dialog dat)) nil) (progn - (set_tile "modus_1" "1") + (set_tile "modus_3dlinie" "1") (action_tile "accept" - "(setq gmodus (cond ((= (get_tile \"modus_2\") \"1\") 2) - ((= (get_tile \"modus_3\") \"1\") 3) - ((= (get_tile \"modus_4\") \"1\") 4) - ((= (get_tile \"modus_5\") \"1\") 5) - (t 1))) + "(setq gmodus (if (= (get_tile \"modus_werte\") \"1\") \"2\" \"1\")) (done_dialog 1)") (action_tile "cancel" "(done_dialog 0)") - (action_tile "back" "(done_dialog 2)") (setq ergebnis (start_dialog)) (unload_dialog dat) - (cond - ((= ergebnis 1) gmodus) - ((= ergebnis 2) 'ZURUECK) - (t 'ABBRUCH) - ) + (if (= ergebnis 1) gmodus 'ABBRUCH) ) ) ) @@ -1200,20 +1278,14 @@ ;; ============================================================ ;; TEIL 12: DISPATCHER c:VarioFoerderer ;; ============================================================ -;; Erzwungener QC-Modus (Linienzug-Modus 4/5, vfc-dialog-linienzug-modus- -;; waehlen/Konsolen-Fallback unten): "4"/"5" waehrend des naechsten +;; Erzwungener QC-Modus (Linienzug-Modus 4/5, siehe *vf-vorauswahl-linienzug- +;; modus* oben/c:QcLinieMitGf*): "4"/"5" waehrend des naechsten ;; vf-linienzug-modus-Laufs, sonst nil. Von vf-linienzug-modus (vf_linienzug. ;; lsp, spaeter geladen) gelesen/geleert - globale Vorab-Deklaration hier, ;; damit sie unabhaengig von der Lade-Reihenfolge existiert. (if (not (boundp '*vfl-forciere-qc-modus*)) (setq *vfl-forciere-qc-modus* nil)) (defun c:VarioFoerderer ( / typ-eintr anlage-typ berechne-fn einfuege-fn - eingabe deltaL deltaH richtung startpunkt seite hz - eingabe-modus ergebnis ergebnis-liste gueltige-winkel - horizontal-info - best-winkel L_GF L_GF1 L_GF2 L_VF - idx eintrag wahl antwort verteilung-modus - n-scanner vf-nummer hoehe-von hoehe-bis lastEnt - staustrecke-basis vf-insert dlg-typ dlg-modus zurueck-zu-typ) + idx wahl vf-nummer dlg-typ zurueck-zu-typ) (princ "\n=========================================") (princ (ssg-text "vfc-banner-titel")) @@ -1272,24 +1344,13 @@ ;; Kette mit gemischten GF/VF-Segmenten), passt nicht in das berechne-fn/ ;; einfuege-fn-Schema fuer ein einzelnes durchgehendes Segment - siehe ;; vf_linienzug.lsp. Dispatcht hier direkt und beendet den Standard-Ablauf. + ;; Jeder Aufrufer (Menue-Wrapper c:LinienzugVarioFoerderer*/c:QcLinieMitGf*) + ;; setzt *vf-vorauswahl-linienzug-modus* VOR dem Aufruf - der frueher + ;; hier gefuehrte Modus-Dialog/Konsolen-Fallback ist dadurch entfallen. (if (= anlage-typ "linienzug") (progn - (setq dlg-modus (vfc-dialog-linienzug-modus-waehlen)) - (cond - ((eq dlg-modus 'ABBRUCH) (exit)) - ((eq dlg-modus 'ZURUECK) (setq zurueck-zu-typ t)) - (dlg-modus (setq wahl dlg-modus)) - (t - ;; Dialog nicht verfuegbar/nicht erlaubt - alte Konsolen-Liste. - (princ (ssg-text "vfc-linienzug-modus-header")) - (princ (ssg-text "vfc-linienzug-modus-1")) - (princ (ssg-text "vfc-linienzug-modus-2")) - (princ (ssg-text "vfc-linienzug-modus-3")) - (princ (ssg-text "vfc-linienzug-modus-4")) - (princ (ssg-text "vfc-linienzug-modus-5")) - (setq wahl (getint (ssg-text "prompt-wahl-1-5"))) - ) - ) + (setq wahl *vf-vorauswahl-linienzug-modus* + *vf-vorauswahl-linienzug-modus* nil) (if (not zurueck-zu-typ) (progn ;; Konsolen-Nummer -> interne Funktion: @@ -1321,215 +1382,26 @@ (setq vf-nummer (vf-next-number)) (princ (ssg-textf "vfc-naechste-vf-nummer" (list (itoa vf-nummer)))) - ;; 2b. Standard- ODER Etage-Typ + Werteingabe -> DCL-Dialog - ;; (dcl/variofoerderer.dcl; Standard: vfs-standard-dialog-ablauf in - ;; vf_standard.lsp, Etage: vfe-etage-dialog-ablauf in vf_etage.lsp - beide - ;; nutzen dieselben Dialoge vfs-dialog-eingabe-basis/-winkel-verteilung). - ;; 3D-Linie-Eingabe und der Typ Linienzug bleiben unveraendert interaktiv - ;; (fallen unten in den Konsolen-Ablauf, der die Eingabemodus-Frage erneut - ;; stellt - siehe vf-eingabe-abfragen). + ;; 2b. Standard- ODER Etage-Typ -> DCL-Dialog (dcl/variofoerderer.dcl; + ;; Standard: vfs-standard-dialog-ablauf in vf_standard.lsp, Etage: + ;; vfe-etage-dialog-ablauf in vf_etage.lsp - beide duenne Wrapper um + ;; vf-dialog-ablauf). Die Eingabemodus-Frage (3D-Linie vs. Werte) stellt + ;; vf-dialog-ablauf selbst, VOR dem Basis-Dialog - bei 3D-Linie gehen + ;; deltaL/deltaH/Richtung/Einfuegehoehe als Prefill in denselben + ;; Basis-Dialog ein, den auch die Werteingabe nutzt (siehe dortiger + ;; Kopfkommentar). Damit entfaellt der fruehere rein interaktive + ;; Konsolen-Ablauf (Schritte 3-11, vf-eingabe-abfragen) komplett - er lief + ;; bei 3D-Linie an der GUI vorbei und fragte Seite/Fahrtrichtung/Verteilung + ;; erneut auf der Kommandozeile ab, obwohl der Dialog dieselben Felder + ;; laengst per GUI anbietet. (if (member anlage-typ '("standard" "etage")) (progn - ;; Eingabemodus: Vorauswahl (Menue-Wrapper) hat Vorrang, sonst fragen. - (if *vf-vorauswahl-eingabemodus* - (setq antwort *vf-vorauswahl-eingabemodus*) - (progn - (princ (ssg-text "vfc-eingabemodus-header")) - (princ (ssg-text "vfc-eingabemodus-3dlinie")) - (princ (ssg-text "vfc-eingabemodus-werte")) - (setq antwort (getstring (ssg-text "vfc-prompt-wahl-1-2-ohne-default"))) - ) - ) - (if (= antwort "2") - (progn - (if (= anlage-typ "etage") - (vfe-etage-dialog-ablauf vf-nummer) - (vfs-standard-dialog-ablauf vf-nummer)) - (exit) - ) - ) - ) - ) - - ;; 3. Gemeinsame Eingabe (deltaL, deltaH, richtung, startpunkt) - richtung - ;; steht bei beiden Eingabemodi (Werteingabe UND 3D-Linie) bereits fest. - (setq eingabe (vf-eingabe-abfragen)) - (setq deltaL (nth 0 eingabe) - deltaH (nth 1 eingabe) - richtung (nth 2 eingabe) - startpunkt (nth 3 eingabe) - hz (nth 4 eingabe) - eingabe-modus (nth 5 eingabe)) - - ;; 4. Seite-Auswahl (vor Berechnung, weil Etage-Typ sie fuer Geometrie braucht) - (princ (ssg-text "vfc-seite-header")) - (princ (ssg-text "vfc-seite-rechts")) - (princ (ssg-text "vfc-seite-links")) - (setq antwort (getstring (ssg-text "prompt-wahl-1-2"))) - (if (= antwort "2") (setq seite "links") (setq seite "rechts")) - (princ (ssg-textf "vfc-seite-gewaehlt" (list seite))) - - ;; 5. Typ-spezifische Berechnung (init + Winkelsuche) - (setq ergebnis (apply berechne-fn (list deltaL deltaH richtung seite))) - (setq ergebnis-liste (cadddr ergebnis)) - - ;; 5b. Horizontale Zwischenstrecke als Zusatzoption: geometrisch NUR bei - ;; "Ab" ueberhaupt erreichbar (die festen 3-Grad-Elemente wirken immer - ;; absenkend) - "Auf" wird deshalb gar nicht erst geprueft. Gilt einheitlich - ;; fuer Werteingabe UND 3D-Linie, da richtung hier in jedem Fall feststeht. - ;; Bibliothek ist durch den berechne-fn-Aufruf oben bereits initialisiert. - (if (and (= anlage-typ "standard") (= richtung "Ab")) - (progn - (setq horizontal-info (berechne-horizontale-mitte deltaL deltaH "Ab" nil)) - (if (and horizontal-info (caddr horizontal-info)) - (progn - (setq ergebnis-liste - (append ergebnis-liste - (list (list 0 (car horizontal-info) (cadr horizontal-info) T)))) - (princ (ssg-textf "vfc-hinweis-horizontal-moeglich" (list (chr 176) (chr 916)))) - ) - (setq horizontal-info nil) - ) - ) - ) - - ;; Konfiguration (nach ssg_core-Init verfuegbar). - (setq staustrecke-basis (ssg-cfg-or "vario" "staustrecke_basis" 1000)) - - ;; 7. Gueltige Winkel ermitteln - (setq gueltige-winkel - (mapcar 'car - (vl-remove-if-not - (function (lambda (e) (and (nth 3 e) - (numberp (nth 1 e)) (numberp (nth 2 e)) - (>= (nth 1 e) 0) (>= (nth 2 e) 0)))) - ergebnis-liste))) - (if (null gueltige-winkel) - (progn - (alert (ssg-textf "vfc-alert-kein-winkel" - (list (chr 916) (rtos deltaL 2 0) (rtos deltaH 2 0) richtung))) + (if (= anlage-typ "etage") + (vfe-etage-dialog-ablauf vf-nummer) + (vfs-standard-dialog-ablauf vf-nummer)) (exit) ) ) - - ;; 8. Winkelauswahl (automatisch oder interaktiv) - ;; Sentinel-Winkel 0 = horizontale Zwischenstrecke (Schritt 6/11 bei 0 - ;; Grad, Boegen fest auf_3/ab_3) - siehe berechne-horizontale-mitte. - (if (= (length gueltige-winkel) 1) - (progn - (setq best-winkel (car gueltige-winkel)) - (setq eintrag (assoc best-winkel ergebnis-liste)) - (setq L_GF (nth 1 eintrag) L_VF (nth 2 eintrag)) - (if (= best-winkel 0) - (princ (ssg-text "vfc-einzige-variante-horizontal")) - (princ (ssg-textf "vfc-einziger-winkel" (list (itoa best-winkel) (chr 176)))) - ) - ) - (progn - (princ (ssg-text "vfc-mehrere-winkel-header")) - (setq idx 1) - (foreach w gueltige-winkel - (setq eintrag (assoc w ergebnis-liste)) - (if (= w 0) - (princ (ssg-textf "vfc-winkel-option-horizontal" - (list idx (chr 176) - (rtos (nth 1 eintrag) 2 1) (rtos (nth 2 eintrag) 2 1)))) - (princ (ssg-textf "vfc-winkel-option" - (list idx (itoa w) (chr 176) - (rtos (nth 1 eintrag) 2 1) (rtos (nth 2 eintrag) 2 1)))) - ) - (setq idx (1+ idx)) - ) - (setq wahl (getint (ssg-textf "vfc-prompt-winkel-waehlen" - (list (length gueltige-winkel))))) - (if (or (null wahl) (< wahl 1) (> wahl (length gueltige-winkel))) - (setq wahl 1)) - (setq best-winkel (nth (1- wahl) gueltige-winkel)) - (setq eintrag (assoc best-winkel ergebnis-liste)) - (setq L_GF (nth 1 eintrag) L_VF (nth 2 eintrag)) - ) - ) - (princ "\n\n=========================================") - (if (= best-winkel 0) - (princ (ssg-textf "vfc-zus-horizontal" - (list (rtos L_GF 2 2) (rtos L_VF 2 2)))) - (princ (ssg-textf "vfc-zus-winkel" - (list (itoa best-winkel) (chr 176) (rtos L_GF 2 2) (rtos L_VF 2 2)))) - ) - (princ "\n=========================================") - - ;; 9. L_GF Verteilung - (princ (ssg-text "vfc-gf-verteilung-header")) - (princ (ssg-text "vfc-gf-verteilung-1")) - (princ (ssg-text "vfc-gf-verteilung-2")) - (princ (ssg-text "vfc-gf-verteilung-3")) - (princ (ssg-text "vfc-gf-verteilung-4")) - (setq verteilung-modus (getstring (ssg-text "prompt-wahl-1-2-3-4"))) - (if (= verteilung-modus "") (setq verteilung-modus "1")) - (cond - ((= verteilung-modus "1") - (setq L_GF1 (/ L_GF 2.0) L_GF2 (/ L_GF 2.0))) - ((= verteilung-modus "2") - (setq L_GF1 (float staustrecke-basis)) - (setq L_GF2 (max 0.0 (- L_GF (float staustrecke-basis))))) - ((= verteilung-modus "3") - (setq L_GF2 (float staustrecke-basis)) - (setq L_GF1 (max 0.0 (- L_GF (float staustrecke-basis))))) - ((= verteilung-modus "4") - (setq L_GF1 (getreal (ssg-textf "vfc-prompt-lgf1-vorne" - (list (rtos (/ L_GF 2.0) 2 2))))) - (if (null L_GF1) (setq L_GF1 (/ L_GF 2.0))) - (setq L_GF2 (max 0.0 (- L_GF L_GF1))) - (princ (ssg-textf "vfc-lgf2-hinten" (list (rtos L_GF2 2 2))))) - (t (setq L_GF1 (/ L_GF 2.0) L_GF2 (/ L_GF 2.0))) - ) - (princ (ssg-textf "vfc-zus-lgf" (list (rtos L_GF1 2 2) (rtos L_GF2 2 2)))) - - ;; Scanner-Anzahl wird nicht mehr abgefragt (Attribut ANZAHL_SCANNER bleibt 0). - (setq n-scanner 0) - - ;; 11. Bestaetigung - (princ (ssg-text "vfc-einfuegen-frage")) - (princ (ssg-text "vfc-einfuegen-optionen")) - (setq antwort (getstring (ssg-text "vfc-prompt-wahl-1-2-ohne-default"))) - - (if (= antwort "1") - (progn - ;; Hoehenangaben fuer Attribute und Beschriftung - (setq hoehe-von (caddr startpunkt)) - (setq hoehe-bis (cond - ((= richtung "Auf") (+ hoehe-von deltaH)) - ((= richtung "Ab") (- hoehe-von deltaH)) - (t hoehe-von))) - - ;; lastEnt VOR der Einfuegung merken - (setq lastEnt (ssg-lastent-ohne-attribute)) - - ;; Typ-spezifische Einfuegung - (apply einfuege-fn - (list deltaL deltaH richtung best-winkel L_GF1 L_GF2 L_VF startpunkt seite hz)) - - ;; Gemeinsame VF_*-Block-Erstellung - ;; Geruest fuer Einzelmodul/Geruestoption sind in diesem interaktiven - ;; Konsolen-Ablauf (Etage/Linienzug) nicht abfragbar - bleiben auf - ;; Schema-Default (analog Kreisel: nur ueber Dialog editierbar). - (setq vf-insert - (vf-block-erstellen anlage-typ seite vf-nummer n-scanner - hoehe-von hoehe-bis deltaH deltaL L_VF L_GF1 L_GF2 - richtung best-winkel startpunkt lastEnt hz - "0" "Schoenenberger Geruest")) - - ;; Standard- UND Etage-Bloecke aus dem interaktiven Konsolen-Ablauf mit der - ;; SSG_VF_EDIT-XDATA markieren - sie sind (wie die Dialog-Variante) aus - ;; Attributen + hz verlustfrei rekonstruierbar, also per Doppelklick - ;; (c:VARIOFOERDERER_EDIT) editierbar. Linienzug bleibt unmarkiert. - (if (and vf-insert (member anlage-typ '("standard" "etage"))) - (vf-edit-xdata-schreiben vf-insert anlage-typ hz)) - - (princ "\n=========================================") - ) - (princ (ssg-text "vfc-vorgang-abgebrochen")) - ) nil ) @@ -1540,7 +1412,6 @@ ;; Menue-Wrapper: jeder feste Endpunkt der VarioFoerderer-Erzeugung ist ;; direkt aufrufbar (Typ + Eingabemodus vorbelegt, keine Rueckfrage). -;; Nur der Linienzug fragt intern noch Modus 1/2/3 (komplexer Fall). ;; Eingabemodus-Vorauswahl: "2" = Werte manuell (DCL-Dialog), ;; "1" = aus 3D-Linie (Linie picken). @@ -1568,9 +1439,34 @@ (c:VarioFoerderer) ) -;; --- Linienzug (bleibt interaktiv: fragt Modus 1/2/3) --- -(defun c:LinienzugVarioFoerderer () - (setq *vf-vorauswahl-typ* "linienzug") +;; --- Linienzug/Streckengruppe (Modus 1/2/3, Typ+Modus vorbelegt) --- +(defun c:LinienzugVarioFoerdererManuell () + (setq *vf-vorauswahl-typ* "linienzug" + *vf-vorauswahl-linienzug-modus* 1) + (c:VarioFoerderer) +) +(defun c:LinienzugVarioFoerdererZielhoehe () + (setq *vf-vorauswahl-typ* "linienzug" + *vf-vorauswahl-linienzug-modus* 2) + (c:VarioFoerderer) +) +(defun c:LinienzugVarioFoerdererStueckweise () + (setq *vf-vorauswahl-typ* "linienzug" + *vf-vorauswahl-linienzug-modus* 3) + (c:VarioFoerderer) +) + +;; --- QC-Linie (Linienzug-Modus 4/5, Typ+Modus vorbelegt) --- +;; Menue: ILS -> Gefaellestrecke (gehoeren inhaltlich dorthin, technisch +;; weiterhin ueber den Linienzug-Ablauf/*vfl-forciere-qc-modus* gebaut). +(defun c:QcLinieMitGf () + (setq *vf-vorauswahl-typ* "linienzug" + *vf-vorauswahl-linienzug-modus* 4) + (c:VarioFoerderer) +) +(defun c:QcLinieMitGfUForm () + (setq *vf-vorauswahl-typ* "linienzug" + *vf-vorauswahl-linienzug-modus* 5) (c:VarioFoerderer) ) diff --git a/Lisp/vf_linienzug.lsp b/Lisp/vf_linienzug.lsp index 3dbd70c..9670e33 100644 --- a/Lisp/vf_linienzug.lsp +++ b/Lisp/vf_linienzug.lsp @@ -1033,7 +1033,17 @@ ;; "Neue Linie: GF" - Separator VOR/NACH (2 Ja/Nein-Toggles in einem ;; Bildschirm). Siehe dcl/vf_linienzug_wizard.dcl (vflw_sep_gf). -(defun vflw-gruppe-sep-gf-impl ( / dat ergebnis gsepvor gsepnach) +;; es-folgt-sep: T, wenn dieses GF-Stueck das Kettenende MIT ES-Element ist +;; (gf-kettenende-antwort steht beim Aufruf schon fest, siehe Aufrufer) - +;; dann baut vfl-insert-es-element ohnehin IMMER seinen eigenen Separator +;; VOR dem ES-Block, ein zusaetzlicher "Separator NACH" waere ein zweiter, +;; direkt anschliessender Separator. Statt die Frage zu stellen und die +;; Antwort hinterher zu verwerfen (Nutzer-Feedback 2026-10-08: verwirrend), +;; wird die Kachel hier direkt deaktiviert+abgehakt - der bestehende +;; Konsolen-/Sicherheitsnetz-Pfad (siehe Aufrufer, "ueberschrieben"-Meldung) +;; bleibt UNVERAENDERT bestehen (deckt weiterhin den reinen Konsolen-Fall ab, +;; wo diese Dialog-Funktion gar nicht laeuft). +(defun vflw-gruppe-sep-gf-impl (es-folgt-sep / dat ergebnis gsepvor gsepnach) (setq dat (load_dialog (vflw-dcl-pfad))) (if (not (new_dialog "vflw_sep_gf" dat)) (if (and dat (>= dat 0)) (unload_dialog dat)) @@ -1041,6 +1051,7 @@ (set_tile "kopf" (vflw-clean (ssg-text "vfl-sep-gf-header"))) (set_tile "sepvor" "0") (set_tile "sepnach" "0") + (if es-folgt-sep (mode_tile "sepnach" 1)) (action_tile "accept" "(setq gsepvor (get_tile \"sepvor\")) (setq gsepnach (get_tile \"sepnach\")) (done_dialog 1)") (action_tile "cancel" "(done_dialog 0)") @@ -1516,11 +1527,11 @@ (princ)) ;; "Naechstes Element waehlen" - Hauptmenue des Linienzug-Aufbaus (Modus 1). -;; Kettenanfang (frame=nil): alle 6 Optionen waehlbar, Vario-Kurve inklusive -;; (kann nur als allererstes Kettenglied gewaehlt werden - siehe Kommentar an -;; der Aufrufstelle). Sonst (Frame vorhanden): Vario-Kurve per mode_tile -;; deaktiviert, die uebrigen 5 Optionen behalten dieselbe Reihenfolge/ -;; Bedeutung wie im Konsolen-Menue, nur ohne die Luecke. Pusht die +;; Kettenanfang (frame=nil): alle 5 Radio-Optionen waehlbar, Vario-Kurve +;; inklusive (kann nur als allererstes Kettenglied gewaehlt werden - siehe +;; Kommentar an der Aufrufstelle). Sonst (Frame vorhanden): Vario-Kurve per +;; mode_tile deaktiviert, die uebrigen 4 Optionen behalten dieselbe +;; Reihenfolge/Bedeutung wie im Konsolen-Menue, nur ohne die Luecke. Pusht die ;; POSITIONELLE Antwort ("1".."6" bzw. "1".."5"), identisch zur bisherigen ;; Konsolen-Nummerierung, damit Journal/Replay unveraendert bleiben - die ;; Radio-Buttons selbst tragen daher STABILE, kontextunabhaengige Keys @@ -1531,9 +1542,20 @@ ;; - eindeutig als VF erkannt (Startpunkt liegt auf einer bestehenden ;; VF-Kette) macht "GF-Bogen"/"Neue Linie: GF" als DIREKTE Fortsetzung keinen ;; Sinn (kein GF-Baustein wird an dieser Stelle einfach an ein VF-Teil -;; angeflanscht) - diese beiden Optionen werden dann ausgegraut. "Neue Linie -;; BIS Kettenende" bleibt immer waehlbar (hat ihre eigene GF/VF-Erkennung). -(defun vflw-gruppe-naechstes-element-impl (kettenanfang familie / dat ergebnis slot gwahl) +;; angeflanscht) - diese beiden Optionen werden dann ausgegraut. +;; as-eben-eingefuegt: T, wenn der Anwender die AS-Frage ("AS-Element +;; setzen?") explizit mit Ja beantwortet hat (as-vorhanden in +;; vf-linienzug-modus) - das AS-Element braucht danach zuerst ein GERADES +;; Segment (Linie-GF/Linie-VF/Horizontal-VF), eine horizontale Kurve direkt +;; im Anschluss (GF-Bogen/Vario-Kurve) ergibt keinen Sinn und wird ebenfalls +;; ausgegraut. Greift nur, wenn familie nicht schon "VF" ist (dort ist +;; wahl_gfbogen bereits deaktiviert); nil, wenn der Startpunkt automatisch +;; auf einer bestehenden Kette erkannt wurde (as-vorhanden dann ohnehin nil). +;; "Neue Linie BIS Kettenende" ist kein Radio mehr, sondern der eigene Button +;; "abschliessen" (done_dialog 3) - er setzt slot direkt auf 6 und ignoriert +;; die aktuelle Radio-Auswahl (hat ihre eigene GF/VF-Erkennung, bleibt daher +;; immer waehlbar, auch wenn GF-Bogen/Neue Linie: GF ausgegraut sind). +(defun vflw-gruppe-naechstes-element-impl (kettenanfang familie as-eben-eingefuegt / dat ergebnis slot gwahl) (setq dat (load_dialog (vflw-dcl-pfad))) (if (not (new_dialog "vflw_naechstes_element" dat)) (if (and dat (>= dat 0)) (unload_dialog dat)) @@ -1546,20 +1568,31 @@ (mode_tile "wahl_gfbogen" 1) (mode_tile "wahl_liniegf" 1) (set_tile "wahl_variokurve" "1"))) + ;; Unmittelbar nach einem explizit eingefuegten AS-Element ergibt eine + ;; horizontale Kurve (GF-Bogen/Vario-Kurve) als DIREKTE Fortsetzung + ;; keinen Sinn - das AS-Element braucht zuerst ein gerades Segment + ;; (Linie-GF/Linie-VF/Horizontal-VF). Nur relevant am Kettenanfang und + ;; nur, wenn nicht schon durch familie="VF" abgedeckt (dort ist + ;; wahl_gfbogen bereits deaktiviert). + (if (and kettenanfang as-eben-eingefuegt (not (equal familie "VF"))) + (progn + (mode_tile "wahl_gfbogen" 1) + (mode_tile "wahl_variokurve" 1) + (set_tile "wahl_liniegf" "1"))) (action_tile "accept" "(setq slot (cond ((= (get_tile \"wahl_gfbogen\") \"1\") 1) ((= (get_tile \"wahl_variokurve\") \"1\") 2) ((= (get_tile \"wahl_linievf\") \"1\") 4) ((= (get_tile \"wahl_horizontalvf\") \"1\") 5) - ((= (get_tile \"wahl_linieende\") \"1\") 6) (t 3))) (done_dialog 1)") + (action_tile "abschliessen" "(setq slot 6) (done_dialog 3)") (action_tile "cancel" "(done_dialog 0)") (action_tile "back" "(done_dialog 2)") (setq ergebnis (start_dialog)) (unload_dialog dat) (cond - ((= ergebnis 1) + ((or (= ergebnis 1) (= ergebnis 3)) (setq gwahl (if (or kettenanfang (<= slot 2)) slot (1- slot))) (vflw-pending-push-all (list (itoa gwahl)))) ((= ergebnis 2) (setq *vfl-wizard-abbruch-grund* "zurueck")) @@ -6594,7 +6627,8 @@ (progn (if (vfl-wizard-aktiv) (vl-catch-all-apply 'vflw-gruppe-naechstes-element-impl - (list (null frame) (if (null frame) startpunkt-familie nil)))) + (list (null frame) (if (null frame) startpunkt-familie nil) + (if (null frame) as-vorhanden nil)))) (if frame (progn (princ (ssg-text "vfl-menu-gf-bogen-1")) @@ -7008,7 +7042,7 @@ (setq hz-neu (car (frame->hz-winkel frame))) ) (setq rad3 (* gf-max-winkel (/ pi 180.0))) - (if (vfl-wizard-aktiv) (vl-catch-all-apply 'vflw-gruppe-sep-gf-impl nil)) + (if (vfl-wizard-aktiv) (vl-catch-all-apply 'vflw-gruppe-sep-gf-impl (list (= gf-kettenende-antwort "1")))) (princ (ssg-text "vfl-sep-vor-gf-frage")) (princ (ssg-text "vfl-ja")) (princ (ssg-text "vfl-nein")) @@ -7050,9 +7084,16 @@ (if (> sep-anzahl 0) (setq deltaH (max 0.0 (- deltaH (* sep-anzahl *vfk-separator-laenge* (sin rad3)))))) ;; ES-Fussabdruck VORAB reservieren, siehe Kommentar bei - ;; gf-kettenende-antwort oben. + ;; gf-kettenende-antwort oben. ES bringt IMMER seinen eigenen + ;; Separator mit (vfl-insert-es-element, siehe Kommentar oben + ;; "bringt seinen eigenen Separator VOR dem ES-Block schon + ;; mit") - dessen Hoehenanteil fehlte hier bisher komplett + ;; (realer Bug, Nutzer-Meldung 2026-10-08: Kette baute zu lang/ + ;; zu tief, weil der automatische Kettenende-Separator anders + ;; als die optionalen vor/nach-Separatoren oben NICHT reserviert + ;; wurde). (if (= gf-kettenende-antwort "1") - (setq deltaH (max 0.0 (- deltaH (abs ein-dz))))) + (setq deltaH (max 0.0 (- deltaH (* *vfk-separator-laenge* (sin rad3)) (abs ein-dz))))) (if (vfl-wizard-aktiv) (vl-catch-all-apply 'vflw-gruppe-gefaelle-impl (list (vfl-gf-hoehe-vorschlag (caddr p-aktuell)) t nil))) @@ -7116,7 +7157,7 @@ ;; gepickten deltaL abgezogen, damit die Kette exakt am ;; gepickten Punkt endet statt danach ueberzustehen. (setq rad3 (* gf-max-winkel (/ pi 180.0))) - (if (vfl-wizard-aktiv) (vl-catch-all-apply 'vflw-gruppe-sep-gf-impl nil)) + (if (vfl-wizard-aktiv) (vl-catch-all-apply 'vflw-gruppe-sep-gf-impl (list (= gf-kettenende-antwort "1")))) (princ (ssg-text "vfl-sep-vor-gf-frage")) (princ (ssg-text "vfl-ja")) (princ (ssg-text "vfl-nein")) @@ -7139,9 +7180,15 @@ (if (> sep-anzahl 0) (setq deltaL (- deltaL (* sep-anzahl *vfk-separator-laenge* (cos rad3))))) ;; ES-Fussabdruck VORAB reservieren, siehe Kommentar bei - ;; gf-kettenende-antwort oben. + ;; gf-kettenende-antwort oben. ES bringt IMMER seinen + ;; eigenen Separator mit (vfl-insert-es-element) - dessen + ;; Laenge fehlte hier bisher komplett (realer Bug, + ;; Nutzer-Meldung 2026-10-08: Kette baute ca. 300mm*cos(w) + ;; zu lang, weil der automatische Kettenende-Separator + ;; anders als die optionalen vor/nach-Separatoren oben + ;; NICHT reserviert wurde). (if (= gf-kettenende-antwort "1") - (setq deltaL (- deltaL (abs ein-dx)))) + (setq deltaL (- deltaL (* *vfk-separator-laenge* (cos rad3)) (abs ein-dx)))) (if (< deltaL 1.0) (progn (princ (ssg-text "vfl-fehler-linie-zu-kurz")) (setq gf-ok nil))) (if gf-ok @@ -8985,6 +9032,12 @@ (princ (ssg-text "vfl-vwnb-titel")) (princ "\n=========================================") + ;; "Zurueck"/"Abbrechen"-Flag ganz am Anfang zuruecksetzen - identischer Fix + ;; wie in vf-linienzug-modus/-modus2 (siehe dortiger Kommentar): sonst + ;; wuerde ein von einem VORHERIGEN Lauf noch gesetztes Flag den allerersten + ;; vfl-in-*-Aufruf dieses NEUEN Laufs sofort wieder abbrechen. + (setq *vfl-wizard-abbruch-grund* nil) + ;; --- Debug-Session (Schalter "vfl-modus3", DEFAULT AN) ------------------- ;; Bei Bedarf abschaltbar: (dbg-schalter-off "vfl-modus3") in der Konsole. ;; Alle interaktiven Eingaben (Punkte, Hoehen, Seiten, Winkel, Menue- @@ -9503,6 +9556,7 @@ nonclimber-cnt nkurve kurve-chords run-span hor-koerper-len hor-pairs flat-p flat-zone-erste fill-len wahl3 rad3v feste-vf dH-adj dir-x dir-y fill-D end-hz + laengs-wert quer-wert soll-korrigiert es-vek-fix es-along-fix gf-total br-gf-mode br-gf2-exp filler-A-len filler-a-done as-vorhanden es-vorhanden dbg-an dbg-old-error @@ -9512,6 +9566,16 @@ (princ (ssg-text "vfl-m3-titel")) (princ "\n=========================================") + ;; "Zurueck"/"Abbrechen"-Flag ganz am Anfang zuruecksetzen (auch schon vor + ;; der ersten Praeambel-Frage) - sonst wuerde ein von einem VORHERIGEN Lauf + ;; (egal ob Modus 1/2/3) noch gesetztes Flag (z.B. nach "Abbrechen") den + ;; allerersten vfl-in-*-Aufruf DIESES NEUEN Laufs sofort wieder abbrechen + ;; (siehe zentraler Check in vfl-in-value/-value-p) - identischer Fix wie in + ;; vf-linienzug-modus (Modus 1). Realer Bug: ein zweiter Modus-2-Aufruf in + ;; derselben Zeichnung/Session brach sofort mit "ABBRUCH-TRIGGER: + ;; *vfl-wizard-abbruch-grund*=abbrechen" ab, ohne ueberhaupt die + ;; Pfad-Auswahl anzuzeigen (Livetest 2026-09-21). + (setq *vfl-wizard-abbruch-grund* nil) ;; *vfl-journal* VOR dem allerersten vfl-in-*-Aufruf zuruecksetzen (nicht ;; *vfl-replay-queue*, siehe Kommentar bei vfl-journal-reset-lauf und die ;; analoge Korrektur in vf-linienzug-modus). Frueher stand dieser Reset erst @@ -10304,12 +10368,30 @@ ;; ~0 sein (Endpunkt liegt auf der KS_AUS-Achse), Laengs = ES-Ausladung. (setq end-hz (car (frame->hz-winkel frame))) ; KS_AUS-Achsrichtung (setq dir-x (cos (* end-hz (/ pi 180.0))) dir-y (sin (* end-hz (/ pi 180.0)))) - (princ (ssg-textf "vfl-m3-laengs-quer" - (list (rtos (+ (* (- (car ist-ende) (car soll-ende)) dir-x) - (* (- (cadr ist-ende) (cadr soll-ende)) dir-y)) 2 1) - (rtos (+ (* (- (car ist-ende) (car soll-ende)) (- dir-y)) - (* (- (cadr ist-ende) (cadr soll-ende)) dir-x)) 2 1)))) + (setq laengs-wert (+ (* (- (car ist-ende) (car soll-ende)) dir-x) + (* (- (cadr ist-ende) (cadr soll-ende)) dir-y))) + (setq quer-wert (+ (* (- (car ist-ende) (car soll-ende)) (- dir-y)) + (* (- (cadr ist-ende) (cadr soll-ende)) dir-x))) + (princ (ssg-textf "vfl-m3-laengs-quer" (list (rtos laengs-wert 2 1) (rtos quer-wert 2 1)))) (princ (ssg-text "vfl-m3-achse-hinweis")) + ;; Soll (ES-korrigiert): der gepickte Zielpunkt, verschoben um den bereits + ;; oben gemessenen Laengs-Wert entlang der KS_AUS-Achse - zeigt, dass die + ;; Abweichung oben keine Unsicherheit ist, sondern GENAU der ES-eigene + ;; Fussabdruck (90/30-Grad-Schwenk, siehe doc/VarioFoerderer_Linienzug_ + ;; Prinzipien.md Abschnitt 6/14.11: "seitliche ES-Ausladung, kein Fehler"). + ;; Bewusst aus dem bereits gemessenen Laengs-Wert abgeleitet statt ueber + ;; eine zweite, eigenstaendige vf-element-ks-info-Neuberechnung - das waere + ;; ein zweiter Rechenweg fuer dieselbe Information mit eigenem Bug-Risiko, + ;; hier reicht die Umkehrung der bereits validierten Laengs/Quer-Zerlegung. + (setq soll-korrigiert (list (+ (car soll-ende) (* laengs-wert dir-x)) + (+ (cadr soll-ende) (* laengs-wert dir-y)) + (caddr soll-ende))) + (princ (ssg-textf "vfl-m3-ziel-soll-es-korrigiert" + (list (rtos (car soll-korrigiert) 2 1) (rtos (cadr soll-korrigiert) 2 1) (rtos (caddr soll-korrigiert) 2 1)))) + (princ (ssg-textf "vfl-m3-abweichung-es-korrigiert" + (list (rtos (- (car ist-ende) (car soll-korrigiert)) 2 1) + (rtos (- (cadr ist-ende) (cadr soll-korrigiert)) 2 1) + (rtos (- (caddr ist-ende) (caddr soll-korrigiert)) 2 1)))) (princ "\n=========================================") (if dbg-an diff --git a/Lisp/vf_spec.lsp b/Lisp/vf_spec.lsp index 67b48ec..bd8fe61 100644 --- a/Lisp/vf_spec.lsp +++ b/Lisp/vf_spec.lsp @@ -1,7 +1,7 @@ ;; ============================================================ ;; vf_spec.lsp - VF-Linienzug aus Eingabedaten bauen (ohne GUI/Konsole) ;; ============================================================ -;; Stufe 1 des Fahrplans in doc/TODO-plan-vf-interactive.md. +;; Stufe 1 des Fahrplans in doc/todo/plan-vf-interactive.md. ;; ;; Eine SPEC beschreibt eine Kette in Domaenenwerten ("links", "winkel", ;; "aussen", ja/nein) statt in Menue-Codes: lesbar, schreibbar, versionierbar. @@ -903,15 +903,28 @@ ;; abgebrochene Kette bleibt also als lose Geometrie liegen und ist per ;; c:VF_SEKTION_RESTORE rettbar (vfl-segment-xdata-sichern hat pro Iteration ;; schon SSG_VF_EDIT_SEG/_PRE geschrieben). -(defun vsp-bau-aus-spec (spec / kopf sid journal rec vor-ent alt-error err - offen hl meld ist-glieder soll-glieder diff - ist-journal jdiff ent ed dim) +(defun vsp-bau-aus-spec (spec / kopf journal) (setq kopf (vsp-kopf spec)) - (setq sid (vsp-spec-id kopf)) + ;; vsp-journal sammelt seine Fehler in *vsp-fehler* - darum erst danach lesen. (setq journal (vsp-journal spec)) + (vsp-bau-journal (vsp-spec-id kopf) journal (ssg-val kopf "dim") *vsp-fehler*)) + +;; Eine Kette aus einem fertigen Eingabe-Journal bauen (Liste (art . wert) in +;; Bau-Reihenfolge, wie vfl-journal-replay-start sie erwartet). Gemeinsamer +;; Kern fuer Specs (vsp-bau-aus-spec, Journal per vsp-journal uebersetzt) und +;; fuer UNVERAENDERT uebernommene Aufzeichnungen - z.B. die SSG_VF_EDIT-XDATA +;; eines von Hand gebauten VF_n (tests/test_dematic_arvato.lsp, Journal per +;; vfl-string->entry gelesen). Letztere brauchen keinen Uebersetzer und +;; laufen darum auch dann, wenn der Dialog neuer ist als die Spec-Grammatik. +;; sid = Kennung im Record, dim = "2D"/"3D" oder nil (Sitzung), +;; fehler = Liste der Spec-Fehler (bei nil-Journal die Begruendung). +;; Erwartet den Headless-Rahmen (vsp-headless-an) beim Aufrufer. +(defun vsp-bau-journal (sid journal dim fehler / rec vor-ent alt-error err + offen hl meld ist-glieder soll-glieder diff + ist-journal jdiff ent ed) (setq soll-glieder (if journal (vfl-journal-glieder journal) nil)) (setq rec (vsp-rec-neu sid)) - (setq rec (vsp-set rec "spec_fehler" *vsp-fehler*)) + (setq rec (vsp-set rec "spec_fehler" fehler)) (setq rec (vsp-set rec "glieder_soll" soll-glieder)) (setq rec (vsp-set rec "eingaben_gesamt" (if journal (length journal) 0))) (princ (strcat "\n [SPEC] " sid)) @@ -919,9 +932,9 @@ (cond ;; --- Spec fehlerhaft: nichts bauen --- ((null journal) - (princ (strcat "\n " (itoa (length *vsp-fehler*)) + (princ (strcat "\n " (itoa (length fehler)) " Spec-Fehler, nichts gebaut:")) - (foreach f *vsp-fehler* (princ (strcat "\n - " f))) + (foreach f fehler (princ (strcat "\n - " f))) (setq rec (vsp-set rec "status" "spec-fehler")) (setq rec (vsp-set rec "dimension" (vsp-dim-text))) rec) @@ -934,7 +947,7 @@ ;; Feld in der Spec. Ist keines gesetzt, gilt die Sitzung. (setq dim (if (and (boundp '*vsp-dim-override*) *vsp-dim-override*) *vsp-dim-override* - (ssg-val kopf "dim"))) + dim)) (if dim (setq *ssg-ils-dim* dim)) (setq rec (vsp-set rec "dimension" (vsp-dim-text))) (princ (strcat " -> " (itoa (length journal)) " Journal-Eintraege, " diff --git a/Lisp/vf_standard.lsp b/Lisp/vf_standard.lsp index 99e8daf..658bf1f 100644 --- a/Lisp/vf_standard.lsp +++ b/Lisp/vf_standard.lsp @@ -803,11 +803,26 @@ ;; ============================================================ ;; DCL-DIALOG (Standardfall) - dcl/variofoerderer.dcl -;; Ersetzt die interaktive Werteingabe aus vf-eingabe-abfragen -;; (Konsolen-Modus "Werteingabe") fuer anlage-typ "standard" durch -;; zwei DCL-Dialoge: Basis-Eingabe und Winkel/Verteilung. Die -;; 3D-Linie-Eingabe sowie die Typen "etage"/"linienzug" bleiben -;; unveraendert interaktiv (siehe Verzweigung in c:VarioFoerderer). +;; Ersetzt die frueher komplett interaktive Werteingabe fuer anlage-typ +;; "standard" durch zwei DCL-Dialoge: Basis-Eingabe und Winkel/Verteilung. +;; Beide Eingabemodi (3D-Linie UND Werteingabe, siehe vf-dialog-ablauf in +;; vf_core.lsp) laufen seitdem ueber denselben Basis-Dialog - bei 3D-Linie +;; nur mit deltaL/deltaH/Richtung/Einfuegehoehe vorbelegt. Nur der Typ +;; "linienzug" bleibt unveraendert interaktiv (siehe Verzweigung in +;; c:VarioFoerderer). +;; +;; Beide Dialoge existieren je in zwei Varianten: +;; -popup (Dropdowns, urspruengliche Implementierung, unveraendert) und +;; -radio (Radio-Buttons statt Dropdown). Radio-Button-Labels lassen sich +;; nach new_dialog nicht per set_tile aendern (DCL-Limitierung) - die +;; -radio-Varianten loesen das, indem sie ihre DCL-Datei bei JEDEM Aufruf +;; frisch per ssg-dcl-temp-schreiben (ssg_core.lsp) schreiben und die +;; Labels dabei direkt mit dem schon von ssg-text/ssg-textf aufgeloesten +;; String befuellen - funktioniert dadurch in jeder Sprache, keine +;; Sprachweiche noetig (anders als vfc-dialog-typ-waehlen). Die +;; namenlosen Dispatcher-Funktionen (ohne Suffix) bevorzugen -radio und +;; fallen nur bei einem technischen Fehler (Temp-Datei nicht schreibbar/ +;; ladbar, Sentinel 'FEHLER) auf -popup zurueck. ;; ============================================================ ;; Bau-Parameter eines bestehenden VF_n-Blocks aus XDATA + Attributen lesen - @@ -846,14 +861,76 @@ (cons "hz" hz) (cons "z-start" z-start))) -;; Basis-Eingabe (Dialog 1): deltaL, deltaH, Richtung, Einfuegehoehe, -;; Fahrtrichtung, Seite, Geruest fuer Einzelmodul, Geruestoption. +;; Baut die DCL-Zeilen einer boxed_radio_column mit einem radio_button pro +;; Eintrag in "labels" (Tile-Keys "_0".."_(n-1)"). labels +;; sind bereits fertige, uebersetzte Strings (ssg-text/ssg-textf) - werden +;; hier nur noch fuer die DCL-Syntax escaped (ssg-dcl-label-escape). +;; Genutzt von vfs-dialog-eingabe-basis-radio fuer die drei verbleibenden +;; Radio-Gruppen (Seite, Motorseite, Geruestoption). +(defun vfs-dcl-radio-gruppe-zeilen (prefix box-label labels / zeilen i) + (setq zeilen (list + ": boxed_radio_column {" + (strcat " label = \"" (ssg-dcl-label-escape box-label) "\";") + (strcat " key = \"" prefix "\";"))) + (setq i 0) + (foreach lbl labels + (setq zeilen (append zeilen (list + (strcat " : radio_button { key = \"" prefix "_" (itoa i) "\"; label = \"" + (ssg-dcl-label-escape lbl) "\"; }")))) + (setq i (1+ i)) + ) + (append zeilen (list "}")) +) + +;; Baut das (cond ...)-Fragment (als String), das innerhalb eines +;; action_tile-Callbacks den gewaehlten Index 0..(n-1) einer per +;; vfs-dcl-radio-gruppe-zeilen erzeugten Gruppe ermittelt. n ist die +;; tatsaechliche Options-Anzahl zum Generierungszeitpunkt - dadurch bleibt +;; z.B. die Geruesttyp- oder Winkel-Gruppe korrekt, auch wenn deren Anzahl +;; sich einmal aendert (kein hartkodiertes "_1"/"_2"/"_3" im Aufrufer). +(defun vfs-dcl-radio-idx-cond (prefix n / s i) + (setq s "(cond " i 1) + (while (< i n) + (setq s (strcat s "((= (get_tile \"" prefix "_" (itoa i) "\") \"1\") " (itoa i) ")")) + (setq i (1+ i)) + ) + (strcat s "(t 0))") +) + +;; L_GF1/L_GF2 aus dem gewaehlten Verteilungsmodus ("0".."3") berechnen - +;; gemeinsam genutzt von der Popup- UND der Radio-Variante von +;; vfs-dialog-winkel-verteilung (frueher inline in beiden dupliziert). +;; Rueckgabe: (L_GF1 L_GF2). +(defun vfs-verteilung-berechnen (verteilung-modus L_GF staustrecke-basis lgf1-manuell-str / + L_GF1 L_GF2) + (cond + ((= verteilung-modus "0") + (setq L_GF1 (/ L_GF 2.0) L_GF2 (/ L_GF 2.0))) + ((= verteilung-modus "1") + (setq L_GF1 (float staustrecke-basis)) + (setq L_GF2 (max 0.0 (- L_GF (float staustrecke-basis))))) + ((= verteilung-modus "2") + (setq L_GF2 (float staustrecke-basis)) + (setq L_GF1 (max 0.0 (- L_GF (float staustrecke-basis))))) + ((= verteilung-modus "3") + (setq L_GF1 (atof lgf1-manuell-str)) + (if (or (null L_GF1) (< L_GF1 0)) (setq L_GF1 (/ L_GF 2.0))) + (if (> L_GF1 L_GF) (setq L_GF1 L_GF)) + (setq L_GF2 (max 0.0 (- L_GF L_GF1)))) + (t (setq L_GF1 (/ L_GF 2.0) L_GF2 (/ L_GF 2.0))) + ) + (list L_GF1 L_GF2) +) + +;; Basis-Eingabe (Dialog 1, Popup-Variante): deltaL, deltaH, Richtung, +;; Einfuegehoehe, Fahrtrichtung, Seite, Geruest fuer Einzelmodul, +;; Geruestoption. ;; prefill: Assoziationsliste zur Vorbelegung (fuer VARIOFOERDERER_EDIT) mit ;; Schluesseln "deltaL" "deltaH" "richtung" "einfuegehoehe" "hz" "seite" ;; "geruest-einzelmodul" "geruest-typ" - oder nil fuer Neuanlage mit Defaults. ;; Rueckgabe: (deltaL deltaH richtung einfuegehoehe hz seite ;; geruest-einzelmodul geruest-typ) oder nil bei Abbruch. -(defun vfs-dialog-eingabe-basis (prefill / dcl-pfad dat ergebnis +(defun vfs-dialog-eingabe-basis-popup (prefill / dcl-pfad dat ergebnis dlg-deltal dlg-deltah dlg-richtung dlg-hoehe dlg-fahrtrichtung dlg-seite dlg-motorseite dlg-dimension dlg-geruest-einzelmodul dlg-geruest-typ @@ -973,17 +1050,189 @@ ) ) -;; Winkel/Verteilung-Eingabe (Dialog 2): Winkel-Popup aus den vorher +;; Basis-Eingabe (Dialog 1, dynamische Variante) - siehe Kopfkommentar +;; des DCL-DIALOG-Abschnitts. Nur "Seite", "Motorseite" und "Geruestoption" +;; bleiben als Radio-Button-Gruppen (alle Optionen sofort sichtbar); alle +;; anderen Felder (Foerderrichtung, Fahrtrichtung, Darstellung 2D/3D) sind +;; wieder Comboboxen (popup_list), wie der uebrige Dialog. Gleiche +;; prefill-Struktur/Rueckgabe wie -popup; 'FEHLER bei technischem Fehler +;; (Dispatcher faellt dann zurueck). +(defun vfs-dialog-eingabe-basis-radio (prefill / zeilen dcl-pfad dat ergebnis + dlg-deltal dlg-deltah dlg-hoehe + dlg-richtung-idx dlg-fahrt-idx dlg-seite-idx + dlg-motorseite-idx dlg-dim-idx + dlg-geruest-einzelmodul dlg-geruest-typ-idx + deltaL deltaH richtung hz seite z-start dim + motorseite geruest-einzelmodul geruest-typ + sel-richtung sel-fahrt sel-seite sel-motorseite + sel-dim sel-geruest-typ n-geruest-typ) + ;; Vorbelegte Auswahl-Indizes aus prefill ableiten - gleiche Logik wie + ;; -popup, nur als Index statt als Popup-Tile-Wert. + (setq sel-richtung + (if (and prefill (equal (cdr (assoc "richtung" prefill)) "Ab")) 1 0)) + (setq sel-fahrt + (if prefill + (cond ((equal (cdr (assoc "hz" prefill)) 90.0 0.1) 1) + ((equal (cdr (assoc "hz" prefill)) 180.0 0.1) 2) + ((equal (cdr (assoc "hz" prefill)) 270.0 0.1) 3) + (t 0)) + 0)) + (setq sel-seite + (if (and prefill (equal (cdr (assoc "seite" prefill)) "links")) 1 0)) + (setq sel-motorseite + (if (and prefill (equal (cdr (assoc "motorseite" prefill)) "links")) 1 0)) + (setq sel-dim + (if (equal (cond ((cdr (assoc "dim" prefill))) ((ssg-ils-dim-aktuell))) "2D") 1 0)) + (setq n-geruest-typ (length *ssg-geruest-optionen*)) + (setq sel-geruest-typ + (ssg-geruest-typ-to-idx (if prefill (cdr (assoc "geruest-typ" prefill)) nil))) + + (setq zeilen (list + "vfs_basis_dyn : dialog {" + " label = \"VarioFoerderer (Standard) - Eingabe\";" + " : column {" + " : boxed_column {" + " label = \"Geometrie\";" + " : row {" + " : edit_box { key = \"deltal\"; label = \"Horizontale Distanz deltaL (mm):\"; edit_width = 10; }" + " : popup_list { key = \"richtung\"; label = \"Foerderrichtung:\"; width = 16; }" + " }" + " : row {" + " : edit_box { key = \"einfuegehoehe\"; label = \"Einfuegehoehe (mm):\"; edit_width = 10; }" + " : edit_box { key = \"deltah\"; label = \"Hoehenunterschied deltaH (mm):\"; edit_width = 10; }" + " }" + " }" + " : boxed_column {" + " label = \"Ausrichtung\";" + " : popup_list { key = \"fahrtrichtung\"; label = \"Fahrtrichtung:\"; width = 30; }" + " : row {")) + (setq zeilen (append zeilen + (vfs-dcl-radio-gruppe-zeilen "seite" "Seite:" + (list (ssg-text "gf-dlg-rechts") (ssg-text "gf-dlg-links"))))) + (setq zeilen (append zeilen + (vfs-dcl-radio-gruppe-zeilen "motorseite" "Motorseite:" + (list (ssg-text "gf-dlg-rechts") (ssg-text "gf-dlg-links"))))) + (setq zeilen (append zeilen (list + " }" + " : popup_list { key = \"dimension\"; label = \"Darstellung (2D/3D):\"; width = 20; }" + " }" + " : boxed_column {" + " label = \"Geruest\";" + " : toggle { key = \"geruest_einzelmodul\"; label = \"Geruest fuer Einzelmodul\"; }"))) + (setq zeilen (append zeilen + (vfs-dcl-radio-gruppe-zeilen "geruest_typ" "Geruestoption:" *ssg-geruest-optionen*))) + (setq zeilen (append zeilen (list + " }" + " }" + " ok_cancel;" + "}"))) + + (setq dcl-pfad (ssg-dcl-temp-schreiben "vfsbasis" zeilen)) + (if (null dcl-pfad) + 'FEHLER + (progn + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "vfs_basis_dyn" dat)) + (progn + (if (and dat (>= dat 0)) (unload_dialog dat)) + (vl-file-delete dcl-pfad) + 'FEHLER + ) + (progn + (set_tile "deltal" (if prefill (rtos (cdr (assoc "deltaL" prefill)) 2 0) "15000")) + (set_tile "deltah" (if prefill (rtos (cdr (assoc "deltaH" prefill)) 2 0) "3000")) + (set_tile "einfuegehoehe" (if prefill (rtos (cdr (assoc "einfuegehoehe" prefill)) 2 1) "0")) + + (start_list "richtung") + (add_list (ssg-text "vfs-dlg-richtung-auf")) + (add_list (ssg-text "vfs-dlg-richtung-ab")) + (end_list) + (set_tile "richtung" (itoa sel-richtung)) + + (start_list "fahrtrichtung") + (add_list (ssg-textf "gf-dlg-richtung-0" (list grad-zeichen))) + (add_list (ssg-textf "gf-dlg-richtung-90" (list grad-zeichen))) + (add_list (ssg-textf "gf-dlg-richtung-180" (list grad-zeichen))) + (add_list (ssg-textf "gf-dlg-richtung-270" (list grad-zeichen))) + (end_list) + (set_tile "fahrtrichtung" (itoa sel-fahrt)) + + (set_tile (strcat "seite_" (itoa sel-seite)) "1") + (set_tile (strcat "motorseite_" (itoa sel-motorseite)) "1") + + (start_list "dimension") + (add_list "3D") + (add_list "2D") + (end_list) + (set_tile "dimension" (itoa sel-dim)) + + (set_tile "geruest_einzelmodul" + (if (or (null prefill) (equal (cdr (assoc "geruest-einzelmodul" prefill)) "1")) "1" "0")) + (set_tile (strcat "geruest_typ_" (itoa sel-geruest-typ)) "1") + + (action_tile "accept" + (strcat + "(setq dlg-deltal (get_tile \"deltal\"))" + "(setq dlg-deltah (get_tile \"deltah\"))" + "(setq dlg-hoehe (get_tile \"einfuegehoehe\"))" + "(setq dlg-richtung-idx (atoi (get_tile \"richtung\")))" + "(setq dlg-fahrt-idx (atoi (get_tile \"fahrtrichtung\")))" + "(setq dlg-seite-idx " (vfs-dcl-radio-idx-cond "seite" 2) ")" + "(setq dlg-motorseite-idx " (vfs-dcl-radio-idx-cond "motorseite" 2) ")" + "(setq dlg-dim-idx (atoi (get_tile \"dimension\")))" + "(setq dlg-geruest-einzelmodul (get_tile \"geruest_einzelmodul\"))" + "(setq dlg-geruest-typ-idx " (vfs-dcl-radio-idx-cond "geruest_typ" n-geruest-typ) ")" + "(done_dialog 1)" + ) + ) + (action_tile "cancel" "(done_dialog 0)") + + (setq ergebnis (start_dialog)) + (unload_dialog dat) + (vl-file-delete dcl-pfad) + + (if (= ergebnis 1) + (progn + (setq deltaL (atof dlg-deltal)) + (setq deltaH (atof dlg-deltah)) + (setq richtung (nth dlg-richtung-idx '("Auf" "Ab"))) + (setq z-start (atof dlg-hoehe)) + (setq hz (nth dlg-fahrt-idx '(0.0 90.0 180.0 270.0))) + (setq seite (nth dlg-seite-idx '("rechts" "links"))) + (setq motorseite (nth dlg-motorseite-idx '("rechts" "links"))) + (setq dim (nth dlg-dim-idx '("3D" "2D"))) + (setq geruest-einzelmodul dlg-geruest-einzelmodul) + (setq geruest-typ (ssg-geruest-idx-to-typ dlg-geruest-typ-idx)) + (list deltaL deltaH richtung z-start hz seite dim geruest-einzelmodul geruest-typ motorseite) + ) + nil + ) + ) + ) + ) + ) +) + +;; Dispatcher: bevorzugt die dynamisch generierte Variante (Seite/ +;; Motorseite/Geruestoption als Radio, Rest als Combobox - siehe +;; Kopfkommentar des DCL-DIALOG-Abschnitts), Rueckfall auf die reine +;; Popup-Variante nur bei technischem Fehler. +(defun vfs-dialog-eingabe-basis (prefill / ergebnis) + (setq ergebnis (vfs-dialog-eingabe-basis-radio prefill)) + (if (eq ergebnis 'FEHLER) (vfs-dialog-eingabe-basis-popup prefill) ergebnis) +) + +;; Winkel/Verteilung-Eingabe (Dialog 2, Popup-Variante): Winkel-Popup aus den vorher ;; berechneten gueltigen Varianten (gueltige-winkel/ergebnis-liste, siehe ;; berechne-alle-winkel), plus L_GF-Verteilung vorne/hinten (analog Schritt ;; 8+9 in c:VarioFoerderer). ;; prefill: Assoziationsliste ("winkel" . best-winkel) ("verteilung-idx" . "0".."3") ;; ("lgf1" . mm) - oder nil fuer Vorbelegung mit dem kleinsten gueltigen Winkel. ;; Rueckgabe: (best-winkel L_GF L_VF L_GF1 L_GF2 verteilung-modus) oder nil bei Abbruch. -(defun vfs-dialog-winkel-verteilung (gueltige-winkel ergebnis-liste staustrecke-basis prefill / +(defun vfs-dialog-winkel-verteilung-popup (gueltige-winkel ergebnis-liste staustrecke-basis prefill / dcl-pfad dat ergebnis w eintrag idx sel-idx init-verteilung dlg-winkel dlg-verteilung dlg-lgf1 - best-winkel L_GF L_VF verteilung-modus L_GF1 L_GF2) + best-winkel L_GF L_VF verteilung-modus L_GF1 L_GF2 lgf-paar) (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/variofoerderer.dcl")) (setq dat (load_dialog dcl-pfad)) (if (not (new_dialog "variofoerderer_winkel" dat)) @@ -1052,22 +1301,8 @@ (setq eintrag (assoc best-winkel ergebnis-liste)) (setq L_GF (nth 1 eintrag) L_VF (nth 2 eintrag)) (setq verteilung-modus dlg-verteilung) - (cond - ((= verteilung-modus "0") - (setq L_GF1 (/ L_GF 2.0) L_GF2 (/ L_GF 2.0))) - ((= verteilung-modus "1") - (setq L_GF1 (float staustrecke-basis)) - (setq L_GF2 (max 0.0 (- L_GF (float staustrecke-basis))))) - ((= verteilung-modus "2") - (setq L_GF2 (float staustrecke-basis)) - (setq L_GF1 (max 0.0 (- L_GF (float staustrecke-basis))))) - ((= verteilung-modus "3") - (setq L_GF1 (atof dlg-lgf1)) - (if (or (null L_GF1) (< L_GF1 0)) (setq L_GF1 (/ L_GF 2.0))) - (if (> L_GF1 L_GF) (setq L_GF1 L_GF)) - (setq L_GF2 (max 0.0 (- L_GF L_GF1)))) - (t (setq L_GF1 (/ L_GF 2.0) L_GF2 (/ L_GF 2.0))) - ) + (setq lgf-paar (vfs-verteilung-berechnen verteilung-modus L_GF staustrecke-basis dlg-lgf1)) + (setq L_GF1 (car lgf-paar) L_GF2 (cadr lgf-paar)) (list best-winkel L_GF L_VF L_GF1 L_GF2 verteilung-modus) ) nil @@ -1076,6 +1311,14 @@ ) ) +;; Winkel/Verteilung-Eingabe: Dialog nutzt durchgaengig Comboboxen +;; (variofoerderer_winkel in dcl/variofoerderer.dcl) - keine Radio-Variante +;; mehr noetig, da weder "winkel" noch "verteilung" als Radio bleiben +;; (siehe Kopfkommentar des DCL-DIALOG-Abschnitts). +(defun vfs-dialog-winkel-verteilung (gueltige-winkel ergebnis-liste staustrecke-basis prefill) + (vfs-dialog-winkel-verteilung-popup gueltige-winkel ergebnis-liste staustrecke-basis prefill) +) + ;; ============================================================ ;; XDATA-Metadaten fuer den Edit-Nachbau (App "SSG_VF_EDIT"). ;; Markiert ein VF_n-INSERT als "mit dem Standard-Dialog erstellt" und @@ -1310,6 +1553,38 @@ ;; Neuanlage 0). Wer hz nicht kennt: der Wert steht in der urspruenglichen ;; Bau-Eingabe (z.B. mubea.json "hz") bzw. ergibt sich aus der Ausrichtung. ;; Bereits markierte Bloecke und Nicht-VF-Bloecke werden uebersprungen. + +;; Baurichtung (hz) fuer EINEN Fund per Dialog abfragen - ersetzt den +;; frueheren getreal-Prompt in c:VARIOFOERDERER_NACHRUESTEN. "kopf" per +;; set_tile aus ssg-text befuellt (Blockname + erkannter Typ), deshalb +;; sprachunabhaengig. Rueckgabe: hz (Real) bei OK, 'ABBRUCH wenn der Nutzer +;; bewusst abbricht (Aufrufer uebernimmt dann default-hz, OHNE nochmal auf +;; der Konsole zu fragen), nil wenn der Dialog gar nicht gezeigt werden +;; konnte/durfte (GUI aus) - NUR dann faellt der Aufrufer auf den alten +;; getreal-Prompt zurueck. +(defun vfs-dialog-nachruesten-hz (bname typ default-hz / dcl-pfad dat ergebnis hz) + (if (or (not (car (atoms-family 1 '("SSG-GUI-P")))) (ssg-gui-p)) + (progn + (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/variofoerderer.dcl")) + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "vfs_nachruesten_hz" dat)) + (progn (if (and dat (>= dat 0)) (unload_dialog dat)) nil) + (progn + (set_tile "kopf" (ssg-textf "vfs-nachruesten-erkannt" (list bname typ))) + (set_tile "hz" (rtos default-hz 2 1)) + (action_tile "accept" + "(setq hz (distof (get_tile \"hz\") 2)) (done_dialog 1)") + (action_tile "cancel" "(done_dialog 0)") + (setq ergebnis (start_dialog)) + (unload_dialog dat) + (cond ((and (= ergebnis 1) hz) hz) (t 'ABBRUCH)) + ) + ) + ) + nil + ) +) + (defun c:VARIOFOERDERER_NACHRUESTEN ( / ss i ent ed bname attribs xd typ hz n-neu n-skip default-hz) (ssg-start "VARIOFOERDERER_NACHRUESTEN" nil) @@ -1337,8 +1612,14 @@ (if (or (assoc "GF_Bogen_R_60" attribs) (assoc "GF_Bogen_L_60" attribs)) "etage" "standard")) (princ (ssg-textf "vfs-nachruesten-erkannt" (list bname typ))) - (setq hz (getreal (ssg-textf "vfs-nachruesten-prompt-hz" (list (rtos default-hz 2 1))))) - (if (null hz) (setq hz default-hz)) + (setq hz (vfs-dialog-nachruesten-hz bname typ default-hz)) + (cond + ((eq hz 'ABBRUCH) (setq hz default-hz)) + ((null hz) + (setq hz (getreal (ssg-textf "vfs-nachruesten-prompt-hz" (list (rtos default-hz 2 1))))) + (if (null hz) (setq hz default-hz)) + ) + ) (setq default-hz hz) (vf-edit-xdata-schreiben ent typ hz) (princ (ssg-textf "vfs-nachruesten-markiert" (list (rtos hz 2 1)))) diff --git a/README.md b/README.md index 9f9bdfc..9715b25 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # dxfmakros -AutoLISP-Makros fuer BricsCAD Pro zur automatisierten Erstellung von Foerderanlagen- und Kreisel-Layouts. +AutoLISP-Makros (SSG_LIB) fuer BricsCAD Pro zur automatisierten Erstellung von Foerderanlagen-Layouts (ILS Kreisel, Omniflo, VarioFoerderer, Gefaellestrecke, Geruest). ## Menustruktur (SSG_LIB) @@ -14,164 +14,70 @@ SSG_LIB │ │ └── Eckrad → ILS_Eckrad │ ├── Zusatzmodul │ │ ├── BTMT-Beladung → ILS_BTMT_Beladung -│ │ └── BTMT-Entladung → ILS_BTMT_Entladung +│ │ ├── BTMT-Entladung → ILS_BTMT_Entladung +│ │ ├── Scanner einfuegen → ILS_SCANNER_INSERT +│ │ └── Separator einfuegen → ILS_SEPARATOR_INSERT │ ├── Foerderer -│ │ ├── VarioFoerderer → FOERDERANLAGE -│ │ └── Gefaellestrecke → ILS_G{K90,K60,K30}{L,R} -│ └── ILS Schliessen +│ │ ├── Standard → StandardVarioFoerderer / StandardVarioFoerderer3D +│ │ ├── Etage → EtageVarioFoerderer / EtageVarioFoerderer3D +│ │ ├── Streckengruppe (Linienzug) → LinienzugVarioFoerdererManuell / -Zielhoehe / -Stueckweise +│ │ └── Vario_Kette_Merge / VARIOFOERDERER_NACHRUESTEN +│ └── Gefaellestrecke +│ ├── einfach → GEFAELLESTRECKE_EINFACH +│ ├── aus 3D-Linie → GEFAELLESTRECKE_3DLINIE +│ └── aus Linienzug → GEFAELLESTRECKE_LINIENZUG ├── Omniflo -│ ├── Boegen -│ │ ├── 90 → OMNI_APB_630_90 -│ │ ├── 67.5 → OMNI_APB_550_675 -│ │ ├── 45 → OMNI_APB_630_45 -│ │ ├── 22.5 → OMNI_APB_550_225 -│ │ └── 180 → OMNI_APB_650_180 -│ ├── Aluprofil Gerade -│ │ ├── AP 60 → OMNI_AP60 -│ │ ├── AP 110 → OMNI_AP110 -│ │ └── APG 110 → OMNI_APG110 -│ ├── Weiche 90 Grad -│ │ ├── Einfach → OMNI_W90_Einfach -│ │ ├── Doppel → OMNI_W90_Doppel -│ │ └── Dreiwege → OMNI_W90_Dreiwege -│ ├── Weiche 45 Grad -│ │ ├── Einfach → OMNI_W45_Einfach -│ │ ├── Doppel → OMNI_W45_Doppel -│ │ └── Dreiwege → OMNI_W45_Dreiwege -│ ├── Weichen Parallel -│ │ ├── Einfach → OMNI_WP_Einfach -│ │ ├── Doppel → OMNI_WP_Doppel -│ │ └── Dreiwege → OMNI_WP_Dreiwege -│ ├── Weichenkoerper -│ │ ├── Einfach → OMNI_WK_Einfach -│ │ ├── Doppel → OMNI_WK_Doppel -│ │ └── Dreiwege → OMNI_WK_Dreiwege -│ ├── Weichenkombinationen -│ │ ├── Delta 1400/700 → OMNI_WKomb_Delta_1400 -│ │ ├── Delta 1600/800 → OMNI_WKomb_Delta_1600 -│ │ └── Star → OMNI_WKomb_Star -│ ├── TEF Elemente -│ │ ├── Umlenkspannst. rechts → OMNI_TEF_UmlenkR -│ │ ├── Umlenkspannst. links → OMNI_TEF_UmlenkL -│ │ ├── Antriebst. links → OMNI_TEF_AntriebL -│ │ ├── Antriebst. rechts → OMNI_TEF_AntriebR -│ │ └── TEF Gerade → OMNI_TEF_Gerade -│ ├── KettenFoerderer → OMNI_KettenFoerderer -│ └── Ladeschleifen -│ └── AP 110 → OMNI_LADESCHLEIFE_AP110 +│ ├── Boegen APB110/APB60 +│ ├── Aluprofil Gerade (AP60/AP110/APG110) +│ ├── Weichen (90/45/Parallel/Weichenkoerper/Weichenkombinationen) +│ ├── TEF Elemente, Anbaugruppen, Verbinder, Boegen fuer Weichen +│ ├── Element bearbeiten → OMNI_EDIT +│ └── Ladeschleifen (AP110) → OMNI_LADESCHLEIFE_AP110 +├── Geruest +│ ├── Rohr-Geruest-Traeger → GERUEST_TRAEGER +│ ├── Saeulen / Rohrabhaenger / Wandbefestigung → GERUEST +│ └── Funktionen ▸ Traeger beschriften → GERUEST_TRAEGER_BESCHRIFTEN +├── SPS +│ ├── TRO (Marker einfuegen/bearbeiten) → TRO_INSERT / TRO_EDIT +│ └── Connections (einfuegen/bearbeiten, Eingang/Ausgang) → CONNECTION_INSERT / CONNECTION_EDIT / ILS_EINGANG_INSERT / ILS_AUSGANG_INSERT +├── Export +│ ├── Export Sivas → EXPORTSIVAS +│ └── Export CSV → EXPORTCSV ├── Konfiguration │ ├── Umschalten 2D und 3D → SSG_DIM_SWITCH -│ └── Sprache → SSG_SPRACHE -└── External - ├── Call Python → CALLPYTHON - ├── Export Sivas → EXPORTSIVAS - └── Export CSV → EXPORTCSV +│ ├── Sprache → SSG_SPRACHE +│ └── Planquadrate an/aus → PLANQUADRATE_TOGGLE +├── Werkzeuge +│ ├── Bloecke zaehlen/loeschen, Attribute ersetzen → ssg_blocktools +│ └── Text ersetzen/parallel/Hoehe/Stil → ssg_texttools +└── Tests (Testsuiten ausfuehren und exportieren) ``` -## Befehle nach Modul +Vollstaendige, laufend aktualisierte Befehls-/Modulzuordnung: siehe `CLAUDE.md` (Abschnitt "Modulzuordnung im Menue") und `menu/SSG_LIB.mnu`. -### KreiselInsert.lsp - Kreisel Modul-Einfuegesystem +## Lademechanismus -Zeichnet ILS-Kreiselmodule als Compound-Bloecke mit konfigurierbarem Abstand, Typ und Attributen. +Module werden per Lazy-Loading ueber das Menuesystem geladen (`ssg-ensure` in `SSG_LIB.mnl`). Einmalige Einrichtung pro BricsCAD-Installation: -| Befehl | Beschreibung | -| --- | --- | -| `KreiselInsert` | Modul an manuell gewaehltem Punkt einfuegen (Abstand, Drehung, Hoehe, Typ interaktiv) | -| `KreiselConnect` | Smart Connect: Kreisel zwischen zwei parallelen Linien einfuegen, berechnet Position/Abstand/Rotation automatisch | -| `KreiselEdit` | Bestehenden Kreisel per DCL-Dialog bearbeiten (Name, Abstand, Hoehe, Ausrichtung, Drehrichtung, Typ) | -| `KreiselRedraw` | Kreisel mit optionalem neuem Abstand/Hoehe neu zeichnen, Attribute bleiben erhalten | -| `KreiselQuick` | Schnelleinfuegen mit Standardparametern (horizontal) | -| `KreiselParams` | Aktuelle Kreisel-Parameterkonfiguration anzeigen | -| `ILS_Eckrad` | Einzelnen AN8-Block (Antriebs-/Eckrad) an gewaehltem Punkt einfuegen | -| `KreiselLabelPos` | Label-Position (X/Y-Offset) konfigurieren | -| `KreiselLabelHoehe` | Label-Texthoehe konfigurieren | -| `KreiselLabelSetup` | Label-Darstellung konfigurieren (Hoehe, Farbe, Abstand, Schriftart) | +1. `bin/setenv.bat` ausfuehren (setzt `DXFM_LISP` u.a.) +2. BricsCAD starten +3. In der Kommandozeile `_MENULOAD` eingeben, `menu/SSG_LIB.mnu` auswaehlen -### OmniModulInsert.lsp - Omniflo Komponenten - -Einfuegen von Omniflo-Standardkomponenten (Boegen, Geraden, Weichen, TEF-Elemente). - -| Befehl | Beschreibung | -| --- | --- | -| `OMNI_LOAD` | Omniflo-Komponentendaten aus JSON-Dateien laden | -| `OMNI_INFO_BOGEN` | Info zu einem Omniflo-Bogen nach Sivas-ID anzeigen | -| `OMNI_INFO_WEICHE` | Info zu einer Omniflo-Weiche nach Sivas-ID anzeigen | -| `OMNI_APB_*` | Boegen einfuegen (90, 67.5, 45, 22.5, 180 Grad) | -| `OMNI_AP60/AP110/APG110` | Aluprofil-Geraden einfuegen | -| `OMNI_W90/W45/WP/WK_*` | Weichen einfuegen (Einfach, Doppel, Dreiwege) | -| `OMNI_WKomb_Delta_1400/1600, OMNI_WKomb_Star` | Weichenkombinationen einfuegen | -| `OMNI_TEF_*` | TEF-Elemente einfuegen (Umlenk-/Antriebsstationen, Gerade) | -| `OMNI_KettenFoerderer` | Kettenfoerderer einfuegen | -| `OMNI_LADESCHLEIFE_AP110` | Ladeschleife (AP 110) ueber DCL-Dialog einfuegen | - -### VarioFoerderer.lsp - Foerderanlage Generator (v24.4) - -Generiert komplette Vario-Foerderanlagen mit Vertikalboegen, Motor-/Spannstationen, Staustrecken und Ein-/Ausschleus-Elementen. - -| Befehl | Beschreibung | -| --- | --- | -| `FOERDERANLAGE` | Interaktiver Generator: Zwei Punkte oder manuelle Distanz/Hoehe, berechnet optimalen Bogenwinkel | -| `FOERDERTEST` | Automatischer Testlauf (Distanz=6000, Hoehe=2000, Richtung=Auf), speichert als DXF | - -Unterstuetzte Bogenwinkel: 3, 9, 12, 15, 24, 36, 48 Grad - -### ssg_layer.lsp - Layerverwaltung - -| Befehl | Beschreibung | -| --- | --- | -| `SSG-LayerSet` | Objekt anklicken, dessen Layer wird aktiv | -| `SSG-LayerInfo` | Layer eines angeklickten Objekts anzeigen | -| `SSG-LayerMove` | Selektierte Objekte auf Ziel-Layer verschieben | -| `SSG-LayerCopy` | Selektierte Objekte auf Ziel-Layer kopieren | -| `SSG-LayerMoveType` | Alle Objekte gleichen Typs von Referenz- auf Ziel-Layer verschieben | -| `SSG-LayerOff` | Layer per Klick ausschalten (mehrfach moeglich) | -| `SSG-LayerFreeze` | Layer per Klick einfrieren (mehrfach moeglich) | -| `SSG-FreezeAll` | Alle Layer ausser dem angeklickten einfrieren | -| `SSG-ThawAll` | Alle eingefrorenen Layer auftauen | -| `SSG-LayerOnAll` | Alle ausgeschalteten Layer einschalten | -| `SSG-LayerDelete` | Layer und alle Objekte darauf loeschen (mit Bestaetigung) | - -### SSG_LIB_Commands.lsp - Konfiguration - -| Befehl | Beschreibung | -| --- | --- | -| `SSG_DIM_SWITCH` | Schaltet zwischen 2D- und 3D-Bloecken um | -| `SSG_SPRACHE` | Sprache umschalten (Deutsch/Englisch), persistiert ueber `DXFM_LANG` | - -### tests.lsp - Export und Python-Integration - -| Befehl | Beschreibung | -| --- | --- | -| `CALLPYTHON` | Python-Skripte via CLI aufrufen, Ausgabe loggen | -| `EXPORTSIVAS` | Daten im Sivas-Format exportieren | -| `EXPORTCSV` | Zeichnungsdaten als CSV exportieren | - -## Kernbibliotheken (Lisp/) - -| Datei | Beschreibung | -| --- | --- | -| `ssg_core.lsp` | Kernel: Umgebung, Layer-Ops, Block-Ops, Attribut-Ops, Fehlerbehandlung | -| `ssg_lang.lsp` | Sprachumschaltung Deutsch/Englisch (`ssg-text`, `ssg-textf`, `*ssg-lang*`) | -| `ssg_dialog.lsp` | Dialog-Vorlagen: Slide-Preview, Modul-Dialog, Block-Einfuegesequenz | -| `ssg_layer.lsp` | Layer-Verwaltungsbefehle | -| `ssg_load.lsp` | Loader: Laedt alle SSG-Bibliotheken in korrekter Reihenfolge | -| `on_start.lsp` | Startup-Skript: Setzt Umgebung und laedt Libraries | +Details und die Core-Ladereihenfolge: siehe `CLAUDE.md` Abschnitt "Lademechanismus (Lazy Loading via MNL)". ## Projektstruktur ```text dxfmakros/ -├── Blocks/ # DWG-Bloecke (AN8, SP8, Vertikalboegen, etc.) -├── Lisp/ # AutoLISP-Makros und Kernbibliotheken -├── bin/ # Hilfs-Skripte (setenv, create_tests, etc.) -├── cfg/ # Konfigurationsdateien (export.cfg, block_suffix.cfg) -├── data/ # Quelldaten (JSON, DXF) - nicht im Git -├── dcl/ # DCL-Dialogdefinitionen (kreisel_edit.dcl) -├── doc/ # Dokumentation und Referenz-DXFs -├── examples/ # Beispieldateien -├── lib/ # Python-Skripte (export_csv.py, etc.) -├── logs/ # Logdateien - nicht im Git -├── menu/ # BricsCAD-Menudefinition (SSG_LIB.mnu) +├── Lisp/ # AutoLISP-Makros und Kernbibliotheken (Details: Lisp/README.md) +├── bin/ # Hilfs-Skripte (setenv.bat, start_briscad.bat) +├── cfg/ # Konfigurationsdateien +├── data/ # JSON-Daten, DXF-Quellen, Block-Libraries - nicht im Git +├── dcl/ # DCL-Dialogdefinitionen +├── doc/ # Dokumentation (doc/plan Architektur/Analysen, doc/todo offene Fahrplaene) +├── lib/ # Python-Skripte (DXF-Bearbeitung, Export) +├── log/ # Logdateien - nicht im Git +├── menu/ # BricsCAD-Menudefinition (SSG_LIB.mnu, SSG_LIB.mnl) ├── results/ # Ergebnisse / Exporte - nicht im Git ├── tests/ # Testskripte und Referenzdaten ├── LICENSE @@ -181,33 +87,34 @@ dxfmakros/ ## Umgebungsvariablen +Werden via `bin/setenv.bat` gesetzt. Wichtigste: + | Variable | Beschreibung | | --- | --- | | `DXFMAKRO` | Wurzelverzeichnis des Projekts | -| `DXFM_BLOCKS` | Pfad zum Blocks-Verzeichnis | -| `DXFM_LISP` | Pfad zu den LISP-Dateien | -| `DXFM_RESULTS` | Pfad fuer DXF-Exporte | -| `DXFM_BIN` | Skriptverzeichnis | -| `DXFM_LIB` | Python-Quellcode | -| `DXFM_CFG` | Konfigurationsdateien | -| `DXFM_TESTS` | Testverzeichnis | -| `DXFM_DATA` | Datenverzeichnis | +| `DXFM_LISP` | Pfad zu den LISP-Dateien (benoetigt fuer `ssg-ensure`) | +| `DXFM_BLOCKS` | Pfad zu DWG-Bloecken | +| `DXFM_DATA` | Datenverzeichnis (JSON, DXF) | +| `DXFM_LOG` | Log-Verzeichnis | +| `DXFM_DCL` | Pfad zu DCL-Dialogdateien | +| `DXFM_CFG` | Konfigurationsverzeichnis | | `DXFM_LANG` | Aktive Sprache (`de_DE`/`en_GB`), persistiert von `SSG_SPRACHE`; Default `de_DE` | -| `BRICSCAD` | Pfad zur BricsCAD-Executable | - -## Einrichtung - -1. `bin\setenv.bat` ausfuehren (setzt alle Umgebungsvariablen) -2. BricsCAD starten - `on_start.lsp` laedt alle Libraries automatisch via `startup.scr` -3. Menu `SSG_LIB` nutzen oder Befehle in der Kommandozeile ausfuehren +| `DXFM_VF_SPEC` | Spec-Datei fuer `VF_SPEC_BAU` (optional) | +| `BRICSCAD` | Pfad zur BricsCAD-Executable (fuer headless Testlauf) | ## Tests +Headless-Unit-Tests (file- und zeichnungsfrei): + ```bat -bin\create_tests.bat +bin\run_tests.bat --lisp ``` -Erzeugt eine Test-DXF, fuehrt Kreisel-Einfuege- und Exportbefehle aus, und validiert die Ergebnisse gegen Referenzdateien in `tests/references/`. +Zeichnungs-/Szenario-Tests laufen interaktiv in BricsCAD ueber das Menue `Tests` bzw. `SSG_RUN_ALL_TESTS`. Details: `doc/LispTests.md`, `tests/README.md`. + +## Dokumentation + +Ausfuehrliche Modul- und Befehlsdokumentation: `CLAUDE.md` (Projektanweisungen) und `Lisp/README.md`. Weitere Anwender-/Entwickler-Themen direkt in `doc/` (u.a. `variofoerderer.md`, `csv-export.md`, `faq.md`, `kommandos.md`). Architektur-Analysen und Planungsdokumente in `doc/plan/` (u.a. `translate.md`, `Entwicklungsplan.md`), offene Fahrplaene/TODOs in `doc/todo/`. ## Lizenz diff --git a/bin/dxf_anlage_export.bat b/bin/dxf_anlage_export.bat new file mode 100644 index 0000000..40952ca --- /dev/null +++ b/bin/dxf_anlage_export.bat @@ -0,0 +1,13 @@ +@echo off +REM ================================================================ +REM Mit unseren Makros gebaute (und von Hand nachbearbeitete) Anlage +REM aus einer Zeichnung in Nachbau-Testdaten zurueckschreiben. +REM Siehe doc/kommandos.md, doc/json-input-lisp.md. +REM +REM Aufruf: +REM bin\dxf_anlage_export.bat [--projekt NAME] +REM ================================================================ + +call "%~dp0setenv.bat" + +python "%DXFM_LIB%\dxf_anlage_export.py" %* diff --git a/bin/dxf_scan_components.bat b/bin/dxf_scan_components.bat new file mode 100644 index 0000000..b8abe93 --- /dev/null +++ b/bin/dxf_scan_components.bat @@ -0,0 +1,14 @@ +@echo off +REM ================================================================ +REM Erkennt ILS-/Omniflo-Komponenten in einer FREMDEN Projektzeichnung +REM (ohne unsere Wrapper-Bloecke) und schreibt sie als Nachbau-JSON. +REM Siehe doc/kommandos.md, doc/json-input-lisp.md. +REM +REM Aufruf: +REM bin\dxf_scan_components.bat +REM [--fenster X0 Y0 X1 Y1] [--projekt NAME] +REM ================================================================ + +call "%~dp0setenv.bat" + +python "%DXFM_LIB%\dxf_scan_components.py" %* diff --git a/bin/dxf_vf_abbild.bat b/bin/dxf_vf_abbild.bat new file mode 100644 index 0000000..ee5fd21 --- /dev/null +++ b/bin/dxf_vf_abbild.bat @@ -0,0 +1,14 @@ +@echo off +REM ================================================================ +REM Attribut-/Bausteinabbild der VF_/GF_-Wrapperbloecke einer +REM Testzeichnung - Regressionsnetz fuer Umbauten am Bau-Ablauf. +REM Siehe doc/kommandos.md. +REM +REM Aufruf: +REM bin\dxf_vf_abbild.bat [--spec S] [--json J] [--referenz R] +REM [--schreibe-referenz] [--praefix VF_,GF_] +REM ================================================================ + +call "%~dp0setenv.bat" + +python "%DXFM_LIB%\dxf_vf_abbild.py" %* diff --git a/bin/set_coords.bat b/bin/set_coords.bat index 4bc3eee..7354666 100644 --- a/bin/set_coords.bat +++ b/bin/set_coords.bat @@ -1,6 +1,6 @@ @echo off REM ================================================================ -REM Setzt Einfuegepunkte fuer Omniflo DXF-Dateien +REM Setzt Koordinatensystem-Bloecke (K1-K4) in Omniflo DXF-Dateien REM ================================================================ call "%~dp0setenv.bat" diff --git a/bin/show_exportcsv.bat b/bin/show_exportcsv.bat index 37f9b67..e1fee54 100644 --- a/bin/show_exportcsv.bat +++ b/bin/show_exportcsv.bat @@ -6,11 +6,12 @@ REM Zeichnet jede Zeile der Export-CSV (EXPORTCSV) als achsparalleles REM Rechteck aus Position + Boundingbox, mit Legende und Tooltip je REM Rechteck sowie den Anschluss-Koordinatensystemen K1-K4 (rotes Kreuz, REM blaue Linie K1->K2->K3->K4), und oeffnet das Ergebnis im Browser. -REM Optional zusaetzlich Materialfluss- und Bahnzusammenhang-Graph. +REM Optional zusaetzlich Materialfluss-, Bahnzusammenhang- und TRO-Fluss-Graph. REM REM Die Darstellung uebernimmt sps_skel (bin\material_flow.bat, -REM Option --show-bbs). sps_skel wird neben dxfmakros erwartet -REM (..\sps_skel) oder ueber die Umgebungsvariable SPS_SKEL_HOME. +REM Option --show-bbs, bzw. bin\tro_flow.bat fuer 'tro'). sps_skel wird +REM neben dxfmakros erwartet (..\sps_skel) oder ueber die Umgebungs- +REM variable SPS_SKEL_HOME. REM REM Aufruf: REM bin\show_exportcsv.bat results\export.csv, alle Zeilen @@ -18,17 +19,51 @@ REM bin\show_exportcsv.bat meine_export.csv andere CSV in results\ (oder Pf REM bin\show_exportcsv.bat export.csv flow ohne VF/GF-Einzelbausteine REM bin\show_exportcsv.bat export.csv mflow zusaetzlich Materialfluss-Graph REM bin\show_exportcsv.bat export.csv track zusaetzlich Bahnzusammenhang-Graph -REM bin\show_exportcsv.bat export.csv flow mflow track alles kombiniert +REM bin\show_exportcsv.bat export.csv tro zusaetzlich TRO-Fluss-Graph (lagerichtig) +REM bin\show_exportcsv.bat export.csv flow mflow track tro alles kombiniert REM -REM mflow/track brauchen Graphviz ('dot' im PATH). +REM mflow/track/tro brauchen Graphviz ('dot' bzw. 'neato' im PATH). REM REM Ergebnis: %SKEL_RESULTS%\_bbs.svg REM %SKEL_RESULTS%\_material_flow.svg (nur mit 'mflow') REM %SKEL_RESULTS%\_track.svg (nur mit 'track') +REM %SKEL_RESULTS%\_tro_flow.svg (nur mit 'tro') REM ================================================================ setlocal +if /i "%~1"=="--help" goto :help +if /i "%~1"=="-h" goto :help +if "%~1"=="/?" goto :help +goto :main + +:help +echo Aufruf: +echo bin\show_exportcsv.bat results\export.csv, alle Zeilen +echo bin\show_exportcsv.bat meine_export.csv andere CSV in results\ ^(oder Pfad^) +echo bin\show_exportcsv.bat export.csv flow ohne VF/GF-Einzelbausteine +echo bin\show_exportcsv.bat export.csv mflow zusaetzlich Materialfluss-Graph +echo bin\show_exportcsv.bat export.csv track zusaetzlich Bahnzusammenhang-Graph +echo bin\show_exportcsv.bat export.csv tro zusaetzlich TRO-Fluss-Graph ^(lagerichtig^) +echo bin\show_exportcsv.bat export.csv flow mflow track tro alles kombiniert +echo. +echo Schalter ^(2.-5. Argument, Reihenfolge beliebig^): +echo all Darstellungsmodus: alle Zeilen ^(Default^) +echo flow Darstellungsmodus: ohne VF/GF-Einzelbausteine +echo mflow zusaetzlich Materialfluss-SVG erzeugen und oeffnen +echo track zusaetzlich Bahnzusammenhang-SVG erzeugen und oeffnen +echo tro zusaetzlich TRO-Fluss-SVG ^(lagerichtig^) erzeugen und oeffnen +echo. +echo mflow/track/tro brauchen Graphviz ^('dot' bzw. 'neato' im PATH^). +echo. +echo Ergebnis: +echo %%SKEL_RESULTS%%\^_bbs.svg +echo %%SKEL_RESULTS%%\^_material_flow.svg ^(nur mit 'mflow'^) +echo %%SKEL_RESULTS%%\^_track.svg ^(nur mit 'track'^) +echo %%SKEL_RESULTS%%\^_tro_flow.svg ^(nur mit 'tro'^) +endlocal & exit /b 0 + +:main REM Umgebung dxfmakros (DXFM_RESULTS ...) call "%~dp0setenv.bat" >nul @@ -58,20 +93,24 @@ for %%F in ("%CSV%") do ( set "SVG=%SKEL_RESULTS%\%%~nF_bbs.svg" set "MF_SVG=%SKEL_RESULTS%\%%~nF_material_flow.svg" set "TRACK_SVG=%SKEL_RESULTS%\%%~nF_track.svg" + set "TRO_SVG=%SKEL_RESULTS%\%%~nF_tro_flow.svg" ) REM Weitere Argumente (Reihenfolge beliebig): REM all (Default) / flow - Darstellungsmodus der Boundingbox-Ansicht REM mflow - zusaetzlich Materialfluss-SVG erzeugen und oeffnen REM track - zusaetzlich Bahnzusammenhang-SVG erzeugen und oeffnen +REM tro - zusaetzlich TRO-Fluss-SVG (lagerichtig) erzeugen und oeffnen set "MODE=all" set "MFLOW=" set "TRACK=" -for %%A in (%2 %3 %4) do ( +set "TRO=" +for %%A in (%2 %3 %4 %5) do ( if /i "%%~A"=="all" set "MODE=all" if /i "%%~A"=="flow" set "MODE=flow" if /i "%%~A"=="mflow" set "MFLOW=1" if /i "%%~A"=="track" set "TRACK=1" + if /i "%%~A"=="tro" set "TRO=1" ) REM Beide Graphen entstehen erst mit --tosvg (Graphviz 'dot') @@ -83,10 +122,15 @@ REM Alte SVGs entfernen, damit nie eine veraltete Ansicht geoeffnet wird if exist "%SVG%" del "%SVG%" if defined MFLOW if exist "%MF_SVG%" del "%MF_SVG%" if defined TRACK if exist "%TRACK_SVG%" del "%TRACK_SVG%" +if defined TRO if exist "%TRO_SVG%" del "%TRO_SVG%" call "%SPS_SKEL_HOME%\bin\material_flow.bat" --file "%CSV%" --show-bbs %MODE% --show-kx %OPTS% set "RC=%ERRORLEVEL%" +if defined TRO ( + call "%SPS_SKEL_HOME%\bin\tro_flow.bat" --file "%CSV%" --tosvg --use-cords +) + if not exist "%SVG%" ( echo FEHLER: SVG wurde nicht erzeugt ^(material_flow Exit-Code %RC%^). endlocal & exit /b 1 @@ -115,6 +159,14 @@ if defined TRACK ( echo WARNUNG: Bahnzusammenhang-SVG wurde nicht erzeugt ^(Graphviz 'dot' vorhanden?^). ) ) +if defined TRO ( + if exist "%TRO_SVG%" ( + echo TRO-Fluss: %TRO_SVG% + start "" "%TRO_SVG%" + ) else ( + echo WARNUNG: TRO-Fluss-SVG wurde nicht erzeugt ^(Graphviz 'neato' vorhanden?^). + ) +) endlocal & exit /b 0 diff --git a/cfg/sivas.cfg b/cfg/sivas.cfg index d3b1aa8..8a19a35 100644 --- a/cfg/sivas.cfg +++ b/cfg/sivas.cfg @@ -64,14 +64,14 @@ # Code (bedingte Umbenennung bzw. Umrechnung mm->m). [eckrad] -# Bewusst (noch) beschreibende Klartext-Keys statt Merkmalnummern (kein -# bekanntes Sivas-Merkmal fuer Eckrad-Geruest hinterlegt) - details_mit_ -# bezeichnung() in export_sivas.py laesst nicht-numerische Keys unveraendert. -# "ist_eins" liefert ein ECHTES bool (True/False), NICHT "Ja"/"Nein" wie -# ja_nein bei Kreisel/Gefaellestrecke - json.dumps schreibt dann true/false -# ohne Anfuehrungszeichen (bisheriges Verhalten von build_eckrad_details). -Geruest fuer Einzelmodul= GERUEST_EINZELMODUL : 0 | ist_eins -Geruestoption fuer Einzelmodul= GERUEST_TYP : Schoenenberger Geruest +# Dieselben Sivas-Merkmalnummern wie bei Kreisel (siehe oben), aus +# Merkmalsstamm_in_Sivas.xlsx: 3992 "Geruest fuer Einzelmodul", 3993 +# "Geruestoption fuer Einzelmodul". "ist_eins" liefert ein ECHTES bool +# (True/False), NICHT "Ja"/"Nein" wie ja_nein bei Kreisel/Gefaellestrecke - +# json.dumps schreibt dann true/false ohne Anfuehrungszeichen (bisheriges +# Verhalten von build_eckrad_details). +3992= GERUEST_EINZELMODUL : 0 | ist_eins +3993= GERUEST_TYP : Schoenenberger Geruest | geruest_typ_anzeige [geruest] Farbe= FARBE diff --git a/dcl/gefaellestrecke.dcl b/dcl/gefaellestrecke.dcl index bfb6c12..a6610ec 100644 --- a/dcl/gefaellestrecke.dcl +++ b/dcl/gefaellestrecke.dcl @@ -6,6 +6,14 @@ // Eingaben entsprechen dem interaktiven Skript Gefaellestrecke.lsp: // Abstand deltaL, Gefaellewinkel, Fahrtrichtung, // Seite AUS-Element, Seite EIN-Element. +// +// gefaellestrecke_linienzug: Modus 3 (aus Linienzug LINE+ARC) - ersetzt die +// Konsolenfragen AUS-/EIN-Element Winkel+Seite, Winkelbestaetigung und die +// finale Einfuegen-Bestaetigung in EINEM Dialog (gf-dialog-linienzug in +// Gefaellestrecke.lsp). Die Objektauswahl (ssget LINE/ARC) UND die +// Start-/Endpunktwahl bleiben davor Zeichnung/Konsole - der automatisch +// berechnete Vorschlagswinkel wird als Vorbelegung des Winkel-Feldes +// gezeigt, mit einer kurzen Zusammenfassung der Segmentanalyse darueber. // ============================================================ gefaellestrecke : dialog { @@ -108,3 +116,64 @@ gefaellestrecke : dialog { ok_cancel; } + +// Modus 3 (aus Linienzug): AUS-/EIN-Element Winkel+Seite, Gefaellewinkel +// (Vorschlag vorbelegt, ueberschreibbar) und eine kurze Zusammenfassung der +// automatisch analysierten Segmentkette. "zusammenfassung" wird per +// set_tile aus mehreren ssg-textf-Zeilen zusammengesetzt (gf-dialog- +// linienzug, Gefaellestrecke.lsp) - sprachunabhaengig, nur das Label-Chrome +// bleibt hart deutsch wie der Rest dieser Datei. +gefaellestrecke_linienzug : dialog { + label = "Gefaellestrecke aus Linienzug"; + + : column { + + : boxed_column { + label = "Segmentanalyse"; + : text { key = "zusammenfassung"; label = ""; width = 55; } + } + + : boxed_row { + label = "AUS-Element"; + + : popup_list { + key = "aus_winkel"; + label = "Winkel:"; + width = 12; + } + : popup_list { + key = "aus_seite"; + label = "Seite:"; + width = 14; + } + } + + : boxed_row { + label = "EIN-Element"; + + : popup_list { + key = "ein_winkel"; + label = "Winkel:"; + width = 12; + } + : popup_list { + key = "ein_seite"; + label = "Seite:"; + width = 14; + } + } + + : boxed_column { + label = "Gefaellewinkel"; + + : edit_box { + key = "winkel"; + label = "Gefaellewinkel (Grad):"; + edit_width = 10; + } + } + + } + + ok_cancel; +} diff --git a/dcl/variofoerderer.dcl b/dcl/variofoerderer.dcl index ef475a9..6af94de 100644 --- a/dcl/variofoerderer.dcl +++ b/dcl/variofoerderer.dcl @@ -3,14 +3,47 @@ // Dialoge fuer c:VarioFoerderer (vf_core.lsp): // vfc_typ: Anlagen-Typ waehlen (Standard/Etage/Linienzug) - ersetzt die // Konsolen-Liste am Befehlsanfang. Radio-Buttons statt Dropdown, daher -// Labels FEST auf Deutsch (siehe Kommentar bei vfc_linienzug_modus). -// vfc_linienzug_modus: NUR bei Typ "Linienzug" - Modus 1/2/3 waehlen. -// variofoerderer_basis/variofoerderer_winkel: Werteingabe fuer den -// Standardfall (anlage-typ "standard"): deltaL, deltaH, Foerderrichtung, -// Einfuegehoehe, Fahrtrichtung, Seite, Winkel, GF-Verteilung. -// Die 3D-Linie-Eingabe (Modus "3D-Linie"), der Etage-Typ und die -// Linienzug-Kette selbst (nach der Modus-Wahl) bleiben interaktiv -// (Kommandozeile bzw. eigener Wizard in vf_linienzug_wizard.dcl). +// Labels FEST auf Deutsch. +// vfc_startpunkt: Startpunkt der Anlage picken (Punktwahl-Button + +// X/Y/Z-Anzeige) - ersetzt den reinen Konsolen-getpoint fuer +// Standard UND Etage (vfc-dialog-startpunkt-waehlen, vf_core.lsp). +// variofoerderer_basis/variofoerderer_winkel: Popup-Fallback-Varianten +// der Werteingabe (deltaL, deltaH, Foerderrichtung, Einfuegehoehe, +// Fahrtrichtung, Seite, Motorseite, Dimension, Geruest, Winkel, +// GF-Verteilung) - gemeinsam genutzt von Standard UND Etage. Die +// bevorzugte Variante (vfs_basis_dyn) wird zur Laufzeit generiert +// (vfs-dialog-eingabe-basis-radio in vf_standard.lsp) und steht NICHT +// in dieser Datei - NUR "Seite", "Motorseite" und "Geruestoption" +// bleiben dort Radio-Button-Gruppen (sofort sichtbare Optionen), alle +// anderen Felder sind Comboboxen wie hier. variofoerderer_basis hier +// ist nur noch der Fallback, falls das Schreiben/Laden der Temp-DCL +// mal scheitert. variofoerderer_winkel (Winkel/Verteilung) hat KEINE +// generierte Variante mehr und wird direkt verwendet (komplett +// Combobox, siehe vfs-dialog-winkel-verteilung in vf_standard.lsp). +// vfc_eingabemodus: Eingabemodus (3D-Linie / Werte manuell) waehlen - +// ersetzt die Konsolen-Abfrage am Anfang von vf-dialog-ablauf fuer +// Standard UND Etage (vfc-dialog-eingabemodus-waehlen, vf_core.lsp). +// Die 3D-Linie SELBST (Objektauswahl) bleibt danach Zeichnung/Konsole +// (get-line-start-end-points) - eine Linie laesst sich nicht durch ein +// Formularfeld ersetzen; alle abgeleiteten Werte (deltaL/deltaH/hz/ +// Einfuegehoehe) landen danach als Prefill im bestehenden Basis-Dialog +// (variofoerderer_basis), der sie ganz normal ueberschreibbar anzeigt. +// Der Etage-Typ und die Linienzug-Kette selbst bleiben interaktiv +// (Kommandozeile bzw. eigener Wizard in vf_linienzug_wizard.dcl). Der +// Linienzug-Modus (1/2/3/4/5) wird seit den Menue-Wrappern +// c:LinienzugVarioFoerderer*/c:QcLinieMitGf* nicht mehr per Dialog erfragt, +// sondern ist je Menuepunkt fest vorbelegt - der frueher hier gefuehrte +// Dialog vfc_linienzug_modus ist dadurch entfallen. +// +// Dialog fuer c:VARIOFOERDERER_NACHRUESTEN (vf_standard.lsp): +// vfs_nachruesten_hz: Baurichtung (hz) je unmarkiertem VF_n-Fund abfragen +// - ersetzt den fruehren getreal-Prompt. Die Objektauswahl selbst +// (ssget) bleibt Zeichnung/Konsole; je Fund OHNE SSG_VF_EDIT-Marker +// zeigt der Befehl diesen Dialog einmal, mit dem zuletzt eingegebenen +// Wert als Vorgabe (vfs-dialog-nachruesten-hz in vf_standard.lsp). +// "Abbrechen" uebernimmt fuer diesen Fund den Vorgabewert, OHNE auf die +// alte Konsolenfrage zurueckzufallen (die bleibt reiner Rueckfall fuer +// den Fall, dass der Dialog gar nicht gezeigt werden kann/darf). // ============================================================ // Anlagen-Typ waehlen (Standard/Etage/Linienzug). Radio-Buttons statt @@ -39,7 +72,7 @@ vfc_typ : dialog { } : radio_button { key = "typ_linienzug"; - label = "3D-Linienzug (gemischte GF/VF-Kette)"; + label = "Streckengruppe (gemischte GF/VF-Kette)"; } } @@ -57,50 +90,75 @@ vfc_typ : dialog { } } -// Linienzug-Modus waehlen (nur wenn Anlagen-Typ = Linienzug). Radio-Buttons, -// gleicher Deutsch-fest-Grund wie bei vfc_typ oben. -vfc_linienzug_modus : dialog { - label = "VarioFoerderer - Linienzug Modus"; +// Eingabemodus waehlen (3D-Linie / Werte manuell) - Radio-Buttons, gleiches +// Muster und dieselbe Sprach-/GUI-Einschraenkung wie vfc_typ oben (Labels +// hart deutsch, Rueckfall auf Konsolen-Liste bei DXFM_LANG=en_GB oder +// abgeschalteter GUI - siehe vfc-dialog-eingabemodus-waehlen, vf_core.lsp). +vfc_eingabemodus : dialog { + label = "VarioFoerderer - Eingabemodus"; : boxed_radio_column { - label = "Linienzug-Modus waehlen:"; + label = "Eingabemodus waehlen:"; key = "modus"; : radio_button { - key = "modus_1"; - label = "Manuelle Eingabe (Punkte klicken)"; + key = "modus_3dlinie"; + label = "3D-Linie auswaehlen (Start- und Endpunkt mit Hoehe)"; value = "1"; } : radio_button { - key = "modus_2"; - label = "3D-Objekte + Ziel-Hoehe (Randwert-Solver, fertig)"; - } - : radio_button { - key = "modus_3"; - label = "3D-Objekte stueckweise (Vorwaerts-Nachbau, in Arbeit)"; - } - : radio_button { - key = "modus_4"; - label = "QC Linie mit GF (automatische Auf-Ab-Berechnung)"; - } - : radio_button { - key = "modus_5"; - label = "QC Linie mit GF und U-Form"; + key = "modus_werte"; + label = "Werte manuell eingeben"; } } - // "Zurueck" springt hier sinnvoll zur Anlagen-Typ-Frage zurueck (siehe - // vfc-dialog-linienzug-modus-waehlen/c:VarioFoerderer). : row { alignment = centered; - : button { key = "back"; label = "Zurueck"; fixed_width = true; width = 12; } - spacer; : button { key = "accept"; label = "Ok Weiter"; is_default = true; fixed_width = true; width = 12; } spacer; : button { key = "cancel"; label = "Abbrechen"; is_cancel = true; fixed_width = true; width = 12; } } } +// Startpunkt der Anlage waehlen - Punktwahl-Button + Anzeige, analog +// vflw_punkt_zahl (dcl/vf_linienzug_wizard.dcl): der Button schliesst den +// Dialog (done_dialog 2), DANACH laeuft getpoint auf der Kommandozeile +// (aus einem action_tile-Callback heraus funktioniert getpoint in BricsCAD +// nicht), der Dialog wird danach mit der Anzeige erneut aufgebaut. "kopf" +// und "pt_anzeige" werden per set_tile aus ssg-text befuellt (siehe +// vfc-dialog-startpunkt-waehlen, vf_core.lsp) - deshalb sprachunabhaengig +// nutzbar. Button-Chrome bleibt hart deutsch, wie im Rest dieser Datei. +vfc_startpunkt : dialog { + label = "VarioFoerderer - Startpunkt"; + + : column { + : text { + key = "kopf"; + label = ""; + width = 50; + } + : row { + : button { + key = "pick"; + label = "Punkt waehlen..."; + fixed_width = true; + width = 18; + } + : text { + key = "pt_anzeige"; + label = "(kein Punkt gewaehlt)"; + } + } + } + + : row { + alignment = centered; + : button { key = "accept"; label = "Ok Weiter"; is_default = true; fixed_width = true; width = 12; } + spacer; + : button { key = "cancel"; label = "Abbrechen"; is_cancel = true; fixed_width = true; width = 12; } + } +} + variofoerderer_basis : dialog { label = "VarioFoerderer (Standard) - Eingabe"; @@ -115,24 +173,24 @@ variofoerderer_basis : dialog { label = "Horizontale Distanz deltaL (mm):"; edit_width = 10; } - : edit_box { - key = "deltah"; - label = "Hoehenunterschied deltaH (mm):"; - edit_width = 10; - } - } - - : row { : popup_list { key = "richtung"; label = "Foerderrichtung:"; width = 16; } + } + + : row { : edit_box { key = "einfuegehoehe"; label = "Einfuegehoehe (mm):"; edit_width = 10; } + : edit_box { + key = "deltah"; + label = "Hoehenunterschied deltaH (mm):"; + edit_width = 10; + } } } @@ -144,15 +202,17 @@ variofoerderer_basis : dialog { label = "Fahrtrichtung:"; width = 30; } - : popup_list { - key = "seite"; - label = "Seite:"; - width = 16; - } - : popup_list { - key = "motorseite"; - label = "Motorseite:"; - width = 16; + : row { + : popup_list { + key = "seite"; + label = "Seite:"; + width = 16; + } + : popup_list { + key = "motorseite"; + label = "Motorseite:"; + width = 16; + } } : popup_list { key = "dimension"; @@ -211,3 +271,25 @@ variofoerderer_winkel : dialog { ok_cancel; } + +// Baurichtung (hz) je unmarkiertem VF_n-Fund abfragen (VARIOFOERDERER_ +// NACHRUESTEN). "kopf" per set_tile aus ssg-text befuellt (Blockname + +// erkannter Typ), deshalb sprachunabhaengig nutzbar - Button-Chrome bleibt +// hart deutsch wie der Rest dieser Datei. "Abbrechen" bricht nur den +// aktuellen Fund ab: der vorbelegte default-hz wird fuer DIESEN Fund +// uebernommen (Aufrufer sieht 'ABBRUCH, kein Rueckfall auf die Konsole) - +// die ganze Nachruesten-Schleife laeuft weiter, kein Gesamtabbruch. +vfs_nachruesten_hz : dialog { + label = "VarioFoerderer nachruesten - Baurichtung"; + + : column { + : text { key = "kopf"; label = ""; width = 50; } + : edit_box { + key = "hz"; + label = "Baurichtung hz (Grad):"; + edit_width = 10; + } + } + + ok_cancel; +} diff --git a/dcl/vf_linienzug_wizard.dcl b/dcl/vf_linienzug_wizard.dcl index 6447aea..3a31dc8 100644 --- a/dcl/vf_linienzug_wizard.dcl +++ b/dcl/vf_linienzug_wizard.dcl @@ -523,12 +523,18 @@ vflw_horizontal : dialog { } // "Naechstes Element waehlen" - Hauptmenue des Linienzug-Aufbaus (Modus 1). -// IMMER alle 6 Optionen im Dialog vorhanden (stabile Keys) - "Vario-Kurve" +// IMMER alle 5 Optionen im Dialog vorhanden (stabile Keys) - "Vario-Kurve" // wird per mode_tile deaktiviert, wenn kein echter Kettenanfang vorliegt // (siehe vflw-gruppe-naechstes-element-impl, das dort auch die Positions- // Nummerierung passend umrechnet). Radio-Buttons statt Dropdown, Labels fest // deutsch, OHNE Nummern-Prefix (anders als die Konsolen-Variante - hier -// braucht es keine Zifferneingabe). +// braucht es keine Zifferneingabe). GF-Optionen stehen zuerst, VF-Optionen +// danach (nur Reihenfolge, kein echtes 2-Spalten-Layout: radio_button-Tiles +// muessen DIREKTE Kinder EINES Clusters sein, sonst ist die gegenseitige +// Ausschliesslichkeit kaputt - siehe Warnung bei vflw_winkel_hoehen unten, +// per Test bestaetigt). "Neue Linie BIS Kettenende" ist kein Radio mehr, +// sondern der eigene Button "OK und Abschliessen" unten (ruft direkt Slot 6 +// auf, ohne vorher eine Radio-Auswahl zu verlangen). vflw_naechstes_element : dialog { label = "VarioFoerderer Assistent"; @@ -542,27 +548,29 @@ vflw_naechstes_element : dialog { key = "wahl"; label = ""; : radio_button { key = "wahl_gfbogen"; label = "GF-Bogen (horizontale Kurve)"; } - : radio_button { key = "wahl_variokurve"; label = "Vario-Kurve (horizontale Kurve, 30/60/90 Grad)"; } : radio_button { key = "wahl_liniegf"; label = "Neue Linie: GF (Gefaellestrecke)"; value = "1"; } + : radio_button { key = "wahl_variokurve"; label = "Vario-Kurve (horizontale Kurve, 30/60/90 Grad)"; } : radio_button { key = "wahl_linievf"; label = "Neue Linie: Ab/Auf VF (VarioFoerderer-Einheit)"; } : radio_button { key = "wahl_horizontalvf"; label = "Neue VF mit horizontalem Anfang (Horizontal-Stueck)"; } - : radio_button { key = "wahl_linieende"; label = "Neue Linie BIS Kettenende (danach Separator + ES-Element)"; } } } // PROTOTYP "Zurueck"-Button (siehe Plan curious-prancing-parasol.md): ersetzt - // ok_cancel durch eine eigene 3-Button-Zeile. done_dialog-Codes: 0=Abbrechen + // ok_cancel durch eine eigene 4-Button-Zeile. done_dialog-Codes: 0=Abbrechen // (unveraendert, is_cancel -> ESC/Leertaste wirkt weiterhin), 1=Weiter - // (unveraendert, is_default), NEU 2=Zurueck (verwirft das zuletzt gebaute + // (unveraendert, is_default), 2=Zurueck (verwirft das zuletzt gebaute // Kettenglied und fragt es neu ab, siehe vflw-gruppe-naechstes-element-impl/ - // vfl-modus-abbruch-sichern). + // vfl-modus-abbruch-sichern), NEU 3=Abschliessen (entspricht der fruehen + // Radio-Option "Neue Linie BIS Kettenende" - ignoriert die Radio-Auswahl). : row { alignment = centered; - : button { key = "back"; label = "Zurueck"; fixed_width = true; width = 12; } + : button { key = "back"; label = "Zurueck"; fixed_width = true; width = 12; } spacer; - : button { key = "accept"; label = "Ok Weiter"; is_default = true; fixed_width = true; width = 12; } + : button { key = "accept"; label = "Ok Weiter"; is_default = true; fixed_width = true; width = 12; } spacer; - : button { key = "cancel"; label = "Abbrechen"; is_cancel = true; fixed_width = true; width = 12; } + : button { key = "abschliessen"; label = "OK und Abschliessen"; fixed_width = true; width = 18; } + spacer; + : button { key = "cancel"; label = "Abbrechen"; is_cancel = true; fixed_width = true; width = 12; } } } diff --git a/doc/faq.md b/doc/faq.md index aa0cbcc..31c0dc1 100644 --- a/doc/faq.md +++ b/doc/faq.md @@ -1,85 +1,364 @@ # FAQ - Dokumentation +- [FAQ - Dokumentation](#faq---dokumentation) + - [Allgemein](#allgemein) + - [Darf ich Baugruppen kopieren?](#darf-ich-baugruppen-kopieren) + - [Darf ich Baugruppen auflösen?](#darf-ich-baugruppen-auflösen) + - [Darf ich Attribute in den Baugruppen manuell ändern?](#darf-ich-attribute-in-den-baugruppen-manuell-ändern) + - [Darf ich Baugruppen mustern?](#darf-ich-baugruppen-mustern) + - [1. Kreisel](#1-kreisel) + - [1.1 Zusammensetzung, Abhängigkeiten, Randbedingungen](#11-zusammensetzung-abhängigkeiten-randbedingungen) + - [Zusammensetzung einer Kreiselbaugruppe](#zusammensetzung-einer-kreiselbaugruppe) + - [Einfügepunkt und Koordinatensystem](#einfügepunkt-und-koordinatensystem) + - [Höhe (Laufprofil und Unterkante)](#höhe-laufprofil-und-unterkante) + - [1.2 Funktionen](#12-funktionen) + - [Wie füge ich einen Kreisel ein?](#wie-füge-ich-einen-kreisel-ein) + - [Wie drehe ich einen Kreisel?](#wie-drehe-ich-einen-kreisel) + - [Wie ändere ich die Höhe eines Kreisels?](#wie-ändere-ich-die-höhe-eines-kreisels) + - [Wie ändere ich die Länge eines Kreisels?](#wie-ändere-ich-die-länge-eines-kreisels) + - [2. Gefällestrecke](#2-gefällestrecke) + - [2.1 Zusammensetzung, Abhängigkeiten, Randbedingungen](#21-zusammensetzung-abhängigkeiten-randbedingungen) + - [Zusammensetzung einer Gefällestrecke](#zusammensetzung-einer-gefällestrecke) + - [Einfügepunkt und Koordinatensystem](#einfügepunkt-und-koordinatensystem-1) + - [Höhe und Übergang zu Kreiselkoordinatensystem (Unterkante SP \<-\> Oberkante LP)](#höhe-und-übergang-zu-kreiselkoordinatensystem-unterkante-sp---oberkante-lp) + - [2.2 Funktionen](#22-funktionen) + - [Wie füge ich eine Gefällestrecke ein?](#wie-füge-ich-eine-gefällestrecke-ein) + - [Wie drehe ich eine Gefällestrecke?](#wie-drehe-ich-eine-gefällestrecke) + - [Wie ändere ich die Länge einer Gefällestrecke?](#wie-ändere-ich-die-länge-einer-gefällestrecke) + - [Wie baue ich eine Gefällestrecke mit einer bestimmten Kapazität als Puffer (freie Länge des Stauprofils)](#wie-baue-ich-eine-gefällestrecke-mit-einer-bestimmten-kapazität-als-puffer-freie-länge-des-stauprofils) + - [Wie baue ich eine Gefällestrecke zwischen zwei Kreiseln mit definiertem Abstand?](#wie-baue-ich-eine-gefällestrecke-zwischen-zwei-kreiseln-mit-definiertem-abstand) + - [Wie baue ich eine Gefällestrecke mit Kurven als Übergang zwischen zwei Kreiseln mit unterschiedlicher Höhe?](#wie-baue-ich-eine-gefällestrecke-mit-kurven-als-übergang-zwischen-zwei-kreiseln-mit-unterschiedlicher-höhe) + - [Wie baue ich eine Gefällestrecke mit manueller Höhenüberwindung ohne VF (QS-Platz Mubea)](#wie-baue-ich-eine-gefällestrecke-mit-manueller-höhenüberwindung-ohne-vf-qs-platz-mubea) + - [3. Varioförderer](#3-varioförderer) + - [3.1 Zusammensetzung, Abhängigkeiten, Randbedingungen](#31-zusammensetzung-abhängigkeiten-randbedingungen) + - [Zusammensetzung eines Varioförderer mit allen möglichen Komponenten](#zusammensetzung-eines-varioförderer-mit-allen-möglichen-komponenten) + - [Verfügbare Steigungen](#verfügbare-steigungen) + - [Einfügepunkt und Koordinatensystem](#einfügepunkt-und-koordinatensystem-2) + - [Höhe und Übergang zu Kreiselkoordinatensystem (Unterkante SP \<-\> Oberkante LP)](#höhe-und-übergang-zu-kreiselkoordinatensystem-unterkante-sp---oberkante-lp-1) + - [3.2 Funktionen](#32-funktionen) + - [Welche Einfügemodi gibt es und wie unterscheiden sich diese?](#welche-einfügemodi-gibt-es-und-wie-unterscheiden-sich-diese) + - [Wie baue ich einen VF in einem Puffer mit Gefällestrecken als Umschleusung?](#wie-baue-ich-einen-vf-in-einem-puffer-mit-gefällestrecken-als-umschleusung) + - [Wie baue ich einen VF zur Anfahrung einer bestimmten Höhe (Arbeitsplatz)?](#wie-baue-ich-einen-vf-zur-anfahrung-einer-bestimmten-höhe-arbeitsplatz) + - [Wie baue ich einen VF als Übergang zwischen zwei verschiedenen Kreiseln (unterschiedliche Höhe und Position x/y/z)](#wie-baue-ich-einen-vf-als-übergang-zwischen-zwei-verschiedenen-kreiseln-unterschiedliche-höhe-und-position-xyz) + - [Wie baue ich einen Förderer zu Ebenenüberquerung zwischen zwei Pufferblöcken, welche übereinander positioniert sind?](#wie-baue-ich-einen-förderer-zu-ebenenüberquerung-zwischen-zwei-pufferblöcken-welche-übereinander-positioniert-sind) + - [Wie baue ich eine Strecke mit mehreren VF und Gefällestrecken hintereinander zur Überbrückung von großen Entfernungen?](#wie-baue-ich-eine-strecke-mit-mehreren-vf-und-gefällestrecken-hintereinander-zur-überbrückung-von-großen-entfernungen) + - [4. Scanner und Separator](#4-scanner-und-separator) + - [4.1 Zusammensetzung, Abhängigkeiten, Randbedingungen](#41-zusammensetzung-abhängigkeiten-randbedingungen) + - [Einfügepunkt und Koordinatensystem](#einfügepunkt-und-koordinatensystem-3) + - [In welchen Baugruppen sind Scanner und Separatoren bereits eingebaut (Blöcke)?](#in-welchen-baugruppen-sind-scanner-und-separatoren-bereits-eingebaut-blöcke) + - [Zuordnung der frei platzierten Scanner und Separatoren zu einem Kreisel, Gefällestrecke oder VF](#zuordnung-der-frei-platzierten-scanner-und-separatoren-zu-einem-kreisel-gefällestrecke-oder-vf) + - [4.2 Funktionen](#42-funktionen) + - [Wie füge ich einen Scanner ein?](#wie-füge-ich-einen-scanner-ein) + - [Wie füge ich einen Separator ein?](#wie-füge-ich-einen-separator-ein) + - [5. Be- und Entladung](#5-be--und-entladung) + - [5.1 Zusammensetzung, Abhängigkeiten, Randbedingungen](#51-zusammensetzung-abhängigkeiten-randbedingungen) + - [Einfügepunkt und Koordinatensystem](#einfügepunkt-und-koordinatensystem-4) + - [Übergang zu Rutschstange (Oberkante LP \<-\> Oberkante Rutschprofil)](#übergang-zu-rutschstange-oberkante-lp---oberkante-rutschprofil) + - [5.2 Funktionen](#52-funktionen) + - [Wie füge ich eine Beladung oder Entladung ein?](#wie-füge-ich-eine-beladung-oder-entladung-ein) + - [Wie binde ich einen FLEX Förderer an die Entladung an?](#wie-binde-ich-einen-flex-förderer-an-die-entladung-an) + ## Allgemein -- Darf ich Baugruppen kopieren? -- Darf ich Baugruppen auflösen? -- Darf ich Attribute in den Baugruppen manuell ändern? -- Darf ich Baugruppen mustern? +### Darf ich Baugruppen kopieren? + +Natürlich darf man eine erzeugte Baugruppe kopieren. Beim Export erhält es dann eine neue eigene ID, so dass keine Verwechslungen im CSV File auftreten können. + +### Darf ich Baugruppen auflösen? + +**Nein**. Der Export erkennt Baugruppen anhand ihres Blocknamens. Wird eine Baugruppe aufgelöst (EXPLODE), fällt sie komplett aus dem Export heraus: keine ID-Vergabe, keine Export-Zeile, keine Scanner-/Separator-Zuordnung. Zusätzlich gehen die Attribute dabei verloren, da sie nicht mehr mit einem Block verknüpft sind. + +### Darf ich Attribute in den Baugruppen manuell ändern? + +Grundsätzlich **ja**, dafür gibt es teilweise auch eigene Dialoge (z.B. zum Bearbeiten eines Kreisels). Zwei Punkte sind dabei zu beachten: + +- **ID**: Wird eine ID manuell auf einen bereits vergebenen Wert gesetzt, wird das beim nächsten Export als Duplikat erkannt und der zweiten gefundenen Baugruppe automatisch eine neue ID zugewiesen – der manuell gesetzte Wert kann also überschrieben werden. +- **Artikelnummer / Teileart**: Hier gibt es keine automatische Prüfung. Ein falsch gesetzter Wert führt zu einer falschen Merkmalszuordnung im Sivas-Export, ohne dass das vorher auffällt. + +Andere Attribute (Bezeichnung, Höhe, Abstand etc.) können bedenkenlos manuell angepasst werden, sollten aber nach Möglichkeit über die vorgesehenen Edit-Befehle statt direkt am Attribut geändert werden, damit die Geometrie konsistent bleibt. + +![Attribute](images/Kreisel-attribute.png) +*Abbildung: Attribute eines Kreisels* + + +### Darf ich Baugruppen mustern? + +**Ja**. Gemusterte Kopien tragen zunächst dieselbe ID wie das Original, beim nächsten Export-Lauf wird das als Duplikat erkannt und den weiteren Instanzen automatisch eine neue, eindeutige ID zugewiesen. Die Eindeutigkeit ist also am Ende gewährleistet, sobald einmal der Export (oder die ID-Prüfung) gelaufen ist. ## 1. Kreisel ### 1.1 Zusammensetzung, Abhängigkeiten, Randbedingungen -- Zusammensetzung einer Kreiselbaugruppe -- Einfügepunkt und Koordinatensystem -- Höhe (Laufprofil und Unterkante) +#### Zusammensetzung einer Kreiselbaugruppe + +Eine Kreiselbaugruppe besteht aus: + +- einem **AN8-Kreis** (Antriebsstation) +- einem **SP8-Kreis** (Spannstation) +- zwei **Tangentenlinien** (oben/unten) +- optional zwei **PIN-Linien** (nur bei Kreiselart "PIN") +- einem **Beschriftungstext** ("KREISEL n: Art_Abstand") +- Attributen wie ID, Bezeichnung, Artikelnummer, Montagehöhe, Kreiselart, Abstand, Anzahl Separator/Scanner/Rampen, Gerüsttyp, Drehrichtung, Drehung, Nummer + +Das verwandte Eckrad besteht nur aus einem AN8-Kreis plus eigenen Attributen – ohne Tangenten, PIN-Linien oder Beschriftung. + +#### Einfügepunkt und Koordinatensystem + +Bei Rotation 0 (horizontal) liegt der Einfügepunkt auf der linken Kreistangente der AN-Seite (Antriebsstation); die Spannstation liegt im Abstand "Abstand" dahinter. Die Rotation dreht den gesamten Kreisel um diesen Punkt. + +Beim Verbinden zweier Kreisel ist der Startpunkt explizit der äusserste AN-Punkt (Antriebsstation) und der Endpunkt der äusserste SP-Punkt (Spannstation); Abstand und Rotation werden aus Distanz und Winkel der beiden Klickpunkte berechnet. Beim Eckrad ist der Einfügepunkt der berechnete Kreismittelpunkt (Berührpunkt + Radius in Klickrichtung). + +#### Höhe (Laufprofil und Unterkante) + +Die Höhe wird über die Z-Koordinate des Einfügepunkts gesteuert (ein separates Laufprofil/Unterkante-Konzept gibt es beim Kreisel nicht). Wird beim Einfügen ein Punkt mit Höhe > 0 gewählt, gilt diese; ansonsten greift ein konfigurierbarer Standardwert (Default 2000 mm). Über den Bearbeiten-Dialog kann die Höhe jederzeit nachträglich geändert werden – der Kreisel wird dann mit der neuen Höhe neu aufgebaut. + +> **Hinweis**: Eine getrennte Betrachtung von "Laufprofil" und "Unterkante" (zwei unterschiedliche Bezugsebenen) ist technisch nicht hinterlegt – nur ein einziger Höhenwert steuert die Position. Der Zusammenhang zu Gefällestrecke/VF-Übergängen (siehe unten) ist eine reine Konstruktionsfrage. ### 1.2 Funktionen -- Wie füge ich einen Kreisel ein? -- Wie drehe ich einen Kreisel? -- Wie ändere ich die Höhe eines Kreisels? -- Wie ändere ich die Länge eines Kreisels? +#### Wie füge ich einen Kreisel ein? + +Unter *ILS -> Kreisel-Module -> Einfuegen*. Dann die Fragen nach Anfangspunkt, Länge und Höhe des Kreisels beantworten. Alternativ *ILS -> Kreisel-Module -> Verbinden*, um einen Kreisel direkt an einen bestehenden anzuschliessen. + +#### Wie drehe ich einen Kreisel? + +Am einfachsten durch einen Doppelklick auf den Kreisel und der Auswahl des Dropdowns Ausrichtung (Horizontal, Vertikal). Alternativ über *ILS -> Kreisel-Module -> Bearbeiten* (oder per Rechtsklick auf den Kreisel -> *Kreisel bearbeiten*). +![Oberfläche Kreisel](images/Kreisel-mit-gui.png) +*Abbildung: Kreisel-Dialog mit GUI-Eingabe* + +#### Wie ändere ich die Höhe eines Kreisels? + +Durch einen Doppelklick auf den Kreisel und der Eingabe der neuen Höhe unter Hoehe (mm). Alternativ über *ILS -> Kreisel-Module -> Bearbeiten* (oder per Rechtsklick auf den Kreisel -> *Kreisel bearbeiten*). + +#### Wie ändere ich die Länge eines Kreisels? + +Durch einen Doppelklick auf den Kreisel und der Eingabe des neuen Abstands im Bearbeiten-Dialog. Alternativ über *ILS -> Kreisel-Module -> Bearbeiten* (oder per Rechtsklick auf den Kreisel -> *Kreisel bearbeiten*). ## 2. Gefällestrecke +- einfach +- aus 3D Linie +- aus Linienzug +- QC mit 30 Grad ES/AS +- QC mit 90 Grad ES/AS + ### 2.1 Zusammensetzung, Abhängigkeiten, Randbedingungen -- Zusammensetzung einer Gefällestrecke -- Einfügepunkt und Koordinatensystem -- Höhe und Übergang zu Kreiselkoordinatensystem (Unterkante SP <-> Oberkante LP) +#### Zusammensetzung einer Gefällestrecke + +Im Standardfall besteht eine Gefällestrecke aus vier in Reihe eingefügten Bausteinen: + +1. **AUS-Element** +2. **Staustrecke** (auf die gewünschte Länge skaliert, um den Gefällewinkel geneigt) +3. **Separator** +4. **EIN-Element** + +Beim Aufbau entlang eines frei gezeichneten Linienzugs kommen zusätzlich Gefällebogen-Bausteine hinzu; vor jedem Bogen wird automatisch ein weiterer Separator eingefügt. + +![Gefaellestrecke](images/gefaellestrecke.png) +*Abbildung: Gefällestrecke* + + +#### Einfügepunkt und Koordinatensystem + +Jeder Baustein hat ein Ein- und ein Ausgangskoordinatensystem, über die die Bausteine beim Verketten passgenau aneinandergesetzt werden. Beim Verketten kommt das Eingangskoordinatensystem (nicht der Block-Ursprung) auf den Zielpunkt zu liegen. + +Der vom Anwender gepickte Startpunkt der Gefällestrecke entspricht dem Eingangskoordinatensystem des AUS-Elements; die Förderstrecken-Mittelachse läuft durch diesen Punkt. Am Kettenende wird die Höhe hingegen am Ausgangskoordinatensystem des EIN-Elements gemessen, damit dieses exakt der Zielhöhe entspricht. + +#### Höhe und Übergang zu Kreiselkoordinatensystem (Unterkante SP <-> Oberkante LP) + +> **Hinweis**: Eine feste Höhenbeziehung zwischen "Unterkante SP" (Stauprofil) und "Oberkante LP" (Laufprofil eines Kreisels) ist nicht hinterlegt – das ist eine reine Konstruktionsfrage. Die Anschlusshöhe wird vom Konstrukteur über die Parameter Einfügehöhe/Zielhöhe gesteuert. ### 2.2 Funktionen -- Wie füge ich eine Gefällestrecke ein? -- Wie drehe ich eine Gefällestrecke? -- Wie ändere ich die Länge einer Gefällestrecke? -- Wie baue ich eine Gefällestrecke mit einer bestimmten Kapazität als Puffer (freie Länge des Stauprofils) -- Wie baue ich eine Gefällestrecke zwischen zwei Kreiseln mit definiertem Abstand? -- Wie baue ich eine Gefällestrecke mit Kurven als Übergang zwischen zwei Kreiseln mit unterschiedlicher Höhe? -- Wie baue ich eine Gefällestrecke mit manueller Höhenüberwindung ohne VF (QS-Platz Mubea) +#### Wie füge ich eine Gefällestrecke ein? + +Unter *ILS -> Gefaellestrecke -> einfach* für den Standardfall (Anfangspunkt, Länge, Höhe, Winkel über Dialog). Für eine Gefällestrecke entlang einer vorgezeichneten 3D-Linie *ILS -> Gefaellestrecke -> aus 3D-Linie*, für einen Linienzug aus mehreren Linien/Bögen *ILS -> Gefaellestrecke -> aus Linienzug (LINE + ARC)*. + +#### Wie drehe ich eine Gefällestrecke? + +Durch einen Doppelklick auf die Gefällestrecke (öffnet den Bearbeiten-Dialog mit denselben Eingaben wie beim Einfügen) oder per Rechtsklick -> *Gefaellestrecke bearbeiten*. + +#### Wie ändere ich die Länge einer Gefällestrecke? + +Durch einen Doppelklick auf die Gefällestrecke und Eingabe der neuen Länge im Bearbeiten-Dialog, oder per Rechtsklick -> *Gefaellestrecke bearbeiten*. + +#### Wie baue ich eine Gefällestrecke mit einer bestimmten Kapazität als Puffer (freie Länge des Stauprofils) + +#### Wie baue ich eine Gefällestrecke zwischen zwei Kreiseln mit definiertem Abstand? + +#### Wie baue ich eine Gefällestrecke mit Kurven als Übergang zwischen zwei Kreiseln mit unterschiedlicher Höhe? + +#### Wie baue ich eine Gefällestrecke mit manueller Höhenüberwindung ohne VF (QS-Platz Mubea) + +#### Was sind "QC mit 30/90 Grad ES/AS" und "QC mit U-Form"? + +Zwei Spezialbefehle fürs Zeichnen eines Linienzugs vorab, bei denen die +komplette Kette danach **automatisch ohne weitere Rückfragen** gebaut wird +(`QcLinieMitGf`/`QcLinieMitGfUForm`, technisch über den Linienzug-Ablauf +(Streckengruppe) mit einem erzwungenen Modus gebaut, im Menü aber bewusst +unter *ILS -> Gefaellestrecke* eingeordnet, da das Ergebnis eine reine +Gefällestrecke von AS bis ES ist): Statt bei jedem Schritt zu fragen "Welches +Element als nächstes?", wird direkt die Gefällestrecke zwischen den beiden +gewählten Punkten gebaut. "QC mit U-Form" (`QcLinieMitGfUForm`) löst +zusätzlich eine gefaltete (U-förmige) Linienführung: zwei Gefällestrecken- +Abschnitte mit unterschiedlicher Neigung (3°/9°) werden über ein +Gleichungssystem aus Höhen- und Lagebilanz passend zur Zielgeometrie +berechnet, nur am Kettenanfang nutzbar. ## 3. Varioförderer +Varioförderer können auf verschiedene Arten gebaut werden: + +1. Standard +2. Etage +3. Streckengruppe + - Manuelle Eingabe + - 3D-OBjekte mit Ziel-höhe + - 3D Objekte Stückweise (wird gerade noch implementiert bzw. ist expirementell) + +Der **"Standard Förderer"** ist die Verbindung von zwei Kreiseln mit einem definierten Abstand und (wenn nötig) einer Höhendifferenz. (z.B. für eine Umschleusung in einem Gefällepuffer) + +Ein **Etagenförderer** hat 30° Aussschleuselemente und wird verwendet, um zwei Kreisel über eine Etage zu verbinden. Diese beiden Kreisel müssen dabei übereinander liegen. + +Standard und Etage können aufgerufen werden mit _"Werte manuell"_ oder _"3D - Linie"_. +- Bei "_Werte Manuell_" definiert man den Verlauf durch Höhe und Länge über die Eingabe in einer Oberfläche. +- bei "_3D Linie_" ist die Auswahl einer Gerade im Raum möglich. Damit wird Richtung, Länge und Höhendifferenz angegeben. Dadurch werden diese Werte in die Oberfläche übernommen. Der beliebige Winkel in der Ebene kann durch die Linie festgelegt werden und ist nicht auf die Raster 0,90,270 Grad festgelegt + +Die **Variablen Förderer** könne auf drei verschiedene Arten definiert werden: + +- die _manuelle Eingabe_ frägt nach der Definition des AS Elementes ab, ob man abwechselnd eine GF oder einen VF definieren möchte. Mit einem Knopf unten kann man den Assistenten abschliessen und das ES erzeugen +- _Eine 3D Linie_ muss aus Geraden und Bögen (Winkel 30° mit dem Radius 500mm) bestehen. Wenn eine 3D Linie für Verlauf mit der korrekten Zielhöhe existiert, kann man iterativ die Einzelelemente (oder auch mehrere) dieser Einzellinien Linie anwählen, um den nächsten Förderer oder den nöchsten Gefälle-Anteil zu definieren. + + ### 3.1 Zusammensetzung, Abhängigkeiten, Randbedingungen -- Zusammensetzung eines Varioförderer mit allen möglichen Komponenten -- Verfügbare Steigungen -- Einfügepunkt und Koordinatensystem -- Höhe und Übergang zu Kreiselkoordinatensystem (Unterkante SP <-> Oberkante LP) +#### Zusammensetzung eines Varioförderer mit allen möglichen Komponenten + +Es gibt drei Anlagentypen: + +- **Standard**: gerade AS-/ES-Elemente + Staustrecke + Umlenk-/Motorstation + Separatoren, feste horizontale Blöcke. +- **Etage**: wie Standard, aber mit Etagen-Schrägsektion/-Bögen statt gerader AS-/ES-Elemente. +- **Linienzug**: frei aus der Zeichnung gebaute Kette aus AS-/ES-Element, Gefälle-Bogen, Vario-Kurve, horizontalem/geneigtem Förderer-Segment, Separatoren und Umlenk-/Motorstation. + +Der Bauteilablauf folgt dabei grundsätzlich: Startpunkt → optionales AS-Element → beliebige Folge aus Bogen / Gerade / Auf-Ab-Förderer / Horizontal-Förderer (mit Vario-Kurve bzw. horizontalem Zwischenstück) → Kettenende mit optionalem ES-Element. Jede Förderer-Einheit besteht aus Umlenkstation + Motorstation plus Separator(en). +![Variofoerderer](images/variofoerderer.png) +*Abbildung: Varioförderer Standard* + +#### Verfügbare Steigungen + +Zwei getrennte Winkel-Systeme: + +1. **Vertikale Neigung** (Gefälle/Steigung in Fahrtrichtung): aus einer festen Winkel-Tabelle (3, 6, 9, 12, 15, 18, 21, 27, 33, 39, 45, 51 Grad), maximal 51 Grad. +2. **Horizontale Kurven** (Gefälle-Bogen und Vario-Kurve): 30, 60 oder 90 Grad. + +**Wichtige Ausnahme**: AS-/ES-Elemente haben nur **30 und 90 Grad**, explizit **keine** 60-Grad-Variante. Die 30/60/90-Grad-Dreiteilung gilt also für Bögen/Vario-Kurve, nicht für AS-/ES-Elemente. + +#### Einfügepunkt und Koordinatensystem + +Identisch zum Gefällestrecke-Mechanismus: Die Verkettung erfolgt über Ein- und Ausgangskoordinatensysteme jedes Bausteins, das Eingangskoordinatensystem kommt dabei auf den Zielpunkt zu liegen. + +Beim Standard-Typ wird vor dem ersten Dialog der Startpunkt (X/Y) gepickt, die Z-Höhe kommt separat aus dem Dialogfeld "Einfügehöhe". Bei Etage ebenso. Im Linienzug-Modus ist der Startpunkt der erste Punktwahl-Schritt, die Starthöhe ein separates Zahlenfeld mit Default = Z des Punkts. + +#### Höhe und Übergang zu Kreiselkoordinatensystem (Unterkante SP <-> Oberkante LP) + +> **Hinweis**: Wie bei der Gefällestrecke gibt es keine feste Höhenbeziehung zwischen "Unterkante SP" und "Oberkante LP" eines Kreisels. Anschlusshöhen werden über die Parameter Einfügehöhe/Zielhöhe gesteuert – das ist eine reine Konstruktionsfrage. ### 3.2 Funktionen -- Welche Einfügemodi gibt es und wie unterscheiden sich diese? -- Wie baue ich einen VF in einem Puffer mit Gefällestrecken als Umschleusung? -- Wie baue ich einen VF zur Anfahrung einer bestimmten Höhe (Arbeitsplatz)? -- Wie baue ich einen VF als Übergang zwischen zwei verschiedenen Kreiseln (unterschiedliche Höhe und Position x/y/z) -- Wie baue ich einen Förderer zu Ebenenüberquerung zwischen zwei Pufferblöcken, welche übereinander positioniert sind? -- Wie baue ich eine Strecke mit mehreren VF und Gefällestrecken hintereinander zur Überbrückung von großen Entfernungen? +#### Welche Einfügemodi gibt es und wie unterscheiden sich diese? + +Unter *ILS -> Foerderer* stehen folgende Einfügemodi zur Verfügung: + +- **Standard -> Werte manuell**: alle Werte (Längen, Winkel, Höhen) werden über einen Dialog abgefragt. +- **Standard -> aus 3D-Linie**: wie Standard, aber entlang einer vorgezeichneten 3D-Linie. +- **Etage -> Werte manuell** / **Etage -> aus 3D-Linie**: wie Standard, jedoch mit Etagen-Schrägsektion/-Bögen statt gerader AS-/ES-Elemente. +- **Streckengruppe**: frei aus der Zeichnung gebaute Kette, Schritt für Schritt über Dialoge/Konsole abgefragt (AS-Element, Bögen, Vario-Kurven, horizontale/geneigte Abschnitte, ES-Element). + +![Variofoerderer dialog1](images/vf-gui1.png) +*Abbildung: Varioförderer Dialog zur Erzeugung* + +![Variofoerderer dialog2](images/vf-gui2.png) +*Abbildung: Varioförderer Dialog zur Winkelbestimmung* + + +#### Wie baue ich einen VF in einem Puffer mit Gefällestrecken als Umschleusung? +Ich baue eine Gefällestrecke und kann dann mit einem Klick einen Varioförderer daneben bauen. Dazu die Gefällestrecke doppelklicken und dann auf den Knopf "VarioFoerderer daneben bauen" klicken. +![Variofoerderer dialog2](images/gf-vf-kombination.png) +*Abbildung: Erzeugung eines Varioförderers passend zur Gefällestrecke* + +#### Wie baue ich einen VF zur Anfahrung einer bestimmten Höhe (Arbeitsplatz)? + +Das macht man aus einer Streckengruppe aus aus mindestens einer GF und einer VF und den entsprechend nötigen Bögen. Eventuell noch die Verwendung eines horizontalen Anteils beim Varioförderer, um die Zielhöhe zu erreichen. + +#### Wie baue ich einen VF als Übergang zwischen zwei verschiedenen Kreiseln (unterschiedliche Höhe und Position x/y/z) + +Standardfall. Höhenunterschiede und Einfügehöhe einfach in Interface angeben. +![Variofoerderer dialog1](images/vf-gui1.png) +*Abbildung: Varioförderer Dialog zur Erzeugung* + + +#### Wie baue ich einen Förderer zu Ebenenüberquerung zwischen zwei Pufferblöcken, welche übereinander positioniert sind? + +Dafür ist der sogenannte Etagenförderer vorgesehen. +*ILS -> Foerderer-> Etage* + +#### Wie baue ich eine Strecke mit mehreren VF und Gefällestrecken hintereinander zur Überbrückung von großen Entfernungen? + +Dies kann nur Stückweise erfolgen, indem man ausprobiert, welche GF VF Kombination welche Länge erreicht und dabei eine gewünschte Höhe nicht überschreitet. Danach kann man die einzelnen Einheiten zu Einem Mergen. ## 4. Scanner und Separator ### 4.1 Zusammensetzung, Abhängigkeiten, Randbedingungen -- Einfügepunkt und Koordinatensystem -- In welchen Baugruppen sind Scanner und Separatoren bereits eingebaut (Blöcke)? -- Zuordnung der frei platzierten Scanner und Separatoren zu einem Kreisel, Gefällestrecke oder VF +#### Einfügepunkt und Koordinatensystem + +Scanner und Separatoren werden als frei platzierbare Einzel-Blöcke eingefügt. Der Einfügepunkt ist ein frei gewählter Punkt, die Rotation wird im Anschluss interaktiv am Cursor festgelegt. + +Es gibt hier **kein** Koordinatensystem-Verkettungssystem wie bei Gefällestrecke/Varioförderer – der Block wird direkt an seinem Ursprung auf dem gewählten Punkt platziert. + +#### In welchen Baugruppen sind Scanner und Separatoren bereits eingebaut (Blöcke)? + +Innerhalb von **Gefällestrecken-** und **Varioförderer**-Ketten wird intern automatisch ein Separator eingefügt (als Trennsteg zwischen den Staustrecken-Segmenten). Diese verpackten Separatoren werden beim Export erkannt und in den Attributen "Anzahl Separator"/"Anzahl Scanner" der jeweiligen Baugruppe mitgezählt. + +Reine Scanner-Blöcke sind dagegen **nicht** standardmässig in Gefällestrecke/Varioförderer/Kreisel verbaut – sie kommen nur als frei platzierte Einzelblöcke vor. + +#### Zuordnung der frei platzierten Scanner und Separatoren zu einem Kreisel, Gefällestrecke oder VF + +Es gibt **keine feste Verknüpfung** zum Zeitpunkt des Einfügens. Die Zuordnung erfolgt erst **nachträglich beim Export** über die geometrische Nähe: Scanner außerhalb einer Baugruppen-Umgrenzung werden per Abstand der nächstgelegenen Baugruppe zugeordnet; ist der Abstand zu mehreren Kandidaten nahezu gleich, wird das als "strittig" markiert und im Export entsprechend vermerkt. + +Für Separatoren, die bereits in einer Kette verbaut sind, ist die Zuordnung dagegen von vornherein eindeutig. + +**Fazit**: Die Zuordnung frei platzierter Scanner/Separatoren ist rein geometrisch (Abstand), keine feste Verknüpfung. ### 4.2 Funktionen -- Wie füge ich einen Scanner ein? -- Wie füge ich einen Separator ein? +#### Wie füge ich einen Scanner ein? + +Unter *ILS -> Zusatzmodul -> Scanner einfuegen*. Dann Anfangspunkt auswählen und über den zweiten Klick den Winkel festsetzen. + +#### Wie füge ich einen Separator ein? + +Unter *ILS -> Zusatzmodul -> Separator einfuegen*. Dann Anfangspunkt auswählen und über den zweiten Klick den Winkel festsetzen. ## 5. Be- und Entladung ### 5.1 Zusammensetzung, Abhängigkeiten, Randbedingungen -- Einfügepunkt und Koordinatensystem -- Übergang zu Rutschstange (Oberkante LP <-> Oberkante Rutschprofil) +#### Einfügepunkt und Koordinatensystem + +Be- und Entladung werden als frei platzierbare Einzel-Blöcke eingefügt. Wie bei Scanner/Separator ist der Einfügepunkt ein frei gewählter Punkt, die Rotation wird interaktiv am Cursor festgelegt – es gibt keine Koordinatensystem-Verkettung zu einer vorgelagerten Strecke, die Station steht für sich allein in der Zeichnung. + +Bemerkenswert: Der Entladungsblock sitzt intern schräg im Raum, sodass bei der Koordinatenberechnung im Export eine zusätzliche Korrektur nötig ist, damit die Weltkoordinaten nicht verzerrt bzw. gespiegelt werden. + +#### Übergang zu Rutschstange (Oberkante LP <-> Oberkante Rutschprofil) + +> **Hinweis**: Eine feste Höhenbeziehung zwischen "Oberkante LP" und "Oberkante Rutschprofil" ist nicht hinterlegt. Diese Frage ist eine reine Konstruktionsfrage und sollte entsprechend beantwortet werden. ### 5.2 Funktionen -- Wie füge ich eine Beladung oder Entladung ein? -- Wie binde ich einen FLEX Förderer an die Entladung an? +#### Wie füge ich eine Beladung oder Entladung ein? +Unter *ILS -> Zusatzmodul -> BTMT-Beladung* bzw. *BTMT-Entladung*. Dann Anfangspunkt auswählen und über den zweiten Klick den Winkel festsetzen. + +#### Wie binde ich einen FLEX Förderer an die Entladung an? diff --git a/doc/faq.pdf b/doc/faq.pdf new file mode 100644 index 0000000..0596dd4 --- /dev/null +++ b/doc/faq.pdf @@ -0,0 +1,7834 @@ +%PDF-1.4 +% +1 0 obj +<> +endobj +3 0 obj +<> +endobj +5 0 obj +<> +endobj +7 0 obj +<> +endobj +8 0 obj +<> +endobj +9 0 obj +<> +endobj +10 0 obj +<> +endobj +11 0 obj +<> +endobj +12 0 obj +<> +endobj +13 0 obj +<> +endobj +14 0 obj +<> +endobj +15 0 obj +<> +endobj +16 0 obj +<> +endobj +17 0 obj +<> +endobj +18 0 obj +<> +endobj +19 0 obj +<> +endobj +20 0 obj +<> +endobj +21 0 obj +<> +endobj +22 0 obj +<> +endobj +23 0 obj +<> +endobj +24 0 obj +<> +endobj +25 0 obj +<> +endobj +26 0 obj +<> +endobj +27 0 obj +<> +endobj +28 0 obj +<> +endobj +29 0 obj +<> +endobj +30 0 obj +<> +endobj +31 0 obj +<> +endobj +32 0 obj +<> +endobj +33 0 obj +<> +endobj +34 0 obj +<> +endobj +35 0 obj +<> +endobj +36 0 obj +<> +endobj +37 0 obj +<> +endobj +38 0 obj +<> +endobj +39 0 obj +<> +endobj +40 0 obj +<> +endobj +41 0 obj +<> +endobj +42 0 obj +<> +endobj +43 0 obj +<> +endobj +44 0 obj +<> +endobj +45 0 obj +<> +endobj +46 0 obj +<> +endobj +47 0 obj +<> +endobj +48 0 obj +<> +endobj +49 0 obj +<> +endobj +50 0 obj +<> stream +x\m B tLQD]Z)~vP)^ٗ î93"rfvA?_&$kA16,!%4q̏XyM_з_ëyë?Yրyk[cew~zd`R 57 8 #G @T?y2b] Ix@qPޢ ޳IvȒRH(2!`Er&vOdb ^d-Wq\Pp>QAdC'2Y{8E!_TY&Pd$'W8)h(xrX0]rK +!cnYOPl5 nq6ZdDK [ 8)\1a:mNY@}6NE[,Uq3ge=*۷|e9_TĘˠe1a-sXXWuUS4SN:iYaݾwgG +x<܌]LK'ѩsQQu>X9Z֣pDuZcۚ" B׶wEw W۸,[;ea߭\=nl..\D#D5pqݲ!c[qj^`Bm,JTxVmuPi²a-]a>^#٦ӎWglj@V^"Wr}GZ8B90a%>2.UQ7t,^yVTyE퓁SXo$wpB,lLHC0r j@rp"R[šwuTU UO=ec_ᢦ+-6kkLnpx$! IDLH,hLb؁۠0]J Xnup 5Fpvu;Ps{LpB^(`cas9GbPk%I9?! +"D{i{nP-lZ˦lna&J_{Snڇp:ݯj5н⫍]Hh#!ݶ }j4q0h=!7BX>nF#j"GQf3_wU:'v8vJ/ U8f]fv%3/ςkOŜ#6p:t%'Ⱥ K^{zAտNտDW$,*JTgn*E*(W{ +W7"*EZ̈L +XJ΢h^vQz6K9^) zq8ڪHJ/6x(@ū20V5HD`0jRTTTV ryR3׈XRMF+U .|@Z4hЬ9Y_F͡F9b_rYr0]jcun=5ۮ:aJES7 T3Jk")!On>+%wӄx!sۄҋ/ = 4e󸇲6eR]'d5_u]KgPs(XÕ~Gc4C^@uk~U{;mWKU~Qڮ-lQ??nN>'݀=]I'=Qo'@h+_ NG!Bt$w.xnL6ӭdko)1ўy;z.z$K +-kj?'U*Ut84+3Cas<5Г{Rȅ &ڳ)=Q76yS:f˞8uPs)Wۺ9A=osΦ_ApfCg/@A%,}Zٝ*f LyoU\rQŸ+m3#u3V.]Ɓu;"'YJ8*噅m7c\]1fH>׻Bt9a4lT1fˋ+/;ڣl9UUDb/R/tWd ۩/Riڏ٦fwzZǻ>ZRPG7pmFEaJj2/W*Ԣ7*B(7 t/R韓Ѩ WNt;`jdhss}KucKq㞦( c6+;!.!4 6׼>Sf8甙h.@Х=]p/u L.k[R"K>{PGlf=z\60wᡖS'R5v:+N B aW)2Koc[+qgk`O7:ldu/'d= ݕL/Iˉ:K ;̿S ,RrΆ)퉚q;6nfst̞fHf8xzUYhy\?vU5f>jnzt vnʹƜknMkcS\-,L.QMdW?Sq{NP?cG/_#d6ޯ9sZ`S\$@ףX}D +endstream +endobj +53 0 obj +<> +endobj +54 0 obj +<> +endobj +55 0 obj +<> +endobj +56 0 obj +<> +endobj +57 0 obj +<> +endobj +58 0 obj +<> +endobj +59 0 obj +<> +endobj +60 0 obj +<> +endobj +61 0 obj +<> +endobj +62 0 obj +<> +endobj +63 0 obj +<> +endobj +64 0 obj +<> +endobj +65 0 obj +<> +endobj +66 0 obj +<> +endobj +67 0 obj +<> +endobj +68 0 obj +<> +endobj +69 0 obj +<> +endobj +70 0 obj +<> +endobj +71 0 obj +<> +endobj +72 0 obj +<> +endobj +73 0 obj +<> +endobj +74 0 obj +<> +endobj +75 0 obj +<> +endobj +76 0 obj +<> stream +x\[$ ~_JbؙsㅼgۄUU}KTwT3+ +L_8 O~|A4UfBg& ̠Hmj_0tB3*O/40=Ք>|+͟7_2ח-M'3H_>~yvy/J +3˛PO`Z5NaBvz-7x1->L/SP!}6/13-fm#|C]-Q̃i" ivR_Nyy}(D)JJ3+1*߭0IiZ +seN9G'B=ץ;ef^g(oOF=Vcދz,f<?[7aJ +FC}H4Rc#ETH@YQBS('P_7h#Y;>ո)[@<ǹZ֫u?aH:Ny_Nf'>ڷŢ(lLvv]_F۴Zmi'.EMo5?;+AlwRh3n<OLg,*&VY\lП<-Q/I#]zgWx}8'Ġg3xnS!OădfF`C=}`+( ;|$`@☲ِszH4je:!P^YŃXyC0e4^ɳ1!>cf^={Ւ&UQԳ"V9XkVB#EӬ(C3$*F1 ,D*G?\xvH/_9)!I{īOe(^3|lx @"W +$l:=bT\M N34(14ʕ4ʿhViU.rT-%-_U[So܆/ +`bBtXN/i;FD D(y*pXQgP"E yYũQ@sQ,eN8)-暜b=ok6y0+ n͛<".zTdQ!;w͚^NqkF?8gt(%p"MD<ly*r"Q@HuW4";fd݅<r,kk*.Éɬ@Z)G8F Xa Fu83ZFȋH+"T>54"Na#VS#S;|NdCTGǤqD +Ps%f;JנNVrمgsV0f)1E4K,DW A]S= '(6>)KGDcdB]ègHb+}J7)KeքIѯBS MEx2)o6:1;{6aVXfuᬝGZYxϤw5fж'BdDS/@=ѳ-6_!\Tvh'B`=Cy +N sdHfKEIP!Y}8}fX֋Z?>*I!9 V2)T&~v+'@XY[SBJK '͊)חdH2k]:cTZw6ҹ|iw25Sra)g] #"ZѢ Y3+}]i f0,>h3d8*fg*ȯ:1+ p& 0mZws{K?w-Ivڂz%7kQ9#cz-.8:E]{k|5ˎ@+s`"&ֺU> <QZlS5)i_\2 +a&Nښ{/<.OPn0w:$W;PB@m%݉IE&ݼ{ p7`z?QD+V~;"8pg8/{P-$}UlNhV7͎] V2rR26ݴAϽu%yʻ]iۮvFYIĦȤV:ު:[{ z[;:[mrccR_pLnk-&:=I3v82&v_wΆ@\HV$$UPcʨ11YΗ +t-_N(d 쫖RI%c&,xTeiHկu K|BJyo.\~}J{Ȁ?-ǟ~MUԠB@rLAidV'pDcR`7䂟c^wEqBfV>gb:DNPKu=m +endstream +endobj +79 0 obj +<> stream +x}JԂ(28hiRpi"VSAOHStspu+.c(#ARx@?F[V[G@`*dK$O.K o@6`O,f'˘O asx0A6vf 8{c7%opZ:u Q 0Q٣F *Ԑ(SDGACAajgrx]s PxM cvhO> stream +x흻+ǵ_C+`gHxA8ڎ  p0e lӁ =B`Ⱦeեɮ^oacvX5X~?|o~?O3Zmnχ}bb^Oonחm?x3f$ծ}0^ЏCm꿜/w_}n " +lT ַ~)u{93[^1>wlhKQOu?o,fAP + @ "(0\90D-P` Z@@ hq +mF;&羳[Pw +gd_t|jp@ oԅ(H)> ?}u9[$xxz4r6UWzw zQݼZmNRelC5X*r +9 %_:0$R|jO`Q:X3 ZK{rS\IahYޢQB gN vp__W6_7(0hP`CTo9pӶ9p;x3 ''L}. "*M_ >۪wܸk:X |P'_}y`]E݊n):Q[l5 \?aNGm`H?ҝph[~%90x8Ї A + @ \@@@@?~}F$I?翢 +O͞_5ڿw៿@#q~_w_ qIH >߯?|w͟ZM'2~#ۮsӞ"<qR^9p-~}r#PưF8p= +ofo(oe+p;M{?l[վrr'vk+gw8[?m +A *9f&W`b\X#BKKun#;)=ͨݯ>Z$Ra%^Rm/utX (0h3=qKN Z@@ hA +}`~^xqpc"9IxӣK/C^ݰƇ6O MS&=&#E ^FLwq {"ф ȁ"L+1>7ND 90ˁO?@恡<0/@BMF^ z`=p7@b'"(0D-P` Z@@ r` Z@@ hAb +|xLDpf|w'r[xT)Oj鉙2 +l(BG%)X3#X=eON?MӛπvbCiع}_ ;wc1Rơ Z_:`mT5R~s3Qۧ0toQK(%(pql +1_tXRcf+3 ^{? EMϔew9i`,X$U3Ql:wpoW>fZPbæZW3`m溵E"v +"f,fhߘm P`cSgos8L,Ӧ*Z랸Ҭl2p&FZxaA(0D-P` ZR90D-P` Z@@ hAТ{6bJpVzcU2ưu {Ҏ=hz=4vHP2]6 wxRHGdyBOYq3++&9:^jRFp)W)x sq7> \ScO/h  +" +l40ZS +|^3RL=Ƞ[&]%v(p{$#r1vT + +(nA%-4$eh*9b><0pmp;S(S1VrơڊBpoh2([c{GC2{A<ӯT6b=0'"(0D-P` Z@@ r` Z@@ hAEvMeoM56%VDEt*V?NsBwF;Y;YA Q`Ty/³f֓ +"Nyf3`~%C"2 +\ퟎ]9Y2y*[:j&x!*p<3Wuo6M>Q,|>GfG!޴5*7q(Sҳ"rB*SNq0ُ$gDɁQJyܽvV;{!UW6 {I4Y·{I +1()svK斶7lBru9-*mHcSN{oԱ7lC .S`yS`_T`%oaE6B|-)0 0+:[Ɋ(0H {T^Ǜ8qߚ `L@ xR-~.@"(0D-p)Ђ"(0D-P` Z@@ hQ|WfDKQ~Y#XLky.EFɸm~7˄ +b*ԏ- ]BSy]1ɐߐwm-}{gb' +nuT`p~"̇bMxjnD%p ĺ4r/hkP; HiޡZn8b'ĎP7}QL`x:7ѸŰʇgRBS5Rip ĺ1 ,u5(@ +Y#@2˓y`S##kF A.5`wB0ctzww:n8 2D`OD-P` Z@@ hK@@ hA + @]N]tRDNwSjg75 2:}kUv{Ds8uuJ1K%da%.Q`)dZt$4ˀ)Y:ě@28G/L0K%d`OZ])Aѳ sZ%"6 ܥjrћKs`W )pS*Ρ +!,FӺI^BS)~y&tw615<+~:w'#?T(K%t'[f.&3E +ݱ 0~VN(wO^KG +Qq)2$3+YCՓEǥdH7` +u"k-hrz5j44Ӻ ^BvX +,-uLA2Ϫ}&.NpxF5({ hLn1+` + !*@@ r` Z@@ hA.EuyWo<ֆPeo\8fWk):tuBm۪PQb(3UcQu ^&M0";U$:x %FQ`Rt5pЫ{e˻] .Ea"nPu L.EoiOAd` +p)B }Yis6\6jhЕA 0@)@e*0.E e*0 A"-ȁ hA + @ "r)'lM>o +7TXKQ(y"+L$_>TPa.EVQбON䚓9:% +r) +նl~+.{UThPa].E!{ -m`p}y!QU .=PX 1FU*˥HJ߂)Pa].E=Pr|#ƫ1X º\${}汲X\,P=q@XR4[ " +X@" +(0D-p)Ђ"(0D-P` Z@@ hQB97jcsLF+;2"[aUAJ9{H5 8. +lNٿs7U^5f0=ck+eX P\(m zHKE"3g+ P_-9tgVN)R2.hƠeFle̠N9 Yއ(pb̑vJw1d&>y`c؛ kXRe# G-x7K#tW͍+ ʁHJ P`YO/\?^>Okbewę5nvE4m~r5?X2; 糴[Z5}It3Ӓzc{uzWYyg|l^,;gADW@cO2O΁rzCWf&(b(y +,_sb ʖ6E=t'xLY_xΙ\3VT`RB^Uc-D-vɸPsci^tP9 {S&Y%]԰'DvՁ6+R`\&c`.^fNJDP` ZR90D-P` Z@@ hAТLm.`glU՞+ثGmpZX:+2 Y/{_tvR:Zf{Ȑ!Tۧncv/[Cu<5[bԢ+qgib0$GvyTqd}Dh}EP-JFQK. !#)H>G[ٹ"­2LڹAϚ91L:<d0}3$= t=M1,Jk|aC3"1 qgPǐ= BFHWxѐ_Ly14@FI +)j4I,A + @5 +endstream +endobj +81 0 obj +<> stream +x\[d7~_quURVvz#$τ$H,G/' j:>͟?mRH;/O67?<`C{Jr!ۧ'R6Ֆ_8tlN?>}+:ӻ?_~7߿C_~ryzj0 wkFk Za5or.Xٗ7uZj\'uq\G:@k})对4zPW-1c}QL'Q\;AU]uMum[/~zxˋƑRPʋbYtV2RF,3&-.6Ya Wz@ıbq D۫GF2~jWdO>ͩ~]YGf{PWON:yҀ{:P+6-mlBB?E2EL3<obחw}o(Aw|Kc؇7}quh +F7kwPiE/S=t^/5&+O`Le +`&>Vc T IYGƋJ\<,(m . sebBM@ckqnG3y)y V7;f >X2{VU  9nF636U+"CPv PO0G[Mrڕwn"u9n*K bu~@q1/[> 響AVƽ[ckUt:|wT `Z_tfؑkVDZ{,2.m2o/$n]Jq$ uP!f(NAp~h +tj'LksED\,Hy+\e{N# C֛녩ޭ>}톎XdW9xL}۶^:QkK̀`~imŭ\ +A,#p^C+=鴥tHZaڻ $_9O({3|o'-S17n>6JF^0{BmsQT<~>٧iZj lRhn &&JQ~(wt;"*qMw,^@bRe߁np(su$c9ؠM+Ir/HjIcьqAXfbk@X:#)k4-H #"E!F Q\M|Sur]M,RA +*IvǍqX4'k=g,Y3"eBT a!LŠ!Dpv*~f? l~q~6:~6~ +~6KȠC7[y;k,g\N( Y F$%jIh4x`7& +h@MB;&4n@B?cL?c@jg*3݈ڍ@O1^E&@&OgjSl ΄y5GaT:'RDq3|2BF-!>c n4`G†~ҙ~2B#>H~qdtUDVevdXWK>e>;|MqO%w6tݓ/ F xo)AKsEi!GگB5o'z!tC=$ű`O l稊$Q5鈪9\GTQ5쌪9fGTM1i FXM&X͝ŘvWb W Oھ)_X1 &) GhڱD@X3]C:abqUȚu5,5kMP/b2==\/C|5OdUw+.^TYbN.M녥Et~bѹݦm={oaO%qY^kXqEzlU"m=)cTSĽSfop=WwJjV;zopb˿"ޒנ{Ka.=rX mCۊT$#]//.W>n8_~rD~7>o(+vu00\a:{onb5IAƚ%Dgn:6I$*_{, AU뽴c.470,FWjsSDkx;)b뛏Yoy2iuo%^e2!ݽCE}8ͼ<^]W0?MgWV OwG} ]{h{̛Ba|gHG5jBQ> +endobj +84 0 obj +<> +endobj +85 0 obj +<> stream +xZY\7~_q[R60^*Ikv2Ƃ +aBr1O6vrB;]?'_9|p~޽{d\KB|I4LW|*4)}VJyCk3?>o_m@W .MןOQO&Ow6X @w~?tb` @W 32Iaz,i˓L>es#{w^3;W?,1~tY,!Kޮ(-L.43 Zi&pSM5@uy6%m<* +V%^fƎMQekVi^he`J{Ba \󞪐,q<!Y}?c&dX1i^\Ѩ^ $&>hc큷 4BzeK< gx%:%2xmߒ jddH[rg7-ҵkkV|S1su܂2XzRb.Zsm ʃWV['ܳ|ѷ|y8f#c}X&pTϹ]Ԥp=f^fVe9bfUykeRq}A)M0zq!\3nJsm{Ln* lΥkccHצlʻH\g~NOD_LֆiU[lj"E,*f^Yt((Z..WKXTd aV4:W}+Bˮ+)4N{Qm)à +b4pT¯ĠPo}Hm mh0*h] Gv +Va@q+o md5Li9ˑεԇǐ7O$r!UMV*iezu<|](t ;k nTc`VKE5 Squk9gyBqr2QG GRES9`7 š9tC}g2z9mnaW'@GskMGz}FM ZtwHƒ<1es|cDZh8y-9`n?/fU/h1 =# %HU4+6?ko{=H>}MD>0'2|߀wP~k)ef؎_~8}8}?/2OhLw?&)Kث+ vs)M%K=TT;Z')3]"?!0W%Ğ ޠb:dGu LCS\1 +endstream +endobj +87 0 obj +<> stream +xka~NqD2R,FkVH~ H>b17*.=`XeyHNસV2y XɵծVnf̙ݧt߿~==}~:L7n NB!RtVnրM` +0!"Vc,7ƃ\ B`p Z90~Zh$(A`(-?UMq?P@wʸ?$b%SY!?VXx8To(8LnB²Urv +կ*!Z WR,2 \rcղRn`_|ԕEa"^rY @IoUk7|覑[~R@~oټ]\jY4d@W׼-_O,?{?[yCY4dd+y'_5~{K8_{  +bY&iW׼wi9Xcoֶ, H__+rُ~=cY8_Xyŵ}m׾~}0--2ՊWlCϿ=p_F,ߍ$wM# 즑y,5k+e뇍rlpSI(u$SZG bi'OC4MXQ,wxu9쑣WyDzP,-%*W}SwJ߲m{bcx(V]b bı(TXgڼ34'<b@ݨbMm46Ujb.tdy,vdEbb)E.4<5ҝP,u^q(VgWI#b)S6yYN%CAgH}IS`rT1Z jckEŚhIјlꨗH@ߝdؠdIkI h0!ڼYR#KIGv:U̷%bEXVX6]9ђ/k?}՚+6(#1N7eElbyHw:2h|)kAHlP,r-M!79y?om]]R/V5v,֠]*X5MVB1$(ܠ]JE2)}ъ*^ (VZWxDcܥ:Q,OBBA*PA'\H|G}i<)F㪢+&uj]A;wAVJX'Bb$=]h X15&Zʴb19goEZfc;X}0d TX Ū{P,baP,AA+WWyVX(źyVqxg,?(Vb bXuE, b=; 2gXX:bBR&XÍxDzfP,BHuAP,BHuAP,BHuA $)VF0d31}Q7Q~ ;A,X: 2]w¹7@̄jםpA P,3u'@P,p5(V/ϨXSc6Me!K ylhy^vd6?tFHL{Sbf̟>fv\wk4xGTXNV\iUDp)w*4SlZNz]sudWW}AUNj:j_QG%I?2|IםkWN5a0X"h*V,Dfn贊0%']B$5\bTXòF& + (*8رXkb)_Wn/bi; +4sibIkTC{A*b-U,SCMh&'qķmVB7}+W*ljl;;N:l]V8BvTX6ĆG$PVN:: -:bTt?@P,pˢPu (8e,TsPbNbe +ծ;\S xGvXBN8ׁX(t2>fs@P,pRuP,pdRQ,BHh+Q,RuP,pRuP,p͵iBNݞ; WZŊbwq;v[XVZJ,SLOO"b *>(!"(8LmkjlӦV-(!"(8LίfWMO6~bQfGFgLoq-kUb%~+J:j(@5Q,ؤa\(f[3#N ' +AȐAa*R,>~;Bvn6Mu'=źYXf~UKPJH+qPb5O<zN +9MzJȖ'm+&bJH!19jY¯Ο?T(XH5vz"/Z(֠۲L +j;BS|ڠbf SNX=굒"I+ \u Q:z]sSctug"lPBb ek7ۤ´kzGNI%L`AϣNCaYZBeQ,QOldVh`({d3&۠Rck8Xgu~!_Rר8֗zX)3#r<灤|7ڷP,pW˖ԏŲ?-lсG8RVĹ*ʞbX}2S8XJ#VqeG 1 q*)(!"(8 UFP,BDP,pQK"D$QR>}ځbv+B|~FP,h<(V;v cǎi?#(4R}P,h<(!Xtr}0+Q,BH(r E1 ը͵iv5pj ը}}bmjt,eSQAFFg3?gGTPs45zS; =:zG'Ǽw zWh-5cjlS\;։c-O"Զ"͢.Tq^e^Ex#{S$R29ڭ{MZ@M8;;>;;(UY鷳N#@}+FcDz-Di*`)JSa|mM+F7o*+qJL3\R*jЋU?^EyLRGaϱz+ ;Y +jZ:/zUyAјQGX*шb5 +0~X]7f XoVPCXX؀! +nPGU˜RBZGh+UB`4PTJ?pn઒y: + +Vx+Fcb#ΣϨ#mPɭ^\1U͓e5 _W7}e5aOAT퓃u2ߍ(T&q}E+V?áFSbu~=I}Bà K褮Pѡ)V 1 SX4b)X<2EgC+˩^=}j`T jZbU jZbU \eM.ZX+Q,iQ_"ovPAX+KQ ,j`;ȱc8 $PX\P,BX\P,BX\P,BX\T:e(!$9ZW(4u;x0o\=b,(4NhJwJB=!ĆX\V+[w+G`L=xfyY&!E2biX~%PgzFe^6&ZCPty"ML@kybEZXX+aH@lZ{"M ~_NKߎ4hU[=U@>QTA)²ՙ[~wVFJ'|#bASO?<WbE)!TA5iLmŒ6j6@Gp7n;+ߛs)BA$+Vg;wbXdnnnOĴsXPP,[n!oFXdzzt5HH^(4Tnyb-[y91(ivb3], eKP,X(-AHbcPMǍ7Sc2-Z:cqɠX3##3և&E #pZZN^55*gr+kf|oib)ց4Hb-+b):baY` +ytgy^kB WkV+8_ +B%6INe +33UF~19::Xkf|XEgqqqvv6<}vvvqqQbcPeMғ 4&X)M{WJ"fP;`@JRWMwF;0Wtԟw03sEL7,E]j)*`u3*Ku|pBm2tsqus90X²zL,//`]#t.jl%_`ߖ*WQUN #Ĥ3/:9~2JRe\ʖ'S鉝WXr]ϫ%j Øb +La7EjX ZAX-SD ODum>)Xrhv?C-_ ).Ҳ~b{T,aYjܹ(~9Mt]~r.?b +PIY&bD"~vYoO0`J?&UNei*7 +QOR!ưbeo&oƢ{R)r|pkD6| Q w;b,LIdՔҬ?9g[)(?ߚ$f[(8y +~/9]8*!٠XP(e>sWNzɿ~㭢ٳO>Q̜={BP,2[}}KT/uٽ' gNOOtK.XVQA +Teuu+*+|lvgy2?;[~_fff~_277w"N/PZҎxG ( ;~kSyk~{O/'NXZZ2#Eeii)H֠XP( ;6˔'Nݗsĉ"N/AP,P,X(V8(VQA +L(V_QU w/5b͌Oɔ!g**F'>zkf|맧`Lz7:(WVˍD UbPbuLe%vTԊQA(3A +P,JVрA F)[g\JS~l4A#^`]XE*@H(Z4m5dgHZ-KimO{M:oW-[KhMȠXE*Z̯X<ݽdkŊQ,O4䐬wJWfFJS}'PEΒԱb,OwG /( %X@NTЊ?vKX1XU*@H(YQ0=xnT, IT v~y u)4 e"(TEB\,Qh0;]Rz+VPf5zDQvYp>fAL*b]QeXk@G>=hw ҁbP}A +UP_Ţ\o_2ۊR!5==dpGUTP,(ueαX?ݵ,l9|ώ)[/5;>}znnδ7|sffK2b1 bbi; +{u7M^@x8{WN]Kv_/7/gϞ~7ۖ4777==}l썿SXUS,7v)ֲe+7\珚7!ob\2Oٳg=Zso~c>[)bw(5\{aӷpB9t5\XQc):XِXW#ث'OBl̫|5Wn1],Raײ޻}_n7rBww%uG`xjІh=owӖEyWx_CsQ,(z)Vp +/_C{9cHyCGk~8 !QR=V\\aoi[6oN1b#8_T +}jruܼoڰakbU/[!AZIn_5dzPJ7oY=._;den]-7~ +"ꪎI +_E*VB/!P 12Xi +*VlCTmQ,*LdV) WzJ? ((B(ҐʕxU 8d"lS+sdYTU)KeILQ/(S2F'4a uB j_^5d+ +DݿCd])Ϯ6&U&aȁԪ݊eYk`Y+\Ue4UfTVkY\_ +(!W(VA X,2^Yd4BqmD&,iʔݚTZۄbBI"!+ee}x-Vƥ1?UQJ*[֊ibXy@Ŋ.ؖUո #mR'4¯+黄(@YXő j*W10B +(,(@٠Xőf{ӱޣ˪\V>9EknqVIB~7 ++wsR?tIcka?UmCZܐͲ#rXvBK*e"ϨRZRMX$bUX) +?=eI閕>VTCMg[3kޔYSZiPQ YUb٤^uV8C~#\752R+WP,HO+ˈ,eU'@df0.3 RJҠ'_bH/W۵+]K'?500 +~gyvC?y臟|?r V;yyoyY~yss/~yxkwNyޫW#8`*g与?9CQGLKizmh/(^QO#rQ_3~Ououowo?(~ڽiK/7οuo><מw~ye,z>K].uy[.SV_A֪,wwlŊiJ.zC>r0xim`.MXbIT #W(Z( j! +*Ж5bB +, @Gٟ!Tʜ_9XUTRn J*j)Dذ-+i8nU]kxh +# ^낢h՗+@*z +VbCi-+5V2T_TyJW"ۄbUZI^TCUXnj Y1_0,²9oAeQ~¬_$t@%evByX]e(Vm|MK}ďNX"~B.t]_ԑ?fu~y?#If3zg0SiÞtE]Qdth?bQ(_Yn $G+ԟH ۔9K -X95[,AeJN5 S0Ӱ(f +6 i jNCSJlJ{/r Rv50bZ}aY)VŖep`"ʎL)VE%)_b mY7d-+kc8򫕙&, PB)C̟k8ʡXXVzW`-/ΊX4rGWRXTސ;0uD0.4,rU| 8Ce.N +|dYF(R޽1BKq~H5; *-'P2]Xe'c`?I7ɊeK Ů9Ce).Z5B ۩ZMXA,Ag(J:%(WeL[QV4Au"eW n:C!eiRjeY(=`5 ʃu(V&*oȪei`?/Ư\P,j(vW,Oײ0^C"/1\WVRXY4XC0bYz*X\~b5wZPx{e!ZNQ\W ͽaXbaYAъxdPyqq7@r0bhYDkHW@R'q#~eu%ŎAnŲ XYBՠ8TT8bch*ϲd`*D_$`_^InO*>wW+Yb5Ȳ70?>Ń_U+/E(֕MV2_lM)2eR~eJP,EҬqPNe@w*f.lJij (VnS,, JM23Q+SbP ZP ~r˯,Bb \քڡb%WƊueߞP#oXM+M3lSKhY}m50Osk׭߶ֽidK` Z>x+WuׂvQS(m;b6ݷ?MI1{*M-ޒn!75ӺsȖD>ٽw]>[Xv2uZX%==A.\~… B/ +HĻ?'|*Jm… FnmDž o2<ɓd« (Vxk[·~T~uOۿ+ |'zɧOvaaA6um;~taaA~S{ɧTy Wޙ#hXINQ/JFKkC@ͮzDK ld6;vߥxɧN:ab_DZRU3b  +OnEy}⢰n۱x݆o~zZy ߙCMr +k 8 ZX\\ܷx#*~5X\\K}f/.. +uQ_QӮ76l}iY8b]xwݱ}|3(?~F-K?k?kꎯ]ŋbkc޲Owފk ?c Xr@^MV,Ir~W@Fx>ŋxb`xr O?̾wmZ?|'}\ڍAZ)El(YX)u6#pc8k/)1orFahٳ%R#ŊV%ŒJz\xk]x1оvHj I|'.H2XG6o]ZZ +T#ff%To[?}K.S]]fGw~ RwJ88naGJ#PO2qv47Ξ{oxyVF&)Vw6jjwYZZ1s=P;EhأJ_(RQblgbZӟåw~!b?pϥKV?:pϗG6o~'ܣD66l%mظcGKgH]Xab+;vToQ* +yןjfdV(i +/_;uwMyyg6bYv +wbb;3 (UX-A,GqE@t;(Q#bD XBݱΌb9HbEYYbNĆ W/mygF$ވ(VLjhP+qXSE!*)$Qğ(W/|'y(TbP١R9AI&bYD bhr @]Btlo iHzX=QG>K;^r,p؏jgw6TyDW;㶁beK.8xvp%~L'<= W/@]p.[KzŊbq N Xsjb{C)؏Smv~ +1"+^+fۑݬE> stream +x[n$}"bi$N$؛Y?`7/͞$ HSݬ*:#NL_8Q=) Q\ 0D$NL\HOߜ!CE% "E.}8Ο>?}OLo}u۷_5Nߟ>}b{shϪfj[6Jf}xX3kDvRPL +8ĚBwL֠6 bمߴ$x93hZh'ax" jJ媢yp!^ qRdu=ȁ"_xcIHq$IguK1 J:$%\PJLۭmg;p vGӬ 85藣1yjk3@!THn!t%S0MOPx< iBVL8n AC e! uQlN 1i4w?RHȼAI).o^db (İfP YIbP,""nav "M&/(%ɲY&0ީOѨNjI5Rr(d( OʊRAw.Z`cQP!uP.yUfN1_ejyË_'ɘj8# >@\zniT#GDaR-yXHUqE=& @ha͇W{RAn@YU?V^]7=RJ}!:/J5-y͑蔐,)stHeLy2B(UvYxڮIh?1F2; be,my'|jlvl.@UA_τG:Vm[Ns'L򭱲/vwl¯{_+7t'CSb?XN`nxIB{\:+K6~37G]Pk7K]Ro"Ҷ 27Uq*-iv|_æY{7!&Zq}=Q*򝃒4 ^u.B=xkw ]-o0_߱+:BۿF.fwÔVrt Ԏ@&Hg'sJ"Sh9ߴt}r{jp587_ڕ=no6ld/ͻqmΗ-s`F* +endstream +endobj +90 0 obj +<> stream +xOǞpFH,AxgK^0ҬZAlq 734zW +Nj̪>vVUfDVdD??߈Ww&}e8!)I +,%L½{7E<*׿{y}H%c*LN$,=SIYyX2&'L&$*:l09%U0 0e6Wl; f9}oqmdag0 03ynN'd&La:0 s䊞ɔ*SE -9&GHHs[-y0 ݒw)A &@ns=ECO:V008d39d $ݥU,Y] +E8»w*m3<{}Ƽgpn<09'cI AhO!գ%-Ly2u8C'3tNf/ݒg&:'$ya2\&iEtK.?dsZyV popO=RY]_f p^4u՘.w\k %7(Y*wYY}mv4$ /~tiU}mvI%9L?_ɉ:> +-)L.|Vy>TRR/q-LFz:'%:+yr0I w@}Vu6Ear%>qxۚ9]O~67(- _샦_'L9-$ɻ$xQEQe}lA)ĿtR$y*ͯ¤(B%LNC{RT0\k09u׻UIEQEW=LNOXI13-_R<#sW&EQe09dw(O=;3~ gb$INoTEQCNe+Xl1AbZ)"L*(ˁz&o[CFEeѿ$LR[#bL!Dxd筚?fWT-1$b3Z\%r_a2x_+KYɣ*[3&Ih`d}sɖ vK6(EQEQr1#zYaO20((cn^ӛy3r;w;EQ-?grQ9z& i;@(rek#Fw¤(l극HGTEQC]`ka1-&EQe/eu\4+9S9K8O¤ @n0LԚaD1N/.^ׯ߾~7o=z^C,3O=Ͽz-]Q9>x=__~vyw<ob͗n06Wck[kEZ}Ijy.{|rL:|mj(Ms޾({Ў*e>{~ss:,]ٲߎMy]Zu5cklE..^V`6ߪ?k/{|ONoجjI׋=sq Γ_?}ܴ׋>CW/_Esx58t_>{襌G|4Ғ3)85<0 #g>}_ө)Wjyp_KWt^ߧ_ÅIVXC4Oi016Yޞx'&crgT~Eۥwx%&}zbugEGS42m+~{Co>wXl5׽8i w7S qwRtN2[wnimv}`c ZaH3Rq/)F~=L;m38EwN61w/O]b+Q.j(c>}RFOk}~wca/68xܥcW1,H_J[.=zO?yntHbmF$M[8㵫9'tg$/=N#Cqb=`ݑWNC|\ەJVŘ%5zkig|f:7Va*?oߋFPYÓWa?.XWqݯ`6g4S +Qu95e4}q<Gԃ_|vbӍ~4=$o~CtV 'arݡ4(L?Zy{Դ9D?oG_͏뫫XnX$NkK;caV我i@H Ήote~\__\·_t:ҧN>sg:W$&qJIîH͊O|n>`3n~O:ҕ%v¼_]}/u0y-hB`FSo|2R-'h]Za|Δ|Fj5n6b\>*&h%渔KL~Ym^v/=~\_7gaGo!LFzUz`]_暯 S \(dirTd=?$y)zzWlcLgߎz&h)sk#}Sln-Le4c< #-t7_s..^9!χ+&,mnX'NFdZZOo] Sj>(W?36+~!m:5-#ydtjbx +pe\OQ#|D40zN: SZn}ߩsUCr&SdlTwivQ{#p3yjB:?1RXQdT<-iM5xΣpT)l͋HOgϋij|8[1Q^y}@aR+hQ9?xXLk6bͶEo!LΛVh>W#s;a.6? Ǐo"1Lnֽ_|,*L 6?:4b/t*6ٸf]-yÊ_S 4i}ӘGZ#vzn~l[4+-V{s&;o8KrGϩ#XuR:?e_{g+͂Խ`NaX'$]/(Ohr5 +endstream +endobj +91 0 obj +<> stream +xZێ }ﯨI0 L/6 ywv\$KOvc*](:9uz>uy,ǵ#YLkHmsky&m- 4G]MayVe§OO{ XPbY6UW$͚8 dǨE/m]!6f}V32G5eP~Uc?>)J3'xF7_?/ʮz<]k f}&يWɚDrGHxMl6{'F^$8ՠaca&0ͮ]]-p'XcziHq֮={).g"A)+憖 0Ek*K<- +Á*n=Djhċ( +T#?{Һ_SF]繲 8Sk;W"pVyq5- 9w!^) y1Ml&٣/gVQk] XfoTzn病@ehBÈ}rDZ%Iv|W >'(Gy:xT}TrU}4w(rP Ԩ&|oaKc~3bJ!)8*pp{ʻ" +'C֖'xn\cƋ V9ѹL|Rܪ6`8ˀ;ҮTwINʝ2ѵbbm魒f|+.:UV&ic` .aJ|xöT1J!emMz ܭP;X:DNwjִ(#FK-5߻_qײ޳֙ }͐ `BGϷU`C>,VȚ7u&D+"Bp 5sEk['I5f2Ed9AOײ*$QςWF"-1ȩ’GOI0χQmp!_fGXqODÔ>aI;F`bZKZ@\9e +endstream +endobj +93 0 obj +<> stream +x\],m}_+$fzf/\68?7QU=eiUD!u*ew}(3QlۏnƐrZJcw)l?t(c)Oư(Ϸ/?sw}oۗw,[}w돷ﴆ55h (mػ; 8LǾv?ʿ59kMy<رk[7aH^:qt.|BbĞ҄ދ" ݍc7j魋XgFVcb 0]~_|sV8{I#mh `Ѧ A:YhLuto;G5׎jMk*ӈV{RGllX^}h1f+b +H]R@zEF̫8,{w_wLvI6pFYp 8] +ox Y3 0Aa_X2|GqֲQZOPΤOZo^޿$sqI/Pz>.^WE.qVl?ŭM1Ѝ"4S `- E'o]&P/!JݚMTAhy*3ٚQmw} m\ms͊K.&>%Qr A%,pa׋L䧾 UG}۠jsCRCR V#_ƟNqĬ_YVpN9PDOΉ:v(LZ/*5B^Z$D>_~['W3StJT6pRWc[츴!9sv ;k㝤 Π46w۬i r+is.v ba i&2{$)6EcO2. +Pl1*zbk샑ƛ9ca U1MV[؍͠mn\ݐ +<\RFyhNa&*YR2Ao85n +&ua&fk6c}>*t*t>EUrTҵ+V_-r}r`Na+V\HR̓9ߋKA 1h7@ ptkt.pY( +Pǿ1cP+wzƘ"0̈́1pڋXb8V`bM 'ڗiӉXIwxʪO:vff T !Κgmx>Nz Ȁ[Ad np;L07L{X8FXHb\8p +2I 4#B7(sgA사6[AMy&2[Kr^PhV33k.qfMt]Q +9@UA739; uBp&ʂN_,N1ѾFbok 4,nlզ#9$:sCKt bQX1ŠA"8ЄAX٘FW3gGʣ~+f(|B2ZrźjFB7t܄@ Ql_lzVF7lzsCu/J4l%I@$@ {l'BJ5COQVDܿH+4{Dýnzsc q. +cAL uQ/m*|`Cfo(U={0ё3ڏoa*@=,!]О=udw|' KsV?SpZ*,mV7ob[S8,fۤzk9I\~[k3>52tCC@xVldǙNG+<Yӂ^|Q.D,@Fâ*ld9TbgFyF^{!N %h@p5Z88 2-ʝ/x},Ա6mc'@!TᴱdI q3L@D?Z4U]v re\ބ_^;⑁-zAgvWvA*RSAivAJ;B+j8*Ҿz@^g2լY*L~&I\m"N>ML hkq=). vd.lzcO\nJ`;,Jq-cߋŶƲk5<>r[\`1X TmļW5>s@)mCƕHM`zJϔp=5#=zgw* n +1T~Mfx={Xc 41RX8Ȧ4,D-6JSZ )]6d34&iО^5ͿDɳ6 n *L.Z j ۟bSU)8 l? gJ !H!: +ӺX_%Ǽ7ӫDoyl ;%T5sb'F?ٮϰ?Vg\b1\Kq,a!6 OܨDv] OF@"YK]_gGЦMq p7S؍ɠt8OC`36f zXOXWz0N`- '+0<Hx^_LO:^K.fT< :pM +ٜa_!iR)3p_A 4A3Qq*zHЎ*Rm$É'Al|BIt\+K57 Փ ȵQ_@kE?^_2c$mr,bܭ_T15WJw)ӌ m\~vgd׵\; yu;K]F:3NFމۙK;g Q%#A@&V#3ghB*Rض06qblbĶrDdiuflR[`*~zR)G,g'My+gYq :+ܘ'SL{7T{l<%eMc따+rS = {lض26ufl؆jHƌ=]О^#$^ؤ*'iB,0TjŢj&B7Y~D|$d +Wo'=Ep), LZ0l7 NxRT[Ѯ[VkItJNh5 +͚:_E㧴*s<{C*d+KMs*zEYǔ*l% =}U{ ZX&,^za';GdHM}= |YCb~2L r9ơs/CP8<>\/T{z yMOhHdW0Hua4z7ؾ&|Zkawy 7dhƃr~Q>#gKI<;= +$ӯA^eM={yZ[̔w]9W>?h,|noGhLZLMj:-3#Z%S:`;v߷}2j!y<%U:mtW+IO̝x˛ev* s>1SN +%tmj/ϰQhM򙴣>yldw8b,WI +endstream +endobj +95 0 obj +<> stream +xݿʗKpD8H RD7#^Oe+ 0vpUzur8:.*w3mw\l~p <' @Dhmy "OA 6<' @Dhmy "OA 6<' @Dhmy "OA 6<' @Dhmy "OA 6<' @Dhmy "OA 6<' @Dhmy`1???CKi<<[Dh ?ϟdT?u-v/"]Ig[jgyWIQ?(Ҡvd}_:lnϘEz-5?2<pKfp6vU*??Ҧvd}A}Y3?qDVFʸh޽\]z"OKڽU:"3pylO +&,ݛإWrlKڽU: +"8d%8\"OupTC=9~{Kh*D,,3f{%tDFe) <]e+~nF/N~~Ү" lcTc?_`~lTcUv,ZUG~~_Ҡ[=^UDğ8@m#ҙ 5TwSOK]cO ɸñKj@3?#Ϻ:ySϥM<'>~Ja''MspC7r=]ϢJKl; ̥Y^*yJ2g_/M?&g\3ieTC=-dԽ\]z"OKڽU: +#lRL:R'$,xPO{RmҫT%K=G7_ )igg)_0b-y׮l#%I˭B2iSWJ`l?L> K榣A+43ðSh/ ?&X& Tfݽs|Ɯo8z7jǫdǧjmۭđgW DAԈ K'=I~&UL*~ +^OyBO]G5ag)Mؑ- +u?ta#$h[V}LcbS^԰ <'dpçQu(1D5)\UH#R=d0|c!]̑>UޡB<86y8=`Q?iP8'wp0<˨v"O'z<()"OS|G ~{zg$ypyp<6D*"O 'X"OUy2 y%"O?'ԗ߾|}u}=uyI>vO߿|{tqo߯>۷^|%o7o~]\v ZH=~r}'NiZO=wi$. ,%җv}VVcr@݋OK'Ȩiy/_]_6_R^|%ǧϞn5(|KT*4-ՕGV[o޾cT>-I/ݔ~G2Yyy)(0iL?zDXhzf(LLpwjf}|߽qݦMv|叧Ϟ[V*vף]]}nQnJ..^x֮uss+v[rmѸg ||tJ&kIǣO$mnzvM4ۭ$`߃؋$\!;i 2jZ6+N/pzv.l}}ݔJF,J^w_q}6e635=~rH(|Z4Jfsy;Z-x-OdWJwYI2Ajk G̿_~er,-lR_5)wfE3i07oi+B1{"6im"mmB:)m ZTG'56t2rXK"//?ỉkkf3iCE:xKfou]^y(~aY!$*TtgmهOx88:9YuFӳs=zPd,ER.:7n$J5Gn6nA +ު,_N&G.7l+eԴTk4g͈R(Lf[f2PyJٸl˛`5Hܞ$Iz襾O+[6Kgj:WshWWe)s# v-VKmB#^횻ң44œ&KW)Wn]b}[>cc6>T 4Tk ɴJw.T7J#Õ.[8.Vt6"Qu߮@z-k=7K8lgٓjAr]jewP\]wTK2jXgRO%KwLvn[<;Q>Qu׀ӞE_igvf?hF6t䙽k&͇ӳs}IM욻V/*K37ߟ- {ќ< =(Z[-tTD} stVa+eԴ6! Z+nf[_äAffWZ"3;3J+%CKaN/ ~Qagw/eH "ϠLҎCPGuݥ)ҊM/ݱO7NJy Nk6,HJEEx Ͷfަu“2宩fԄdG9gJ'_ ۺJtgp *]gguIv;}V魝TGj-KsLn7Ԝ늲w`2jB(GVI(B?iK:XL</UC%8\ZR[zӳsHKi˖3@ hוʤ>T7샻jY:ERtCjdEڗ n5R4yRn9"Ԏ ^Hs5[Sz#3J."y: %_MUpTv;.@u$/}[z.{f3ײV6yk:}}%MM(N죰}v;ʂ1*cgcgZSW +ɴ-fJWdmQeqyHzur?fJpHw!{f$o&,|NKH):)g4;n;;J/{FRXCk-rgK~U{2\=7}n iأ4H[ +endstream +endobj +96 0 obj +<> stream +x\Y~_LȪb N$Qllر L7b_]\co]>3 1 v@9Ƣחnp+ϜQZ`eO_,ӓB.o__/o߾.~}]-bC\D7 oeMLkyf?yB_]o笡ɌH%=L]yDOYPFu y3;9Mv4.!؜uwzgwRaGW^JmRnո$w40u[T[S=V:5א)i,j.c:ը.҉9g-۱C+TClywacƖE:0'}o>qa|bX:6Q1*,>Htj"ղR5y@ag]>e`d?Cy>+]sa3v" +!^hWW~{`ptq6:Eb]Uʕiu_]~8pқT!>U(EV?4^/?=)h7C46xMQs0X0Uhg֝W\0o[8M+%v%턈m<;LXԶv&ah ֆxY0qxM 79)%MLJZj*φO;ODUhTR׫í-7ZiW>[ S|䇬=>`}5;Ja"X }YsG $*M{8Tj͎X!W+! +|dCPhL<)9\Kޟ<iTdYA}_ܱ4)ݶ)߉j| r;EMڰIp} + >'`%IK8Ssmv%7̤ZK'mEhh$Tζ>9Cx6.n̜8(oQqkrr#8E%FvL7^nBnSyuZP]{9zUHZy]Moƛ]BwM +)UNdwH[T:ÁZN`RV˾W9ig8;1`\.Ƣ<*򞦔m$32soʷը2]LNZׁ?JGUevuft[뛖RmmVX_wD5hj-;k9Dp$NWrkU=m8NUF]7oi' o9[џm27`>HǣOݎI nFS;nf֫@ڿ:7` ]QY'[IjIZJ+*RTVe;^y:lrn`;?ޞƗbTMff+VZ֐!.Gr`^6ZqیcKHGǕ [Iծz^DS)oV7Fn; K% )uۙp0)P +hǢElM 0EAMw|7!|!%_Fvo͐t6৓;; +{OvԐfH8BgJ! +2 +>!LyUIo}EOgUYh!qo Z~Dÿ)< .j =xѭȠ*թcAȲcZHuB#ht|i\Yt3_Nc!l\'HKqp#n +@wf(gbLwUW$c,~w^ +]<ǭ#2R=ʤAv79e͌y8~ɳuZϘf<;6䟃7Oh 9)v.W񶅨<6V4D5tn;n$:Hww<|oOg7|xc"qt [\odh=ͼHHrr$W]ְss^ؠ7z2'Aj"O[,a+xк *A@ +endstream +endobj +98 0 obj +<> stream +xߏǝ: p`9mXz~84`NpAA?,XCd[eWfvelfc`ì;aF<B]]Ul6 [>{O|w U F*TKߩjwM͍ˊ;~Q/^U}c?3O=]8CAۗ'N??vS=s_?? X.O~O=?Ĺoǥ*AA.wB&=#׍  s}wAA~gs>7.J_% (2.'y'޿ׇ  /1,[: hZ'N}3O=]ADq橧 A /Sξb=BiV%fw_}#(.3S(dPs[q(yDl(?1)VXy+LFJid{inN "L/A׃gRyPM"Ɉ80FLA1USξ" ,Ĝk5Ւ0)V@ {Pn$ y0 A:c46.jlc>@ {~߄YdNAmdtp @]d 4<M@d TO֙rHL TgaAX))<U> /)<U> /)<U> /)ungcS[V{Zg/,~;h[/_H*.9x{~5Lh$g}/^ zT*pj eyMs7+#7NzmϺOw_i*MIQ]iњeLe\%=(+W.wwV@vOM3]֭8#V>Uky#qEVr(F(`_BNkaz\<϶̩tnV˨I\ܧ\>ee%ly둚Ev<Klƞu|EՔGpQcd؁KmK')ĕhտ5u)X=AzZt]F_o|!kݧ𠍜:TKZBclSڧӾB'{Sٺmuold>qG횏JqP,nq;%q3҃J3Y7]`T6JqQ҉0q\Cs-%ƭ^MKަl}VB]z_+5Z҃ zPz]l7j)Egݧu~6i޺9R5 (S=XtCyyݎu4 JI8\tGc4"}Vxb>_^ܶxJ UlKh@GXm<dfV$Lʣ7kTةkۧ{U[:so]=e9auZceԯus-`\7iYPw.+%BVud@-i Nƞʙ2zSS57id*}F}JB1xj } _S&x } _S&x } _S&x } _S&xFRL{w9$& +@d 4+Q*O?'^ϣYƃʣҗ> ,ڑJFnwN7aEyp8 Vr`/{&6אޫ4%UV;[~qמWA`&NgXY +!~\7O~/iJ*MU<荵haX:l *SᖄkoTtd WX45ǭR*zpgkJԜJ,fxll&&y0vo poQٙnemeRnCh*hWo_]r$փiJ*M5EÂ,WƮ\q0 ;TX?Z#WS֙UZ] xNCi#Du`0P ё, h[.sg^t7T*lYzEdğhW~,"\!zG_AV6zP?4*2RVneF0 :[#]Hhq>]GI54ǃJ:90d 4<Md2Ph2ĀWh4:<<%qxx8xp òw3xpA%J'_,j>N>V (<>reseda,VwgOjmXQ:(׬]xHykYNhrɋ2Q*i6&u"?BLvdMP&\V=Efim<$cZhњՕh%뵽`f:*Nj3ڕ%E Z%XZ Wz0hbEeɘٜ?h)\'Xr^/ gO::0q +wD|g5j-i}8-zQX+`J: .q}5^)dR{2v;%,<P:xDx=@Y>ϧ/AdE=:]ÇՃ`-(Ѓ Ӟ?4Ro&5Jy;!l<x6ɷyx6 e ( h5AIuA{UNk5u`0P ё,)̃>BNW=] Yg=k҅깢9l%An.BN +өZhYyƃd 4<M.d2FCшd3jGC(#M @y <PG +Xy+ߺO{`k,AfPypq\1mĺ)wmQo rX1z tuZNGI|et1|NLqzU㽯*RMM@VK2Y>g|[w=v|I㣡+KTbj8]1pqQΪ=xזtI{ ol {mϭ[Z8 dI&s9UU׬Tm3ف 9݃v-]n+zV2TL3NU + NSNn) +\ىBAmT݋yoUmR@TU%xP<.꿲*ftn:ae}jV4.+*,A6XB+A:]'*Þzizu*T(0E N\:0IG1ɈQ:4jNN& T2&HZ%X1ILY48#ʨR%ԫ2j9?42Vsp5\qK>y\0. +PU%7tûr ʉ BF`ښŬxrȒLa)rCN; paу+v2'!gMM +@Sh#IBw9.A~O4փDDDd='ɤ_~?L⎙x &Ah2xLf<Ah2x &Ah2x &wo6`ejɃCCwVc+<$k +TbVtUבc2@${0liZi9]R_d񠵾_uF>X̓q݌$pbr@ݒZ}׌-ih+Am\Tz-⬹;N!<݃u28SH[1mJ+A}"=7ǸN%0F2W;8KzP_y>.U K @"U*?+N8Ψ]'Rst+ ?ڵ}x/_?ѵ\Txp?/Jؖ\/nܸ1Q!<5[?||Ν;_җǙ>Y~[?L&ׯ_ PxjJ_%燷۲w7$/n߾=zuT1_(hm+w[rdoo/?/@qA)ƒxBPSlm',Ē <5%C> +zV-v_+BMY4tu]i((tװݖƒy,͉ocjjVAZTZ{Ύn4XO}=;r+L#MmubP; ԔAKk=|kkТ`i/[m63wrje)FKX <5e|0-d0᝕{0\@?/Qѧ1fX/ɼqT<BMY`h$GJE`H L>h`B<ksp*=Y\ѐ?9Dlnxc\48 BMp^rLq<{?̻Ǎ/N&H<k T<BMiT<BM9ڵ*LʖXܸqc??/@qn퓟~Cw(g7v8ڵg9<~]<ƍ +o߾=Lx=ԎO?oǏG{^~v[oi +c3;7oo~~PO~_ $ҥǎ?q.Uʅ o:'gyke@A\zg?q;WJΝ{r%x/?裏9BXo^s}/{\~<3 .] +RX'>t O?R%q +endstream +endobj +99 0 obj +<> stream +xMoFqdc{Dqz-#/iw؞CN&A{6,ؖXHRBC$Jl p61]Ç$/MBBUOU=bEq7Pj j ߾=s燆. " ^a|g@7ĉs!}oҥ˛[[y:ȗ/)o1t鲘?ƌ @qr㋼mt_n|qԻw6wϜ}~X= n޼lo͛7ruzzziiLMM-//[nY^^tG{qI)Y$&`aaazz#H$穩]j355򖥥%a#:;;#%´BXt:.&&''EIuM/lo<$(gm]˒K,//[z?}'JeZqtY\l-Ki~ԲҤ"!EZ&- )Zjvvwa,Ŝ%.q`qh9X휚Ӑt奥%)TrI֟Z /0Z#CDO j]XXZ-ΪX$:m6uFHy +cDdUY[C j155EfP---HZLh +Za<$[DЩ@CC:==MUV+ 5HT,jU2J.ı(r*/0Z擔4Svʟ3K*[ΒoS$Ys|ȅ<1bO_Qv¢H{Ł07^+1&pj2jsa +蔊Z&hfۨEժʥIZ9?M!LG*?ZZXX 'fDǩ$ A|X& k{<qljX]z MDZO{h?ƼL ~Qb^V˖ P,Z[˦{hx2iYZcc%58ޡgUZcKs䥦g ҎXBwdI|אHiiGtoQ˼K%ZvG-2jކUD^A2/齓";PlS,-ԫmMK|I,u}u ڝ+@jWGݡEl˼ہ}2 (q/w~y25 UGE %v6ik{_Vo/gOW;byE^8e-E~Dn):27z9(2Z@hr-Pe @9@(2Zn6 fDG!~pp +`}}]+Bhh݄ +FC+hb-PRj7 @nulB'3Jm$hٙV*2y3_TNfdE$-4K`'f1f:^[/΋Rzu2 +OLe\*x!Gt&~(#enz9g<1j335W@H߱$ՙZEL9]>]`Q8.oe½>Kf +7 $a{iͮW&z h}/^񻻻/^HZd:V5 \&ZSw;\h<(T'CrWYL[gzULf\eh;f*Z#fۚ]&lc@ϟ?]YY+++Ϟ=h{_coD擀+\A;A-5vv*Vxx.b@)ޔWh34ٵ&5vqQx)ӧOyYzKmfhZV;/tZf2{vb 6?S&3S|gi*2ٯ&4ZsV1IjZk LXꭸc7I; Dԝ%ìKn^\ϻR6$r^6̋aKkR!gch9 8tI_fƲ\/pSݡ\Ǒ7]5{_68lȫTdeL^K_3a,-eZv9hT}XDyLؼVI}7ű<72ifdӲ$~gC+UDR2cLZrvy1Ӳfx[ +~զ @(2+i6_~ @9(2Z@>Oc2~(WZmi[@W?SnK F -3 炖TI+EL-D0^]nVSVع -@% +Y%?qf~_ -g!WgR He&.jt؎hZk5]UU/,*ڧm5T"-3~fl2Y\5FnI?-5M{4}>;%:0oOut%:ZʄI;:kůku}zHx(%R kJJ!{U3sIAWȿӯ 6=JJQnjzy~V%49!Ģem|_eM*3b4LDFih[iG0MWƢ@?²u9+cYٱM6=XKޣ ˄U| s NW܀[(:P]TD34-۵쎱O -kre%Y- e H铛CKG]JeLL:Vh1^5xW ?|ժ#%F-xx)ebhG:600/zeR <dwu&Չ )qFokyQҠֿpfN> C# @9(2Ze/1 ű + J ́Aq92(.2Zܺu+@(˦@!C:9Q诿^1c=jxo.chPn !i)4AбIm1oy&egK9{u M5O]9H6 0j9p\*zDZyMLOĤIkX2x)љ-sײ4Ğ$I)U/BMl˼LƶhJdіؽA6`OUm -$eX}FVSjWF8M# HVMcd|x)1=6e}L~l9 jsK!yﾠ쁖9)iY!o̗xvv%Z椧eZ@ˠ@hh-2җZZ@hr-PeA -zHZ hr-Pe @9(2Zxx+O׳uqRul4kq|@&ݽ/_eプ~ղ3QN8HtylZ6CD/zRG3}-&#-$|muFԵܲ^'A˅Z6QuI‡]OV&m- }\iŅ>fbVr$iSY"M@&iY3+V|}iMen3[?QZn)-4FeвĴ\SNL5elOB"Bc8 =o&M@&]cKsURղ~x-۟Z-Z6Wͯ4`hĤ^ƈG)e-TZNhDMUQHQ˲jbWޫoԙ|u*-'lO+@&ero-M 'FiN +Z6-ٝ|]wulnn6|{{{$ѽ%nR>\c^ߏ\hѣZZn>v_6w]~OBnk|wNUϟ =t#s8}|׎.vxR # +$/.À<ۂeo]O4 +endstream +endobj +100 0 obj +<> stream +x[me ~\W,ˆ%0sgn(46 nI6Ϲ/a ,3sl˒l4l ^/džՆVlmZygbKg+9\da3gz7"'jvntōn!34R!شֱ:YBG3>'ݲ@5OaoAӐƸbOhp HH7u4MCtI쒄 $.Ig$]%:MM` Uj 8ջ=1p|6=RGy"}h`ZŪڟn ` ˪ {?Ho^ \I gho jySHM o1<#fUMXcņIOC~eV=[ܸ\9=u:\ Zh:DwO\6{]ЕMc4uGhIڤ13[bޠb4q= jzIv f.nb^\,~⏲.{.N" NJ,0zWZ|.us(f̫H;F͡3qŒ@.e]K0rł{.'}߮ԙ~&vڏJΘUg˵镙қ*o)e.bOs6tQOc9m7Mo<__8&8++<' sq(/PE(ɹ-De vRK>$ +[2 <{6G#C;vy9t'a-(/ɯAwsk8C6]}OY?Ͻf~c/sڮdԾoQWnF;n-Nۡh+jqlkeE?PRO}:$!zhm+XY|_TI{N%8bK\JYTd7aDjdkڇ^&xZqiL GeMX{zG@N^>)LZ`@cn7hgE[qtYYr!TGoȏו¼s\~[Džح5;Z#v3/yisZuƥ*jCK s!=> stream +x[ۊ$}ﯨgr㒑Xfd=mA2TV^=څ'"3rDT! 3X4c Ï?_>^8 Dl:b.?aI[ +>2 +t/~uy_?_}wmÇzyw N+Ɓ`ax="0;;Dq o^]?=?=BqPtG fuIh0 0u0 qpm[r9 .4QҀ3:6[&g +ow@@k H1! ΅65WXOeR7ЉJZ}is}ÆIF$D5)k5떡ޅ]Dg%3wɑ=pu3{bMs5"6Q\#:rQ ޞPWfw7ANhpK3iQUXiLIЀve0* yS +1ٰevSM[o<A "NjE1[ȕk.h(Dp<4]Z*BI?_>G56gӎU:m2E#d)gHׇI8-__}V;Q^v&Q܂\O9^οG1U)f֙D0fnռ{7Mk'OG&XFi@;d&e!ǩ{pC/j|wYdy40؆fj{v?:{tNZMe匎\y9?mO.XɌxM1fu[FC?U*qhI|XA5Ss5H.Jb>WmM^yKE^i?Hu$0!iҝoʁ5 +TeϤXU$'/`'&R U!*p*OߕY@EH5`]5HN&8& +dT[!Qjyl$ &땻=t%/8h9< TK-"rqqjʮIGqxT:,lvxJ8LB(24qyߊF(E3tġ3_&hŔI1E9({:Wje6b@gUh+]so%Tֱg<-e 0 +*;EEIVgvڼZ~p wNQ9rq9*Q r":l>fAB͈"aq q߲s<21SRt{)o-'̺.YZJ2nKp!h;[@;LDyZ!تQݺm +F3XkoM_4oߚowxoȉc=In l[-;]/ї s6 Ҙ}JKܳ'͆8ց-5jtNU_cShSc=6:W(:VX`:JS^9KG>AUυ.Y?))'V Xڟ͜|Z3N_[[(ؖVzF5KӺ] Pz9Y}q0HA(ɦG:"mW6QlLTζy|CۓՉvI»GZGktX[,z|8̉ TTƧxt:)u| s(Zu Q8Bm.Ŏg#یҊտj%T f*Zé4,{wm{VDO֕!b:. +ׁtj2,ڡi>VqZ!Hoh9)Kq$,gMG +eO ŶV)0ʎ0H&c%z>r18CZ_BԃAY,kk| + AqSb>O.a=|}{Jf:q%&E60}_")Ф̦H-P3[&y +endstream +endobj +104 0 obj +<> stream +xYٮG }HԵ]v-B!H ?jWgAJR./v#F_8s]Ɯe@HF2 8FO\șƯ?~? _ʛ/<"qNo՝ɏ|~_|qի0 cyd.Z`t +6WP.BB1_]QU/ϟ~o]TәG#q$<xIkk|`vn7>/3^g]3]t+T*pZӌIMʬ.c;8[ݱ٘d\'( )0>9TOU9IZ.;yƣ()¢1*Kұr=8o +h=ף1Sy32 -k>L9s)d]zj_ѻE(tMGLZO6$bL6կnyi!*挿 +{<5ɺuA7 {:nl?8mP 6W/iU4h [p+xT*([!7{Jvf4R@ Q(&_3) 8 o|641 jAsRڦ|?8XD=ُ.D cɐLK/JzKхa(7ln(R\^/r#]$dٯh[73}HgƠaAV[]Pcѥ8mUb*M`41e <2dzB +/XyjTwlb2"2\%_wE0wBxY\|44.AjA $"K׌ܬ]N,4`L.:v 4BVO)R#FIGdƋ +% 5$߮F`\&^&pUGd "e^u8 7qzws_a^ -_V/"!]$n٘1s ݽw) \re'ƀs CK?mfQWI7GVċhvsXov1.F7_IŊ롉@_9Rc+unFݓ #FH>]`$뱟هڼ/:}:<.ڣ_sI':BJyNjxᶣ8~Nxރk߸\ E>^{ݞi٣c”-J9ӫZ/}i[k2DkT)F8]v_(*.-'~~NҚh8S-9.JjXmpښOc^S~@Б^ 뿊oo?ѡ&yT$P;&yS^A|ٙDlѥ`9I'n@{R}bG}!1Q\+ +\O472\))ӏ +endstream +endobj +2 0 obj +<> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Annots [7 0 R 8 0 R 9 0 R 10 0 R 11 0 R 12 0 R 13 0 R 14 0 R 15 0 R 16 0 R 17 0 R 18 0 R 19 0 R 20 0 R 21 0 R 22 0 R 23 0 R 24 0 R 25 0 R 26 0 R 27 0 R 28 0 R 29 0 R 30 0 R 31 0 R 32 0 R 33 0 R 34 0 R 35 0 R 36 0 R 37 0 R 38 0 R 39 0 R 40 0 R 41 0 R 42 0 R 43 0 R 44 0 R 45 0 R 46 0 R 47 0 R 48 0 R 49 0 R] +/Contents 50 0 R +/StructParents 0 +/Tabs /S +/Parent 105 0 R>> +endobj +51 0 obj +<> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Annots [53 0 R 54 0 R 55 0 R 56 0 R 57 0 R 58 0 R 59 0 R 60 0 R 61 0 R 62 0 R 63 0 R 64 0 R 65 0 R 66 0 R 67 0 R 68 0 R 69 0 R 70 0 R 71 0 R 72 0 R 73 0 R 74 0 R 75 0 R] +/Contents 76 0 R +/StructParents 44 +/Tabs /S +/Parent 105 0 R>> +endobj +77 0 obj +<> +/XObject <> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 81 0 R +/StructParents 68 +/Tabs /S +/Parent 105 0 R>> +endobj +82 0 obj +<> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 85 0 R +/StructParents 69 +/Tabs /S +/Parent 105 0 R>> +endobj +86 0 obj +<> +/XObject <> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 88 0 R +/StructParents 70 +/Tabs /S +/Parent 105 0 R>> +endobj +89 0 obj +<> +/XObject <> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 91 0 R +/StructParents 71 +/Tabs /S +/Parent 105 0 R>> +endobj +92 0 obj +<> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 93 0 R +/StructParents 72 +/Tabs /S +/Parent 105 0 R>> +endobj +94 0 obj +<> +/XObject <> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 96 0 R +/StructParents 73 +/Tabs /S +/Parent 105 0 R>> +endobj +97 0 obj +<> +/XObject <> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 100 0 R +/StructParents 74 +/Tabs /S +/Parent 106 0 R>> +endobj +101 0 obj +<> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 102 0 R +/StructParents 75 +/Tabs /S +/Parent 106 0 R>> +endobj +103 0 obj +<> +/Font <>>> +/MediaBox [0 0 595.91998 841.91998] +/Contents 104 0 R +/StructParents 76 +/Tabs /S +/Parent 106 0 R>> +endobj +105 0 obj +<> +endobj +106 0 obj +<> +endobj +107 0 obj +<> +endobj +108 0 obj +<> +endobj +112 0 obj +<> +endobj +111 0 obj +<> +endobj +115 0 obj +<> +endobj +117 0 obj +<> +endobj +116 0 obj +<>]>> +endobj +120 0 obj +<> +endobj +122 0 obj +<> +endobj +121 0 obj +<>]>> +endobj +125 0 obj +<> +endobj +127 0 obj +<> +endobj +126 0 obj +<>]>> +endobj +124 0 obj +<> +endobj +129 0 obj +<> +endobj +131 0 obj +<> +endobj +130 0 obj +<>]>> +endobj +128 0 obj +<> +endobj +133 0 obj +<> +endobj +135 0 obj +<> +endobj +134 0 obj +<>]>> +endobj +132 0 obj +<> +endobj +137 0 obj +<> +endobj +139 0 obj +<> +endobj +138 0 obj +<>]>> +endobj +136 0 obj +<> +endobj +123 0 obj +<>]>> +endobj +119 0 obj +<> +endobj +141 0 obj +<> +endobj +143 0 obj +<> +endobj +142 0 obj +<>]>> +endobj +146 0 obj +<> +endobj +148 0 obj +<> +endobj +147 0 obj +<>]>> +endobj +151 0 obj +<> +endobj +153 0 obj +<> +endobj +152 0 obj +<>]>> +endobj +150 0 obj +<> +endobj +155 0 obj +<> +endobj +157 0 obj +<> +endobj +156 0 obj +<>]>> +endobj +154 0 obj +<> +endobj +159 0 obj +<> +endobj +161 0 obj +<> +endobj +160 0 obj +<>]>> +endobj +158 0 obj +<> +endobj +149 0 obj +<>]>> +endobj +145 0 obj +<> +endobj +163 0 obj +<> +endobj +165 0 obj +<> +endobj +164 0 obj +<>]>> +endobj +168 0 obj +<> +endobj +170 0 obj +<> +endobj +169 0 obj +<>]>> +endobj +167 0 obj +<> +endobj +172 0 obj +<> +endobj +174 0 obj +<> +endobj +173 0 obj +<>]>> +endobj +171 0 obj +<> +endobj +176 0 obj +<> +endobj +178 0 obj +<> +endobj +177 0 obj +<>]>> +endobj +175 0 obj +<> +endobj +180 0 obj +<> +endobj +182 0 obj +<> +endobj +181 0 obj +<>]>> +endobj +179 0 obj +<> +endobj +166 0 obj +<>]>> +endobj +162 0 obj +<> +endobj +144 0 obj +<>]>> +endobj +140 0 obj +<> +endobj +184 0 obj +<> +endobj +186 0 obj +<> +endobj +185 0 obj +<>]>> +endobj +189 0 obj +<> +endobj +191 0 obj +<> +endobj +190 0 obj +<>]>> +endobj +194 0 obj +<> +endobj +196 0 obj +<> +endobj +195 0 obj +<>]>> +endobj +193 0 obj +<> +endobj +198 0 obj +<> +endobj +200 0 obj +<> +endobj +199 0 obj +<>]>> +endobj +197 0 obj +<> +endobj +202 0 obj +<> +endobj +204 0 obj +<> +endobj +203 0 obj +<> <>]>> +endobj +201 0 obj +<> +endobj +192 0 obj +<>]>> +endobj +188 0 obj +<> +endobj +206 0 obj +<> +endobj +208 0 obj +<> +endobj +207 0 obj +<>]>> +endobj +211 0 obj +<> +endobj +213 0 obj +<> +endobj +212 0 obj +<>]>> +endobj +210 0 obj +<> +endobj +215 0 obj +<> +endobj +217 0 obj +<> +endobj +216 0 obj +<>]>> +endobj +214 0 obj +<> +endobj +219 0 obj +<> +endobj +221 0 obj +<> +endobj +220 0 obj +<>]>> +endobj +218 0 obj +<> +endobj +223 0 obj +<> +endobj +225 0 obj +<> +endobj +224 0 obj +<> <>]>> +endobj +222 0 obj +<> +endobj +227 0 obj +<> +endobj +229 0 obj +<> +endobj +228 0 obj +<>]>> +endobj +226 0 obj +<> +endobj +231 0 obj +<> +endobj +233 0 obj +<> +endobj +232 0 obj +<> <>]>> +endobj +230 0 obj +<> +endobj +235 0 obj +<> +endobj +237 0 obj +<> +endobj +236 0 obj +<> <>]>> +endobj +234 0 obj +<> +endobj +209 0 obj +<>]>> +endobj +205 0 obj +<> +endobj +187 0 obj +<>]>> +endobj +183 0 obj +<> +endobj +239 0 obj +<> +endobj +241 0 obj +<> +endobj +240 0 obj +<>]>> +endobj +244 0 obj +<> +endobj +246 0 obj +<> +endobj +245 0 obj +<>]>> +endobj +249 0 obj +<> +endobj +251 0 obj +<> +endobj +250 0 obj +<>]>> +endobj +248 0 obj +<> +endobj +253 0 obj +<> +endobj +255 0 obj +<> +endobj +254 0 obj +<>]>> +endobj +252 0 obj +<> +endobj +257 0 obj +<> +endobj +259 0 obj +<> +endobj +258 0 obj +<>]>> +endobj +256 0 obj +<> +endobj +261 0 obj +<> +endobj +263 0 obj +<> +endobj +262 0 obj +<> <>]>> +endobj +260 0 obj +<> +endobj +247 0 obj +<>]>> +endobj +243 0 obj +<> +endobj +265 0 obj +<> +endobj +267 0 obj +<> +endobj +266 0 obj +<>]>> +endobj +270 0 obj +<> +endobj +272 0 obj +<> +endobj +271 0 obj +<>]>> +endobj +269 0 obj +<> +endobj +274 0 obj +<> +endobj +276 0 obj +<> +endobj +275 0 obj +<>]>> +endobj +273 0 obj +<> +endobj +278 0 obj +<> +endobj +280 0 obj +<> +endobj +279 0 obj +<>]>> +endobj +277 0 obj +<> +endobj +282 0 obj +<> +endobj +284 0 obj +<> +endobj +283 0 obj +<> <>]>> +endobj +281 0 obj +<> +endobj +286 0 obj +<> +endobj +288 0 obj +<> +endobj +287 0 obj +<> <>]>> +endobj +285 0 obj +<> +endobj +290 0 obj +<> +endobj +292 0 obj +<> +endobj +291 0 obj +<> <>]>> +endobj +289 0 obj +<> +endobj +268 0 obj +<>]>> +endobj +264 0 obj +<> +endobj +242 0 obj +<>]>> +endobj +238 0 obj +<> +endobj +294 0 obj +<> +endobj +296 0 obj +<> +endobj +295 0 obj +<>]>> +endobj +299 0 obj +<> +endobj +301 0 obj +<> +endobj +300 0 obj +<>]>> +endobj +304 0 obj +<> +endobj +306 0 obj +<> +endobj +305 0 obj +<>]>> +endobj +303 0 obj +<> +endobj +308 0 obj +<> +endobj +310 0 obj +<> +endobj +309 0 obj +<>]>> +endobj +307 0 obj +<> +endobj +312 0 obj +<> +endobj +314 0 obj +<> +endobj +313 0 obj +<> <>]>> +endobj +311 0 obj +<> +endobj +302 0 obj +<>]>> +endobj +298 0 obj +<> +endobj +316 0 obj +<> +endobj +318 0 obj +<> +endobj +317 0 obj +<>]>> +endobj +321 0 obj +<> +endobj +323 0 obj +<> +endobj +322 0 obj +<>]>> +endobj +320 0 obj +<> +endobj +325 0 obj +<> +endobj +327 0 obj +<> +endobj +326 0 obj +<>]>> +endobj +324 0 obj +<> +endobj +319 0 obj +<>]>> +endobj +315 0 obj +<> +endobj +297 0 obj +<>]>> +endobj +293 0 obj +<> +endobj +329 0 obj +<> +endobj +331 0 obj +<> +endobj +330 0 obj +<>]>> +endobj +334 0 obj +<> +endobj +336 0 obj +<> +endobj +335 0 obj +<>]>> +endobj +339 0 obj +<> +endobj +341 0 obj +<> +endobj +340 0 obj +<>]>> +endobj +338 0 obj +<> +endobj +343 0 obj +<> +endobj +345 0 obj +<> +endobj +344 0 obj +<>]>> +endobj +342 0 obj +<> +endobj +337 0 obj +<>]>> +endobj +333 0 obj +<> +endobj +347 0 obj +<> +endobj +349 0 obj +<> +endobj +348 0 obj +<>]>> +endobj +352 0 obj +<> +endobj +354 0 obj +<> +endobj +353 0 obj +<>]>> +endobj +351 0 obj +<> +endobj +356 0 obj +<> +endobj +358 0 obj +<> +endobj +357 0 obj +<>]>> +endobj +355 0 obj +<> +endobj +350 0 obj +<>]>> +endobj +346 0 obj +<> +endobj +332 0 obj +<>]>> +endobj +328 0 obj +<> +endobj +118 0 obj +<>]>> +endobj +114 0 obj +<> +endobj +113 0 obj +<>]>> +endobj +360 0 obj +<> +endobj +359 0 obj +<> +endobj +362 0 obj +<> +endobj +361 0 obj +<> +endobj +364 0 obj +<> +endobj +363 0 obj +<> +endobj +366 0 obj +<> +endobj +365 0 obj +<> +endobj +369 0 obj +<> +endobj +368 0 obj +<> +endobj +370 0 obj +<> +endobj +367 0 obj +<> +endobj +372 0 obj +<> +endobj +371 0 obj +<> +endobj +374 0 obj +<> +endobj +376 0 obj +<> +endobj +375 0 obj +<> +endobj +377 0 obj +<> +endobj +373 0 obj +<> +endobj +380 0 obj +<> +endobj +382 0 obj +<> +endobj +381 0 obj +<> +endobj +383 0 obj +<> +endobj +379 0 obj +<> +endobj +385 0 obj +<> +endobj +387 0 obj +<> +endobj +386 0 obj +<> +endobj +388 0 obj +<> +endobj +384 0 obj +<> +endobj +378 0 obj +<>]>> +endobj +390 0 obj +<> +endobj +389 0 obj +<> +endobj +392 0 obj +<> +endobj +393 0 obj +<> +endobj +395 0 obj +<> +endobj +394 0 obj +<> +endobj +391 0 obj +<> +endobj +397 0 obj +<> +endobj +396 0 obj +<> +endobj +400 0 obj +<> +endobj +399 0 obj +<> +endobj +401 0 obj +<> +endobj +398 0 obj +<> +endobj +403 0 obj +<> +endobj +402 0 obj +<> +endobj +405 0 obj +<> +endobj +404 0 obj +<> +endobj +407 0 obj +<> +endobj +406 0 obj +<> +endobj +409 0 obj +<> +endobj +408 0 obj +<> +endobj +412 0 obj +<> +endobj +413 0 obj +<> +endobj +415 0 obj +<> +endobj +414 0 obj +<> +endobj +416 0 obj +<> +endobj +411 0 obj +<> +endobj +418 0 obj +<> +endobj +419 0 obj +<> +endobj +421 0 obj +<> +endobj +420 0 obj +<> +endobj +422 0 obj +<> +endobj +417 0 obj +<> +endobj +424 0 obj +<> +endobj +425 0 obj +<> +endobj +427 0 obj +<> +endobj +426 0 obj +<> +endobj +428 0 obj +<> +endobj +423 0 obj +<> +endobj +430 0 obj +<> +endobj +431 0 obj +<> +endobj +433 0 obj +<> +endobj +432 0 obj +<> +endobj +434 0 obj +<> +endobj +429 0 obj +<> +endobj +436 0 obj +<> +endobj +437 0 obj +<> +endobj +439 0 obj +<> +endobj +438 0 obj +<> +endobj +440 0 obj +<> +endobj +435 0 obj +<> +endobj +442 0 obj +<> +endobj +443 0 obj +<> +endobj +441 0 obj +<> +endobj +410 0 obj +<>]>> +endobj +445 0 obj +<> +endobj +444 0 obj +<> +endobj +447 0 obj +<> +endobj +446 0 obj +<> +endobj +449 0 obj +<>]>> +endobj +448 0 obj +<> +endobj +451 0 obj +<> +endobj +450 0 obj +<> +endobj +453 0 obj +<> +endobj +452 0 obj +<> +endobj +455 0 obj +<> +endobj +454 0 obj +<> +endobj +459 0 obj +<> +endobj +458 0 obj +<> +endobj +460 0 obj +<> +endobj +457 0 obj +<> +endobj +456 0 obj +<> +endobj +462 0 obj +<> +endobj +461 0 obj +<> +endobj +464 0 obj +<> +endobj +463 0 obj +<> +endobj +466 0 obj +<> +endobj +468 0 obj +<> +endobj +467 0 obj +<> +endobj +469 0 obj +<> +endobj +471 0 obj +<> +endobj +470 0 obj +<> +endobj +472 0 obj +<> +endobj +465 0 obj +<> +endobj +474 0 obj +<> +endobj +473 0 obj +<> +endobj +476 0 obj +<> +endobj +478 0 obj +<> +endobj +477 0 obj +<> +endobj +479 0 obj +<> +endobj +481 0 obj +<> +endobj +480 0 obj +<> +endobj +482 0 obj +<> +endobj +483 0 obj +< +/P 475 0 R +/Pg 86 0 R +/K 0>> +endobj +485 0 obj +<> +endobj +484 0 obj +<> +endobj +475 0 obj +<> +endobj +487 0 obj +<> +endobj +486 0 obj +<> +endobj +489 0 obj +<> +endobj +491 0 obj +<> +endobj +490 0 obj +<> +endobj +492 0 obj +<> +endobj +494 0 obj +<> +endobj +493 0 obj +<> +endobj +495 0 obj +<> +endobj +488 0 obj +<> +endobj +497 0 obj +<> +endobj +496 0 obj +<> +endobj +499 0 obj +<> +endobj +501 0 obj +<> +endobj +500 0 obj +<> +endobj +502 0 obj +<> +endobj +504 0 obj +<> +endobj +503 0 obj +<> +endobj +505 0 obj +<> +endobj +498 0 obj +<> +endobj +507 0 obj +<> +endobj +506 0 obj +<> +endobj +510 0 obj +<> +endobj +511 0 obj +<> +endobj +509 0 obj +<> +endobj +513 0 obj +<> +endobj +514 0 obj +<> +endobj +512 0 obj +<> +endobj +516 0 obj +<> +endobj +517 0 obj +<> +endobj +515 0 obj +<> +endobj +519 0 obj +<> +endobj +520 0 obj +<> +endobj +518 0 obj +<> +endobj +522 0 obj +<> +endobj +523 0 obj +<> +endobj +521 0 obj +<> +endobj +508 0 obj +<>]>> +endobj +525 0 obj +<> +endobj +524 0 obj +<> +endobj +527 0 obj +<> +endobj +526 0 obj +<> +endobj +529 0 obj +<> +endobj +528 0 obj +<> +endobj +532 0 obj +<> +endobj +534 0 obj +<> +endobj +533 0 obj +<> +endobj +531 0 obj +<> +endobj +536 0 obj +<> +endobj +538 0 obj +<> +endobj +537 0 obj +<> +endobj +539 0 obj +<> +endobj +535 0 obj +<> +endobj +541 0 obj +<> +endobj +543 0 obj +<> +endobj +542 0 obj +<> +endobj +540 0 obj +<> +endobj +545 0 obj +<> +endobj +547 0 obj +<> +endobj +546 0 obj +<> +endobj +544 0 obj +<> +endobj +530 0 obj +<>]>> +endobj +549 0 obj +<> +endobj +548 0 obj +<> +endobj +551 0 obj +<> +endobj +553 0 obj +<> +endobj +552 0 obj +<> +endobj +550 0 obj +<> +endobj +555 0 obj +<> +endobj +554 0 obj +<> +endobj +557 0 obj +<> +endobj +556 0 obj +<> +endobj +559 0 obj +<> +endobj +558 0 obj +<> +endobj +561 0 obj +<> +endobj +560 0 obj +<> +endobj +565 0 obj +<> +endobj +564 0 obj +<> +endobj +566 0 obj +<> +endobj +563 0 obj +<> +endobj +562 0 obj +<> +endobj +568 0 obj +<> +endobj +567 0 obj +<> +endobj +570 0 obj +<> +endobj +569 0 obj +<> +endobj +572 0 obj +<> +endobj +574 0 obj +<> +endobj +573 0 obj +<> +endobj +575 0 obj +<> +endobj +577 0 obj +<> +endobj +576 0 obj +<> +endobj +578 0 obj +<> +endobj +580 0 obj +<> +endobj +579 0 obj +<> +endobj +581 0 obj +<> +endobj +571 0 obj +<> +endobj +583 0 obj +<> +endobj +582 0 obj +<> +endobj +585 0 obj +<> +endobj +587 0 obj +<> +endobj +586 0 obj +<> +endobj +588 0 obj +<> +endobj +584 0 obj +<> +endobj +590 0 obj +<> +endobj +589 0 obj +<> +endobj +592 0 obj +<> +endobj +594 0 obj +<> +endobj +593 0 obj +<> +endobj +595 0 obj +<> +endobj +591 0 obj +<> +endobj +597 0 obj +<> +endobj +596 0 obj +<> +endobj +599 0 obj +<> +endobj +598 0 obj +<> +endobj +601 0 obj +<> +endobj +600 0 obj +<> +endobj +603 0 obj +<> +endobj +602 0 obj +<> +endobj +605 0 obj +<> +endobj +604 0 obj +<> +endobj +607 0 obj +<> +endobj +606 0 obj +<> +endobj +610 0 obj +<> +endobj +611 0 obj +<> +endobj +609 0 obj +<> +endobj +613 0 obj +<> +endobj +614 0 obj +<> +endobj +612 0 obj +<> +endobj +616 0 obj +<> +endobj +617 0 obj +<> +endobj +620 0 obj +<> +endobj +621 0 obj +<> +endobj +619 0 obj +<> +endobj +623 0 obj +<> +endobj +624 0 obj +<> +endobj +622 0 obj +<> +endobj +626 0 obj +<> +endobj +627 0 obj +<> +endobj +625 0 obj +<> +endobj +618 0 obj +<>]>> +endobj +615 0 obj +<> +endobj +608 0 obj +<>]>> +endobj +629 0 obj +<> +endobj +631 0 obj +<> +endobj +630 0 obj +<> +endobj +632 0 obj +<> +endobj +628 0 obj +<> +endobj +634 0 obj +<> +endobj +636 0 obj +<> +endobj +635 0 obj +<> +endobj +637 0 obj +<> +endobj +633 0 obj +<> +endobj +639 0 obj +<> +endobj +641 0 obj +<> +endobj +640 0 obj +<> +endobj +642 0 obj +<> +endobj +644 0 obj +<> +endobj +643 0 obj +<> +endobj +645 0 obj +<> +endobj +638 0 obj +<> +endobj +648 0 obj +<> +endobj +649 0 obj +<> +endobj +647 0 obj +<> +endobj +651 0 obj +<> +endobj +652 0 obj +<> +endobj +650 0 obj +<> +endobj +646 0 obj +<>]>> +endobj +654 0 obj +<> +endobj +656 0 obj +<> +endobj +655 0 obj +<> +endobj +657 0 obj +<> +endobj +653 0 obj +<> +endobj +660 0 obj +<> +endobj +661 0 obj +<> +endobj +659 0 obj +<> +endobj +663 0 obj +<> +endobj +664 0 obj +<> +endobj +662 0 obj +<> +endobj +658 0 obj +<>]>> +endobj +666 0 obj +<> +endobj +665 0 obj +<> +endobj +668 0 obj +<> +endobj +667 0 obj +<> +endobj +670 0 obj +<> +endobj +669 0 obj +<> +endobj +673 0 obj +<> +endobj +675 0 obj +<> +endobj +674 0 obj +<> +endobj +676 0 obj +<> +endobj +672 0 obj +<> +endobj +678 0 obj +<> +endobj +680 0 obj +<> +endobj +679 0 obj +<> +endobj +681 0 obj +<> +endobj +677 0 obj +<> +endobj +683 0 obj +<> +endobj +685 0 obj +<> +endobj +684 0 obj +<> +endobj +686 0 obj +<> +endobj +682 0 obj +<> +endobj +671 0 obj +<>]>> +endobj +688 0 obj +<> +endobj +689 0 obj +<> +endobj +691 0 obj +<> +endobj +690 0 obj +<> +endobj +687 0 obj +<> +endobj +693 0 obj +<> +endobj +692 0 obj +<> +endobj +695 0 obj +<> +endobj +694 0 obj +<> +endobj +698 0 obj +<> +endobj +700 0 obj +<> +endobj +699 0 obj +<> +endobj +701 0 obj +<> +endobj +697 0 obj +<> +endobj +703 0 obj +<> +endobj +705 0 obj +<> +endobj +704 0 obj +<> +endobj +706 0 obj +<> +endobj +702 0 obj +<> +endobj +696 0 obj +<>]>> +endobj +709 0 obj +<> +endobj +708 0 obj +<> +endobj +710 0 obj +<> +endobj +712 0 obj +<> +endobj +711 0 obj +<> +endobj +713 0 obj +<> +endobj +715 0 obj +<> +endobj +714 0 obj +<> +endobj +716 0 obj +<> +endobj +707 0 obj +<> +endobj +718 0 obj +<> +endobj +717 0 obj +<> +endobj +720 0 obj +<> +endobj +719 0 obj +<> +endobj +722 0 obj +<> +endobj +721 0 obj +<> +endobj +724 0 obj +<> +endobj +723 0 obj +<> +endobj +728 0 obj +<> +endobj +727 0 obj +<> +endobj +729 0 obj +<> +endobj +726 0 obj +<> +endobj +725 0 obj +<> +endobj +731 0 obj +<> +endobj +730 0 obj +<> +endobj +733 0 obj +<> +endobj +732 0 obj +<> +endobj +735 0 obj +<> +endobj +737 0 obj +<> +endobj +736 0 obj +<> +endobj +738 0 obj +<> +endobj +734 0 obj +<> +endobj +741 0 obj +<> +endobj +743 0 obj +<> +endobj +742 0 obj +<> +endobj +744 0 obj +<> +endobj +740 0 obj +<> +endobj +746 0 obj +<> +endobj +748 0 obj +<> +endobj +747 0 obj +<> +endobj +749 0 obj +<> +endobj +745 0 obj +<> +endobj +751 0 obj +<> +endobj +753 0 obj +<> +endobj +752 0 obj +<> +endobj +754 0 obj +<> +endobj +756 0 obj +<> +endobj +755 0 obj +<> +endobj +757 0 obj +<> +endobj +750 0 obj +<> +endobj +759 0 obj +<> +endobj +761 0 obj +<> +endobj +760 0 obj +<> +endobj +762 0 obj +<> +endobj +758 0 obj +<> +endobj +739 0 obj +<>]>> +endobj +764 0 obj +<> +endobj +765 0 obj +<> +endobj +767 0 obj +<> +endobj +766 0 obj +<> +endobj +763 0 obj +<> +endobj +769 0 obj +<> +endobj +770 0 obj +<> +endobj +772 0 obj +<> +endobj +771 0 obj +<> +endobj +768 0 obj +<> +endobj +774 0 obj +<> +endobj +773 0 obj +<> +endobj +776 0 obj +<> +endobj +775 0 obj +<> +endobj +778 0 obj +<> +endobj +777 0 obj +<> +endobj +780 0 obj +<> +endobj +779 0 obj +<> +endobj +782 0 obj +<> +endobj +781 0 obj +<> +endobj +784 0 obj +<>]>> +endobj +783 0 obj +<> +endobj +786 0 obj +<> +endobj +785 0 obj +<> +endobj +788 0 obj +<> +endobj +787 0 obj +<> +endobj +790 0 obj +<> +endobj +789 0 obj +<> +endobj +792 0 obj +<> +endobj +794 0 obj +<> +endobj +793 0 obj +<> +endobj +795 0 obj +<> +endobj +791 0 obj +<> +endobj +797 0 obj +<> +endobj +796 0 obj +<> +endobj +799 0 obj +<> +endobj +798 0 obj +<> +endobj +801 0 obj +<> +endobj +803 0 obj +<> +endobj +802 0 obj +<> +endobj +804 0 obj +<> +endobj +800 0 obj +<> +endobj +806 0 obj +<> +endobj +805 0 obj +<> +endobj +808 0 obj +<> +endobj +810 0 obj +<> +endobj +809 0 obj +<> +endobj +811 0 obj +<> +endobj +813 0 obj +<> +endobj +812 0 obj +<> +endobj +814 0 obj +<> +endobj +807 0 obj +<> +endobj +816 0 obj +<> +endobj +818 0 obj +<> +endobj +817 0 obj +<> +endobj +819 0 obj +<> +endobj +815 0 obj +<> +endobj +821 0 obj +<> +endobj +820 0 obj +<> +endobj +823 0 obj +<> +endobj +822 0 obj +<> +endobj +825 0 obj +<> +endobj +827 0 obj +<> +endobj +826 0 obj +<> +endobj +828 0 obj +<> +endobj +824 0 obj +<> +endobj +830 0 obj +<> +endobj +829 0 obj +<> +endobj +832 0 obj +<> +endobj +834 0 obj +<> +endobj +833 0 obj +<> +endobj +835 0 obj +<> +endobj +831 0 obj +<> +endobj +837 0 obj +<> +endobj +836 0 obj +<> +endobj +839 0 obj +<> +endobj +838 0 obj +<> +endobj +841 0 obj +<> +endobj +840 0 obj +<> +endobj +843 0 obj +<> +endobj +842 0 obj +<> +endobj +845 0 obj +<> +endobj +844 0 obj +<> +endobj +847 0 obj +<> +endobj +846 0 obj +<> +endobj +851 0 obj +<> +endobj +850 0 obj +<> +endobj +852 0 obj +<> +endobj +849 0 obj +<> +endobj +848 0 obj +<> +endobj +854 0 obj +<> +endobj +853 0 obj +<> +endobj +856 0 obj +<> +endobj +855 0 obj +<> +endobj +858 0 obj +<> +endobj +860 0 obj +<> +endobj +859 0 obj +<> +endobj +861 0 obj +<> +endobj +863 0 obj +<> +endobj +862 0 obj +<> +endobj +864 0 obj +<> +endobj +857 0 obj +<> +endobj +866 0 obj +<> +endobj +865 0 obj +<> +endobj +110 0 obj +<> +endobj +867 0 obj +[111 0 R 112 0 R 115 0 R 117 0 R 120 0 R 122 0 R 125 0 R 127 0 R 129 0 R 131 0 R 133 0 R 135 0 R 137 0 R 139 0 R 141 0 R 143 0 R 146 0 R 148 0 R 151 0 R 153 0 R 155 0 R 157 0 R 159 0 R 161 0 R 163 0 R 165 0 R 168 0 R 170 0 R 172 0 R 174 0 R 176 0 R 178 0 R 180 0 R 182 0 R 184 0 R 186 0 R 189 0 R 191 0 R 194 0 R 196 0 R 198 0 R 200 0 R 202 0 R 204 0 R 206 0 R 208 0 R 211 0 R 213 0 R 215 0 R 217 0 R 219 0 R 221 0 R 223 0 R 225 0 R 227 0 R 229 0 R 231 0 R 233 0 R 235 0 R 237 0 R 239 0 R 241 0 R 244 0 R 246 0 R 249 0 R 251 0 R 253 0 R 255 0 R 257 0 R 259 0 R 261 0 R 263 0 R 265 0 R 267 0 R 270 0 R 272 0 R 274 0 R 276 0 R] +endobj +868 0 obj +[278 0 R 280 0 R 282 0 R 284 0 R 286 0 R 288 0 R 290 0 R 292 0 R 294 0 R 296 0 R 299 0 R 301 0 R 304 0 R 306 0 R 308 0 R 310 0 R 312 0 R 314 0 R 316 0 R 318 0 R 321 0 R 323 0 R 325 0 R 327 0 R 329 0 R 331 0 R 334 0 R 336 0 R 339 0 R 341 0 R 343 0 R 345 0 R 347 0 R 349 0 R 352 0 R 354 0 R 356 0 R 358 0 R 360 0 R 362 0 R 364 0 R 366 0 R 369 0 R 370 0 R 372 0 R 374 0 R 376 0 R 377 0 R 380 0 R 382 0 R 383 0 R 385 0 R 387 0 R 388 0 R] +endobj +869 0 obj +[390 0 R 392 0 R 393 0 R 395 0 R 397 0 R 400 0 R 401 0 R 403 0 R 405 0 R 407 0 R 409 0 R 412 0 R 413 0 R 415 0 R 416 0 R 418 0 R 419 0 R 421 0 R 422 0 R 424 0 R 425 0 R 427 0 R 428 0 R 430 0 R 431 0 R 433 0 R 434 0 R 436 0 R 437 0 R 439 0 R 440 0 R 442 0 R 443 0 R 445 0 R 447 0 R 449 0 R] +endobj +870 0 obj +[456 0 R 449 0 R 451 0 R 453 0 R 455 0 R 459 0 R 460 0 R 462 0 R 464 0 R 466 0 R 468 0 R 469 0 R 471 0 R 472 0 R 474 0 R 476 0 R 478 0 R 479 0 R 481 0 R 482 0 R] +endobj +871 0 obj +[483 0 R 485 0 R 487 0 R 489 0 R 491 0 R 492 0 R 494 0 R 495 0 R 497 0 R 499 0 R 501 0 R 502 0 R 504 0 R 505 0 R 507 0 R 510 0 R 511 0 R 513 0 R 514 0 R 516 0 R 517 0 R 519 0 R 520 0 R 522 0 R 523 0 R 525 0 R 527 0 R 529 0 R 532 0 R 534 0 R 536 0 R 538 0 R 539 0 R 541 0 R 543 0 R 545 0 R 547 0 R] +endobj +872 0 obj +[562 0 R 549 0 R 551 0 R 553 0 R 555 0 R 557 0 R 559 0 R 561 0 R 565 0 R 566 0 R 568 0 R 570 0 R 572 0 R 574 0 R 575 0 R 577 0 R 578 0 R 580 0 R 581 0 R 583 0 R 585 0 R 587 0 R 588 0 R 590 0 R 592 0 R 594 0 R 595 0 R] +endobj +873 0 obj +[597 0 R 599 0 R 601 0 R 603 0 R 605 0 R 607 0 R 610 0 R 611 0 R 613 0 R 614 0 R 616 0 R 617 0 R 620 0 R 621 0 R 623 0 R 624 0 R 626 0 R 627 0 R 629 0 R 631 0 R 632 0 R 634 0 R 636 0 R 637 0 R 639 0 R 641 0 R 642 0 R 644 0 R 645 0 R 648 0 R 649 0 R 651 0 R 652 0 R 654 0 R 656 0 R 657 0 R 660 0 R 661 0 R 663 0 R 664 0 R 666 0 R 668 0 R 670 0 R] +endobj +874 0 obj +[725 0 R 673 0 R 675 0 R 676 0 R 678 0 R 680 0 R 681 0 R 683 0 R 685 0 R 686 0 R 688 0 R 689 0 R 691 0 R 693 0 R 695 0 R 698 0 R 700 0 R 701 0 R 703 0 R 705 0 R 706 0 R 709 0 R 710 0 R 712 0 R 713 0 R 715 0 R 716 0 R 718 0 R 720 0 R 722 0 R 724 0 R 728 0 R 729 0 R 731 0 R 733 0 R] +endobj +875 0 obj +[735 0 R 737 0 R 738 0 R 741 0 R 743 0 R 744 0 R 746 0 R 748 0 R 749 0 R 751 0 R 753 0 R 754 0 R 756 0 R 757 0 R 759 0 R 761 0 R 762 0 R 764 0 R 765 0 R 767 0 R 769 0 R 770 0 R 772 0 R 774 0 R 776 0 R 778 0 R 780 0 R 782 0 R 784 0 R] +endobj +876 0 obj +[784 0 R 786 0 R 788 0 R 790 0 R 792 0 R 794 0 R 795 0 R 797 0 R 799 0 R 801 0 R 803 0 R 804 0 R 806 0 R 808 0 R 810 0 R 811 0 R 813 0 R 814 0 R 816 0 R 818 0 R 819 0 R 821 0 R 823 0 R 825 0 R 827 0 R 828 0 R 830 0 R 832 0 R 834 0 R 835 0 R 837 0 R 839 0 R 841 0 R] +endobj +877 0 obj +[848 0 R 843 0 R 845 0 R 847 0 R 851 0 R 852 0 R 854 0 R 856 0 R 858 0 R 860 0 R 861 0 R 863 0 R 864 0 R 866 0 R] +endobj +878 0 obj +<> +endobj +109 0 obj +<> +endobj +879 0 obj +<> +/StructTreeRoot 109 0 R +/ViewerPreferences <> +/Lang (de-DE)>> +endobj +880 0 obj +<> stream +x |E3$ G'$C 4 A  KE.EaȪ(QgeX +* zt[53!3OUWWwsSO=U`'\8&X2~ipںEuKV@?s/x(Xpۦ.Z_1z0L{eC}p)u0Nt"3}˥sO0nh?\y Θ6Qk 1cGL}e Y^ +sɏ] 9Hmls@2.|ٴ~R{ޛ{(\rz}iso ++ ࡇ.4 6v; XmPOf|ӦҒ` +/ugx??N/1ݾݦ0t>.$B^lCRMLz3 /Ǘxg +|(b?q>^ P G <{k +O}A/T`&D >!vQiY9 1 MӾ8x[[=ݨ]ޏ}slKam``:16`xyХ+1Kq" ŘyÇRz>f% 11דּk>%(+0W`:*\yd,> aK1 0?0 FiyÅic|X+yE>LŘ._gۋbkd\̀C0gLxa3'`!1bf2ZLg31sXdƍ3i=8>b% q9|XC1qg&rXi S[clgbnOA/dG!#8נASaQSad  Zi)8iG;TӐI#S2^tLdk@| t_;lh'CwWA+~Ew~E.zj __=~F/k?7 +!#|i?O(D #Q~De(EX}_P28_;cw +(@8Gv0H; +TkǡZ1X@U}A}j Ӿ`h ׾j0j0 #c(cvՎB\H\(\}ѨӾDo1####c8I77LaL40&a5p5kLax*fi_Fj_a:.׾F +30W3q%fa%fc%`vav3|ޮ•X}yX} /XA,2?A\,%XXR\2ܠuQۏX}h>V+{sgXq=n> U 763ڧhzS܄fS'=>ؠ}[Т}[Ѣ}u[c܎{ik<};Cڇ؀VCڇq}?`şp>xD{/xi! >u<׵^ 7"^]5}؋}xh +>U|}D{1:>^L{ob ++x_h/]^{R{+e|Gj{ ^§8>gx?k]Gm`~KWEۃqBۃ8opR{GpJ{2| 8wд=! 8N!)VngGqgG ^_bx/0û~X638k&0\p?W1^R0-Q(·d%ԴwMM\rmwɵoԴ榦eι"5-sٗ_7/cw楳Rܙg3HNʌTW Cn%|ȃ.-{¯ ϰO8+m‘-mVoNbE ?(gm>d=E.b2vksgH?ﰑ ^rXi#bi4ؚi4=_I͓_}akofXnv+a^cFs胜싚,#DrrGQ>(p6mփE!Y{iio[8ڲ(dy,Nm0wo0Z8Y۴O|mO'Wjh kM LS=S\BsnpY?Viml_d)J)ߒ=F[r)ܺh#%irrsiil /MmwJ۱@X^I=n,)fTqN~|YoۜOEdsmn5Mܴ(ߴW\Gy٪xSVUDaW"Uͪf"=Vo?]vqBnsP얊|ЍB<2d8a ?96RF°02GP+ L/#}1;B-=OD":X1A`"zGg$[)1b<1&bO$%ײzX{z|ٖvغe[}60(6ҟUlh#e;b +2svn;)K +z5c~7(GGD#G35їFD5*7HƎ_7MA#)A# 䣑H4(6jjc{㏍o<}#4~Aۍ_m|qoK{_h|qwS77>޸Ʀ5W6^׸qiƑC)'NC,G +$pW+kkNcuKՇ3Vۧ}G`o>I;&D+MXW;mϏ\o"70؄u&vݘy~'[ԥ؏q7kGV24uӦ,{(GQvKF"f MAQl`nZx(\=r4$(qE6 +癯/ T7 +T7ΌW56G&_:GFD_Ud +TM3F + +h +ThA7s[ +NjUnjrA~ ?:}M۽%Dr"bJUQ]Qer76nZfǔh<.Oo[=cl4f为([M? 3|T܃U5k3|n`35P5! AQCU ިCZkyjL=mjT]׫~# T0 zV%ISlL62(7MEOӽkoGͿ~OnamɔY1R2~z 7(WW=#P}d_=^?.i'7VǚMO L\nUTe2UGɃ"xq6zaP$ɝEu7_}.7"/ w׌eGy"5#;ft]S7ƣ1Q1-@ cc딼gO nhj njhܦ-M榹 >6mM൑a_6xtM5j<`ߌ1cQyHu9ϢYhA~\USҦ/Fe͎LgŘ(=VgןPjFK#~?C7)R.U;aw r Eĕ| ?[M23s=M;Q՗\7:XN<*v~z:Cr}m2ecJftR5t]"bv%cDaI<݋]B1zaڐ!́SiGRq6l䷠A؎!nJYl$q+9OF6r!zǽ4Cn/? sX{}}齿݀[{Ɲ֑+m$! IHB$$! IHB$$! IHB$$! IHB$$! IHB$$߂5G +ECb^/}pp*~G־1L\ti0?斋- %&d AuA/q:GEh_ :"8YG>]'3CIfXlYH-#xD"G^ojvT?ӄdx**H,v΍M}]Qw)3UN5w {[Mmqd" |vEGm B_7鈈# 6to#eLI?ȵmv0 2Ly#t:MG,V"QGڴ[Rdb?OpzD8+."R# 9zI3ד@C=Aq<0O o3KijSC6}+MZ.(,d_2Qs߿p!5JNr[%92&r!GoyG isKܖϸrrov+0!Sq@x69>h!+B..J+7TN>/80XYZYXXUUXX  ^+݄Zh\0`q c1WK7|vxKqcÑ^mM'DtTT8 )S8I +q}}|s>}yAy5]Hߤ~#63S'm'GvS;\cǺ'ApwŠ,bѡu:b**` ++ qﴺVwy]Emj?eP܂(Wus15YV_ֆc4V%bաBv V0J +)."} +@ӕ*ƹSʻni\xx/+yU`iF1fD223lNg-u.p'Z]%innw5YnW]qG0f׏bIC SMsvMy̨<pʀCz͌.`ܟ$)pQ* ~ë:Zu.- EB:i$.ppA:BJAiVu\OfR&;nR/f&J.:l)H]ǯIzt2Kp9̾'&M'̠13S;%5Wڧ5D.4XC *cvCs .ϡh琛3R.7a%髣 =/\4b؂cnj[X6|l?;XQ)Bq-7|%bQ F1Y6^01b "xL2iьM2&0Y- zTkVC̒q_$zsVh bvXpAG((δ0pP 3O&,qݻ7Xww&r}? INjΝwu˓\c0srJݎ[*t,!(4dlDxyЄZ8"T%EoH7KhvkvYmXMRmVHKs7C&;)iQ:-J_6}ڴ_3b"bB-57,S@뿑ÉG܁5@YVrѹSS)BwJ']䮝Z1ޓ6ݫ{ԍbۮٖ'8vo;$rjovtFDV76(j# +2'4b TIfj&iA nsp.7,z˺^TLiv\;}hH"e21 (z9#ԅ\)sPI?a}[ɽd׷UG򱤉(l:ovzR@{.@Aw*y xba`JJ!Pq +ҦDh%.VKvDZa(GeL1P:n*5},9QjA죤ٿ~Qǫ ;-62;u)$n&Jɰ."qDZ'IFEE8^ z"iF`2i'8BSONkk(D*~:opRInrS5۷EJ.Ui[l19d]D `$.K풖ڴS]8iJ[] %t-2g5X,6)c } rΎǡbO=t<`$6EQI[xHh͔m⌧u=-m7 P) TĴXnӾ l̞@;3{B68Kak0+; uTJir YKZ𝗫quo|,Vu$E):@it! B,zh qC({<ɴWTT$)ܣæM6q7w[:ne@Ydƾqr<**H=D7m[@df\2L@$y2"홴}"h3?:glNR3Ze6SrJtz:!NcM_z6 +8[`=JR+e [e& g-d/q +ʍV;EmxFsA@/S +4T +JA=xP YIPAp(`4z:&&P~$Dt6mf\Kcbcd\F|+"0øΔx\)RKo5tVKw+cQԝY$YMDĮ*n\mYϷvx6qrRR' E\}]ܼT8mI0y;h.5t8pdЂ /"(,EuYJ}MkN!dY0PԇaᘈxXptI*MeERӘy +:ZMs +?#m!$gg⟛ɽOmMvEli/qFTr391Fjm8_N(AC:(εp8(tTpD=u~!CBWciB87I3X8S]O3!:e:% +,qp,Ob˩g hͺ[t u$$=/uUҔ9>wsmF-婡可9t' ;$n)TuuYD*I/2[]sP>=J Tqu:C,QwO>M2I߸$[`*K`ƺsN޴.::}Xj- ݨRJ3ƔRKqɵi?1)r v!1'-P/q'HW?} 5u8(U;Աu$ɯB WpO\vnf8BŞNB}\y{~_Zîtğ+9:aOK TO< $=oߙ_BnW_W5ӣ7޸jg^RI{ ^-KzHU=--MZNHc؂LJj+q,u뻭,Sֺ'4%֓\/u,5pgy,9:<0;ի9N1یqTƉоF0kMȣ[XY0fE͇*fo=’{Ŗ`- 5KT{ y\_a3q J)% +\2( v>3j{SM5'aPN9rzՐ< 3(uBL<).E]^o~ZetetRӲ|ZOAўo C?BK[99dx&MwJyq|WڍgBG! %)ݸӱ9f*{Chܒ j~[ߙ|]~q^#68ۦ4Ψ￧[9N/=oīFNY70T]ZY9 7okGκ}B/;I$$Ht g +6DX9^|]> GQp2:|bՓ zBEЦBg²e,#`!3 ԫ8 ))ԩ"wR9>[`5J1gt9Ns&3Pw̋cdZMG+h%[&ib[1701P^ѕ:GKw;>eY@. hU/ W _1%ŸDt\5iol5Zu|,T1ZLj" H_,]Oڻ[ǜFڤx3Q)ڴvڥiʂPǒ)Bj*'<鬜#kXBIV8aKAUDZ'$w}:i[NN[NoHyp2]@ŷKgE)d7#^nk0EDrhFQOOX +tI,HgZ7]o^zDj͔f]DCVF4ncC$jm4h).pi-G]$B3jm(ƛ,S0ӈY̛P/  1 1~>_<5_T?t :a)vAFrxOՅJl9t0ԣ>?1i -b ح/qkd,0zPGsd !.J}}Qhb9>&L&F*!fF-l/lK|L+Lm4Ux d`sPp=N0+⼊W]%Sۜѣ>ٯ~f +>)~V=M/L+{۫KJ*Ox?n`g/@;-8jM8jM8)f * MbtKF!׾q$![.f jMj2P⍙d~uw_qyxN_F?Fo٨X&JQ a"g3|OE"d]DpBhxFbEJxvlСL 4L Xw8;PEejI @6ϩ7qީwQ}~6ّc\lLDv:Wj͵|N)/W +2|df̎\sm^O2mjP>>ҚI^F0V< +;p"H&n9bKy .xJOܕPW/ TdKVwNZݹ:sT dw ԝ99OXpǢ r8t_"#Va7/~~W?{-_/hxU=pConWyo hSXnLp3".#z;|fR MIk"&Zf:{RLV]xC[xɹR }wbR7,zcG >u/:HdOl{#Bؠq)ޭ$b2Bs^K5n9bజXEĘ枈kq7l%C P=+wT]U;Ȓ"+1#41D)[y=5o7x7y=uL%%kN}q絏~}{bT +8j$P:Hz`3C-9b_#TQtXb^f wW| wQ.76BW)tn΢)M dh™tfOvwrGY?(-Ywg {?Dnz.#;L!iߓқx=}w!M;`v+隌fb17G,6'qT5 0,Z ,%@22,MR,™.QP ˡ=. ݱB[N/:z7޻}-`tRxY۬.ugjcDh5GLchXRl,WVse bzQhm㒻Mr+">oxko{jF?!w(=9;.mlU}#NGK=ҍ|*cg\g.m+paƣ!?խ¢8nQv%: d!ۋ1B @:V0)Zc*Kmx,=tZ]"#t2@k(~arZkVp -4G)v#S"&_g$xÌ鱆Ӗ5-14쉯v]1躗 {*[nWm( 㤳]Œ5frzKd!|0I8g[tm&"A{,ҵ9:D!׶#6ӵRBum l:"r:WsQ5E<^AU1z0(xWRMVxM(V kmƞ(<ƧۇPtk?A'j~gio(t#E*1 ;+Xy/Կ_~m;G<$Hɟ?מ^3}olRyγMo3wJx{>;vz~ۧ~E/WPҘkL|9,qⰞ4O;ish +|ޚH?q孏^"c)xsǾe}{_Ln0kd[o-i<{W*]bCԉg.,u_II"uv-G}k5{Es[mx@I>31еAbd;mei&7GR +›x͑ԴVl蹒8O,9Q,2k,NA=ǾFۙh=5T_g\:PykVϼaYYe#C U5F+pyUם7䊚y}{d7`a)dB "*LKSRFFU2tRsDg,tǘEH&ً_IS,bpKA9ҁsJZ\$MUc;e\[c4J8U Y(Oi"7پ u&RK`L,&sN-f +Ҟu3o|1𷩛g2H=nP:JdxvPn#pFcgVnhI!#)TƙX6NLs)kěS&%iR-4ӝQ۹Q. +n_J̫^U{-;ȥNܢ]m$ 9jQ[s?*VD$G=b_ƕE9"Y9f_cpF W7c>ɵ!~ZMJ<D[HGbDK.G2<ȥD.-Ţ \D-S<צT^\wtޢi11:<wzyC.uw6;w#:WH.w~w0?D`$I  xtޠg*qc?D{$9t?p¸'NW<`}[6a`դlvR$xP1r.A ڃKL6;""9!7GeYVm4wQrתިjSsCޠLERqEsK(s#A-8R@W3_ڲ'΍{\Ӹn'S~qޜWN=-}{{X>88,^o`RM|lv7=44 @ tKҳYԋ{ի\ܻ,ܫWzR咓7m9m;ce(6`/ |Mh)Fy@ .~K^|jwmm"x`c2wb?/Hz^NK^ h$N:$J6NINm:N'N4xzcEpS$$! IHB-00gy=/9>^>t`tN3t>3>dgO$}$$! IHB$ ,f= gu d0^2:^3ϬKz͖,I][C[|~J$$! IHB&6}"?1FQ`&A4,&dAOaHth N a>1#wv> |S$$! IHB-Mg6tϛghM&A2fl4MF^]g6^$hЛu.>_̆DNIHB$$! I v\ +DfA'N̂`60Mfl%f-Fl 4x  F gݹrF[;XHhVLl,a&f[$cUjQׇx+X|f)Ϣ;qeI~EJِBFʢU+Θ<o8+9/0|7jW+#Xo_?|D,bPB,IuQ]Q(RBjΔ.k1HΕ B15(Xj*vb=(<#.ebyPUd +V4rWNZi+exrN:%I9#YJ)UZ !ޚ|c]=V"OxHDCsf^m]\9'jbFv!`6=w'eQU%Vch<[MzˬGJ)4yxۋh(fW!I޺U5O$up5W[iucMU*k-̨(X|nۗH|?Y2]Nq!"JV*(ImýuN$x-M=:=WVC%X|3w䶜h;뺃451ii4tt Kw)Mv1d9kpo[Gsn%zD,D4o{1wH~*̐oc]!N =-`kLx{c0H|?Y~_/Î2rw}n~~?NC=>syLNF!iю{u7㖓H|?Y>9F +endstream +endobj +881 0 obj +<> +endobj +882 0 obj +<> +/W [0 [645.50781 0 0 273.92578 0 392.08984] 11 12 301.75781 14 [684.08203 216.79688 399.90234 216.79688 389.64844] 19 28 539.0625 29 30 216.79688 31 33 684.08203 34 [448.24219 0 645.01953 573.24219 619.14063 701.17188 505.85938 488.28125 686.03516 709.96094 266.11328 356.93359 580.07813 470.70313 897.94922 748.04688 753.90625 560.05859 753.90625 598.14453 531.25 523.92578 687.01172 621.09375 934.08203 589.84375 552.73438 570.3125] 66 [415.03906 0 508.78906 587.89063 461.91406 588.86719 522.94922 312.98828 588.86719 565.91797 242.1875 242.1875 497.07031 242.1875 861.32813 565.91797 585.9375 587.89063 588.86719 347.65625 424.31641 338.86719 565.91797 479.00391 722.65625 458.98438 483.88672 452.14844] 104 [687.01172 0 0 0 508.78906] 124 [585.9375] 129 [565.91797 0 376.95313] 137 [543.94531] 2862 [862.79297]] +/DW 500>> +endobj +883 0 obj +<> stream +x]n0 yCEҎJi@8 4 +遷bVځD?%&ʼ4ӎMwڴfWaRV7n%\Xyt#c΃/7x- >l Vo.YeAu_8.X:do^,ە-ݲd3{+dInyB("a`r-vOm1}X%B +ҡ@:FHyF!CI"ʌH!%D]g{O:{'W)"r~;-Š +9n[Q@\Ũ2?<`g__x"8* +endstream +endobj +4 0 obj +<> +endobj +884 0 obj +<> stream +x xTE7ޝ;v:iN$ =4Cve (}EgtluD\\e!Y AϼϿrԩsOխ{{6K>0D4VNr~Oӥl|i;:@{ټe/DFFu~c2de+獘(̽tuO^ 47=ʆ~i0|FGQ ,tiV74 5K65ct=]ڸz@</my=@O-[ڲ })V4/{g8`*= C{3nA@ +¸8MЀB(?ѽ0ֆSO]e=Gg~ͶK֋??k,|f R$i 4Eqjụ2E}8VA +6iJtIG1A3H@gAAFm CA)1p)c#6qa/蜿&}H/XS~}K;VZvYuuM0R>@K/ +}r f-8$LnA܂xDr Y!/^ &`&69^ X),X%T">4`ZXT`K05E3V AA cch/J\eh>)f*,A#V@LB4aK1+1Tg + +15Xf(?QX, +,+k X_BDK|U-z.G3 +J3 w!1+Ќ+`2$K ++` b"MXeR>6!(`U<~˰ +.D#.<8N{b +sŎŮBq-KzP0 1KDo쮜{1>KWYVa&U s)X'P#vg82͂b*%h"dc!%+шX 4ۑَ,o)';ޅ5 @4&&flC'*0=X -f/0 TɺP 1:lGqO7Kob-n٨,b +pH%aieuv756/ B}y|½x)[%h6Xz+ +셌Kv.^>!.r4V6SnH adwpXBd\M#SiE^#Sji6ͦ^A}t}~NRIeRDZ*-J C9K'3MPsQSj95nC_t^뽯}td" PhD#a5،7HDFT2,"jr@I4Psv6Lm4tO؀IHKVal>{i|\3,`9Wj7|Hr75R=Xl E4+EdCx2Vc!p ._ѥQXH3>Wza&{ݍ|k5)ŝx{5wX3ӌcCν%.|{5;&(gߐƃp Ņ.Nl Wja* %NF]=JV\f:{܉YenŭrF[]F/Ψ@$mgm2.YΓq.F6 H+ |fjdY,WϏ8h̦MI>|S`7/S?|Sm5&y5m Mq#N:֔,#4g^3'y54;#-&ɒ[Qn D?1ޣ͵ r54&p5R "jayGi ̦D)>LSIcdd+?7hsjԺX[wJȮH >ҚIuv&-#jHd/cSg)Um 񽭮9cj:MuKbTu$:*rVܨN?.Cq<)ʎDu2Ցsۣi})Jc}DA1QMQ96NPhc}1qj=6>b0VAԅ %QѴ ( NQI9qұDw + N┭Ex_k/J0Dbn+1s4ʉ[H$2ni!a_3Ѷ䃆nCa:;ϯN \W؀(~;{"mmJT[|y"nDmu{">M'&mHr\)tjOΦACqG 6O6mfu"S4㺤p#7'?/pQ;5uE*ƹ갱 +poH"H6ۨD[1mS\lU3*W%P_sb +>R<TMxQ6wBS@^6)usb;u.gR/ 2ί\~9j!44(*ZU3ίkTÁFn7Įg:~Սm*ms:e^csW{lWu*mm6DT9w2QQ5AU+MP] +46nc!]GU+R*Q94񸱾!jrm6n;mwSmC(Wl8EFw7aoEFSr9GP4^=#^pA:%A&W]Rsiɴ/hs'NhP:&6bO৺7,vu +/??=R~VI$ +h6'A(OԡJ:.kI- vI~|tZ+%*͒%/lk$/Z%/6K^씼xMRɋG%/Ot(>[E)kLPX%'`|%'fKN)9VӮ)9q\%gEMTfc9^4;/ScuX1^v`.U!e5)ˤ VBF)*i=aљ,|t$HT" %@'6B{:-G+.Nz=LXCnn<}vcƗZM!z~@?D=rzA<=ė t =}yrJߧF`wl}p@BqėG8(7:&%R6FHJ(S 6V S6 +ݏ)t?~,E=eZlJp)}B@B~d=0=)%}1 Wѽ/~(W ~/|t}CЗ`/F_B}UNNН(;1lwҝҝ4cQa;Gh>x\"_88vBaX 8°2GG4°A +W]_V8.0p0p90p\SV&F#L^L ++C+0^^A|QP84pu;i}N#fzi֟iV/i dJ]4K.Һn"-5HZsIkiUHI8JDU% +tyBkQNXC0w*1L/;ڃG.>5yI!<$X(~l6}{zFh6JQ@QN1fc Ɨ4Z/KK,]_dLϋ~yl!ۅҝb^%Ic]o֯|mFJE +M7/JU |A G +;<(v|ۉSOcL:|Do{n\Փs(! ۴G^:|jZxbh %*7-8wV_g/Փr}e1a!P  IިL|f(<}:dp].Ottn]ޡ-zޠzYOЧEYw8?Kӊ2mCr=EPSjZ=} Vw5zԙ&0jT׌QG:6M- U)?k'䎈:"uQ(af7Ol!owzͷG"pe\^*w uoz_aW k|x BԧԵ1&2vVFcl]a[6Z(:v)CcP~E~!,uf]NW%#}FcUu^䝒$}e/%%N*^ZJwtDKDR5TuTēB-ViI/;B ~͉Uq,+uB--IY䎭lvfUXR*HȇOʗ +PT(ADK|)Pi+} 7E#Is.|gCzv7`Fv&afg` + ; 찲pN#viHeT2ƾ;N!NN,v +N >cPط@a ~ r;AkG}a_c k 0$0D1DB$ PٿP/c;aPv%(b'0(p$be PrH*0}1(c_a,?P ?Prvfq!*qLv X8.F%;Ǿ$'c<Sp!S1}iNE Ԡ`& +x &a2Lac& S瘅sԣ} 83рZw4w%34!>\d?cafO1_gb!~ΎaاX,4O7_cX,G3+0}Wb}˱}+j,fGq%.eGq.cGq`);kuXΎ`haGp=V#rnf\fWXa܊هh5C܆kaǵC܎؇k؇׳׳n܅X7ƍ!#ླྀ}X~cx!<[!<6~xŝlv.v ~baIop{O~^` ^d^!2ۇa#UG+ۇO+ )^ggx&ۋ~_{_-* ^Wx]*N/^Idk|^78| >b/G`8^?ܦmƦ#~O~d?>~$iWc?76#a?M?,l>6釅M?Ǧ#-lz6C6}q6?=Nϵ.N?6m_/ChgtE.J B#`G2Z*=G"rw"'ˇ "B[T(fOdflGz +i,IΔ(;e gtF&ރ ΀  +-G\sǜNtYZ.Y _3F-gi=L$˳<ÓdZθE3hUeuפJ9ͽXؔ$}qfJzrUֵt^vKh߳f%Tac'x4A¨}8 /H8lu!))Ra`')Xڔ >dpWb4%Z{ lWƀ"A +}1ҭ}6.?P> + ~@[Aꗣ^c.iD;X73i2bnNJ]Kf9+*t,5pC\mEtSmE` [͍w_y׶駯z&}~ϒ_q,b- 84` .a'Cb@ HnJ_+z'}P/N&)j!&J}wDYwFg > ۅzZFp&Ƅ 2ifkp^h4n'efL~y(fʝ^ C$6(Iц5bJ{](-kwZn%E7k?\Rz5ߏ3e삗ӨJM0sE8f0{4^NNQbztGD N)U|vGi~(*pw!WapP1a8jyFG*M}w580 g}Sqd4;4;;t/_&"b\URou<8u}<˴l*lzv'+{$BYE;'ۉ=J\[:Ip!ZCMp';|a}K9M5Ti|v'zl'C +,;SVs,]k\kMҡC*Nq<~6MGv: =;v }A=_5u:3F%Ԕfڛ^{QZ0dh$7,>da@V8W4VdC_>734"'x c+U&d2d``^a`#{z4ɕIPl\ ]K 'pQZ^n8J z^(!s|Y_b-MXb[67cʴ[mi0&E֑D nwOdXɔ._#.{=;8G.} 8Zf+K)sN9I$]KP A(;,??!%#:2$ +aC^P?O3G؄D-)^En2bD# & +,Z=T쒁L˓.$#$ UA^ZPĽCIBt%I4!`\t"ݻxǯ-8al޲h.g_g7l=vOzpz5=BW_tM7)[^1wÃcW>O 4 B=\򞃉m{WYw '&oI o&I :}X@t 'iI@4 D@RH܏KjuLO^6i..6#KB0i%`t0=&Id5el  0 Gg5CؐpsXL%/DpeYZtќV j +(?CV~bB>r'O(}lNvd[i!Zn:tG9ERv~$W&^֣~쬺p)l,5N)5lO)_{mK~[MrV2ӨT,]`4TTTv0Rd/J%;^|wEO>Fez "kDDGI5#a2qEm lW̷x,oz*^BsEg"0qQZpfmw۸bpVߤ>o:`zϭOIuYeItGj5͒fT>uزB-k8ėU&or%/>۶ԶvM s "p\ԕa 92 Vr/dDeO2߹kV_+K m=#kCkmav 1ngݐ]my=՟9b1KOzdzVGT*XbEk޴t4i:m ;8.kKxΙg't._y!v?P ^>/ 9] 0|sGfxfb6inM7lx%l^SMxrk{!!B=\gJ]82RQKsussUxgu +c&@;#97b/kin&Ec&I–s'f(;,m Q2ӛP:o {fKJrlR 60ZggkvFiNg(}'8,I +6uW?.΀Έ{ !y)ٝ-d*֜˜4]xjwt+ JG֤:]yV̘C+un/o=wLZǯyeѐCF~SCo\G5?=량Dy`f4r7066LdS$3aBb2Hej%eշl2Jd6YJdZ +y^{7[k-;SHJGuuXJxjRkUJ+DբJD9 QN"ӒxTW4}ЗF8<97QZ/G1}@6(YQݡ(WQ>P!r!+cy$=X[ ̂ì cJyBaDaSX,Z㝻>[|{ONɻܲxͷΛn ӯj k~#>h㻇6λ`u1?78iM lᙧqby6"ȵK_pD..Lȗ]qjY&[$% Sf];P#?|/PlxA(ĕy>8.x.tz\?D#.~qI`$ҬϺPYe}rRI 㑌Mȁstwe6<|攘7*}_%d>tFv2IgCg$#s yn܄& 7-vj:G zl'du@֍+Z%XN#FKZ,iɠJx¾YSa(*pEf1Hx _)NNti{Ξ{O_scd.^2v1ѿ}Oz;S*߼EGcJlR)2Y *5O/q4aP~"A C̷ |(YO<Of>3`k3 x#}erWajppv{&sByKҼ yHh~arZ˦o߆%" +r4KҁKNˣfGÏW(tIe2qzB=L(^Nٵ):^KvMB$4Ihy=V*ѨߵDQcB0Xd +V\Ÿ: ]ǣfxų# +U'=~q8~i0gy.Ay4R~*FjvN,nK80w>ž>7$n[>8_}p{%O4s#G4'+[IףMZ2mrɆ܍4̲n,KX(Jax- +[eJ{{ŊNGr(k]-fr'grŧLne< +pD᎒E$B +V%lFP18~BlBlȈΝ 3a2srduW(4Dl"7Gl}:c/zζLjx +pu,/[]],ubJK n0 ŋP角f2@4d.EzҐ%XPX*//mQxϰ8(W`l6ݾ']~=<5z=]us/~w9u7o=ӟrc)u/](uˣaQ%F\h5Ҥ-O/Ϭ˽MMowo>slS(3ML3B=Gf~>MD6ey:6#aqZxUpDp7ȩwVb V MtW8mp֤Ӷ +mcBX3|An $֞#xZ]pYUg W-R,3yWϑ?tK ^˱ ;ChњYQ)c1&*R.(Kv ?9o37{ag[Ww!ՏDXi޽ϿK P +endstream +endobj +885 0 obj +<> +endobj +886 0 obj +<> +/W [3 [277.83203] 16 [333.00781 277.83203 277.83203] 19 71 556.15234 73 [277.83203] 80 [833.00781 0 0 0 556.15234]] +/DW 750>> +endobj +887 0 obj +<> stream +x]j0y9$ֺ$P"v@j 1|bbC?f|LlƚϪ2^!8KxڨpP9BeSpj08% NzLtvu'4ʗνvKMC"F)1&W/WcNm,?nW/ +endstream +endobj +6 0 obj +<> +endobj +888 0 obj +<> stream +x|y|E9LfrdHLI20Ș1ű uZ_mȺ+z**YEe1mLBD}_[IUwS<(Xg۶|)Fy5@ō@/;w `ywܶvwdm8,gd&h'Lrђ9m .Z M<>5cK0&c@jh .=9`R`a ʛ#m@A ̫֙Lh3? ݣc?wEn?]gK9Y-5򓖝Sod Kc\1ðח&L BML 1hr> +B( q$PZԡq |Rzj QhH0j +rc`} +]Kpy~$a^^Nb{{'r\;w ;GBTHQzCAzB,X-Vuݲ[>KS=hc#1q]`,J\YܫLQ럻\rWMu)3'/7UYLUFžS?LngE1[k>W/qhm:\&qGޒFwʇͼ۸:laa6JlcC6·m}&4abE]|~/`p#!tANaHpa#p01RldFc 3ڸؼ(NF-l>ڏ±1ld7 -䦁ڠpA&*0T}v~1'uoTV?AƟgw`ө,'PДg a\E{=?{L\%0,B;a..r,PjT=B}=zS!G(G%,\%X%KpyVdp!ӱB\ +,7bI߅v7s1`.V!3sq>b.hX&EXsMB%XqAP +PT6,RGcІ1 8,|{cX`eѿgEfmɍ1=ΒLC&sry!h7 +7&`,Y`;p\b.cv3e( M.>)m_6,",GSq] 8; $e,=q,_odr.,+xeٯ˹pU/g,_΢%Y +w +Vz9.xs-xs߸,<6Sx >!#v5!{O $jOs@p- 3W&="+?;鸓3ǿgǾ碝ƮGDƮdgOhS71d7mzYd ,a9,&A,"`;y dmrm\[mr_D;nnF~E޸p=~ ݲ՛ aθ޲ՙV6zV&i|tl-JN4LÙx, 藛U蕛 /֒5\t.z]5>۟D@6 Bt1zU^3Uz-^Ƽ(n#g"FCƑFx1R2.#G2H?/q?F~Qc`HG ȹIspQuD"μ|G(߹diSQmlDr ?ֲgX$v{y )\3f@MAM&&Xָj5AͤT8NsF4NN6ԤUF5ˤ UJG5NwE'~NM7![7^Fs)ںܔVIoMQ#uSr3[~JE 6u B;ܠmXЦҎ4,Ў6jG"hOpЄ+N|y:X]ܤfѨj ˷[(&55jRS&M"usMI34[~K$X X V3!:l=a ' +T*\pc{3~~܇l' '3D.Bq!lG> +c#l(4GEb{b0l|bJo1eƷ"fC ʍc(Eq e4!fb| +TߠCoG `50Pf|j_H 00jpq#PgH2 Q$`|1 +u8 +c|QkAG0 cqхqdt.d0&8jƙ88Ifdm|&4_b +RƗ8 3/0 3/p6f_S82a31 -h7>,5>9gB+5Qbl3!2\l8fp!+^]g|Ƈ/C\ƇXˍW`4l/qqqq+}lįc3xWb6F=\{7l_V]\]\\_f-x7؊;&e7n5Vl33׸؏p6~q;76px w!-oaowf~vo^ |gF]f~_bQB51O["O;"O{b1qb5vD6vM. ne頉g146JHxH"$A$"((Q " +UE9Q2gA)іؗ<`I&$MRU+&":[QYNi-NnįCߟ12 *)Ce@ϊpzT˩x\AW pviUIrJيMVYNg?"yWU_UyC^3S8=X\\;ln5R1NJwee8S ݏ&UClOv +geƁˣx\vҔ49W?&O?F4N[P G;{م~de|/KrAs*,Oӏ`?y;Fr ի4TenzV<乐D~VV^zCPП38,|J fيR}ay}hOͲ?PQШ67< @ ` ?qz%"9@0_pٹY9ٮ=`r NCߛr2 Qc: +7 DB$``@ +,/ +WS<#Qr'ȯe`Tq(7g>ք$473b. ^1wdp7vdi6Ty:!Ѿ >8q:ok >q@WO'MEF $5={4#܋5Mxoa=4|0??????uZ'q#n46 h֛V\؈D!v#C#SFy|{<9'ɳ6Ϙt Ǎsӓ#G ?-1zhՐxeEy$:xp(?/7'KUMZ$Q9!(!~_ܰPˮolQ%& +#j(Kf4>ݨy&5oGrXJLBׄ`A +502](oS-P5Pc +jlk kʤ0m0kjL:SA MZ^c*sD>N!s"٬le׏G0hF5PPcF<_kĭ >38N򪶐n´]ݫ͊f. a*c ) 46_5ל`a(G;477̏4Di il}a-;J;n@Ilk+-IeGOOD0J4^KN5 L5ejВmR tڍJi!M,ėEBb*=Ғ]%M 5yD?ؕ*-iWMM͛c]4D'`~o:5>ɇé 9>p_dtdtͣ#ћ[7ufGBJdvm҆֐I[6ꔦ'njܓgPoKHxX0za&:zM0fpifoCy4 j0LCjT0Y3k0Yct†S2 +{ڽəTiI8LUI.- k&7C܁d,ҘVڲ{mY׽5.-ӯ[ϛՈ+7mkjsq|& ˈ]d5QB5/jv<F7+Mj|}`M*\D)T^%v£hF#Yn& ӈOyB [3Z>qJD}LëዦIXt-iq)A8lf%Z9 ͛PCh>jeTuA(jC $QT0ڧ^]~quji%Zrp$TVsLmpiX0(t*?nb/O8GOƥ!8~>#8汽И:25,)Z2]Լ:x ' !WLޞ$WL޼A +bj0uI>IcSF2O$uf+gVs: :`N'S҈LDI0ɥ[tJuf?iRҒ1v&Ъ|RI #6b'&nI`!4WuYӛNfJhiL$PE 7+\k(5iP;`TiBrŤsyf5*C6@R ˁy >W"}*jX- {c_xbD0x=JAv9XƉ3q_CF WdVdQWIb]DeYWE9Q#?g(>N  %}gyA !_ +k!eXKD('a1u]'_wvF$ߒuzKr;fs¤lL.>d2@*w'CrVБ h o2veb].U7Ѷ|7[ Z(,|I~·H9aHŕ}H*yG1^2\6,"Iòl*)cxZ3a^ƀ +B„ӠtHޢ8ĝ*J(ȬmW&zk5lFᯍ,@wάr>*ӌ-Px0 :?ݓͼDVM=e{z 9Fפ+C@V%_p]" [e)Y{)BH8"Vz[S^Qq?%6U]HcfAx2uXZ͊WRTCUC":4^UxoVÅ V^MްR+n[4z1^0u;n!go߸ ]$snTuW]%yyNIvIKrI|2,T,ee|Gȷ-m?㶔]̰FrPՓҥtUddy#y`"eL'Wd1>yRd3_ptԺe0n-$7lByلa!ZN* FE5Kiܦ%s7OwPc3o^\3|VL7tbytb ?1PT_SYWT\_[QOrqw hJc3Df!6{-SHQFllY 5Mm(S X@VxA.(czUa7v]m.㷝D8歋G۸sʝ9c*srcJ^^2pnmv^>vƃ',m m;&?e_2W•P]BREKc:jwL,Q,!0"L]D" a3V"qYHyQ\m==;}Z9wD#Q Dl7;z$aHd6=,}7fYg^ jΙB\=M+ CEUC+a(* P4|'rX,VvƘX 'L:EFXe"NqlNxB/0tקN( $ۜO2\X;RP pGӑ,oKj6Av[ +.kmunnE^֢XKWe+a:.5i>)mh#jZ޲(%o.qc}^vRCsCMl;'O6Zm) d,[(Җa!;]df|IINAnwOW]o= v}){y}_R-Fg$ -)A2ĺ%E\ %ŰIekzzePK<=wq%enޙ~h^NKItIdKJb9wkBbȈ}(3] b?Ďw'z^;@08ďw 3qX+#Ẍ}[R~[b7,% ),cTVi5HηI.Y-h)!PWԢHd+)eW{eQ9٭di"꯴?OO&զd>% t}A9q.++!.qkB|LtQ[[K9t,=$DF1cz:=LM9dŔ.Em-}LnC 6 JzAbS[fyގ5Vîfj3(' +2JU ۞eS}1 o$VKưS3sw@Ɂp!VBx*t*pYk- ._ "8b=> ?^ϲxs2r5ncF=s0z2Tt<'-3N#0,GgJY~)bˀ1ȝ\FT~Q['3Dq?,HH14* 0V2P$r*\]YRUFt%ʐ@mm/;!A$aʖ,/EB|&kDAm=p[{d?)(B0}pZwL]}~h޹IÓj)eNg,qbze^Z[Kyx?u*5?>IKd&(s`79pm݇Vͦ; G-O-خO euKlj6vӋI`Zj;YFQl& $N.W>sw߻zRGmClƫoǛg7ine&%,bI:(w0K&kBLy:ʩGRƬQ&TiCUC+ջ;Fwo2^~(ĈdQ!IYק$y.V +HAAq`5fFH<ϊ'CER=4e(P)Qz|Բ Rlr駟CFhyz͟g͹n{{Ξ}ά')91Evw6uk_}.W_|g ZMT# +aI[fnYm)I +X@[JfxO@r%ZbH$_#zXQg.ĀM]56T3,ɲuwƵy9kiMCf'ji;P)kUaDDlo6=~FvX"ȂLeY78spqT X! X-]44傺~7/^8kzj`Ek]9{Ȍ^Z~$9vlVqUaCv]+9E6oQUx@"^0y/ܒ 2n)MX~KJ5,a6+^'=E?WR_BD-!Ic>Ÿm,b,;5!c.2%Rհ.{z:(3{.aV5ݻmd;b䉦GHˤ%@daYCYObc VJd=起DݥߠL'؏ 7d !Rl'E2hfe,X"RL 3Dfט+˘d!N:LOnQ88zLJDڞ M82Kg)-cRk #Ν0}{D3'WbH2JRDZ<2gWdhYL]D,G K0_|prb฾g+ݜ-17z٧7GBIT=hZ`H#s/y綤x+q,VB3̦ؓ.pXƍ`^' +'C~.^hIE9#8YwF +"3v^u/ޜ6:㷤܊SR'agr)֕H/x.4ڜt;cZsKk:pZZ)ӔEjSnT᪈)(R + QСW}~Iz}2<1Z! +[|`޸Y5R:!!0!9ӻ5֔E`[?q ?+{`^woJWa"l{NCjo?WԢU瞳z*p%GПg [^+cC5d%^7ޚb̍֔ȽʩOo[vl)@U>?ʹj?KD9\q-/\V8}DxRZwWz$ça<6,uxe֔8w8t,3T AW$͔4%n+ +NH^0k!otR+[оwm#CU. >$0Ae2j"֒QH-WS5$ped#j(\nOB,21~s`; ֿxĻkfQYlXd +Wv )rПxeCJkΥj,=&RƽtW '3lxİ[B?ӚNYk~cWq- c/t{󷦼 +YlA|zW+N#G끮vK& LW*g2ꠘPu:,ŷu-zmϧsg.9/^:Xg3‘Vv嶭 B 7?  xmۚrҟbm m6+3N6M*7C*7Sf +^W2ᚶNpeK2̲{Nsfֶ!}vrrz7 $ +'͛7iܹ&i8c3a0ƥz~.Isz9 6֢ZXն!Ud2և1ف}0⪬xeU.G,=;^'dx? 0V8k\)3I܆!ƟT-tW(DH&%am7O % I񇻇z~#x`C_ljƎ&4pF&UrY rp[S9Jc۶ +ِCR-ueTbeՀ!iY6 ,OIgWF_9J+=UwxiNyGH8?ml}]IVl_ʃd"3=a&_w~_9tSOpyiҚlurGޙⓕ.yKg,Zjۥzvou<鑇4-[cKZ▘bx2d`Gt:PY*[~&'nwIv3\rV bx7_xSZO0炓Ċ^iec=R†~'PRi:BFb+L429/u?lAqe%K˪HWݒfޒRRAuuH: 6;]I2Dh T|tt8 [Tn44h 7QW.zigDj->sg$3k]vfs,ao\-kYB*|5ܘdYFܸ)v"}*:YR"Yrnq[jxu*觞 +jzBzxO9:}=~VHf7>os}wηCrxYoHNi:'"s[9-pz(0פ?ïܣF?x<2?=;njpS9kdr`1K &d YlBn\g4w%ZZP[g&[iGωyq+k"8}XA<%ki$? [ +7;A߭wH5V^)]HiekΘXѳCO{~t9sKO{NcnKukJIH %d!ڝM% vy6I0 EPc-]o_t=k?G&?D&7朁V2]#9\rЕ\Nt?Ljѭ2`VrSWSdYIAl5xlNȕ2)(6OYg^%xKJD̢ L8% +7.W;z+Y9,]|-\ڙM`QfF?`'CdB"ݔ"^/nJN% +p?^h\k3Tֽ֬a +U&_gn0 X" k/igr}!Ѫ*=HEצ@Y06HL#xWMi ܀> +endobj +890 0 obj +<> +/W [0 [645.50781 0 0 275.87891 0 493.16406] 11 12 369.14063 15 [270.99609 404.29688 0 443.35938] 19 28 575.19531 31 33 707.03125 34 [437.98828 0 703.125 641.11328 0 737.30469 532.22656 520.01953 710.9375 766.11328 316.89453 445.3125 648.92578 511.23047 957.03125 790.03906 758.30078 614.25781 758.30078 652.83203 560.54688 585.9375 723.14453 666.99219 1004.88281 655.27344 0 606.93359] 68 [538.08594 620.11719 479.98047 619.14063 541.01563 383.30078 619.14063 602.05078 284.17969 284.17969 559.08203 284.17969 916.01563 604.98047 611.32813 620.11719 619.14063 397.94922 439.94141 389.16016 604.98047 541.99219 797.36328 552.24609 538.08594 479.00391] 104 [723.14453 0 0 0 538.08594] 124 [610.83984] 129 [604.98047] 137 [627.92969]] +/DW 0>> +endobj +891 0 obj +<> stream +x]n0E +/EdBJ!H,Pi>E*gW!uҹkȫӍxu2pk#롙ȫ^fCeۑ) ~nᛣ/ep[&4sɲhߚ *~ٝYLdEih` TJ)3eYf w$.iO d' +TD%QH#R tH@TH"|*g|en +Jy$.TJɮ=PVQ<H)TBDUD{zXï 򘪾:$6Z?ϲ +endstream +endobj +52 0 obj +<> +endobj +892 0 obj +<> stream +xz|sqx͸777f_ $,BHJ K@T D jRj}A+ZR:-8@)R {{Ò~~={yw $y=}R֕͘׾ów,5} +2꼀zmt=y˗?@ yVEn2‸]|1 о5{j@qWלddԮ+sbuϿpP< +' x8X@?7 H&^GX[10r+ F~S}GibMvDz ,K-w⁳,~7Φ~0')FY:4` +C!܈VlEX{+JFy%V*t*Sxlp+6~Ah@'vkL X؎ >XTXxou fcFnA':p?FaPX|' 7`YNW›qzNWUNWNW¢%NW˜<~vG¼vGvGœ.gN ˝WU}ݾ?*OFGf,O S3ػەδ`gG`HvnY',Q~҈Ĥ[.WWOq]}\W {;nw6g^!$#$j=pX?;]6w6:8Ho Ǯg邏 +R IԲ~Z>OrY_' ]n/)3.K=7{Jֲ/30{KƲ/セ~]t|oJ?g(M&lNJ*[v7֐ + W̊sZOד$xz~bsO#(rX8!С-p|d(3)%e0bRH)DJ!@O1c*) !!8u!VnroyRHj;`E?Q'D'hh5d(-OJ.VQYqŏ]-v9Nla2v6T5ʚFY4UW5Ϸ4MSeJ{v + 4-t4ꡧ`0D`= zXiXaaSB;\4TBOO/# $!_HD|$BO‹TO0OFT" ҐI@:lDG&B.A|rP@C. +wS| ߢE[~JRzE('PJPNOT 0?0 (zQE58*QK#Z F~*ߠ`h_kh51(Ѐ&z h0(ƠXLG1Q4a=fL_+G +0~J$L_b2f/ѪmI`J*4̦c::瘁9s\zG,%:~9XL?\\F?c ~XF?\N?B,b`1VOp.* b5˰~q5˕p +\K?J\G?*Jb5~F?UJx5q nZH:laMC7?f>nn-}lV>6V>nm=tv6F͸-[GVCn=n}nы߱ N;KW܍܃_ӷq/vҷq~C[6oAӃ%~OoWJ[5oa'/ |D_›)}}o}s/ 8 x_>%<G>|Gç>}Gp>q>/p>/q>(_pL 7п8!tAx'["}|O@4h38Iti8E i&F43݋"ѽ(!%74iܘэ GUWWV /6hH ?/7';HI xw۬l2:F#&qr\uk].5~+'-P^[NJ2lu¥m*x1XH'|2caB kN;Sɖխ|{=uCl Fl]7˒ͭXvd.b";+6EGu* okg-^AuKx1Vv/`ta.vo u24]PV[+cW=_{Co+|;*vw2U9QȲ;x? O\ZOP^[+;jbY1)+iikE:A{YlJrd7x\ucqcm9ٍMgI\cKkw1OGQ- 'D ;+y-F?γ-'_]uwwӵ^߽`^ZU,t'6ymEd{յ4ʶLK M*ٙUuKGseCuc/R)3Sf+:2ƷʜY +?> oPakd|̆61+''mnٍp^MYDVvlv/';m~Rn-SNy~zT֔mn=\,yx\v'rF[{_RP[zۼEdAf5\@zavI&2q|dtU*YvǴa&ήKM_6[~6—ԁ:fK_M61,*ANnʤVFzeo{bƢs6Jc8Ujp&YLzZ 1N/tq:: +I0E"t&jjTktZW֨5jAJ\S ~:$/ĤE0VgSZF3%jZ +&VL{ LZt:Ygb2ĚQ3=3zޠ B14Z^Rxx1&aR`f50LQ *ft0%LZ"Zx V +NӪtzZQtPkTKtOuM f)u,hLPHw:hWxPzJojpNtSSbxjHf0ILz;k2-fW6ѨA0j5KtjO- SF[s -65$pM6,l05fFl2C*E ;4_cLZ ccآ@ZcH00bs9d[=ѹQKFɤ$ L$I t FHtT$k&}'`]6s=p.áOs`lv0 ( ?Q +}.$8?W71#RnoːvC"Džz&Fc6#%OOc +MR`D+3 Fqz̞#`]JcoǸĕoƂ#Vا1>JD^ͣ2 {VinZ?GF?o5k"qz/*+ J9I˟ ZKky#<,G}ž"g"_Flo彷z﹯w$D+Ah}9kWUvR㹢!\z(''nڷRW"*M?VV?8i̱|b[|E>Ks# ȶm5v#-F\ONqC*J|܎9?9Oq7*Q}0u'6 SXahh);VnԎ$a7q\.$VpECh,8uI*LO[wLM% M{'̛eR{q򪮟/*IVRIQ:g˴,aYF-nYP1uUfWktզ\VSbK2?sXS~Av.ؐi(%춡X(~hHkR˕dwfe%) ~' Y3#jM8HZcŖLFC ۣ$xWZWZ("vk)kzI̺34  q:͂F*eeL>IFҊ )x5GF s$TB^g07'D;5Wؤ7 F %BHĬdkbM +.%}&qj&nTxJT6+><@ȦIqEuFzS :% 3ab_ei5Eɑ+89z!E܍rg^}2؎QI.߂|3dA,QTQ[SCN8em9U-֜;i!gkl^'Nߺjϵa'S~'Џ+3>ޣz9rqWXm9}Od() lSN:AOZSWU}No[i&&O!V'\O0_գ] }j!>!o`_IΈiݹpbiVңQkml"7<"vns"?l8i.'f&JW+,D;8_X%6_W,%&]UI#C&E7Oۚ>?аf~KÙ/s+YN,)/6xOw/nMc<ҕGrC~!0yN>X{DkEi񓴴t?I>T\\BBprXUzY[[ @wޫ. 0ev"zb3Knp87L;EU[>6v/o4SyF^2d-˳ +}~[qq|._WԊp:]Qb_6CjW=@[sf^Py/o'lp*)7)7$[?0 uou&, LԔ툍DpQr'|:z'I+TB;O |k4*" r y/ӢN"*k58.1)QN}i ^AڜУ @| z{$ɚcVƌc4f}}3t^ٿ5g?\mrRE{{=7YBmFhs{s<4u>ca-AG(smJO>Ğ/fOWt*\8rl\qW%i)kY912mV#} CۆUr9m}Vo)%5ot]]FNy偶)2x+3ٚZ90vdܾ%#6ʬd~GB!S~񳵆#9"3'"w*"rw`'="}A#ڼM|ԨKl!ğζA[u++ڇ;A'.xQq~ m>m\U;:O]֦cwq39 OQC) qv|>QhuO}Mo|&a6gMbg^7JZq 3%w.&ƉK|w'h,.o +ϱf5g<6۔xwɔɦ4I9hd)zt+SA>Ʒ,3xFD#Xceӗ-lsQ>IL<;N(K8q;C+wk,="7(3W9 gjoL)M_3r%;]4IP(oҘV Brxl%M7ｮ Ȝ|ì =X[8ytE_OfNorKˇ: +&Wϼen[QgY1X2lj؟Y7mBpGxC|ؘfU;8A ٬yMR*t Κ1O옧w9o޻ӑSWXNNW2r区\Ws][0ƥ8ŝgPX6-pU_Si[|^ˢ{,= @v%N$kwVfC+ JA:Th۳V.TanqՖJu36MM枩B3_7u-]%wMe5m!ݥ|x)(;lZ*GZoSx +bBbߠ6j /7M)[:.+yDgJ]#懶ϛ|L-X?(a)S2жaILokYCIo,|yӪRg,X\W)(|x"Y,&7/2z^4 JPE f4!T繤5jL.sƲgfe{͖V7gzᗷI<P^ja7YE۽uW5aʯ5hfC|JdК{fqU & ZRKBKt ^ +𝈜A4rijd`[!j5l:]"kƦ4{dQǡ{v^+i^1Z =S`A~ ?-DN; +- mS\6v`z>J(qϲJ[戼cy W;>{Wڐ!snqa[g=ԷnFQy0ˊU;;`PֻjGb~2 +(&Ma`Pk +0!fiR=BukscQ0+\׍Ը$H-q8C<| {7$^y*ߜ~ ?T,-6T1˶cB']wpv +UV +,5J$ΥTuZV?pQ 5icF-ܱ[Ǝ[>d&QR'̘[6&v,vyBdeu&˛̍e ofPq5YCgHU^12eaZvfԛx?T]6tg/^3kD2a:u[/DY1*++GO عWt{878k1=Eͷf͝%;C[B[f%ҶeYX:wa^޹#YsF$8H@(ke2xBl.7zb|:V98Gybl KPY4ު7>8ojٌӖ][8dp_[i-,.b8};ptRZ9̺zU~ֹgΝ91TF{)sDp a^` ¼RE lck#CLam`j6yF ުQ- %Nj*ngִiR+Ci#R̪$z;)Qpϔlq\7q'ڜl1Q)ýbe.@l GU}a洊SկG'Npi%h$S42>;;'bĊe$8fѯ< KFhZ~M4X(TBDߜS\bΊ%,Wr + id[FYSȥ׬|0ygPTYWbzg(Gc0cxM8M"ע:֧Z&CnpC,,Yb֬}gFZ^5ʧUQ4jTv,_hȌ+ةsc[ހ@`DR ƹO?] "Pj̱@0xV?0.c_&q+gTć7Q 4(ߥnK@4?RN +dq#.lLv^o93OxMgzK3~D<6yhfP)os> +endobj +894 0 obj +<> +/W [0 [645.50781 0 0 274.90234 0 374.02344] 11 12 304.19922 14 [685.05859 0 399.90234] 22 [539.0625] 29 [217.77344 0 0 0 685.05859 0 0 631.83594 573.24219 639.16016 711.91406 499.02344 488.76953 687.98828 0 266.11328 0 599.60938 462.89063 817.87109 750.97656 0 0 0 582.03125 497.07031 525.87891 688.96484 627.92969 929.19922 0 0 569.82422] 68 69 541.99219 70 [436.03516 541.99219 486.81641 294.92188 541.99219 557.12891 258.78906 0 490.23438 258.78906 857.91016 562.01172 535.15625 541.99219 0 354.98047 395.01953 323.24219 558.10547] 93 [452.14844] 108 [541.99219] 124 [535.15625]] +/DW 0>> +endobj +895 0 obj +<> stream +x]n0D +/E1BJ H,Pi> E*gWx=k/+R{fl*24WPkKȽy̖R#Kν/ٚx >"뎿jü:M4\4Zeo^=gۖ=gSLĥciQ< Zw!HyRE2_vi8yD)RGHN#_rP(@9H(s: +@;P )t+rK=:Zg:`kQ'@BkưG8h_c]&7u}iuγ +endstream +endobj +80 0 obj +<> +endobj +xref +0 896 +0000000000 65535 f +0000000015 00000 n +0000101209 00000 n +0000000286 00000 n +0000198745 00000 n +0000000323 00000 n +0000214405 00000 n +0000000399 00000 n +0000000548 00000 n +0000000691 00000 n +0000000853 00000 n +0000001025 00000 n +0000001217 00000 n +0000001379 00000 n +0000001520 00000 n +0000001712 00000 n +0000001885 00000 n +0000002064 00000 n +0000002239 00000 n +0000002385 00000 n +0000002560 00000 n +0000002722 00000 n +0000002914 00000 n +0000003107 00000 n +0000003267 00000 n +0000003460 00000 n +0000003640 00000 n +0000003821 00000 n +0000004049 00000 n +0000004274 00000 n +0000004420 00000 n +0000004610 00000 n +0000004785 00000 n +0000004990 00000 n +0000005254 00000 n +0000005519 00000 n +0000005743 00000 n +0000006012 00000 n +0000006280 00000 n +0000006529 00000 n +0000006777 00000 n +0000006937 00000 n +0000007131 00000 n +0000007351 00000 n +0000007519 00000 n +0000007702 00000 n +0000007933 00000 n +0000008160 00000 n +0000008306 00000 n +0000008510 00000 n +0000008728 00000 n +0000101769 00000 n +0000230011 00000 n +0000012008 00000 n +0000012223 00000 n +0000012486 00000 n +0000012749 00000 n +0000013034 00000 n +0000013317 00000 n +0000013606 00000 n +0000013894 00000 n +0000014050 00000 n +0000014243 00000 n +0000014424 00000 n +0000014643 00000 n +0000014882 00000 n +0000015121 00000 n +0000015267 00000 n +0000015442 00000 n +0000015616 00000 n +0000015771 00000 n +0000015964 00000 n +0000016145 00000 n +0000016351 00000 n +0000016497 00000 n +0000016686 00000 n +0000016884 00000 n +0000102206 00000 n +0000021192 00000 n +0000020823 00000 n +0000242506 00000 n +0000028802 00000 n +0000102499 00000 n +0000032601 00000 n +0000032642 00000 n +0000032683 00000 n +0000102791 00000 n +0000034926 00000 n +0000050522 00000 n +0000103084 00000 n +0000053361 00000 n +0000059607 00000 n +0000103401 00000 n +0000062072 00000 n +0000103679 00000 n +0000066673 00000 n +0000073688 00000 n +0000103996 00000 n +0000077434 00000 n +0000087896 00000 n +0000093808 00000 n +0000104302 00000 n +0000096713 00000 n +0000104572 00000 n +0000099459 00000 n +0000104866 00000 n +0000104988 00000 n +0000105078 00000 n +0000105146 00000 n +0000178360 00000 n +0000172977 00000 n +0000110241 00000 n +0000110162 00000 n +0000132517 00000 n +0000132431 00000 n +0000110323 00000 n +0000110475 00000 n +0000110396 00000 n +0000132281 00000 n +0000112342 00000 n +0000110584 00000 n +0000110736 00000 n +0000110657 00000 n +0000112208 00000 n +0000111106 00000 n +0000110845 00000 n +0000110997 00000 n +0000110918 00000 n +0000111446 00000 n +0000111184 00000 n +0000111336 00000 n +0000111257 00000 n +0000111788 00000 n +0000111524 00000 n +0000111678 00000 n +0000111598 00000 n +0000112130 00000 n +0000111866 00000 n +0000112020 00000 n +0000111940 00000 n +0000116164 00000 n +0000112428 00000 n +0000112582 00000 n +0000112502 00000 n +0000116046 00000 n +0000114108 00000 n +0000112692 00000 n +0000112846 00000 n +0000112766 00000 n +0000113982 00000 n +0000113220 00000 n +0000112956 00000 n +0000113110 00000 n +0000113030 00000 n +0000113562 00000 n +0000113298 00000 n +0000113452 00000 n +0000113372 00000 n +0000113904 00000 n +0000113640 00000 n +0000113794 00000 n +0000113714 00000 n +0000115960 00000 n +0000114194 00000 n +0000114348 00000 n +0000114268 00000 n +0000115826 00000 n +0000114722 00000 n +0000114458 00000 n +0000114612 00000 n +0000114532 00000 n +0000115064 00000 n +0000114800 00000 n +0000114954 00000 n +0000114874 00000 n +0000115406 00000 n +0000115142 00000 n +0000115296 00000 n +0000115216 00000 n +0000115748 00000 n +0000115484 00000 n +0000115638 00000 n +0000115558 00000 n +0000121188 00000 n +0000116250 00000 n +0000116404 00000 n +0000116324 00000 n +0000121070 00000 n +0000117968 00000 n +0000116514 00000 n +0000116668 00000 n +0000116588 00000 n +0000117842 00000 n +0000117042 00000 n +0000116778 00000 n +0000116932 00000 n +0000116852 00000 n +0000117384 00000 n +0000117120 00000 n +0000117274 00000 n +0000117194 00000 n +0000117764 00000 n +0000117462 00000 n +0000117616 00000 n +0000117536 00000 n +0000120984 00000 n +0000118054 00000 n +0000118208 00000 n +0000118128 00000 n +0000120826 00000 n +0000118582 00000 n +0000118318 00000 n +0000118472 00000 n +0000118392 00000 n +0000118924 00000 n +0000118660 00000 n +0000118814 00000 n +0000118734 00000 n +0000119266 00000 n +0000119002 00000 n +0000119156 00000 n +0000119076 00000 n +0000119646 00000 n +0000119344 00000 n +0000119498 00000 n +0000119418 00000 n +0000119988 00000 n +0000119724 00000 n +0000119878 00000 n +0000119798 00000 n +0000120368 00000 n +0000120066 00000 n +0000120220 00000 n +0000120140 00000 n +0000120748 00000 n +0000120446 00000 n +0000120600 00000 n +0000120520 00000 n +0000126219 00000 n +0000121274 00000 n +0000121428 00000 n +0000121348 00000 n +0000126101 00000 n +0000123342 00000 n +0000121538 00000 n +0000121692 00000 n +0000121612 00000 n +0000123208 00000 n +0000122066 00000 n +0000121802 00000 n +0000121956 00000 n +0000121876 00000 n +0000122408 00000 n +0000122144 00000 n +0000122298 00000 n +0000122218 00000 n +0000122750 00000 n +0000122486 00000 n +0000122640 00000 n +0000122560 00000 n +0000123130 00000 n +0000122828 00000 n +0000122982 00000 n +0000122902 00000 n +0000126015 00000 n +0000123428 00000 n +0000123582 00000 n +0000123502 00000 n +0000125865 00000 n +0000123956 00000 n +0000123692 00000 n +0000123846 00000 n +0000123766 00000 n +0000124298 00000 n +0000124034 00000 n +0000124188 00000 n +0000124108 00000 n +0000124641 00000 n +0000124376 00000 n +0000124530 00000 n +0000124450 00000 n +0000125023 00000 n +0000124719 00000 n +0000124873 00000 n +0000124793 00000 n +0000125405 00000 n +0000125101 00000 n +0000125255 00000 n +0000125175 00000 n +0000125787 00000 n +0000125483 00000 n +0000125637 00000 n +0000125557 00000 n +0000129402 00000 n +0000126305 00000 n +0000126459 00000 n +0000126379 00000 n +0000129284 00000 n +0000128037 00000 n +0000126570 00000 n +0000126726 00000 n +0000126645 00000 n +0000127911 00000 n +0000127104 00000 n +0000126837 00000 n +0000126993 00000 n +0000126912 00000 n +0000127449 00000 n +0000127182 00000 n +0000127338 00000 n +0000127257 00000 n +0000127833 00000 n +0000127527 00000 n +0000127683 00000 n +0000127602 00000 n +0000129198 00000 n +0000128123 00000 n +0000128279 00000 n +0000128198 00000 n +0000129080 00000 n +0000128657 00000 n +0000128390 00000 n +0000128546 00000 n +0000128465 00000 n +0000129002 00000 n +0000128735 00000 n +0000128891 00000 n +0000128810 00000 n +0000132195 00000 n +0000129488 00000 n +0000129644 00000 n +0000129563 00000 n +0000132077 00000 n +0000130830 00000 n +0000129755 00000 n +0000129911 00000 n +0000129830 00000 n +0000130712 00000 n +0000130289 00000 n +0000130022 00000 n +0000130178 00000 n +0000130097 00000 n +0000130634 00000 n +0000130367 00000 n +0000130523 00000 n +0000130442 00000 n +0000131991 00000 n +0000130916 00000 n +0000131072 00000 n +0000130991 00000 n +0000131873 00000 n +0000131450 00000 n +0000131183 00000 n +0000131339 00000 n +0000131258 00000 n +0000131795 00000 n +0000131528 00000 n +0000131684 00000 n +0000131603 00000 n +0000132704 00000 n +0000132623 00000 n +0000132853 00000 n +0000132772 00000 n +0000133002 00000 n +0000132921 00000 n +0000133150 00000 n +0000133069 00000 n +0000133452 00000 n +0000133299 00000 n +0000133218 00000 n +0000133371 00000 n +0000133610 00000 n +0000133529 00000 n +0000133993 00000 n +0000133678 00000 n +0000133840 00000 n +0000133759 00000 n +0000133912 00000 n +0000134868 00000 n +0000134387 00000 n +0000134078 00000 n +0000134234 00000 n +0000134153 00000 n +0000134306 00000 n +0000134782 00000 n +0000134473 00000 n +0000134629 00000 n +0000134548 00000 n +0000134701 00000 n +0000135064 00000 n +0000134984 00000 n +0000135453 00000 n +0000135131 00000 n +0000135225 00000 n +0000135385 00000 n +0000135305 00000 n +0000135618 00000 n +0000135538 00000 n +0000135918 00000 n +0000135766 00000 n +0000135686 00000 n +0000135838 00000 n +0000136075 00000 n +0000135995 00000 n +0000136223 00000 n +0000136143 00000 n +0000136371 00000 n +0000136291 00000 n +0000136520 00000 n +0000136439 00000 n +0000139241 00000 n +0000136977 00000 n +0000136587 00000 n +0000136662 00000 n +0000136824 00000 n +0000136743 00000 n +0000136896 00000 n +0000137461 00000 n +0000137071 00000 n +0000137146 00000 n +0000137308 00000 n +0000137227 00000 n +0000137380 00000 n +0000137945 00000 n +0000137555 00000 n +0000137630 00000 n +0000137792 00000 n +0000137711 00000 n +0000137864 00000 n +0000138429 00000 n +0000138039 00000 n +0000138114 00000 n +0000138276 00000 n +0000138195 00000 n +0000138348 00000 n +0000138913 00000 n +0000138523 00000 n +0000138598 00000 n +0000138760 00000 n +0000138679 00000 n +0000138832 00000 n +0000139163 00000 n +0000139007 00000 n +0000139082 00000 n +0000139470 00000 n +0000139389 00000 n +0000139618 00000 n +0000139537 00000 n +0000139803 00000 n +0000139686 00000 n +0000139950 00000 n +0000139870 00000 n +0000140097 00000 n +0000140017 00000 n +0000140245 00000 n +0000140165 00000 n +0000140621 00000 n +0000140544 00000 n +0000140392 00000 n +0000140312 00000 n +0000140464 00000 n +0000140792 00000 n +0000140712 00000 n +0000140940 00000 n +0000140860 00000 n +0000141548 00000 n +0000141008 00000 n +0000141169 00000 n +0000141088 00000 n +0000141237 00000 n +0000141399 00000 n +0000141318 00000 n +0000141467 00000 n +0000141730 00000 n +0000141649 00000 n +0000142648 00000 n +0000141798 00000 n +0000141960 00000 n +0000141879 00000 n +0000142028 00000 n +0000142190 00000 n +0000142109 00000 n +0000142258 00000 n +0000142339 00000 n +0000142580 00000 n +0000142500 00000 n +0000142845 00000 n +0000142765 00000 n +0000143449 00000 n +0000142913 00000 n +0000143073 00000 n +0000142993 00000 n +0000143141 00000 n +0000143301 00000 n +0000143221 00000 n +0000143369 00000 n +0000143630 00000 n +0000143550 00000 n +0000144238 00000 n +0000143698 00000 n +0000143859 00000 n +0000143778 00000 n +0000143927 00000 n +0000144089 00000 n +0000144008 00000 n +0000144157 00000 n +0000144420 00000 n +0000144339 00000 n +0000145658 00000 n +0000144644 00000 n +0000144488 00000 n +0000144563 00000 n +0000144878 00000 n +0000144722 00000 n +0000144797 00000 n +0000145112 00000 n +0000144956 00000 n +0000145031 00000 n +0000145346 00000 n +0000145190 00000 n +0000145265 00000 n +0000145580 00000 n +0000145424 00000 n +0000145499 00000 n +0000145879 00000 n +0000145798 00000 n +0000146028 00000 n +0000145947 00000 n +0000146177 00000 n +0000146096 00000 n +0000147557 00000 n +0000146472 00000 n +0000146244 00000 n +0000146400 00000 n +0000146319 00000 n +0000146859 00000 n +0000146550 00000 n +0000146706 00000 n +0000146625 00000 n +0000146778 00000 n +0000147173 00000 n +0000146945 00000 n +0000147101 00000 n +0000147020 00000 n +0000147479 00000 n +0000147251 00000 n +0000147407 00000 n +0000147326 00000 n +0000147772 00000 n +0000147692 00000 n +0000148087 00000 n +0000147839 00000 n +0000148019 00000 n +0000147939 00000 n +0000148244 00000 n +0000148164 00000 n +0000148392 00000 n +0000148312 00000 n +0000148539 00000 n +0000148459 00000 n +0000148686 00000 n +0000148606 00000 n +0000149063 00000 n +0000148986 00000 n +0000148834 00000 n +0000148754 00000 n +0000148906 00000 n +0000149235 00000 n +0000149154 00000 n +0000149384 00000 n +0000149303 00000 n +0000150223 00000 n +0000149452 00000 n +0000149614 00000 n +0000149533 00000 n +0000149682 00000 n +0000149844 00000 n +0000149763 00000 n +0000149912 00000 n +0000150074 00000 n +0000149993 00000 n +0000150142 00000 n +0000150421 00000 n +0000150340 00000 n +0000150800 00000 n +0000150489 00000 n +0000150651 00000 n +0000150570 00000 n +0000150719 00000 n +0000150966 00000 n +0000150885 00000 n +0000151345 00000 n +0000151034 00000 n +0000151196 00000 n +0000151115 00000 n +0000151264 00000 n +0000151510 00000 n +0000151430 00000 n +0000151658 00000 n +0000151578 00000 n +0000151806 00000 n +0000151726 00000 n +0000151954 00000 n +0000151874 00000 n +0000152102 00000 n +0000152022 00000 n +0000152250 00000 n +0000152170 00000 n +0000153851 00000 n +0000152471 00000 n +0000152317 00000 n +0000152391 00000 n +0000152703 00000 n +0000152549 00000 n +0000152623 00000 n +0000153765 00000 n +0000152781 00000 n +0000152856 00000 n +0000153639 00000 n +0000153093 00000 n +0000152937 00000 n +0000153012 00000 n +0000153327 00000 n +0000153171 00000 n +0000153246 00000 n +0000153561 00000 n +0000153405 00000 n +0000153480 00000 n +0000154293 00000 n +0000153978 00000 n +0000154140 00000 n +0000154059 00000 n +0000154212 00000 n +0000154693 00000 n +0000154378 00000 n +0000154540 00000 n +0000154459 00000 n +0000154612 00000 n +0000155319 00000 n +0000154778 00000 n +0000154940 00000 n +0000154859 00000 n +0000155008 00000 n +0000155170 00000 n +0000155089 00000 n +0000155238 00000 n +0000155888 00000 n +0000155576 00000 n +0000155420 00000 n +0000155495 00000 n +0000155810 00000 n +0000155654 00000 n +0000155729 00000 n +0000156319 00000 n +0000156004 00000 n +0000156166 00000 n +0000156085 00000 n +0000156238 00000 n +0000156872 00000 n +0000156560 00000 n +0000156404 00000 n +0000156479 00000 n +0000156794 00000 n +0000156638 00000 n +0000156713 00000 n +0000157069 00000 n +0000156988 00000 n +0000157218 00000 n +0000157137 00000 n +0000157367 00000 n +0000157286 00000 n +0000158610 00000 n +0000157740 00000 n +0000157434 00000 n +0000157588 00000 n +0000157508 00000 n +0000157660 00000 n +0000158132 00000 n +0000157826 00000 n +0000157980 00000 n +0000157900 00000 n +0000158052 00000 n +0000158524 00000 n +0000158218 00000 n +0000158372 00000 n +0000158292 00000 n +0000158444 00000 n +0000159064 00000 n +0000158734 00000 n +0000158815 00000 n +0000158996 00000 n +0000158915 00000 n +0000159230 00000 n +0000159149 00000 n +0000159379 00000 n +0000159298 00000 n +0000160236 00000 n +0000159755 00000 n +0000159446 00000 n +0000159602 00000 n +0000159521 00000 n +0000159674 00000 n +0000160150 00000 n +0000159841 00000 n +0000159997 00000 n +0000159916 00000 n +0000160069 00000 n +0000161057 00000 n +0000160436 00000 n +0000160355 00000 n +0000160508 00000 n +0000160670 00000 n +0000160589 00000 n +0000160742 00000 n +0000160904 00000 n +0000160823 00000 n +0000160976 00000 n +0000161247 00000 n +0000161166 00000 n +0000161396 00000 n +0000161315 00000 n +0000161544 00000 n +0000161463 00000 n +0000161692 00000 n +0000161611 00000 n +0000162071 00000 n +0000161994 00000 n +0000161841 00000 n +0000161760 00000 n +0000161913 00000 n +0000162243 00000 n +0000162162 00000 n +0000162392 00000 n +0000162311 00000 n +0000162768 00000 n +0000162460 00000 n +0000162620 00000 n +0000162540 00000 n +0000162688 00000 n +0000164676 00000 n +0000163159 00000 n +0000162853 00000 n +0000163007 00000 n +0000162927 00000 n +0000163079 00000 n +0000163551 00000 n +0000163245 00000 n +0000163399 00000 n +0000163319 00000 n +0000163471 00000 n +0000164179 00000 n +0000163637 00000 n +0000163792 00000 n +0000163711 00000 n +0000163864 00000 n +0000164026 00000 n +0000163945 00000 n +0000164098 00000 n +0000164590 00000 n +0000164281 00000 n +0000164437 00000 n +0000164356 00000 n +0000164509 00000 n +0000165146 00000 n +0000164808 00000 n +0000164916 00000 n +0000165078 00000 n +0000164997 00000 n +0000165569 00000 n +0000165231 00000 n +0000165339 00000 n +0000165501 00000 n +0000165420 00000 n +0000165735 00000 n +0000165654 00000 n +0000165884 00000 n +0000165803 00000 n +0000166033 00000 n +0000165952 00000 n +0000166182 00000 n +0000166101 00000 n +0000166331 00000 n +0000166250 00000 n +0000166517 00000 n +0000166399 00000 n +0000166666 00000 n +0000166585 00000 n +0000166815 00000 n +0000166734 00000 n +0000166964 00000 n +0000166883 00000 n +0000167346 00000 n +0000167031 00000 n +0000167193 00000 n +0000167112 00000 n +0000167265 00000 n +0000167512 00000 n +0000167431 00000 n +0000167661 00000 n +0000167580 00000 n +0000168045 00000 n +0000167728 00000 n +0000167891 00000 n +0000167809 00000 n +0000167963 00000 n +0000168212 00000 n +0000168130 00000 n +0000168834 00000 n +0000168280 00000 n +0000168444 00000 n +0000168362 00000 n +0000168516 00000 n +0000168680 00000 n +0000168598 00000 n +0000168752 00000 n +0000169253 00000 n +0000168935 00000 n +0000169099 00000 n +0000169017 00000 n +0000169171 00000 n +0000169420 00000 n +0000169338 00000 n +0000169570 00000 n +0000169488 00000 n +0000169952 00000 n +0000169638 00000 n +0000169802 00000 n +0000169720 00000 n +0000169870 00000 n +0000170119 00000 n +0000170037 00000 n +0000170501 00000 n +0000170187 00000 n +0000170351 00000 n +0000170269 00000 n +0000170419 00000 n +0000170668 00000 n +0000170586 00000 n +0000170818 00000 n +0000170736 00000 n +0000170968 00000 n +0000170886 00000 n +0000171117 00000 n +0000171036 00000 n +0000171265 00000 n +0000171184 00000 n +0000171413 00000 n +0000171332 00000 n +0000171792 00000 n +0000171715 00000 n +0000171562 00000 n +0000171481 00000 n +0000171634 00000 n +0000171965 00000 n +0000171884 00000 n +0000172114 00000 n +0000172033 00000 n +0000172726 00000 n +0000172182 00000 n +0000172344 00000 n +0000172263 00000 n +0000172412 00000 n +0000172576 00000 n +0000172494 00000 n +0000172644 00000 n +0000172909 00000 n +0000172827 00000 n +0000174019 00000 n +0000174662 00000 n +0000175113 00000 n +0000175420 00000 n +0000175599 00000 n +0000175914 00000 n +0000176149 00000 n +0000176512 00000 n +0000176811 00000 n +0000177062 00000 n +0000177345 00000 n +0000177476 00000 n +0000178456 00000 n +0000178673 00000 n +0000197075 00000 n +0000197318 00000 n +0000198344 00000 n +0000198886 00000 n +0000213499 00000 n +0000213736 00000 n +0000214061 00000 n +0000214546 00000 n +0000228403 00000 n +0000228651 00000 n +0000229595 00000 n +0000230158 00000 n +0000241039 00000 n +0000241294 00000 n +0000242091 00000 n +trailer +<> +startxref +242655 +%%EOF diff --git a/doc/images/Kreisel-attribute.png b/doc/images/Kreisel-attribute.png new file mode 100644 index 0000000..15e20f6 Binary files /dev/null and b/doc/images/Kreisel-attribute.png differ diff --git a/doc/images/Kreisel-mit-gui.png b/doc/images/Kreisel-mit-gui.png new file mode 100644 index 0000000..c8a57de Binary files /dev/null and b/doc/images/Kreisel-mit-gui.png differ diff --git a/doc/images/gefaellestrecke-gui.png b/doc/images/gefaellestrecke-gui.png new file mode 100644 index 0000000..0cae1e4 Binary files /dev/null and b/doc/images/gefaellestrecke-gui.png differ diff --git a/doc/images/gefaellestrecke.png b/doc/images/gefaellestrecke.png new file mode 100644 index 0000000..44f0165 Binary files /dev/null and b/doc/images/gefaellestrecke.png differ diff --git a/doc/images/gf-linienzug1.png b/doc/images/gf-linienzug1.png new file mode 100644 index 0000000..3f86d3d Binary files /dev/null and b/doc/images/gf-linienzug1.png differ diff --git a/doc/images/gf-linienzug2.png b/doc/images/gf-linienzug2.png new file mode 100644 index 0000000..8cd4a5d Binary files /dev/null and b/doc/images/gf-linienzug2.png differ diff --git a/doc/images/gf-linienzug3.png b/doc/images/gf-linienzug3.png new file mode 100644 index 0000000..b5e6af2 Binary files /dev/null and b/doc/images/gf-linienzug3.png differ diff --git a/doc/images/gf-vf-kombination.png b/doc/images/gf-vf-kombination.png new file mode 100644 index 0000000..f37f8f1 Binary files /dev/null and b/doc/images/gf-vf-kombination.png differ diff --git a/doc/images/variofoerderer.png b/doc/images/variofoerderer.png new file mode 100644 index 0000000..af3e473 Binary files /dev/null and b/doc/images/variofoerderer.png differ diff --git a/doc/images/vf-gui1.png b/doc/images/vf-gui1.png new file mode 100644 index 0000000..431947b Binary files /dev/null and b/doc/images/vf-gui1.png differ diff --git a/doc/images/vf-gui2.png b/doc/images/vf-gui2.png new file mode 100644 index 0000000..f34cbe4 Binary files /dev/null and b/doc/images/vf-gui2.png differ diff --git a/doc/json-input-lisp.md b/doc/json-input-lisp.md new file mode 100644 index 0000000..910a632 --- /dev/null +++ b/doc/json-input-lisp.md @@ -0,0 +1,449 @@ +# JSON-Eingabe fuer den LISP-Bau + +Welche Objekte sich aus einer JSON-Datei an einer gegebenen x/y/z-Koordinate +erzeugen lassen, in welchem Format sie beschrieben werden und welche +LISP-Routine sie baut. Grundlage sind die Testdaten in `tests/testdata/*.json` +und die Treiber in `tests/test_*.lsp`, die sie lesen. + +Die zugehoerigen LISP-Routinen mit Signaturen stehen in +[lisp_methods.md](lisp_methods.md). Diese Seite ersetzt das fruehere +`tests/testdata/object_data.md` (geloescht in Commit `e147b89`, auf das Code- +Kommentare teilweise noch verweisen). + +**Feldnamen als Python-Konstanten**: `lib/testdata_schema.py` buendelt die +Feldnamen/festen Werte der Abschnitte 1 (Kreisel), 2 (Einzelbloecke), 3 (VF +Standard/Etage) und 4.1 (Gefaellestrecke Modus 1) als benannte Konstanten +(`sch.F_ABSTAND`, `sch.SEITE_LINKS`, ...), genutzt von `lib/dxf_anlage_export.py` +(eigene, mit unseren Makros gebaute Zeichnungen). `lib/dxf_scan_components.py` +(fremde Zeichnungen) hat dieselben Feldnamen weiterhin als eigene String- +Literale - gleiches Schema, noch nicht auf das gemeinsame Modul umgestellt. + +--- + +## 0. Uebersicht + +| Objekt | Erkennungsmerkmal im JSON | Bau-Routine (Produktion) | Koordinaten-Eingang | Beispiel-Datei | +|---|---|---|---|---| +| [Kreisel (Insert)](#1-kreisel) | `"function": "insert"`, KEIN `block` | `kreisel-insert-script` | `x`,`y`,`z` = Einfuegepunkt | `kreisel_tests.json`, `mubea.json`, `hundm05.json`, `dematic_arvato.json` | +| [Kreisel (Connect)](#12-connect-start--und-endpunkt) | `"function": "connect"` | `kreisel-connect-script` | `start_*`, `end_*` | (nur `test_kreisel.lsp`, z.Z. kein Datensatz) | +| [Einzelblock](#2-einzelbloecke-separator-scanner-btmt-eingangausgang-vario-bausteine) (Separator, Scanner, BTMT, Eingang/Ausgang, Vario-Bausteine) | `"function": "insert"` + `"block"` | direktes `_.INSERT` nach `ssg-ils-block-laden` | `x`,`y`,`z` + `rotation` | `mubea.json`, `hundm05.json`, `dematic_arvato.json` | +| [VarioFoerderer Standard](#3-variofoerderer-standard-und-etage) | `test_id` beginnt mit `VF_`, `typ` fehlt oder `"standard"` | `berechne-alle-winkel` + `variofoerderer-einfuegen` + `vf-block-erstellen` | `x`,`y`,`z` = KS_EIN des AS-Elements | `mubea.json`, `foerderer_tests.json` | +| [VarioFoerderer Etage](#3-variofoerderer-standard-und-etage) | `test_id` `VF_*` + `"typ": "etage"` | `berechne-etage` + `etage-foerderanlage-einfuegen` + `vf-block-erstellen` | wie Standard | `mubea.json` | +| [Gefaellestrecke Modus 1](#4-gefaellestrecke) | `test_id` `GF_*` bzw. `"modus": 1` | `gefaellestrecke-einfuegen` (bzw. `gf-rebuild`) | `start_mm` = KS_EIN des AS-Elements | `mubea.json`, `gefaellestrecke_tests.json` | +| [Gefaellestrecke Modus 2](#42-modus-2---richtung-aus-zwei-punkten) | `"modus": 2` | wie Modus 1, `deltaL`/`hz` aus zwei Punkten | `start_mm` + `linie_start_mm`/`linie_ende_mm` | `gefaellestrecke_tests.json` | +| [Gefaellestrecke Modus 3](#43-modus-3---linienzug) | `"modus": 3` | nur ueber `test_gefaellestrecke.lsp` | `start_mm`, `ende_mm`, `bogen` | `gefaellestrecke_tests.json` | +| [VF-Linienzug-Kette (Spec)](#5-vf-linienzug-kette-spec) | Kopf mit `spec_id`, danach `glied`/`sub` | `vsp-bau-aus-spec` (Replay durch `vf-linienzug-modus`) | `start_punkt` = Kettenanfang | `hundm05.json` | +| [VF-Linienzug (Journal)](#6-vf-linienzug-eingabe-journal) | Kopf mit `test_id`, danach `typ` = `point_abs`/`real`/`string`/... | `vfl-journal-replay-start` + `vf-linienzug-modus` | erstes `point_abs` | `linienzug_tests.json`, `hm_recformat.json` | +| [Omniflo Bogen/Weiche](#71-bogen-und-weiche) | `"type": "bogen"` / `"weiche"` + `sivasnr` | `_.INSERT` der `.dxf` (Kern `omni:insert-dxf` fragt den Punkt interaktiv) | `x`,`y`, Z = `hoehe` | `omniflo_tests.json`, `omniflo_strecke_tests.json` | +| [Omniflo Gerade](#72-aluprofil-gerade) | `"type": "gerade"` + `profil` | `omni:make-gerade` | `x`,`y` -> `x_ende`,`y_ende`, Z = `hoehe` | `omniflo_strecke_tests.json` | +| [Waagrechte Foerderstrecke](#8-waagrechte-foerderstrecke-gerade---noch-ohne-bau-pfad) | `"typ": "gerade"` + `startpunkt` | **kein Bau-Pfad** (wird gemeldet und uebersprungen) | `startpunkt`, `endpunkt` | `dematic_arvato.json` | + +Nicht aus JSON baubar (es gibt keine Testdaten und keinen Treiber): Eckrad, +Geruest, TEF-Foerderer-Linie, TRO-Marker, Connections, Omniflo-Ladeschleife. +Fuer Eckrad und Geruest existiert ein skriptfaehiger Kern, siehe +[lisp_methods.md](lisp_methods.md). + +### Allgemeine Regeln + +- **Einheiten**: Laengen und Koordinaten in **mm**, Winkel in **Grad**. + Fahrtrichtung `hz`: 0 = +X (Ost), 90 = +Y (Nord), 180 = -X, 270 = -Y. +- **Z ist absolut**: `z` (bzw. Z in `start_mm`/`start_punkt`) ist die + Weltkoordinate des Einfuegepunkts, also die Einbauhoehe. +- **Dimension 2D/3D**: Gebaut wird in der aktuellen Dimension + (`ssg-ils-dim-aktuell`: `*ssg-ils-dim*` -> `DXFM_DIM`, Default 3D). + Das Feld `darstellung` in `dematic_arvato.json` ist reine Dokumentation und + wird nicht ausgewertet; `TEST_HUNDM05_2D`/`_3D` erzwingen die Dimension. +- **Flaches JSON**: Die meisten Dateien werden mit `ssg-load-json` gelesen + (zeilenweise, ein Objekt je `{`). Verschachtelte Objekte und mehrzeilige + Arrays darin funktionieren nicht - darum stehen z.B. die Glieder einer + Kette als eigene Objekte hinter ihrem Kopf-Objekt. Ausnahme: + `TEST_DEMATIC_ARVATO` liest mit dem rekursiven `ssg-json-laden`. +- **Reine Doku-Felder**: `comment`, `beschreibung`, `description`, `quelle`, + `row`, `seq`, `gruppe`, `assigned_to`, `hoehe_unbekannt`, `darstellung` + sowie alle `expect_*`/`erwartung_*`-Felder werden beim Bau nicht gelesen. + `expect_*` pruefen die Python-Tests gegen das Ergebnis. +- **Template-Felder** (nur `test_mubea.lsp`): `anzahl`, `delta_x`, `delta_y` + erzeugen aus einem Eintrag `anzahl` Kopien, jeweils um `delta_x`/`delta_y` + versetzt; `test_id` bekommt dann das Suffix `_01` ... `_nn`. Gilt fuer VF, + GF und Einzelbloecke. + +--- + +## 1. Kreisel + +Block `KREISEL_n`, gebaut von `KreiselInsert.lsp`. + +### 1.1 Insert (freier Punkt) + +```json +{ "id": "KR_Kreuz_Q1_0Grad", "function": "insert", + "x": 500, "y": 500, "z": 2500, + "abstand": 2000, "rotation": 0.0, "typ": "STANDARD" } +``` + +| Feld | Pflicht | Bedeutung | Default | +|---|---|---|---| +| `id` | ja (fuer den Treiber) | Kennung im Ergebnis; NICHT die Block-ID (die vergibt `ssg-id-generate`) | - | +| `function` | ja | `"insert"`; ohne `block` = Kreisel | - | +| `x`, `y` | ja | Einfuegepunkt. Liegt auf der Kreiselachse **einen Radius (400 mm) vor der Mitte des Antriebsrads (AN)**, also am aeussersten Punkt der AN-Seite | - | +| `z` | ja | Einbauhoehe; wird als `hoehe` uebergeben und in das Attribut `HOEHE` geschrieben | `kreisel.default_hoehe` (2000) | +| `abstand` | ja | Mittenabstand Antriebsrad - Spannrad | `kreisel.default_laenge` (2300) | +| `rotation` | nein | Drehung der Achse AN -> SP, frei (kein Raster) | 0.0 | +| `typ` | nein | `"STANDARD"` oder `"PIN"` -> Attribut `KREISELART` | `"STANDARD"` | +| `drehrichtung` | nein | `"GUZ"` oder `"UZS"` -> Attribut `DREHRICHTUNG` | `"UZS"` | + +Treiber: `kreisel:run-insert-test` (`test_kreisel.lsp`), `mubea:build-kreisel`, +`hundm05:bau-kreisel` (auch fuer `dematic_arvato.json`/`showroom_ils.json`). +Nur `hundm05:bau-kreisel` liest `drehrichtung` aus und reicht sie an +`kreisel-insert-script` weiter; `mubea:build-kreisel` setzt es (noch) nicht um. + +### 1.2 Connect (Start- und Endpunkt) + +```json +{ "id": "K2", "function": "connect", + "start_x": 0, "start_y": 0, "start_z": 2000, + "end_x": 5000, "end_y": 0, "end_z": 2000, "typ": "STANDARD" } +``` + +`start_*` und `end_*` sind die aeussersten Punkte der AN- bzw. SP-Seite. +`abstand` (= Distanz - Kreiseldurchmesser 800) und `rotation` werden daraus +berechnet. Die Einbauhoehe kommt aus `start_z`. Nur `test_kreisel.lsp` kennt +`connect`; die anderen Treiber bauen ausschliesslich `insert`. + +--- + +## 2. Einzelbloecke (Separator, Scanner, BTMT, Eingang/Ausgang, Vario-Bausteine) + +Jeder Eintrag mit `"function": "insert"` UND `"block"` wird als einzelner +Block eingefuegt, ohne Wrapper-Block und ohne Verkettung. + +```json +{ "id": "HundM05_SCANNER_02", "function": "insert", "block": "Scanner", + "x": 4095.5, "y": 1164.1, "z": 2154, "rotation": 270 } +``` + +| Feld | Pflicht | Bedeutung | Default | +|---|---|---|---| +| `block` | ja | Blockname OHNE `_2D`/`_3D`-Suffix | - | +| `x`, `y`, `z` | ja | Einfuegepunkt = **Basispunkt der Block-DWG** (nicht KS_EIN) | - | +| `rotation` | nein | Drehung um Z | 0 | +| `id` / `test_id` | nein | Kennung im Ergebnis | `SEPARATOR_` bzw. Blockname | + +Ablauf: `ssg-ils-block-laden` loest den Namen auf `data/ils/_.dwg` +auf (3D-Fallback), danach `_.INSERT eff pt "" "" rotation` und +`ssg-id-generate`. **Fehlt die DWG, wird `Separator_SP` eingefuegt.** +Treiber: `mubea:build-separator`, `hundm05:bau-sensor` (auch Dematic). +Das Layer-Attribut `LAYER` wird dabei nicht angewendet; der Block landet auf +dem aktuellen Layer. + +### In den Testdaten verwendete Blocknamen + +| `block` | DWG in `data/ils` | Verwendet in | Hinweis | +|---|---|---|---| +| `Scanner` | `Scanner_2D/_3D.dwg` | mubea, hundm05, dematic_arvato | | +| `Separator_SP` | `Separator_SP_2D/_3D.dwg` | (Fallback) | Block von `ILS_SEPARATOR_INSERT` | +| `S-LP` | **fehlt** | mubea, hundm05, dematic_arvato | wird zu `Separator_SP` | +| `S-SP` | **fehlt** | dematic_arvato | wird zu `Separator_SP` | +| `BTMT-Beladung` | `BTMT-Beladung_2D/_3D.dwg` | mubea, hundm05 | wie `ILS_BTMT_Beladung` | +| `SC_Entladung` | `SC_Entladung_2D/_3D.dwg` | mubea, hundm05 | wie `ILS_BTMT_Entladung` | +| `Eingang` / `Ausgang` | `Eingang_*/Ausgang_*.dwg` | mubea | Symbole wie `ILS_EINGANG_INSERT`/`ILS_AUSGANG_INSERT` | +| `AS_Element_90_links` / `_rechts` | vorhanden | dematic_arvato | loses AS-Element (sonst Teil eines VF/GF) | +| `ES_Element_90_rechts`, `ES_Element_30_rechts` | vorhanden | dematic_arvato | loses ES-Element | +| `Vario_Motorstation_500mm_rechts` | vorhanden | dematic_arvato | lose Motorstation | +| `Vario_Umlenkstation_500mm_rechts` | vorhanden | dematic_arvato | lose Umlenkstation | +| `Vario_Kurve_rechts_30_TEF_aussen` | vorhanden | dematic_arvato | lose Vario-Kurve | + +Grundsaetzlich ist **jeder** Blockname aus `data/ils` erlaubt (es gibt keine +Whitelist). Die losen AS/ES-/Vario-Bausteine bilden aber keine Kette und keinen +`VF_n`/`GF_n`-Block - fuer eine zusammenhaengende Strecke Abschnitt 3-5 nutzen. + +--- + +## 3. VarioFoerderer Standard und Etage + +Block `VF_n`. Eingang sind die **Gesamtmasse** der Anlage; Winkel und +Teillaengen berechnet der Solver. + +```json +{ "test_id": "VF_Schnitt_C", "richtung": "Auf", + "deltaL": 9110, "deltaH": 474, "winkel": 21, + "gf_verteilung": "manuell", "L_GF1": 2298, "seite": "links", + "hz": 0.0, "x": 400, "y": 14120, "z": 1554 } +``` + +| Feld | Pflicht | Bedeutung | Default | +|---|---|---|---| +| `test_id` | ja | muss mit `VF_` beginnen (steuert den Dispatcher in `test_mubea.lsp`) | - | +| `typ` | nein | `"standard"` (AS/ES 90 Grad) oder `"etage"` (AS/ES 30 Grad, uebereinander) | `"standard"` | +| `richtung` | ja | `"Auf"` oder `"Ab"` | - | +| `deltaL` | ja | horizontale Gesamtlaenge inkl. AS/ES, Boegen, GF-Vor-/Nachlauf | - | +| `deltaH` | ja | Hoehendifferenz (Betrag; Vorzeichen kommt aus `richtung`) | - | +| `winkel` | nein | Bogenwinkel erzwingen, nur aus der Kandidatenliste (`vario.bogen_winkel`: 3, 6, 9, 12, 15, 18, 21, 27, 33, 39, 45, 51). Ist er nicht loesbar, wird NICHT gebaut | kleinster gueltiger Winkel | +| `L_GF1` | nein (mubea) | Vorlauf-Laenge (GF vor dem Foerderer); Nachlauf = Rest von `L_GF` | - | +| `gf_verteilung` | nein (foerderer) | `"gleichmaessig"`, `"vorne"`, `"hinten"`; in `mubea.json` nur Doku (dort zaehlt `L_GF1`) | `"gleichmaessig"` | +| `seite` | nein | `"links"`/`"rechts"` (Seite der AS/ES-Elemente) | `"links"` | +| `hz` | nein | Fahrtrichtung | 0.0 | +| `x`, `y`, `z` | ja (mubea) | Startpunkt = **KS_EIN des AS-Elements**; `z` = Einbauhoehe am Anfang | - | + +Hinweise: +- `foerderer_tests.json` hat statt `x/y/z` einen Kopf-Eintrag + `{"y_abstand": 600}`: alle Foerderer starten bei x = 0, z = 0 und werden um + `y_abstand` versetzt. Dieses Format kennt nur `test_foerderer.lsp`. +- `"Ab"` mit `deltaH` < 1 ist geometrisch unmoeglich und wird abgewiesen. +- Der Treiber schreibt nach dem Bau `vf-edit-xdata-schreiben` (Typ + `hz`), + damit der Block per Doppelklick editierbar ist. + +--- + +## 4. Gefaellestrecke + +Block `GF_n`: AS-Element -> Staustrecke (skaliert) -> Separator -> ES-Element. +Eingang ist die **horizontale Laenge**, nicht die Hoehendifferenz - die ergibt +sich aus Laenge und Neigung. + +### 4.1 Modus 1 - Werteingabe + +```json +{ "test_id": "GF_Mubea", "modus": 1, + "deltaL_mm": 9110, "hz_grad": 180.0, "winkel_grad": 2.27, + "start_mm": [9510, 12300, 2028], + "as_seite": "links", "es_seite": "links", + "as_winkel": "90", "es_winkel": "90" } +``` + +| Feld | Pflicht | Bedeutung | Default | +|---|---|---|---| +| `test_id` | ja | in `mubea.json` muss sie mit `GF_` beginnen | - | +| `modus` | nein | `1` | - | +| `deltaL_mm` | ja | horizontale Gesamtlaenge AS + Staustrecke + Separator + ES | - | +| `winkel_grad` | nein | Neigung der Staustrecke | 3.0 | +| `hz_grad` | nein | Fahrtrichtung | 0.0 | +| `start_mm` | ja | `[x, y, z]` = **KS_EIN des AS-Elements**; Z = Einbauhoehe oben | - | +| `as_seite`, `es_seite` | nein | `"links"`/`"rechts"` | `"links"` | +| `as_winkel`, `es_winkel` | nein | `"90"` oder `"30"` (als STRING) | `"90"` | + +Die Staustrecke ergibt sich aus +`L_stau = (deltaL - aus-dx - ein-dx - 300 * cos(w)) / cos(w)` +(300 = `gefaelle.separator_breite`). Eine Ziel-Hoehe gibt es nicht. + +In `gefaellestrecke_tests.json` stehen `deltaL_mm`, `winkel_grad` und +`z_start_mm` in einem gemeinsamen Kopf-Eintrag ohne `test_id` und gelten fuer +alle Faelle der Datei. + +### 4.2 Modus 2 - Richtung aus zwei Punkten + +Wie Modus 1, aber `deltaL` und `hz` werden aus `linie_start_mm` -> +`linie_ende_mm` berechnet (nur X/Y). `start_mm` bleibt der Einfuegepunkt und +ist unabhaengig von der Linie. + +```json +{ "test_id": "M2_hz000", "modus": 2, "start_mm": [0, -35000, 5000], + "linie_start_mm": [0, -35000, 0], "linie_ende_mm": [10000, -35000, 0], + "as_seite": "links", "es_seite": "links", "as_winkel": "90", "es_winkel": "90" } +``` + +### 4.3 Modus 3 - Linienzug + +In der Produktion nicht skriptbar (`gf-linienzug-modus` waehlt vorgezeichnete +LINE/ARC-Objekte per Maus). `test_gefaellestrecke.lsp` zeichnet die Leitlinie +selbst und baut sie nicht-interaktiv nach. Zwei Formen: + +```json +{ "test_id": "M3_Bogen", "modus": 3, + "start_mm": [30000, -50000, 2000], "ende_mm": [38500, -43500, 1800], + "bogen": {"winkel_grad": 90, "radius_mm": 500, "seite": "links"}, + "as_seite": "links", "es_seite": "links", "as_winkel": "90", "es_winkel": "90" } +{ "test_id": "M3_hz270", "modus": 3, "richtung": "Sued", + "start_mm": [0, -50000, 5000], + "deltaH_quelle": "M2_hz000", "deltaL_quelle": "M2_hz000", ... } +``` + +`deltaH_quelle`/`deltaL_quelle` uebernehmen die Masse eines frueher gebauten +Falls. Dieses Format ist an den Treiber gebunden. Fuer neue Anlagen besser +eine VF-Linienzug-Spec (Abschnitt 5) mit `Linie-GF`/`GF-Bogen` verwenden. + +--- + +## 5. VF-Linienzug-Kette (Spec) + +Beliebige Ketten aus GF-Linien, GF-Boegen, Vario-Kurven und VF-Einheiten, +**ohne Dialog** gebaut (`VF_SPEC_BAU`, `TEST_HUNDM05`). Eine Kette = ein +Kopf-Objekt, danach ihre Glieder (`glied`) und deren Unterknoten (`sub`) in +Baureihenfolge. Ergebnis ist ein `VF_n`-Block mit vollem `SSG_VF_EDIT`-Journal +(per Doppelklick editierbar). + +```json +{ "spec_id": "VF_spec_LZ_01", "modus": 1, + "start_punkt": [4912.2, 1230.9, 2154.0], "start_hoehe": 2154.0, + "as": 1, "as_winkel": "90", "as_seite": "links" } +{ "glied": "Linie-GF", "nr": 1, "dl": 2249.3, "hz": 90.0, + "gefaelle": "winkel", "winkel": 3.0, "ende": "nein" } +{ "glied": "Horizontal-VF", "nr": 2, "dl": 3256.9, "gf_verteilung": "einlauf", + "vf_sep_vor": 0, "vf_sep_nach": 0, "vf_ende": "nein", "vf_separator": 0 } +{ "sub": "vario-kurve", "winkel": 90, "seite": "rechts", "variante": "innen" } +{ "sub": "motorstation" } +{ "glied": "ES", "winkel": "90", "seite": "links" } +``` + +**Kopf** + +| Feld | Bedeutung | +|---|---| +| `spec_id` | Kennung der Kette | +| `modus` | `1` (nur Modus 1 hat einen Uebersetzer) | +| `start_punkt` | `[x, y, z]` Kettenanfang (KS_EIN des AS-Elements bzw. erstes Glied) | +| `start_hoehe` | Einbauhoehe am Start | +| `as` | `1` = AS-Element setzen, `0` = nicht | +| `as_winkel` / `as_seite` | `"90"`/`"30"` bzw. `"links"`/`"rechts"` | + +**Glieder** (`glied`) + +| `glied` | wichtigste Felder | +|---|---| +| `Linie-GF` | `dl`, `hz` (nur beim ersten Glied der Kette), `laenge_modus` (`endpunkt`/`hoehe`/`steigend`), `ende` (`ja-mit-es`/`ja-ohne-es`/`nein`), `sep_vor`, `sep_nach`, `gefaelle` (`hoehe`/`winkel`) + `hoehe` bzw. `winkel` | +| `GF-Bogen` | `winkel` (30/60/90), `seite` | +| `Vario-Kurve` | als eigenes Glied (Kettenanfang) vom Uebersetzer noch NICHT unterstuetzt -> Spec-Fehler; Vario-Kurven als `sub` einer VF-Einheit angeben | +| `Horizontal-VF` | `dl`, `eingang_hoehe`, `gf_verteilung` (`haelfte`/`einlauf`), `vf_sep_vor`, `vf_sep_nach`, `vf_ende` (`ja-mit-es`/`nein`/`automatisch`/`zielpunkt-ohne-es`), `vf_separator` (nur bei `vf_ende` = `nein`) + `sub`-Knoten | +| `Linie-VF` | `dl`, `hoehe`, optional `winkel_idx` + `sub`-Knoten | +| `Linie` | `dl`, `hoehe`, `segment_typ` (`GF`/`VF`), optional `winkel_idx` | +| `ES` | `winkel` (`"90"`/`"30"`), `seite` | + +**Unterknoten einer VF-Einheit** (`sub`): `horizontal` (`sep_vor`, `sep_nach`), +`vario-kurve` (`winkel`, `seite`, `variante` `aussen`/`innen`), `auf-ab` +(`richtung` `auf`/`ab`, `hoehe`), `motorstation`, `kettenende` (`es`, +`es_winkel`, `es_seite`). + +Ja/Nein-Felder (`as`, `sep_vor`, `vf_sep_vor`, `es`, ...) als `1`/`0` oder +`"ja"`/`"nein"`; mehrwertige Felder (`ende`, `vf_ende`) nur mit den genannten +Woertern. Vollstaendige Regeln +(Menue-Codes je Frame, `hz` nur einmal, Verhalten bei `winkel_idx`): +[variofoerderer.md, Abschnitt 8b](variofoerderer.md#spec-pfad-kette-aus-eingabedaten-vf_spec_bau). +Die Spec wird nicht von Hand geschrieben, sondern mit +`python lib/vf_spec_export.py ` aus einer +aufgezeichneten Kette erzeugt. Fehlerhafte Specs werden komplett abgewiesen +(`vsp-pruefen` sammelt alle Fehler, gebaut wird dann nichts). + +**Andere Objekte in derselben Datei**: Neben den Ketten darf `hundm05.json` +Kreisel (Abschnitt 1) und Einzelbloecke (Abschnitt 2) enthalten. Erkennbar +sind sie an `function`; `vsp-gruppieren` ueberspringt sie, und +`hundm05:bau-zusatzobjekte` baut sie nach den Ketten. `vf_spec_export.py` +haengt sie beim Neuerzeugen unveraendert ans Dateiende. + +--- + +## 6. VF-Linienzug (Eingabe-Journal) + +Das Rohformat hinter der Spec: die Antworten auf die Fragen des interaktiven +Linienzug-Ablaufs, in Reihenfolge. Nur fuer Regressionstests gedacht - fuer +neue Anlagen die Spec (Abschnitt 5) verwenden. + +```json +{ "test_id": "VF_hundm05_LZ_01", "anlagetyp": "linienzug", "modus": 1, ... } +{ "typ": "point_abs", "wert": [4912.2, 1230.9, 2154.0], "kommentar": "Startpunkt" } +{ "typ": "real", "wert": 2154.0, "kommentar": "Hoehe (Z)" } +{ "typ": "string", "wert": "1", "kommentar": "AS-Element? Ja" } +{ "typ": "step", "wert": "Linie-GF", "kommentar": "Glied-Marker" } +{ "typ": "point_rel", "dL": 2249.3, "hz": 90.0, "kommentar": "Endpunkt" } +{ "typ": "int", "wert": 90, "kommentar": "Vario-Kurve Winkel" } +``` + +`typ`: `point_abs` (absoluter Punkt), `point_rel` (Abstand `dL` + Richtung +`hz`, `hz` nur beim ersten Segment), `real`, `int`, `string` (Menue-Code als +String), `step` (Glied-Marker, beim Replay uebersprungen). Kopf-Feld heisst +`anlagetyp`, nicht `typ`, damit Kopf und Eingabe unterscheidbar bleiben. + +| Datei | Treiber | +|---|---| +| `linienzug_tests.json`, `linienzug_tests_stufe2.json` | `TEST_LINIENZUG`, `TEST_LINIENZUG_STUFE2` | +| `hm_recformat.json` (5 echte HundM-Ketten, erzeugt mit `lib/vf_journal_export.py`) | `TEST_HM_RECFORMAT` (in `alltests.json` abgeschaltet) | + +--- + +## 7. Omniflo + +### 7.1 Bogen und Weiche + +```json +{ "id": "821104025", "type": "bogen", "sivasnr": "821104025", + "x": 219.4, "y": 223.06, "hoehe": 2000, "drehung": 0.0 } +``` + +| Feld | Pflicht | Bedeutung | Default | +|---|---|---|---| +| `type` | ja | `"bogen"` oder `"weiche"` | - | +| `sivasnr` | ja | Sivas-Nummer = Dateiname `%DXFM_OMNIFLO%/.dxf` | - | +| `x`, `y` | ja | Einfuegepunkt (`$INSBASE` der DXF, gesetzt mit `set_einfuegepkt.py`) | - | +| `hoehe` | nein | Z des Einfuegepunkts UND Attribut `HOEHE` | 2000 | +| `drehung` | nein | Drehung + Attribut `DREHUNG` | 0 | + +Es gibt kein `z`: die Hoehe ist zugleich die Z-Koordinate. Gueltige +Sivas-Nummern: `data/json/omniflo_boegen.json`, `omniflo_weichen.json`. +Treiber: `omni:test-insert` (`test_omniflo.lsp`), `omnistr:insert-bogen` +(`test_omniflo_strecke.lsp`). + +### 7.2 Aluprofil-Gerade + +```json +{ "seq": 1, "type": "gerade", "profil": "AP110", "laenge": 1000.0, + "x": 2000.0, "y": 0.0, "x_ende": 3000.0, "y_ende": 0.0, + "drehung": 0.0, "hoehe": 2000, "id": "0003" } +``` + +`profil` = `"AP60"`, `"AP110"` oder `"APG110"`. Die Gerade laeuft von +(`x`,`y`) nach (`x_ende`,`y_ende`) auf Z = `hoehe`; Laenge und Drehung folgen +aus den Punkten (`laenge` ist nur Doku). Gebaut mit `omni:make-gerade`. + +--- + +## 8. Waagrechte Foerderstrecke (`gerade`) - noch ohne Bau-Pfad + +```json +{ "test_id": "GERADE_Arvato_01", "typ": "gerade", "laenge": 8313.39, "hz": 90.0, + "startpunkt": [2334.97, 177818.67, 0.0], "endpunkt": [2334.96, 186132.06, 0.0] } +``` + +Ein Antriebs-/Umlenkstation-Paar ohne Hoehendifferenz, so von +`lib/dxf_scan_components.py` ausgegeben (ein VarioFoerderer ist bei +`deltaH` = 0 nicht loesbar). `TEST_DEMATIC_ARVATO` meldet diese Eintraege und +ueberspringt sie. Passende Primitive waere `insert-hz-scaled-block-by-ks` +(`vf_etage.lsp`) mit `Staustrecke_SP_1000_mm`, siehe +[lisp_methods.md](lisp_methods.md). + +--- + +## 9. Testdaten-Dateien im Ueberblick + +| Datei | Inhalt | Treiber / Befehl | +|---|---|---| +| `kreisel_tests.json` | 8 Kreisel (`insert`) | `TEST_KREISEL` | +| `foerderer_tests.json` | Kopf `y_abstand` + 17 VF Standard | `TEST_FOERDERER` | +| `gefaellestrecke_tests.json` | Kopf + GF Modus 1/2/3 | `TEST_GEFAELLESTRECKE` | +| `omniflo_tests.json` | 27 Boegen, 80 Weichen | `TEST_OMNIFLO` | +| `omniflo_strecke_tests.json` | Streckenzug aus Geraden und Boegen | `TEST_OMNIFLO_STRECKE` | +| `linienzug_tests.json` / `_stufe2.json` | Eingabe-Journal je einer Kette | `TEST_LINIENZUG` / `TEST_LINIENZUG_STUFE2` | +| `hm_recformat.json` | 5 HundM-Ketten als Journal | `TEST_HM_RECFORMAT` | +| `hundm05.json` | 5 HundM-Ketten als Spec + Kreisel, Separatoren, Scanner, BTMT | `TEST_HUNDM05`, `VF_SPEC_BAU` | +| `mubea.json` | Gesamtanlage: Kreisel, VF Standard/Etage, GF-Template (20 Stueck), Separatoren, Scanner, BTMT, Eingang/Ausgang | `TEST_MUBEA` | +| `dematic_arvato.json` | Vorlage aus `dxf_scan_components.py`: Kreisel, Einzelbloecke, `gerade` (Hoehen fehlen) | `TEST_DEMATIC_ARVATO` (abgeschaltet) | +| `showroom_ils.json` | ILS-3.0-Showroom-Vorlage aus `dxf_scan_components.py` (Kreisel, Gefaellestrecken; Hoehen teils Platzhalter), gleicher Treiber wie `dematic_arvato.json` | `TEST_SHOWROOM_ILS` | +| `hundm05_linienzug_polylines.json` | Polylinien aus `extract_polylines.py` | kein Treiber (Analyse-Daten) | +| `vfl_journal_hm05_abbruch.json` | rohes Journal (`kind`/`value`) eines abgebrochenen Baus | kein Treiber | + +--- + +## 10. Eigene Anlage beschreiben - Kurzanleitung + +1. Kreisel als `insert` (Abschnitt 1): `x/y` am aeussersten Punkt der AN-Seite, + `z` = Einbauhoehe. +2. Einfache Steig-/Fall-Strecken mit fester Form als VF Standard/Etage + (Abschnitt 3) bzw. Gefaellestrecke Modus 1 (Abschnitt 4.1), Startpunkt + jeweils = KS_EIN des AS-Elements. +3. Ketten mit Kurven, mehreren VF-Einheiten oder GF-Boegen als Spec + (Abschnitt 5) - am einfachsten eine Kette einmal interaktiv bauen, mit + `lib/vf_journal_export.py` + `lib/vf_spec_export.py` als Spec exportieren + und Startpunkt/Laengen anpassen. +4. Separatoren, Scanner, BTMT-Stationen, Eingang/Ausgang als Einzelblock + (Abschnitt 2). +5. Aus Kreisel, Einzelbloecken und Specs gemischt baut derzeit nur der + HundM05-Treiber (`TEST_HUNDM05`); fuer VF Standard/Etage + GF zusammen mit + Kreiseln den Mubea-Treiber (`TEST_MUBEA`) als Vorlage nehmen. diff --git a/doc/kommandos.md b/doc/kommandos.md new file mode 100644 index 0000000..b903441 --- /dev/null +++ b/doc/kommandos.md @@ -0,0 +1,304 @@ +# Kommandouebersicht + +Diese Seite listet alle Kommandos des Projekts auf einen Blick: + +1. [BricsCAD-Befehle (AutoLISP)](#1-bricscad-befehle-autolisp) - an der BricsCAD-Kommandozeile einzugeben +2. [Test-Befehle in BricsCAD](#2-test-befehle-in-bricscad) +3. [Batch-/Shell-Skripte (`bin/`)](#3-batch-shell-skripte-bin) +4. [Python-Kommandozeilen (`lib/`)](#4-python-kommandozeilen-lib) +5. [Python-Tests (`pytest`)](#5-python-tests-pytest) + +Ausfuehrliche Beschreibungen stehen in `Lisp/README.md`, `doc/variofoerderer.md`, +`doc/tools.md` (set_einfuegepunkt/set_koords), `doc/dbg2lsp.md`, `doc/csv-export.md` +und `doc/LispTests.md`. Diese Seite ist nur der Einstieg. + +**Voraussetzung fuer alle BricsCAD-Befehle**: Menue `menu/SSG_LIB.mnu` einmalig per +`_MENULOAD` geladen (siehe `CLAUDE.md`, "Menue einrichten"). Die MNL laedt die Module +dann beim Start. Befehle, die nicht im Menue stehen, lassen sich trotzdem an der +Kommandozeile aufrufen, sofern ihr Modul geladen ist - sonst vorher +`(ssg-ensure "Modulname")` eingeben. + +--- + +## 1. BricsCAD-Befehle (AutoLISP) + +Gross-/Kleinschreibung spielt an der Kommandozeile keine Rolle. + +### ILS Kreisel / Eckrad (`KreiselInsert.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `KreiselInsert` | Kreisel einfuegen: Position und Parameter (Abstand, Typ, Rotation, Hoehe) manuell eingeben | +| `KreiselConnect` | Kreisel zwischen zwei gewaehlten Punkten einfuegen (Abstand und Drehung aus den Punkten) | +| `KreiselQuick` | Kreisel schnell mit Standardwerten (horizontal) einfuegen | +| `KreiselEdit` | Bestehenden Kreisel per Dialog (`kreisel_edit.dcl`) bearbeiten und neu aufbauen | +| `KreiselRedraw` | Kreisel aus seinen Block-Attributen neu zeichnen (z.B. mit neuem Abstand) | +| `KreiselParams` | Aktuelle Kreisel-Parameter anzeigen | +| `KreiselLabelSetup` | Beschriftung einstellen (Hoehe, Farbe, Abstand, Schriftart) | +| `KreiselLabelPos` | Versatz der Beschriftung (dx/dy) einstellen | +| `KreiselLabelHoehe` | Texthoehe der Beschriftung einstellen | +| `ILS_Eckrad` | Eckrad an einem Tangentenpunkt mit Richtung einfuegen | + +### VarioFoerderer (`VarioFoerderer.lsp` -> `vf_core`/`vf_standard`/`vf_etage`/`vf_linienzug`/`vf_spec`) + +| Befehl | Beschreibung | +|---|---| +| `FOERDERANLAGE` / `VarioFoerderer` | Hauptbefehl, fragt den Anlagentyp (Standard/Etage/Linienzug) ab | +| `StandardVarioFoerderer` | Standardtyp (AS/ES 90 Grad), Werte per DCL-Dialog | +| `StandardVarioFoerderer3D` | Standardtyp aus einer gewaehlten 3D-Linie | +| `EtageVarioFoerderer` | Etagentyp (AS/ES 30 Grad), Werte per DCL-Dialog | +| `EtageVarioFoerderer3D` | Etagentyp aus einer gewaehlten 3D-Linie | +| `LinienzugVarioFoerdererManuell` | Streckengruppe, Modus 1 (manuelle Eingabe, Punkte klicken) | +| `LinienzugVarioFoerdererZielhoehe` | Streckengruppe, Modus 2 (3D-Objekte + Ziel-Hoehe, Randwert-Solver) | +| `LinienzugVarioFoerdererStueckweise` | Streckengruppe, Modus 3 (3D-Objekte stueckweise, in Arbeit) | +| `QcLinieMitGf` | Streckengruppe Modus 4 (QC-Linie mit GF, automatische Auf-Ab-Berechnung); Menue unter Gefaellestrecke | +| `QcLinieMitGfUForm` | Streckengruppe Modus 5 (QC-Linie mit GF und U-Form); Menue unter Gefaellestrecke | +| `VARIOFOERDERER_EDIT` | VF_n-Block editieren (dispatcht per XDATA-Marker auf Standard/Etage/Linienzug); auch per Doppelklick | +| `VARIOFOERDERER_NACHRUESTEN` / `VF_NACHRUESTEN` | Altbestand-VF_n-Bloecke ohne `SSG_VF_EDIT`-Marker editierbar machen | +| `Vario_Kette_Merge` | Mehrere einzeln gebaute VF_n-Bloecke ab einem Start-Baustein zu einem Gesamt-Block zusammenfuehren | +| `VF_SEKTION_RESTORE` | Aufgebrochene Linienzug-Kette aus der XDATA der losen Objekte wieder zu einem Block mit Journal zusammensetzen | +| `VF_WIZARD_AN` / `VF_WIZARD_AUS` | Linienzug-Fragen per DCL-Assistent (Standard) bzw. per Konsole stellen | +| `VF_SPEC_BAU` | Linienzug-Ketten ohne Dialog aus einer Spec-Datei bauen (`DXFM_VF_SPEC`, Default `tests/testdata/hundm05.json`) | +| `VFL_KS_DIAG` | Diagnose: inneren Aufbau eines Blocks anzeigen (Lage von KS_EIN/KS_AUS) | + +### Gefaellestrecke (`Gefaellestrecke.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `GEFAELLESTRECKE` | Fragt den Eingabemodus per Konsole ab | +| `GEFAELLESTRECKE_EINFACH` | Modus 1: Werteingabe per DCL-Dialog | +| `GEFAELLESTRECKE_3DLINIE` | Modus 2: aus einer 3D-Linie | +| `GEFAELLESTRECKE_LINIENZUG` | Modus 3: aus einem Linienzug (LINE + ARC) | +| `GEFAELLESTRECKE_EDIT` | GF_n-Block editieren (Dialog vorbelegt, Neuaufbau); auch per Doppelklick | + +### ILS-Zusatzmodule, Sensoren, Ein-/Ausgang (`SSG_LIB_Commands.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `ILS_BTMT_Beladung` | BTMT-Beladung wiederholt einfuegen (Drehung interaktiv) | +| `ILS_BTMT_Entladung` | BTMT-Entladung wiederholt einfuegen | +| `ILS_EINGANG_INSERT` / `ILS_AUSGANG_INSERT` | Eingang-/Ausgang-Symbol frei platzieren | +| `ILS_SCANNER_INSERT` | Scanner einfuegen | +| `ILS_SEPARATOR_INSERT` | Separator einfuegen | +| `TEF_FOERDERER_LINIE` (`TEFInsert.lsp`) | Linie zwischen zwei Punkten zeichnen und mit 1000-mm-TEF-Geraden belegen | + +### Omniflo (`OmniModulInsert.lsp`) + +| Befehl(e) | Beschreibung | +|---|---| +| `OMNI_LOAD` | Omniflo-Komponentendaten laden | +| `OMNI_INFO_BOGEN` / `OMNI_INFO_WEICHE` | Daten eines Bogens / einer Weiche anzeigen | +| `OMNI_APB60_90`, `OMNI_APB_630_90`, `OMNI_APB_630_45`, `OMNI_APB_550_675`, `OMNI_APB_550_225`, `OMNI_APB_650_180` | Boegen einfuegen (Dialog `omniflo_boegen.dcl`) | +| `OMNI_AP60`, `OMNI_AP110`, `OMNI_APG110` | Gerade Profile einfuegen | +| `OMNI_W90_Einfach`/`_Doppel`/`_Dreiwege` | Weichen 90 Grad (Dialog `omniflo_weichen.dcl`) | +| `OMNI_W45_Einfach`/`_Doppel`/`_Dreiwege` | Weichen 45 Grad | +| `OMNI_WP_Einfach`/`_Doppel`/`_Dreiwege` | Parallelweichen | +| `OMNI_WK_Einfach`/`_Doppel`/`_Dreiwege` | Weichenkoerper | +| `OMNI_WKomb_Delta_1400`, `OMNI_WKomb_Delta_1600`, `OMNI_WKomb_Star` | Weichenkombinationen (Delta, Stern) | +| `OMNI_APBW_R400_45_140`, `OMNI_APBW_R400_675_260`, `OMNI_APBW_R550_45_77`, `OMNI_APBW_R550_45_194`, `OMNI_APBW_R550_225_360`, `OMNI_APBW_R550_225_410A`/`B`/`C`, `OMNI_APBW_R550_675_58`/`_125`/`_208`/`_360`, `OMNI_APBW_R650_90_300`, `OMNI_APBW_R750_90_200` | Boegen fuer Weichen (fest, ohne Dialog) | +| `OMNI_TEF_UmlenkL`/`R`, `OMNI_TEF_AntriebL`/`R`, `OMNI_TEF_Gerade` | TEF-Elemente (fest, ohne Drehung) | +| `OMNI_STOPPER`, `OMNI_SCANNER`, `OMNI_BUERSTENBREMSE` | Anbaugruppen | +| `OMNI_TV_W_W`, `OMNI_TV_W_AP`, `OMNI_TV_W_AP60`, `OMNI_TV_W_AP110`, `OMNI_TV_W_AP110_W`, `OMNI_TV_50`, `OMNI_TV_80`, `OMNI_TV_ENDPLATTE`, `OMNI_TV_ANSCHLAG`, `OMNI_TV_MUFFE`, `OMNI_TV_A_AP110_AP60`, `OMNI_TV_A_AP60_ST`, `OMNI_TV_A_AP110_ST`, `OMNI_TV_SW_II_SW_SW`, `OMNI_TV_SW_III_AP110`, `OMNI_TV_SW_III_AP110_SW`, `OMNI_TV_SW_IV_AP60`, `OMNI_TV_SW_IV_ST` | Verbinder | +| `OMNI_LADESCHLEIFE_AP110` | Ladeschleife (Dialog `omniflo_ladeschleifen.dcl`) | +| `OMNI_KettenFoerderer` | Platzhalter (noch ohne Funktion) | +| `OMNI_EDIT` | Omniflo-Element per Dialog bearbeiten; auch per Doppelklick | + +### Geruest (`GeruestInsert.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `GERUEST` | Geruest-Dialog (Bereich frei waehlbar) | +| `GERUEST_SAEULEN` / `GERUEST_ROHRABHAENGER` / `GERUEST_WANDBEFESTIGUNG` | Derselbe Dialog, im jeweiligen Bereich geoeffnet | +| `GERUEST_TRAEGER` | Rohr-Geruest-Traeger: Dialog (`geruest_traeger.dcl`), danach Start-/Endpunkt oder Laenge bis ESC/Enter | +| `GERUEST_TRAEGER_BESCHRIFTEN` | Alle Traeger der Zeichnung neu beschriften, verwaiste Beschriftungen entfernen | + +### TRO und Connections (`Tro_Edit.lsp`, `Connection_Edit.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `TRO_INSERT` | TRO-Marker (`TRO_SYM_`) einfuegen und ID/TYPE setzen (Blockdefinition muss existieren) | +| `TRO_EDIT` | ID/TYPE eines TRO-Markers per Dialog aendern | +| `CONNECTION_INSERT` | Verbindungspfeil (Fluss) zwischen zwei Elementen zeichnen | +| `CONNECTION_EDIT` | Quelle/Ziel einer Verbindung aendern | + +### Export und IDs (`export.lsp`, `ssg_id.lsp`, `count_sep_scan.lsp`, `check_hoehen.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `EXPORTSIVAS` | Sivas-Export-CSV mit Summierungszeilen (ruft `lib/export_sivas.py`) | +| `EXPORTCSV` | Einfache Item-Liste aller Bloecke inkl. Bounding-Box/Planquadrat (ruft `lib/export_csv.py`) | +| `CSV_EXPORT_KONFIG` | Export-Einstellungen per Dialog (u.a. gefrorene Layer ausschliessen) | +| `OMNI_UPDATE_ATTRIBS` | HOEHE und DREHUNG aller Omniflo-Elemente aus der Geometrie aktualisieren | +| `IDSCHECK` | Alle Bloecke auf doppelte IDs pruefen und korrigieren | +| `IDGENERATE` | Gewaehltem Block eine neue ID zuweisen | +| `ZAEHLE_SEP_SCAN` | Scanner/Separatoren je Kreisel/VF/GF zaehlen und in ANZAHL_SCANNER/ANZAHL_SEPARATOR schreiben (laeuft auch automatisch vor jedem Export) | +| `HOEHEN_CHECK` | Hoehen von Kreiseln/VF/GF messen und in HOEHE/HOEHE_VON_mm/HOEHE_BIS_mm/MONTAGEHOEHE_m schreiben | +| `CALLPYTHON` (`external_call.lsp`) | Test des LISP->Python-Aufrufs (`lib/testpycall.py`) | + +### Konfiguration, Planquadrate, Doppelklick + +| Befehl | Beschreibung | +|---|---| +| `SSG_DIM_SWITCH` | Globalen Modus 2D/3D umschalten (`DXFM_DIM`) | +| `SSG_DIM_ALL_2D` / `SSG_DIM_ALL_3D` | Alle VF_n-/GF_n-Bloecke der Zeichnung nach 2D bzw. 3D umbauen | +| `SSG_SPRACHE` | Sprache Deutsch/Englisch waehlen (`DXFM_LANG`) | +| `DRAW_PLANQUADRATE` | Planquadrat-Raster (Block `ZZ_PLANQUADRATE`) zeichnen bzw. neu aufbauen | +| `DELETE_PLANQUADRATE` | Planquadrat-Raster entfernen | +| `PLANQUADRATE_TOGGLE` | Raster an/aus (zeichnen, falls keins existiert, sonst entfernen) | +| `SSG_BLOCKEDIT` | Doppelklick-/Kontextmenue-Dispatcher: Kreisel, Omniflo, GF_*, VF_*, GR_*, TRO_* auf den passenden Edit-Befehl | +| `EATTEDIT` | Ueberschreibt den nativen Befehl, leitet an `SSG_BLOCKEDIT` weiter (Fallback `_.EATTEDIT`) | + +### Layer-Werkzeuge (`ssg_layer.lsp`) + +| Befehl | Beschreibung | +|---|---| +| `SSG-LayerSet` | Layer eines angeklickten Objekts aktiv setzen | +| `SSG-LayerInfo` | Layer eines Objekts anzeigen | +| `SSG-LayerMove` | Objekte auf einen anderen Layer verschieben | +| `SSG-LayerCopy` | Objekte auf einen anderen Layer kopieren | +| `SSG-LayerMoveType` | Alle Objekte eines Typs (Referenzobjekt) vom gleichen Layer auf einen neuen Layer verschieben | +| `SSG-LayerOff` / `SSG-LayerFreeze` | Layer per Anklicken aus-/einfrieren | +| `SSG-FreezeAll` | Alle Layer ausser dem aktiven einfrieren | +| `SSG-ThawAll` / `SSG-LayerOnAll` | Alle Layer auftauen / einschalten | +| `SSG-LayerDelete` | Alle Objekte eines Layers und den Layer loeschen (mit Sicherheitsabfrage) | + +### Block-Pflege und Diagnose (Entwickler) + +Arbeiten auf den Block-DWGs in `data/ils` (Voraussetzung `DXFM_DATA`). + +| Befehl | Beschreibung | +|---|---| +| `ILS_ATTR_SYNC` (`addattribute.lsp`) | ATTDEFs der DWGs mit `data/ils/allocations.json` abgleichen; Modus Ergaenzen/Ersetzen | +| `ILS_ATTR_REPLACE` | Direkt Modus "Ersetzen" (Sicherheitsfrage bleibt) | +| `ILS_ATTR_COLLECT` (`collect_attributes.lsp`) | Aktuelle ATTDEF-Werte aller DWGs nach `allocations_collected.json` schreiben | +| `ILS_BLOCK_LIST` (`list_blocks.lsp`) | Sub-Block-Definitionen aller DWGs nach `blocks_collected.json` schreiben (Kollisionen 2D/3D finden) | +| `ILS_BLOCK_PURGE` (`purge_blocks.lsp`) | Unbenutzte Bloecke/Layer in allen DWGs entfernen | +| `KS_PRUEFEN` (`ks_pruefung.lsp`) | KS_EIN/KS_AUS der 2D- gegen die 3D-Variante vergleichen, Ergebnis als CSV | +| `MenuInventory` (`menu-inventory.lsp`) | Menuegruppen, Plugins und Startdateien von BricsCAD auflisten | + +--- + +## 2. Test-Befehle in BricsCAD + +Aus dem Menue "Tests" bzw. der Kommandozeile; Details in `doc/LispTests.md`. + +| Befehl | Beschreibung | +|---|---| +| `SSG_RUN_ALL_TESTS` | Alle in `tests/alltests.json` aktivierten Szenarien ausfuehren (fragt den Modus ab) | +| `SSG_RUN_ALL_TESTS_EXPORT` | Dito, Automatik: speichern + CSV/Sivas-Export + schliessen | +| `SSG_RUN_ALL_TESTS_OFFEN` | Dito, Kontrolle: Zeichnungen bleiben offen, kein Export | +| `TEST_EXPORT_ALL` | Jede Zeichnung aus `tests/output/` oeffnen und exportieren | +| `TEST_UNIT` | File- und zeichnungsfreie Unit-Tests (`tests/test_unit.lsp`), Ergebnis `tests/output/unit_results.txt` | +| `TEST_VF_SPEC` | Unit-Test Spec-Uebersetzer (`vsp-journal`) | +| `TEST_VFL_SCHEMA` | Unit-Test Glied-Schema des Linienzugs | +| `TEST_KREISEL` | Kreisel-Szenario | +| `TEST_FOERDERER` | VarioFoerderer-Szenario | +| `TEST_GEFAELLESTRECKE` | Gefaellestrecke-Szenario | +| `TEST_LINIENZUG` / `TEST_LINIENZUG_STUFE2` | Linienzug-Szenarien | +| `TEST_OMNIFLO` | Alle Omniflo-Testbloecke einfuegen | +| `TEST_OMNIFLO_STRECKE` | Omniflo-Streckenzug aufbauen | +| `TEST_HM_RECFORMAT` (`_2D`/`_3D`) | Echte HundM-Aufzeichnungen per Journal-Replay nachbauen | +| `TEST_HUNDM05` (`_2D`/`_3D`) | HundM05-Anlage aus der Spec bauen | +| `TEST_MUBEA` | Mubea-Nachbau aus `tests/testdata/mubea.json` | +| `TEST_DEMATIC_ARVATO` | Dematic/Arvato-Nachbau (Flowpuffer/Kreisel) | +| `TEST_SHOWROOM_ILS` | ILS-3.0-Showroom-Nachbau (Kreisel, Gefaellestrecken; Hoehen noch Platzhalter) | + +--- + +## 3. Batch-/Shell-Skripte (`bin/`) + +Alle Skripte rufen zuerst `setenv.bat` (bzw. `setenv.sh`) auf. + +| Skript | Beschreibung | +|---|---| +| `setenv.bat` / `setenv.sh` | Umgebungsvariablen setzen (`DXFMAKRO`, `DXFM_LISP`, `DXFM_DATA`, `BRICSCAD` ...); `.sh` muss gesourct werden | +| `start_briscad.bat` | Umgebung setzen und BricsCAD starten | +| `get_cmd.bat` / `get_cmd.sh` | Shell mit gesetzter Umgebung oeffnen | +| `install_py.bat` / `install_py.sh` | `.venv` anlegen und `requirements.txt` installieren (nur wenn noch nicht vorhanden) | +| `activate_venv.bat` / `activate_venv.sh` | `.venv` aktivieren, Python-Version und Pakete anzeigen | +| `run_tests.bat` | Testausfuehrung, siehe unten | +| `create_tests.bat` | Kompletter ILS-Testlauf: Basis-DXF erzeugen, BricsCAD mit `ILS_test.scr`, Ergebnisse validieren | +| `set_einfuegepunkt.bat [schalter]` | Wrapper fuer `lib/set_einfuegepkt.py` (siehe `doc/tools.md`) | +| `set_coords.bat [schalter]` | Wrapper fuer `lib/set_koords.py` (siehe `doc/tools.md`) | +| `dbg2lsp.bat [argumente]` | Wrapper fuer `lib/dbg2lsp.py` (siehe `doc/dbg2lsp.md`) | +| `show_exportcsv.bat [csv] [flow] [mflow] [track]` | Export-CSV mit sps_skel als SVG darstellen; `flow` ohne VF/GF-Einzelbausteine, `mflow` Materialfluss-Graph, `track` Bahnzusammenhang (beide brauchen Graphviz) | +| `dxf_anlage_export.bat [--projekt NAME]` | Wrapper fuer `lib/dxf_anlage_export.py` | +| `dxf_scan_components.bat [--fenster X0 Y0 X1 Y1] [--projekt NAME]` | Wrapper fuer `lib/dxf_scan_components.py` | +| `dxf_vf_abbild.bat [--spec S] [--json J] [--referenz R] [--schreibe-referenz] [--praefix VF_,GF_]` | Wrapper fuer `lib/dxf_vf_abbild.py` | + +### `run_tests.bat` + +``` +bin\run_tests.bat --lisp BricsCAD headless (/b tests\test_unit.scr), TEST_UNIT, Auswertung unit_results.txt +bin\run_tests.bat --check [test_xyz.py] pytest-Validierung (alle oder eine Datei) +bin\run_tests.bat --diff_references [datei] CSVs tests\reference vs. tests\output vergleichen, bei Unterschieden meld +bin\run_tests.bat Hilfe +``` + +--- + +## 4. Python-Kommandozeilen (`lib/`) + +Aufruf mit aktivierter `.venv` (bzw. ueber `setenv`, damit `DXFM_*` gesetzt sind). +`python --help` zeigt bei den argparse-Skripten alle Optionen. + +### Export (normalerweise von `EXPORTSIVAS`/`EXPORTCSV` aufgerufen) + +| Aufruf | Beschreibung | +|---|---| +| `python export_sivas.py [--mit-bezeichnung]` | Sivas-CSV mit Summierungszeilen, zusaetzlich `_zusammengefasst.csv` | +| `python export_csv.py ` | Einfache Item-Liste (Planquadrat, Bounding-Box, Nachbarn, Merkmale) | +| `python export_graph.py []` | Materialfluss-Graph aus dem CSV-Export als `.json`, `.dot` und `.mmd` | + +Reine Bibliotheken ohne eigene Kommandozeile: `export_blockpatterns.py`, +`export_neighbors.py`, `export_planquadrat.py`, `merkmalstamm.py`, `sivas_mapping.py`, +`omniflo_utils.py`, `vf_linienzug_grammatik.py`. + +### Omniflo-DXF-Aufbereitung + +| Aufruf | Beschreibung | +|---|---| +| `python set_einfuegepkt.py [--boegen] [--weichen45] [--weichen90] [--weichenkoerper] [--weichen-parallel] [--delta] [--dreifachweiche] [--sternweiche] [--number SIVASNR] [--show-omniflo]` | `$INSBASE` der Omniflo-DXFs setzen | +| `python set_koords.py [--k1set] [--k2set] [--k3set] [--k4set] [--set-all] [--force] [--test] [--number SIVASNR] [--show-omniflo]` | KS-Bloecke K1-K4 in die Omniflo-DXFs setzen | +| `python split_block_library.py` | `data/block_libraries/ils_library.dxf` in einzelne DXFs je Block aufteilen | + +### VarioFoerderer-Journal und Spec + +| Aufruf | Beschreibung | +|---|---| +| `python vf_journal_export.py [--csv ] [--kein-startpunkt-fix]` | `SSG_VF_EDIT`-Journale der VF_n-Bloecke als Frage-Antwort-Protokoll (z.B. `tests/testdata/hm_recformat.json`) | +| `python vf_spec_export.py ` | Protokoll in eine Spec uebersetzen (z.B. `tests/testdata/hundm05.json`) | +| `python dxf_vf_abbild.py [--spec S] [--json J] [--referenz R] [--schreibe-referenz] [--praefix VF_,GF_]` | Attribut-/Bausteinabbild der VF_/GF_-Bloecke; `--referenz` vergleicht (Exit 1 bei Abweichung) | +| `python dxf_anlage_export.py [--projekt NAME]` | Mit unseren Makros GEBAUTE (und von Hand nachbearbeitete) Anlage aus der Zeichnung in Nachbau-Testdaten zurueckschreiben (Gegenstueck zu `dxf_scan_components.py`); erzeugt z.B. `tests/testdata/dematic_arvato.json` | +| `python dump_vf_wrapper_inhalt.py ` | Diagnose: Sub-INSERTs je VF_n/GF_n-Wrapper in Baureihenfolge | +| `python dump_vf_kette_inhalt.py []` | Diagnose: Glied-Folge der Spec gegen die tatsaechliche Separatorliste | + +### Fremdzeichnungen auswerten + +| Aufruf | Beschreibung | +|---|---| +| `python dxf_scan_components.py [--fenster X0 Y0 X1 Y1] [--projekt NAME]` | ILS-/Omniflo-Komponenten einer fremden Zeichnung als Nachbau-JSON erkennen | +| `python dxf_abbild.py [--fenster X0 Y0 X1 Y1] [--max-tiefe N] [--ohne-geometrie-container]` | Getreue Abbildung aller Bauteile (ohne Interpretation) als JSON | +| `python extract_polylines.py [--layer Z-6]` | LWPOLYLINEs eines Layers mit Stuetzpunkten und Laengen als JSON | + +### Entwickler-Tools + +| Aufruf | Beschreibung | +|---|---| +| `python dbg2lsp.py --method NAME [--recursive] [--max-depth N] [--search-dir D] [--exclude NAME] [--add-open DATEI METHODE] [--dbg-file F] [--dbg-envvar V] [--force] [--dry-run]` | LISP-Funktionen mit `ssg_dbg.lsp`-Aufrufen instrumentieren (siehe `doc/dbg2lsp.md`) | +| `python testpycall.py []` | Gegenstueck zu `CALLPYTHON` | + +--- + +## 5. Python-Tests (`pytest`) + +``` +pytest tests/ alle Python-Tests +pytest tests/test_vf_spec.py einzelne Datei +bin\run_tests.bat --check dasselbe ueber das Batch-Skript +``` + +Die Szenario-Tests (`test_kreisel.py`, `test_foerderer.py`, `test_hundm05.py` ...) +validieren die Ausgaben der zugehoerigen BricsCAD-Testbefehle in `tests/output/` +gegen `tests/reference/`; reine Python-Tests wie `test_vf_spec.py`, +`test_vf_journal_grammatik.py` oder `test_export_graph.py` laufen ohne BricsCAD. diff --git a/doc/lisp_methods.md b/doc/lisp_methods.md new file mode 100644 index 0000000..72c3163 --- /dev/null +++ b/doc/lisp_methods.md @@ -0,0 +1,329 @@ +# LISP-Routinen zum Bau einzelner Einheiten + +Uebersicht ueber die LISP-Funktionen, die eine Einheit (Kreisel, Eckrad, +VarioFoerderer, Gefaellestrecke, Omniflo-Element, Geruest, Einzelblock) +erzeugen, mit Signatur, Parametern, Rueckgabe und Voraussetzungen. + +Zu jedem Element steht der interaktive **Befehl** (was der Anwender aufruft) +und der **skriptfaehige Kern** (ohne `getpoint`/Dialog, aus Code oder JSON +aufrufbar). Das JSON-Format, mit dem die Testtreiber diese Kerne aufrufen, +steht in [json-input-lisp.md](json-input-lisp.md); alle Befehle in +[kommandos.md](kommandos.md). + +Einheiten: mm und Grad. `hz` = Fahrtrichtung in der XY-Ebene, 0 = +X, +90 = +Y. Punkte sind Listen `(x y z)` in Weltkoordinaten. + +--- + +## 0. Uebersicht + +| Einheit | Befehl | Skriptfaehiger Kern | Ergebnis-Block | Modul | +|---|---|---|---|---| +| Kreisel | `KreiselInsert`, `KreiselConnect`, `KreiselQuick` | `kreisel-insert-script`, `kreisel-connect-script` | `KREISEL_n` | `KreiselInsert.lsp` | +| Eckrad | `ILS_Eckrad` | `ils-eckrad-insert` | `ECKRAD_n` | `KreiselInsert.lsp` | +| VF Standard | `StandardVarioFoerderer`, `FOERDERANLAGE` | `berechne-standard` + `variofoerderer-einfuegen` + `vf-block-erstellen` | `VF_n` | `vf_standard.lsp`, `vf_core.lsp` | +| VF Etage | `EtageVarioFoerderer` | `berechne-etage` + `etage-foerderanlage-einfuegen` + `vf-block-erstellen` | `VF_n` | `vf_etage.lsp`, `vf_core.lsp` | +| VF Linienzug | `LinienzugVarioFoerdererManuell`/`-Zielhoehe`/`-Stueckweise`, `QcLinieMitGf`/`-UForm` | `vsp-bau-aus-spec` (Spec) bzw. `vfl-journal-replay-start` + `vf-linienzug-modus` | `VF_n` | `vf_linienzug.lsp`, `vf_spec.lsp` | +| Gefaellestrecke | `GEFAELLESTRECKE_EINFACH`/`_3DLINIE` | `gf-rebuild` bzw. `gefaellestrecke-einfuegen` | `GF_n` | `Gefaellestrecke.lsp` | +| Gefaellestrecke Linienzug | `GEFAELLESTRECKE_LINIENZUG` | - (nur interaktiv; Kern `gf-linienzug-einfuegen` braucht analysierte Segmente) | `GF_n` | `Gefaellestrecke.lsp` | +| Separator, Scanner | `ILS_SEPARATOR_INSERT`, `ILS_SCANNER_INSERT` | - (Schleife mit `getpoint`); Kern: `ssg-ils-block-laden` + `_.INSERT` | Einzelblock | `SSG_LIB_Commands.lsp`, `ssg_core.lsp` | +| BTMT, Eingang/Ausgang | `ILS_BTMT_*`, `ILS_EINGANG_INSERT`/`ILS_AUSGANG_INSERT` | wie Separator | Einzelblock | `SSG_LIB_Commands.lsp` | +| Omniflo Bogen/Weiche/TEF | `OMNI_APB_*`, `OMNI_W*_*`, `OMNI_TEF_*` ... | `_.INSERT` der `.dxf` (Kern `omni:insert-dxf` fragt den Punkt) | Einzelblock | `OmniModulInsert.lsp` | +| Omniflo Gerade | `OMNI_AP60`/`AP110`/`APG110` | `omni:make-gerade` | Compound-Block | `OmniModulInsert.lsp` | +| TEF-Foerderer-Linie | `TEF_FOERDERER_LINIE` | `tefl-insert-element` (ein Element) | Einzelbloecke | `TEFInsert.lsp` | +| Geruest (Saeule, Rohrabhaenger, Wandbefestigung) | `GERUEST`, `GERUEST_SAEULEN` ... | `geruest-block-bauen` | `GR__` | `GeruestInsert.lsp` | +| Geruest-Traeger | `GERUEST_TRAEGER` | `geruest-traeger-block-bauen` | `GR__` | `GeruestInsert.lsp` | + +--- + +## 1. Kreisel und Eckrad (`KreiselInsert.lsp`) + +### `kreisel-insert-script (pt abstand rotation typ hoehe drehrichtung)` + +Kreisel an einem freien Punkt. Ruft `draw-module` auf. + +| Parameter | Bedeutung | +|---|---| +| `pt` | Einfuegepunkt: aeusserster Punkt der AN-Seite auf der Achse (einen Radius = 400 mm vor der Mitte des Antriebsrads) | +| `abstand` | Mittenabstand Antriebsrad - Spannrad | +| `rotation` | Drehung der Achse AN -> SP in Grad | +| `typ` | `"STANDARD"` oder `"PIN"` (nil = `"STANDARD"`) -> Attribut `KREISELART` | +| `hoehe` | Einbauhoehe; nil = Z von `pt`, sonst `*kreisel-default-hoehe*` | +| `drehrichtung` | `"GUZ"`/`"UZS"` -> Attribut `DREHRICHTUNG` (optional, nil = Default `"UZS"` aus `*kreisel-attrib-defs*`) | + +Rueckgabe: Entity des `KREISEL_n`-Blocks oder nil. Setzt `ssg-start`/`ssg-end` +selbst. + +### `kreisel-connect-script (ptStart ptEnd typ hoehe)` + +Kreisel zwischen zwei aeussersten Punkten (AN-Seite, SP-Seite). Berechnet +`abstand` = Distanz - `*kreisel-durchmesser*` (800) und `rotation` aus den +Punkten. Rueckgabe wie oben. + +### `draw-module (basePoint abstand rotation attribs)` + +Gemeinsamer Bau-Kern beider Funktionen: setzt Antriebs- und Spannstation, +Tangenten, Beschriftung, fasst alles zu `KREISEL_n` zusammen, schreibt die +Attribute (`attribs` = Alist, wird mit `*kreisel-attrib-defs*` gemischt). +Direkt nur aufrufen, wenn zusaetzliche Attribute gesetzt werden muessen. + +### `ils-eckrad-insert (pt rotation attribs)` + +Eckrad als Compound-Block `ECKRAD_n`. + +| Parameter | Bedeutung | +|---|---| +| `pt` | **Radmitte** `(x y hoehe)` | +| `rotation` | Drehung in Grad | +| `attribs` | Alist mit Ueberschreibungen, z.B. `(("GERUEST_EINZELMODUL" . "1") ("GERUEST_TYP" . "Schoenenberger Geruest"))`; nil = Defaults | + +`c:ILS_Eckrad` berechnet die Radmitte aus Beruehrpunkt + Radius in Richtung +des zweiten Klicks. Rueckgabe: Entity des Blocks. + +--- + +## 2. VarioFoerderer Standard und Etage (`vf_core.lsp`, `vf_standard.lsp`, `vf_etage.lsp`) + +Ablauf in drei Schritten: **loesen** (Winkel und Teillaengen aus den +Gesamtmassen), **einfuegen** (Bausteine verketten), **Block bilden** +(`VF_n` mit Attributen). Der Dialog-Ablauf `vf-dialog-ablauf` / +`vf-dialog-berechnen-einfuegen` macht dasselbe, oeffnet aber Dialog 2 und ist +darum nicht skriptfaehig. + +### Vorbereitung + +| Funktion | Zweck | +|---|---| +| `init-bibliothek ()` | Bogen-, AS-/ES- und Stationsmasse aus den Bloecken lesen. Setzt `*lib-initialized*`. Wird von `berechne-standard` aufgerufen | +| `init-bibliothek-etage ()` | dasselbe fuer Etage, aufgerufen von `berechne-etage` | +| `vf-set-as-masse (winkel seite)` / `vf-set-es-masse (winkel seite)` | AS-/ES-Masse (`aus-dx`/`aus-dz`, `ein-dx`/`ein-dz`) fuer die Variante `"90"`/`"30"` + `"links"`/`"rechts"` setzen | + +### Loesen + +| Funktion | Rueckgabe | +|---|---| +| `berechne-standard (deltaL deltaH richtung seite)` | `(best-winkel L_GF L_VF ergebnis-liste)` | +| `berechne-alle-winkel (deltaL deltaH richtung feste-hz schon-flach)` | wie oben; `feste-hz` nil = 1600 mm feste Horizontale, `schon-flach` nil | +| `berechne-etage (deltaL deltaH richtung seite)` | wie oben, Etage-Geometrie (setzt die Gefaellebogen-Masse je `seite`) | +| `vf-winkel-solve (...)` | gemeinsamer L_GF/L_VF-Solve beider Typen (intern) | + +- `richtung` = `"Auf"`/`"Ab"`, `deltaH` als Betrag. +- `ergebnis-liste` = je Kandidatenwinkel `(winkel L_GF L_VF gueltig)`. + Kandidaten aus `vario.bogen_winkel` (3 ... 51). Einen bestimmten Winkel + erzwingen: Eintrag mit diesem `winkel` aus der Liste nehmen und + `gueltig`, `L_GF` > 0, `L_VF` > 0 pruefen (so `mubea:build-vario-one`). +- `L_GF` wird danach auf Vorlauf `L_GF1` und Nachlauf `L_GF2` aufgeteilt + (gleichmaessig / vorne / hinten / manuell, `foerderer:split-gf`). + +### Einfuegen + +``` +(variofoerderer-einfuegen deltaL deltaH richtung best-winkel L_GF1 L_GF2 L_VF startpunkt seite hz) +(etage-foerderanlage-einfuegen deltaL deltaH richtung best-winkel L_GF1 L_GF2 L_VF startpunkt seite hz) +``` + +Identische Signatur (Registry-Vertrag `*vf-typ-registry*`). `startpunkt` = +Lage von **KS_EIN des AS-Elements**, Z = Einbauhoehe am Anfang. `seite` = +`"links"`/`"rechts"`. Rueckgabe: Endpunkt (KS_AUS des ES-Elements). +`variofoerderer-einfuegen` ist aus Teilen zusammengesetzt (`vfs-as-teil`, +VF-Eingang/Koerper, `vfs-es-teil`), die auch der Linienzug nutzt. + +### Block bilden + +``` +(setq lastEnt (ssg-lastent-ohne-attribute)) ; VOR dem Einfuegen merken +...einfuegen... +(vf-block-erstellen anlage-typ seite (vf-next-number) n-scanner + hoehe-von hoehe-bis deltaH deltaL L_VF L_GF1 L_GF2 + richtung best-winkel startpunkt lastEnt hz + geruest-einzelmodul geruest-typ) +(vf-edit-xdata-schreiben ent anlage-typ hz) ; editierbar per Doppelklick +``` + +- `anlage-typ` = `"standard"`/`"etage"`; `hoehe-bis` = +deltaH bei `"Auf"`, + -deltaH bei `"Ab"`; `geruest-einzelmodul` `"0"`/`"1"` (nil = `"1"`), + `geruest-typ` einer aus `*ssg-geruest-optionen*`. +- Sammelt alle Objekte seit `lastEnt` zum Block `VF_n`, setzt Layer, Attribute, + ID (`ssg-id-generate`) und Dimension. Rueckgabe: Entity des Blocks. +- `lastEnt` immer mit `ssg-lastent-ohne-attribute` holen, nicht mit + `(entlast)` (siehe `CLAUDE.md`, ssg_core). +- Blocknummer immer ueber `vf-next-number`: eine feste Nummer fuehrt bei der + zweiten Anlage zu einer Rueckfrage von `_.-BLOCK` und einem haengenden Befehl. + +--- + +## 3. VF-Linienzug (`vf_linienzug.lsp`, `vf_spec.lsp`) + +Ketten mit Vario-Kurven, GF-Boegen und mehreren VF-Einheiten. Der Bau-Ablauf +ist ein Frage-Antwort-Assistent; jede Eingabe wird journalisiert und als XDATA +am `VF_n`-Block gespeichert. Nicht-interaktiv baut man ihn, indem man ein +Journal **abspielt**. + +| Funktion | Zweck | +|---|---| +| `vf-linienzug-modus ()` | Modus 1, frei zeichnend. Liest alle Eingaben ueber `vfl-in-point`/`-string`/`-real`/`-int` - aus der Replay-Queue, falls eine aktiv ist | +| `vf-linienzug-modus2 ()` | Modus 2, Pfad + Zielhoehe (Objektauswahl, eigenes Journal `"linienzug2"`) | +| `vfl-journal-replay-start (forward-journal)` | Journal als Antwort-Queue setzen; danach `vf-linienzug-modus` aufrufen | +| `vsp-journal (spec)` | Spec -> Journal (nil bei Spec-Fehlern, Fehler in `*vsp-fehler*`) | +| `vsp-pruefen (spec)` | alle Spec-Fehler sammeln | +| `vsp-bau-aus-spec (spec)` | eine Kette aus einer Spec bauen (headless, Replay, Ergebnis-Record mit `status`, Block, `prompts`, `glieder_soll`/`glieder_ist`) | +| `vsp-bau-liste (specs)` | mehrere Specs, je mit `vl-catch-all-apply` | +| `vsp-bau-datei (datei)` | Spec-Datei lesen (`vsp-json-laden` + `vsp-gruppieren`) und alle Ketten bauen; das ist `VF_SPEC_BAU` | +| `vsp-headless-an ()` / `vsp-headless-aus ()` | Headless-Rahmen: `*vfl-headless*`, Wizard aus, `*ssg-gui-aus*`, zaehlende Eingabe-Stubs | + +Ein Abbruch im Headless-Modus nennt die Stelle (`*vfl-headless-fehler*`), +statt auf eine Live-Eingabe zu warten. Details zum Ablauf und zu den +Journal-Regeln: [variofoerderer.md](variofoerderer.md), Abschnitte 5-8b. + +--- + +## 4. Gefaellestrecke (`Gefaellestrecke.lsp`) + +### `gf-rebuild (deltaL winkel hz-winkel as-seite es-seite startpunkt as-winkel es-winkel geruest-einzelmodul geruest-typ)` + +Der bequemste skriptfaehige Einstieg fuer Modus 1/2: setzt die AS-/ES-Masse, +berechnet die Staustrecke +`L_stau = (deltaL - aus-dx - ein-dx - separator_breite * cos(w)) / cos(w)` +und ruft `gefaellestrecke-einfuegen`. Ohne Zusammenfassung und Rueckfrage +(eigentlich fuer `GEFAELLESTRECKE_EDIT` gedacht). + +| Parameter | Bedeutung | +|---|---| +| `deltaL` | horizontale Gesamtlaenge AS + Staustrecke + Separator + ES | +| `winkel` | Neigung der Staustrecke in Grad (Default im Dialog 3.0) | +| `hz-winkel` | Fahrtrichtung | +| `as-seite`, `es-seite` | `"links"`/`"rechts"` | +| `startpunkt` | **KS_EIN des AS-Elements**, Z = Einbauhoehe oben | +| `as-winkel`, `es-winkel` | `"90"`/`"30"` als STRING (nil = `"90"`) | +| `geruest-einzelmodul`, `geruest-typ` | wie beim VF | + +Rueckgabe: `(ename deltaH deltaL)` oder nil (Staustrecke <= 0.1 mm -> `alert`). + +### `gefaellestrecke-einfuegen (L_stau winkel startpunkt as-seite es-seite hz deltaL-total as-winkel es-winkel geruest-einzelmodul geruest-typ)` + +Eigentlicher Bau: AS-Element, skalierte Staustrecke, Separator, ES-Element, +Block `GF_n` mit Attributen, XDATA `SSG_GF_EDIT` und ID. Erwartet die +fertige Staustreckenlaenge `L_stau` und passend gesetzte AS-/ES-Masse +(`vf-set-as-masse`/`vf-set-es-masse`). Rueckgabe wie `gf-rebuild`. + +### Weitere + +| Funktion | Zweck | +|---|---| +| `gf-modus12-abschluss (... dialog-bestaetigt ...)` | Abschluss Modus 1/2 mit Zusammenfassung; fragt ohne `dialog-bestaetigt` = T per Konsole nach | +| `gf-init-bibliothek ()` | AS-/ES-Masse fuer die GF lesen | +| `gf-linienzug-modus ()` | Modus 3, interaktiv (Auswahl vorhandener LINE/ARC) | +| `gf-linienzug-einfuegen (segmente grade startframe)` | Bau-Kern von Modus 3, erwartet die von `gf-analysiere-kette` aufbereiteten Segmente | + +**Falle `*lib-initialized*`**: `gefaellestrecke-einfuegen` initialisiert die +GF-Masse nur, wenn `*lib-initialized*` nil ist - dasselbe Flag setzt +`init-bibliothek` des VarioFoerderers. Wer in einem Lauf erst VF und dann GF +baut, muss `gf-init-bibliothek` einmal selbst erzwingen (so +`mubea:ensure-gf-init` in `tests/test_mubea.lsp`), sonst rechnet die GF mit +den Vario-Massen und landet auf falscher Hoehe. + +--- + +## 5. Einzelbloecke: Separator, Scanner, BTMT, Eingang/Ausgang + +| Funktion | Zweck | +|---|---| +| `ils-insert-sensor (fname)` | Befehls-Kern Separator/Scanner: fuegt in einer Schleife ein, Punkt per `getpoint`, Drehung per `pause` - **nicht skriptfaehig** | +| `ils-insert-station (rohname)` | dasselbe fuer BTMT-Beladung, SC_Entladung, Eingang, Ausgang; setzt zusaetzlich den Layer aus dem `LAYER`-Attribut | +| `ssg-ils-block-laden (blockname)` | Blockdefinition `data/ils/_.dwg` einmal je Zeichnung laden; Rueckgabe: effektiver Blockname mit Suffix oder nil | +| `ssg-ils-block-datei (blockname)` | nur den Dateipfad aufloesen (3D-Fallback) | +| `ssg-block-layer-vorgabe` | `LAYER`-Attribut eines eingefuegten Blocks als Ziel-Layer anwenden | +| `ssg-id-generate (ent)` | eindeutige `ID` vergeben (nur wenn der Block ein ID-Attribut hat) | + +Skriptfaehig bauen (Muster aus `hundm05:bau-sensor`): + +```lisp +(setq eff (ssg-ils-block-laden "Scanner")) ; nicht per (and ...) verketten! +(command "_.INSERT" eff (list x y z) "" "" rotation) +(while (and (> (getvar "CMDACTIVE") 0) (< n 5)) (command "") (setq n (1+ n))) +(ssg-id-generate (entlast)) +``` + +`ATTREQ`/`ATTDIA` vorher auf 0 setzen. Restliche Prompts gezaehlt mit Enter +beantworten, nicht ungebremst: eine Rueckfrage, die Enter ablehnt, haelt +`CMDACTIVE` sonst dauerhaft > 0. + +--- + +## 6. Omniflo (`OmniModulInsert.lsp`) + +| Funktion | Zweck | +|---|---| +| `omni:insert-dxf (sivasnr-str hoehe drehung)` | `%DXFM_OMNIFLO%/.dxf` einfuegen, `HOEHE`/`DREHUNG` setzen, Layer. **Einfuegepunkt per Maus** (`pause`); Rueckgabe: Einfuegepunkt oder nil | +| `omni:insert-from-entry (dlg-result)` | Dialog-Ergebnis von Bogen/Weiche -> `omni:insert-dxf` | +| `omni:make-gerade (blockname pt pt2 srcAttribs textHeight textGap textEnt)` | **skriptfaehig**: Aluprofil-Gerade `"AP60"`/`"AP110"`/`"APG110"` von `pt` nach `pt2` als Compound-Block mit Text. `srcAttribs` per `omni:read-src-attribs`, `textEnt` nil. Kein `ssg-start` - Aufrufer setzt OSMODE/ATTREQ/ATTDIA = 0. Rueckgabe: Entity | +| `omni:insert-block (blockname laengemax)` | Befehls-Kern der Geraden (fragt `pt`/`pt2` per `getpoint`) | +| `omni:ladeschleifen-dialog (profiltyp init-hoehe)` | Dialog Ladeschleife, danach `omni:insert-dxf` | + +Skriptfaehig fuer Boegen/Weichen: `_.INSERT` der DXF direkt mit Punkt +`(x y hoehe)` und Drehung, danach `ssg-attrib-set-on` mit `HOEHE`/`DREHUNG` +(`omni:test-insert` in `tests/test_omniflo.lsp`). Die festen TEF-/Zubehoer- +Befehle (`OMNI_TEF_*`, `OMNI_STOPPER` ...) rufen `omni:insert-dxf` mit fester +Sivas-Nummer. `OMNI_TV_*` und `OMNI_APBW_*` sind Platzhalter ohne Bau-Logik. + +--- + +## 7. TEF-Foerderer-Linie (`TEFInsert.lsp`) + +| Funktion | Zweck | +|---|---| +| `c:TEF_FOERDERER_LINIE` | Start-/Endpunkt abfragen, Linie zeichnen, 1000-mm-TEF-Geraden (`0_B10030.dxf`) aneinanderreihen; das letzte Stueck wird zurueckversetzt, damit der Foerderer genau am Linienende endet | +| `tefl-insert-element (start richtung-einheit s hz winkel)` | ein Element an Position `s` (mm ab `start`) entlang der Linie, Rz(hz)*Ry(winkel) | +| `tefl-ensure-block-loaded (dxf-pfad)` | Blockdefinition einmal laden | + +--- + +## 8. Geruest (`GeruestInsert.lsp`) + +| Funktion | Zweck | +|---|---| +| `geruest-einfuegen (bg wahl)` | Befehls-Kern Saeulen/Rohrabhaenger/Wandbefestigung: baut aus der Dialog-Auswahl `wahl` = `(variante-index oben unten laenge farbe)` die Werte (ARTINR, BEZEICHNUNG, TEILEART, LAENGE, TEILEFARBE), fragt dann den Punkt per `getpoint` | +| `geruest-block-bauen (bg variante werte pt teile-dwgs)` | **skriptfaehiger Kern**: Dummy-DWG + Teile-DWGs bei `pt`, Block `GR__`. `bg` = Baugruppe aus `geruest.json`, `werte` = Attribut-Alist, `teile-dwgs` aus `geruest-teile-dwgs` | +| `geruest-traeger-einfuegen (bg wahl)` | Befehls-Kern Traeger: Schleife Startpunkt -> Endpunkt oder Laenge | +| `geruest-traeger-block-bauen (bg layer netto strebe strebe-pfad muffe-pfad werte pt winkel)` | **skriptfaehiger Kern** Traeger: LINE (0,0,0)-(netto,0,0), Streben, Muffe, Block bei `pt` mit `winkel` (Radiant). Rueckgabe: `(blockname . entity)` | +| `geruest-traeger-laenge`, `-start`, `-streben`, `-pruefen` | reine Berechnung (Netto-Laenge nach Abzuegen, Startpunkt, Strebenverteilung, min/max) - in `tests/test_unit.lsp` getestet | +| `geruest-traeger-beschriften (blockEnt)` | Beschriftungstext aus dem fertigen Block | +| `geruest-block-abschliessen (bg attribs werte lastEnt pt rot)` | gemeinsamer Schluss aller Geruest-Bloecke (ATTDEFs, Block bilden, einfuegen, ID) | + +Fuer Geruest gibt es noch keinen JSON-Treiber. + +--- + +## 9. Einfuegeprimitiven (`ssg_ks_insert.lsp`, `vf_etage.lsp`) + +Grundbausteine, auf denen VF, GF und Linienzug aufsetzen. Alle legen **KS_EIN** +des Blocks (nicht den Block-Ursprung) auf den Startpunkt und geben den +Weltpunkt von **KS_AUS** zurueck - damit lassen sich Bausteine verketten. + +| Funktion | Zweck | +|---|---| +| `ensure-block-loaded (name)` | Block einmal ins Dokument laden | +| `extract-ks-from-block (block-obj)` | KS_EIN/KS_AUS eines eingefuegten Blocks (VLA-Objekt) lesen, Cache `*ks-cache*` je Blockname | +| `insert-block-by-ks (blockname einfuegepunkt hz)` | Block nur um Z gedreht (AS/ES-Elemente, Stationen) | +| `insert-inclined-scaled-block (blockname startpunkt laenge winkel hz)` | Block in X auf `laenge` skaliert und um `winkel` geneigt, Rz(hz)*Ry(winkel) (Staustrecken) | +| `insert-rotated-block-with-ks (blockname startpunkt winkel block-dx block-dz hz)` | Block gedreht, `block-dx`/`block-dz` nur als Fallback ohne KS_AUS (Boegen) | +| `insert-hz-scaled-block-by-ks (blockname startpunkt laenge hz-winkel vert-winkel)` | waagrechter, auf `laenge` skalierter Block (`Staustrecke_SP_1000_mm`, Massstab `laenge/1000`); Kandidat fuer die noch fehlende waagrechte Foerderstrecke. Bricht bei fehlender Blockdatei mit `(exit)` ab - vorher mit `ssg-ils-block-laden` pruefen | +| `ssg-rot-matrix-zy (chz shz cv sv)` | 4x4-Rotationsmatrix Rz(hz)*Ry(vert) aus Cosinus/Sinus beider Winkel (`ssg_core.lsp`) | + +--- + +## 10. Gemeinsame Regeln fuer eigene Treiber + +- Systemvariablen ueber `ssg-start`/`ssg-end` sichern; `OSMODE` 0, + `ATTREQ` 0, `ATTDIA` 0 setzen, sonst fragt `_.INSERT` nach Attributen. +- Module vorher laden: `(ssg-ensure "KreiselInsert")`, `"VarioFoerderer"`, + `"Gefaellestrecke"`, `"SSG_LIB_Commands"`. +- Die Dimension folgt `ssg-ils-dim-aktuell`; fuer einen festen Lauf + `*ssg-ils-dim*` (bzw. `*vsp-dim-override*` beim Spec-Bau) setzen und danach + zuruecksetzen. +- Rueckgaben nicht mit `and`/`or` verketten - die liefern in AutoLISP nur + T/nil (siehe `CLAUDE.md`, Konventionen). +- Interaktive GUI abschalten: `ssg-gui-aus` bzw. `vsp-headless-an`. +- Vorbilder: `tests/test_mubea.lsp` (Kreisel, VF Standard/Etage, GF, + Einzelbloecke), `tests/test_hundm05.lsp` (Spec-Ketten, Kreisel, + Einzelbloecke), `tests/test_omniflo_strecke.lsp` (Omniflo). diff --git a/doc/Entwicklungsplan.md b/doc/plan/Entwicklungsplan.md similarity index 100% rename from doc/Entwicklungsplan.md rename to doc/plan/Entwicklungsplan.md diff --git a/doc/KS-Frame-Architektur.md b/doc/plan/KS-Frame-Architektur.md similarity index 100% rename from doc/KS-Frame-Architektur.md rename to doc/plan/KS-Frame-Architektur.md diff --git a/doc/translate.md b/doc/plan/translate.md similarity index 100% rename from doc/translate.md rename to doc/plan/translate.md diff --git a/doc/vf-parameter-struct-analyse.md b/doc/plan/vf-parameter-struct-analyse.md similarity index 100% rename from doc/vf-parameter-struct-analyse.md rename to doc/plan/vf-parameter-struct-analyse.md diff --git a/doc/TODO-modus2-achsenweise-bilanz.md b/doc/todo/modus2-achsenweise-bilanz.md similarity index 100% rename from doc/TODO-modus2-achsenweise-bilanz.md rename to doc/todo/modus2-achsenweise-bilanz.md diff --git a/doc/TODO-plan-vf-interactive.md b/doc/todo/plan-vf-interactive.md similarity index 98% rename from doc/TODO-plan-vf-interactive.md rename to doc/todo/plan-vf-interactive.md index f27da22..b63210a 100644 --- a/doc/TODO-plan-vf-interactive.md +++ b/doc/todo/plan-vf-interactive.md @@ -1,6 +1,9 @@ # TODO/Plan: VF-Linienzug ohne GUI/Konsole aufrufbar machen -**Stand:** 2026-09-02 · **Status:** Stufe 0 fertig (im CAD noch ungetestet) +**Stand:** 2026-09-02, Fortschrittsnotizen bis 2026-09-18 · +**Status:** Stufe 0 fertig und CAD-verifiziert; Stufe 1 (Modus 1) im CAD +verifiziert, `TEST_HUNDM05` aktiv in `tests/alltests.json`; Stufe 2 +Schritte 0-4 + 7-Assertion fertig, 5/6/8/9/10 offen, 11 zurueckgestellt. **Herkunft:** Planungslauf (Plan-Modus) vom 2026-09-02, hier eingecheckt zur Nachverfolgung. ## Fortschritt @@ -12,7 +15,7 @@ | P1 | `vfl-meldung` statt `alert` in den Bau-Pfaden | **erledigt** | | P2 | `*vfl-headless*`: leere Replay-Queue wird zum Fehler | **erledigt** | | P3 | Kleinkram (`*vfl-meldungen*`-Reset, `vfl-view-refresh`) | **erledigt** | -| S1 | Stufe 1: `Lisp/vf_spec.lsp` (Spec -> Journal -> Replay) | **Modus 1 fertig**, im CAD ungetestet | +| S1 | Stufe 1: `Lisp/vf_spec.lsp` (Spec -> Journal -> Replay) | **Modus 1 fertig, im CAD verifiziert** (`TEST_HUNDM05` aktiv in `tests/alltests.json`) | | S2 | Stufe 2: echte Funktionstrennung | **Schritte 0-4 + 7-Assertion fertig**, 5/6/8/9/10 offen, 11 zurueckgestellt | | PY | `lib/vf_journal_export.py`: Grammatik vervollstaendigen | **erledigt** | @@ -79,11 +82,11 @@ Block ist (danach entstehen noch Beschriftungstexte). Behoben: - `vfl-meldung` verkraftet jetzt `txt` = nil (fehlender i18n-Schluessel wuerde `strcat` genau dann abbrechen, wenn schon etwas schiefging). -**Noch offen** (braucht BricsCAD): `TEST_HUNDM05` muss 5x -`"status": "executed"` mit `prompts` 0 liefern, und eine interaktive -Gegenprobe (`FOERDERANLAGE` -> Linienzug Modus 1, Doppelklick-Edit, -`SSG_DIM_SWITCH`) muss unveraendert aussehen. Erst danach kann in -`tests/alltests.json` das `"disabled": true` der hundm05-Zeile weg. +**Erledigt**: `TEST_HUNDM05` liefert 5x `"status": "executed"` mit `prompts` +0; die interaktive Gegenprobe (`FOERDERANLAGE` -> Linienzug Modus 1, +Doppelklick-Edit, `SSG_DIM_SWITCH`) ist unveraendert. Das `"disabled": true` +der hundm05-Zeile in `tests/alltests.json` ist weg, der Test laeuft aktiv +mit. **Bewusst nicht umgestellt**: `vfl-konvertiere-ent` (Batch-2D/3D) laeuft weiter ohne `*vfl-headless*` - eine Live-Rueckfrage ist dort bisher gewolltes diff --git a/doc/tools.md b/doc/tools.md index 92efe5d..5e01b66 100644 --- a/doc/tools.md +++ b/doc/tools.md @@ -70,7 +70,7 @@ Die JSON-Dateien liefern die IDs (Sivasnr) und Metadaten zur Filterung. Die DXF- ### --boegen -Alle Eintraege aus `omniflo_boegen.json` (27 Items, KurvenWinkel 22.5/45/67.5/90/180). +Alle Eintraege aus `omniflo_boegen.json` (29 Items, KurvenWinkel 22.5/45/67.5/90/180). **Kriterium:** Schnittpunkt der Tangenten am Anfangs- und Endpunkt der Bogenkurve. Bei 180-Grad-Boegen wird der Mittelpunkt zwischen Start und Ende verwendet. @@ -103,19 +103,21 @@ Einzel-, Doppel- und Dreiwegeweichen mit KurvenWinkel 0, ohne Sternweiche (8 Ite ### --delta -Deltaweichen (1 Item). +Deltaweichen (7 Items). **Kriterium:** Mittelpunkt der laengsten horizontalen Linie. ### --dreifachweiche -Dreifachweichen (6 Items). +Dreifachweichen (aktuell 0 Items in `omniflo_weichen.json` - Schalter und +Filterkriterium existieren weiter in `lib/omniflo_utils.py` fuer den Fall, +dass wieder Dreifachweichen-Daten gepflegt werden). **Kriterium:** Mittelpunkt der laengsten horizontalen Linie. ### --sternweiche -Sternweiche (1 Item). +Sternweiche (2 Items). **Kriterium:** Zentrum, berechnet als Mittelpunkt der laengsten horizontalen Linie (entspricht dem Schnittpunkt der horizontalen und vertikalen Mittelachse). @@ -135,21 +137,24 @@ Hier die Weichen ## Abdeckung -Alle 107 Items (27 Boegen + 80 Weichen) sind exklusiv genau einem Schalter zugeordnet. Keine Ueberlappungen, keine Luecken. +Alle 110 Items (29 Boegen + 81 Weichen, Stand aktuelle `data/json/omniflo_*.json`) +sind exklusiv genau einem Schalter zugeordnet. Keine Ueberlappungen, keine +Luecken. Die Zahlen je Schalter verschieben sich mit der Datenbasis; bei +Zweifel per `SWITCH_FILTERS` (`lib/omniflo_utils.py`) nachrechnen. ## Uebersicht aller Schalter | Schalter | Items | WeichenTyp | KurvenWinkel | Einfuegepunkt-Kriterium | | --- | --- | --- | --- | --- | -| `--boegen` | 27 | - | 22.5, 45, 67.5, 90, 180 | Tangentenschnittpunkt am Bogen (180: Mittelpunkt) | +| `--boegen` | 29 | - | 22.5, 45, 67.5, 90, 180 | Tangentenschnittpunkt am Bogen (180: Mittelpunkt) | | `--weichen45` | 32 | Einzel-, Doppel-, Dreiwegeweiche | 45 | Tangente oberer Bogenpunkt x laengste Vertikale | | `--weichen90` | 24 | Einzel-, Doppel-, Dreiwegeweiche | 90 | Tangente oberer Bogenpunkt x laengste Vertikale | | `--weichenkoerper` | 8 | Einzel-, Doppel-, Dreiwegeweiche | 22.5 | Laengste Diagonale x laengste Vertikale | | `--weichen-parallel` | 8 | Einzel-, Doppel-, Dreiwegeweiche | 0 | Laengste Diagonale x laengste Vertikale | -| `--dreifachweiche` | 6 | Dreifachweiche | 90 | Mittelpunkt laengste Horizontale | -| `--delta` | 1 | Deltaweiche | 90 | Mittelpunkt laengste Horizontale | -| `--sternweiche` | 1 | Sternweiche | 0 | Zentrum (Mittelpunkt laengste Horizontale) | -| **Gesamt** | **107** | | | | +| `--dreifachweiche` | 0 | Dreifachweiche | 90 | Mittelpunkt laengste Horizontale | +| `--delta` | 7 | Deltaweiche | 90 | Mittelpunkt laengste Horizontale | +| `--sternweiche` | 2 | Sternweiche | 0 | Zentrum (Mittelpunkt laengste Horizontale) | +| **Gesamt** | **110** | | | | ## Umgebungsvariablen @@ -169,9 +174,11 @@ Setzt Koordinatensystem-Bloecke (K1, K2, K3, K4) in Omniflo DXF-Dateien. Jeder B ## Aufruf ``` -python lib/set_koords.py [--schalter] [--number SIVASNR] [--force] +bin\set_coords.bat [--schalter] [--number SIVASNR] [--force] ``` +Das Batch-Skript ruft `setenv.bat` auf und startet `lib/set_koords.py` mit den uebergebenen Argumenten. + ## Datenquellen | Pfad | Inhalt | diff --git a/doc/variofoerderer.md b/doc/variofoerderer.md index fd97fca..ad0d2a8 100644 --- a/doc/variofoerderer.md +++ b/doc/variofoerderer.md @@ -185,12 +185,18 @@ Winkelberechnung befuellt, da seine Optionsliste von Dialog 1 abhaengt. | Verteilung Staustrecken | `verteilung` | Dropdown | Gleichmaessig (L_GF1=L_GF2) / Vorne Minimum, hinten Rest / Hinten Minimum, vorne Rest / Eigene Werte | Gleichmaessig | | L_GF1 vorne (manuell) | `lgf1_manuell` | Zahl (mm) | nur aktiv bei Verteilung "Eigene Werte" | L_GF / 2 | -Vorgelagert (Konsole, vor Dialog 1): Eingabemodus-Frage "3D-Linie" vs. "Werte -manuell" — nur bei Wahl "2" oeffnen sich obige Dialoge, sonst laeuft der -komplette [Legacy-Konsolen-Pfad](#8-legacy-konsolen-pfad). Direkt vor Dialog 1 -wird zusaetzlich der Startpunkt (X/Y) per Punktwahl gewaehlt -(`vfs-standard-dialog-ablauf`, `Lisp/vf_standard.lsp:1069`); die Z-Hoehe kommt -aus dem Feld "Einfuegehoehe". +Vorgelagert: Eingabemodus-Frage "3D-Linie" vs. "Werte manuell" per DCL-Dialog +(`vfc_eingabemodus`, `vfc-dialog-eingabemodus-waehlen` in `Lisp/vf_core.lsp`; +Radio-Buttons wie `vfc_typ`, Rueckfall auf die alte Konsolenfrage bei +abgeschalteter GUI oder `DXFM_LANG=en_GB`). **Beide** Antworten fuehren zu +Dialog 1/2 oben: bei "3D-Linie" wird zuerst die Linie gewaehlt +(`vfc-3dlinie-erfassen`, Objektauswahl bleibt Zeichnung/Konsole — eine Linie +laesst sich nicht durch ein Formularfeld ersetzen) und deltaL/deltaH/hz/ +Einfuegehoehe gehen als Prefill in Dialog 1; bei "Werte manuell" wird nur der +Startpunkt per Punktwahl-Dialog (`vfc-dialog-startpunkt-waehlen`) gewaehlt und +Dialog 1 startet ohne Geometrie-Prefill. Der +[Legacy-Konsolen-Pfad](#8-legacy-konsolen-pfad) existiert nur noch als +Rueckfall, wenn keiner der beiden Dialoge gezeigt werden kann/darf. --- @@ -236,13 +242,62 @@ Das Winkel/Seite-Paar (`aus_winkel`/`aus_seite`, `ein_winkel`/`ein_seite`) taucht identisch auch im Linienzug als AS-/ES-Element-Baustein auf (siehe Abschnitt 5.2). -Zusaetzlich als Legacy-Konsole vorhanden (kein Dialog): +**Modus 2** — Startpunkt/Endpunkt waehlen (`GEFAELLESTRECKE_3DLINIE`): 2x +Punktwahl + Gefaellewinkel (Zahl, aus DeltaH automatisch vorgeschlagen). +Legacy-Konsole, kein Dialog. -- **Modus 2** — Startpunkt/Endpunkt waehlen: 2x Punktwahl + Gefaellewinkel - (Zahl, aus DeltaH automatisch vorgeschlagen). -- **Modus 3** — Bestehenden Linienzug (Linien/Boegen) auswaehlen: Objektauswahl, - Winkel wird aus der Geometrie vorgeschlagen und kann per j/n bestaetigt oder - ueberschrieben werden. +**Modus 3** — Bestehenden Linienzug (Linien/Boegen) auswaehlen +(`GEFAELLESTRECKE_LINIENZUG`): Objektauswahl (`ssget` LINE/ARC) und +Start-/Endpunktwahl bleiben Zeichnung/Konsole. AUS-/EIN-Element (Winkel +90/30 + Seite links/rechts) laufen danach ueber EINEN Dialog +(`gefaellestrecke_linienzug`, `gf-dialog-linienzug-aus-ein` in +`Lisp/Gefaellestrecke.lsp`) — muss vor der automatischen Segmentlaengen- +/Winkelberechnung laufen, die von der AS-/ES-Masse abhaengt. Danach zeigt +ein zweiter Dialog (`gf-dialog-linienzug-winkel`) den automatisch +berechneten Vorschlagswinkel ueberschreibbar zusammen mit einer kurzen +Segment-Zusammenfassung; dessen OK ersetzt zugleich die SPAETERE finale +Einfuegen-Bestaetigung (keine doppelte Rueckfrage nach der rein +automatischen AS/ES-Korrekturschleife). Rueckfall auf die alten +Konsolenfragen (inkl. der finalen Einfuegen-Bestaetigung), wenn einer der +beiden Dialoge nicht gezeigt werden kann/darf (GUI aus); ein bewusster +Dialog-Abbruch ('ABBRUCH) bricht dagegen den ganzen Befehl ab, OHNE auf die +Konsole zurueckzufallen. + +**Beispiel Modus 3 — Gefaellestrecke aus einem gezeichneten Linienzug:** + +1. Vorab eine Kette aus LINE-/ARC-Objekten entlang der gewuenschten Trasse + zeichnen (Geraden + Rundungen, hier ein abgerundeter Linienzug): + ![GF aus Linienzug - Ausgangslinie](images/gf-linienzug1.png) +2. `GEFAELLESTRECKE_LINIENZUG` aufrufen, die Objekte auswaehlen sowie Start- + und Endpunkt der Kette anklicken. Danach AS-/EIN-Element (Winkel/Seite) + im ersten Dialog waehlen; der zweite Dialog zeigt den automatisch aus + der Geometrie berechneten Gefaellewinkel-Vorschlag (hier 3°, AS/ES-Felder + nur noch zur Kontrolle, nicht mehr editierbar): + ![GF aus Linienzug - Dialog mit Vorschlagswinkel](images/gf-linienzug2.png) +3. Nach OK baut der Befehl die Gefaellestrecke direkt entlang der + Original-Linie (AUS-Element, Gefaellebogen an jeder Rundung, + Staustrecke, EIN-Element) — die urspruengliche Linie bleibt zur + Kontrolle in der Zeichnung stehen: + ![GF aus Linienzug - fertige Strecke neben der Ausgangslinie](images/gf-linienzug3.png) + +**Bearbeiten (`c:GEFAELLESTRECKE_EDIT`):** Doppelklick auf einen per +Linienzug gebauten `GF_n`-Block (TEILEART `"Streckengruppe"`, enthaelt +mindestens einen Bogen) dispatcht auf `gf-linienzug-rebuild` statt auf den +einfachen Gefaellestrecke-Dialog — der kennt keine Segmentliste/Boegen und +wuerde beim Neuaufbau die Bogengeometrie verlieren. Die Segmentliste +(Typ/Fahrtrichtung/Laenge/Winkel/Seite je Segment, bereits laengenfertig) +UND der Baustartpunkt stehen als eigene XDATA (App `SSG_GF_LZ`, +`gf-lz-xdata-schreiben`/`-lesen`, variable Laenge + Chunking wie die +Sepliste-XDATA in `ssg_ks_insert.lsp`) auf dem Block — ohne sie bleibt eine +Streckengruppe wie zuvor nicht editierbar (Meldung "Nur einfache +Gefaellestrecken..."). Der Edit-Ablauf nutzt dieselben zwei Dialoge wie das +Bauen (`gf-dialog-linienzug-aus-ein`/`-winkel`), diesmal mit den aktuellen +Attributen (`WINKEL_AS`/`SEITE_AS`/`WINKEL_ES`/`SEITE_ES`) vorbelegt statt +mit Defaults — AS-/ES-Element und Gefaellewinkel bleiben damit nachtraeglich +aenderbar, die Segmentlaengen/-form (Geraden, Boegen) selbst nicht (dafuer +muss die Kette per `GEFAELLESTRECKE_LINIENZUG` neu gebaut werden). Baut am +selben Startpunkt neu und loescht den alten Block erst NACH erfolgreichem +Neuaufbau. --- @@ -377,6 +432,18 @@ interaktive Linienzug-Ablauf weiter (Abschnitt 5). Einzige Eingabe — Rest laeuft automatisch (Attribute aggregiert, Luecken werden gemeldet). +**VARIOFOERDERER_NACHRUESTEN / VF_NACHRUESTEN** + +| Feld | Steuerelement | Werte | +|---|---|---| +| VF_n-Bloecke | Objektauswahl (`ssget`) | Altbestand ohne `SSG_VF_EDIT`-Marker | +| Baurichtung hz je Fund | Dialog `vfs_nachruesten_hz` (Zahl, Grad) | Vorgabe = zuletzt eingegebener Wert; Rueckfall auf Konsole nur, wenn der Dialog nicht gezeigt werden kann/darf | + +Typ (Standard/Etage) wird automatisch aus den Attributen erkannt +(`GF_Bogen_R/L_60` -> Etage). Nur die Baurichtung ist nicht rekonstruierbar +und wird je unmarkiertem Fund abgefragt; "Abbrechen" im Dialog uebernimmt +fuer diesen Fund den Vorgabewert, ohne die ganze Schleife abzubrechen. + **VF_SEKTION_RESTORE — lose Kette aus der Zeichnung wiederherstellen** | Feld | Steuerelement | Werte | @@ -419,9 +486,11 @@ Wiederherstellungs-Daten gehoeren ausschliesslich in die XDATA der Zeichnung. ## 8. Legacy-Konsolen-Pfad -Wird bei Standard/Etage durchlaufen, wenn auf die Eingabemodus-Frage *nicht* -"2" getippt wird (Enter/leer faellt ebenfalls hierher zurueck) — also aktuell -noch der Vorgabe-Pfad. Zwei Untermodi: +Reiner Rueckfall fuer Standard/Etage: greift nur noch, wenn der Dialog +`vfc_eingabemodus` nicht gezeigt werden kann/darf (GUI abgeschaltet, +`DXFM_LANG=en_GB`) — im Normalfall (GUI an, Deutsch) laufen beide +Eingabemodi inzwischen ueber den Dialog (Abschnitt 2, "Vorgelagert"). Zwei +Untermodi: **3D-Linie auswaehlen** @@ -448,7 +517,7 @@ Optionen, bei "Eigene Werte" zusaetzlich L_GF1 als Zahl) -> Bestaetigung ## 8b. Nicht-interaktiver Betrieb (Headless) Fuer Tests, Batch-Nachbau und den geplanten Spec-Bau (Fahrplan: -`doc/TODO-plan-vf-interactive.md`) muss eine Kette **ohne** Dialog und ohne +`doc/todo/plan-vf-interactive.md`) muss eine Kette **ohne** Dialog und ohne Konsolenfrage laufen. Drei Schalter greifen dabei ineinander: | Schalter | Datei | Wirkung | @@ -585,19 +654,13 @@ eine bereits genannte, kleinere Nummer (z.B. 34 -> 35 -> 34) sind Schleifen |---|---|---|---| | 1 | Befehl waehlen | FOERDERANLAGE / GEFAELLESTRECKE | 2, 40 | | 2 | Anlagen-Typ | Standard / Etage / Linienzug | 3, 3, 30 | -| 3 | Eingabemodus (nur Standard/Etage) | Konsole / Dialog | 4, 10 | -| 4 | Startpunkt waehlen | Punktwahl | 5 | +| 3 | Eingabemodus (nur Standard/Etage) | Dialog `vfc_eingabemodus`: 3D-Linie / Werte manuell | 11, 4 | +| 4 | Startpunkt waehlen | Punktwahl-Dialog | 5 | | 5 | Dialog "Basis" | DeltaL, DeltaH, Auf/Ab, Einfuegehoehe, Fahrtrichtung, Seite, Motorseite, 2D/3D, Geruest | 6 | | 6 | Winkelberechnung (automatisch) | - | 7 | | 7 | Dialog "Winkel/Verteilung" | Winkel, Verteilung, ggf. L_GF1 | 8 | | 8 | Bau (automatisch) | - | ENDE | -| 10 | Eingabemodus Konsole | 3D-Linie / Werte | 11, 12 | -| 11 | 3D-Linie waehlen | Objektwahl -> DeltaL/DeltaH/Fahrtrichtung automatisch | 13 | -| 12 | Werte eingeben | DeltaL, DeltaH, Auf/Ab, Startpunkt, Fahrtrichtung | 13 | -| 13 | Seite waehlen | rechts/links | 14 | -| 14 | Winkel waehlen | automatisch bei 1 Treffer, sonst Liste | 16 | -| 16 | Staustrecken-Verteilung | 4 Optionen, ggf. L_GF1 manuell | 17 | -| 17 | Bestaetigung "Einfuegen?" | Ja/Nein | 8 | +| 11 | 3D-Linie waehlen | Objektwahl (Zeichnung) -> DeltaL/DeltaH/Fahrtrichtung automatisch, Prefill fuer Dialog 5 | 5 | | 30 | Linienzug-Modus | Manuell / Pfad+Zielhoehe / Vorwaerts-Nachbau | 31, 50, 55 | | 31 | Startpunkt + Starthoehe | Punktwahl + Zahl | 32 | | 32 | AS-Element setzen? | Ja/Nein | 33, 34 | @@ -645,9 +708,9 @@ eine bereits genannte, kleinere Nummer (z.B. 34 -> 35 -> 34) sind Schleifen ### Beispiel-Abfolgen -- Standard, Dialog-Pfad: `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8` -- Standard, Legacy-Konsole mit 3D-Linie: `1 -> 2 -> 3 -> 10 -> 11 -> 13 -> 14 -> 16 -> 17 -> 8` -- Etage, Dialog-Pfad: `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8` +- Standard, Werte manuell: `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8` +- Standard, aus 3D-Linie: `1 -> 2 -> 3 -> 11 -> 5 -> 6 -> 7 -> 8` +- Etage, Werte manuell: `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8` - Linienzug — AS-Element, GF, Auf/Ab-VF mit Zwischenkurve, Kettenende: `1 -> 2 -> 30 -> 31 -> 32 -> 33 -> 34 -> 36 -> 41 -> 34 -> 37 -> 42 -> 46 -> 42 -> 45` - Linienzug — horizontaler Anfang direkt bis Kettenende: diff --git a/doc/vf_linienzug_modus1_anleitung.md b/doc/vf_linienzug_modus1_anleitung.md index 371b0ba..3645412 100644 --- a/doc/vf_linienzug_modus1_anleitung.md +++ b/doc/vf_linienzug_modus1_anleitung.md @@ -10,9 +10,8 @@ aufrufbar in BricsCAD ueber `TEST_LINIENZUG_STUFE2` (siehe diesen Testlauf jederzeit wiederholen. Fuer die Architektur-Details (Frame-Kette, Journal/XDATA, Wizard-Dialoge) -siehe `doc/variofoerderer.md` und `doc/VarioFoerderer_Linienzug_Prinzipien.md`. -Diese Anleitung konzentriert sich auf die Bedienung und die typischen -Stolperfallen. +siehe `doc/variofoerderer.md`. Diese Anleitung konzentriert sich auf die +Bedienung und die typischen Stolperfallen. ## 1. Was ist Modus 1? @@ -58,43 +57,48 @@ ist der interessante Teil (siehe Abschnitt 4, Stufe 1/Stufe 2). Diese Tabelle zitiert die tatsaechlichen Konsolen-Fragen aus dem Testfall (Kommentar-Spalte = `kommentar`-Feld im JSON) und erklaert, was jede Frage -bedeutet. +bedeutet. Die Datei hat aktuell 62 Eingabe-Eintraege (ohne das Kopf-Objekt); +mehrere Eintraege pro Zeile sind zu einem Schritt zusammengefasst, wo eine +Antwort mehrere JSON-Eintraege verbraucht (z.B. eine Vario-Kurve = Winkel + +Seite + Variante = 3 Eintraege). -| # | Frage (sinngemaess) | Antwort im Beispiel | Bedeutung | +| # (JSON-Eintraege) | Frage (sinngemaess) | Antwort im Beispiel | Bedeutung | |---|---|---|---| | 1 | Startpunkt der Kette | Klick (X/Y) | Beliebiger Punkt in der Zeichnung | | 2 | Hoehe (Z) Startpunkt | 2154 | Absolute Einbauhoehe des Kettenanfangs | | 3 | AS-Element setzen? | Ja | Umlenkstation am Anfang - "AS" = Ausgangs-/Anfangs-Element | | 4 | AS-Element Winkel | 90 Grad | Baugroesse des Umlenkstations-Blocks (90 oder 30 Grad Kurvenradius) | | 5 | AS-Seite | links | Auf welcher Seite die Umlenkstation seitlich ausschwenkt | -| 6 | Naechstes Element | Horizontal-VF | Kettenanfang-Menue hat 6 Optionen (GF-Bogen, Vario-Kurve, Linie-GF, Linie-VF, Horizontal-VF, Linienende) | -| 7 | Endpunkt Horizontal-VF | Klick | Laenge/Richtung der ersten VF-Einheit | -| 8 | Ziel-Hoehe Eingang GF1 | 1980 | Hoehe, auf die der Eingangs-GF-Anteil der VF-Einheit einregelt | -| 9 | Ist der Endpunkt der Foerderer? | Nein | Innerhalb der VF-Einheit: "geht die Kette hier zu Ende?" | -| 10-13 | Naechstes im VarioFoerderer -> Vario-Kurve 90 rechts innen | - | Grundriss-Schwenk INNERHALB der laufenden VF-Einheit | -| 14 | Ist der Endpunkt der Foerderer? | Nein | s.o. | -| 15-16 | Horizontaler Foerderer, Endpunkt | Klick | Weiteres gerades VF-Sub-Segment | -| 17 | Ist der Endpunkt der Foerderer? | Nein | s.o. | -| 18-21 | Vario-Kurve 90 rechts innen | - | Zweiter Grundriss-Schwenk | -| 22 | Ist der Endpunkt der Foerderer? | Ja, nur Motorstation | Schliesst die 1. VF-Einheit ab (Motorstation, kein ES) | -| 23 | Ist das Kettenende (ES-Element)? | Nein, weiterbauen | Nach der Motorstation: geht die Kette weiter? | -| 24 | Zusaetzlichen Separator hier? | Nein | Optionaler Separator direkt an der Motorstation | -| 25 | Naechstes Element | Neue Linie: GF | Jetzt folgt ein reines Gefaellestrecke-Element (kein VF) | -| 26 | Laenge bestimmen ueber | Endpunkt waehlen | Alternativ: Zielhoehe zuerst festlegen (siehe `vfl-gf-laenge-modus`) | -| 27 | Endpunkt Gefaellestrecke | Klick | Bestimmt deltaL der GF-Geraden | -| 28-29 | Separator VOR / NACH? | Ja / Ja | GF-Stuecke werden ueber Separatoren mechanisch begrenzt | -| 30-31 | Gefaelle festlegen -> Neigungswinkel | 3 Grad | Direkter Winkel (Alternative: Zielhoehe -> Winkel wird berechnet) | -| 32 | Ist das Kettenende? | Nein, weiterbauen | 3-Optionen-Menue: Ja+ES / Ja ohne ES / Nein | -| 33 | Naechstes Element | Horizontal-VF (2. Einheit) | Neue VF-Einheit beginnt direkt am GF-Ausgang (Separator als Eingang) | -| 34-49 | (wie oben: Vario-Kurven, Auf/Ab-Foerderer 27 Grad) | - | s.o. | -| 50 | Ist der Endpunkt der Foerderer? | Ja, Motorstation + Kettenende | Startet den automatischen Kettenende-Abschluss | -| 51-53 | ES-Element setzen? / Winkel / Seite | Ja / 90 / links | Ausgangs-Element, spiegelbildlich zum AS-Element | -| 54 | Endpunkt Kettenende | Klick | Letzter gewuenschter Punkt der Kette | -| 55 | Ziel-Hoehe Kettenende | 2154 | Muss wieder exakt die Starthoehe sein | -| 56 | (automatisch, keine Eingabe) | - | Stufe-1/Stufe-2-Loeser rechnet, siehe Abschnitt 4 | -| 57 | GF2=86mm unter Mindestlaenge - trotzdem bauen? | Ja | Sicherheitsfrage, siehe Abschnitt 4 | +| 6 | Naechstes Element | Neue VF mit horizontalem Anfang | Kettenanfang-Menue hat 6 Optionen (GF-Bogen, Vario-Kurve, Linie-GF, Linie-VF, Horizontal-VF, Linienende) | +| 7 | Endpunkt der Linie | Klick | Laenge/Richtung der ersten VF-Einheit | +| 8 | Ziel-Hoehe fuer den horizontalen VF-Anfang | 1980 | Hoehe, auf die der Eingangs-GF-Anteil der VF-Einheit einregelt | +| 9-10 | Zusaetzlichen Separator VOR/NACH dem horizontalen Stueck? | Nein / Nein | Optionale Separatoren direkt am VF-Einlauf | +| 11 | Ist der Endpunkt der Foerderer? | Nein | Innerhalb der VF-Einheit: "geht die Kette hier zu Ende?" | +| 12-15 | Naechstes im VarioFoerderer -> Vario-Kurve 90 rechts innen | - | Grundriss-Schwenk INNERHALB der laufenden VF-Einheit | +| 16 | Ist der Endpunkt der Foerderer? | Nein | s.o. | +| 17-18 | Horizontaler Foerderer, Endpunkt | Klick | Weiteres gerades VF-Sub-Segment | +| 19-20 | Zusaetzlichen Separator VOR/NACH? | Nein / Nein | s.o. | +| 21 | Ist der Endpunkt der Foerderer? | Nein | s.o. | +| 22-25 | Vario-Kurve 90 rechts innen | - | Zweiter Grundriss-Schwenk | +| 26 | Ist der Endpunkt der Foerderer? | Ja, nur Motorstation | Schliesst die 1. VF-Einheit ab (Motorstation, kein ES) | +| 27 | Ist das Kettenende (ES-Element)? | Nein, weiterbauen | Nach der Motorstation: geht die Kette weiter? | +| 28 | Zusaetzlichen Separator hier? | Nein | Optionaler Separator direkt an der Motorstation | +| 29 | Naechstes Element | Neue Linie: GF | Jetzt folgt ein reines Gefaellestrecke-Element (kein VF) | +| 30 | Laenge bestimmen ueber | Endpunkt waehlen | Alternativ: Zielhoehe zuerst festlegen (siehe `vfl-gf-laenge-modus`) | +| 31 | Ist das Kettenende? | Nein, weiterbauen | 3-Optionen-Menue: Ja+ES / Ja ohne ES / Nein - kommt VOR der Gefaelle-/Laengenberechnung | +| 32 | Endpunkt Gefaellestrecke | Klick | Bestimmt deltaL der GF-Geraden | +| 33-34 | Separator VOR / NACH? | Ja / Ja | GF-Stuecke werden ueber Separatoren mechanisch begrenzt | +| 35-36 | Gefaelle festlegen -> Neigungswinkel | 3 Grad | Direkter Winkel (Alternative: Zielhoehe -> Winkel wird berechnet) | +| 37 | Naechstes Element | Neue VF mit horizontalem Anfang (2. Einheit) | Neue VF-Einheit beginnt direkt am GF-Ausgang (Separator als Eingang) | +| 38-55 | (wie oben: Separatoren, Vario-Kurven, Auf/Ab-Foerderer 27 Grad) | - | s.o.; Auf/Ab-Foerderer nutzt Index 8 der gueltigen Winkeltabelle-Kandidaten = 27 Grad | +| 56 | Ist der Endpunkt der Foerderer? | Ja, Motorstation + Kettenende | Startet den automatischen Kettenende-Abschluss | +| 57-59 | ES-Element setzen? / Winkel / Seite | Ja / 90 / links | Ausgangs-Element, spiegelbildlich zum AS-Element | +| 60 | Endpunkt Kettenende | Klick | Letzter gewuenschter Punkt der Kette | +| 61 | Ziel-Hoehe Kettenende | 2154 | Muss wieder exakt die Starthoehe sein | +| 62 | GF2=319mm unter Mindestlaenge (400mm) - trotzdem bauen? | Ja | Sicherheitsfrage, siehe Abschnitt 4 - Stufe-1/Stufe-2-Loeser rechnet dazwischen automatisch | -**Wichtig zu Frage 9/14/17 ("Ist der Endpunkt der Foerderer?"):** Diese Frage +**Wichtig zu "Ist der Endpunkt der Foerderer?"** (Eintraege 11/16/21/26 usw.): +Diese Frage kommt IMMER, wenn Sie innerhalb einer laufenden VF-Einheit einen Punkt gepickt haben. "Nein" heisst: der gepickte Punkt ist nur eine Zwischen-Etappe, es geht in derselben VF-Einheit weiter (Vario-Kurve, @@ -103,7 +107,7 @@ Motorstation - optional zusaetzlich mit ES-Element (echtes Kettenende). ## 4. Stufe 1 / Stufe 2 - wie die letzte Strecke berechnet wird -Am Kettenende (Frage 55/56) ist die Aufgabe: von der aktuellen Position/ +Am Kettenende (Eintrag 61/62) ist die Aufgabe: von der aktuellen Position/ Hoehe zur gewuenschten Ziel-Hoehe kommen, UND dabei die feste Baugruppe Motorstation + Separator (+ ES-Element, falls gewaehlt) unterbringen. Das Programm versucht das in zwei Stufen (`vfl-winkel-stufe-entscheidung`, @@ -112,25 +116,25 @@ Programm versucht das in zwei Stufen (`vfl-winkel-stufe-entscheidung`, - **Stufe 1 - Winkeltabelle:** Es probiert der Reihe nach die festen Vario-Kurven-Winkel 3/6/9/12/15/18/21/27/33/39/45/51 Grad durch (`berechne-alle-winkel`) und prueft, ob einer davon eine PASSENDE, - positive VF-Laenge ergibt. Das ist der Normalfall (siehe die Zeilen - "34-49" in der Tabelle: der Auf/Ab-Foerderer in der 2. VF-Einheit findet + positive VF-Laenge ergibt. Das ist der Normalfall (siehe die Zeile + "38-55" in der Tabelle: der Auf/Ab-Foerderer in der 2. VF-Einheit findet so einen passenden Winkel, Auswahl-Index 8 = 27 Grad). - **Stufe 2 - Horizontale Mitte + GF-Ausgleich:** Wenn KEIN Tabellenwinkel - passt (wie im Beispiel: alle 12 Kandidaten ergeben eine negative - VF-Laenge, die Reststrecke ist einfach zu kurz fuer einen echten + passt (wie im Beispiel am Kettenende: alle 12 Kandidaten ergeben eine + negative VF-Laenge, die Reststrecke ist einfach zu kurz fuer einen echten Vertikalbogen), rechnet `berechne-horizontale-mitte` eine andere Loesung: ein HORIZONTALES VF-Stueck (winkel=0) plus eine kurze Gefaellestrecke (GF2), die exakt den fehlenden Hoehenunterschied ausgleicht. Im Beispiel: - GF2=86mm, VF=286mm. + GF2=319mm, L_VF=48mm. Die Formel dahinter ist simpel und lohnt sich zu verinnerlichen: bei einem FESTEN Neigungswinkel von 3 Grad braucht ein Hoehenausgleich von `H` -Millimetern eine GF-Laenge von `H / tan(3 Grad) ~= H * 19`. Ein winziger -Hoehenrest von z.B. 49mm braucht demnach bereits ~935mm GF-Laenge - siehe -Abschnitt 5.a. GF2 im Beispiel (86mm) ist kuerzer als die uebliche -Mindestlaenge (400mm, `*vfl-gf-min-laenge*`) - deshalb die Rueckfrage in -Schritt 57 ("trotzdem mit 86mm bauen?"). "Ja" baut trotzdem exakt mit dem -berechneten Wert; "Nein" wuerde den bis dahin gebauten Teil verwerfen (siehe +Millimetern eine GF-Laenge von `H / tan(3 Grad) ~= H * 19`. Ein Hoehenrest +von z.B. 17mm braucht demnach bereits ~320mm GF-Laenge - siehe Abschnitt +5.a. GF2 im Beispiel (319mm) liegt knapp unter der uebliche Mindestlaenge +(400mm, `*vfl-gf-min-laenge*`) - deshalb die Rueckfrage im letzten Eintrag +("trotzdem mit 319mm bauen?"). "Ja" baut trotzdem exakt mit dem berechneten +Wert; "Nein" wuerde den bis dahin gebauten Teil verwerfen (siehe `vfl-loesche-seit`/`vfl-modus-abbruch-sichern`). **Merksatz:** Stufe 1 sucht einen "sauberen" Standard-Winkel; Stufe 2 ist @@ -170,9 +174,11 @@ Fallback ausloest. Ein AS- oder ES-Element mit 90 Grad Bauform dreht die Fahrtrichtung nicht einfach "auf der Stelle" - sein Block hat eine reale Baugroesse mit einem -seitlichen (quer zur Fahrtrichtung liegenden) Versatz. Im Standard-Testfall -(`linienzug_tests.json`) betraegt dieser Versatz ca. 637mm (`dY`), im -Stufe-2-Testfall ca. 638mm (`dX`, da die Fahrtrichtung dort anders liegt). +seitlichen (quer zur Fahrtrichtung liegenden) Versatz. Sowohl im Standard- +Testfall (`linienzug_tests.json`) als auch im Stufe-2-Testfall +(`linienzug_tests_stufe2.json`) betraegt dieser Versatz ca. 638mm (dort als +`erwartung_dx_mm` dokumentiert, da die Fahrtrichtung am Kettenende auf der +Y-Achse liegt und sich der Versatz dadurch in X statt in Y zeigt). **Das ist kein Baufehler** - es ist die tatsaechliche Geometrie des 90-Grad-ES/AS-Blocks. Ein "Ist-Ziel-Report" mit einer Restabweichung von ca. 638mm quer zur letzten Fahrtrichtung, aber ~0mm in Laengs-/Hoehenrichtung, diff --git a/lang/de_DE.json b/lang/de_DE.json index 721c443..4d76bbf 100644 --- a/lang/de_DE.json +++ b/lang/de_DE.json @@ -245,6 +245,8 @@ "vfl-m3-abweichung": "\n Abweichung: dX=%1 dY=%2 dZ=%3 mm", "vfl-m3-laengs-quer": "\n Laengs KS_AUS-Achse: %1 mm | Quer zur Achse (soll ~0): %2 mm", "vfl-m3-achse-hinweis": "\n (dZ=Ziel-Hoehe; Quer zur KS_AUS-Achse ~0 => Endpunkt liegt auf der Achse)", + "vfl-m3-ziel-soll-es-korrigiert": "\n Soll (ES-korrigiert): X=%1 Y=%2 Z=%3 (Ziel + bekannter ES-Laengsversatz)", + "vfl-m3-abweichung-es-korrigiert": "\n Abweichung (ES-korrigiert): dX=%1 dY=%2 dZ=%3 mm", "gf-fehler-block-fehlt": "\n FEHLER: Block '%1' fehlt", "gf-fehler-block-fehlt-ausruf": "\n FEHLER: Block '%1' fehlt!", "gf-fehler-blockdatei-fehlt": "\n FEHLER: Block-Datei nicht gefunden: %1", @@ -330,7 +332,6 @@ "vfc-delta-l-h-richtung": "\n %1L=%2 mm %1H=%3 mm Fahrtrichtung=%4%5", "vfc-endpunkt-xyz": "\n KS_AUS: X=%1 Y=%2 Z=%3", "vfc-endpunkt-xyz-dxdz": "\n KS_AUS: X=%1 Y=%2 Z=%3 (dx=%4 dz=%5)", - "vfc-fahrtrichtung-ergebnis": "\n>>> Fahrtrichtung: %1%2", "vfc-fehler-block-datei-fehlt": "\n FEHLER: Block-Datei nicht gefunden: %1", "vfc-fehler-block-nicht-in-bibliothek": "\n FEHLER: Block '%1' nicht in Bibliothek", "vfc-fehler-block-nicht-in-bibliothek-abgebrochen": "\n FEHLER: Block '%1' nicht in Bibliothek - abgebrochen", @@ -500,32 +501,18 @@ "vfc-alert-keine-gueltige-linie": "Keine gueltige Linie ausgewaehlt!", "vfc-bitte-3dlinie-foerderstrecke": "\nBitte 3D-Linie fuer die Foerderstrecke auswaehlen:", "vfc-bks-weltkoordinaten": "\n BKS auf Weltkoordinaten gesetzt.", + "vfc-dlg-startpunkt-kopf": "Startpunkt der Anlage waehlen (X/Y):", "vfc-eingabemodus-3dlinie": "\n 1 - 3D-Linie auswaehlen (Start- und Endpunkt mit Hoehe)", "vfc-eingabemodus-header": "\n\nEingabemodus waehlen:", "vfc-eingabemodus-werte": "\n 2 - Werte manuell eingeben", - "vfc-fahrtrichtung-0": "\n 1 - 0%1 (X-Achse +, Ost)", - "vfc-fahrtrichtung-180": "\n 3 - 180%1 (X-Achse -, West)", - "vfc-fahrtrichtung-270": "\n 4 - 270%1 (Y-Achse -, Sued)", - "vfc-fahrtrichtung-90": "\n 2 - 90%1 (Y-Achse +, Nord)", - "vfc-fahrtrichtung-header": "\n\nFahrtrichtung waehlen:", "vfc-fehler-keine-linie": "\n FEHLER: Keine Linie oder Polylinie ausgewaehlt!", "vfc-foerderrichtung-ab": "\n Foerderrichtung: AB", "vfc-foerderrichtung-auf": "Auf", - "vfc-foerderrichtung-menu": "\nFoerderrichtung:\n 1 - AUF\n 2 - AB", - "vfc-gf-verteilung-header": "\n\nVerteilung der Gefaellestrecken (vorne/hinten):", - "vfc-gf-verteilung-1": "\n 1 - Gleichmaessig (L_GF1 = L_GF2 = L_GF/2)", - "vfc-gf-verteilung-2": "\n 2 - Vorne Minimum, hinten Rest", - "vfc-gf-verteilung-3": "\n 3 - Hinten Minimum, vorne Rest", - "vfc-gf-verteilung-4": "\n 4 - Eigene Werte eingeben", "vfc-kein-objekt-gewaehlt": "\n Kein Objekt gewaehlt.", "vfc-label-von-bis": ": von %1mm bis %2mm, ", "vfc-linie-polylinie-waehlen": "\n >> 3D-Linie oder Polylinie waehlen: ", - "vfc-modus-3dlinie-fallback": "Linie", "vfc-modus-3dlinie-header": "\n\n>>> MODUS: 3D-Linie auswaehlen <<<", - "vfc-modus-werteingabe-header": "\n\n>>> MODUS: Manuelle Werteingabe <<<", "vfc-objekt-block-waehlen": "\n >> Objekt (Block) waehlen: ", - "vfc-prompt-delta-h": "\n%1H - Hoehenunterschied (mm): ", - "vfc-prompt-delta-l": "\n%1L - Horizontale Distanz (mm): ", "vfc-prompt-startpunkt-aus": "\nStartpunkt fuer AUS_Element waehlen: ", "vfc-prompt-wahl-1-2-ohne-default": "\nIhre Wahl (1/2): ", "vfc-status-ok": " OK", @@ -540,25 +527,7 @@ "vfc-prompt-wahl-1-n": "\nIhre Wahl (1-%1) [1]: ", "vfc-typ-gewaehlt": "\n>>> Typ: %1", "vfc-naechste-vf-nummer": "\n>>> Naechste VF-Nummer: VF%1", - "vfc-seite-header": "\n\nSeite waehlen:", - "vfc-seite-rechts": "\n 1 - Rechts", - "vfc-seite-links": "\n 2 - Links", - "vfc-seite-gewaehlt": "\n>>> Seite: %1", - "vfc-hinweis-horizontal-moeglich": "\n\n>>> Hinweis: Ein horizontale Variofoerderer ( 0%1) ist bei diesem %2L/%2H zusaetzlich moeglich!", "vfc-alert-kein-winkel": "Kein passender Winkel gefunden!\n%1L=%2 mm, %1H=%3 mm, Richtung=%4", - "vfc-einzige-variante-horizontal": "\n\n>>> Einzige gueltige Variante: Horizontale Variofoerderer", - "vfc-einziger-winkel": "\n\n>>> Einziger gueltiger Winkel: %1%2", - "vfc-mehrere-winkel-header": "\n\nMehrere gueltige Winkel verfuegbar. Bitte waehlen:", - "vfc-winkel-option-horizontal": "\n %1 - Horizontale Variofoerderer (0%2) (L_GF=%3 mm, L_VF=%4 mm)", - "vfc-winkel-option": "\n %1 - %2%3 (L_GF=%4 mm, L_VF=%5 mm)", - "vfc-prompt-winkel-waehlen": "Winkel waehlen (1-%1) [1]: ", - "vfc-zus-horizontal": "\n>>> Horizontale Variofoerderer L_GF: %1 mm L_VF: %2 mm", - "vfc-zus-winkel": "\n>>> Winkel: %1%2 L_GF: %3 mm L_VF: %4 mm", - "vfc-prompt-lgf1-vorne": "\nL_GF1 vorne (mm) [%1]: ", - "vfc-lgf2-hinten": "\n L_GF2 hinten: %1 mm", - "vfc-zus-lgf": "\n>>> L_GF1=%1 mm L_GF2=%2 mm", - "vfc-einfuegen-frage": "\n\nMoechten Sie die Foerderanlage einfuegen?", - "vfc-einfuegen-optionen": "\n 1 - Ja, Module einfuegen\n 2 - Nein, abbrechen", "vfc-vorgang-abgebrochen": "\nVorgang abgebrochen.", "vfs-dlg-richtung-auf": "Auf", "vfs-dlg-richtung-ab": "Ab", @@ -808,6 +777,7 @@ "gf-status-deltah-3dpunkte": "\n %1H aus 3D-Punkten: %2 mm", "gf-status-sortiere-segmente": "\n Sortiere Segmente ...", "gf-alert-keine-kette": "Keine verbundene Kette gefunden!", + "gf-alert-lz-edit-kein-dialog": "Bearbeiten einer Streckengruppe (Linienzug) braucht die GUI - bitte GUI einschalten (ssg-gui-an) und erneut versuchen.", "gf-status-segmente-gefunden": " %1 Segmente gefunden.", "gf-status-segment-analyse-header": "\n\n--- Segment-Analyse (Laengen nach Kuerzung) ---", "gf-status-segment-linie": "\n %1. Linie L=%2 mm hz=%3%4", @@ -846,6 +816,7 @@ "gf-dlg-richtung-270": "270%1 (Y-, Sued)", "gf-dlg-links": "Links", "gf-dlg-rechts": "Rechts", + "gf-dlg-linienzug-vorlauf": "Linienzug ausgewaehlt - Winkel wird nach Bestaetigung berechnet.", "gf-status-gf-block-erstellt": "\n>>> GF-Block erstellt: %1 (%2)", "gf-status-schritt1-aus": "\n\n1/4: %1 Fahrtrichtung=%2%3 KS_EIN-hz=%4%5 v=%6%7", "gf-status-schritt2-staustrecke": "\n\n2/4: Staustrecke L=%1 mm hz=%2%3 v=%4%5", @@ -946,13 +917,11 @@ "vfc-linienzug-modus-1": "\n 1 - Manuelle Eingabe (Punkte klicken)", "vfc-linienzug-modus-2": "\n 2 - 3D-Objekte + Ziel-Hoehe (Randwert-Solver, fertig)", "vfc-linienzug-modus-3": "\n 3 - 3D-Objekte stueckweise (Vorwaerts-Nachbau, in Arbeit)", - "vfc-linienzug-modus-4": "\n 4 - QC Linie mit GF (automatische Auf-Ab-Berechnung)", - "vfc-linienzug-modus-5": "\n 5 - QC Linie mit GF und U-Form", - "prompt-wahl-1-5": "\nIhre Wahl (1/2/3/4/5) [1]: ", + "prompt-wahl-1-3": "\nIhre Wahl (1/2/3) [1]: ", "vfl-qc-uform-nicht-implementiert": "\nFEHLER: 'QC Linie mit GF und U-Form' ist noch nicht implementiert - bitte Option 4 oder einen anderen Modus waehlen.", "vfc-typ-standard-beschreibung": "Standard VarioFoerderer (AS/ES 90 Grad, horizontal versetzt)", "vfc-typ-etage-beschreibung": "Etage VarioFoerderer (AS/ES 30 Grad, direkt uebereinander)", - "vfc-typ-linienzug-beschreibung": "3D-Linienzug (gemischte GF/VF-Kette; Modus 1 manuell / Modus 2 Ziel-Hoehe fertig / Modus 3 stueckweise in Arbeit)", + "vfc-typ-linienzug-beschreibung": "Streckengruppe (gemischte GF/VF-Kette; Modus 1 manuell / Modus 2 Ziel-Hoehe fertig / Modus 3 stueckweise in Arbeit)", "vfs-schritt6-horizontal": "\n\n6/11: Horizontale Zwischenstrecke (0 Grad, L=%1 mm)", "vfs-schritt6-steigung": "\n\n6/11: Steigungsstrecke (%1 Grad, L=%2 mm)", "vfs-schritt6-gefaelle": "\n\n6/11: Gefaellestrecke (%1 Grad, L=%2 mm)", @@ -1042,5 +1011,59 @@ "gr-tr-beschr-ergebnis": "\n%1 Traeger beschriftet (davon %2 ohne bekannte Variante), %3 nicht beschriftbar, %4 verwaiste Beschriftungen entfernt.", "gr-tr-beschr-keine": "\nKeine Rohr-Geruest-Traeger in der Zeichnung.", "gr-tr-strebe-rand": "Traeger %1 mm: Der Randabstand der Querstreben betraegt %2 mm und liegt ausserhalb des erlaubten Bereichs %3 bis %4 mm (Strebenabstand %5 mm, %6 Streben). Der Traeger wird trotzdem eingefuegt." + "in-yesno-keys": "Ja Nein", + "in-keys-bereich": "Alle Auswahl", + "in-keys-modus": "Teil Gesamt", + "bt-prompt-muster": "\nBlockname oder Muster (z.B. GR_*): ", + "bt-kein-block": "\nDas gewaehlte Objekt ist keine Blockeinfuegung.", + "bt-prompt-waehlen-count": "\nBlock waehlen [Name/Muster] : ", + "bt-count-keine": "\nKeine Einfuegungen von %1 gefunden.", + "bt-count-keine-alle": "\nKeine Blockeinfuegungen im aktuellen Layout.", + "bt-count-ergebnis": "\n%1 Einfuegung(en) von %2.", + "bt-count-zeile": "\n %1: %2", + "bt-count-summe": "\nGesamt: %1 Einfuegung(en) in %2 Block(s).", + "bt-prompt-waehlen-delete": "\nZu loeschenden Block waehlen [Name/Muster]: ", + "bt-delete-kein-muster": "\nKein Block gewaehlt - nichts geloescht.", + "bt-delete-alle-gesperrt": "\nAlle %1 Einfuegung(en) liegen auf gesperrten Layern - nichts geloescht.", + "bt-delete-frage": "%1 Einfuegung(en) von %2 loeschen?", + "bt-delete-titel": "Bloecke loeschen", + "bt-delete-ergebnis": "\n%1 Einfuegung(en) geloescht.", + "bt-delete-gesperrt": "\n%1 Einfuegung(en) auf gesperrten Layern blieben stehen.", + "bt-abgebrochen": "\nAbgebrochen - nichts geaendert.", + "bt-attr-bereich": "\nBereich", + "bt-attr-muster": "\nBlockname-Muster", + "bt-attr-auswahl": "\nBloecke waehlen: ", + "bt-attr-keine-bloecke": "\nKeine passenden Blockeinfuegungen gefunden.", + "bt-attr-tag": "\nAttribut-Tag (Muster)", + "bt-attr-suche": "\nSuchen nach", + "bt-attr-ersatz": "\nErsetzen durch", + "bt-attr-modus": "\nErsetzen als", + "bt-attr-nichts": "\nKein Attributwert enthaelt den Suchtext.", + "bt-attr-frage": "%1 Attributwert(e) in %2 Block(s) aendern?", + "bt-attr-titel": "Attribute ersetzen", + "bt-attr-ergebnis": "\n%1 Attributwert(e) geaendert.", + "tt-bereich": "\nBereich", + "tt-auswahl": "\nObjekte waehlen: ", + "tt-keine-objekte": "\nKeine passenden Objekte gefunden.", + "tt-suche": "\nSuchen nach", + "tt-ersatz": "\nErsetzen durch", + "tt-modus": "\nErsetzen als", + "tt-nichts": "\nKein Text und kein Attributwert enthaelt den Suchtext.", + "tt-frage": "%1 Text(e) und %2 Attributwert(e) aendern?", + "tt-ersetzen-titel": "Text ersetzen", + "tt-ergebnis": "\n%1 Text(e) und %2 Attributwert(e) geaendert.", + "tt-abgebrochen": "\nAbgebrochen - nichts geaendert.", + "tt-parallel-titel": "Text parallel beschriften", + "tt-hoehe": "\nTexthoehe", + "tt-abstand": "\nAbstand zur Linie", + "tt-parallel-waehlen": "\nLinie, Polylinie oder Bogen waehlen (Enter = Ende): ", + "tt-parallel-keine-kurve": "\nWinkel am gewaehlten Objekt nicht ermittelbar.", + "tt-text": "\nText", + "tt-parallel-fehler": "\nText konnte nicht erzeugt werden.", + "tt-hoehe-titel": "Texthoehe aendern", + "tt-geaendert": "\n%1 Text(e) geaendert.", + "tt-stil": "\nTextstil", + "tt-stil-fehlt": "\nTextstil %1 existiert nicht in der Zeichnung.", + "tt-stil-titel": "Textstil aendern" } } diff --git a/lang/en_GB.json b/lang/en_GB.json index 7a94884..78f8f2e 100644 --- a/lang/en_GB.json +++ b/lang/en_GB.json @@ -245,6 +245,8 @@ "vfl-m3-abweichung": "\n Deviation: dX=%1 dY=%2 dZ=%3 mm", "vfl-m3-laengs-quer": "\n Along KS_AUS axis: %1 mm | across axis (should be ~0): %2 mm", "vfl-m3-achse-hinweis": "\n (dZ=target height; across KS_AUS axis ~0 => end point lies on the axis)", + "vfl-m3-ziel-soll-es-korrigiert": "\n Target (ES-corrected): X=%1 Y=%2 Z=%3 (target + known ES lateral offset)", + "vfl-m3-abweichung-es-korrigiert": "\n Deviation (ES-corrected): dX=%1 dY=%2 dZ=%3 mm", "gf-fehler-block-fehlt": "\n ERROR: block '%1' missing", "gf-fehler-block-fehlt-ausruf": "\n ERROR: block '%1' missing!", "gf-fehler-blockdatei-fehlt": "\n ERROR: block file not found: %1", @@ -330,7 +332,6 @@ "vfc-delta-l-h-richtung": "\n %1L=%2 mm %1H=%3 mm Travel direction=%4%5", "vfc-endpunkt-xyz": "\n KS_AUS: X=%1 Y=%2 Z=%3", "vfc-endpunkt-xyz-dxdz": "\n KS_AUS: X=%1 Y=%2 Z=%3 (dx=%4 dz=%5)", - "vfc-fahrtrichtung-ergebnis": "\n>>> Travel direction: %1%2", "vfc-fehler-block-datei-fehlt": "\n ERROR: block file not found: %1", "vfc-fehler-block-nicht-in-bibliothek": "\n ERROR: block '%1' not in library", "vfc-fehler-block-nicht-in-bibliothek-abgebrochen": "\n ERROR: block '%1' not in library - cancelled", @@ -500,32 +501,18 @@ "vfc-alert-keine-gueltige-linie": "No valid line selected!", "vfc-bitte-3dlinie-foerderstrecke": "\nPlease select a 3D line for the conveyor section:", "vfc-bks-weltkoordinaten": "\n UCS set to world coordinates.", + "vfc-dlg-startpunkt-kopf": "Select start point of the system (X/Y):", "vfc-eingabemodus-3dlinie": "\n 1 - Select 3D line (start and end point with height)", "vfc-eingabemodus-header": "\n\nSelect input mode:", "vfc-eingabemodus-werte": "\n 2 - Enter values manually", - "vfc-fahrtrichtung-0": "\n 1 - 0%1 (X axis +, East)", - "vfc-fahrtrichtung-180": "\n 3 - 180%1 (X axis -, West)", - "vfc-fahrtrichtung-270": "\n 4 - 270%1 (Y axis -, South)", - "vfc-fahrtrichtung-90": "\n 2 - 90%1 (Y axis +, North)", - "vfc-fahrtrichtung-header": "\n\nSelect travel direction:", "vfc-fehler-keine-linie": "\n ERROR: No line or polyline selected!", "vfc-foerderrichtung-ab": "\n Conveying direction: DOWN", "vfc-foerderrichtung-auf": "Up", - "vfc-foerderrichtung-menu": "\nConveying direction:\n 1 - UP\n 2 - DOWN", - "vfc-gf-verteilung-header": "\n\nDistribution of slope sections (front/rear):", - "vfc-gf-verteilung-1": "\n 1 - Even (L_GF1 = L_GF2 = L_GF/2)", - "vfc-gf-verteilung-2": "\n 2 - Front minimum, rear remainder", - "vfc-gf-verteilung-3": "\n 3 - Rear minimum, front remainder", - "vfc-gf-verteilung-4": "\n 4 - Enter custom values", "vfc-kein-objekt-gewaehlt": "\n No object selected.", "vfc-label-von-bis": ": from %1mm to %2mm, ", "vfc-linie-polylinie-waehlen": "\n >> Select 3D line or polyline: ", - "vfc-modus-3dlinie-fallback": "Line", "vfc-modus-3dlinie-header": "\n\n>>> MODE: Select 3D line <<<", - "vfc-modus-werteingabe-header": "\n\n>>> MODE: Manual value entry <<<", "vfc-objekt-block-waehlen": "\n >> Select object (block): ", - "vfc-prompt-delta-h": "\n%1H - height difference (mm): ", - "vfc-prompt-delta-l": "\n%1L - horizontal distance (mm): ", "vfc-prompt-startpunkt-aus": "\nSelect start point for AUS_Element: ", "vfc-prompt-wahl-1-2-ohne-default": "\nYour choice (1/2): ", "vfc-status-ok": " OK", @@ -540,25 +527,7 @@ "vfc-prompt-wahl-1-n": "\nYour choice (1-%1) [1]: ", "vfc-typ-gewaehlt": "\n>>> Type: %1", "vfc-naechste-vf-nummer": "\n>>> Next VF number: VF%1", - "vfc-seite-header": "\n\nSelect side:", - "vfc-seite-rechts": "\n 1 - Right", - "vfc-seite-links": "\n 2 - Left", - "vfc-seite-gewaehlt": "\n>>> Side: %1", - "vfc-hinweis-horizontal-moeglich": "\n\n>>> Note: a horizontal VarioFoerderer ( 0%1) is additionally possible for this %2L/%2H!", "vfc-alert-kein-winkel": "No suitable angle found!\n%1L=%2 mm, %1H=%3 mm, direction=%4", - "vfc-einzige-variante-horizontal": "\n\n>>> Only valid variant: horizontal VarioFoerderer", - "vfc-einziger-winkel": "\n\n>>> Only valid angle: %1%2", - "vfc-mehrere-winkel-header": "\n\nSeveral valid angles available. Please choose:", - "vfc-winkel-option-horizontal": "\n %1 - Horizontal VarioFoerderer (0%2) (L_GF=%3 mm, L_VF=%4 mm)", - "vfc-winkel-option": "\n %1 - %2%3 (L_GF=%4 mm, L_VF=%5 mm)", - "vfc-prompt-winkel-waehlen": "Select angle (1-%1) [1]: ", - "vfc-zus-horizontal": "\n>>> Horizontal VarioFoerderer L_GF: %1 mm L_VF: %2 mm", - "vfc-zus-winkel": "\n>>> Angle: %1%2 L_GF: %3 mm L_VF: %4 mm", - "vfc-prompt-lgf1-vorne": "\nL_GF1 front (mm) [%1]: ", - "vfc-lgf2-hinten": "\n L_GF2 rear: %1 mm", - "vfc-zus-lgf": "\n>>> L_GF1=%1 mm L_GF2=%2 mm", - "vfc-einfuegen-frage": "\n\nDo you want to insert the conveyor system?", - "vfc-einfuegen-optionen": "\n 1 - Yes, insert modules\n 2 - No, cancel", "vfc-vorgang-abgebrochen": "\nProcess cancelled.", "vfs-dlg-richtung-auf": "Up", "vfs-dlg-richtung-ab": "Down", @@ -808,6 +777,7 @@ "gf-status-deltah-3dpunkte": "\n %1H from 3D points: %2 mm", "gf-status-sortiere-segmente": "\n Sorting segments ...", "gf-alert-keine-kette": "No connected chain found!", + "gf-alert-lz-edit-kein-dialog": "Editing a chain group (path-built) requires the GUI - please enable the GUI (ssg-gui-an) and try again.", "gf-status-segmente-gefunden": " %1 segments found.", "gf-status-segment-analyse-header": "\n\n--- Segment analysis (lengths after trimming) ---", "gf-status-segment-linie": "\n %1. Line L=%2 mm hz=%3%4", @@ -846,6 +816,7 @@ "gf-dlg-richtung-270": "270%1 (Y-, South)", "gf-dlg-links": "Left", "gf-dlg-rechts": "Right", + "gf-dlg-linienzug-vorlauf": "Path selected - angle will be calculated after confirmation.", "gf-status-gf-block-erstellt": "\n>>> GF block created: %1 (%2)", "gf-status-schritt1-aus": "\n\n1/4: %1 travel dir=%2%3 KS_EIN-hz=%4%5 v=%6%7", "gf-status-schritt2-staustrecke": "\n\n2/4: Buffer section L=%1 mm hz=%2%3 v=%4%5", @@ -946,13 +917,11 @@ "vfc-linienzug-modus-1": "\n 1 - Manual entry (click points)", "vfc-linienzug-modus-2": "\n 2 - 3D objects + target height (boundary-value solver, finished)", "vfc-linienzug-modus-3": "\n 3 - 3D objects step by step (forward reconstruction, work in progress)", - "vfc-linienzug-modus-4": "\n 4 - QC line with GF (automatic up/down calculation)", - "vfc-linienzug-modus-5": "\n 5 - QC line with GF and U-shape", - "prompt-wahl-1-5": "\nYour choice (1/2/3/4/5) [1]: ", + "prompt-wahl-1-3": "\nYour choice (1/2/3) [1]: ", "vfl-qc-uform-nicht-implementiert": "\nERROR: 'QC line with GF and U-shape' is not yet implemented - please choose option 4 or a different mode.", "vfc-typ-standard-beschreibung": "Standard VarioFoerderer (AS/ES 90 degrees, offset horizontally)", "vfc-typ-etage-beschreibung": "Etage VarioFoerderer (AS/ES 30 degrees, directly stacked)", - "vfc-typ-linienzug-beschreibung": "3D line path (mixed GF/VF chain; mode 1 manual / mode 2 target height finished / mode 3 step by step work in progress)", + "vfc-typ-linienzug-beschreibung": "Route group (mixed GF/VF chain; mode 1 manual / mode 2 target height finished / mode 3 step by step work in progress)", "vfs-schritt6-horizontal": "\n\n6/11: Horizontal intermediate section (0 deg, L=%1 mm)", "vfs-schritt6-steigung": "\n\n6/11: Incline section (%1 deg, L=%2 mm)", "vfs-schritt6-gefaelle": "\n\n6/11: Slope section (%1 deg, L=%2 mm)", @@ -1042,5 +1011,59 @@ "gr-tr-beschr-ergebnis": "\n%1 beam(s) labelled (%2 without known variant), %3 not labellable, %4 orphaned label(s) removed.", "gr-tr-beschr-keine": "\nNo pipe scaffold beams in the drawing.", "gr-tr-strebe-rand": "Beam %1 mm: the edge distance of the cross braces is %2 mm, outside the allowed range %3 to %4 mm (brace spacing %5 mm, %6 braces). The beam is inserted anyway." + "in-yesno-keys": "Yes No", + "in-keys-bereich": "All Selection", + "in-keys-modus": "Part Whole", + "bt-prompt-muster": "\nBlock name or pattern (e.g. GR_*): ", + "bt-kein-block": "\nThe selected object is not a block reference.", + "bt-prompt-waehlen-count": "\nSelect block [Name/pattern] : ", + "bt-count-keine": "\nNo references of %1 found.", + "bt-count-keine-alle": "\nNo block references in the current layout.", + "bt-count-ergebnis": "\n%1 reference(s) of %2.", + "bt-count-zeile": "\n %1: %2", + "bt-count-summe": "\nTotal: %1 reference(s) in %2 block(s).", + "bt-prompt-waehlen-delete": "\nSelect block to delete [Name/pattern]: ", + "bt-delete-kein-muster": "\nNo block selected - nothing deleted.", + "bt-delete-alle-gesperrt": "\nAll %1 reference(s) are on locked layers - nothing deleted.", + "bt-delete-frage": "Delete %1 reference(s) of %2?", + "bt-delete-titel": "Delete blocks", + "bt-delete-ergebnis": "\n%1 reference(s) deleted.", + "bt-delete-gesperrt": "\n%1 reference(s) on locked layers were kept.", + "bt-abgebrochen": "\nCancelled - nothing changed.", + "bt-attr-bereich": "\nScope", + "bt-attr-muster": "\nBlock name pattern", + "bt-attr-auswahl": "\nSelect blocks: ", + "bt-attr-keine-bloecke": "\nNo matching block references found.", + "bt-attr-tag": "\nAttribute tag (pattern)", + "bt-attr-suche": "\nFind", + "bt-attr-ersatz": "\nReplace with", + "bt-attr-modus": "\nReplace as", + "bt-attr-nichts": "\nNo attribute value contains the search text.", + "bt-attr-frage": "Change %1 attribute value(s) in %2 block(s)?", + "bt-attr-titel": "Replace attributes", + "bt-attr-ergebnis": "\n%1 attribute value(s) changed.", + "tt-bereich": "\nScope", + "tt-auswahl": "\nSelect objects: ", + "tt-keine-objekte": "\nNo matching objects found.", + "tt-suche": "\nFind", + "tt-ersatz": "\nReplace with", + "tt-modus": "\nReplace as", + "tt-nichts": "\nNo text or attribute value contains the search text.", + "tt-frage": "Change %1 text(s) and %2 attribute value(s)?", + "tt-ersetzen-titel": "Replace text", + "tt-ergebnis": "\n%1 text(s) and %2 attribute value(s) changed.", + "tt-abgebrochen": "\nCancelled - nothing changed.", + "tt-parallel-titel": "Label parallel to line", + "tt-hoehe": "\nText height", + "tt-abstand": "\nDistance to line", + "tt-parallel-waehlen": "\nSelect line, polyline or arc (Enter = finish): ", + "tt-parallel-keine-kurve": "\nCannot determine the angle on the selected object.", + "tt-text": "\nText", + "tt-parallel-fehler": "\nText could not be created.", + "tt-hoehe-titel": "Change text height", + "tt-geaendert": "\n%1 text(s) changed.", + "tt-stil": "\nText style", + "tt-stil-fehlt": "\nText style %1 does not exist in the drawing.", + "tt-stil-titel": "Change text style" } } diff --git a/lib/dxf_anlage_export.py b/lib/dxf_anlage_export.py new file mode 100644 index 0000000..62ad022 --- /dev/null +++ b/lib/dxf_anlage_export.py @@ -0,0 +1,413 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +dxf_anlage_export.py - Eine mit unseren Makros GEBAUTE (und von Hand +nachbearbeitete) Anlage aus der Zeichnung zurueck in Nachbau-Testdaten +schreiben. + +Gegenstueck zu lib/dxf_scan_components.py: der Scanner liest FREMDE +Zeichnungen (Rohbloecke, Linien) und muss vieles raten. Hier stehen unsere +Wrapper-Bloecke in der Zeichnung, und jeder traegt seine Bau-Parameter +selbst - als Attribute und XDATA, genau die Werte, die auch der jeweilige +Edit-Befehl (Doppelklick) zum Neuaufbau liest. Typischer Ablauf: Scanner- +Vorlage nachbauen, in BricsCAD von Hand korrigieren/ergaenzen, Zeichnung als +DXF speichern und mit diesem Skript die Testdaten aktualisieren. + +Je Wrapper (Felder wie in tests/testdata/object_data.md bzw. mubea.json): + + KREISEL_n -> Kreisel ("function": "insert", x/y/z = Einfuegepunkt, + abstand = Mittenabstand AN8-SP8 aus der Blockdefinition, + rotation, typ = KREISELART, drehrichtung = DREHRICHTUNG) + GF_n -> Gefaellestrecke Modus 1 (XDATA SSG_GF_EDIT wie + gf-xdata-lesen + SEITE_AS/SEITE_ES wie GEFAELLESTRECKE_EDIT). + Endet die Strecke auf der Kette eines Kreisels, wird statt + des gebauten Winkels dessen Hoehe als hoehe_ende_mm + uebernommen - der Treiber rechnet den Winkel daraus neu. + VF_n "standard"/"etage" + -> VarioFoerderer im mubea-Schema (Parameter wie + vfs-edit-basis-lesen: Einfuegepunkt, hz aus XDATA, DELTA_L/ + DELTA_H/ANTRIEBFAHRTRICHTUNG/SEITE_AS/MOTORSEITE, dazu + VF_WINKEL und L_GF1 aus L_GF_m) + VF_n "linienzug" + -> das Eingabe-Journal UNVERAENDERT ("typ": + "linienzug_journal"). Bewusst KEINE Spec: der Bau-Dialog ist + neuer als die Spec-Grammatik (vf_linienzug_grammatik.py, + vf_spec.lsp), eine Uebersetzung wuerde desynchronisieren. + Der Treiber spielt das Journal per vsp-bau-journal ab. + sonstige Bloecke (Separator, Scanner, ...) + -> Einzel-Insert ("function": "insert", "block" ohne + _2D/_3D-Suffix, damit die Dimension der Sitzung gilt) + +Nicht uebernommen (gemeldet): "linienzug2" (Modus 2 - Journal verweist auf +Pfad-Objekte der Zeichnung per Handle) und Bloecke ohne Bau-Parameter. + +Aufruf: + python dxf_anlage_export.py [--projekt NAME] + +Beispiel (Dematic/Arvato, Nachbau-Daten fuer TEST_DEMATIC_ARVATO): + python lib/dxf_anlage_export.py C:/develop/sps_skel/data/Dematic_TST.dxf \\ + tests/testdata/dematic_arvato.json --projekt Arvato + +Bewusst OHNE ezdxf: reine Gruppencode-Lesung (vf_journal_export.gruppen), +ASCII-DXF. +""" + +import argparse +import collections +import json +import math +import os +import re +import sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from vf_journal_export import TRENNER, gruppen # noqa: E402 +from dxf_scan_components import arrays_einzeilig, kreisel_anschluss # noqa: E402 +import testdata_schema as sch # noqa: E402 + +PREFIX = "[dxf_anlage_export]" +RUND = 2 + +# Kreisel-Durchmesser (Radmitte bis Kette), wie component_defaults.json. +KREISEL_RADIUS = 400.0 + +# Bis zu diesem Abstand (mm) gilt ein GF-Ende als auf der Kette eines +# Kreisels (der GF-Bau legt AS-/ES-Ursprung genau auf die Kette). +GF_KREISEL_TOL = 50.0 + +DIM_SUFFIX = re.compile(r"_(2D|3D)$") + + +# ============================================================ +# DXF lesen +# ============================================================ + +def _float(v): + try: + return float(v) + except (TypeError, ValueError): + return 0.0 + + +def lese_zeichnung(dxf_pfad): + """Modelspace-INSERTs (mit Attributen und XDATA je App) und die INSERTs + jeder Blockdefinition. + + Rueckgabe: (inserts, block_inhalt) + inserts - Liste {name, handle, p, rot, attribs, xdata}; xdata ist + app -> Liste der 1000er-Werte in Reihenfolge + block_inhalt - blockname -> Liste {name, p} der direkt enthaltenen + INSERTs (fuer den Kreisel-Mittenabstand) + """ + paare = gruppen(dxf_pfad) + inserts = [] + block_inhalt = {} + section = None + block = None + i, n = 0, len(paare) + while i < n: + code, wert = paare[i] + if code != "0": + i += 1 + continue + if wert == "SECTION" and i + 1 < n: + section = paare[i + 1][1].strip() + elif wert == "ENDSEC": + section = None + elif wert == "BLOCK": + j = i + 1 + while j < n and paare[j][0] != "0": + if paare[j][0] == "2": + block = paare[j][1] + break + j += 1 + elif wert == "ENDBLK": + block = None + elif wert == "INSERT" and section in ("ENTITIES", "BLOCKS"): + e = {"name": None, "handle": None, "p": [0.0, 0.0, 0.0], + "rot": 0.0, "attribs": {}, "xdata": {}, "ps": 0} + app = None + j = i + 1 + while j < n and paare[j][0] != "0": + c, v = paare[j] + if c == "2" and e["name"] is None: + e["name"] = v + elif c == "5" and e["handle"] is None: + e["handle"] = v + elif c in ("10", "20", "30") and app is None: + e["p"][{"10": 0, "20": 1, "30": 2}[c]] = _float(v) + elif c == "50": + e["rot"] = _float(v) + elif c == "67": + e["ps"] = int(_float(v)) + elif c == "1001": + app = v + e["xdata"][app] = [] + elif c == "1000" and app: + e["xdata"][app].append(v) + j += 1 + # Attribute: ATTRIB-Entities bis SEQEND (Wert Code 1, Tag Code 2) + while j < n and paare[j] == ("0", "ATTRIB"): + k = j + 1 + tag = val = None + while k < n and paare[k][0] != "0": + if paare[k][0] == "2" and tag is None: + tag = paare[k][1] + elif paare[k][0] == "1" and val is None: + val = paare[k][1] + k += 1 + if tag: + e["attribs"][tag] = val if val is not None else "" + j = k + if section == "ENTITIES": + if e["ps"] != 1: + inserts.append(e) + elif block: + block_inhalt.setdefault(block, []).append( + {"name": e["name"], "p": e["p"]}) + i = j + continue + i += 1 + return inserts, block_inhalt + + +# ============================================================ +# Wrapper -> Eintraege +# ============================================================ + +def _nummer(name): + m = re.search(r"_(\d+)", name) + return int(m.group(1)) if m else 0 + + +def _r(v): + return round(float(v), RUND) + 0.0 + + +def _richtung(hz): + rad = math.radians(hz) + return (math.cos(rad), math.sin(rad)) + + +def kreisel_eintrag(e, block_inhalt, projekt): + """Kreisel wie hundm05:bau-kreisel ihn erwartet.""" + a = e["attribs"] + abstand = _float(a.get("ABSTAND")) + quelle = "Attribut ABSTAND (ganze mm)" + # Genauer aus der Blockdefinition: Mittenabstand der beiden Stationen + stationen = [s for s in block_inhalt.get(e["name"], []) + if s["name"] and s["name"].upper().startswith(("AN8", "SP8"))] + an = [s for s in stationen if s["name"].upper().startswith("AN8")] + sp = [s for s in stationen if s["name"].upper().startswith("SP8")] + if an and sp: + abstand = math.hypot(sp[0]["p"][0] - an[0]["p"][0], + sp[0]["p"][1] - an[0]["p"][1]) + quelle = "Blockdefinition (AN8 -> SP8)" + nr = int(_float(a.get("NUMMER"))) or _nummer(e["name"]) + return collections.OrderedDict([ + (sch.F_ID, "Kreisel_%s_%02d" % (projekt, nr)), + (sch.F_FUNCTION, sch.FUNC_INSERT), + (sch.F_X, _r(e["p"][0])), (sch.F_Y, _r(e["p"][1])), (sch.F_Z, _r(e["p"][2])), + (sch.F_ABSTAND, _r(abstand)), + (sch.F_ROTATION, _r(e["rot"])), + (sch.F_TYP, a.get("KREISELART") or sch.TYP_STANDARD), + # Umlaufsinn: bestimmt die Reihenfolge im Kreisel-Umlauf und damit den + # TRO-Fluss - ohne ihn kam jeder Nachbau als UZS heraus (Dematic 1/4: + # GUZ). hundm05:bau-kreisel reicht ihn an kreisel-insert-script weiter. + (sch.F_DREHRICHTUNG, a.get("DREHRICHTUNG") or sch.DREHRICHTUNG_UZS), + (sch.F_COMMENT, "aus Zeichnung: %s (ID %s), abstand aus %s" + % (e["name"], a.get("ID", "?"), quelle)), + ]) + + +def kreisel_geo(kreisel): + """kreisel_geo-Form (siehe dxf_scan_components.kreisel_anschluss) aus + einem Kreisel-Eintrag: Achse ab AN8-Radmitte = Einfuegepunkt + Radius.""" + u = _richtung(kreisel["rotation"]) + return {"id": kreisel["id"], + "a": (kreisel["x"] + KREISEL_RADIUS * u[0], + kreisel["y"] + KREISEL_RADIUS * u[1]), + "u": u, "laenge": kreisel["abstand"], "r": KREISEL_RADIUS, + "z": kreisel["z"]} + + +def kreisel_an_punkt(p, richtung, geo): + """Kreisel, auf dessen Kette p liegt (oder None).""" + ans = kreisel_anschluss(p, richtung, geo) + if ans and abs(ans[2]) <= GF_KREISEL_TOL: + return ans[0] + return None + + +def gf_eintrag(e, geo, projekt, hinweise): + """Gefaellestrecke Modus 1 - Felder wie GEFAELLESTRECKE_EDIT sie liest.""" + a = e["attribs"] + xd = e["xdata"].get("SSG_GF_EDIT") + if not xd or len(xd) < 6: + hinweise.append("%s ohne SSG_GF_EDIT-XDATA - uebersprungen" % e["name"]) + return None + hz, winkel = _float(xd[0]), _float(xd[1]) + z_start, deltaL = _float(xd[4]), _float(xd[5]) + start = (e["p"][0], e["p"][1]) + r = _richtung(hz) + ende = (start[0] + deltaL * r[0], start[1] + deltaL * r[1]) + eintrag = collections.OrderedDict([ + (sch.F_TEST_ID, "GF_%s_%02d" % (projekt, _nummer(e["name"]))), + (sch.F_MODUS, sch.GF_MODUS_WERTEINGABE), + (sch.F_DELTAL_MM, _r(deltaL)), + (sch.F_HZ_GRAD, _r(hz)), + (sch.F_START_MM, [_r(start[0]), _r(start[1]), _r(z_start)]), + (sch.F_AS_SEITE, a.get("SEITE_AS") or sch.SEITE_LINKS), + (sch.F_ES_SEITE, a.get("SEITE_ES") or sch.SEITE_LINKS), + (sch.F_AS_WINKEL, xd[2] or sch.SCHLEUS_WINKEL_90), + (sch.F_ES_WINKEL, xd[3] or sch.SCHLEUS_WINKEL_90), + ]) + k_start = kreisel_an_punkt(start, r, geo) + k_ende = kreisel_an_punkt(ende, (-r[0], -r[1]), geo) + if k_start: + eintrag["kreisel_start"] = k_start["id"] + if k_ende: + eintrag["kreisel_ende"] = k_ende["id"] + eintrag["hoehe_ende_mm"] = k_ende["z"] + kommentar = ("Endhoehe = Hoehe von %s (%.1f), Winkel rechnet der " + "Treiber neu; gebaut war %.4f Grad -> HOEHE_BIS %s" + % (k_ende["id"], k_ende["z"], winkel, + a.get("HOEHE_BIS_mm", "?"))) + else: + eintrag["winkel_grad"] = round(winkel, 4) + kommentar = "kein Kreisel am Ende - gebauter Winkel uebernommen" + eintrag[sch.F_COMMENT] = "aus Zeichnung: %s (ID %s); %s" % ( + e["name"], a.get("ID", "?"), kommentar) + return eintrag + + +def vf_standard_eintrag(e, projekt, typ): + """VarioFoerderer im mubea-Schema (mubea:vario-bauen).""" + a = e["attribs"] + xd = e["xdata"].get("SSG_VF_EDIT") or [] + l_gf = [t for t in (a.get("L_GF_m") or "").split(",") if t.strip()] + eintrag = collections.OrderedDict([ + (sch.F_TEST_ID, "VF_%s_%02d" % (projekt, _nummer(e["name"]))), + (sch.F_VF_TYP, typ), + (sch.F_RICHTUNG, a.get("ANTRIEBFAHRTRICHTUNG") or sch.RICHTUNG_AUF), + (sch.F_DELTA_L, _r(_float(a.get("DELTA_L_mm")))), + (sch.F_DELTA_H, _r(_float(a.get("DELTA_H_mm")))), + (sch.F_WINKEL, int(_float(a.get("VF_WINKEL")))), + (sch.F_L_GF1, _r(1000.0 * _float(l_gf[0])) if l_gf else 0.0), + (sch.F_SEITE, a.get("SEITE_AS") or sch.SEITE_RECHTS), + (sch.F_MOTORSEITE, (a.get("MOTORSEITE") or sch.SEITE_RECHTS).split(",")[0]), + (sch.F_HZ, _r(_float(xd[1]) if len(xd) > 1 else 0.0)), + (sch.F_X, _r(e["p"][0])), (sch.F_Y, _r(e["p"][1])), (sch.F_Z, _r(e["p"][2])), + (sch.F_COMMENT, "aus Zeichnung: %s (ID %s), Hoehe %s -> %s; deltaL/" + "deltaH aus den (ganzzahligen) Attributen" + % (e["name"], a.get("ID", "?"), a.get("HOEHE_VON_mm", "?"), + a.get("HOEHE_BIS_mm", "?"))), + ]) + return eintrag + + +def vf_journal_eintrag(e, projekt, nr): + """Linienzug: Journal unveraendert (Tokens 'ART:wert').""" + a = e["attribs"] + roh = "".join(e["xdata"]["SSG_VF_EDIT"][1:]) + tokens = [t for t in roh.split(TRENNER) if t] + return collections.OrderedDict([ + (sch.F_TEST_ID, "VF_%s_LZ_%02d" % (projekt, nr)), + (sch.F_VF_TYP, "linienzug_journal"), + ("journal", tokens), + (sch.F_COMMENT, "aus Zeichnung: %s (ID %s), %d Eingaben, Hoehe %s -> %s; " + "wird 1:1 abgespielt (vsp-bau-journal)" + % (e["name"], a.get("ID", "?"), len(tokens), + a.get("HOEHE_VON_mm", "?"), a.get("HOEHE_BIS_mm", "?"))), + ]) + + +def einzel_eintrag(e): + a = e["attribs"] + info = ", ".join("%s %s" % (k, a[k]) for k in ("ID", "ZUORDNUNG", "ARTINR") + if a.get(k)) + return collections.OrderedDict([ + (sch.F_FUNCTION, sch.FUNC_INSERT), + (sch.F_BLOCK, DIM_SUFFIX.sub("", e["name"])), + (sch.F_X, _r(e["p"][0])), (sch.F_Y, _r(e["p"][1])), (sch.F_Z, _r(e["p"][2])), + (sch.F_ROTATION, _r(e["rot"])), + (sch.F_COMMENT, "aus Zeichnung: %s%s" % (e["name"], + (" (%s)" % info) if info else "")), + ]) + + +def baue_eintraege(inserts, block_inhalt, projekt): + """Reihenfolge wie mubea.json: Kreisel, VF, GF, Einzelbloecke - die VF + vor den GF, weil gf-init-bibliothek globale Elementmasse umsetzt.""" + kreisel, vf, lz, gf, einzel, hinweise = [], [], [], [], [], [] + for e in sorted(inserts, key=lambda e: (e["name"] or "", e["p"][0], e["p"][1])): + name = e["name"] or "" + if name.startswith("KREISEL_"): + kreisel.append(kreisel_eintrag(e, block_inhalt, projekt)) + geo = [kreisel_geo(k) for k in kreisel] + for e in inserts: + name = e["name"] or "" + if name.startswith("KREISEL_"): + continue + if name.startswith("GF_"): + g = gf_eintrag(e, geo, projekt, hinweise) + if g: + gf.append(g) + elif name.startswith("VF_"): + xd = e["xdata"].get("SSG_VF_EDIT") + marker = xd[0] if xd else None + if marker in ("standard", "etage"): + vf.append(vf_standard_eintrag(e, projekt, marker)) + elif marker == "linienzug": + lz.append(vf_journal_eintrag(e, projekt, len(lz) + 1)) + else: + hinweise.append("%s: Marker %r nicht nachbaubar - uebersprungen" + % (name, marker)) + elif name.startswith("*") or name.startswith("ZZ_"): + continue # anonyme Bloecke, Export-Marker + else: + einzel.append(einzel_eintrag(e)) + gf.sort(key=lambda g: g["test_id"]) + vf.sort(key=lambda v: v["test_id"]) + kreisel.sort(key=lambda k: k["id"]) + return kreisel + vf + lz + gf + einzel, hinweise + + +def main(): + p = argparse.ArgumentParser( + description="Gebaute Anlage (Wrapper-Bloecke) aus einer Zeichnung in " + "Nachbau-Testdaten schreiben.") + p.add_argument("dxf", help="Zeichnung (ASCII-DXF)") + p.add_argument("output", help="Ziel-JSON") + p.add_argument("--projekt", help="Kennung in den IDs (Default: Dateiname)") + args = p.parse_args() + if not os.path.isfile(args.dxf): + print("%s FEHLER: DXF nicht gefunden: %s" % (PREFIX, args.dxf)) + sys.exit(1) + projekt = args.projekt or os.path.splitext(os.path.basename(args.dxf))[0] + + print("%s lese %s ..." % (PREFIX, args.dxf)) + inserts, block_inhalt = lese_zeichnung(args.dxf) + eintraege, hinweise = baue_eintraege(inserts, block_inhalt, projekt) + + zaehler = collections.Counter( + "Kreisel" if sch.F_ABSTAND in e else + "GF" if sch.F_MODUS in e else + "VF Linienzug" if e.get(sch.F_VF_TYP) == "linienzug_journal" else + "VF %s" % e[sch.F_VF_TYP] if sch.F_VF_TYP in e and sch.F_TEST_ID in e else + e.get(sch.F_BLOCK, "?") for e in eintraege) + for k, v in sorted(zaehler.items()): + print("%s %-22s %d" % (PREFIX, k, v)) + for h in hinweise: + print("%s ! %s" % (PREFIX, h)) + + with open(args.output, "w", encoding="utf-8") as fh: + fh.write(arrays_einzeilig(json.dumps(eintraege, ensure_ascii=False, + indent=2))) + fh.write("\n") + print("%s %d Eintraege geschrieben -> %s" + % (PREFIX, len(eintraege), args.output)) + + +if __name__ == "__main__": + main() diff --git a/lib/dxf_scan_components.py b/lib/dxf_scan_components.py index 2cb37f2..fc03960 100644 --- a/lib/dxf_scan_components.py +++ b/lib/dxf_scan_components.py @@ -11,6 +11,11 @@ also so, dass die Anlage per JSON-Treiber mit den Produktionsmakros nachgebaut werden kann (Vorbild: tests/testdata/mubea.json, das bisher von Hand aus einem DXF abgeleitet wurde). +Gefaellestrecken, die nicht als Blockpaar, sondern als 3D-LINE auf einem +Staustrecken-Layer gezeichnet sind (GF_LINIE_LAYER), werden in einem zweiten +Lesedurchgang erkannt und als Modus-1-Eintraege (Schema 2.1) ausgegeben, +siehe gf_eintraege_aus_linien. + Aufruf: python dxf_scan_components.py [--fenster X0 Y0 X1 Y1] @@ -44,6 +49,7 @@ import struct import sys from ezdxf.lldxf.types import BINARY_DATA, INT16, INT32, INT64, DOUBLE, BYTES +from ezdxf.lldxf.types import cast_tag_value from ezdxf.math import Matrix44, OCS sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) @@ -62,6 +68,10 @@ MAX_PAAR_ABSTAND = 60000.0 # 10 mm deckt Rundungs- und Zeichenungenauigkeiten der Fremdzeichnung ab. GERADE_MAX_DELTA_H = 10.0 +# Projektkennung in den erzeugten IDs (Kreisel__01 ...); main() +# setzt sie aus --projekt bzw. dem Namen der DXF-Datei. +PROJEKT = "HundM05" + # Toleranz fuer die Dedup-Rundung (Nachkommastellen). RUND = 2 @@ -123,6 +133,52 @@ ACHSE_MAX_QUER = 1500.0 # der Antriebsstationen, ohne benachbarte Bauteile zu verwechseln. ZWILLING_MAX_ABSTAND = 1500.0 +# --- Gefaellestrecken aus Staustrecken-Linien ------------------------------- +# Manche Zeichnungen (Dematic_arvato_reduced.dxf) fuehren die Gefaellestrecke +# nicht als Blockpaar, sondern als einfache 3D-LINE auf einem Staustrecken- +# Layer vom hohen zum tiefen Kreisel (dort: 27 Linien auf "6-SP", 10654 mm +# lang, 370 mm Gefaelle). Nur Modelspace-LINEs; Muster wie FAMILIEN. +GF_LINIE_LAYER = ["6-SP"] + +# Mindest-Hoehendifferenz (mm), ab der eine Staustrecken-Linie als Gefaelle +# gilt. Darunter ist sie eine waagrechte Strecke - die liegen auf denselben +# Layern (Rueckfuehrungen, Kreisel-Verbindungen) und sind keine GF. +GF_LINIE_MIN_DZ = 100.0 + +# Suchbereich fuer das Ausschleuselement am oberen Linienende, gemessen im +# Linien-KS: "entlang" ab Linienstart in Gefaellerichtung, "quer" seitlich. +# In Dematic_arvato_reduced.dxf sitzt es 1158 mm entlang und 467 mm quer - +# der Nachbar-AS der Linie daneben (800 mm Raster) liegt nur 433 mm quer auf +# der ANDEREN Seite. Darum entscheidet die Seite aus dem Blocknamen (links/ +# rechts), nicht der kleinste Abstand. +GF_AS_MAX_ENTLANG = 2000.0 +GF_AS_MAX_QUER = 700.0 +# Wie weit (mm) das AS/ES VOR dem Linienende liegen darf, also schon auf der +# Kreisel-Seite. In Dematic_arvato liegt es innerhalb der Linie; im +# Showroom_ILS_3_0-Plan endet die Staustrecke 305 mm vor dem Element, das auf +# der Kreisel-Kette sitzt. Kleiner als das Linienraster quer zur Kette +# (Nachbar-GF der Gegenrichtung lag dort 1200 mm entfernt). +GF_AS_MAX_VOR = 800.0 +# Toleranz (mm) fuer zusammenstossende Linienenden beim Zusammenfassen +# zerstueckelter Staustrecken (linien_zusammenfassen). +GF_LINIE_STOSS_TOL = 1.0 + +# Groesste Luecke (mm) zwischen Linienende und Kreisel-Kette, bis zu der die +# Linie an diesen Kreisel angeschlossen wird. Gezeichnet ist nur die +# Staustrecke: oben fehlt das Ausschleuselement (~430 mm), unten das +# Einschleuselement (~480 mm) bis zur Kette. +GF_KREISEL_MAX_LUECKE = 1500.0 + +# Separatoren auf der GF-Achse: die Gefaellestrecke baut ihren eigenen +# (Staustrecke_Separator_SP_300_mm), der gezeichnete waere doppelt. Gilt fuer +# Vorkommen bis GF_SEP_MAX_QUER (mm) neben der Achse. +GF_SEP_MUSTER = ["S-SP", "S-LP", "Separator*"] +GF_SEP_MAX_QUER = 300.0 + +# Abstand (mm), bis zu dem eine --kreisel-hoehe X Y Z dem Kreisel mit diesem +# Einfuegepunkt (Eintrag x/y) zugeordnet wird. +KREISEL_HOEHE_TOL = 50.0 + # --------------------------------------------------------------------------- # Hilfsfunktionen @@ -190,6 +246,48 @@ def iter_binary_tags(mm): yield code, value +def iter_ascii_tags(mm): + """Streamt (code, value)-Tags aus einem ASCII-DXF. + + Gegenstueck zu iter_binary_tags fuer Zeichnungen, die als Text-DXF + gespeichert wurden (z.B. Dematic_arvato.dxf). Die Werte werden ueber die + ezdxf-Typtabelle in float/int gewandelt, damit lese_inserts dieselben + Typen sieht wie beim binaeren Lesen. + """ + i = 0 + n = len(mm) + while i < n: + end = mm.find(b"\n", i) + if end < 0: + break + code_raw = mm[i:end].strip() + i = end + 1 + end = mm.find(b"\n", i) + if end < 0: + end = n + value_raw = mm[i:end].rstrip(b"\r") + i = end + 1 + if not code_raw: + continue + code = int(code_raw) + value = decode_str(value_raw) + if code == 0: + value = value.strip() + else: + try: + value = cast_tag_value(code, value) + except ValueError: + pass + yield code, value + + +def iter_tags(mm): + """Binaer- oder ASCII-DXF anhand der Kopfzeile erkennen.""" + if mm[:22] == b"AutoCAD Binary DXF\r\n\x1a\x00": + return iter_binary_tags(mm) + return iter_ascii_tags(mm) + + # --------------------------------------------------------------------------- # Familien-Erkennung (Blockname -> Bauteilfamilie) # --------------------------------------------------------------------------- @@ -197,8 +295,8 @@ def iter_binary_tags(mm): # mit Wildcards - die Blocknamen der Fremdzeichnungen enthalten Umlaute und # Sonderzeichen (z.B. "3D_Schraegfoerderer_Antrieb", "TEF_Bogen_90Grad_..."). FAMILIEN = [ - ("kreisel_an", ["AN8", "AN8_*"]), - ("kreisel_sp", ["SP8", "SP8_*"]), + ("kreisel_an", ["AN8", "AN8_*", "AN8 Pinband*"]), + ("kreisel_sp", ["SP8", "SP8_*", "SP8 Pinband*"]), ("foerderer_antrieb", ["3D_TEF_Antrieb*", "3D_FF_Antrieb*", "3D_Schr*rderer_Antrieb*", "Antrieb FF"]), ("foerderer_umlenk", ["3D_TEF_Umlenk*", "3D_FF_Umlenk*", @@ -214,8 +312,9 @@ FAMILIEN = [ ("omniflo_weiche", ["Weiche *", "Weichen-TEF*"]), ("bogen", ["3D_ILS_Bogen_*", "3D_FF_Bogen_*", "TEF_Bogen_*", "tef30*", "tef90*"]), + # "AE-D"/"EE-R": Kurznamen der aelteren ILS-Plaene (Showroom_ILS_3_0.dxf) ("schleuselement", ["Ausschleuselement*", "Einschleuselement*", - "EE_Neu*", "AE_Neu*"]), + "EE_Neu*", "AE_Neu*", "AE-*", "EE-*"]), ("sensor", ["S-LP", "S-SP", "SCAN", "SCAN_*", "Scanner*", "Separator*", "Stopper*", "Stopperschleuse*"]), ] @@ -310,12 +409,12 @@ def mappe_block(bname): geraten) # Aus-/Einschleuselement -> AS_Element / ES_Element - if "ausschleus" in low or low.startswith("ae_"): + if "ausschleus" in low or low.startswith(("ae_", "ae-")): winkel, geschaetzt = winkel_aus_name(bname, DEFAULT_SCHLEUS_WINKEL) if geschaetzt: geraten.append("Winkel=%d" % winkel) return "AS_Element_%d_%s" % (winkel, seite_aus()), geraten - if "einschleus" in low or low.startswith("ee_"): + if "einschleus" in low or low.startswith(("ee_", "ee-")): winkel, geschaetzt = winkel_aus_name(bname, DEFAULT_SCHLEUS_WINKEL) if geschaetzt: geraten.append("Winkel=%d" % winkel) @@ -443,7 +542,7 @@ def lese_inserts(dxf_path): fh.close() raise try: - for code, value in iter_binary_tags(mm): + for code, value in iter_tags(mm): if code == 0: # Ein ATTRIB endet immer am naechsten 0-Tag. Erst hier steht # sicher fest, dass Tag UND Wert gelesen sind - in einem ATTRIB @@ -496,6 +595,19 @@ def lese_inserts(dxf_path): block_merken(aktueller_block)["kinder"].add(value) elif aktuell == "ATTRIB": attrib_tag = value + elif aktuell == "CIRCLE" and aktueller_block and code in (10, 20, 30): + # Mittelpunkt des ERSTEN Kreises der Blockdefinition merken - + # bei AN8/SP8 ist das das Rad. Die Pinband-Varianten in + # Dematic_arvato.dxf haben ihr Rad ~15 m neben dem + # Einfuegepunkt; ohne diesen Wert laege der Kreisel dort. + # Ein zweiter Kreis beginnt mit Code 10, waehrend "kreis" schon + # existiert - ab da ist der erste fertig (Code 30 ist optional). + info = block_merken(aktueller_block) + if code == 10 and "kreis" in info: + info["kreis_fertig"] = True + if not info.get("kreis_fertig"): + kreis = info.setdefault("kreis", [0.0, 0.0, 0.0]) + kreis[{10: 0, 20: 1, 30: 2}[code]] = value elif aktuell == "BLOCK" and aktueller_block and code in (10, 20, 30): block_base[aktueller_block][{10: 0, 20: 1, 30: 2}[code]] = value elif aktuell == "INSERT" and rec is not None: @@ -533,6 +645,62 @@ def lese_inserts(dxf_path): return ms_inserts, block_inserts, block_base, statistik, block_info +def lese_linien(dxf_path, layer_muster): + """Liest alle Modelspace-LINEs auf den Layern aus layer_muster. + + Eigener Durchlauf statt Erweiterung von lese_inserts: dessen Rueckgabe + nutzt auch lib/dxf_abbild.py, und die Linien braucht nur die + Gefaellestrecken-Erkennung. Kostet einen zweiten Lesedurchgang. + + Rueckgabe: Liste {"layer", "a": [x, y, z], "b": [x, y, z]} in WCS + (eine LINE ist immer in WCS angegeben, keine OCS-Umrechnung noetig). + """ + linien = [] + section = None + warte_auf_sectionname = False + rec = None + + def ablegen(r): + if r and r["ps"] != 1 and matches_any(r["layer"] or "", layer_muster): + linien.append({"layer": r["layer"], "a": r["a"], "b": r["b"]}) + + fh = io.open(dxf_path, "rb") + try: + mm = mmap.mmap(fh.fileno(), 0, access=mmap.ACCESS_READ) + except ValueError: + fh.close() + raise + try: + for code, value in iter_tags(mm): + if code == 0: + ablegen(rec) + rec = None + if value == "SECTION": + warte_auf_sectionname = True + elif value == "ENDSEC": + section = None + elif value == "LINE" and section == "ENTITIES": + rec = {"layer": None, "a": [0.0, 0.0, 0.0], + "b": [0.0, 0.0, 0.0], "ps": 0} + elif code == 2 and warte_auf_sectionname: + section = value + warte_auf_sectionname = False + elif rec is not None: + if code == 8: + rec["layer"] = value + elif code in (10, 20, 30): + rec["a"][{10: 0, 20: 1, 30: 2}[code]] = value + elif code in (11, 21, 31): + rec["b"][{11: 0, 21: 1, 31: 2}[code]] = value + elif code == 67: + rec["ps"] = value + ablegen(rec) + finally: + mm.close() + fh.close() + return linien + + def insert_matrix(rec, block_base): """Transformationsmatrix eines INSERT (inkl. Basispunkt des Zielblocks). @@ -630,6 +798,13 @@ def sammle_vorkommen(ms_inserts, block_inserts, block_base, max_tiefe=12, xachse = mat.transform((1.0, 0.0, 0.0)) - ursprung rot = math.degrees(math.atan2(xachse.y, xachse.x)) % 360.0 fam = familie_von(rec["name"]) + # Kreisel-Stationen: Position = Radmitte, nicht Einfuegepunkt + # (siehe "kreis" in lese_inserts). Die Rotation oben bleibt die + # des Inserts. + kreis = ((block_info or {}).get(rec["name"], {}).get("kreis") + if fam in ("kreisel_an", "kreisel_sp") else None) + if kreis: + ursprung = mat.transform(tuple(kreis)) if fam: treffer.append({ "familie": fam, @@ -866,6 +1041,78 @@ def zwillinge_zusammenfuehren(treffer): # Paarbildung und Schema-Abbildung # --------------------------------------------------------------------------- +# Querversatz (mm), bis zu dem AN8 und SP8 noch auf derselben Kreisel-Achse +# liegen. Beide Stationen sitzen auf der Mittellinie des Kreisels; in +# Dematic_arvato.dxf liegen echte Paare auf 0,2 mm genau auf einer Achse. +KREISEL_MAX_QUER = 100.0 + + +def kreisel_paare_bilden(an_liste, sp_liste): + """AN8 und SP8 zu Kreiseln paaren. + + Global nach Abstand (kuerzestes Paar zuerst) statt AN8 fuer AN8 in + X-Reihenfolge: dort griff sich ein frueh sortierter AN8 die naechste noch + freie SP8 eines Nachbar-Kreisels, und alle folgenden Paare rutschten mit + (Dematic_arvato: ein 33,5-m-Kreisel wurde mit der SP8 eines 3,6-m-Kreisels + 19 m daneben gepaart). Zusaetzlich muessen beide auf einer gemeinsamen + Achse liegen (Querversatz <= KREISEL_MAX_QUER). + + Danach Tausch-Nachbesserung auf minimale Abstandssumme (siehe unten). + + Rueckgabe: (paare [(an, sp, abstand)] nach AN-Position sortiert, + AN8 ohne Partner, SP8 ohne Partner) + """ + def abstand(an, sp): + """Mittenabstand, oder None wenn nicht auf gemeinsamer Achse.""" + dx = abs(sp["x"] - an["x"]) + dy = abs(sp["y"] - an["y"]) + if min(dx, dy) > KREISEL_MAX_QUER: + return None + return math.hypot(dx, dy) + + kandidaten = [] + for ia, an in enumerate(an_liste): + for isp, sp in enumerate(sp_liste): + d = abstand(an, sp) + if d is not None: + kandidaten.append((d, ia, isp)) + kandidaten.sort() + an_frei = set(range(len(an_liste))) + sp_frei = set(range(len(sp_liste))) + paare = [] + for dist, ia, isp in kandidaten: + if ia in an_frei and isp in sp_frei: + an_frei.discard(ia) + sp_frei.discard(isp) + paare.append([an_liste[ia], sp_liste[isp], dist]) + + # Nachbesserung: zwei Paare tauschen ihre SP8, solange die Summe der + # Abstaende dadurch kleiner wird. "Kuerzestes Paar zuerst" allein + # scheitert an zwei Kreiseln auf DERSELBEN Achse: die Luecke zwischen + # SP8 des einen und AN8 des anderen ist kuerzer als beide Kreisel und + # wird zuerst gepaart (Showroom_ILS_3_0: 800 + 12832 statt 9033 + 3000). + # Die echte Zuordnung hat immer die kleinere Summe - jede vertauschte + # Paarung ueberspannt mindestens eine Luecke doppelt. + verbessert = True + while verbessert: + verbessert = False + for i in range(len(paare)): + for j in range(i + 1, len(paare)): + a1, s1, d1 = paare[i] + a2, s2, d2 = paare[j] + n1, n2 = abstand(a1, s2), abstand(a2, s1) + if n1 is None or n2 is None or n1 + n2 >= d1 + d2 - 1e-6: + continue + paare[i] = [a1, s2, n1] + paare[j] = [a2, s1, n2] + verbessert = True + paare = [tuple(p) for p in paare] + paare.sort(key=lambda p: (p[0]["x"], p[0]["y"])) + return (paare, + [an_liste[i] for i in sorted(an_frei)], + [sp_liste[i] for i in sorted(sp_frei)]) + + def paare_bilden(antriebe, umlenkungen): """Gegenseitig naechste Nachbarn paaren. @@ -978,7 +1225,7 @@ def foerderer_eintrag(a, u, dist_xy, nummer, gf_winkel_min): # Die echte Hoehe liefert der 3D-Zwilling (siehe Zusammenfuehrung). if a.get("darstellung") == "2D": return { - "test_id": "GERADE_HundM05_%02d" % nummer, + "test_id": "GERADE_%s_%02d" % (PROJEKT, nummer), "typ": "gerade", "darstellung": "2D", "laenge": round(dist_xy, RUND), @@ -993,7 +1240,7 @@ def foerderer_eintrag(a, u, dist_xy, nummer, gf_winkel_min): if abs(dz) < GERADE_MAX_DELTA_H: return { - "test_id": "GERADE_HundM05_%02d" % nummer, + "test_id": "GERADE_%s_%02d" % (PROJEKT, nummer), "typ": "gerade", "darstellung": a.get("darstellung", "?"), "laenge": round(dist_xy, RUND), @@ -1008,7 +1255,7 @@ def foerderer_eintrag(a, u, dist_xy, nummer, gf_winkel_min): if dz < 0 and neigung >= gf_winkel_min: return { - "test_id": "GF_HundM05_%02d" % nummer, + "test_id": "GF_%s_%02d" % (PROJEKT, nummer), "modus": 1, "darstellung": a.get("darstellung", "?"), "deltaL_mm": round(dist_xy, RUND), @@ -1025,7 +1272,7 @@ def foerderer_eintrag(a, u, dist_xy, nummer, gf_winkel_min): } return { - "test_id": "VF_HundM05_%02d" % nummer, + "test_id": "VF_%s_%02d" % (PROJEKT, nummer), "typ": "standard", "darstellung": a.get("darstellung", "?"), "richtung": "Auf" if dz > 0 else "Ab", @@ -1104,28 +1351,388 @@ def sensor_eintrag(t, bekannte_bloecke=None, hinweise=None, treffer=None): } +def as_am_ende(p, richtung, as_liste, belegt): + """Ausschleuselement an einem Linienende suchen. + + p = Linienende (x, y), richtung = Einheitsvektor (x, y) von dort in die + Linie hinein. Gesucht wird im Linien-KS (siehe GF_AS_MAX_ENTLANG/-QUER); + "quer" ist positiv LINKS der Richtung. Ein AS mit Seite im Blocknamen muss + auf dieser Seite liegen - das trennt ihn vom Nachbar-AS der Linie daneben. + Bereits vergebene AS (belegt = Menge von id()) zaehlen nicht. + + Funktioniert genauso fuer Einschleuselemente am unteren Ende (es_liste in + gf_eintraege_aus_linien), dann mit der Richtung vom unteren Ende in die + Linie hinein. + + Rueckgabe: (treffer, zielblock, geraten) oder None. + """ + beste = None + for t in as_liste: + if id(t) in belegt: + continue + vx, vy = t["x"] - p[0], t["y"] - p[1] + entlang = vx * richtung[0] + vy * richtung[1] + quer = richtung[0] * vy - richtung[1] * vx + if not (-GF_AS_MAX_VOR <= entlang <= GF_AS_MAX_ENTLANG + and abs(quer) <= GF_AS_MAX_QUER): + continue + block, geraten = mappe_block(t["block"]) + if "Seite=%s" % DEFAULT_SEITE not in (geraten or []): + if block.endswith("_links") and quer < 0: + continue + if block.endswith("_rechts") and quer > 0: + continue + if beste is None or abs(quer) < beste[0]: + beste = (abs(quer), t, block, geraten or []) + return beste[1:] if beste else None + + +def kreisel_anschluss(p, richtung, kreisel): + """Schnittpunkt einer GF-Achse mit der naechsten Kreisel-Kette. + + p = Linienende (x, y), richtung = Einheitsvektor (x, y) der GF-Achse. + Je Kreisel (siehe kreisel_geo in baue_eintraege: Achse von der AN8- zur + SP8-Radmitte, Kette im Abstand r beidseits) wird die Kette auf der Seite + von p genommen und die Achse bis dorthin verlaengert bzw. gekuerzt. Nur + Kreisel, an deren Laenge p liegt und deren Kette hoechstens + GF_KREISEL_MAX_LUECKE entfernt ist; bei mehreren gewinnt die kleinste + Verschiebung. + + Rueckgabe: (kreisel, punkt (x, y), verschiebung entlang richtung) oder None. + """ + beste = None + for k in kreisel: + ux, uy = k["u"] + nx, ny = -uy, ux + vx, vy = p[0] - k["a"][0], p[1] - k["a"][1] + t = vx * ux + vy * uy + q = vx * nx + vy * ny + if not (-k["r"] <= t <= k["laenge"] + k["r"]): + continue + if abs(abs(q) - k["r"]) > GF_KREISEL_MAX_LUECKE: + continue + dn = richtung[0] * nx + richtung[1] * ny + if abs(dn) < 1e-6: # GF parallel zum Kreisel + continue + kette = k["r"] if q >= 0 else -k["r"] + lam = (kette - q) / dn + if beste is None or abs(lam) < abs(beste[2]): + beste = (k, (p[0] + lam * richtung[0], p[1] + lam * richtung[1]), lam) + return beste + + +def linien_zusammenfassen(linien): + """Kollineare, aneinanderstossende Linien desselben Layers vereinen. + + Eine Staustrecke ist im Plan oft in Stuecke zerlegt (Showroom_ILS_3_0: + vier LINEs je GF, an den Separatoren getrennt). Als Einzelstuecke fehlte + jedem das AS am einen oder das ES am anderen Ende. Vereint wird nur bei + gleicher Richtung (in 3D) und Stoss innerhalb GF_LINIE_STOSS_TOL. + """ + def richtung(ln): + d = [ln["b"][i] - ln["a"][i] for i in range(3)] + n = math.sqrt(sum(c * c for c in d)) + return [c / n for c in d] if n else None + + def kollinear(r1, r2): + kreuz = (r1[1] * r2[2] - r1[2] * r2[1], r1[2] * r2[0] - r1[0] * r2[2], + r1[0] * r2[1] - r1[1] * r2[0]) + # 1e-3 rad (~0.06 Grad): die Plaene sind nicht exakt gezeichnet - + # im Showroom-Plan sitzt das Separatorstueck 0,3 mm neben der Achse, + # das verkippt das bis dahin vereinte Stueck um ~2.6e-4. + return math.sqrt(sum(c * c for c in kreuz)) < 1e-3 + + def gleich(p, q): + return math.dist(p, q) <= GF_LINIE_STOSS_TOL + + rest = [{"layer": ln["layer"], "a": list(ln["a"]), "b": list(ln["b"])} + for ln in linien] + fertig = [] + while rest: + akt = rest.pop(0) + gewachsen = True + while gewachsen: + gewachsen = False + ra = richtung(akt) + for ln in rest: + rb = richtung(ln) + if (ln["layer"] != akt["layer"] or ra is None or rb is None + or not kollinear(ra, rb)): + continue + # Die vier moeglichen Stoesse; das Ergebnis behaelt die + # beiden aeusseren Enden. + for p_akt, q_akt in (("a", "b"), ("b", "a")): + for p_ln, q_ln in (("a", "b"), ("b", "a")): + if gleich(akt[p_akt], ln[p_ln]): + akt = {"layer": akt["layer"], "a": akt[q_akt], + "b": ln[q_ln]} + gewachsen = True + break + if gewachsen: + break + if gewachsen: + rest.remove(ln) + break + fertig.append(akt) + return fertig + + +def seite_aus_lage(t, p, r): + """Seite eines AS/ES aus seiner Lage zur GF-Fahrtrichtung. + + t = Element, p = Punkt auf der Achse, r = Fahrtrichtung der GF (bergab). + Links der Fahrtrichtung -> "links", sonst "rechts" - dieselbe Zuordnung + wie in Dematic_arvato ("Ausschleuselement links" liegt links der + Fahrtrichtung, siehe as_am_ende). Nur fuer Bloecke ohne Seite im Namen + ("AE-D"/"EE-R"); gespiegelte Inserts landen dadurch automatisch auf der + Gegenseite. + """ + vx, vy = t["x"] - p[0], t["y"] - p[1] + return "links" if r[0] * vy - r[1] * vx > 0 else "rechts" + + +def gf_eintraege_aus_linien(linien, as_liste, kreisel=None, sep_liste=None, + winkel_default=3.0, es_liste=None, flach=False): + """Gefaellestrecken (Modus 1, Schema 2.1) aus Staustrecken-Linien. + + Eine Gefaellestrecke laeuft immer bergab: Start ist das HOEHERE + Linienende, unabhaengig von der Zeichenrichtung. Das Ausschleuselement + gehoert an dieses obere Ende. Sitzt es dagegen am UNTEREN Ende, faehrt + die Strecke vom tiefen Kreisel hinauf - das ist ein Steigfoerderer und + keine GF (Dematic_arvato_reduced.dxf: 3 solche Linien); sie wird + gemeldet und uebersprungen. + + Anschluss an die Kreisel: gezeichnet ist nur die Staustrecke. Das Makro + legt den Ursprung des AS-Elements auf start_mm und dessen Einlauf + (KS_EIN) seitlich daneben, auf gleicher Hoehe der Achse; ebenso liegt der + Auslauf des ES-Elements neben dessen Ursprung, und deltaL_mm reicht von + AS- bis ES-Ursprung (gemessen an GF_Mubea: 9510 -> 399.2 = 9110.8). Damit + beide die Kreisel-Kette treffen, werden Start und Ende auf die jeweils + naechste Kette geschoben (kreisel_anschluss). Ohne Kreisel in Reichweite + bleibt das Linienende stehen und es gibt einen Hinweis. + + Hoehen: tragen beide Kreisel eine Anwender-Hoehe ("z_anwender"), wird + start_mm.z die des oberen und hoehe_ende_mm die des unteren Kreisels - + den Winkel rechnet dann der LISP-Treiber mit gf-winkel-berechnen + (dieselbe Naeherung wie Modus 3, mit den Elementmassen der aktuellen + 2D/3D-Bibliothek). Sonst ist winkel_default ein Platzhalter. + + Rueckgabe: (eintraege, verbrauchte ids, hinweise). Verbraucht werden das + AS am oberen Ende und Separatoren auf der Achse (sep_liste) - beides baut + die Gefaellestrecke selbst mit, als Einzel-Insert stuenden sie doppelt in + der Zeichnung (und im Sivas-Export). Der AS eines uebersprungenen + Steigfoerderers bleibt unverbraucht. + + es_liste: Einschleuselemente; eines am unteren Ende liefert es_seite/ + es_winkel und wird ebenfalls verbraucht. Ohne es_liste bleiben beide + Defaults (Dematic_arvato hat kein ES im Plan). + + flach: 2D-Plan ohne Hoehen (alle Linien waagrecht, z.B. + Showroom_ILS_3_0). Dann ist eine waagrechte Linie eine GF, wenn genau an + EINEM Ende ein Ausschleuselement sitzt - dieses Ende ist oben. Ohne flach + werden waagrechte Linien wie bisher uebergangen. + """ + eintraege, hinweise = [], [] + belegt = set() + waagrecht = 0 + kandidaten = [] + for ln in linien_zusammenfassen(linien): + a, b = ln["a"], ln["b"] + if abs(a[2] - b[2]) < GF_LINIE_MIN_DZ: + lxy = math.hypot(b[0] - a[0], b[1] - a[1]) + if not (flach and lxy > 0.0): + waagrecht += 1 + continue + r_ab = ((b[0] - a[0]) / lxy, (b[1] - a[1]) / lxy) + as_a = as_am_ende(a, r_ab, as_liste, belegt) + as_b = as_am_ende(b, (-r_ab[0], -r_ab[1]), as_liste, belegt) + if (as_a is None) == (as_b is None): + waagrecht += 1 + continue + hoch, tief = (a, b) if as_a is not None else (b, a) + kandidaten.append((hoch, tief, lxy, ln["layer"])) + continue + hoch, tief = (a, b) if a[2] > b[2] else (b, a) + lxy = math.hypot(tief[0] - hoch[0], tief[1] - hoch[1]) + if lxy <= 0.0: + continue + kandidaten.append((hoch, tief, lxy, ln["layer"])) + kandidaten.sort(key=lambda k: (round(k[0][0], RUND), round(k[0][1], RUND))) + + for hoch, tief, lxy, layer in kandidaten: + r = ((tief[0] - hoch[0]) / lxy, (tief[1] - hoch[1]) / lxy) + oben = as_am_ende(hoch, r, as_liste, belegt) + if oben is None: + unten = as_am_ende(tief, (-r[0], -r[1]), as_liste, belegt) + if unten is not None: + # AS NICHT verbrauchen: er gehoert zum Steigfoerderer und + # bleibt als Einzel-Insert in der Ausgabe stehen. + hinweise.append( + "Staustrecken-Linie (%.0f, %.0f, %.0f) -> (%.0f, %.0f, " + "%.0f): Ausschleuselement am UNTEREN Ende - Steigfoerderer, " + "keine Gefaellestrecke, uebersprungen" + % (tief[0], tief[1], tief[2], hoch[0], hoch[1], hoch[2])) + continue + tid = "GF_%s_%02d" % (PROJEKT, len(eintraege) + 1) + kommentar = ("aus DXF: LINE auf Layer '%s' (%.2f, %.2f) -> (%.2f, " + "%.2f), Laenge XY %.2f" + % (layer, hoch[0], hoch[1], tief[0], tief[1], lxy)) + + # Start/Ende auf die Kreisel-Ketten schieben + start, ende = (hoch[0], hoch[1]), (tief[0], tief[1]) + k_start = k_ende = None + for wo, p, rr in (("oberen", hoch, r), ("unteren", tief, (-r[0], -r[1]))): + ans = kreisel_anschluss(p, rr, kreisel or []) + if ans is None: + hinweise.append("%s: kein Kreisel am %s Ende - Linienende " + "bleibt stehen" % (tid, wo)) + kommentar += "; am %s Ende kein Kreisel in Reichweite" % wo + continue + k, punkt, lam = ans + kommentar += ("; am %s Ende um %.1f mm bis zur Kette von %s " + "verlaengert" % (wo, -lam, k["id"])) + if wo == "oberen": + start, k_start = punkt, k + else: + ende, k_ende = punkt, k + laenge = (ende[0] - start[0]) * r[0] + (ende[1] - start[1]) * r[1] + + eintrag = { + "test_id": tid, + "modus": 1, + "deltaL_mm": round(laenge, RUND), + "hz_grad": round(math.degrees(math.atan2(r[1], r[0])) % 360.0, RUND) + 0.0, + "start_mm": [round(start[0], RUND) + 0.0, round(start[1], RUND) + 0.0, 0.0], + "as_seite": DEFAULT_SEITE, + "es_seite": "links", + "as_winkel": str(DEFAULT_SCHLEUS_WINKEL), + "es_winkel": str(DEFAULT_SCHLEUS_WINKEL), + } + if k_start: + eintrag["kreisel_start"] = k_start["id"] + if k_ende: + eintrag["kreisel_ende"] = k_ende["id"] + if (k_start and k_ende and k_start.get("z_anwender") is not None + and k_ende.get("z_anwender") is not None): + eintrag["start_mm"][2] = float(k_start["z_anwender"]) + eintrag["hoehe_ende_mm"] = float(k_ende["z_anwender"]) + eintrag["hoehe_quelle"] = "Anwender" + kommentar += ("; Hoehen vom Anwender (Kreisel %s / %s), den Winkel " + "rechnet der Treiber" % (k_start["id"], k_ende["id"])) + else: + eintrag["winkel_grad"] = winkel_default + eintrag["hoehe_unbekannt"] = True + kommentar += ("; Hoehen unbekannt - winkel_grad %.1f ist Platzhalter" + % winkel_default) + + if oben is not None: + t, block, geraten = oben + belegt.add(id(t)) + teile = block.split("_") # AS_Element__ + eintrag["as_winkel"], eintrag["as_seite"] = teile[2], teile[3] + if "Seite=%s" % DEFAULT_SEITE in geraten: + eintrag["as_seite"] = seite_aus_lage(t, hoch, r) + geraten = [g for g in geraten if not g.startswith("Seite=")] + block = "AS_Element_%s_%s" % (eintrag["as_winkel"], + eintrag["as_seite"]) + kommentar += ("; as_seite %s aus der Lage zur Fahrtrichtung" + % eintrag["as_seite"]) + kommentar += ("; AS aus Block '%s' bei (%.2f, %.2f) -> %s, als " + "Einzel-Insert entfernt (baut die GF selbst)" + % (t["block"], t["x"], t["y"], block)) + if geraten: + kommentar += " - geraten: %s" % ", ".join(geraten) + else: + kommentar += ("; KEIN Ausschleuselement am oberen Ende gefunden - " + "as_seite/as_winkel sind Defaults") + hinweise.append("%s ohne Ausschleuselement am oberen Ende" % tid) + + # Separatoren auf der Achse zwischen Start und Ende + weg = [] + for s in sep_liste or []: + if id(s) in belegt or not matches_any(s["block"], GF_SEP_MUSTER): + continue + vx, vy = s["x"] - start[0], s["y"] - start[1] + entlang = vx * r[0] + vy * r[1] + quer = r[0] * vy - r[1] * vx + if 0.0 <= entlang <= laenge and abs(quer) <= GF_SEP_MAX_QUER: + belegt.add(id(s)) + weg.append("%s bei (%.0f, %.0f)" % (s["block"], s["x"], s["y"])) + if weg: + kommentar += ("; Separator auf der Achse entfernt (die GF baut " + "ihren eigenen): %s" % ", ".join(weg)) + + unten = (as_am_ende(tief, (-r[0], -r[1]), es_liste, belegt) + if es_liste else None) + if unten is not None: + t, block, geraten = unten + belegt.add(id(t)) + teile = block.split("_") # ES_Element__ + eintrag["es_winkel"], eintrag["es_seite"] = teile[2], teile[3] + if "Seite=%s" % DEFAULT_SEITE in geraten: + eintrag["es_seite"] = seite_aus_lage(t, tief, r) + geraten = [g for g in geraten if not g.startswith("Seite=")] + block = "ES_Element_%s_%s" % (eintrag["es_winkel"], + eintrag["es_seite"]) + kommentar += ("; es_seite %s aus der Lage zur Fahrtrichtung" + % eintrag["es_seite"]) + kommentar += ("; ES aus Block '%s' bei (%.2f, %.2f) -> %s, als " + "Einzel-Insert entfernt (baut die GF selbst)" + % (t["block"], t["x"], t["y"], block)) + if geraten: + kommentar += " - geraten: %s" % ", ".join(geraten) + kommentar += "." + else: + kommentar += "; es_seite/es_winkel sind Defaults (kein ES im DXF)." + eintrag["comment"] = kommentar + eintraege.append(eintrag) + + if waagrecht: + hinweise.append("%d waagrechte Staustrecken-Linie(n) auf %s - keine " + "Gefaellestrecke, nicht ausgegeben" + % (waagrecht, "/".join(GF_LINIE_LAYER))) + return eintraege, belegt, hinweise + + def baue_eintraege(treffer, defaults, boegen, weichen, - bekannte_bloecke=None): - """Erkannte Vorkommen auf die Schemata aus object_data.md abbilden.""" + bekannte_bloecke=None, linien=None, kreisel_hoehen=None, + kreisel_achsen=None, flach=False): + """Erkannte Vorkommen auf die Schemata aus object_data.md abbilden. + + kreisel_hoehen: Liste (x, y, z) vom Anwender - z gilt fuer den Kreisel, + dessen Einfuegepunkt (Eintrag x/y) hoechstens KREISEL_HOEHE_TOL entfernt + liegt, und fuer die Gefaellestrecken, die an ihm anschliessen. + + kreisel_achsen: Liste (x1, y1, x2, y2) vom Anwender - Radmitten eines + Kreisels ohne AN8/SP8 im Plan (Showroom_ILS_3_0: Schleifen, die an beiden + Enden mit Weichenboegen schliessen). Wird als STANDARD-Kreisel + angenaehert, x1/y1 gilt als AN8-Seite. + + flach: siehe gf_eintraege_aus_linien. + """ nach_familie = {} for t in treffer: nach_familie.setdefault(t["familie"], []).append(t) eintraege = [] hinweise = [] + kreisel_geo = [] # Achse/Kette je Kreisel fuer kreisel_anschluss + offene_hoehen = list(kreisel_hoehen or []) # --- Kreisel: AN8 (Antriebsstation) + SP8 (Spannstation) -------------- durchmesser = defaults.get("kreisel", {}).get("durchmesser", 800.0) - an_liste = sorted(nach_familie.get("kreisel_an", []), key=lambda t: (t["x"], t["y"])) - sp_liste = list(nach_familie.get("kreisel_sp", [])) - for i, an in enumerate(an_liste, start=1): - if not sp_liste: - hinweise.append("AN8 bei (%.2f, %.2f) ohne SP8-Partner" % (an["x"], an["y"])) - eintraege.append(sensor_eintrag(an, bekannte_bloecke, hinweise, treffer)) - continue - sp = min(sp_liste, key=lambda s: math.hypot(s["x"] - an["x"], s["y"] - an["y"])) - sp_liste.remove(sp) - dist = math.hypot(sp["x"] - an["x"], sp["y"] - an["y"]) + kreisel_paare, an_rest, sp_liste = kreisel_paare_bilden( + nach_familie.get("kreisel_an", []), nach_familie.get("kreisel_sp", [])) + for an in an_rest: + hinweise.append("AN8 bei (%.2f, %.2f) ohne SP8-Partner" % (an["x"], an["y"])) + eintraege.append(sensor_eintrag(an, bekannte_bloecke, hinweise, treffer)) + for x1, y1, x2, y2 in kreisel_achsen or []: + an = {"block": "(manuell AN8)", "layer": "--kreisel-achse", + "x": x1, "y": y1, "z": 0.0, "darstellung": "2D"} + sp = {"block": "(manuell SP8)", "layer": "--kreisel-achse", + "x": x2, "y": y2, "z": 0.0, "darstellung": "2D"} + kreisel_paare.append((an, sp, math.hypot(x2 - x1, y2 - y1))) + for i, (an, sp, dist) in enumerate(kreisel_paare, start=1): rotation = math.degrees(math.atan2(sp["y"] - an["y"], sp["x"] - an["x"])) % 360.0 # AN8/SP8 sind flache 2D-Symbole auf Z=0 - die Einbauhoehe steht nicht # im DXF. Sie wird aus den 3D-Modellen in der Umgebung abgeleitet @@ -1144,24 +1751,76 @@ def baue_eintraege(treffer, defaults, boegen, weichen, hoehe_hinweis = (" ACHTUNG hoehe=%.1f ist NICHT belegt: " "AN8/SP8 sind flache 2D-Symbole auf Z=0 und " "%s." % (hoehe, grund)) + # an/sp sind Radmitten (siehe "kreis" in lese_inserts). draw-module + # (KreiselInsert.lsp) legt AN8 bei (radius, 0) und SP8 bei + # (radius + abstand, 0) in den Block: abstand ist also der + # Mittenabstand, und der Einfuegepunkt liegt einen Radius VOR der + # AN8-Mitte. Die fruehere "connect"-Ausgabe uebergab die Radmitten an + # kreisel-connect-script, das Aussenkanten erwartet - der Kreisel + # wurde dadurch an beiden Enden um einen Radius zu kurz. + radius = durchmesser / 2.0 + richtung = math.radians(rotation) eintraege.append({ - "id": "Kreisel_HundM05_%02d" % i, - "function": "connect", - "start_x": an["x"], "start_y": an["y"], "start_z": an["z"], - "end_x": sp["x"], "end_y": sp["y"], "end_z": sp["z"], + "id": "Kreisel_%s_%02d" % (PROJEKT, i), + "function": "insert", + "x": round(an["x"] - radius * math.cos(richtung), RUND) + 0.0, + "y": round(an["y"] - radius * math.sin(richtung), RUND) + 0.0, + "z": hoehe, + "abstand": round(dist, RUND), + "rotation": round(rotation, RUND) + 0.0, "typ": "STANDARD", "darstellung": an.get("darstellung", "?"), - "hoehe": hoehe, - "comment": ("aus DXF: AN8 (Layer %s) -> SP8 (Layer %s), Abstand " - "%.2f; daraus folgt produktionsseitig abstand = %.2f - " - "%.1f = %.2f und rotation = %.2f Grad." - % (an["layer"], sp["layer"], dist, dist, durchmesser, - dist - durchmesser, rotation)) + hoehe_hinweis, + "comment": ("aus DXF: Radmitte %s (Layer %s) (%.2f, %.2f) -> " + "%s (Layer %s) (%.2f, %.2f), Mittenabstand %.2f, " + "rotation %.2f Grad; x/y = AN8-Mitte minus Radius." + % (an["block"], an["layer"], an["x"], an["y"], + sp["block"], sp["layer"], sp["x"], sp["y"], dist, + rotation)) + hoehe_hinweis, }) + kreisel = eintraege[-1] + for h in offene_hoehen: + if math.hypot(h[0] - kreisel["x"], h[1] - kreisel["y"]) <= KREISEL_HOEHE_TOL: + kreisel["z"] = float(h[2]) + kreisel["hoehe_quelle"] = "Anwender" + kreisel["comment"] += " Hoehe %.1f vom Anwender." % h[2] + offene_hoehen.remove(h) + break + kreisel_geo.append({ + "id": kreisel["id"], + "a": (an["x"], an["y"]), + "u": (math.cos(richtung), math.sin(richtung)), + "laenge": dist, + "r": radius, + "z_anwender": kreisel["z"] if kreisel.get("hoehe_quelle") else None, + }) + for h in offene_hoehen: + hinweise.append("Kreisel-Hoehe %.1f bei (%.2f, %.2f): kein Kreisel-" + "Einfuegepunkt in %g mm - nicht verwendet" + % (h[2], h[0], h[1], KREISEL_HOEHE_TOL)) for sp in sp_liste: hinweise.append("SP8 bei (%.2f, %.2f) ohne AN8-Partner" % (sp["x"], sp["y"])) eintraege.append(sensor_eintrag(sp, bekannte_bloecke, hinweise, treffer)) + # --- Gefaellestrecken aus Staustrecken-Linien --------------------------- + # Nach den Kreiseln (Anschluss an deren Ketten) und vor dem Rest-Block: + # sie entnehmen ihre Ausschleuselemente und Separatoren aus den Familien + # (siehe gf_eintraege_aus_linien), der Rest-Block darf diese nicht mehr + # als Einzel-Insert ausgeben. + if linien: + as_liste = [t for t in nach_familie.get("schleuselement", []) + if mappe_block(t["block"])[0].startswith("AS_Element")] + es_liste = [t for t in nach_familie.get("schleuselement", []) + if mappe_block(t["block"])[0].startswith("ES_Element")] + gf, belegt, gf_hinweise = gf_eintraege_aus_linien( + linien, as_liste, kreisel_geo, nach_familie.get("sensor", []), + defaults.get("gefaelle", {}).get("default_winkel", 3.0), + es_liste, flach) + eintraege.extend(gf) + hinweise.extend(gf_hinweise) + for familie in ("schleuselement", "sensor"): + nach_familie[familie] = [t for t in nach_familie.get(familie, []) + if id(t) not in belegt] + # --- Foerderer: Antriebs- und Umlenkstation paaren --------------------- gf_winkel_min = defaults.get("gefaelle", {}).get("default_winkel", 3.0) paare, rest_a, rest_u = paare_bilden(nach_familie.get("foerderer_antrieb", []), @@ -1188,7 +1847,7 @@ def baue_eintraege(treffer, defaults, boegen, weichen, hinweise.append("Omniflo %s ohne Sivasnr: '%s' (%s)" % (typ, t["block"], grund)) eintraege.append({ - "id": sivasnr or ("%s_HundM05_%02d" % (typ.upper(), i)), + "id": sivasnr or ("%s_%s_%02d" % (typ.upper(), PROJEKT, i)), "type": typ, "sivasnr": sivasnr, "x": t["x"], "y": t["y"], "z": t["z"], @@ -1283,6 +1942,84 @@ def filtere_fenster(eintraege, fenster): return behalten, len(eintraege) - len(behalten), ohne_punkte +def hoehen_entfernen(eintraege): + """Alle Hoehen auf 0 setzen, ausser den vom Anwender vorgegebenen. + + Fuer Zeichnungen, deren Z-Werte (noch) nicht belastbar sind: lieber + gar keine Hoehe als eine, die nach Einbauhoehe aussieht und keine ist. + Ausgenommen sind Eintraege mit hoehe_quelle "Anwender" (--kreisel-hoehe + und die daran anschliessenden Gefaellestrecken). + Rueckgabe: Anzahl der geaenderten Eintraege. + """ + n = 0 + for e in eintraege: + if e.get("hoehe_quelle") == "Anwender": + continue + geaendert = False + for feld in ("z", "hoehe"): + if feld in e and e[feld] != 0.0: + e[feld] = 0.0 + geaendert = True + for feld in ("startpunkt", "start_mm", "endpunkt"): + p = e.get(feld) + if isinstance(p, list) and len(p) >= 3 and p[2] != 0.0: + p[2] = 0.0 + geaendert = True + if any(f in e for f in ("z", "hoehe", "startpunkt", "start_mm")): + e["hoehe_unbekannt"] = True + if geaendert: + e["comment"] = e.get("comment", "") + " [Hoehe entfernt: --ohne-hoehen]" + n += 1 + return n + + +# Querabstand (mm) zur Kreisel-Kette, bis zu dem ein Einzelteil (Separator, +# Scanner) als "auf dem Kreisel" gilt und dessen Anwender-Hoehe bekommt. +SENSOR_KETTE_MAX_QUER = 350.0 + + +def sensor_hoehen_von_kreiseln(eintraege, durchmesser=800.0): + """Einzelteile auf einer Kreisel-Kette bekommen dessen Anwender-Hoehe. + + Im flachen 2D-Plan (--ohne-hoehen) stehen Separatoren/Scanner sonst auf + Z=0, waehrend der Kreisel per --kreisel-hoehe auf seiner Hoehe sitzt. + Kette = Achse (Einfuegepunkt + Radius entlang rotation, Laenge abstand) + im Abstand r beidseits, plus die Halbkreise an den Enden. Nur Kreisel mit + hoehe_quelle "Anwender"; bei mehreren gewinnt der naechste. + + Rueckgabe: Anzahl gesetzter Hoehen. + """ + r = durchmesser / 2.0 + kreisel = [] + for e in eintraege: + if "abstand" in e and e.get("hoehe_quelle") == "Anwender": + w = math.radians(e.get("rotation", 0.0)) + u = (math.cos(w), math.sin(w)) + a = (e["x"] + r * u[0], e["y"] + r * u[1]) + kreisel.append((e, a, u, float(e["abstand"]))) + gesetzt = 0 + for e in eintraege: + if e.get("function") != "insert" or "block" not in e: + continue + beste = None + for k, a, u, laenge in kreisel: + vx, vy = e["x"] - a[0], e["y"] - a[1] + t = max(0.0, min(laenge, vx * u[0] + vy * u[1])) + # Abstand zur Achse (Strecke), davon r abgezogen = Abstand zur Kette + d = abs(math.hypot(vx - t * u[0], vy - t * u[1]) - r) + if d <= SENSOR_KETTE_MAX_QUER and (beste is None or d < beste[0]): + beste = (d, k) + if beste: + k = beste[1] + e["z"] = float(k["z"]) + e["hoehe_quelle"] = "Anwender" + e.pop("hoehe_unbekannt", None) + e["comment"] += " Hoehe %.1f von %s (liegt auf dessen Kette)." % ( + k["z"], k["id"]) + gesetzt += 1 + return gesetzt + + def arrays_einzeilig(text): """Zahlen-Arrays im JSON-Text auf eine Zeile ziehen. @@ -1346,7 +2083,7 @@ def main(): description="Erkennt ILS-/Omniflo-Komponenten in einem fremden DXF " "und schreibt sie im JSON-Schema aus " "tests/testdata/object_data.md.") - parser.add_argument("dxf", help="Quellzeichnung (binaeres DXF)") + parser.add_argument("dxf", help="Quellzeichnung (binaeres oder ASCII-DXF)") parser.add_argument("data_dir", help="Datenverzeichnis mit json/") parser.add_argument("output", help="Ziel-JSON") parser.add_argument("--fenster", nargs=4, type=float, @@ -1354,8 +2091,33 @@ def main(): help="Nur Bauteile in diesem XY-Fenster (mm) " "ausgeben - fuer den Nachbau eines einzelnen " "Anlagenabschnitts statt der ganzen Zeichnung") + parser.add_argument("--ohne-hoehen", action="store_true", + help="Alle Hoehen auf 0 setzen (Z der Zeichnung nicht " + "belastbar); ausgenommen --kreisel-hoehe") + parser.add_argument("--kreisel-hoehe", nargs=3, type=float, action="append", + metavar=("X", "Y", "Z"), + help="Hoehe Z fuer den Kreisel mit Einfuegepunkt X/Y " + "(wie im Ausgabe-JSON); gilt auch fuer Start/Ende " + "der daran anschliessenden Gefaellestrecken. " + "Mehrfach angebbar") + parser.add_argument("--kreisel-achse", nargs=4, type=float, + action="append", metavar=("X1", "Y1", "X2", "Y2"), + help="Kreisel ohne AN8/SP8 im Plan (z.B. Schleife mit " + "Weichenboegen an beiden Enden): Radmitten der " + "beiden Enden, X1/Y1 = AN8-Seite. Wird als " + "STANDARD-Kreisel angenaehert. Mehrfach angebbar") + parser.add_argument("--flach", action="store_true", + help="2D-Plan ohne Hoehen: waagrechte Staustrecken-" + "Linien mit Ausschleuselement an genau einem " + "Ende als Gefaellestrecke ausgeben (Hoehen dann " + "ueber --kreisel-hoehe)") + parser.add_argument("--projekt", + help="Projektkennung in den erzeugten IDs " + "(Default: Name der DXF-Datei ohne Endung)") args = parser.parse_args() dxf_path, data_dir, output_path = args.dxf, args.data_dir, args.output + global PROJEKT + PROJEKT = args.projekt or os.path.splitext(os.path.basename(dxf_path))[0] fenster = None if args.fenster: x0, y0, x1, y1 = args.fenster @@ -1407,8 +2169,23 @@ def main(): dim_stat["attribute_uebernommen"], dim_stat["nur_2d"], dim_stat["nur_3d"], len(treffer))) + linien = lese_linien(dxf_path, GF_LINIE_LAYER) + print("%s %d Staustrecken-Linien auf %s" % (PREFIX, len(linien), + "/".join(GF_LINIE_LAYER))) + eintraege, hinweise = baue_eintraege(treffer, defaults, boegen, weichen, - bekannte_bloecke) + bekannte_bloecke, linien, + args.kreisel_hoehe, args.kreisel_achse, + args.flach) + if args.ohne_hoehen: + print("%s --ohne-hoehen: Hoehe in %d Eintraegen auf 0 gesetzt" + % (PREFIX, hoehen_entfernen(eintraege))) + if args.kreisel_hoehe: + print("%s Einzelteile auf Kreisel-Ketten: Hoehe in %d Eintraegen vom " + "Kreisel uebernommen" + % (PREFIX, sensor_hoehen_von_kreiseln( + eintraege, + defaults.get("kreisel", {}).get("durchmesser", 800.0)))) if fenster: vorher = len(eintraege) diff --git a/lib/dxf_vf_abbild.py b/lib/dxf_vf_abbild.py index 88a62d6..6b1584f 100644 --- a/lib/dxf_vf_abbild.py +++ b/lib/dxf_vf_abbild.py @@ -5,7 +5,7 @@ dxf_vf_abbild.py - Abbild der VF_/GF_-Wrapperbloecke einer Testzeichnung: Attribute und Bausteinliste je Kette. Zweck: Regressionsnetz fuer Umbauten am Bau-Ablauf. Nach jedem Schritt der -Funktionstrennung (doc/TODO-plan-vf-interactive.md, Stufe 2) muss die +Funktionstrennung (doc/todo/plan-vf-interactive.md, Stufe 2) muss die gebaute Geometrie unveraendert sein - "unveraendert" heisst hier: gleiche Attribute (inklusive der reihenfolgeabhaengigen Komma-Listen L_VF_m/L_GF_m/ GF_WINKEL, die in der Zeichnung unsichtbar, im Sivas-Export aber falsch diff --git a/lib/export_neighbors.py b/lib/export_neighbors.py index 3b099fe..81d3e44 100644 --- a/lib/export_neighbors.py +++ b/lib/export_neighbors.py @@ -1287,6 +1287,11 @@ def compute_kreisel_umlauf(items, tolerance_mm, durchmesser_mm=800.0, punkte_je_kreisel = {tid: [] for tid in kreisel} + # Ein-/Auslaufpunkt je Strecke (K1 = KS_EIN des AS, K2 = KS_AUS des ES), + # fuer AS/ES, deren Marker-Box keinen Kreisel trifft (siehe unten). + strecken_kos = {it.get("teileid", ""): _asel_kos_xy(it) + for it in items if it.get("teileart", "") in GF_VF_TEILEARTEN} + for item in items: if item.get("teileart", "") not in KREISEL_UMLAUF_TEILEARTEN: continue @@ -1305,6 +1310,31 @@ def compute_kreisel_umlauf(items, tolerance_mm, durchmesser_mm=800.0, (teileid, bbox.get("cx", 0.0), bbox.get("cy", 0.0))) matched_tid = tid break + # Rueckfall fuer AS/ES: der ZZ_ASES_MARKER sitzt auf dem EINFUEGEPUNKT + # des Elements, der Kreisel beruehrt aber dessen Ein-/Auslauf (KS_EIN/ + # KS_AUS). Ein 90-Grad-Element hat den Einlauf ~610 mm seitlich - laeuft + # die Strecke quer vom Kreisel weg, liegt dieser Versatz entlang der + # Kette und der Marker trotzdem darauf; laeuft sie PARALLEL zum + # Kreisel, liegt er quer dazu und der Marker ~560 mm daneben (Dematic/ + # Arvato VF_5 an Kreisel1: Marker 557 mm, Einlauf 52 mm von der Kette, + # Review 2026-10-08). Nur wenn die Marker-Box nichts trifft - bereits + # zugeordnete AS/ES behalten Position und Reihenfolge. + if matched_tid is None and item.get("teileart", "") in ( + AUSSCHLEUS_TEILEART, EINSCHLEUS_TEILEART): + k1_xy, k2_xy = strecken_kos.get(item.get("_zuordnung", ""), (None, None)) + pt = k1_xy if item.get("teileart", "") == AUSSCHLEUS_TEILEART else k2_xy + if pt is not None: + pt_bounds = _bounds({"cx": pt[0], "cy": pt[1], "dx": 0.0, "dy": 0.0}, + half_tol) + for tid, kb in kreisel_bounds.items(): + if _overlaps(pt_bounds, kb): + punkte_je_kreisel[tid].append((teileid, pt[0], pt[1])) + matched_tid = tid + if dbg: + dbg(f" Umlauf-Kandidat {teileid!r}: Marker-Box ohne " + f"Kreisel, Ein-/Auslauf ({pt[0]:.0f},{pt[1]:.0f}) " + f"liegt auf Kreisel {tid}") + break if dbg: if matched_tid is not None: dbg(f" Umlauf-Kandidat {teileid!r} ({item.get('teileart', '')!r}) " diff --git a/lib/export_sivas.py b/lib/export_sivas.py index ccb3ead..e62012f 100644 --- a/lib/export_sivas.py +++ b/lib/export_sivas.py @@ -907,9 +907,9 @@ def format_csv_line(item, details=None): def details_mit_bezeichnung(details, merkmalstamm): """Kopie von details, bei der jeder Merkmalnummer-Key durch seine Klartext-Bezeichnung aus dem Merkmalstamm ersetzt wird (Wert bleibt - unveraendert). Keys, die keine reine Zahl sind (aktuell nur beim - Eckrad, siehe build_eckrad_details - dort noch beschreibende - Klartext-Keys statt Merkmalnummern), bleiben unveraendert.""" + unveraendert). Keys, die keine reine Zahl sind, bleiben unveraendert + (aktuell kein Normalfall mehr - alle Sektionen in cfg/sivas.cfg nutzen + echte Merkmalnummern).""" neu = {} for key, value in details.items(): if key.isdigit(): diff --git a/lib/testdata_schema.py b/lib/testdata_schema.py new file mode 100644 index 0000000..a1e5e11 --- /dev/null +++ b/lib/testdata_schema.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +testdata_schema.py - Feldnamen und feste Werte der JSON-Testdaten-Schemas aus +doc/json-input-lisp.md, als einzige Quelle fuer alle Erzeuger. + +Bisher standen dieselben Feldnamen ("function", "abstand", "deltaL_mm", +"as_seite", ...) als lose String-Literale unabhaengig in dxf_scan_components.py +(fremde Zeichnungen) UND dxf_anlage_export.py (eigene, mit unseren Makros +gebaute Zeichnungen) - ein Tippfehler oder eine Schema-Aenderung in nur einer +der beiden Dateien waere nicht aufgefallen. Dieses Modul buendelt sie an +einer Stelle; die LISP-Treiber (tests/test_*.lsp) lesen die JSON-Keys direkt +als Strings und sind davon nicht betroffen. + +Nur Feldnamen/feste Werte, KEINE Validierung oder Default-Logik - die bleibt +bewusst in den jeweiligen Erzeugern, deren Kontext (fremde vs. eigene +Zeichnung) unterschiedliche Fallbacks braucht. +""" + +# --- Gemeinsame Felder --- +F_FUNCTION = "function" +F_ID = "id" +F_TEST_ID = "test_id" +F_BLOCK = "block" +F_X = "x" +F_Y = "y" +F_Z = "z" +F_ROTATION = "rotation" +F_COMMENT = "comment" + +FUNC_INSERT = "insert" +FUNC_CONNECT = "connect" + +# --- Abschnitt 1 (json-input-lisp.md): Kreisel --- +F_ABSTAND = "abstand" +F_TYP = "typ" +F_DREHRICHTUNG = "drehrichtung" + +TYP_STANDARD = "STANDARD" +TYP_PIN = "PIN" +DREHRICHTUNG_UZS = "UZS" +DREHRICHTUNG_GUZ = "GUZ" + +# --- Abschnitt 3: VarioFoerderer Standard und Etage --- +F_VF_TYP = "typ" +F_RICHTUNG = "richtung" +F_DELTA_L = "deltaL" +F_DELTA_H = "deltaH" +F_WINKEL = "winkel" +F_L_GF1 = "L_GF1" +F_GF_VERTEILUNG = "gf_verteilung" +F_SEITE = "seite" +F_MOTORSEITE = "motorseite" +F_HZ = "hz" + +VF_TYP_STANDARD = "standard" +VF_TYP_ETAGE = "etage" +RICHTUNG_AUF = "Auf" +RICHTUNG_AB = "Ab" +SEITE_LINKS = "links" +SEITE_RECHTS = "rechts" + +# --- Abschnitt 4.1: Gefaellestrecke Modus 1 --- +F_MODUS = "modus" +F_DELTAL_MM = "deltaL_mm" +F_WINKEL_GRAD = "winkel_grad" +F_HZ_GRAD = "hz_grad" +F_START_MM = "start_mm" +F_AS_SEITE = "as_seite" +F_ES_SEITE = "es_seite" +F_AS_WINKEL = "as_winkel" +F_ES_WINKEL = "es_winkel" + +GF_MODUS_WERTEINGABE = 1 +GF_MODUS_RICHTUNG_AUS_PUNKTEN = 2 +GF_MODUS_LINIENZUG = 3 + +SCHLEUS_WINKEL_90 = "90" +SCHLEUS_WINKEL_30 = "30" diff --git a/lib/vf_spec_export.py b/lib/vf_spec_export.py index a52abc4..861b0a4 100644 --- a/lib/vf_spec_export.py +++ b/lib/vf_spec_export.py @@ -7,7 +7,7 @@ uebersetzen und zurueck. Eine Spec beschreibt eine Kette in Domaenenwerten ("links", "winkel", "aussen", ja/nein) statt in Menue-Codes und Journal-Tokens: lesbar, schreibbar und damit die Eingabeform fuer den nicht-interaktiven Bau -(Lisp/vf_spec.lsp, siehe doc/TODO-plan-vf-interactive.md Stufe 1). +(Lisp/vf_spec.lsp, siehe doc/todo/plan-vf-interactive.md Stufe 1). Zwei Richtungen, die einander pruefen: diff --git a/menu/SSG_LIB.cui b/menu/SSG_LIB.cui index 0cd7164..db2be1c 100644 --- a/menu/SSG_LIB.cui +++ b/menu/SSG_LIB.cui @@ -92,10 +92,22 @@ ^C^C(ssg-ensure "VarioFoerderer") EtageVarioFoerderer3D - + - 3D-Linienzug - ^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerderer + Werte manuell + ^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererManuell + + + + + aus 3D Linie mit Zielhoehe + ^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererZielhoehe + + + + + 3D Objekte stueckweise (in Arbeit) + ^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererStueckweise @@ -128,6 +140,18 @@ ^C^C(ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_LINIENZUG + + + QC Linie mit GF (automatische Auf-Ab-Berechnung) + ^C^C(ssg-ensure "VarioFoerderer") QcLinieMitGf + + + + + QC Linie mit GF und U-Form + ^C^C(ssg-ensure "VarioFoerderer") QcLinieMitGfUForm + + 90 @@ -669,114 +693,168 @@ + + Bloecke zaehlen + ^C^C(ssg-ensure "ssg_blocktools") SSG_BLOCK_COUNT + + + + + Bloecke loeschen + ^C^C(ssg-ensure "ssg_blocktools") SSG_BLOCK_DELETE + + + + + Attribute ersetzen + ^C^C(ssg-ensure "ssg_blocktools") SSG_ATTR_ERSETZEN + + + + + Text ersetzen + ^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_ERSETZEN + + + + + Text parallel beschriften + ^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_PARALLEL + + + + + Texthoehe aendern + ^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_HOEHE + + + + + Textstil aendern + ^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_STIL + + + alle Tests ausfuehren und exportieren ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) (c:SSG_RUN_ALL_TESTS_EXPORT) - + Tests ausfuehren und stehen lassen ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) (c:SSG_RUN_ALL_TESTS_OFFEN) - + Export CSV/Sivas ALL ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_export_all.lsp")) (c:TEST_EXPORT_ALL) - + Kreisel ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_kreisel.lsp")) (c:TEST_KREISEL) - + Foerderer ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_foerderer.lsp")) (c:TEST_FOERDERER) - + Foerderer-Linienzug ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_linienzug.lsp")) (c:TEST_LINIENZUG) (c:TEST_LINIENZUG_STUFE2) - + Omniflo ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_omniflo.lsp")) (c:TEST_OMNIFLO) - + Omniflo Strecke ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_omniflo_strecke.lsp")) (c:TEST_OMNIFLO_STRECKE) - + Gefaellestrecke ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_gefaellestrecke.lsp")) (c:TEST_GEFAELLESTRECKE) - + Mubea Gesamtmodell ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_mubea.lsp")) (c:TEST_MUBEA) - + HundM05 Kreisel-Abschnitt ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_hundm05.lsp")) (c:TEST_HUNDM05) - + + + Dematic/Arvato Flowpuffer (Vorlage) + ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_dematic_arvato.lsp")) (c:TEST_DEMATIC_ARVATO) + + + + + ILS 3.0 Showroom (Vorlage) + ^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_showroom_ils.lsp")) (c:TEST_SHOWROOM_ILS) + + + KS 2D/3D pruefen (CSV) ^C^C(load (strcat (getenv "DXFMAKRO") "/Lisp/ks_pruefung.lsp")) KS_PRUEFEN - + Kreisel bearbeiten (ssg-ensure "KreiselInsert") KreiselEdit - + Omniflo Element bearbeiten (ssg-ensure "OmniModulInsert") OMNI_EDIT - + Gefaellestrecke bearbeiten (ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_EDIT - + VarioFoerderer bearbeiten (ssg-ensure "VarioFoerderer") VARIOFOERDERER_EDIT - + TRO-Marker bearbeiten (ssg-ensure "Tro_Edit") TRO_EDIT - + Verbindung bearbeiten (ssg-ensure "Connection_Edit") CONNECTION_EDIT - + SSG Bearbeiten (Auto) (ssg-ensure "SSG_LIB_Commands") SSG_BLOCKEDIT @@ -798,6 +876,7 @@ + ILS @@ -865,12 +944,7 @@ Foerderer - - 3D-Linienzug - - - - + Vario_Kette_Merge @@ -914,6 +988,27 @@ + + Streckengruppe + + Werte manuell + + + + + + aus 3D Linie mit Zielhoehe + + + + + + 3D Objekte stueckweise (in Arbeit) + + + + + Gefaellestrecke @@ -934,6 +1029,18 @@ + + QC Linie mit GF (automatische Auf-Ab-Berechnung) + + + + + + QC Linie mit GF und U-Form + + + + Omniflo @@ -1559,125 +1666,183 @@ - Tests + Werkzeuge - alle Tests ausfuehren und exportieren + Bloecke zaehlen - Tests ausfuehren und stehen lassen + Bloecke loeschen - Export CSV/Sivas ALL + Attribute ersetzen - Kreisel + Text ersetzen - Foerderer + Text parallel beschriften - Foerderer-Linienzug + Texthoehe aendern - Omniflo + Textstil aendern + + + Tests - Omniflo Strecke - - - - - - Gefaellestrecke + alle Tests ausfuehren und exportieren - Mubea Gesamtmodell + Tests ausfuehren und stehen lassen - HundM05 Kreisel-Abschnitt + Export CSV/Sivas ALL + + + Kreisel + + + + + + Foerderer + + + + + + Foerderer-Linienzug + + + + + + Omniflo + + + + + + Omniflo Strecke + + + + + + Gefaellestrecke + + + + + + Mubea Gesamtmodell + + + + + + HundM05 Kreisel-Abschnitt + + + + + + Dematic/Arvato Flowpuffer (Vorlage) + + + + + + ILS 3.0 Showroom (Vorlage) + + + + KS 2D/3D pruefen (CSV) - + - + POP501 SSG_LIB Edit Context Kreisel bearbeiten - + Omniflo Element bearbeiten - + Gefaellestrecke bearbeiten - + VarioFoerderer bearbeiten - + TRO-Marker bearbeiten - + Verbindung bearbeiten - + SSG Bearbeiten (Auto) - + diff --git a/menu/SSG_LIB.mnl b/menu/SSG_LIB.mnl index c899576..aff32f1 100644 --- a/menu/SSG_LIB.mnl +++ b/menu/SSG_LIB.mnl @@ -2,7 +2,7 @@ ;; SSG_LIB.mnl - Automatisch geladen beim MENULOAD von SSG_LIB.mnu ;; ;; Definiert den Lazy-Loader (ssg-ensure) und laedt alle Module. -;; Kern-Module: ssg_core, ssg_lang, ssg_dbg, ssg_dialog, ssg_layer, ssg_id +;; Kern-Module: ssg_core, ssg_lang, ssg_dbg, ssg_dialog, ssg_layer, ssg_id, ssg_input ;; Feature-Module: KreiselInsert, Gefaellestrecke, VarioFoerderer, ... ;; ============================================================ @@ -144,6 +144,8 @@ (ssg-ensure "ssg_dialog") (ssg-ensure "ssg_layer") (ssg-ensure "ssg_id") + ;; Generische Eingabe-Wrapper (ssg-in-*), von den Werkzeug-Modulen genutzt + (ssg-ensure "ssg_input") ;; Gemeinsame KS-Extraktion + Block-Einfuegeprimitiven (von Gefaellestrecke ;; UND VarioFoerderer genutzt) - MUSS vor beiden geladen sein. (ssg-ensure "ssg_ks_insert") @@ -159,6 +161,9 @@ ;; Tro_Edit wird nicht vorgeladen - der Dispatcher SSG_BLOCKEDIT und die ;; Menuemakros holen es per (ssg-ensure "Tro_Edit") bei Bedarf nach. (ssg-ensure "SSG_LIB_Commands") + ;; Werkzeuge (Reihenfolge: ssg_texttools nutzt ssg_blocktools) + (ssg-ensure "ssg_blocktools") + (ssg-ensure "ssg_texttools") ;; Menue einhaengen (menucmd "P13=+SSG_LIB.POP1") diff --git a/menu/SSG_LIB.mnu b/menu/SSG_LIB.mnu index 578eece..19be501 100644 --- a/menu/SSG_LIB.mnu +++ b/menu/SSG_LIB.mnu @@ -21,13 +21,18 @@ [->Etage] [Werte manuell]^C^C(ssg-ensure "VarioFoerderer") EtageVarioFoerderer [<-aus 3D-Linie]^C^C(ssg-ensure "VarioFoerderer") EtageVarioFoerderer3D -[3D-Linienzug]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerderer +[->Streckengruppe] +[Werte manuell]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererManuell +[aus 3D Linie mit Zielhoehe]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererZielhoehe +[<-3D Objekte stueckweise (in Arbeit)]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererStueckweise [Vario_Kette_Merge]^C^C(ssg-ensure "VarioFoerderer") Vario_Kette_Merge [<-VarioFoerderer nachruesten (Marker)]^C^C(ssg-ensure "VarioFoerderer") VARIOFOERDERER_NACHRUESTEN [->Gefaellestrecke] [einfach]^C^C(ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_EINFACH [aus 3D-Linie]^C^C(ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_3DLINIE -[<-<-aus Linienzug (LINE + ARC)]^C^C(ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_LINIENZUG +[aus Linienzug (LINE + ARC)]^C^C(ssg-ensure "Gefaellestrecke") GEFAELLESTRECKE_LINIENZUG +[QC Linie mit GF (automatische Auf-Ab-Berechnung)]^C^C(ssg-ensure "VarioFoerderer") QcLinieMitGf +[<-QC Linie mit GF und U-Form]^C^C(ssg-ensure "VarioFoerderer") QcLinieMitGfUForm [->Omniflo] [->Boegen APB110] [90]^C^C(ssg-ensure "OmniModulInsert") OMNI_APB_630_90 @@ -141,6 +146,15 @@ [Sprache]^C^C(ssg-ensure "SSG_LIB_Commands") SSG_SPRACHE [Planquadrate an/aus]^C^C(ssg-ensure "DrawPlanquadrate") PLANQUADRATE_TOGGLE [<-CSV-Export]^C^C(ssg-ensure "export") CSV_EXPORT_KONFIG +[->Werkzeuge] +[Bloecke zaehlen]^C^C(ssg-ensure "ssg_blocktools") SSG_BLOCK_COUNT +[Bloecke loeschen]^C^C(ssg-ensure "ssg_blocktools") SSG_BLOCK_DELETE +[Attribute ersetzen]^C^C(ssg-ensure "ssg_blocktools") SSG_ATTR_ERSETZEN +[--] +[Text ersetzen]^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_ERSETZEN +[Text parallel beschriften]^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_PARALLEL +[Texthoehe aendern]^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_HOEHE +[<-Textstil aendern]^C^C(ssg-ensure "ssg_texttools") SSG_TEXT_STIL [->Tests] [alle Tests ausfuehren und exportieren]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) (c:SSG_RUN_ALL_TESTS_EXPORT) [Tests ausfuehren und stehen lassen]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_run_all.lsp")) (c:SSG_RUN_ALL_TESTS_OFFEN) @@ -154,6 +168,8 @@ [Gefaellestrecke]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_gefaellestrecke.lsp")) (c:TEST_GEFAELLESTRECKE) [Mubea Gesamtmodell]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_mubea.lsp")) (c:TEST_MUBEA) [HundM05 Kreisel-Abschnitt]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_hundm05.lsp")) (c:TEST_HUNDM05) +[Dematic/Arvato Flowpuffer (Vorlage)]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_dematic_arvato.lsp")) (c:TEST_DEMATIC_ARVATO) +[ILS 3.0 Showroom (Vorlage)]^C^C(load (strcat (getenv "DXFMAKRO") "/tests/test_showroom_ils.lsp")) (c:TEST_SHOWROOM_ILS) [<-KS 2D/3D pruefen (CSV)]^C^C(load (strcat (getenv "DXFMAKRO") "/Lisp/ks_pruefung.lsp")) KS_PRUEFEN ***DOUBLECLICK diff --git a/tests/alltests.json b/tests/alltests.json index dc98cb9..d0caa14 100644 --- a/tests/alltests.json +++ b/tests/alltests.json @@ -10,5 +10,7 @@ { "name": "gefaellestrecke", "save": "dwg", "module": "Gefaellestrecke" }, { "name": "mubea", "save": "dxf", "module": "KreiselInsert" }, { "name": "hundm05", "save": "dxf", "module": "VarioFoerderer" }, - { "name": "hm_recformat", "save": "dxf", "module": "VarioFoerderer", "disabled": true } + { "name": "dematic_arvato", "save": "dxf", "module": "VarioFoerderer", "disabled": true }, + { "name": "hm_recformat", "save": "dxf", "module": "VarioFoerderer", "disabled": true }, + { "name": "showroom_ils", "save": "dxf", "module": "VarioFoerderer", "disabled": true } ] diff --git a/tests/test_dematic_arvato.lsp b/tests/test_dematic_arvato.lsp new file mode 100644 index 0000000..a286aa7 --- /dev/null +++ b/tests/test_dematic_arvato.lsp @@ -0,0 +1,417 @@ +;; ============================================================ +;; test_dematic_arvato.lsp - Nachbau des Abschnitts Flowpuffer/Kreisel der +;; Anlage Dematic/Arvato. +;; +;; Datenquelle: tests/testdata/dematic_arvato.json. Entstehung in zwei +;; Stufen: +;; 1. Vorlage aus der Fremdzeichnung (Scanner, raet vieles): +;; python lib/dxf_scan_components.py \ +;; C:/develop/sps_skel/data/Dematic_arvato_reduced.dxf data \ +;; tests/testdata/dematic_arvato.json --projekt Arvato \ +;; --fenster -2534 -4549 49466 29451 --ohne-hoehen \ +;; --kreisel-hoehe 35860.37 12519.72 2437 \ +;; --kreisel-hoehe 36661.24 24878.8 1826 +;; 2. Vorlage mit diesem Treiber bauen, in BricsCAD von Hand korrigieren +;; und ergaenzen (VF-Ketten, Hoehen, Sensoren aufgeraeumt), als DXF +;; speichern und daraus die Testdaten neu schreiben - AKTUELLER STAND: +;; python lib/dxf_anlage_export.py \ +;; C:/develop/sps_skel/data/Dematic_TST.dxf \ +;; tests/testdata/dematic_arvato.json --projekt Arvato +;; +;; Eintragsarten: +;; "function": "insert" ohne "block" -> Kreisel (hundm05:bau-kreisel -> +;; kreisel-insert-script; x/y = Einfuegepunkt, +;; abstand = Mittenabstand AN8-SP8) +;; "function": "insert" + "block" -> Einzelblock (hundm05:bau-sensor) +;; "typ": "standard"/"etage" + "test_id" +;; -> VarioFoerderer ueber mubea:vario-bauen +;; (mubea-Schema: deltaL, deltaH, richtung, +;; winkel, L_GF1, seite, hz, x/y/z), optional +;; "motorseite" +;; "typ": "linienzug_journal" +;; -> Linienzug-Kette: das aufgezeichnete Eingabe- +;; Journal (SSG_VF_EDIT) wird 1:1 abgespielt +;; (vsp-bau-journal) - keine Spec, weil der +;; Dialog neuer ist als die Spec-Grammatik +;; "modus": 1 -> Gefaellestrecke ueber mubea:gf-bauen +;; (start_mm + deltaL_mm, kein Endpunkt). Mit +;; hoehe_ende_mm (Hoehe des Kreisels am Ende) +;; rechnet dematic_arvato:gf-geometrie Winkel +;; und Staustreckenlaenge (gf-bauen-exakt), +;; sonst gilt winkel_grad. +;; "typ": "gerade" -> waagrechter Foerderer aus der Scanner-Vorlage - +;; kein Bau-Pfad, wird gemeldet und uebersprungen +;; +;; Reihenfolge wie mubea.json (VF vor GF): gf-init-bibliothek setzt die +;; globalen AS/ES-Masse um, siehe mubea:ensure-gf-init. +;; +;; Keine eigene Bau-Logik: hundm05:bau-kreisel/-sensor aus +;; tests/test_hundm05.lsp und mubea:gf-bauen/-vario-bauen aus +;; tests/test_mubea.lsp werden mitgeladen (beide Dateien definieren nur +;; Funktionen), Linienzug-Ketten laufen ueber vsp-bau-journal (vf_spec.lsp). +;; +;; Aufruf in BricsCAD: +;; (load (strcat (getenv "DXFMAKRO") "/tests/test_dematic_arvato.lsp")) +;; TEST_DEMATIC_ARVATO +;; ============================================================ + +(if (not (boundp '*dematic-arvato-records*)) (setq *dematic-arvato-records* nil)) + +;; Module und die Bau-Funktionen aus test_hundm05.lsp beim LADEN dieser Datei +;; holen, nicht erst in c:TEST_DEMATIC_ARVATO: in BricsCAD werden per load +;; definierte Funktionen erst nach Rueckkehr zum Top-Level sichtbar (siehe +;; tests/test_unit.scr). +(ssg-ensure "KreiselInsert") +(ssg-ensure "VarioFoerderer") +(ssg-ensure "SSG_LIB_Commands") +(ssg-ensure "Gefaellestrecke") +(if (null (car (atoms-family 1 '("HUNDM05:BAU-SENSOR")))) + (load (strcat (getenv "DXFMAKRO") "/tests/test_hundm05.lsp"))) +(if (null (car (atoms-family 1 '("MUBEA:VARIO-BAUEN")))) + (load (strcat (getenv "DXFMAKRO") "/tests/test_mubea.lsp"))) + +(defun dematic_arvato:datei () + (strcat (getenv "DXFMAKRO") "/tests/testdata/dematic_arvato.json")) + +;; Record um den gebauten Block ergaenzen (oder als Abbruch markieren). +(defun dematic_arvato:rec-block (rec ent fehlertext / ed) + (if (and ent (= (type ent) 'ENAME)) + (progn + (setq ed (entget ent)) + (princ (strcat " -> Block " (cdr (assoc 2 ed)))) + (setq rec (vsp-set rec "block_name" (cdr (assoc 2 ed)))) + (setq rec (vsp-set rec "block_handle" (cdr (assoc 5 ed)))) + (setq rec (vsp-set rec "insert_point" (cdr (assoc 10 ed)))) + (setq rec (vsp-set rec "attribs" (ssg-attrib-read ent))) + (vsp-set rec "status" "executed")) + (progn + (princ (strcat " FEHLER: " fehlertext)) + (vsp-set (vsp-set rec "status" "abbruch") "fehler_text" fehlertext)))) + +;; Foerderer "gerade": noch kein Bau-Pfad - nur melden. +(defun dematic_arvato:gerade-melden (obj / tid rec) + (setq tid (ssg-val obj "test_id")) + (princ (strcat "\n [GERADE] " (if tid tid "?") + " uebersprungen - waagrechter Foerderer noch nicht unterstuetzt")) + (setq rec (vsp-rec-neu (if tid tid "(ohne id)"))) + (setq rec (vsp-set rec "kind" "gerade")) + (vsp-set (vsp-set rec "status" "uebersprungen") "fehler_text" + "kein Bau-Pfad fuer typ gerade")) + +;; ES-Element bei Einlaufneigung w (Grad, bergab) in Fahrtrichtung hz +;; vermessen: horizontale Laenge entlang hz und Abfall von KS_EIN bis KS_AUS. +;; Wie gf-messe-dz-block (Gefaellestrecke.lsp), liefert aber zusaetzlich die +;; Laenge - beide aendern sich mit der Neigung (90-Grad-ES flach ~436 mm +;; lang, bei 43 Grad nur noch ~292 mm). +;; Rueckgabe: (dx dz), dz positiv = nach unten. +(defun dematic_arvato:es-mass (blockname hz w / rad-h rad-v frame-aus ent-vor ent-nach p) + (setq rad-h (* hz (/ pi 180.0)) + rad-v (* w (/ pi 180.0))) + (setq ent-vor (entlast)) + (setq frame-aus + (insert-block-ks-to-ks blockname + (make-frame-from-dir '(0 0 0) + (list (* (cos rad-h) (cos rad-v)) (* (sin rad-h) (cos rad-v)) + (- (sin rad-v)))))) + (setq ent-nach (entlast)) + (if (and ent-nach (not (eq ent-nach ent-vor))) (entdel ent-nach)) + (setq p (car frame-aus)) + (list (+ (* (car p) (cos rad-h)) (* (cadr p) (sin rad-h))) + (- 0.0 (caddr p)))) + +;; Winkel UND Staustreckenlaenge einer GF (Modus 1) aus Start- und Endhoehe, +;; so dass der ES-Auslauf genau auf Hoehe UND Kette des unteren Kreisels +;; liegt. deltaL reicht von AS-KS_EIN bis ES-KS_AUS (horizontal). +;; +;; H = deltaL - aus-dx - es_dx(w) horizontale Laenge der Schraege +;; tan(w) = (dH - aus-dz - es_dz(w)) / H Schraege = Staustrecke + Separator +;; L_stau = H / cos(w) - 300 +;; +;; es_dx/es_dz werden beim aktuellen Winkel gemessen (dematic_arvato:es-mass) +;; und iteriert; das AS liegt flach, aus-dx/aus-dz sind fest. +;; +;; Warum nicht mubea:gf-bauen / gf-winkel-berechnen: +;; - gf-winkel-berechnen rechnet asin(dH / L), also mit SCHRAEGER Laenge +;; (Modus 3); Modus 1 haelt aber die horizontale Laenge fest. Bei 2-3 Grad +;; (Dematic) gleich, bei den steilen Showroom-GF (1860 mm auf 2405 mm) +;; ~50 statt ~43 Grad - die GF endete weit unter dem Kreisel. +;; - mubea:gf-bauen zieht die FLACH gemessene ES-Laenge ein-dx ab. Bei 43 +;; Grad ist das ES horizontal ~144 mm kuerzer, die GF hoerte so 144 mm +;; vor der Kette des unteren Kreisels auf (Hoehe stimmte). +;; VORZEICHEN: vf-set-as-masse misst aus-dz als KS_AUS.z - KS_EIN.z +;; (negativ) - darum der Betrag (Dematic: sonst HOEHE_BIS 1568 statt 1826). +;; Rueckgabe: (winkel L_stau) +(defun dematic_arvato:gf-geometrie (deltaL hz as-seite es-seite as-winkel es-winkel + z-start z-ende / es-block dH es H winkel vorher + iter dx-as dz-as) + (mubea:ensure-gf-init) + (vf-set-as-masse as-winkel as-seite) + (vf-set-es-masse es-winkel es-seite) + (setq es-block (strcat "ES_Element_" es-winkel "_" es-seite) + dx-as (float aus-dx) + dz-as (abs (float aus-dz)) + dH (- z-start z-ende) + es (list (float ein-dx) (abs (float ein-dz))) + vorher -999.0 + iter 0) + (setq H (- deltaL dx-as (car es)) + winkel (* (atan (- dH dz-as (cadr es)) H) (/ 180.0 pi))) + (while (and (< iter 8) (> (abs (- winkel vorher)) 0.0005)) + (setq vorher winkel + es (dematic_arvato:es-mass es-block hz winkel) + H (- deltaL dx-as (car es)) + winkel (* (atan (- dH dz-as (cadr es)) H) (/ 180.0 pi)) + iter (1+ iter))) + (vf-set-as-masse "90" as-seite) + (vf-set-es-masse "90" es-seite) + (list winkel (- (/ H (cos (* winkel (/ pi 180.0)))) 300.0))) + +;; GF mit vorgegebener Staustreckenlaenge einfuegen (wie mubea:gf-bauen, aber +;; L_stau kommt aus dematic_arvato:gf-geometrie statt aus der flachen +;; ES-Laenge). +(defun dematic_arvato:gf-bauen-exakt (tid start-mm deltaL hz as-seite es-seite + as-winkel es-winkel winkel L_stau / ent) + (mubea:ensure-gf-init) + ;; Element-Masse der Variante wie in mubea:gf-bauen, danach zurueck auf 90 + (vf-set-as-masse as-winkel as-seite) + (vf-set-es-masse es-winkel es-seite) + (princ (strcat "\n [GF] " tid " -> Start=(" (rtos (car start-mm) 2 0) + "," (rtos (cadr start-mm) 2 0) "," (rtos (caddr start-mm) 2 0) + ") hz=" (rtos hz 2 0) " deltaL=" (rtos deltaL 2 0) + " winkel=" (rtos winkel 2 3) " L_stau=" (rtos L_stau 2 1))) + (setq ent (car (gefaellestrecke-einfuegen + L_stau winkel start-mm as-seite es-seite hz + deltaL as-winkel es-winkel "0" "Schoenenberger Geruest"))) + (vf-set-as-masse "90" as-seite) + (vf-set-es-masse "90" es-seite) + ent) + +;; Gefaellestrecke (Modus 1) bauen - Felder wie mubea:build-gf, ohne dessen +;; anzahl/delta-Vervielfaeltigung (jede GF steht einzeln in der Datei). +;; Mit "hoehe_ende_mm" (Hoehe des Kreisels am Ende) wird der Winkel daraus +;; gerechnet, sonst gilt "winkel_grad" (Default 3.0). +(defun dematic_arvato:bau-gf (obj / tid start deltaL hz winkel z-ende geo + as-seite es-seite as-winkel es-winkel rec) + (setq tid (ssg-val obj "test_id") + start (ssg-val obj "start_mm") + deltaL (ssg-val obj "deltaL_mm") + hz (ssg-val obj "hz_grad") + winkel (ssg-val obj "winkel_grad") + z-ende (ssg-val obj "hoehe_ende_mm") + as-seite (cond ((ssg-val obj "as_seite")) ("links")) + es-seite (cond ((ssg-val obj "es_seite")) ("links")) + as-winkel (cond ((ssg-val obj "as_winkel")) ("90")) + es-winkel (cond ((ssg-val obj "es_winkel")) ("90"))) + (setq rec (vsp-rec-neu (if tid tid "(ohne id)"))) + (setq rec (vsp-set rec "kind" "gefaellestrecke")) + (setq rec (vsp-set rec "dimension" (vsp-dim-text))) + (cond + ((not (and (= (type start) 'LIST) (= (length start) 3) + (numberp deltaL) (numberp hz))) + (princ (strcat "\n [GF] " (if tid tid "?") + " - FEHLER: start_mm, deltaL_mm und hz_grad muessen gesetzt sein")) + (vsp-set (vsp-set rec "status" "spec-fehler") "fehler_text" + "start_mm, deltaL_mm oder hz_grad fehlt bzw. ist ungueltig")) + ((and (numberp z-ende) (>= z-ende (caddr start))) + (princ (strcat "\n [GF] " (if tid tid "?") + " - FEHLER: hoehe_ende_mm liegt nicht unter der Starthoehe")) + (vsp-set (vsp-set rec "status" "spec-fehler") "fehler_text" + "hoehe_ende_mm >= start_mm.z - kein Gefaelle")) + (T + ;; Mit Endhoehe: Winkel + Staustreckenlaenge exakt (gf-geometrie), + ;; sonst fester Winkel ueber mubea:gf-bauen. + (setq geo (if (numberp z-ende) + (dematic_arvato:gf-geometrie (float deltaL) (float hz) + as-seite es-seite as-winkel es-winkel + (float (caddr start)) (float z-ende)))) + (setq winkel + (cond + (geo (car geo)) + ((numberp winkel) (float winkel)) + (T 3.0))) + ;; Winkel und Soll-Endhoehe als Meldung (das Record-Schema aus vf_spec + ;; kennt dafuer kein Feld); die Ist-Endhoehe steht in attribs HOEHE_BIS. + (setq rec (vsp-set rec "meldungen" + (list (strcat "winkel_grad " (rtos winkel 2 3) + (if (numberp z-ende) + (strcat " aus Hoehe " (rtos (caddr start) 2 1) + " -> " (rtos z-ende 2 1)) + ""))))) + (setq rec + (dematic_arvato:rec-block rec + (if geo + (dematic_arvato:gf-bauen-exakt tid (mapcar 'float start) (float deltaL) + (float hz) as-seite es-seite as-winkel + es-winkel winkel (cadr geo)) + (mubea:gf-bauen tid (mapcar 'float start) (float deltaL) (float hz) + as-seite es-seite as-winkel es-winkel winkel)) + "gefaellestrecke-einfuegen lieferte keinen GF-Block")) + ;; Ist-Endhoehe gegen den Kreisel am Ende pruefen + (dematic_arvato:gf-endhoehe-pruefen rec z-ende)))) + +;; HOEHE_BIS_mm des gebauten GF-Blocks mit der Soll-Endhoehe vergleichen; +;; mehr als 5 mm daneben -> status "warnung" + Meldung (die GF trifft den +;; unteren Kreisel nicht). +(defun dematic_arvato:gf-endhoehe-pruefen (rec z-ende / ist diff) + (setq ist (cdr (assoc "HOEHE_BIS_mm" (ssg-val rec "attribs")))) + (cond + ((not (and (numberp z-ende) ist (= (ssg-val rec "status") "executed"))) rec) + (T + (setq diff (- (atof ist) z-ende)) + (setq rec (vsp-set rec "meldungen" + (append (ssg-val rec "meldungen") + (list (strcat "HOEHE_BIS " ist " (Soll " + (rtos z-ende 2 0) ", Abweichung " + (rtos diff 2 0) " mm)"))))) + (if (> (abs diff) 5.0) + (progn + (princ (strcat "\n WARNUNG: GF endet bei " ist " statt " + (rtos z-ende 2 0))) + (vsp-set rec "status" "warnung")) + rec)))) + +;; VarioFoerderer "standard"/"etage" - mubea-Schema, Bau ueber +;; mubea:vario-bauen. "motorseite" wirkt wie im Edit-Dialog ueber den +;; Override *vf-motorseite* (vf-block-erstellen liest ihn). +(defun dematic_arvato:bau-vf (obj / tid typ rec ent) + (setq tid (ssg-val obj "test_id") + typ (cond ((ssg-val obj "typ")) ("standard"))) + (setq rec (vsp-rec-neu (if tid tid "(ohne id)"))) + (setq rec (vsp-set rec "kind" "vario")) + (setq rec (vsp-set rec "dimension" (vsp-dim-text))) + (setq *vf-motorseite* (ssg-val obj "motorseite")) + (setq ent + (vl-catch-all-apply 'mubea:vario-bauen + (list tid typ (ssg-val obj "richtung") + (float (ssg-val obj "deltaL")) (float (ssg-val obj "deltaH")) + (ssg-val obj "winkel") (float (cond ((ssg-val obj "L_GF1")) (0.0))) + (ssg-val obj "seite") (ssg-val obj "hz") + (list (float (ssg-val obj "x")) (float (ssg-val obj "y")) + (float (ssg-val obj "z")))))) + (setq *vf-motorseite* nil) + (if (vl-catch-all-error-p ent) + (vsp-set (vsp-set rec "status" "abbruch") "fehler_text" + (vl-catch-all-error-message ent)) + (dematic_arvato:rec-block rec ent + "kein VF-Block (deltaL beim gewuenschten Winkel nicht loesbar?)"))) + +;; Linienzug-Kette: aufgezeichnetes Journal ("ART:wert"-Tokens, wie in der +;; SSG_VF_EDIT-XDATA) 1:1 abspielen. Headless-Rahmen wie vsp-bau-datei; er +;; MUSS auch nach einem Fehler zurueck, sonst bleiben getstring/getpoint der +;; Sitzung ersetzt. +(defun dematic_arvato:bau-journal (obj / tid journal res) + (setq tid (cond ((ssg-val obj "test_id")) ("(ohne id)"))) + (setq journal (mapcar 'vfl-string->entry (ssg-val obj "journal"))) + (vsp-headless-an) + (setq res (vl-catch-all-apply 'vsp-bau-journal + (list tid journal nil + (if journal nil (list "Feld \"journal\" fehlt oder ist leer"))))) + (vsp-headless-aus) + (if (vl-catch-all-error-p res) + (vsp-set (vsp-set (vsp-rec-neu tid) "status" "abbruch") "fehler_text" + (vl-catch-all-error-message res)) + res)) + +(defun dematic_arvato:bau-eintrag (obj / kind res typ) + (setq typ (ssg-val obj "typ")) + (cond + ((ssg-val obj "modus") + (setq kind "gefaellestrecke") + (setq res (vl-catch-all-apply 'dematic_arvato:bau-gf (list obj)))) + ((= typ "linienzug_journal") + (setq kind "linienzug") + (setq res (dematic_arvato:bau-journal obj))) + ((and (member typ '("standard" "etage")) (ssg-val obj "test_id")) + (setq kind "vario") + (setq res (dematic_arvato:bau-vf obj))) + ((and (= (ssg-val obj "function") "insert") (ssg-val obj "block")) + (setq kind "sensor") + (setq res (vl-catch-all-apply 'hundm05:bau-sensor (list obj)))) + ((= (ssg-val obj "function") "insert") + (setq kind "kreisel") + (setq res (vl-catch-all-apply 'hundm05:bau-kreisel (list obj)))) + ((= typ "gerade") + (setq kind "gerade") + (setq res (dematic_arvato:gerade-melden obj))) + (T + (setq kind "unbekannt") + (princ "\n WARNUNG: unbekannter Eintrag uebersprungen") + (setq res (vsp-set (vsp-rec-neu "(unbekannt)") "status" "uebersprungen")))) + (if (vl-catch-all-error-p res) + (progn + (princ (strcat "\n [" (strcase kind) "] Ausnahme: " + (vl-catch-all-error-message res))) + (vsp-set (vsp-set (vsp-set (vsp-rec-neu (cond ((ssg-val obj "id")) + ((ssg-val obj "test_id")) + ((ssg-val obj "block")) + ("?"))) + "kind" kind) "status" "abbruch") + "fehler_text" (vl-catch-all-error-message res))) + res)) + +;; Alle Eintraege einer Nachbau-Datei bauen und die Records zurueckgeben +;; (nil bei Fehler vor dem Bau). Gemeinsamer Lauf fuer jeden Treiber mit +;; diesem Eintragsschema - auch tests/test_showroom_ils.lsp. +;; befehl = Name fuer Meldungen/ssg-start, titel = Kopfzeile, datei = JSON +(defun dematic_arvato:bau-datei (befehl titel datei / daten out records zaehler st) + (princ "\n\n================================================================") + (princ (strcat "\n " befehl " - " titel)) + (princ (strcat "\n " datei)) + (princ "\n================================================================") + (cond + ((null (car (atoms-family 1 '("VSP-BAU-JOURNAL")))) + (princ (strcat "\n[" befehl "] FEHLER: vf_spec.lsp nicht geladen" + " (VarioFoerderer laden).")) + nil) + ((null (findfile datei)) + (princ (strcat "\n[" befehl "] FEHLER: " datei " nicht gefunden!")) + nil) + (T + (setq daten (ssg-json-laden datei)) + (princ (strcat "\n " (itoa (length daten)) " Eintraege geladen")) + (ssg-start befehl '(("OSMODE") ("CECOLOR") ("ATTREQ") ("ATTDIA"))) + (setvar "OSMODE" 0) + (setvar "ATTREQ" 0) + (setvar "ATTDIA" 0) + ;; Vario-Bibliothek (Bogen-/AS-/ES-Masse) wie C:TEST_MUBEA, und die + ;; GF-Elementmasse in jeder Zeichnung neu ermitteln. + (if (vsp-lib-noetig-p) (init-bibliothek)) + (setq *mubea-gf-init-done* nil) + (setq out '()) + (foreach obj daten + (setq out (cons (dematic_arvato:bau-eintrag obj) out))) + (ssg-end) + (setq records (reverse out)) + ;; Zusammenfassung je Status + (setq zaehler '()) + (foreach r records + (setq st (cond ((ssg-val r "status")) ("?"))) + (if (assoc st zaehler) + (setq zaehler (subst (cons st (1+ (cdr (assoc st zaehler)))) + (assoc st zaehler) zaehler)) + (setq zaehler (cons (cons st 1) zaehler)))) + (princ "\n================================================================") + (foreach z (reverse zaehler) + (princ (strcat "\n " (car z) ": " (itoa (cdr z))))) + (princ "\n================================================================") + (command "_.ZOOM" "_E") + records))) + +(defun c:TEST_DEMATIC_ARVATO () + (setq *dematic-arvato-records* + (dematic_arvato:bau-datei "TEST_DEMATIC_ARVATO" "Abschnitt Flowpuffer/Kreisel" + (dematic_arvato:datei))) + (princ)) + +;; Ergebnis-Export (Konvention :export-results fuer test_run_all.lsp) +(defun dematic_arvato:export-results (out-dir / pfad) + (if (null *dematic-arvato-records*) + (princ "\n Keine Dematic/Arvato-Ergebnisse vorhanden.") + (progn + (vl-mkdir out-dir) + (setq pfad (strcat out-dir "/dematic_arvato_results.json")) + (vsp-results-schreiben *dematic-arvato-records* pfad))) + (princ)) + +(princ "\nTEST_DEMATIC_ARVATO geladen. Aufruf: TEST_DEMATIC_ARVATO") +(princ) diff --git a/tests/test_dxf_anlage_export.py b/tests/test_dxf_anlage_export.py new file mode 100644 index 0000000..22fb36f --- /dev/null +++ b/tests/test_dxf_anlage_export.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +test_dxf_anlage_export.py - Gebaute Anlage -> Nachbau-Testdaten +(lib/dxf_anlage_export.py). Laeuft ohne BricsCAD und ohne DXF: die +Wrapper-Daten sind die Werte aus Dematic_TST.dxf, von Hand nachgestellt +(Form wie lese_zeichnung sie liefert). + + 1. Kreisel: abstand exakt aus der Blockdefinition (AN8 -> SP8), nicht aus + dem ganzzahligen ABSTAND-Attribut. + 2. GF auf zwei Kreiselketten: Endhoehe = Hoehe des Kreisels am Ende, + der (falsch) gebaute Winkel wird NICHT uebernommen. + 3. GF ohne Kreisel am Ende: gebauter Winkel bleibt. + 4. VF "standard": Parameter wie vfs-edit-basis-lesen, L_GF1 aus L_GF_m. + 5. VF "linienzug": Journal unveraendert als Token-Liste. + 6. Einzelblock: _2D/_3D-Suffix entfaellt. +""" + +import os +import sys + +import pytest + +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), + "..", "lib")) +import dxf_anlage_export as dae # noqa: E402 + + +def _insert(name, p, rot=0.0, attribs=None, xdata=None): + return {"name": name, "handle": "1", "p": list(p), "rot": rot, + "attribs": attribs or {}, "xdata": xdata or {}, "ps": 0} + + +KREISEL_OBEN = _insert("KREISEL_2_STANDARD_33044", (35860.37, 12519.72, 2437.0), + 180.0, {"ID": "0002", "NUMMER": "2", "ABSTAND": "33044", + "KREISELART": "STANDARD"}) +KREISEL_UNTEN = _insert("KREISEL_3_STANDARD_33470", (36661.24, 24878.8, 1826.0), + 180.0, {"ID": "0003", "NUMMER": "3", "ABSTAND": "33470", + "KREISELART": "STANDARD"}) +BLOCK_INHALT = { + "KREISEL_2_STANDARD_33044": [{"name": "AN8_3D", "p": [400.0, 0.0, 0.0]}, + {"name": "SP8_3D", "p": [33444.28, 0.0, 0.0]}], + "KREISEL_3_STANDARD_33470": [{"name": "AN8_3D", "p": [400.0, 0.0, 0.0]}, + {"name": "SP8_3D", "p": [33870.18, 0.0, 0.0]}], +} + + +def _geo(): + return [dae.kreisel_geo(dae.kreisel_eintrag(k, BLOCK_INHALT, "T")) + for k in (KREISEL_OBEN, KREISEL_UNTEN)] + + +def test_kreisel_abstand_aus_blockdefinition(): + k = dae.kreisel_eintrag(KREISEL_OBEN, BLOCK_INHALT, "T") + assert k["id"] == "Kreisel_T_02" + assert k["abstand"] == pytest.approx(33044.28, abs=0.01) + assert (k["x"], k["y"], k["z"], k["rotation"]) == (35860.37, 12519.72, 2437.0, 180.0) + ohne_block = dae.kreisel_eintrag(KREISEL_OBEN, {}, "T") + assert ohne_block["abstand"] == 33044.0 + assert k["drehrichtung"] == "UZS" # Attribut fehlt -> Vorgabe + + +def test_kreisel_drehrichtung_aus_attribut(): + guz = _insert("KREISEL_4_STANDARD_3619", (42563.78, 1703.66, 2177.0), 90.0, + {"NUMMER": "4", "DREHRICHTUNG": "GUZ"}) + assert dae.kreisel_eintrag(guz, {}, "T")["drehrichtung"] == "GUZ" + + +def test_gf_zwischen_zwei_kreiseln_bekommt_endhoehe(): + gf = _insert("GF_1", (5833.56, 12919.72, 2437.0), 0.0, + {"ID": "0005", "SEITE_AS": "links", "SEITE_ES": "links", + "HOEHE_BIS_mm": "1568"}, + {"SSG_GF_EDIT": ["90", "3.7929", "90", "90", "2437", "11559.08"]}) + hinweise = [] + e = dae.gf_eintrag(gf, _geo(), "T", hinweise) + assert e["test_id"] == "GF_T_01" + assert e["start_mm"] == [5833.56, 12919.72, 2437.0] + assert e["deltaL_mm"] == 11559.08 and e["hz_grad"] == 90.0 + assert (e["kreisel_start"], e["kreisel_ende"]) == ("Kreisel_T_02", "Kreisel_T_03") + assert e["hoehe_ende_mm"] == 1826.0 + assert "winkel_grad" not in e + assert hinweise == [] + + +def test_gf_ohne_kreisel_behaelt_gebauten_winkel(): + gf = _insert("GF_7", (0.0, 0.0, 1000.0), 0.0, {}, + {"SSG_GF_EDIT": ["0", "3", "90", "30", "1000", "5000"]}) + e = dae.gf_eintrag(gf, _geo(), "T", []) + assert e["winkel_grad"] == 3.0 + assert "hoehe_ende_mm" not in e and "kreisel_ende" not in e + assert e["es_winkel"] == "30" + + +def test_gf_ohne_xdata_wird_gemeldet(): + hinweise = [] + assert dae.gf_eintrag(_insert("GF_9", (0, 0, 0)), [], "T", hinweise) is None + assert "SSG_GF_EDIT" in hinweise[0] + + +def test_vf_standard(): + vf = _insert("VF_2", (3314.07, 24478.8, 1826.0), 0.0, + {"ID": "0082", "DELTA_L_mm": "11559", "DELTA_H_mm": "611", + "ANTRIEBFAHRTRICHTUNG": "Auf", "SEITE_AS": "links", + "MOTORSEITE": "rechts", "VF_WINKEL": "15", + "L_GF_m": "1.907,1.907"}, + {"SSG_VF_EDIT": ["standard", "270"]}) + e = dae.vf_standard_eintrag(vf, "T", "standard") + assert e["test_id"] == "VF_T_02" + assert (e["richtung"], e["deltaL"], e["deltaH"], e["winkel"]) == ("Auf", 11559.0, 611.0, 15) + assert e["L_GF1"] == 1907.0 and e["hz"] == 270.0 + assert (e["seite"], e["motorseite"]) == ("links", "rechts") + assert (e["x"], e["y"], e["z"]) == (3314.07, 24478.8, 1826.0) + + +def test_vf_linienzug_journal_unveraendert(): + roh = ["linienzug", "PT:42161.679193,2448.319538,0^JREAL:2177^JSTR:1^JSTR:9", + "0^JSTEP:Linie-VF^JDL:9370.410886"] + vf = _insert("VF_26", (42161.68, 2448.32, 2177.0), 0.0, {"ID": "0184"}, + {"SSG_VF_EDIT": roh}) + e = dae.vf_journal_eintrag(vf, "T", 1) + assert e["typ"] == "linienzug_journal" and e["test_id"] == "VF_T_LZ_01" + # Chunk-Grenze mitten im Token ("STR:9" + "0") wird korrekt zusammengesetzt + assert e["journal"] == ["PT:42161.679193,2448.319538,0", "REAL:2177", "STR:1", + "STR:90", "STEP:Linie-VF", "DL:9370.410886"] + + +def test_einzelblock_ohne_dimensionssuffix(): + e = dae.einzel_eintrag(_insert("Separator_SP_3D", (3038.72, 12119.73, 2473.0), + 0.0, {"ID": "0043", "ZUORDNUNG": "0002"})) + assert e["block"] == "Separator_SP" + assert e["function"] == "insert" and e["z"] == 2473.0 + assert "ID 0043" in e["comment"] + + +def test_reihenfolge_vf_vor_gf(): + inserts = [ + _insert("GF_1", (5833.56, 12919.72, 2437.0), 0.0, {}, + {"SSG_GF_EDIT": ["90", "3", "90", "90", "2437", "11559.08"]}), + _insert("Scanner_3D", (1, 2, 3)), + _insert("VF_2", (0, 0, 0), 0.0, {}, {"SSG_VF_EDIT": ["standard", "0"]}), + KREISEL_OBEN, KREISEL_UNTEN, + _insert("*U12", (0, 0, 0)), + ] + eintraege, _ = dae.baue_eintraege(inserts, BLOCK_INHALT, "T") + art = ["K" if "abstand" in e else "GF" if "modus" in e else + "VF" if "typ" in e else e["block"] for e in eintraege] + assert art == ["K", "K", "VF", "GF", "Scanner"] diff --git a/tests/test_dxf_scan_gf.py b/tests/test_dxf_scan_gf.py new file mode 100644 index 0000000..3768974 --- /dev/null +++ b/tests/test_dxf_scan_gf.py @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +test_dxf_scan_gf.py - Gefaellestrecken aus Staustrecken-Linien +(gf_eintraege_aus_linien in lib/dxf_scan_components.py). Laeuft ohne +BricsCAD und ohne DXF: die Linien und Ausschleuselemente sind die +gemessenen Werte aus Dematic_arvato_reduced.dxf, von Hand nachgestellt. + + 1. Fallende Linie mit AS am oberen Ende -> GF, AS wird verbraucht. + 2. Der Nachbar-AS der Linie daneben (800 mm Raster, auf der anderen Seite + naeher dran) wird NICHT gegriffen - die Seite aus dem Blocknamen + entscheidet, nicht der kleinste Abstand. + 3. Rueckwaerts gezeichnete GF (tiefes Ende zuerst) -> Start bleibt oben. + 4. AS am UNTEREN Ende -> Steigfoerderer, keine GF, AS bleibt unverbraucht. + 5. Waagrechte Linie -> keine GF. + 6. Anschluss an die Kreisel: Start/Ende werden auf die Ketten geschoben, + deltaL reicht von Kette zu Kette; Hoehen kommen von den Kreiseln. + 7. Separator auf der Achse wird verbraucht, einer daneben nicht. + 8. hoehen_entfernen laesst nur Anwender-Hoehen stehen. +""" + +import os +import sys + +import pytest + +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), + "..", "lib")) +import dxf_scan_components as dsc # noqa: E402 + +AS_LINKS = "Ausschleuselement links 200000217 Draufsicht" + + +def _as(x, y, z=3191.63, block=AS_LINKS): + return {"familie": "schleuselement", "block": block, + "x": x, "y": y, "z": z, "rot": 270.0} + + +def _linie(a, b, layer="6-SP"): + return {"layer": layer, "a": list(a), "b": list(b)} + + +@pytest.fixture(autouse=True) +def _projekt(monkeypatch): + monkeypatch.setattr(dsc, "PROJEKT", "Test") + + +# Die beiden Kreisel am GF-Feld (Radmitten AN8 -> SP8, r = 400), wie +# baue_eintraege sie als kreisel_geo anlegt. Ketten: oben y = 12919.72, +# unten y = 24478.8. +def _kreisel_oben(z=2437.0): + return {"id": "K_oben", "a": (35460.37, 12519.72), "u": (-1.0, 0.0), + "laenge": 33044.28, "r": 400.0, "z_anwender": z} + + +def _kreisel_unten(z=1826.0): + return {"id": "K_unten", "a": (36261.24, 24878.8), "u": (-1.0, 0.0), + "laenge": 33470.18, "r": 400.0, "z_anwender": z} + + +def test_gf_mit_as_am_oberen_ende(): + linie = _linie((5833.56, 13348.38, 3191.63), (5833.44, 24002.54, 2821.63)) + as_eigen = _as(5367.10, 14505.61) + eintraege, belegt, hinweise = dsc.gf_eintraege_aus_linien([linie], [as_eigen]) + assert len(eintraege) == 1 + gf = eintraege[0] + assert gf["test_id"] == "GF_Test_01" + assert gf["modus"] == 1 + # ohne Kreisel: Linienende bleibt stehen, Hoehe unbekannt -> Platzhalter + assert gf["start_mm"] == [5833.56, 13348.38, 0.0] + assert gf["deltaL_mm"] == pytest.approx(10654.16, abs=0.01) + assert gf["hz_grad"] == 90.0 + assert gf["winkel_grad"] == 3.0 + assert gf["hoehe_unbekannt"] is True + assert (gf["as_seite"], gf["as_winkel"]) == ("links", "90") + assert belegt == {id(as_eigen)} + assert len(hinweise) == 2 and all("kein Kreisel" in h for h in hinweise) + + +def test_anschluss_an_beide_kreisel_mit_hoehen(): + linie = _linie((5833.56, 13348.38, 3191.63), (5833.44, 24002.54, 2821.63)) + eintraege, _, hinweise = dsc.gf_eintraege_aus_linien( + [linie], [_as(5367.10, 14505.61)], [_kreisel_oben(), _kreisel_unten()]) + gf = eintraege[0] + assert gf["start_mm"][1] == pytest.approx(12919.72, abs=0.01) + assert gf["start_mm"][2] == 2437.0 + assert gf["hoehe_ende_mm"] == 1826.0 + assert gf["hoehe_quelle"] == "Anwender" + assert "winkel_grad" not in gf # rechnet der LISP-Treiber + assert gf["deltaL_mm"] == pytest.approx(24478.8 - 12919.72, abs=0.05) + assert (gf["kreisel_start"], gf["kreisel_ende"]) == ("K_oben", "K_unten") + assert hinweise == [] + + +def test_kreisel_ohne_hoehe_gibt_platzhalter(): + linie = _linie((5833.56, 13348.38, 3191.63), (5833.44, 24002.54, 2821.63)) + eintraege, _, _ = dsc.gf_eintraege_aus_linien( + [linie], [], [_kreisel_oben(z=None), _kreisel_unten()]) + assert eintraege[0]["kreisel_start"] == "K_oben" + assert "hoehe_ende_mm" not in eintraege[0] + assert eintraege[0]["winkel_grad"] == 3.0 + + +def test_separator_auf_achse_wird_verbraucht(): + linie = _linie((5833.56, 13348.38, 3191.63), (5833.44, 24002.54, 2821.63)) + sep_achse = {"familie": "sensor", "block": "S-SP", "x": 5834.0, "y": 23810.0} + sep_daneben = {"familie": "sensor", "block": "S-SP", "x": 6734.0, "y": 23810.0} + scanner = {"familie": "sensor", "block": "Scanner", "x": 5834.0, "y": 20000.0} + _, belegt, _ = dsc.gf_eintraege_aus_linien( + [linie], [], [_kreisel_oben(), _kreisel_unten()], + [sep_achse, sep_daneben, scanner]) + assert belegt == {id(sep_achse)} + + +def test_hoehen_entfernen_laesst_anwender_hoehen_stehen(): + eintraege = [ + {"id": "K1", "x": 0, "y": 0, "z": 2437.0, "hoehe_quelle": "Anwender"}, + {"block": "S-SP", "x": 0, "y": 0, "z": 2821.63, "comment": ""}, + {"test_id": "G", "typ": "gerade", "startpunkt": [0, 0, 5.0], + "endpunkt": [1, 0, 5.0]}, + ] + assert dsc.hoehen_entfernen(eintraege) == 2 + assert eintraege[0]["z"] == 2437.0 + assert eintraege[1]["z"] == 0.0 and eintraege[1]["hoehe_unbekannt"] is True + assert eintraege[2]["startpunkt"][2] == 0.0 and eintraege[2]["endpunkt"][2] == 0.0 + + +def test_nachbar_as_auf_falscher_seite_wird_nicht_gegriffen(): + # Linie bei x=5834; ihr AS 467 mm links, der AS der Nachbarlinie + # (x=6734) 433 mm RECHTS - also naeher, aber auf der falschen Seite. + linie = _linie((5833.56, 13348.38, 3191.63), (5833.44, 24002.54, 2821.63)) + as_eigen = _as(5367.10, 14505.61) + as_nachbar = _as(6267.10, 14505.61) + _, belegt, _ = dsc.gf_eintraege_aus_linien([linie], [as_nachbar, as_eigen]) + assert belegt == {id(as_eigen)} + + +def test_rueckwaerts_gezeichnete_gf_startet_oben(): + linie = _linie((5833.44, 24002.54, 2821.63), (5833.56, 13348.38, 3191.63)) + eintraege, _, _ = dsc.gf_eintraege_aus_linien([linie], [_as(5367.10, 14505.61)]) + assert eintraege[0]["start_mm"][:2] == [5833.56, 13348.38] + assert eintraege[0]["hz_grad"] == 90.0 + + +def test_as_am_unteren_ende_ist_steigfoerderer(): + # Gemessen: Linie x=2801 von 2822 hinauf auf 3192, AS am tiefen Ende. + linie = _linie((2801.42, 24043.0, 2821.63), (2801.42, 13389.0, 3191.63)) + as_unten = _as(3267.48, 22892.92, z=2821.63) + eintraege, belegt, hinweise = dsc.gf_eintraege_aus_linien([linie], [as_unten]) + assert eintraege == [] + assert belegt == set() + assert len(hinweise) == 1 and "Steigfoerderer" in hinweise[0] + + +def test_waagrechte_linie_ist_keine_gf(): + linie = _linie((36661.0, 10279.0, 2821.63), (36661.0, 24879.0, 2821.63)) + eintraege, belegt, hinweise = dsc.gf_eintraege_aus_linien([linie], []) + assert eintraege == [] + assert belegt == set() + assert any("waagrechte" in h for h in hinweise) + + +def test_ohne_as_defaults_und_hinweis(): + linie = _linie((0.0, 0.0, 1000.0), (5000.0, 0.0, 800.0)) + eintraege, _, hinweise = dsc.gf_eintraege_aus_linien([linie], []) + assert eintraege[0]["hz_grad"] == 0.0 + assert eintraege[0]["as_seite"] == dsc.DEFAULT_SEITE + assert any("ohne Ausschleuselement" in h for h in hinweise) + + +# --- Showroom_ILS_3_0.dxf: flacher 2D-Plan, Werte dort gemessen ------------- + +def _station(x, y): + return {"x": x, "y": y} + + +def test_kreisel_paare_zwei_kreisel_auf_einer_achse(): + # x=26998: AN8 y=3466 / SP8 y=12499 und AN8 y=13299 / SP8 y=16299. Die + # Luecke SP8(12499)-AN8(13299) = 800 ist das kuerzeste Paar - ohne + # Tausch-Nachbesserung kamen 800 + 12833 statt 9033 + 3000 heraus. + an = [_station(26998.0, 3466.4), _station(26998.0, 13298.9)] + sp = [_station(26998.0, 16298.9), _station(26998.0, 12498.9)] + paare, an_rest, sp_rest = dsc.kreisel_paare_bilden(an, sp) + assert an_rest == [] and sp_rest == [] + abstaende = sorted(round(p[2], 1) for p in paare) + assert abstaende == [3000.0, 9032.5] + + +def test_zerstueckelte_linie_wird_vereint(): + # GF bei x=34006 in vier Stuecken, das Separatorstueck 0,3 mm daneben + stuecke = [ + _linie((34005.93, 13893.90, 0.0), (34005.93, 14193.90, 0.0)), + _linie((34005.93, 15043.90, 0.0), (34005.93, 15593.90, 0.0)), + _linie((34006.24, 14744.31, 0.0), (34006.24, 15044.31, 0.0)), + _linie((34005.93, 14193.90, 0.0), (34005.93, 14743.90, 0.0)), + ] + vereint = dsc.linien_zusammenfassen(stuecke) + assert len(vereint) == 1 + ys = sorted([vereint[0]["a"][1], vereint[0]["b"][1]]) + assert ys == pytest.approx([13893.90, 15593.90], abs=0.01) + + +def test_parallele_nachbarlinie_wird_nicht_vereint(): + linien = [_linie((0.0, 0.0, 0.0), (0.0, 1000.0, 0.0)), + _linie((800.0, 1000.0, 0.0), (800.0, 2000.0, 0.0))] + assert len(dsc.linien_zusammenfassen(linien)) == 2 + + +def _kreisel_d(): + # Schleife oben (Kette unten y=15898.9), Radmitten per --kreisel-achse + return {"id": "K_D", "a": (27797.93, 16298.9), "u": (1.0, 0.0), + "laenge": 8908.0, "r": 400.0, "z_anwender": None} + + +def _kreisel_e(): + # Schleife Mitte (Kette oben y=13493.9) + return {"id": "K_E", "a": (28772.93, 13093.9), "u": (1.0, 0.0), + "laenge": 6533.0, "r": 400.0, "z_anwender": None} + + +def test_flacher_plan_richtung_und_seiten_aus_as_es(): + # Waagrechte Linie; AE-D sitzt 305 mm VOR dem oberen Ende auf der + # Kreisel-Kette, 180 mm links der Fahrtrichtung (Fahrt -y, links = +x). + # EE-R am unteren Ende 212 mm rechts davon. + linie = _linie((30455.93, 13893.9, 0.0), (30455.93, 15593.9, 0.0)) + ae = {"familie": "schleuselement", "block": "AE-D", + "x": 30636.27, "y": 15898.9, "z": 0.0, "rot": 270.0} + ee = {"familie": "schleuselement", "block": "EE-R", + "x": 30243.76, "y": 13493.9, "z": 0.0, "rot": 90.0} + eintraege, belegt, _ = dsc.gf_eintraege_aus_linien( + [linie], [ae], [_kreisel_d(), _kreisel_e()], es_liste=[ee], flach=True) + assert len(eintraege) == 1 + gf = eintraege[0] + assert gf["hz_grad"] == 270.0 + assert gf["start_mm"][:2] == [30455.93, 15898.9] + assert gf["deltaL_mm"] == pytest.approx(2405.0, abs=0.01) + assert (gf["as_seite"], gf["es_seite"]) == ("links", "rechts") + assert (gf["kreisel_start"], gf["kreisel_ende"]) == ("K_D", "K_E") + assert belegt == {id(ae), id(ee)} + + +def test_flacher_plan_ohne_flach_schalter_keine_gf(): + linie = _linie((30455.93, 13893.9, 0.0), (30455.93, 15593.9, 0.0)) + ae = {"familie": "schleuselement", "block": "AE-D", + "x": 30636.27, "y": 15898.9, "z": 0.0, "rot": 270.0} + eintraege, _, _ = dsc.gf_eintraege_aus_linien([linie], [ae]) + assert eintraege == [] + + +def test_flacher_plan_ohne_as_keine_gf(): + # Staulinie am Kreisel B (x=36348) - kein AS an einem Ende + linie = _linie((36347.6, 11313.9, 0.0), (36347.6, 14913.9, 0.0)) + eintraege, _, hinweise = dsc.gf_eintraege_aus_linien([linie], [], flach=True) + assert eintraege == [] + assert any("waagrechte" in h for h in hinweise) + + +def test_kurznamen_ae_ee(): + assert dsc.familie_von("AE-D") == "schleuselement" + assert dsc.familie_von("EE-R") == "schleuselement" + assert dsc.mappe_block("AE-D")[0].startswith("AS_Element_90_") + assert dsc.mappe_block("EE-R")[0].startswith("ES_Element_90_") + + +def test_sensor_bekommt_hoehe_des_kreisels(): + # Kreisel_Showroom_03: Einfuegepunkt (37105.93, 9888.9), rotation 180, + # Ketten y=9488.9/10288.9. Separator auf der Kette, Scanner 280 mm + # innerhalb, ein Teil 1000 mm daneben bleibt unberuehrt. + kreisel = {"id": "K3", "x": 37105.93, "y": 9888.9, "z": 1700.0, + "abstand": 7200.0, "rotation": 180.0, "hoehe_quelle": "Anwender"} + sep = {"function": "insert", "block": "S-LP", "x": 30343.39, "y": 9488.9, + "z": 0.0, "hoehe_unbekannt": True, "comment": ""} + scan = {"function": "insert", "block": "Scanner", "x": 35905.93, + "y": 10008.9, "z": 0.0, "comment": ""} + weit = {"function": "insert", "block": "S-LP", "x": 33000.0, "y": 11300.0, + "z": 0.0, "comment": ""} + assert dsc.sensor_hoehen_von_kreiseln([kreisel, sep, scan, weit]) == 2 + assert sep["z"] == 1700.0 and "hoehe_unbekannt" not in sep + assert scan["z"] == 1700.0 + assert weit["z"] == 0.0 + + +def test_sensor_ohne_anwender_hoehe_bleibt(): + kreisel = {"id": "K", "x": 0.0, "y": 0.0, "z": 0.0, "abstand": 5000.0, + "rotation": 0.0} + sep = {"function": "insert", "block": "S-LP", "x": 1000.0, "y": 400.0, + "z": 0.0, "comment": ""} + assert dsc.sensor_hoehen_von_kreiseln([kreisel, sep]) == 0 diff --git a/tests/test_export_kreisel_umlauf.py b/tests/test_export_kreisel_umlauf.py index 2d712b3..b2bce05 100644 --- a/tests/test_export_kreisel_umlauf.py +++ b/tests/test_export_kreisel_umlauf.py @@ -485,3 +485,56 @@ class TestAsEsImKreiselUmlauf: keys = [p[0] for p in umlauf["0001"]] assert "0057" not in keys, ( "ES-Item weit ausserhalb der Kreiselbox wurde faelschlich erkannt") + + +def _trans(x, y, z=0.0): + """Gegenstueck zu _decode_trans_xy (csv:trans-encode in export.lsp): drei + vorzeichenbehaftete 24-Bit-Fixed-Point-Werte (Faktor 10), je 4 Zeichen.""" + from export_neighbors import _B64_CHARS + text = "" + for v in (x, y, z): + n = int(round(v * 10.0)) & 0xFFFFFF + text += "".join(_B64_CHARS[(n >> s) & 63] for s in (18, 12, 6, 0)) + return text + + +def _strecke(teileid, k1_xy, k2_xy): + return {"teileart": "ILS 2.0 Strecke", "teileid": teileid, + "k1": _trans(*k1_xy), "k2": _trans(*k2_xy)} + + +class TestAsEsUeberEinlaufpunkt: + """Dematic/Arvato VF_5 an Kreisel1 (Review 2026-10-08): die Strecke laeuft + PARALLEL zum Kreisel, der 90-Grad-Einlauf (KS_EIN) liegt darum quer zur + Kette - Marker (Einfuegepunkt) 557 mm neben der Kette, Einlauf nur 52 mm + davor. Kreisel entlang +Y, rechte Kette bei x = +400.""" + + def _kreisel_y(self): + return _kreisel("0001", 0.0, 0.0, 90.0, abstand=3619.0) + + def test_marker_daneben_einlauf_auf_der_kette(self): + items = [self._kreisel_y(), + _separator("0043", 400.0, 1500.0), + _ases("ILS Ausschleuselement", "0071", 957.0, 2283.0, "0009"), + _strecke("0009", (348.0, 2283.0), (348.0, 9000.0))] + umlauf = compute_kreisel_umlauf( + items, tolerance_mm=200.0, durchmesser_mm=DURCHMESSER_MM) + punkte = {p[0]: p for p in umlauf["0001"]} + assert "0071" in punkte, "AS ueber den Einlaufpunkt nicht im Umlauf" + # nach dem Einlauf einsortiert, nicht nach dem Marker + assert len(umlauf["0001"]) == 2 + + def test_ohne_einlaufpunkt_bleibt_es_bei_der_marker_box(self): + items = [self._kreisel_y(), + _ases("ILS Ausschleuselement", "0071", 957.0, 2283.0, "0009")] + umlauf = compute_kreisel_umlauf( + items, tolerance_mm=200.0, durchmesser_mm=DURCHMESSER_MM) + assert "0071" not in [p[0] for p in umlauf["0001"]] + + def test_einlauf_weit_weg_wird_nicht_zugeordnet(self): + items = [self._kreisel_y(), + _ases("ILS Ausschleuselement", "0071", 957.0, 2283.0, "0009"), + _strecke("0009", (5000.0, 2283.0), (9000.0, 2283.0))] + umlauf = compute_kreisel_umlauf( + items, tolerance_mm=200.0, durchmesser_mm=DURCHMESSER_MM) + assert "0071" not in [p[0] for p in umlauf["0001"]] diff --git a/tests/test_hm_recformat.lsp b/tests/test_hm_recformat.lsp index bbd5972..3347780 100644 --- a/tests/test_hm_recformat.lsp +++ b/tests/test_hm_recformat.lsp @@ -10,7 +10,7 @@ ;; roh aus der XDATA einer echten Zeichnung. Damit ist dies der einzige Test, ;; der belegt, dass ein BESTEHENDER VF_n-Block weiter abspielbar bleibt - ;; also dass Doppelklick-Editieren und 2D/3D-Konvertierung an Altbestand -;; funktionieren (Invariante I1 in doc/TODO-plan-vf-interactive.md). Ein +;; funktionieren (Invariante I1 in doc/todo/plan-vf-interactive.md). Ein ;; spec-gebautes Journal kann das nicht zeigen, es kommt aus dem Uebersetzer. ;; ;; Darum in tests/alltests.json auf "disabled": true - er baut dieselbe diff --git a/tests/test_hundm05.lsp b/tests/test_hundm05.lsp index e579570..bf972ca 100644 --- a/tests/test_hundm05.lsp +++ b/tests/test_hundm05.lsp @@ -78,14 +78,15 @@ ;; Rueckgabe: Ergebnis-Record in derselben Form wie die Ketten, damit ;; vsp-results-schreiben beide in EINE Datei schreibt (unterschieden ueber ;; das Feld "kind"). -(defun hundm05:bau-kreisel (obj / id x y z abstand rotation typ pt ent ed rec) +(defun hundm05:bau-kreisel (obj / id x y z abstand rotation typ drehrichtung pt ent ed rec) (setq id (ssg-val obj "id")) (setq x (ssg-val obj "x") y (ssg-val obj "y") z (ssg-val obj "z") abstand (ssg-val obj "abstand") rotation (ssg-val obj "rotation") - typ (ssg-val obj "typ")) + typ (ssg-val obj "typ") + drehrichtung (ssg-val obj "drehrichtung")) (if (numberp x) (setq x (float x))) (if (numberp y) (setq y (float y))) (if (numberp z) (setq z (float z))) @@ -106,9 +107,9 @@ (princ (strcat "\n [KREISEL] " id " -> (" (rtos x 2 0) ", " (rtos y 2 0) ", " (rtos (if z z 0.0) 2 0) ") A=" (rtos abstand 2 0) " R=" (rtos (if rotation rotation 0.0) 2 1) - " " typ)) + " " typ (if drehrichtung (strcat " " drehrichtung) ""))) (setq ent (kreisel-insert-script pt abstand - (if rotation rotation 0.0) typ z)) + (if rotation rotation 0.0) typ z drehrichtung)) (if ent (progn (setq ed (entget ent)) @@ -138,6 +139,10 @@ (defun hundm05:bau-sensor (obj / id blockname x y z rotation pt eff n vorher ent ed attribs rec) (setq id (ssg-val obj "id")) (setq blockname (ssg-val obj "block")) + ;; Eintraege aus lib/dxf_scan_components.py haben kein "id" - die + ;; Meldungen unten setzen id per strcat zusammen und brachen dann mit + ;; "bad argument type " ab. + (if (null id) (setq id (cond (blockname) ("(ohne id)")))) (setq x (ssg-val obj "x") y (ssg-val obj "y") z (ssg-val obj "z") diff --git a/tests/test_kreisel.lsp b/tests/test_kreisel.lsp index 531fdb9..4ab63a2 100644 --- a/tests/test_kreisel.lsp +++ b/tests/test_kreisel.lsp @@ -52,8 +52,8 @@ ;; --- Einzelnen Insert-Testfall ausfuehren --- (defun kreisel:run-insert-test (eintrag / id x y z abstand rotation typ - pt blockEnt ed attribs block-name - block-handle insert-point) + drehrichtung pt blockEnt ed attribs + block-name block-handle insert-point) (setq id (ssg-val eintrag "id")) (setq x (ssg-val eintrag "x")) (setq y (ssg-val eintrag "y")) @@ -61,6 +61,7 @@ (setq abstand (ssg-val eintrag "abstand")) (setq rotation (ssg-val eintrag "rotation")) (setq typ (ssg-val eintrag "typ")) + (setq drehrichtung (ssg-val eintrag "drehrichtung")) (if (numberp x) (setq x (float x))) (if (numberp y) (setq y (float y))) @@ -71,9 +72,10 @@ (setq pt (list x y z)) (princ (strcat "\n [INSERT] " id " -> (" (rtos x 2 0) ", " (rtos y 2 0) ", " (rtos z 2 0) ") A=" (rtos abstand 2 0) - " R=" (rtos rotation 2 1) " " typ)) + " R=" (rtos rotation 2 1) " " typ + (if drehrichtung (strcat " " drehrichtung) ""))) - (setq blockEnt (kreisel-insert-script pt abstand rotation typ z)) + (setq blockEnt (kreisel-insert-script pt abstand rotation typ z drehrichtung)) (if blockEnt (progn diff --git a/tests/test_mubea.lsp b/tests/test_mubea.lsp index 3d92a29..982a6b6 100644 --- a/tests/test_mubea.lsp +++ b/tests/test_mubea.lsp @@ -119,19 +119,20 @@ ;; ============================================================ ;; --- Kreisel (wie test_kreisel: kreisel-insert-script) --- -(defun mubea:build-kreisel (e / id x y z abstand rotation typ pt ent) - (setq id (ssg-val e "id") - x (float (ssg-val e "x")) - y (float (ssg-val e "y")) - z (float (ssg-val e "z")) - abstand (float (ssg-val e "abstand")) - rotation (float (ssg-val e "rotation")) - typ (ssg-val e "typ")) +(defun mubea:build-kreisel (e / id x y z abstand rotation typ drehrichtung pt ent) + (setq id (ssg-val e "id") + x (float (ssg-val e "x")) + y (float (ssg-val e "y")) + z (float (ssg-val e "z")) + abstand (float (ssg-val e "abstand")) + rotation (float (ssg-val e "rotation")) + typ (ssg-val e "typ") + drehrichtung (ssg-val e "drehrichtung")) (if (null typ) (setq typ "STANDARD")) (setq pt (list x y z)) (princ (strcat "\n [KREISEL] " id " -> (" (rtos x 2 0) "," (rtos y 2 0) "," (rtos z 2 0) ") A=" (rtos abstand 2 0) " R=" (rtos rotation 2 1))) - (setq ent (kreisel-insert-script pt abstand rotation typ z)) + (setq ent (kreisel-insert-script pt abstand rotation typ z drehrichtung)) (mubea:ent-json id "kreisel" ent) ) @@ -146,8 +147,18 @@ ;; gueltigen Winkel zu nehmen. L_GF1 aus JSON ist der Vorlauf-Zielwert; ;; L_GF2 (Nachlauf) ist der Rest (L_GF_gesamt - L_GF1). (defun mubea:build-vario-one (tid typ richtung deltaL deltaH winkel-soll gf1-ziel seite hz - startpunkt / ergebnis winkel-treffer best-winkel L_GF L_VF - gf1 gf2 hoehe-bis lastEnt ent vf-nummer) + startpunkt) + (mubea:ent-json tid "vario" + (mubea:vario-bauen tid typ richtung deltaL deltaH winkel-soll gf1-ziel seite hz + startpunkt))) + +;; Der eigentliche Bau ohne Ergebnis-Format - auch von +;; tests/test_dematic_arvato.lsp genutzt (dort mit vsp-Records). +;; Rueckgabe: Entity des VF_n-Blocks oder nil (auch, wenn deltaL beim +;; gewuenschten Winkel nicht loesbar ist). +(defun mubea:vario-bauen (tid typ richtung deltaL deltaH winkel-soll gf1-ziel seite hz + startpunkt / ergebnis winkel-treffer best-winkel L_GF L_VF + gf1 gf2 hoehe-bis lastEnt ent vf-nummer) (if (or (null seite) (= seite "")) (setq seite "links")) (if (or (null typ) (= typ "")) (setq typ "standard")) (if (null hz) (setq hz 0.0) (setq hz (float hz))) @@ -207,12 +218,12 @@ ;; Linienzug/Altbestand bleiben unmarkiert. (if (and ent (= (type ent) 'ENAME) (member typ '("standard" "etage"))) (vf-edit-xdata-schreiben ent typ hz)) - (mubea:ent-json tid "vario" ent)) + (if (and ent (= (type ent) 'ENAME)) ent nil)) (progn (princ (strcat "\n FEHLER: deltaL=" (rtos deltaL 2 0) " bei Winkel " (if winkel-soll (rtos winkel-soll 2 0) "auto") " nicht loesbar (kein gueltiges L_GF/L_VF).")) - (mubea:result-json tid "vario" "failed" nil nil nil nil))) + nil)) ) ;; --- Vario(s) aus einem Template-Eintrag bauen --- @@ -290,8 +301,15 @@ ;; sep_x = 300 * cos(v), v = Element-Winkel (winkel_grad, Default 3 Grad) ;; Die Zielhoehe ergibt sich aus L_stau/Winkel (kein Ziel-Hoehen-Parameter). ;; Rueckgabe: Ergebnis-JSON-String. -(defun mubea:build-gf-one (tid start-mm deltaL hz as-seite es-seite as-winkel es-winkel winkel / - rad sep-x test-L_stau ent) +(defun mubea:build-gf-one (tid start-mm deltaL hz as-seite es-seite as-winkel es-winkel winkel) + (mubea:ent-json tid "gefaellestrecke" + (mubea:gf-bauen tid start-mm deltaL hz as-seite es-seite as-winkel es-winkel winkel))) + +;; Der eigentliche Bau ohne Ergebnis-Format - auch von +;; tests/test_dematic_arvato.lsp genutzt (dort mit vsp-Records). +;; Rueckgabe: Entity des GF_n-Blocks oder nil. +(defun mubea:gf-bauen (tid start-mm deltaL hz as-seite es-seite as-winkel es-winkel winkel / + rad sep-x test-L_stau ent) (mubea:ensure-gf-init) ;; Element-Masse fuer die gewaehlte AS/ES-Variante setzen, damit aus-dx/ein-dx ;; zur Variante (90/30 Grad) passen. Danach wieder auf 90 zuruecksetzen. @@ -312,7 +330,7 @@ deltaL as-winkel es-winkel "0" "Schoenenberger Geruest"))) (vf-set-as-masse "90" as-seite) (vf-set-es-masse "90" es-seite) - (mubea:ent-json tid "gefaellestrecke" ent) + ent ) ;; --- Gefaellestrecke(n) aus einem Template-Eintrag bauen --- diff --git a/tests/test_showroom_ils.lsp b/tests/test_showroom_ils.lsp new file mode 100644 index 0000000..28c7ed9 --- /dev/null +++ b/tests/test_showroom_ils.lsp @@ -0,0 +1,77 @@ +;; ============================================================ +;; test_showroom_ils.lsp - Nachbau des ILS-3.0-Showrooms. +;; +;; Datenquelle: tests/testdata/showroom_ils.json. Entstehung in zwei Stufen: +;; 1. Scanner auf der Fremdzeichnung (flacher 2D-Plan, Hoehen vom Anwender): +;; python lib/dxf_scan_components.py \ +;; C:/develop/sps_skel/data/Showroom_ILS_3_0.dxf data \ +;; tests/testdata/showroom_ils.json --projekt Showroom \ +;; --flach --ohne-hoehen \ +;; --kreisel-achse 27797.93 16298.90 36705.93 16298.90 \ +;; --kreisel-achse 35305.93 13093.90 28772.93 13093.90 \ +;; --kreisel-hoehe 26997.93 3066.4 2226.4 \ +;; --kreisel-hoehe 26997.93 12898.9 2226.4 \ +;; --kreisel-hoehe 37105.93 9888.9 1700 \ +;; --kreisel-hoehe 27397.93 16298.9 2226.4 \ +;; --kreisel-hoehe 35705.93 13093.9 1970 +;; 2. VON HAND (geht bei Stufe 1 verloren - danach neu eintragen): +;; Kreisel_Showroom_04 (vertikal, rechts) samt Separator/Scanner bei +;; y=14979 entfernt, dafuer VF_Showroom_01 (VarioFoerderer standard, +;; Auf von Kreisel_Showroom_03 zu Kreisel_Showroom_05) eingetragen. +;; Showroom_BTMT_BEL_01 (Kreisel_Showroom_03) und Showroom_BTMT_ENT_01 +;; (Kreisel_Showroom_01) aus der gebauten Zeichnung uebernommen +;; (results/export_raw.json, EXPORTCSV vom 2026-10-07). +;; +;; Inhalt: 5 Kreisel, 1 VarioFoerderer, 11 Gefaellestrecken (Modus 1), +;; Separatoren/Scanner, BTMT Be- und Entladung. +;; - Ebenen: oben 2226.4 (Kreisel 01/02/05), Mitte 1970 (06), unten 1700 (03) +;; - in der gebauten Zeichnung KREISEL_1/2/4, KREISEL_5, KREISEL_3. +;; - Kreisel_Showroom_05/06 sind Schleifen ohne AN8/SP8 im Plan (an beiden +;; Enden Weichenboegen) - per --kreisel-achse als STANDARD-Kreisel +;; angenaehert (Radmitten = Mittelpunkte der PIN-Kreise). Die AN8-Seite +;; ist NICHT beliebig: der Export legt Bahn L links von AN8->SP8, der +;; Materialfluss setzt den Bahnwechsel ans AN8-Ende. Kreisel_Showroom_06 +;; (UZS) hat AN8 darum im OSTEN, sonst wird Bahn L zur Sackgasse. +;; - Weichen (WB-*/WM-*/WL-*/WR-*) werden bewusst NICHT nachgebaut. +;; - GF: den Winkel +;; und die Staustreckenlaenge rechnet dematic_arvato:gf-geometrie aus +;; hoehe_ende_mm (ES-Masse bei der Neigung gemessen), und +;; dematic_arvato:gf-endhoehe-pruefen meldet "warnung", wenn eine GF +;; den unteren Kreisel um mehr als 5 mm verfehlt. +;; +;; Keine eigene Bau-Logik: Eintragsschema und Lauf wie TEST_DEMATIC_ARVATO +;; (dematic_arvato:bau-datei aus tests/test_dematic_arvato.lsp). +;; +;; Aufruf in BricsCAD: +;; (load (strcat (getenv "DXFMAKRO") "/tests/test_showroom_ils.lsp")) +;; TEST_SHOWROOM_ILS +;; ============================================================ + +(if (not (boundp '*showroom-ils-records*)) (setq *showroom-ils-records* nil)) + +;; Beim LADEN holen (siehe test_dematic_arvato.lsp: per load definierte +;; Funktionen sind erst nach Rueckkehr zum Top-Level sichtbar). +(if (null (car (atoms-family 1 '("DEMATIC_ARVATO:BAU-DATEI")))) + (load (strcat (getenv "DXFMAKRO") "/tests/test_dematic_arvato.lsp"))) + +(defun showroom_ils:datei () + (strcat (getenv "DXFMAKRO") "/tests/testdata/showroom_ils.json")) + +(defun c:TEST_SHOWROOM_ILS () + (setq *showroom-ils-records* + (dematic_arvato:bau-datei "TEST_SHOWROOM_ILS" "ILS 3.0 Showroom" + (showroom_ils:datei))) + (princ)) + +;; Ergebnis-Export (Konvention :export-results fuer test_run_all.lsp) +(defun showroom_ils:export-results (out-dir / pfad) + (if (null *showroom-ils-records*) + (princ "\n Keine Showroom-Ergebnisse vorhanden.") + (progn + (vl-mkdir out-dir) + (setq pfad (strcat out-dir "/showroom_ils_results.json")) + (vsp-results-schreiben *showroom-ils-records* pfad))) + (princ)) + +(princ "\nTEST_SHOWROOM_ILS geladen. Aufruf: TEST_SHOWROOM_ILS") +(princ) diff --git a/tests/test_unit.lsp b/tests/test_unit.lsp index cbabbae..92b812d 100644 --- a/tests/test_unit.lsp +++ b/tests/test_unit.lsp @@ -1601,6 +1601,77 @@ (strcat "harter Fehler: " (vl-catch-all-error-message res)))) ) +;; ------------------------------------------------------------ +;; TESTS: ssg_input / ssg_blocktools / ssg_texttools - reine Funktionen +;; (die interaktiven Befehle SSG_BLOCK_*, SSG_ATTR_ERSETZEN, SSG_TEXT_* +;; brauchen eine Zeichnung und sind hier NICHT abgedeckt) +;; ------------------------------------------------------------ + +(defun tu-tests-werkzeuge ( / _e) + (princ "\n[ssg_input / ssg_blocktools / ssg_texttools]") + (if (not (and (car (atoms-family 1 '("SSG-IN-DEFAULT"))) + (car (atoms-family 1 '("SSG-BT-WERT-NEU"))) + (car (atoms-family 1 '("SSG-TT-LESBARER-WINKEL"))))) + (tu-record nil "werkzeuge/geladen" + "ssg_input/ssg_blocktools/ssg_texttools nicht geladen (ssg_load.lsp)") + (progn + ;; --- ssg_input --- + (tu-eqf "ssg-in-default/vorgabe" 5.0 (ssg-in-default nil 5.0)) + (tu-eqf "ssg-in-default/eingabe" 3.0 (ssg-in-default 3.0 5.0)) + (tu-nil "ssg-in-default/beides-nil" (ssg-in-default nil nil)) + (tu-eq "ssg-in-fmt-real/ganz" "5" (ssg-in-fmt-real 5.0)) + (tu-eq "ssg-in-fmt-real/halb" "2.5" (ssg-in-fmt-real 2.5)) + (tu-eq "ssg-in-fmt-real/null" "0" (ssg-in-fmt-real 0.0)) + (tu-eq "ssg-in-fmt-real/hundert" "100" (ssg-in-fmt-real 100.0)) + (tu-eq "ssg-in-fmt-real/bruch" "0.125" (ssg-in-fmt-real 0.125)) + (tu-eq "ssg-in-fmt-real/negativ" "-1.5" (ssg-in-fmt-real -1.5)) + (tu-eq "ssg-in-fmt-pt/3d" "1,2.5,0" (ssg-in-fmt-pt '(1.0 2.5 0.0))) + (tu-eq "ssg-in-fmt-pt/2d" "1,2,0" (ssg-in-fmt-pt '(1.0 2.0))) + (tu-eq "ssg-in-prompt/mit-vorgabe" "\nHoehe <5>: " (ssg-in-prompt "\nHoehe" "5")) + (tu-eq "ssg-in-prompt/ohne" "\nHoehe: " (ssg-in-prompt "\nHoehe" nil)) + (tu-eq "ssg-in-first-word" "Ja" (ssg-in-first-word "Ja Nein")) + (tu-eq "ssg-in-first-word/ein-wort" "Ja" (ssg-in-first-word "Ja")) + (tu-eq "ssg-in-second-word" "Nein" (ssg-in-second-word "Ja Nein")) + (tu-eq "ssg-in-second-word/ein-wort" "" (ssg-in-second-word "Ja")) + + ;; --- ssg_blocktools --- + (tu-true "ssg-bt-name-passt-p/muster" (ssg-bt-name-passt-p "GR_TR_1" "gr_*")) + (tu-nil "ssg-bt-name-passt-p/kein" (ssg-bt-name-passt-p "GR_TR_1" "XX*")) + (tu-true "ssg-bt-name-passt-p/nil" (ssg-bt-name-passt-p "ABC" nil)) + (tu-true "ssg-bt-name-passt-p/leer" (ssg-bt-name-passt-p "ABC" "")) + (tu-true "ssg-bt-name-passt-p/escape-ja" (ssg-bt-name-passt-p "A.B" "A`.B")) + (tu-nil "ssg-bt-name-passt-p/escape-nein" (ssg-bt-name-passt-p "AxB" "A`.B")) + (tu-eq "ssg-bt-muster-escape" "A`.B`#1" (ssg-bt-muster-escape "A.B#1")) + (tu-eq "ssg-bt-muster-anzeige" "A.B#1" (ssg-bt-muster-anzeige "A`.B`#1")) + (tu-eq "ssg-bt-zaehle-namen" + '(("Alpha" . 1) ("Beta" . 1) ("Zeta" . 3)) + (ssg-bt-zaehle-namen '("Zeta" "Alpha" "Zeta" "Beta" "Zeta"))) + (tu-nil "ssg-bt-zaehle-namen/leer" (ssg-bt-zaehle-namen nil)) + (tu-eq "ssg-bt-wert-neu/teil" "ABC_1" (ssg-bt-wert-neu "ABC-1" "-" "_" T)) + (tu-eq "ssg-bt-wert-neu/mehrfach" "a.b.c" (ssg-bt-wert-neu "a-b-c" "-" "." T)) + (tu-eq "ssg-bt-wert-neu/loeschen" "AC" (ssg-bt-wert-neu "ABC" "B" "" T)) + (tu-nil "ssg-bt-wert-neu/kein-treffer" (ssg-bt-wert-neu "ABC" "X" "y" T)) + (tu-eq "ssg-bt-wert-neu/gesamt-ja" "X" (ssg-bt-wert-neu "ABC" "ABC" "X" nil)) + (tu-nil "ssg-bt-wert-neu/gesamt-nein" (ssg-bt-wert-neu "ABCD" "ABC" "X" nil)) + (tu-nil "ssg-bt-wert-neu/leere-suche" (ssg-bt-wert-neu "ABC" "" "X" T)) + (tu-nil "ssg-bt-wert-neu/gross-klein" (ssg-bt-wert-neu "abc" "ABC" "X" T)) + + ;; --- ssg_texttools --- + (tu-eqf "ssg-tt-lesbarer-winkel/0" 0.0 (ssg-tt-lesbarer-winkel 0.0)) + (tu-eqf "ssg-tt-lesbarer-winkel/45" (/ pi 4.0) (ssg-tt-lesbarer-winkel (/ pi 4.0))) + (tu-eqf "ssg-tt-lesbarer-winkel/90" (/ pi 2.0) (ssg-tt-lesbarer-winkel (/ pi 2.0))) + (tu-eqf "ssg-tt-lesbarer-winkel/135" (* 1.75 pi) (ssg-tt-lesbarer-winkel (* 0.75 pi))) + (tu-eqf "ssg-tt-lesbarer-winkel/180" 0.0 (ssg-tt-lesbarer-winkel pi)) + (tu-eqf "ssg-tt-lesbarer-winkel/270" (/ pi 2.0) (ssg-tt-lesbarer-winkel (* 1.5 pi))) + (tu-eqf "ssg-tt-lesbarer-winkel/-45" (* 1.75 pi) (ssg-tt-lesbarer-winkel (- (/ pi 4.0)))) + (tu-eqf "ssg-tt-lesbarer-winkel/360" 0.0 (ssg-tt-lesbarer-winkel (* 2.0 pi))) + (tu-eqf "ssg-tt-versetzt/x" '(5.0 0.0 0.0) (ssg-tt-versetzt '(0.0 0.0 0.0) 0.0 5.0)) + (tu-eqf "ssg-tt-versetzt/y" '(0.0 2.0 0.0) (ssg-tt-versetzt '(0.0 0.0 0.0) (/ pi 2.0) 2.0)) + (tu-eqf "ssg-tt-versetzt/2d" '(1.0 4.0 0.0) (ssg-tt-versetzt '(1.0 1.0) (/ pi 2.0) 3.0)) + ) + ) +) + (defun c:TEST_UNIT ( / out-dir report) (tu-reset) (princ "\n================================================================") @@ -1610,7 +1681,8 @@ (foreach fn '("tu-tests-core" "tu-tests-lang" "tu-tests-id" "tu-tests-vfcore" "tu-tests-export" "tu-tests-gf" "tu-tests-omni" "tu-tests-kreisel" "tu-tests-sepliste" "tu-tests-json" "tu-tests-geruest" - "tu-tests-sepscan" "tu-tests-vfl-segs" "tu-tests-vfl-abbruch") + "tu-tests-sepscan" "tu-tests-vfl-segs" "tu-tests-vfl-abbruch" + "tu-tests-werkzeuge") (tu-run-block fn)) (princ "\n\n----------------------------------------------------------------") diff --git a/tests/test_vf_geometrie.py b/tests/test_vf_geometrie.py index f62b708..ac8cd37 100644 --- a/tests/test_vf_geometrie.py +++ b/tests/test_vf_geometrie.py @@ -7,7 +7,7 @@ HundM-Ketten. Warum zusaetzlich zu tests/test_hundm05.py: der Ergebnis-Record sagt "executed, kein Prompt, Journal aufgegangen" - er sagt NICHT, ob dieselbe Geometrie herauskam wie vorher. Genau das ist bei der Funktionstrennung in -Stufe 2 (doc/TODO-plan-vf-interactive.md) das Risiko: die Reihenfolge der +Stufe 2 (doc/todo/plan-vf-interactive.md) das Risiko: die Reihenfolge der dL-Subtraktionen und der vfl-acc-*-Aufrufe IST Geometrie, und eine falsche Reihenfolge faellt in der Zeichnung nicht auf - nur im Sivas-Export. diff --git a/tests/test_vf_headless_statisch.py b/tests/test_vf_headless_statisch.py index f098990..60419fe 100644 --- a/tests/test_vf_headless_statisch.py +++ b/tests/test_vf_headless_statisch.py @@ -11,7 +11,7 @@ einem selten erreichten Zweig ein neues (alert ...) oder ein rohes (getreal ...) hinzufuegt. Genau das haelt dieser Test fest: die Fundstellen sind eingecheckt, jede neue muss hier bewusst eingetragen werden. -Hintergrund und Fahrplan: doc/TODO-plan-vf-interactive.md, +Hintergrund und Fahrplan: doc/todo/plan-vf-interactive.md, Mechanik: doc/variofoerderer.md Abschnitt 8b. """ diff --git a/tests/testdata/dematic_arvato.json b/tests/testdata/dematic_arvato.json new file mode 100644 index 0000000..7aade0b --- /dev/null +++ b/tests/testdata/dematic_arvato.json @@ -0,0 +1,774 @@ +[ + { + "id": "Kreisel_Arvato_01", + "function": "insert", + "x": 19204.0, + "y": 1703.66, + "z": 2177.0, + "abstand": 3619.14, + "rotation": 90.0, + "typ": "STANDARD", + "drehrichtung": "GUZ", + "comment": "aus Zeichnung: KREISEL_1_STANDARD_3619 (ID 0056), abstand aus Blockdefinition (AN8 -> SP8)" + }, + { + "id": "Kreisel_Arvato_02", + "function": "insert", + "x": 35860.37, + "y": 12519.72, + "z": 2437.0, + "abstand": 33044.28, + "rotation": 180.0, + "typ": "STANDARD", + "drehrichtung": "UZS", + "comment": "aus Zeichnung: KREISEL_2_STANDARD_33044 (ID 0002), abstand aus Blockdefinition (AN8 -> SP8)" + }, + { + "id": "Kreisel_Arvato_03", + "function": "insert", + "x": 36661.24, + "y": 24878.8, + "z": 1826.0, + "abstand": 33470.18, + "rotation": 180.0, + "typ": "STANDARD", + "drehrichtung": "UZS", + "comment": "aus Zeichnung: KREISEL_3_STANDARD_33470 (ID 0003), abstand aus Blockdefinition (AN8 -> SP8)" + }, + { + "id": "Kreisel_Arvato_04", + "function": "insert", + "x": 42563.78, + "y": 1703.66, + "z": 2177.0, + "abstand": 3619.14, + "rotation": 90.0, + "typ": "STANDARD", + "drehrichtung": "GUZ", + "comment": "aus Zeichnung: KREISEL_4_STANDARD_3619 (ID 0055), abstand aus Blockdefinition (AN8 -> SP8)" + }, + { + "test_id": "VF_Arvato_01", + "typ": "standard", + "richtung": "Auf", + "deltaL": 11559.0, + "deltaH": 611.0, + "winkel": 15, + "L_GF1": 1907.0, + "seite": "links", + "motorseite": "rechts", + "hz": 270.0, + "x": 3314.07, + "y": 24478.8, + "z": 1826.0, + "comment": "aus Zeichnung: VF_1 (ID 0005), Hoehe 0 -> 611; deltaL/deltaH aus den (ganzzahligen) Attributen" + }, + { + "test_id": "VF_Arvato_02", + "typ": "standard", + "richtung": "Auf", + "deltaL": 11559.0, + "deltaH": 611.0, + "winkel": 15, + "L_GF1": 1907.0, + "seite": "links", + "motorseite": "rechts", + "hz": 270.0, + "x": 15285.06, + "y": 24478.8, + "z": 1826.0, + "comment": "aus Zeichnung: VF_2 (ID 0006), Hoehe 0 -> 611; deltaL/deltaH aus den (ganzzahligen) Attributen" + }, + { + "test_id": "VF_Arvato_03", + "typ": "standard", + "richtung": "Auf", + "deltaL": 11559.0, + "deltaH": 611.0, + "winkel": 15, + "L_GF1": 1907.0, + "seite": "links", + "motorseite": "rechts", + "hz": 270.0, + "x": 23843.05, + "y": 24478.8, + "z": 1826.0, + "comment": "aus Zeichnung: VF_3 (ID 0007), Hoehe 0 -> 611; deltaL/deltaH aus den (ganzzahligen) Attributen" + }, + { + "test_id": "VF_Arvato_04", + "typ": "standard", + "richtung": "Auf", + "deltaL": 22559.0, + "deltaH": 0.0, + "winkel": 12, + "L_GF1": 6852.0, + "seite": "rechts", + "motorseite": "rechts", + "hz": 180.0, + "x": 42163.78, + "y": 4017.06, + "z": 2177.0, + "comment": "aus Zeichnung: VF_4 (ID 0008), Hoehe 0 -> 0; deltaL/deltaH aus den (ganzzahligen) Attributen" + }, + { + "test_id": "VF_Arvato_05", + "typ": "standard", + "richtung": "Auf", + "deltaL": 6852.0, + "deltaH": 260.0, + "winkel": 18, + "L_GF1": 767.0, + "seite": "links", + "motorseite": "rechts", + "hz": 90.0, + "x": 19551.49, + "y": 5265.19, + "z": 2177.0, + "comment": "aus Zeichnung: VF_5 (ID 0009), Hoehe 0 -> 260; deltaL/deltaH aus den (ganzzahligen) Attributen" + }, + { + "test_id": "VF_Arvato_LZ_01", + "typ": "linienzug_journal", + "journal": [ + "PT:42161.679193,2448.319538,0", + "REAL:2177", + "STR:1", + "STR:90", + "STR:2", + "STEP:Linie-VF", + "STR:4", + "DL:9370.410886", + "REAL:-180", + "STR:1", + "REAL:2800", + "INT:1", + "STR:2", + "STR:2", + "STR:2", + "STEP:Linie-GF", + "STR:2", + "STR:1", + "STR:3", + "DL:6187.72996", + "STR:1", + "STR:2", + "STR:2", + "REAL:3", + "STEP:Linie-VF", + "STR:3", + "DL:4572.938729", + "STR:2", + "INT:1", + "STR:3", + "STR:1", + "STEP:ES", + "STR:90", + "STR:1", + "DL:2872.479403", + "REAL:2100", + "STR:3", + "STR:1", + "STEP:ES", + "STR:90", + "STR:2", + "DL:2857.418974", + "REAL:2000", + "STR:3", + "STR:1", + "STEP:ES", + "STR:90", + "STR:2", + "DL:2850.93244", + "REAL:2177", + "INT:2", + "STR:2" + ], + "comment": "aus Zeichnung: VF_6 (ID 0010), 52 Eingaben, Hoehe 2177 -> 2174; wird 1:1 abgespielt (vsp-bau-journal)" + }, + { + "test_id": "GF_Arvato_01", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [5833.56, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_1 (ID 0011); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_02", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [6733.56, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_2 (ID 0012); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_03", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [7533.56, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_3 (ID 0013); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_04", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [8333.56, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_4 (ID 0014); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_05", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [9383.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_5 (ID 0015); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_06", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [10183.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_6 (ID 0016); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_07", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [10983.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_7 (ID 0017); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_08", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [12323.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_8 (ID 0018); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_09", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [13123.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_9 (ID 0019); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_10", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [13923.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_10 (ID 0020); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_11", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [16733.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_11 (ID 0021); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_12", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [17533.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_12 (ID 0022); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_13", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [18333.57, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_13 (ID 0023); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_14", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [19381.07, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_14 (ID 0024); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_15", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [20281.07, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_15 (ID 0025); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_16", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [21081.07, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_16 (ID 0026); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_17", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [21881.07, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_17 (ID 0027); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_18", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [25541.07, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_18 (ID 0028); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_19", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [26341.07, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_19 (ID 0029); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_20", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [27841.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_20 (ID 0030); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_21", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [28741.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_21 (ID 0031); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_22", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [29541.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_22 (ID 0032); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_23", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [30341.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_23 (ID 0033); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_24", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [31891.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_24 (ID 0034); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_25", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [32791.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_25 (ID 0035); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_26", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [33591.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_26 (ID 0036); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "test_id": "GF_Arvato_27", + "modus": 1, + "deltaL_mm": 11559.08, + "hz_grad": 90.0, + "start_mm": [34391.06, 12919.72, 2437.0], + "as_seite": "links", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Arvato_02", + "kreisel_ende": "Kreisel_Arvato_03", + "hoehe_ende_mm": 1826.0, + "comment": "aus Zeichnung: GF_27 (ID 0037); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 2.4700 Grad -> HOEHE_BIS 1825" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 3038.72, + "y": 12119.73, + "z": 2473.0, + "rotation": 0.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0038, ZUORDNUNG 0002, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 3482.38, + "y": 24478.8, + "z": 1826.0, + "rotation": 0.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0039, ZUORDNUNG 0003, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 5094.1, + "y": 12919.72, + "z": 2473.0, + "rotation": 180.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0040, ZUORDNUNG 0002, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 15412.41, + "y": 24478.8, + "z": 1826.0, + "rotation": 0.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0041, ZUORDNUNG 0003, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 15994.1, + "y": 12919.78, + "z": 2473.0, + "rotation": 180.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0042, ZUORDNUNG 0002, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 19604.0, + "y": 5042.22, + "z": 2177.0, + "rotation": 270.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0043, ZUORDNUNG 0056, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 24002.04, + "y": 24478.8, + "z": 1826.0, + "rotation": 0.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0044, ZUORDNUNG 0003, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 24794.1, + "y": 12919.82, + "z": 2473.0, + "rotation": 180.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0045, ZUORDNUNG 0002, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 35050.37, + "y": 12919.72, + "z": 2437.0, + "rotation": 180.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0046, ZUORDNUNG 0002, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 35182.77, + "y": 25278.8, + "z": 1826.0, + "rotation": 180.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0047, ZUORDNUNG 0003, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Separator_SP", + "x": 42163.99, + "y": 4269.52, + "z": 2177.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Separator_SP_3D (ID 0048, ZUORDNUNG 0055, ARTINR 200000077)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 3632.63, + "y": 24865.38, + "z": 1826.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0049, ZUORDNUNG 0003, ARTINR 829534306)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 4943.86, + "y": 13306.31, + "z": 2473.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0050, ZUORDNUNG 0011, ARTINR 829534306)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 15562.65, + "y": 24865.38, + "z": 1826.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0051, ZUORDNUNG 0003, ARTINR 829534306)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 15843.86, + "y": 13306.36, + "z": 2473.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0052, ZUORDNUNG 0002, ARTINR 829534306)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 24152.28, + "y": 24865.38, + "z": 1826.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0059, ZUORDNUNG 0003, ARTINR 829534306)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 24643.86, + "y": 13306.4, + "z": 2473.0, + "rotation": 90.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0054, ZUORDNUNG 0028, ARTINR 829534306)" + }, + { + "function": "insert", + "block": "BTMT-Beladung", + "x": 42163.78, + "y": 4978.68, + "z": 2177.0, + "rotation": 270.0, + "comment": "aus Zeichnung: BTMT-Beladung_3D (ID 0057, ARTINR 829662012)" + }, + { + "function": "insert", + "block": "SC_Entladung", + "x": 35609.45, + "y": 25278.8, + "z": 1826.0, + "rotation": 0.0, + "comment": "aus Zeichnung: SC_Entladung_3D (ID 0058, ARTINR 400100156)" + }, + { + "function": "insert", + "block": "Scanner", + "x": 42163.78, + "y": 4224.88, + "z": 2177.0, + "rotation": 180.0, + "comment": "aus Zeichnung: Scanner_3D (ID 0053, ZUORDNUNG 0055, ARTINR 829534306)" + } +] diff --git a/tests/testdata/showroom_ils.json b/tests/testdata/showroom_ils.json new file mode 100644 index 0000000..de0a0bd --- /dev/null +++ b/tests/testdata/showroom_ils.json @@ -0,0 +1,413 @@ +[ + { + "id": "Kreisel_Showroom_01", + "function": "insert", + "x": 26997.93, + "y": 3066.4, + "z": 2226.4, + "abstand": 9032.5, + "rotation": 90.0, + "typ": "STANDARD", + "darstellung": "2D", + "drehrichtung": "GUZ", + "comment": "aus DXF: Radmitte AN8 (Layer 1ANTR-800) (26997.93, 3466.40) -> SP8 (Layer 1SP-800) (26997.93, 12498.90), Mittenabstand 9032.50, rotation 90.00 Grad; x/y = AN8-Mitte minus Radius. ACHTUNG hoehe=11039.9 ist NICHT belegt: AN8/SP8 sind flache 2D-Symbole auf Z=0 und nur 0 3D-Nachbarn in 3000 mm - zu wenige fuer eine belegbare Hoehe. Hoehe 2226.4 vom Anwender.", + "hoehe_quelle": "Anwender" + }, + { + "id": "Kreisel_Showroom_02", + "function": "insert", + "x": 26997.93, + "y": 12898.9, + "z": 2226.4, + "abstand": 3000.0, + "rotation": 90.0, + "typ": "STANDARD", + "darstellung": "2D", + "drehrichtung": "UZS", + "comment": "aus DXF: Radmitte AN8 (Layer 1ANTR-800) (26997.93, 13298.90) -> SP8 (Layer 1SP-800) (26997.93, 16298.90), Mittenabstand 3000.00, rotation 90.00 Grad; x/y = AN8-Mitte minus Radius. ACHTUNG hoehe=11039.9 ist NICHT belegt: AN8/SP8 sind flache 2D-Symbole auf Z=0 und nur 0 3D-Nachbarn in 3000 mm - zu wenige fuer eine belegbare Hoehe. Hoehe 2226.4 vom Anwender.", + "hoehe_quelle": "Anwender" + }, + { + "id": "Kreisel_Showroom_03", + "function": "insert", + "x": 37105.93, + "y": 9888.9, + "z": 1700.0, + "abstand": 7200.0, + "rotation": 180.0, + "typ": "STANDARD", + "darstellung": "2D", + "drehrichtung": "GUZ", + "comment": "aus DXF: Radmitte AN8 (Layer 1ANTR-800) (36705.93, 9888.90) -> SP8 (Layer 1SP-800) (29505.93, 9888.90), Mittenabstand 7200.00, rotation 180.00 Grad; x/y = AN8-Mitte minus Radius. ACHTUNG hoehe=11039.9 ist NICHT belegt: AN8/SP8 sind flache 2D-Symbole auf Z=0 und nur 0 3D-Nachbarn in 3000 mm - zu wenige fuer eine belegbare Hoehe. Hoehe 1700.0 vom Anwender.", + "hoehe_quelle": "Anwender" + }, + { + "id": "Kreisel_Showroom_05", + "function": "insert", + "x": 27397.93, + "y": 16298.9, + "z": 2226.4, + "abstand": 8908.0, + "rotation": 0.0, + "typ": "STANDARD", + "darstellung": "2D", + "drehrichtung": "GUZ", + "comment": "aus DXF: Radmitte (manuell AN8) (Layer --kreisel-achse) (27797.93, 16298.90) -> (manuell SP8) (Layer --kreisel-achse) (36705.93, 16298.90), Mittenabstand 8908.00, rotation 0.00 Grad; x/y = AN8-Mitte minus Radius. ACHTUNG hoehe=0.0 ist NICHT belegt: AN8/SP8 sind flache 2D-Symbole auf Z=0 und nur 0 3D-Nachbarn in 3000 mm - zu wenige fuer eine belegbare Hoehe. Hoehe 2226.4 vom Anwender.", + "hoehe_quelle": "Anwender" + }, + { + "id": "Kreisel_Showroom_06", + "function": "insert", + "x": 35705.93, + "y": 13093.9, + "z": 1970.0, + "abstand": 6533.0, + "rotation": 180.0, + "typ": "STANDARD", + "darstellung": "2D", + "drehrichtung": "UZS", + "comment": "aus DXF: Schleife ohne AN8/SP8, Radmitten der Enden (35305.93, 13093.90) -> (28772.93, 13093.90) aus den PIN-Kreisen (--kreisel-achse), Mittenabstand 6533.00, rotation 180 - AN8-Seite bewusst OSTEN: der Export (export_neighbors.kreisel_half_bboxes) legt Bahn L links von AN8->SP8, und material_flow/tro_flow setzen den Bahnwechsel R->L (UZS) ans AN8-Ende. Mit AN8 im Westen lagen die Zulaeufe von Kreisel_Showroom_05 auf L und die Ablaeufe nach Kreisel_Showroom_03 auf R - Bahn 0005-L wurde zur Sackgasse. Hoehe 1970 vom Anwender.", + "hoehe_quelle": "Anwender" + }, + { + "test_id": "VF_Showroom_01", + "typ": "standard", + "richtung": "Auf", + "deltaL": 5610.0, + "deltaH": 526.4, + "seite": "links", + "hz": 90.0, + "x": 36305.93, + "y": 10288.9, + "z": 1700.0, + "comment": "von Hand: ersetzt Kreisel_Showroom_04 (vertikaler Kreisel AN8 (36706, 10689) -> SP8 (36706, 15499)) samt dessen Separator/Scanner bei y=14979. AS auf der oberen Kette von Kreisel_Showroom_03 (y=10288.9, Hoehe 1700) auf dem linken Strang des alten Kreisels (x=36306), Steigung +Y bis zur unteren Kette von Kreisel_Showroom_05 (y=15898.9, Hoehe 2226.4): deltaL 15898.9 - 10288.9 = 5610, deltaH 2226.4 - 1700 = 526.4. seite noch offen (links als Vorgabe), winkel waehlt der Solver." + }, + { + "test_id": "GF_Showroom_01", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [30455.93, 15898.9, 2226.4], + "as_seite": "links", + "es_seite": "rechts", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_05", + "kreisel_ende": "Kreisel_Showroom_06", + "hoehe_ende_mm": 1970.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (30455.93, 15593.90) -> (30455.93, 13893.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_05 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_05 / Kreisel_Showroom_06), den Winkel rechnet der Treiber; as_seite links aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (30636.27, 15898.90) -> AS_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (30456, 13994), S-SP bei (30456, 14807); es_seite rechts aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (30243.76, 13493.90) -> ES_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_02", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [31255.93, 12693.9, 1970.0], + "as_seite": "rechts", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_06", + "kreisel_ende": "Kreisel_Showroom_03", + "hoehe_ende_mm": 1700.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (31255.93, 12388.90) -> (31255.93, 10688.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_03 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_06 / Kreisel_Showroom_03), den Winkel rechnet der Treiber; as_seite rechts aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (31075.60, 12693.90) -> AS_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (31256, 10789), S-SP bei (31256, 11602); es_seite links aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (31468.11, 10288.90) -> ES_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_03", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [31255.93, 15898.9, 2226.4], + "as_seite": "links", + "es_seite": "rechts", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_05", + "kreisel_ende": "Kreisel_Showroom_06", + "hoehe_ende_mm": 1970.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (31255.93, 15593.90) -> (31255.93, 13893.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_05 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_05 / Kreisel_Showroom_06), den Winkel rechnet der Treiber; as_seite links aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (31436.27, 15898.90) -> AS_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (31256, 13994), S-SP bei (31256, 14807); es_seite rechts aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (31043.76, 13493.90) -> ES_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_04", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [32055.93, 12693.9, 1970.0], + "as_seite": "rechts", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_06", + "kreisel_ende": "Kreisel_Showroom_03", + "hoehe_ende_mm": 1700.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (32055.93, 12388.90) -> (32055.93, 10688.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_03 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_06 / Kreisel_Showroom_03), den Winkel rechnet der Treiber; as_seite rechts aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (31875.60, 12693.90) -> AS_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (32056, 10789), S-SP bei (32056, 11602); es_seite links aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (32268.11, 10288.90) -> ES_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_05", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [32055.93, 15898.9, 2226.4], + "as_seite": "links", + "es_seite": "rechts", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_05", + "kreisel_ende": "Kreisel_Showroom_06", + "hoehe_ende_mm": 1970.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (32055.93, 15593.90) -> (32055.93, 13893.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_05 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_05 / Kreisel_Showroom_06), den Winkel rechnet der Treiber; as_seite links aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (32236.27, 15898.90) -> AS_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (32056, 13994), S-SP bei (32056, 14807); es_seite rechts aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (31843.76, 13493.90) -> ES_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_06", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [33205.93, 12693.9, 1970.0], + "as_seite": "rechts", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_06", + "kreisel_ende": "Kreisel_Showroom_03", + "hoehe_ende_mm": 1700.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (33205.93, 12388.90) -> (33205.93, 10688.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_03 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_06 / Kreisel_Showroom_03), den Winkel rechnet der Treiber; as_seite rechts aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (33025.60, 12693.90) -> AS_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (33206, 10789), S-SP bei (33206, 11602); es_seite links aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (33418.11, 10288.90) -> ES_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_07", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [33205.93, 15898.9, 2226.4], + "as_seite": "links", + "es_seite": "rechts", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_05", + "kreisel_ende": "Kreisel_Showroom_06", + "hoehe_ende_mm": 1970.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (33205.93, 15593.90) -> (33205.93, 13893.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_05 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_05 / Kreisel_Showroom_06), den Winkel rechnet der Treiber; as_seite links aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (33386.27, 15898.90) -> AS_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (33206, 13994), S-SP bei (33206, 14807); es_seite rechts aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (32993.76, 13493.90) -> ES_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_08", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [34005.93, 12693.9, 1970.0], + "as_seite": "rechts", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_06", + "kreisel_ende": "Kreisel_Showroom_03", + "hoehe_ende_mm": 1700.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (34005.93, 12388.90) -> (34005.93, 10688.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_03 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_06 / Kreisel_Showroom_03), den Winkel rechnet der Treiber; as_seite rechts aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (33825.60, 12693.90) -> AS_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (34006, 10789), S-SP bei (34006, 11602); es_seite links aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (34218.11, 10288.90) -> ES_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_09", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [34005.93, 15898.9, 2226.4], + "as_seite": "links", + "es_seite": "rechts", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_05", + "kreisel_ende": "Kreisel_Showroom_06", + "hoehe_ende_mm": 1970.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (34005.93, 15593.90) -> (34005.93, 13893.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_05 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_05 / Kreisel_Showroom_06), den Winkel rechnet der Treiber; as_seite links aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (34186.27, 15898.90) -> AS_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (34006, 13994), S-SP bei (34006, 14807); es_seite rechts aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (33793.76, 13493.90) -> ES_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_10", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [34805.93, 12693.9, 1970.0], + "as_seite": "rechts", + "es_seite": "links", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_06", + "kreisel_ende": "Kreisel_Showroom_03", + "hoehe_ende_mm": 1700.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (34805.93, 12388.90) -> (34805.93, 10688.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_03 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_06 / Kreisel_Showroom_03), den Winkel rechnet der Treiber; as_seite rechts aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (34625.60, 12693.90) -> AS_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (34806, 10789), S-SP bei (34806, 11602); es_seite links aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (35018.11, 10288.90) -> ES_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "test_id": "GF_Showroom_11", + "modus": 1, + "deltaL_mm": 2405.0, + "hz_grad": 270.0, + "start_mm": [34805.93, 15898.9, 2226.4], + "as_seite": "links", + "es_seite": "rechts", + "as_winkel": "90", + "es_winkel": "90", + "kreisel_start": "Kreisel_Showroom_05", + "kreisel_ende": "Kreisel_Showroom_06", + "hoehe_ende_mm": 1970.0, + "hoehe_quelle": "Anwender", + "comment": "aus DXF: LINE auf Layer '6-SP' (34805.93, 15593.90) -> (34805.93, 13893.90), Laenge XY 1700.00; am oberen Ende um 305.0 mm bis zur Kette von Kreisel_Showroom_05 verlaengert; am unteren Ende um 400.0 mm bis zur Kette von Kreisel_Showroom_06 verlaengert; Hoehen vom Anwender (Kreisel Kreisel_Showroom_05 / Kreisel_Showroom_06), den Winkel rechnet der Treiber; as_seite links aus der Lage zur Fahrtrichtung; AS aus Block 'AE-D' bei (34986.27, 15898.90) -> AS_Element_90_links, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90; Separator auf der Achse entfernt (die GF baut ihren eigenen): S-SP bei (34806, 13994), S-SP bei (34806, 14807); es_seite rechts aus der Lage zur Fahrtrichtung; ES aus Block 'EE-R' bei (34593.76, 13493.90) -> ES_Element_90_rechts, als Einzel-Insert entfernt (baut die GF selbst) - geraten: Winkel=90." + }, + { + "function": "insert", + "block": "S-LP", + "x": 26597.93, + "y": 11973.9, + "z": 2226.4, + "rotation": 270.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer '5SEP-LP'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 2226.4 von Kreisel_Showroom_01 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 26597.93, + "y": 13982.92, + "z": 2226.4, + "rotation": 90.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer 'TGW_HB_2OG-AM_5'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 2226.4 von Kreisel_Showroom_02 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 27397.93, + "y": 5450.07, + "z": 2226.4, + "rotation": 90.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer 'TGW_HB_2OG-AM_5'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 2226.4 von Kreisel_Showroom_01 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 27397.93, + "y": 15773.9, + "z": 2226.4, + "rotation": 270.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer '5SEP-LP'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 2226.4 von Kreisel_Showroom_02 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 29397.93, + "y": 13493.9, + "z": 1970.0, + "rotation": 0.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer '5SEP-LP'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1970 von Kreisel_Showroom_06 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 30343.39, + "y": 9488.9, + "z": 1700.0, + "rotation": 0.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer '5SEP-LP'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1700.0 von Kreisel_Showroom_03 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 32083.74, + "y": 9488.9, + "z": 1700.0, + "rotation": 0.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer '5SEP-LP'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1700.0 von Kreisel_Showroom_03 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "S-LP", + "x": 35905.93, + "y": 10288.9, + "z": 1700.0, + "rotation": 180.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'S-LP', Layer '5SEP-LP'; Block 'S-LP' ist in data/ils/ NICHT vorhanden - erzeugt im Testlauf einen Platzhalter; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1700.0 von Kreisel_Showroom_03 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "Scanner", + "x": 29398.73, + "y": 13176.71, + "z": 1970.0, + "rotation": 270.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'SCAN', Layer 'ZZSCANNER', auf Makro-Block 'Scanner' abgebildet; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1970 von Kreisel_Showroom_06 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "Scanner", + "x": 30343.39, + "y": 9208.9, + "z": 1700.0, + "rotation": 270.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'SCAN', Layer 'ZZSCANNER', auf Makro-Block 'Scanner' abgebildet; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1700.0 von Kreisel_Showroom_03 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "Scanner", + "x": 32083.74, + "y": 9208.9, + "z": 1700.0, + "rotation": 270.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'SCAN', Layer 'ZZSCANNER', auf Makro-Block 'Scanner' abgebildet; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1700.0 von Kreisel_Showroom_03 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "function": "insert", + "block": "Scanner", + "x": 35905.93, + "y": 10008.9, + "z": 1700.0, + "rotation": 270.0, + "darstellung": "2D", + "comment": "aus DXF: Block 'SCAN', Layer 'ZZSCANNER', auf Makro-Block 'Scanner' abgebildet; 2D-Schema ohne 3D-Zwilling - z ist keine Einbauhoehe (hoehe_unbekannt) [Hoehe entfernt: --ohne-hoehen] Hoehe 1700.0 von Kreisel_Showroom_03 (liegt auf dessen Kette).", + "hoehe_quelle": "Anwender" + }, + { + "id": "Showroom_BTMT_BEL_01", + "comment": "BTMT Beladung auf Kreisel_Showroom_03 (Hoehe 1700) - von Hand in der gebauten Showroom-Zeichnung ergaenzt, Einfuegepunkt/Drehung aus results/export_raw.json (EXPORTCSV vom 2026-10-07, Block BTMT-Beladung_3D, ID 0040)", + "function": "insert", + "block": "BTMT-Beladung", + "x": 29877.99, + "y": 9478.98, + "z": 1690.08, + "rotation": 180.0 + }, + { + "id": "Showroom_BTMT_ENT_01", + "comment": "BTMT Entladung auf Kreisel_Showroom_01 (Hoehe 2226.4) - von Hand in der gebauten Showroom-Zeichnung ergaenzt, Einfuegepunkt/Drehung aus results/export_raw.json (EXPORTCSV vom 2026-10-07, Block SC_Entladung_3D, ID 0041)", + "function": "insert", + "block": "SC_Entladung", + "x": 27397.93, + "y": 4555.45, + "z": 2226.4, + "rotation": 270.0 + } +]