mistangl/dxfmakros
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: verbleibende e76e24e-Luecken aus vollstaendigem Gap-Vergleich geschlossen

Browse Source 
Bei der abschliessenden Datei-fuer-Datei-Gap-Analyse gegen e76e24e (Funktions-
inventar + Lang-Key-Diff) zusaetzlich gefunden und behoben:

- vfl-modus-abbruch-sichern: "Zurueck"-Behandlung fehlte komplett - verwarf
  bisher wie "Abbrechen" den kompletten Stand statt nur das letzte
  angefangene Kettenglied zu verwerfen und automatisch neu zu fragen
  (vfl-journal-truncate/-replay-start)
- vfl-vf-einheit (Punkt 7, Auf/Ab-Foerderer-Fortsetzung): Fall "Kette kommt
  bereits flach an" (z.B. nach Horizontal-VF/Vario-Kurve) fehlte - fragte
  bisher immer nach einer Zielhoehe, obwohl dort keine sinnvolle Zielhoehe
  existiert; nutzt jetzt vfl-waehle-winkel-hoehen-tabelle
- Horizontal-VF: GF1-Stumpf wird bei vollem Eingang jetzt aus einer
  abgefragten Zielhoehe berechnet statt pauschal auf *vfl-gf-min-laenge*
  gesetzt
- Linie-VF/Linie (automatisch): erweiterte Stufe-2-Diagnose bei "nicht
  baubar" (Mindestwert-Vorschlaege aus vfl-stufe2-diagnose) ergaenzt
- vfl-hor-koerper-bauen: klemmt weiterhin still auf Mindestlaenge (Kollegen-
  Entscheidung, Bauteil muss fuer vf_spec.lsp deterministisch/kopflos
  bleiben), meldet das Klemmen jetzt aber ueber vfl-meldung - die
  urspruengliche interaktive "trotzdem bauen?"-Rueckfrage mit Checkpoint-
  Rueckbau war nicht ohne Bruch der Kopflos-Tauglichkeit restaurierbar

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Yuelin Wang
2026-09-11 22:02:39 +02:00
co-authored by Claude Sonnet 5
parent 0a1d21d8c5
commit 18ee46b361
3 changed files with 259 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Lisp/vf_linienzug.lsp
+223 -45
View File
@@ -77,7 +77,12 @@
*vfl-acc-gfbogen* '() ; Alist ("L_90".n ...) GF-Boegen
*vfl-acc-variokurve* '() ; Alist ("A_90".n ...) Vario-Kurven
*vfl-ziel-punkt* nil ; Soll-ES-Punkt fuer Option-3-Ist-Ziel-Report
*vfl-acc-separator* 0)) ; Anzahl eingefuegter Separatoren (300 mm)
*vfl-acc-separator* 0 ; Anzahl eingefuegter Separatoren (300 mm)
;; "Zurueck"/"Abbrechen"-Button (siehe vfl-in-value/vfl-modus-abbruch-
;; sichern): nil (normal) / "zurueck" (letztes Glied verwerfen und neu
;; fragen) / "abbrechen" (Bau hier stoppen, Baustand bleibt stehen).
*vfl-wizard-abbruch-grund* nil
*vfl-abbruch-letztes-ent* nil))
;; Alist-Zaehler erhoehen / lesen
(defun vfl-inc-count (al key / e)
@@ -2147,12 +2152,22 @@
;; vf-linienzug-modus.
(defun vfl-modus-abbruch-sichern (lastEnt vfl-nummer anzahl-gf anzahl-vf
startpunkt frame as-seite es-seite marker /
e cnt vfl-ins wickel-erg)
e cnt vfl-ins wickel-erg grund fwd n trunc)
;; Abbruch-Grund VOR dem Wickeln merken (das Flag wird unten evtl. schon
;; fuer den "Zurueck"-Neuaufruf zurueckgesetzt) UND immer konsumieren, damit
;; kein "Zurueck"/"Abbrechen" aus diesem Lauf in einen etwaigen naechsten
;; durchsickert (siehe auch Reset am Kopf von vf-linienzug-modus).
(setq grund *vfl-wizard-abbruch-grund*)
(setq *vfl-wizard-abbruch-grund* nil)
(dbgmsg (strcat "ABBRUCH-SICHERN erreicht: grund=" (if grund grund "nil(ESC/Fehler)")))
(setq cnt 0 e (if lastEnt (entnext lastEnt) (entnext)))
(while e (setq cnt (1+ cnt)) (setq e (entnext e)))
(cond
((or (= cnt 0) (null frame))
(princ (ssg-text "vfl-abbruch-nichts-gebaut")))
(princ (ssg-text "vfl-abbruch-nichts-gebaut"))
;; "Zurueck" ohne jede gebaute Geometrie (z.B. ganz am Anfang) - nichts
;; zu verwerfen, einfach denselben Lauf frisch neu starten.
(if (= grund "zurueck") (vl-catch-all-apply 'vf-linienzug-modus)))
(t
;; vfl-block-erstellen nutzt intern (command "_.UCS" ...) fuer den
;; BKS-Wechsel (ssg-block-wrap-welt) - im *error*-Handler-Kontext
@@ -2170,7 +2185,24 @@
(if (vl-catch-all-error-p wickel-erg)
(princ (ssg-textf "vfl-abbruch-wickeln-fehler"
(list (vl-catch-all-error-message wickel-erg))))
(princ (ssg-textf "vfl-abbruch-gesichert" (list (itoa cnt)))))
(progn
(princ (ssg-textf "vfl-abbruch-gesichert" (list (itoa cnt))))
(setq *vfl-abbruch-letztes-ent* vfl-ins)
;; "Zurueck": letztes (angefangenes) Glied verwerfen und automatisch
;; genau das tun, was der Sektions-Reset-Zweig von vfl-edit-ent sonst
;; ueber den Auswahl-Dialog macht - nur ohne den Dialog, Ziel-Sektion
;; ist immer "ein Glied weniger als jetzt vorhanden".
(if (and (= grund "zurueck") vfl-ins)
(progn
(setq fwd (reverse *vfl-journal*))
(setq n (length (vfl-journal-glieder fwd)))
(setq trunc (vfl-journal-truncate fwd (max 0 (1- n))))
(princ (ssg-text "vfl-zurueck-glied-verworfen"))
(entdel vfl-ins)
(vfl-journal-replay-start trunc)
(vl-catch-all-apply 'vf-linienzug-modus)))
)
)
)
)
(princ))
@@ -3097,10 +3129,22 @@
;; und der auf_3-Insert sitzt BEWUSST zwischen Subtraktion 1 und 2 - sein
;; Fussabdruck wird GEMESSEN (vfl-projiziere-distanz), nicht geschaetzt.
;; Hier darf nichts umsortiert werden.
;; Klemmt v auf *vfk-restlaenge-min-clamp*, falls es darunter faellt, und
;; meldet das (headless-sicher via vfl-meldung statt einer interaktiven
;; Rueckfrage - der Bauteil selbst bleibt deterministisch/kopflos-tauglich,
;; siehe vf_spec.lsp; anders als im urspruenglichen einteiligen Entwurf kann
;; hier daher nicht mehr nachgefragt/rueckgebaut werden, nur informieren).
(defun vfl-hor-koerper-klemmen (v / geklemmt)
(setq geklemmt (max *vfk-restlaenge-min-clamp* v))
(if (< v *vfk-restlaenge-min-clamp*)
(vfl-meldung (ssg-textf "vfl-hinweis-horizontal-fussabdruck-geklemmt"
(list (rtos v 2 0) (rtos geklemmt 2 0)))))
geklemmt)
(defun vfl-hor-koerper-bauen (frame hz dL ziel-modus ende-code sep-vor sep-nach
gf2-laenge / pt m1 pt-vor-bogen)
(setq pt (car frame))
(if (and ziel-modus sep-vor) (setq dL (max *vfk-restlaenge-min-clamp* (- dL *vfk-separator-laenge*))))
(if (and ziel-modus sep-vor) (setq dL (vfl-hor-koerper-klemmen (- dL *vfk-separator-laenge*))))
;; auf_3-Eintritt nur, wenn noch NICHT flach (sonst flache Zone fortsetzen).
;; dL ist die gewuenschte Reststrecke AB HIER (pt) - der reale Bogen-
;; Fussabdruck (gemessen, nicht aus der Tabellen-Masse geschaetzt - die
@@ -3113,19 +3157,19 @@
(princ (ssg-text "vfl-bogen-auf3-uebergang"))
(setq pt (insert-rotated-block-with-ks "Vario_Bogen_auf_3_TEF_rechts" pt
(ssg-cfg-or "vario" "gefaelle_winkel" 3) (car m1) (caddr m1) hz))
(setq dL (max *vfk-restlaenge-min-clamp* (- dL (vfl-projiziere-distanz pt-vor-bogen pt hz))))))
(if (and ziel-modus sep-nach) (setq dL (max *vfk-restlaenge-min-clamp* (- dL *vfk-separator-laenge*))))
(setq dL (vfl-hor-koerper-klemmen (- dL (vfl-projiziere-distanz pt-vor-bogen pt hz))))))
(if (and ziel-modus sep-nach) (setq dL (vfl-hor-koerper-klemmen (- dL *vfk-separator-laenge*))))
;; Ausgangs-Fussabdruck (Vario_Bogen_ab_3 + Motorstation) nur reservieren,
;; wenn die Einheit tatsaechlich sofort schliesst (Antwort 1 oder 3); bei
;; Antwort 1 zusaetzlich die GF2 hinter dem Motor.
(if ziel-modus
(cond
((= ende-code "1")
(setq dL (max *vfk-restlaenge-min-clamp* (- dL (car (get-bogen-mass bogen-ab (fix *vfk-gefaelle-winkel*))) *vfk-stations-laenge*
(setq dL (vfl-hor-koerper-klemmen (- dL (car (get-bogen-mass bogen-ab (fix *vfk-gefaelle-winkel*))) *vfk-stations-laenge*
(* (if gf2-laenge gf2-laenge 0.0)
(cos (* *vfk-gefaelle-winkel* (/ pi 180.0))))))))
((= ende-code "3")
(setq dL (max *vfk-restlaenge-min-clamp* (- dL (car (get-bogen-mass bogen-ab (fix *vfk-gefaelle-winkel*))) *vfk-stations-laenge*))))))
(setq dL (vfl-hor-koerper-klemmen (- dL (car (get-bogen-mass bogen-ab (fix *vfk-gefaelle-winkel*))) *vfk-stations-laenge*))))))
;; optionaler Separator VOR - in der horizontalen Ebene (0 Grad)
(if sep-vor (setq pt (vfl-sep-hz pt hz)))
;; horizontale Zwischenstrecke (0 Grad)
@@ -3712,7 +3756,8 @@
linie-mess dL dH hn hzn richtn ent typ w lgf lvf
letzt-hz fertig ziel-ende ziel-gf2 res3 gf2-eff entry-start
res-h vor-antwort es-gewuenscht es-antwort save-eindx save-eindz
hoehe-vorschlaege hoehe-ab hoehe-auf hoehe-fallback)
hoehe-vorschlaege hoehe-ab hoehe-auf hoehe-fallback
schon-flach winkel-hoehen-erg)
;; Vorbelegung: ES gewuenscht (Default) - nur bei "3 - Kettenende definieren"
;; wird explizit gefragt und ggf. auf nil gesetzt (siehe dort).
(setq es-gewuenscht t)
@@ -3859,46 +3904,89 @@
)
;; --- Auf/Ab-Foerderer (folgt der aktuellen Fahrtrichtung) ---
(t
;; Punkt 7: kommt die Kette hier bereits FLACH an (z.B. nach
;; Horizontal-VF/Vario-Kurve), gibt es keine sinnvolle Zielhoehe zum
;; Anpeilen - Auf/Ab wird dann direkt erfragt und aus einer
;; Winkel/Hoehe-Tabelle gewaehlt (vfl-waehle-winkel-hoehen-tabelle),
;; statt eine Zielhoehe abzufragen. schon-flach MUSS vor der
;; vfl-nach-3grad-Wandlung ermittelt werden.
(setq schon-flach (vfl-frame-flach-p frame))
;; gewinkeltes VF braucht 3-Grad-Basis -> flache Zone ggf. mit ab_3 beenden
(setq frame (vfl-nach-3grad frame))
(setq linie-mess (vfl-neue-linie-messen (car frame) letzt-hz))
(if (null linie-mess) (progn (princ (ssg-text "vfl-abgebrochen")) (exit)))
(if linie-mess
(progn
(setq dL (car linie-mess) hzn (cadr linie-mess))
(if (> dL 1.0)
(progn
;; NUR-VF-Vorschlaege (nicht vfl-segment-hoehe-vorschlaege):
;; dieser Zweig setzt eine bestehende VF-Kette fort und lehnt
;; ein hier zurueckkommendes typ="GF" explizit ab (siehe
;; "vfl-segment-gf-nicht-erlaubt" unten) - der GF-Vorschlag
;; (3-Grad-Formel) waere hier also gerade NICHT baubar.
(setq hoehe-vorschlaege (vfl-vf-hoehe-vorschlaege (caddr (car frame)) dL))
(setq hoehe-ab (nth 0 hoehe-vorschlaege) hoehe-auf (nth 1 hoehe-vorschlaege))
(setq hoehe-fallback (if hoehe-ab hoehe-ab (caddr (car frame))))
(vfl-hoehe-hinweis-falls-noetig hoehe-ab hoehe-auf)
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-ziel-hoehe-impl
(list (list hoehe-ab hoehe-auf (caddr (car frame))))))
(setq hn (vfl-in-real
(if (and hoehe-ab hoehe-auf)
(ssg-textf "vfl-prompt-hoehe-endpunkt-2"
(list (rtos hoehe-ab 2 1) (rtos hoehe-auf 2 1)))
(ssg-textf "vfl-prompt-hoehe-endpunkt"
(list (rtos hoehe-fallback 2 1))))))
(if (null hn) (setq hn hoehe-fallback))
(setq dH (- hn (caddr (car frame))))
(setq richtn (if (>= dH 0.0) "Auf" "Ab"))
(setq dH (abs dH))
(setq ent (vfl-segment-entscheidung dL dH richtn))
(setq typ (nth 0 ent) w (nth 1 ent) lgf (nth 2 ent) lvf (nth 3 ent))
(if (and typ (= typ "VF"))
(progn
(setq frame (vfl-frame-3grad (vfs-vf-koerper (car frame) richtn w lvf hzn) hzn))
(setq vf-count (1+ vf-count) letzt-hz hzn)
(vfl-acc-vf-seg richtn w lvf)
(vfl-20m-check p-umlenk (car frame))
(if schon-flach
(progn
(princ (ssg-text "vfl-frage-auf-ab-richtung"))
(princ (ssg-text "vfl-opt-richtung-auf"))
(princ (ssg-text "vfl-opt-richtung-ab"))
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-richtung-impl
(list (ssg-text "vfl-frage-auf-ab-richtung"))))
(setq antwort (vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-opt-richtung-auf")
(ssg-text "vfl-opt-richtung-ab")) 1
"vfl-frage-auf-ab-richtung"))
(setq richtn (if (= antwort "2") "Ab" "Auf"))
(setq winkel-hoehen-erg
(vfl-waehle-winkel-hoehen-tabelle dL richtn (caddr (car frame))))
(if winkel-hoehen-erg
(progn
(setq w (nth 0 winkel-hoehen-erg) lvf (nth 2 winkel-hoehen-erg))
;; Ist-Ziel-Vergleich: vorhergesagte Endhoehe sichern, um
;; nach dem echten Bau (vfs-vf-koerper, unabhaengig
;; verifiziert) auf Abweichung zu pruefen - Sicherheitsnetz
;; fuer die neue Formel, ohne die reale Geometrie zu beeinflussen.
(setq hn (+ (caddr (car frame)) (nth 1 winkel-hoehen-erg)))
(setq frame (vfl-frame-3grad (vfs-vf-koerper (car frame) richtn w lvf hzn) hzn))
(setq vf-count (1+ vf-count) letzt-hz hzn)
(vfl-acc-vf-seg richtn w lvf)
(vfl-20m-check p-umlenk (car frame))
(if (> (abs (- (caddr (car frame)) hn)) 5.0)
(princ (ssg-textf "vfl-winkel-hoehen-abweichung"
(list (rtos hn 2 0) (rtos (caddr (car frame)) 2 0)))))
)
(princ (ssg-text "vfl-linie-zu-kurz-simple"))
)
)
(progn
;; NUR-VF-Vorschlaege (nicht vfl-segment-hoehe-vorschlaege):
;; dieser Zweig setzt eine bestehende VF-Kette fort und lehnt
;; ein hier zurueckkommendes typ="GF" explizit ab (siehe
;; "vfl-segment-gf-nicht-erlaubt" unten) - der GF-Vorschlag
;; (3-Grad-Formel) waere hier also gerade NICHT baubar.
(setq hoehe-vorschlaege (vfl-vf-hoehe-vorschlaege (caddr (car frame)) dL))
(setq hoehe-ab (nth 0 hoehe-vorschlaege) hoehe-auf (nth 1 hoehe-vorschlaege))
(setq hoehe-fallback (if hoehe-ab hoehe-ab (caddr (car frame))))
(vfl-hoehe-hinweis-falls-noetig hoehe-ab hoehe-auf)
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-ziel-hoehe-impl
(list (list hoehe-ab hoehe-auf (caddr (car frame))))))
(setq hn (vfl-in-real
(if (and hoehe-ab hoehe-auf)
(ssg-textf "vfl-prompt-hoehe-endpunkt-2"
(list (rtos hoehe-ab 2 1) (rtos hoehe-auf 2 1)))
(ssg-textf "vfl-prompt-hoehe-endpunkt"
(list (rtos hoehe-fallback 2 1))))))
(if (null hn) (setq hn hoehe-fallback))
(setq dH (- hn (caddr (car frame))))
(setq richtn (if (>= dH 0.0) "Auf" "Ab"))
(setq dH (abs dH))
(setq ent (vfl-segment-entscheidung dL dH richtn))
(setq typ (nth 0 ent) w (nth 1 ent) lgf (nth 2 ent) lvf (nth 3 ent))
(if (and typ (= typ "VF"))
(progn
(setq frame (vfl-frame-3grad (vfs-vf-koerper (car frame) richtn w lvf hzn) hzn))
(setq vf-count (1+ vf-count) letzt-hz hzn)
(vfl-acc-vf-seg richtn w lvf)
(vfl-20m-check p-umlenk (car frame))
)
(princ (ssg-text "vfl-segment-gf-nicht-erlaubt"))
)
(princ (ssg-text "vfl-segment-gf-nicht-erlaubt"))
)
)
(princ (ssg-text "vfl-linie-zu-kurz-simple"))
@@ -4643,7 +4731,8 @@
hoehe-vorschlaege hoehe-ab hoehe-auf hoehe-fallback
gf-laenge-modus gf-steigend-modus sep-vor-gf sep-nach-gf
sep-anzahl erg-bogen vf-eingang-lgf vf-eingang-modus
eingang-laenge winkel-hoehen-erg)
eingang-laenge winkel-hoehen-erg
bogen-mass fest-drop fest-laenge eingang-fertig)
(princ "\n\n=========================================")
(princ (ssg-text "vfl-modus1-header"))
(princ "\n=========================================")
@@ -4929,7 +5018,64 @@
;; VF").
(setq erg (vfl-eingang-modus-bestimmen letzter-typ kettenanfang as-vorhanden p-aktuell))
(setq vf-eingang-lgf (car erg) vf-eingang-modus (cdr erg))
;; VF-Einheit mit horizontalem ersten Koerper (winkel=0, L_VF=deltaL).
;; Bei einem vollen Neuaufbau des Eingangs (modus=nil, GF1 wird
;; frisch gebaut) wird GF1 nicht pauschal auf *vfl-gf-min-laenge*
;; gesetzt, sondern aus einer abgefragten Zielhoehe berechnet - der
;; Rest bleibt wie bisher horizontal. Bei den anderen Eingangs-Modi
;; ("separator"/"gf"/"keine" - Fortsetzung nach einem Vorglied) wird
;; ohnehin kein neues GF1 gebaut, daher unveraendert.
(if (null vf-eingang-modus)
(progn
(if (or (not *lib-initialized*) (null bogen-auf)) (init-bibliothek))
(setq rad3 (* *vfk-gefaelle-winkel* (/ pi 180.0)))
(setq bogen-mass (get-bogen-mass bogen-auf (fix *vfk-gefaelle-winkel*)))
;; Hoehen- bzw. Laengenanteil der FIXEN Elemente (Separator +
;; Umlenkstation + Uebergangsbogen), OHNE GF1 - empirisch
;; bestaetigt: jedes Element traegt Schraeglaenge*sin(3 Grad) an
;; Hoehe bei, der Uebergangsbogen einen festen, winkelunabhaengigen
;; dx/dz-Fussabdruck aus der Bogen-Tabelle.
(setq fest-drop (+ (* *vfk-separator-laenge* (sin rad3))
(* *vfk-stations-laenge* (sin rad3))
(caddr bogen-mass)))
(setq fest-laenge (+ *vfk-separator-laenge* *vfk-stations-laenge* (car bogen-mass)))
(setq eingang-fertig nil)
(while (not eingang-fertig)
(setq eingang-fertig t)
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-ziel-hoehe-impl
(list (- (caddr p-aktuell) fest-drop))))
(setq hoehe-neu
(vfl-in-real (ssg-textf "vfl-prompt-hoehe-eingang-gf1"
(list (rtos (- (caddr p-aktuell) fest-drop) 2 1)))))
(if (null hoehe-neu) (setq hoehe-neu (- (caddr p-aktuell) fest-drop)))
(setq deltaH (- (caddr p-aktuell) hoehe-neu))
(cond
((<= deltaH 0.0)
(vfl-meldung (ssg-text "vfl-alert-eingang-kann-nicht-steigen"))
(setq vf-eingang-lgf nil))
((< deltaH fest-drop)
(vfl-meldung (ssg-textf "vfl-alert-eingang-hoehe-zu-klein" (list (rtos fest-drop 2 0))))
(setq eingang-fertig nil))
(t
(setq vf-eingang-lgf (/ (- deltaH fest-drop) (sin rad3)))
(if (> (+ vf-eingang-lgf fest-laenge) deltaL)
(progn
(vfl-meldung (ssg-textf "vfl-alert-eingang-hoehe-zu-gross"
(list (rtos (- (caddr p-aktuell) fest-drop
(* (- deltaL fest-laenge) (sin rad3))) 2 0))))
(setq vf-eingang-lgf nil))
)
)
)
)
)
)
;; VF-Einheit mit horizontalem ersten Koerper (winkel=0, L_VF=deltaL) -
;; nur bauen, wenn vf-eingang-lgf gueltig ist (s.o.). Ist es nil (Abbruch
;; wegen unpassender Zielhoehe), wird NICHTS gebaut - die aeussere
;; Schleife zeigt danach automatisch wieder "Naechstes Element waehlen".
(if vf-eingang-lgf
(progn
(if dbg-an
(dbgmsg (strcat "GEOMETRIE: vfl-vf-einheit-abschluss horizontal (deltaL=" (rtos deltaL 2 0)
" L_GF=" (rtos vf-eingang-lgf 2 0) " L_VF=" (rtos deltaL 2 0)
@@ -4949,6 +5095,8 @@
(if dbg-an
(dbgmsg (strcat "GEOMETRIE ERFOLG: Horizontal-VF-Einheit gebaut, neue Position="
(dbg-tostring p-aktuell))))
)
)
)
)
)
@@ -5380,7 +5528,7 @@
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-richtung-impl
(list (ssg-text "vfl-frage-auf-ab-richtung"))))
(setq antwort (vfl-menu (ssg-text "vfl-prompt-wahl-1-2")
(setq antwort (vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-opt-richtung-auf")
(ssg-text "vfl-opt-richtung-ab")) 1
"vfl-frage-auf-ab-richtung"))
@@ -5450,6 +5598,21 @@
(progn
(vfl-meldung (ssg-textf "vfl-alert-vf-nicht-baubar"
(list (rtos deltaL 2 0) (rtos deltaH 2 0) richtung)))
;; Gesammelte Stufe-2-Diagnose (falls versucht) + kompaktes
;; 2-Punkte-Alert mit Mindestwerten - analog vfl-body-abschluss.
(if *vfl-stufe2-diagnose-text* (princ *vfl-stufe2-diagnose-text*))
(vfl-meldung
(strcat
(ssg-textf "vfl-alert-vf-entscheidung-p1" (list (rtos deltaL 2 0) (rtos deltaH 2 0) richtung))
(cond
((and *vfl-stufe2-minl-vorschlag* *vfl-stufe2-minh-vorschlag*)
(ssg-textf "vfl-alert-vf-entscheidung-p2-beide"
(list (rtos *vfl-stufe2-minl-vorschlag* 2 0) (rtos *vfl-stufe2-minh-vorschlag* 2 0))))
(*vfl-stufe2-minh-vorschlag*
(ssg-textf "vfl-alert-vf-entscheidung-p2-nur-minh" (list (rtos *vfl-stufe2-minh-vorschlag* 2 0))))
(*vfl-stufe2-minl-vorschlag*
(ssg-textf "vfl-alert-vf-entscheidung-p2-nur-minl" (list (rtos *vfl-stufe2-minl-vorschlag* 2 0))))
(t ""))))
(if dbg-an
(dbgmsg (strcat "GEOMETRIE FEHLGESCHLAGEN: Linie-VF nicht baubar (deltaL="
(rtos deltaL 2 0) " deltaH=" (rtos deltaH 2 0)
@@ -5574,6 +5737,21 @@
(progn
(vfl-meldung (ssg-textf "vfl-alert-segment-nicht-baubar"
(list (rtos deltaL 2 0) (rtos deltaH 2 0) richtung)))
;; Gesammelte Stufe-2-Diagnose (falls versucht) + kompaktes
;; 2-Punkte-Alert mit Mindestwerten - analog vfl-body-abschluss.
(if *vfl-stufe2-diagnose-text* (princ *vfl-stufe2-diagnose-text*))
(vfl-meldung
(strcat
(ssg-textf "vfl-alert-vf-entscheidung-p1" (list (rtos deltaL 2 0) (rtos deltaH 2 0) richtung))
(cond
((and *vfl-stufe2-minl-vorschlag* *vfl-stufe2-minh-vorschlag*)
(ssg-textf "vfl-alert-vf-entscheidung-p2-beide"
(list (rtos *vfl-stufe2-minl-vorschlag* 2 0) (rtos *vfl-stufe2-minh-vorschlag* 2 0))))
(*vfl-stufe2-minh-vorschlag*
(ssg-textf "vfl-alert-vf-entscheidung-p2-nur-minh" (list (rtos *vfl-stufe2-minh-vorschlag* 2 0))))
(*vfl-stufe2-minl-vorschlag*
(ssg-textf "vfl-alert-vf-entscheidung-p2-nur-minl" (list (rtos *vfl-stufe2-minl-vorschlag* 2 0))))
(t ""))))
(if dbg-an
(dbgmsg (strcat "GEOMETRIE FEHLGESCHLAGEN: Linie (automatisch) nicht baubar"
" (deltaL=" (rtos deltaL 2 0) " deltaH=" (rtos deltaH 2 0)