From 00fd48d02e0ec0d599b8c757a23b10729997153a Mon Sep 17 00:00:00 2001 From: Yuelin Wang Date: Thu, 8 Oct 2026 09:55:38 +0200 Subject: [PATCH 1/3] fix: VF-Linienzug Modus 1 GF+ES-Separator-Laenge/Hoehe korrigieren Neue Linie: GF (Zweig A+B) zog bei Kettenende mit ES-Element nur den ES-eigenen Fussabdruck von deltaL/deltaH ab, nicht den zusaetzlichen automatischen 300mm-Separator, den vfl-insert-es-element immer selbst vor dem ES-Block einfuegt - die Kette baute dadurch zu lang/zu tief. Zusaetzlich: "Separator NACH" im Wizard-Dialog (vflw-gruppe-sep-gf-impl) wird jetzt ausgegraut statt gefragt+nachtraeglich verworfen, wenn das GF-Segment ohnehin mit einem ES-Element endet (der automatische Separator deckt das bereits ab). Pending-Queue-Anzahl bleibt dabei unveraendert (Dialog pusht weiterhin 2 Werte), um keinen Versatz mit den nachfolgenden Konsolen-Abfragen zu erzeugen. Co-Authored-By: Claude Sonnet 5 --- Lisp/vf_linienzug.lsp | 83 ++++++++++++++++++++++++++++++++++++------- lang/de_DE.json | 4 +++ lang/en_GB.json | 4 +++ 3 files changed, 79 insertions(+), 12 deletions(-) diff --git a/Lisp/vf_linienzug.lsp b/Lisp/vf_linienzug.lsp index 3dbd70c..d849e94 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)") @@ -7008,7 +7019,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 +7061,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 +7134,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 +7157,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 +9009,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 +9533,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 +9543,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 +10345,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/lang/de_DE.json b/lang/de_DE.json index 78d3d67..34df8a6 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", @@ -500,6 +502,7 @@ "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", @@ -526,6 +529,7 @@ "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-einfuegehoehe-3dlinie": "\nEinfuegehoehe (mm) [%1 - Hoehe des Linien-Startpunkts]: ", "vfc-prompt-startpunkt-aus": "\nStartpunkt fuer AUS_Element waehlen: ", "vfc-prompt-wahl-1-2-ohne-default": "\nIhre Wahl (1/2): ", "vfc-status-ok": " OK", diff --git a/lang/en_GB.json b/lang/en_GB.json index 8af50c3..b758b4d 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", @@ -500,6 +502,7 @@ "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", @@ -526,6 +529,7 @@ "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-einfuegehoehe-3dlinie": "\nInsertion height (mm) [%1 - height of the line start point]: ", "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", From 16a15bb83b5e6ca8907d7a1cc8a93361221469c0 Mon Sep 17 00:00:00 2001 From: Yuelin Wang Date: Thu, 8 Oct 2026 09:55:56 +0200 Subject: [PATCH 2/3] feat: VF-Werteingabe Radio-Dialoge + Startpunkt-Dialog (Standard+Etage) Dropdown-Dialoge der Standard-/Etage-Werteingabe durch Radio-Buttons ersetzt (vfs-dialog-eingabe-basis-radio/vfs-dialog-winkel-verteilung- radio in vf_standard.lsp), da sich Radio-Labels nach new_dialog nicht per set_tile aendern lassen - die DCL wird dafuer bei jedem Aufruf frisch zur Laufzeit geschrieben (neue Kernel-Helfer ssg-dcl-temp- schreiben/ssg-dcl-label-escape in ssg_core.lsp) und dadurch sprachunabhaengig. Popup-Varianten bleiben als Fallback erhalten, falls das Schreiben/Laden der Temp-DCL-Datei scheitert. Startpunkt der Anlage wird jetzt ebenfalls per Dialog gepickt (vfc-dialog-startpunkt-waehlen, neue vfc_startpunkt-Dialogdefinition in dcl/variofoerderer.dcl) statt per reinem Konsolen-getpoint - analog zum bestehenden Punktwahl-Muster im Linienzug-Wizard. Zusaetzlich: Einfuegehoehe der 3D-Linien-Eingabe ist jetzt explizit abfragbar (Vorschlag = Z des Linien-Startpunkts), ueberschreibt nur die absolute Hoehe, deltaH/Steigung bleiben unveraendert aus der Linie abgeleitet. Gemeinsam mit vf_standard.lsp nach Merge-Konflikt zusammengefuehrt: der Kollege hatte an derselben Stelle unabhaengig vfs-edit-basis-lesen ergaenzt (gemeinsame Attribut-Leseroutine fuer Standard- UND Etage-Edit) - beide Ergaenzungen sind inhaltlich unabhaengig und bleiben nebeneinander bestehen. Co-Authored-By: Claude Sonnet 5 --- Lisp/ssg_core.lsp | 38 ++++ Lisp/vf_core.lsp | 68 +++++++- Lisp/vf_standard.lsp | 382 ++++++++++++++++++++++++++++++++++++++--- dcl/variofoerderer.dcl | 60 ++++++- 4 files changed, 518 insertions(+), 30 deletions(-) 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/vf_core.lsp b/Lisp/vf_core.lsp index ec18f05..a1db915 100644 --- a/Lisp/vf_core.lsp +++ b/Lisp/vf_core.lsp @@ -704,7 +704,8 @@ eingabe) (defun vf-eingabe-abfragen ( / eingabe-modus line-points startpunkt endpunkt differenz - deltaL deltaH deltaX deltaY richtung antwort hz-winkel) + deltaL deltaH deltaX deltaY richtung antwort hz-winkel + hoehe-override) ;; 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. @@ -750,6 +751,17 @@ (progn (setq richtung "Ab") (setq deltaH (abs deltaH)) (princ (ssg-text "vfc-foerderrichtung-ab"))) ) + ;; Einfuegehoehe explizit abfragbar - ueberschreibt NUR die absolute + ;; Z-Hoehe des Startpunkts (Vorschlag = Z des Linien-Startpunkts, + ;; Enter uebernimmt ihn unveraendert). deltaH/Steigung bleiben davon + ;; unberuehrt, die kommen weiterhin aus der Geometrie der gepickten + ;; Linie selbst - nur WO die Anlage absolut eingefuegt wird, ist + ;; jetzt eingebbar (bisher ausschliesslich aus der Linie abgeleitet). + (setq hoehe-override + (getreal (ssg-textf "vfc-prompt-einfuegehoehe-3dlinie" + (list (rtos (caddr startpunkt) 2 1))))) + (if hoehe-override + (setq startpunkt (list (car startpunkt) (cadr startpunkt) hoehe-override))) ) (progn (princ (ssg-text "vfc-modus-werteingabe-header")) @@ -1055,12 +1067,64 @@ (list vf-insert vf-endpunkt) ) +;; 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: Startpunkt ;; (X/Y) picken, Basis-Dialog, dann vf-dialog-berechnen-einfuegen. (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"))) + (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 eingabe (vfs-dialog-eingabe-basis nil)) (if (null eingabe) diff --git a/Lisp/vf_standard.lsp b/Lisp/vf_standard.lsp index 99e8daf..9f11549 100644 --- a/Lisp/vf_standard.lsp +++ b/Lisp/vf_standard.lsp @@ -808,6 +808,19 @@ ;; 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). +;; +;; 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 +859,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). +;; Gemeinsam genutzt von vfs-dialog-eingabe-basis-radio UND +;; vfs-dialog-winkel-verteilung-radio. +(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 +1048,169 @@ ) ) -;; Winkel/Verteilung-Eingabe (Dialog 2): Winkel-Popup aus den vorher +;; Basis-Eingabe (Dialog 1, Radio-Button-Variante) - siehe Kopfkommentar +;; des DCL-DIALOG-Abschnitts. 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; }" + " : edit_box { key = \"deltah\"; label = \"Hoehenunterschied deltaH (mm):\"; edit_width = 10; }" + " }")) + (setq zeilen (append zeilen + (vfs-dcl-radio-gruppe-zeilen "richtung" "Foerderrichtung:" + (list (ssg-text "vfs-dlg-richtung-auf") (ssg-text "vfs-dlg-richtung-ab"))))) + (setq zeilen (append zeilen (list + " : edit_box { key = \"einfuegehoehe\"; label = \"Einfuegehoehe (mm):\"; edit_width = 10; }" + " }" + " : boxed_column {" + " label = \"Ausrichtung\";"))) + (setq zeilen (append zeilen + (vfs-dcl-radio-gruppe-zeilen "fahrtrichtung" "Fahrtrichtung:" + (list (ssg-textf "gf-dlg-richtung-0" (list grad-zeichen)) + (ssg-textf "gf-dlg-richtung-90" (list grad-zeichen)) + (ssg-textf "gf-dlg-richtung-180" (list grad-zeichen)) + (ssg-textf "gf-dlg-richtung-270" (list grad-zeichen)))))) + (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 + (vfs-dcl-radio-gruppe-zeilen "dimension" "Darstellung (2D/3D):" (list "3D" "2D")))) + (setq zeilen (append zeilen (list + " }" + " : 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")) + (set_tile (strcat "richtung_" (itoa sel-richtung)) "1") + (set_tile (strcat "fahrtrichtung_" (itoa sel-fahrt)) "1") + (set_tile (strcat "seite_" (itoa sel-seite)) "1") + (set_tile (strcat "motorseite_" (itoa sel-motorseite)) "1") + (set_tile (strcat "dimension_" (itoa sel-dim)) "1") + (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 " (vfs-dcl-radio-idx-cond "richtung" 2) ")" + "(setq dlg-fahrt-idx " (vfs-dcl-radio-idx-cond "fahrtrichtung" 4) ")" + "(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 " (vfs-dcl-radio-idx-cond "dimension" 2) ")" + "(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 Radio-Button-Variante (siehe Kopfkommentar des +;; DCL-DIALOG-Abschnitts), Rueckfall auf -popup 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 +1279,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 +1289,131 @@ ) ) +;; Winkel/Verteilung-Eingabe (Dialog 2, Radio-Button-Variante) - siehe +;; Kopfkommentar des DCL-DIALOG-Abschnitts. Gleiche prefill-Struktur/ +;; Rueckgabe wie -popup; 'FEHLER bei technischem Fehler. +(defun vfs-dialog-winkel-verteilung-radio (gueltige-winkel ergebnis-liste staustrecke-basis prefill / + zeilen dcl-pfad dat ergebnis w eintrag labels + sel-winkel sel-verteilung idx toggle-zeile i + dlg-winkel-idx dlg-verteilung-idx dlg-lgf1 + best-winkel L_GF L_VF verteilung-modus L_GF1 L_GF2 lgf-paar) + ;; Winkel-Labels vorab aufloesen - gleiche Texte wie im Popup. + (setq labels nil) + (foreach w gueltige-winkel + (setq eintrag (assoc w ergebnis-liste)) + (setq labels (append labels (list + (if (= w 0) + (ssg-textf "vfs-dlg-winkel-horizontal" + (list (rtos (nth 1 eintrag) 2 1) (rtos (nth 2 eintrag) 2 1))) + (ssg-textf "vfs-dlg-winkel-option" + (list (itoa w) grad-zeichen (rtos (nth 1 eintrag) 2 1) (rtos (nth 2 eintrag) 2 1))) + ))) + ) + ) + + ;; Vorbelegung: Winkel aus prefill (falls noch gueltig), sonst erster + ;; (kleinster) gueltiger Winkel - analog der automatischen Konsolen-Wahl. + (setq sel-winkel 0 idx 0) + (if prefill + (foreach w gueltige-winkel + (if (equal w (cdr (assoc "winkel" prefill))) (setq sel-winkel idx)) + (setq idx (1+ idx)) + ) + ) + (setq sel-verteilung + (if prefill (atoi (cdr (assoc "verteilung-idx" prefill))) 0)) + + (setq zeilen (list + "vfs_winkel_dyn : dialog {" + " label = \"VarioFoerderer (Standard) - Winkel / Verteilung\";" + " : column {")) + (setq zeilen (append zeilen (vfs-dcl-radio-gruppe-zeilen "winkel" "Winkel:" labels))) + (setq zeilen (append zeilen (list + " : boxed_column {" + " label = \"Verteilung Gefaellestrecken (vorne/hinten)\";"))) + (setq zeilen (append zeilen + (vfs-dcl-radio-gruppe-zeilen "verteilung" "Modus:" + (list (ssg-text "vfs-dlg-verteilung-1") (ssg-text "vfs-dlg-verteilung-2") + (ssg-text "vfs-dlg-verteilung-3") (ssg-text "vfs-dlg-verteilung-4"))))) + (setq zeilen (append zeilen (list + " : edit_box { key = \"lgf1_manuell\"; label = \"L_GF1 vorne (mm):\"; edit_width = 10; }" + " }" + " }" + " ok_cancel;" + "}"))) + + (setq dcl-pfad (ssg-dcl-temp-schreiben "vfswinkel" zeilen)) + (if (null dcl-pfad) + 'FEHLER + (progn + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "vfs_winkel_dyn" dat)) + (progn + (if (and dat (>= dat 0)) (unload_dialog dat)) + (vl-file-delete dcl-pfad) + 'FEHLER + ) + (progn + (set_tile (strcat "winkel_" (itoa sel-winkel)) "1") + (set_tile (strcat "verteilung_" (itoa sel-verteilung)) "1") + (set_tile "lgf1_manuell" + (if (and prefill (cdr (assoc "lgf1" prefill))) + (rtos (cdr (assoc "lgf1" prefill)) 2 1) "0")) + (mode_tile "lgf1_manuell" (if (= sel-verteilung 3) 0 1)) + + ;; Jedes der 4 Verteilung-Radio-Tiles braucht sein EIGENES + ;; action_tile (haengt bei Radio-Buttons nicht am Gruppen-Key wie + ;; bisher am popup_list-Key "verteilung"). + (setq toggle-zeile + "(mode_tile \"lgf1_manuell\" (if (= (get_tile \"verteilung_3\") \"1\") 0 1))") + (setq i 0) + (while (< i 4) + (action_tile (strcat "verteilung_" (itoa i)) toggle-zeile) + (setq i (1+ i)) + ) + + (action_tile "accept" + (strcat + "(setq dlg-winkel-idx " (vfs-dcl-radio-idx-cond "winkel" (length gueltige-winkel)) ")" + "(setq dlg-verteilung-idx " (vfs-dcl-radio-idx-cond "verteilung" 4) ")" + "(setq dlg-lgf1 (get_tile \"lgf1_manuell\"))" + "(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 best-winkel (nth dlg-winkel-idx gueltige-winkel)) + (setq eintrag (assoc best-winkel ergebnis-liste)) + (setq L_GF (nth 1 eintrag) L_VF (nth 2 eintrag)) + (setq verteilung-modus (itoa dlg-verteilung-idx)) + (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 + ) + ) + ) + ) + ) +) + +;; Dispatcher: bevorzugt die Radio-Button-Variante (siehe Kopfkommentar des +;; DCL-DIALOG-Abschnitts), Rueckfall auf -popup nur bei technischem Fehler. +(defun vfs-dialog-winkel-verteilung (gueltige-winkel ergebnis-liste staustrecke-basis prefill / ergebnis) + (setq ergebnis (vfs-dialog-winkel-verteilung-radio gueltige-winkel ergebnis-liste staustrecke-basis prefill)) + (if (eq ergebnis 'FEHLER) + (vfs-dialog-winkel-verteilung-popup gueltige-winkel ergebnis-liste staustrecke-basis prefill) + ergebnis + ) +) + ;; ============================================================ ;; XDATA-Metadaten fuer den Edit-Nachbau (App "SSG_VF_EDIT"). ;; Markiert ein VF_n-INSERT als "mit dem Standard-Dialog erstellt" und diff --git a/dcl/variofoerderer.dcl b/dcl/variofoerderer.dcl index ef475a9..e47686c 100644 --- a/dcl/variofoerderer.dcl +++ b/dcl/variofoerderer.dcl @@ -5,12 +5,21 @@ // 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). +// 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 +// bevorzugten Radio-Button-Varianten (vfs_basis_dyn/vfs_winkel_dyn) +// werden zur Laufzeit generiert (vfs-dialog-eingabe-basis-radio/ +// vfs-dialog-winkel-verteilung-radio in vf_standard.lsp) und stehen +// NICHT in dieser Datei - diese beiden Dialoge hier sind nur noch der +// Fallback, falls das Schreiben/Laden der Temp-DCL-Datei mal scheitert. +// Die 3D-Linie-Eingabe (Modus "3D-Linie") und die Linienzug-Kette selbst +// (nach der Modus-Wahl) bleiben interaktiv (Kommandozeile bzw. eigener +// Wizard in vf_linienzug_wizard.dcl). // ============================================================ // Anlagen-Typ waehlen (Standard/Etage/Linienzug). Radio-Buttons statt @@ -101,6 +110,45 @@ vfc_linienzug_modus : dialog { } } +// 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"; From 8ef73240323e4ca33c49fc3393cd351548e6eed5 Mon Sep 17 00:00:00 2001 From: Samer Ayadi Date: Thu, 8 Oct 2026 11:35:12 +0200 Subject: [PATCH 3/3] [FIX] Kreisel-Umlauf (export_neighbors.compute_kreisel_umlauf): AS/ES, deren ZZ_ASES_MARKER-Box keinen Kreisel trifft, ueber den Ein-/Auslaufpunkt der Strecke (K1 = KS_EIN, K2 = KS_AUS) zuordnen - laeuft eine Strecke parallel zum Kreisel, liegt der Marker (Einfuegepunkt) ~560 mm neben der Kette, der Einlauf aber darauf (Dematic VF_5 an Kreisel1 fehlte in den TrackIds); bereits zugeordnete AS/ES unveraendert + Tests; [ADD] dxf_anlage_export.py: Kreisel-Drehrichtung (DREHRICHTUNG) ins Testdaten-JSON; [CHANGE] dematic_arvato.json aus dem aktuellen Dematic_TST.dxf (Kreisel 1/4 GUZ, BTMT Be-/Entladung, Scanner vor Separator 0048) Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 2 +- lib/dxf_anlage_export.py | 6 +- lib/export_neighbors.py | 30 ++++++ tests/test_dxf_anlage_export.py | 7 ++ tests/test_export_kreisel_umlauf.py | 53 ++++++++++ tests/testdata/dematic_arvato.json | 147 +++++++++++++++++----------- 6 files changed, 185 insertions(+), 60 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 9712b9f..82cca61 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -194,7 +194,7 @@ 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_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; 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_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 diff --git a/lib/dxf_anlage_export.py b/lib/dxf_anlage_export.py index c5e50e4..f864696 100644 --- a/lib/dxf_anlage_export.py +++ b/lib/dxf_anlage_export.py @@ -17,7 +17,7 @@ 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) + 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 @@ -210,6 +210,10 @@ def kreisel_eintrag(e, block_inhalt, projekt): ("abstand", _r(abstand)), ("rotation", _r(e["rot"])), ("typ", a.get("KREISELART") or "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. + ("drehrichtung", a.get("DREHRICHTUNG") or "UZS"), ("comment", "aus Zeichnung: %s (ID %s), abstand aus %s" % (e["name"], a.get("ID", "?"), quelle)), ]) 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/tests/test_dxf_anlage_export.py b/tests/test_dxf_anlage_export.py index b934190..22fb36f 100644 --- a/tests/test_dxf_anlage_export.py +++ b/tests/test_dxf_anlage_export.py @@ -57,6 +57,13 @@ def test_kreisel_abstand_aus_blockdefinition(): 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(): 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/testdata/dematic_arvato.json b/tests/testdata/dematic_arvato.json index 26603ec..7aade0b 100644 --- a/tests/testdata/dematic_arvato.json +++ b/tests/testdata/dematic_arvato.json @@ -8,7 +8,8 @@ "abstand": 3619.14, "rotation": 90.0, "typ": "STANDARD", - "comment": "aus Zeichnung: KREISEL_1_STANDARD_3619 (ID 0001), abstand aus Blockdefinition (AN8 -> SP8)" + "drehrichtung": "GUZ", + "comment": "aus Zeichnung: KREISEL_1_STANDARD_3619 (ID 0056), abstand aus Blockdefinition (AN8 -> SP8)" }, { "id": "Kreisel_Arvato_02", @@ -19,6 +20,7 @@ "abstand": 33044.28, "rotation": 180.0, "typ": "STANDARD", + "drehrichtung": "UZS", "comment": "aus Zeichnung: KREISEL_2_STANDARD_33044 (ID 0002), abstand aus Blockdefinition (AN8 -> SP8)" }, { @@ -30,6 +32,7 @@ "abstand": 33470.18, "rotation": 180.0, "typ": "STANDARD", + "drehrichtung": "UZS", "comment": "aus Zeichnung: KREISEL_3_STANDARD_33470 (ID 0003), abstand aus Blockdefinition (AN8 -> SP8)" }, { @@ -41,10 +44,11 @@ "abstand": 3619.14, "rotation": 90.0, "typ": "STANDARD", - "comment": "aus Zeichnung: KREISEL_4_STANDARD_3619 (ID 0004), abstand aus Blockdefinition (AN8 -> SP8)" + "drehrichtung": "GUZ", + "comment": "aus Zeichnung: KREISEL_4_STANDARD_3619 (ID 0055), abstand aus Blockdefinition (AN8 -> SP8)" }, { - "test_id": "VF_Arvato_02", + "test_id": "VF_Arvato_01", "typ": "standard", "richtung": "Auf", "deltaL": 11559.0, @@ -57,10 +61,10 @@ "x": 3314.07, "y": 24478.8, "z": 1826.0, - "comment": "aus Zeichnung: VF_2 (ID 0082), Hoehe 1826 -> 2437; deltaL/deltaH aus den (ganzzahligen) Attributen" + "comment": "aus Zeichnung: VF_1 (ID 0005), Hoehe 0 -> 611; deltaL/deltaH aus den (ganzzahligen) Attributen" }, { - "test_id": "VF_Arvato_03", + "test_id": "VF_Arvato_02", "typ": "standard", "richtung": "Auf", "deltaL": 11559.0, @@ -73,10 +77,10 @@ "x": 15285.06, "y": 24478.8, "z": 1826.0, - "comment": "aus Zeichnung: VF_3 (ID 0083), Hoehe 1826 -> 2437; deltaL/deltaH aus den (ganzzahligen) Attributen" + "comment": "aus Zeichnung: VF_2 (ID 0006), Hoehe 0 -> 611; deltaL/deltaH aus den (ganzzahligen) Attributen" }, { - "test_id": "VF_Arvato_05", + "test_id": "VF_Arvato_03", "typ": "standard", "richtung": "Auf", "deltaL": 11559.0, @@ -89,10 +93,10 @@ "x": 23843.05, "y": 24478.8, "z": 1826.0, - "comment": "aus Zeichnung: VF_5 (ID 0084), Hoehe 1826 -> 2437; deltaL/deltaH aus den (ganzzahligen) Attributen" + "comment": "aus Zeichnung: VF_3 (ID 0007), Hoehe 0 -> 611; deltaL/deltaH aus den (ganzzahligen) Attributen" }, { - "test_id": "VF_Arvato_06", + "test_id": "VF_Arvato_04", "typ": "standard", "richtung": "Auf", "deltaL": 22559.0, @@ -105,10 +109,10 @@ "x": 42163.78, "y": 4017.06, "z": 2177.0, - "comment": "aus Zeichnung: VF_6 (ID 0085), Hoehe 2177 -> 2177; deltaL/deltaH aus den (ganzzahligen) Attributen" + "comment": "aus Zeichnung: VF_4 (ID 0008), Hoehe 0 -> 0; deltaL/deltaH aus den (ganzzahligen) Attributen" }, { - "test_id": "VF_Arvato_08", + "test_id": "VF_Arvato_05", "typ": "standard", "richtung": "Auf", "deltaL": 6852.0, @@ -121,7 +125,7 @@ "x": 19551.49, "y": 5265.19, "z": 2177.0, - "comment": "aus Zeichnung: VF_8 (ID 0183), Hoehe 2177 -> 2437; deltaL/deltaH aus den (ganzzahligen) Attributen" + "comment": "aus Zeichnung: VF_5 (ID 0009), Hoehe 0 -> 260; deltaL/deltaH aus den (ganzzahligen) Attributen" }, { "test_id": "VF_Arvato_LZ_01", @@ -180,7 +184,7 @@ "INT:2", "STR:2" ], - "comment": "aus Zeichnung: VF_26 (ID 0184), 52 Eingaben, Hoehe 2177 -> 2174; wird 1:1 abgespielt (vsp-bau-journal)" + "comment": "aus Zeichnung: VF_6 (ID 0010), 52 Eingaben, Hoehe 2177 -> 2174; wird 1:1 abgespielt (vsp-bau-journal)" }, { "test_id": "GF_Arvato_01", @@ -195,7 +199,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_1 (ID 0005); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -210,7 +214,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_2 (ID 0006); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -225,7 +229,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_3 (ID 0007); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -240,7 +244,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_4 (ID 0008); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -255,7 +259,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_5 (ID 0009); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -270,7 +274,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_6 (ID 0010); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -285,7 +289,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_7 (ID 0011); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -300,7 +304,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_8 (ID 0012); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -315,7 +319,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_9 (ID 0013); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -330,7 +334,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_10 (ID 0014); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -345,7 +349,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_11 (ID 0015); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -360,7 +364,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_12 (ID 0016); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -375,7 +379,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_13 (ID 0017); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -390,7 +394,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_14 (ID 0018); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -405,7 +409,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_15 (ID 0019); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -420,7 +424,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_16 (ID 0020); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -435,7 +439,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_17 (ID 0021); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -450,7 +454,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_18 (ID 0022); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -465,7 +469,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_19 (ID 0023); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -480,7 +484,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_20 (ID 0024); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -495,7 +499,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_21 (ID 0025); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -510,7 +514,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_22 (ID 0026); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -525,7 +529,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_23 (ID 0027); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -540,7 +544,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_24 (ID 0028); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -555,7 +559,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_25 (ID 0029); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -570,7 +574,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_26 (ID 0030); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -585,7 +589,7 @@ "kreisel_start": "Kreisel_Arvato_02", "kreisel_ende": "Kreisel_Arvato_03", "hoehe_ende_mm": 1826.0, - "comment": "aus Zeichnung: GF_27 (ID 0031); Endhoehe = Hoehe von Kreisel_Arvato_03 (1826.0), Winkel rechnet der Treiber neu; gebaut war 3.7929 Grad -> HOEHE_BIS 1568" + "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", @@ -594,7 +598,7 @@ "y": 12119.73, "z": 2473.0, "rotation": 0.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0043, ZUORDNUNG 0002, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0038, ZUORDNUNG 0002, ARTINR 200000077)" }, { "function": "insert", @@ -603,7 +607,7 @@ "y": 24478.8, "z": 1826.0, "rotation": 0.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0044, ZUORDNUNG 0003, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0039, ZUORDNUNG 0003, ARTINR 200000077)" }, { "function": "insert", @@ -612,7 +616,7 @@ "y": 12919.72, "z": 2473.0, "rotation": 180.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0045, ZUORDNUNG 0002, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0040, ZUORDNUNG 0002, ARTINR 200000077)" }, { "function": "insert", @@ -621,7 +625,7 @@ "y": 24478.8, "z": 1826.0, "rotation": 0.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0046, ZUORDNUNG 0003, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0041, ZUORDNUNG 0003, ARTINR 200000077)" }, { "function": "insert", @@ -630,7 +634,7 @@ "y": 12919.78, "z": 2473.0, "rotation": 180.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0047, ZUORDNUNG 0002, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0042, ZUORDNUNG 0002, ARTINR 200000077)" }, { "function": "insert", @@ -639,7 +643,7 @@ "y": 5042.22, "z": 2177.0, "rotation": 270.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0048, ZUORDNUNG 0001, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0043, ZUORDNUNG 0056, ARTINR 200000077)" }, { "function": "insert", @@ -648,7 +652,7 @@ "y": 24478.8, "z": 1826.0, "rotation": 0.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0049, ZUORDNUNG 0003, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0044, ZUORDNUNG 0003, ARTINR 200000077)" }, { "function": "insert", @@ -657,7 +661,7 @@ "y": 12919.82, "z": 2473.0, "rotation": 180.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0050, ZUORDNUNG 0002, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0045, ZUORDNUNG 0002, ARTINR 200000077)" }, { "function": "insert", @@ -666,16 +670,16 @@ "y": 12919.72, "z": 2437.0, "rotation": 180.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0051, ZUORDNUNG 0002, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0046, ZUORDNUNG 0002, ARTINR 200000077)" }, { "function": "insert", "block": "Separator_SP", - "x": 35857.18, + "x": 35182.77, "y": 25278.8, "z": 1826.0, "rotation": 180.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0052, ZUORDNUNG 0003, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0047, ZUORDNUNG 0003, ARTINR 200000077)" }, { "function": "insert", @@ -684,7 +688,7 @@ "y": 4269.52, "z": 2177.0, "rotation": 90.0, - "comment": "aus Zeichnung: Separator_SP_3D (ID 0053, ZUORDNUNG 0004, ARTINR 200000077)" + "comment": "aus Zeichnung: Separator_SP_3D (ID 0048, ZUORDNUNG 0055, ARTINR 200000077)" }, { "function": "insert", @@ -693,7 +697,7 @@ "y": 24865.38, "z": 1826.0, "rotation": 90.0, - "comment": "aus Zeichnung: Scanner_3D (ID 0073, ZUORDNUNG 0003, ARTINR 829534306)" + "comment": "aus Zeichnung: Scanner_3D (ID 0049, ZUORDNUNG 0003, ARTINR 829534306)" }, { "function": "insert", @@ -702,7 +706,7 @@ "y": 13306.31, "z": 2473.0, "rotation": 90.0, - "comment": "aus Zeichnung: Scanner_3D (ID 0074, ZUORDNUNG 0005, ARTINR 829534306)" + "comment": "aus Zeichnung: Scanner_3D (ID 0050, ZUORDNUNG 0011, ARTINR 829534306)" }, { "function": "insert", @@ -711,7 +715,7 @@ "y": 24865.38, "z": 1826.0, "rotation": 90.0, - "comment": "aus Zeichnung: Scanner_3D (ID 0075, ZUORDNUNG 0003, ARTINR 829534306)" + "comment": "aus Zeichnung: Scanner_3D (ID 0051, ZUORDNUNG 0003, ARTINR 829534306)" }, { "function": "insert", @@ -720,7 +724,7 @@ "y": 13306.36, "z": 2473.0, "rotation": 90.0, - "comment": "aus Zeichnung: Scanner_3D (ID 0076, ZUORDNUNG 0002, ARTINR 829534306)" + "comment": "aus Zeichnung: Scanner_3D (ID 0052, ZUORDNUNG 0002, ARTINR 829534306)" }, { "function": "insert", @@ -729,7 +733,7 @@ "y": 24865.38, "z": 1826.0, "rotation": 90.0, - "comment": "aus Zeichnung: Scanner_3D (ID 0077, ZUORDNUNG 0003, ARTINR 829534306)" + "comment": "aus Zeichnung: Scanner_3D (ID 0059, ZUORDNUNG 0003, ARTINR 829534306)" }, { "function": "insert", @@ -738,6 +742,33 @@ "y": 13306.4, "z": 2473.0, "rotation": 90.0, - "comment": "aus Zeichnung: Scanner_3D (ID 0078, ZUORDNUNG 0022, ARTINR 829534306)" + "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)" } ]