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

fix: VF-Familie bei "Neue Linie BIS Kettenende" nutzt vfl-body-abschluss

Browse Source 
Ersetzt den direkten vfl-vf-entscheidung-Aufruf (1300mm Budget, setzt
immer eine frische Umlenkstation voraus) durch Wiederverwendung von
vfl-body-abschluss + vfl-vf-ausgang-bauen - denselben Bausteinen, die
bereits "Option 3: Kettenende exakt am Zielpunkt" innerhalb einer
laufenden VF-Einheit nutzt (800mm Budget, keine Umlenkstation, volle
Stufe-1/2-Diagnose inkl. exakter Zielhoehe bleibt erhalten, da kein
GF1-Stumpf noetig ist).

Zusaetzlich: vfl-letzter-typ-familie korrigiert - letzter-typ="VF"
(gerade fertig gebaute VF-Einheit) zaehlt NICHT zur "VF"-Familie fuer
diesen Zweck, nur "Vario-Kurve" hat keine eigene Umlenkstation. Eine
neue VF-Einheit nach einer bereits fertigen braucht weiterhin eine
frische Umlenkstation (faellt jetzt korrekt auf die bisherige
Automatik zurueck).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Yuelin Wang
2026-09-12 01:33:01 +02:00
co-authored by Claude Sonnet 5
parent 38ee74ed3e
commit 0d9ec93623
1 changed files with 311 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Lisp/vf_linienzug.lsp
+311 -256
View File
@@ -3486,12 +3486,16 @@
;; Vereinheitlichte Stufe-1(Winkel-Tabelle)/Stufe-2(horizontal+GF)-Entscheidung.
;; Genutzt von ZWEI Aufrufern mit unterschiedlichem Fest-Budget:
;; - vfl-body-zerlegung (Kettenende innerhalb einer laufenden VF-Einheit):
;; - vfl-body-zerlegung (Kettenende innerhalb einer laufenden VF-Einheit
;; ODER "Neue Linie BIS Kettenende" mit als VF-Familie erkanntem
;; Startpunkt, siehe linie-ende-familie/vfl-body-abschluss - beide Faelle
;; brauchen KEINE eigene Umlenkstation):
;; feste-hz=*vfk-feste-horizontal-kettenende* (800, nur Motor+Separator -
;; der Eingang ist zu diesem Zeitpunkt schon gebaut).
;; - vfl-vf-entscheidung ("Neue Linie: Ab/Auf VF"/"BIS Kettenende", Eingang
;; einer FRISCHEN VF-Einheit): feste-hz=*vfl-feste-horizontal* (1300,
;; Umlenkstation+Separator+Motorstation).
;; der Eingang ist zu diesem Zeitpunkt schon gebaut bzw. entfaellt).
;; - vfl-vf-entscheidung ("Neue Linie: Ab/Auf VF" bzw. "BIS Kettenende" mit
;; NICHT eindeutig zuordenbarem Startpunkt, Eingang einer FRISCHEN
;; VF-Einheit): feste-hz=*vfl-feste-horizontal* (1300, Umlenkstation+
;; Separator+Motorstation).
;; schon-flach: nur fuer den Kettenende-Fortsetzungsfall relevant (Frame kann
;; dort schon flach sein, siehe vfl-baue-horizontal-koerper) - am Eingang
;; einer frischen VF-Einheit immer nil (Frame kommt frisch von der
@@ -4452,9 +4456,16 @@
;; laufende Fortsetzung (kettenanfang=nil) ist der Vorgaengertyp bereits
;; ohne KS_AUS-Scan bekannt. "Separator" zaehlt als GF-Familie (er folgt in
;; diesem Ablauf immer auf ein GF-Segment, siehe "Linie-GF"-Zweig).
;; WICHTIG: "VF" (eine gerade FERTIG gebaute VF-Einheit, Motorstation schon
;; eingefuegt) zaehlt hier BEWUSST NICHT zur "VF"-Familie - eine neue
;; VF-Einheit direkt danach braucht sehr wohl eine frische Umlenkstation
;; (siehe vfl-eingang-modus-bestimmen: nur "Vario-Kurve" mappt dort auf
;; eingang-modus="keine", "VF" fehlt dort bewusst und faellt auf den
;; Default/volle-Eingang-Fall zurueck). Nur "Vario-Kurve" hat keine eigene
;; Umlenkstation/keinen Abschluss - eine zweite waere mechanisch sinnlos.
(defun vfl-letzter-typ-familie (letzter-typ)
(cond
((member letzter-typ '("VF" "Vario-Kurve")) "VF")
((equal letzter-typ "Vario-Kurve") "VF")
((member letzter-typ '("GF" "Separator")) "GF")
(t nil)
)
@@ -4860,7 +4871,8 @@
sep-anzahl erg-bogen vf-eingang-lgf vf-eingang-modus
eingang-laenge winkel-hoehen-erg
bogen-mass fest-drop fest-laenge eingang-fertig
linie-ende-familie linie-ende-untermodus)
linie-ende-familie linie-ende-untermodus
res3 save-eindx save-eindz es-gewuenscht)
;; "Zurueck"/"Abbrechen"-Flag ganz am Anfang zuruecksetzen (auch schon vor
;; der ersten Praeambel-Frage) - sonst wuerde ein von einem VORHERIGEN Lauf
;; noch gesetztes Flag (z.B. nach "Abbrechen") den allerersten vfl-in-*-
@@ -5808,263 +5820,306 @@
((= wahl "Linie") ;; --- Neue Linie BIS Kettenende ---
;; GF/VF-Entscheidung: wird der Startpunkt eindeutig einer bestehenden
;; VF- oder GF-Kette zugeordnet (linie-ende-familie, siehe unten),
;; entscheidet DAS die Bau-Logik (Stufe-1/2-Diagnose bzw. Endpunkt/
;; Zielhoehe-Wahl) - nur wenn nicht eindeutig, greift weiterhin die
;; automatische Machbarkeits-Entscheidung (vfl-segment-entscheidung).
;; Fahrtrichtung folgt dem vorherigen Element (Frame); nur das erste
;; Segment (frame=nil) definiert die Richtung frei.
(setq linie-mess (vfl-neue-linie-messen p-aktuell
(if frame (car (frame->hz-winkel frame)) nil)))
(if (null linie-mess) (progn (princ (ssg-text "vfl-abgebrochen")) (exit)))
(setq deltaL (car linie-mess) hz-neu (cadr linie-mess))
;; VF- oder GF-Kette zugeordnet (linie-ende-familie), entscheidet DAS
;; die Bau-Logik - nur wenn nicht eindeutig, greift die automatische
;; Machbarkeits-Entscheidung (vfl-segment-entscheidung).
(setq kettenanfang (null frame))
;; Startpunkt-Typ erkennen (VF/GF/nicht eindeutig): bei einer
;; laufenden Fortsetzung ist der Vorgaengertyp schon bekannt
;; (letzter-typ); am echten Kettenanfang OHNE AS-Element wird wie bei
;; vfl-eingang-modus-bestimmen per KS_AUS-Scan erkannt, ob der
;; gepickte Startpunkt auf einer bestehenden VF- oder GF-Kette liegt.
;; Steht schon ein AS-Element (as-vorhanden), ist der Anfang per
;; Definition neutral/nicht zuordenbar - dann bleibt die generische
;; Automatik (vfl-segment-entscheidung) unten aktiv. Genutzt weiter
;; unten, um bei erkannter Familie NICHT die generische Automatik zu
;; fragen, sondern direkt die passende (VF: Stufe-1/2-Diagnose; GF:
;; Endpunkt/Zielhoehe-Wahl wie "Neue Linie: GF") Logik zu verwenden.
;; Startpunkt-Typ erkennen: bei einer laufenden Fortsetzung ist der
;; Vorgaengertyp schon bekannt (letzter-typ); am echten Kettenanfang
;; OHNE AS-Element wird wie bei vfl-eingang-modus-bestimmen per
;; KS_AUS-Scan erkannt (Rueckgabe (hz . typ) - typ wird bei VF-Familie
;; unten fuer die Flach/3-Grad-Unterscheidung gebraucht). Steht schon
;; ein AS-Element (as-vorhanden), ist der Anfang per Definition
;; neutral/nicht zuordenbar.
(setq erg (if (and kettenanfang (not as-vorhanden))
(vfl-ks-aus-hz-an-punkt p-aktuell)
nil))
(setq linie-ende-familie
(if kettenanfang
(if (not as-vorhanden)
(progn
(setq erg (vfl-ks-aus-hz-an-punkt p-aktuell))
(if erg (vfl-kette-typ-familie (cdr erg)) nil))
nil)
(if erg (vfl-kette-typ-familie (cdr erg)) nil)
(vfl-letzter-typ-familie letzter-typ)))
(if (< deltaL 1.0)
(princ (ssg-text "vfl-fehler-linie-zu-kurz"))
(progn
;; Kettenanfang: AS-Element (falls gewuenscht) SOFORT einfuegen
;; (immer flach, typ-unabhaengig - siehe vfl-insert-as-element;
;; welcher Segmenttyp folgt, steht hier noch nicht fest), reale
;; Restlaenge aus dem tatsaechlichen KS_AUS nachrechnen (siehe
;; vfl-kettenanfang-baustein).
(if kettenanfang
(progn
(setq erg (vfl-kettenanfang-baustein p-aktuell hz-neu deltaL as-seite as-vorhanden))
(setq frame (nth 0 erg) deltaL (nth 1 erg) p-aktuell (car frame))
)
)
;; Nach dem AS-Einfuegen kann die reale Restlaenge (aus dem
;; tatsaechlichen KS_AUS neu gemessen) kleiner als der urspruenglich
;; gepickte Rohwert sein - bei einem knapp gepickten Punkt sogar
;; NEGATIV. Ohne diese zweite Pruefung wuerde die Kurzsegment-
;; Automatik unten (< 1000mm) mit negativem deltaL trotzdem ein
;; "erfolgreiches" GF-Segment bauen (entartete/unsichtbare Strecke,
;; das naechste Element - z.B. ein GF-Bogen - erscheint dann direkt
;; am AS-Element, obwohl der Nutzer davor noch eine Linie wollte).
(if (< deltaL 1.0)
(princ (ssg-text "vfl-fehler-linie-zu-kurz"))
(progn
;; Segment-Typ bestimmen. Kurzsegment (deltaL < 1000 mm): KEINE
;; Hoehenabfrage - automatisch 3-Grad-Gefaellestrecke. Grund: ein VF
;; braucht >= 1000 mm deltaL (Umlenk- + Motorstation = 500+500 mm),
;; und eine GF ist mindestens 3 Grad geneigt. Die Endhoehe ergibt
;; sich damit fest aus deltaH = deltaL*tan(3 Grad).
;; Im Kettenende-Modus (Option 4) wird IMMER nach der Zielhoehe
;; gefragt (Kurzsegment-Automatik hier ueberspringen).
(if (and (< deltaL *vfk-vf-mindestlaenge*) (not linie-ende-modus))
(progn
(setq typ "GF" winkel *vfk-gefaelle-winkel* richtung "Ab" L_GF nil L_VF nil)
(setq deltaH (* deltaL (/ (sin (* *vfk-gefaelle-winkel* (/ pi 180.0)))
(cos (* *vfk-gefaelle-winkel* (/ pi 180.0))))))
(setq hoehe-neu (- (caddr p-aktuell) deltaH))
(princ (ssg-textf "vfl-info-kurzes-segment"
(list (rtos deltaL 2 0) (rtos deltaH 2 1))))
)
(progn
(setq hoehe-vorschlaege (vfl-segment-hoehe-vorschlaege (caddr p-aktuell) deltaL))
(setq hoehe-ab (nth 0 hoehe-vorschlaege) hoehe-auf (nth 1 hoehe-vorschlaege))
(setq hoehe-fallback (if hoehe-ab hoehe-ab (caddr p-aktuell)))
(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 p-aktuell)))))
(setq hoehe-neu
(vfl-in-real
(if (and hoehe-ab hoehe-auf)
(ssg-textf "vfl-prompt-hoehe-linienendpunkt-2"
(list (rtos hoehe-ab 2 1) (rtos hoehe-auf 2 1)))
(ssg-textf "vfl-prompt-hoehe-linienendpunkt" (list (rtos hoehe-fallback 2 1))))))
(if (null hoehe-neu) (setq hoehe-neu hoehe-fallback))
(setq deltaH (- hoehe-neu (caddr p-aktuell)))
(setq richtung (if (>= deltaH 0.0) "Auf" "Ab"))
(setq deltaH (abs deltaH))
(vfl-echo-endpunkt-hoehe p-aktuell deltaL hz-neu hoehe-neu deltaH richtung)
;; Kettenende-Modus (Option 4): Der abgefragte Endpunkt (XY+Z)
;; ist das exakte Ende der Kette NACH Separator + ES-Element.
;; Deren Footprint (Separator 300 mm bei ~3 Grad + ES-Element
;; ein-dx/ein-dz) muss vom baubaren GF/VF-Segment reserviert
;; (abgezogen) werden, damit das ES-Element genau am Zielpunkt
;; endet. Naeherung: Separator-Neigung = 3 Grad (Auslauf).
(if linie-ende-modus
(progn
(setq rad3 (* (float (ssg-cfg-or "vario" "gefaelle_winkel" 3))
(/ pi 180.0)))
(setq deltaL (max 1.0 (- deltaL (* *vfk-separator-laenge* (cos rad3))
(abs (if ein-dx ein-dx 0.0)))))
(setq deltaH (max 0.0 (- deltaH (* *vfk-separator-laenge* (sin rad3))
(abs (if ein-dz ein-dz 0.0)))))
(princ (ssg-textf "vfl-info-kettenende-footprint"
(list (rtos deltaL 2 0) (rtos deltaH 2 0))))
)
)
(cond
;; --- Startpunkt als VF-Familie erkannt ---
;; IMMER ueber die Stufe-1/Stufe-2-Diagnose bauen (auch
;; wenn der natuerliche Winkel zufaellig nahe 3 Grad
;; liegt) - vfl-segment-entscheidung wuerde in dem Fall
;; faelschlich eine reine GF waehlen, obwohl der
;; Vorgaenger eindeutig eine VF-Kette ist.
((equal linie-ende-familie "VF")
(setq entscheidung (vfl-vf-entscheidung deltaL deltaH richtung))
(setq typ (nth 0 entscheidung) winkel (nth 1 entscheidung)
L_GF (nth 2 entscheidung) L_VF (nth 3 entscheidung)))
;; --- Startpunkt als GF-Familie erkannt ---
;; Dieselbe Endpunkt-/Zielhoehe-Wahl wie "Neue Linie: GF"
;; (Zweig A/B) statt der generischen Automatik - eine
;; reine Gefaellestrecke kann nicht steigen.
((equal linie-ende-familie "GF")
;; Stufe-2-Diagnosevariablen zuruecksetzen: dieser Zweig
;; ruft vfl-vf-entscheidung NICHT auf, ein evtl. noch
;; von einem frueheren Versuch gesetzter Text/Vorschlag
;; darf bei einem hier fehlschlagenden GF-Segment nicht
;; faelschlich mit angezeigt werden (siehe gemeinsamer
;; "typ=nil"-Meldungsblock unten).
(setq *vfl-stufe2-diagnose-text* nil)
(setq *vfl-stufe2-minl-vorschlag* nil *vfl-stufe2-minh-vorschlag* nil)
(if (= richtung "Auf")
(setq typ nil)
(cond
;; --- Startpunkt als VF-Familie erkannt: KEINE eigene Umlenkstation
;; noetig (Vorgaenger Vario-Kurve/Umlenk/Motor/Bogen bzw. laufende
;; VF-Fortsetzung). Strukturell IDENTISCH zu "Option 3: Kettenende
;; exakt am Zielpunkt" INNERHALB einer laufenden VF-Einheit
;; (vfl-vf-einheit): derselbe Stufe-1/Stufe-2-Diagnose-Baustein
;; (vfl-body-abschluss, Budget OHNE Umlenkstation -
;; *vfk-feste-horizontal-kettenende*) + Motorstation/GF2
;; (vfl-vf-ausgang-bauen) + ES-Element - KEIN Rueckfall auf eine
;; reine Winkeltabelle noetig (anders als bei "Neue Linie: Ab/Auf
;; VF" mit reduziertem Eingang): hier gibt es keinen GF1-Stumpf,
;; dessen Wegfall die 2-Unbekannten-Loesung stoeren wuerde - die
;; volle Freiheit (Winkel + GF2) bleibt erhalten, exakte Zielhoehe
;; ist also weiterhin moeglich.
((equal linie-ende-familie "VF")
(if kettenanfang
;; Kettenanfang auf einer bestehenden VF-Kette: Frame
;; konstruieren (Vario-Kurve endet flach, alle anderen VF-Typen
;; auf der 3-Grad-Basis) - der eigentliche Endpunkt-Pick erfolgt
;; gleich INNERHALB von vfl-body-abschluss.
(setq frame (make-frame-from-dir p-aktuell
(hz-winkel->xu (car erg)
(if (equal (cdr erg) "KURVE") 0.0 *vfk-gefaelle-winkel*)))))
;; ES-Element hier gewuenscht (+ falls ja: Winkel/Seite) - wie bei
;; "Option 3" (vfl-vf-einheit) VOR vfl-body-abschluss erfragt, weil
;; der tatsaechliche ES-Fussabdruck (ein-dx/ein-dz) die
;; Streckenzerlegung beeinflusst.
(princ (ssg-text "vfl-es-setzen-frage"))
(princ (ssg-text "vfl-ja"))
(princ (ssg-text "vfl-es-nein-zielpunkt"))
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-as-impl (list "vfl-es-setzen-frage")))
(setq antwort (vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-ja") (ssg-text "vfl-es-nein-zielpunkt")) 1
"vfl-es-setzen-frage"))
(setq es-gewuenscht (/= antwort "2"))
(if es-gewuenscht
(setq es-seite (vfl-frage-es-seite t))
(progn (setq save-eindx ein-dx save-eindz ein-dz) (setq ein-dx 0.0 ein-dz 0.0)))
(setq res3 (vfl-body-abschluss frame (car (frame->hz-winkel frame)) (car frame)))
(if (not es-gewuenscht) (setq ein-dx save-eindx ein-dz save-eindz))
(if (null res3)
(if dbg-an
(dbgmsg "GEOMETRIE FEHLGESCHLAGEN: Linie (VF-Familie, Kettenende) nicht baubar"))
(progn
(setq anzahl-vf (+ anzahl-vf (nth 1 res3)))
(setq frame (vfl-vf-ausgang-bauen (nth 0 res3) (nth 2 res3) (nth 3 res3)))
(if es-gewuenscht
(setq frame (vfl-insert-es-element "VF" frame (car (frame->hz-winkel frame)) 0.0
(caddr (car frame)) es-seite)))
(vfl-ziel-report frame)
(setq letzter-typ "VF" p-aktuell (car frame) fertig t)
(if dbg-an
(dbgmsg (strcat "GEOMETRIE ERFOLG: Linie (VF-Familie, Kettenende) gebaut, neue Position="
(dbg-tostring p-aktuell))))
)
)
)
;; --- Startpunkt als GF-Familie erkannt ODER nicht eindeutig ---
(t
;; Fahrtrichtung folgt dem vorherigen Element (Frame); nur das
;; erste Segment (frame=nil) definiert die Richtung frei.
(setq linie-mess (vfl-neue-linie-messen p-aktuell
(if frame (car (frame->hz-winkel frame)) nil)))
(if (null linie-mess) (progn (princ (ssg-text "vfl-abgebrochen")) (exit)))
(setq deltaL (car linie-mess) hz-neu (cadr linie-mess))
(if (< deltaL 1.0)
(princ (ssg-text "vfl-fehler-linie-zu-kurz"))
(progn
;; Kettenanfang: AS-Element (falls gewuenscht) SOFORT einfuegen
;; (immer flach, typ-unabhaengig - siehe vfl-insert-as-element;
;; welcher Segmenttyp folgt, steht hier noch nicht fest), reale
;; Restlaenge aus dem tatsaechlichen KS_AUS nachrechnen (siehe
;; vfl-kettenanfang-baustein).
(if kettenanfang
(progn
(setq erg (vfl-kettenanfang-baustein p-aktuell hz-neu deltaL as-seite as-vorhanden))
(setq frame (nth 0 erg) deltaL (nth 1 erg) p-aktuell (car frame))
)
)
;; Nach dem AS-Einfuegen kann die reale Restlaenge (aus dem
;; tatsaechlichen KS_AUS neu gemessen) kleiner als der urspruenglich
;; gepickte Rohwert sein - bei einem knapp gepickten Punkt sogar
;; NEGATIV. Ohne diese zweite Pruefung wuerde die Kurzsegment-
;; Automatik unten (< 1000mm) mit negativem deltaL trotzdem ein
;; "erfolgreiches" GF-Segment bauen (entartete/unsichtbare Strecke,
;; das naechste Element - z.B. ein GF-Bogen - erscheint dann direkt
;; am AS-Element, obwohl der Nutzer davor noch eine Linie wollte).
(if (< deltaL 1.0)
(princ (ssg-text "vfl-fehler-linie-zu-kurz"))
(progn
;; Segment-Typ bestimmen. Kurzsegment (deltaL < 1000 mm): KEINE
;; Hoehenabfrage - automatisch 3-Grad-Gefaellestrecke. Grund: ein VF
;; braucht >= 1000 mm deltaL (Umlenk- + Motorstation = 500+500 mm),
;; und eine GF ist mindestens 3 Grad geneigt. Die Endhoehe ergibt
;; sich damit fest aus deltaH = deltaL*tan(3 Grad).
;; Im Kettenende-Modus (Option 4) wird IMMER nach der Zielhoehe
;; gefragt (Kurzsegment-Automatik hier ueberspringen).
(if (and (< deltaL *vfk-vf-mindestlaenge*) (not linie-ende-modus))
(progn
(setq typ "GF" winkel *vfk-gefaelle-winkel* richtung "Ab" L_GF nil L_VF nil)
(setq deltaH (* deltaL (/ (sin (* *vfk-gefaelle-winkel* (/ pi 180.0)))
(cos (* *vfk-gefaelle-winkel* (/ pi 180.0))))))
(setq hoehe-neu (- (caddr p-aktuell) deltaH))
(princ (ssg-textf "vfl-info-kurzes-segment"
(list (rtos deltaL 2 0) (rtos deltaH 2 1))))
)
(progn
(setq hoehe-vorschlaege (vfl-segment-hoehe-vorschlaege (caddr p-aktuell) deltaL))
(setq hoehe-ab (nth 0 hoehe-vorschlaege) hoehe-auf (nth 1 hoehe-vorschlaege))
(setq hoehe-fallback (if hoehe-ab hoehe-ab (caddr p-aktuell)))
(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 p-aktuell)))))
(setq hoehe-neu
(vfl-in-real
(if (and hoehe-ab hoehe-auf)
(ssg-textf "vfl-prompt-hoehe-linienendpunkt-2"
(list (rtos hoehe-ab 2 1) (rtos hoehe-auf 2 1)))
(ssg-textf "vfl-prompt-hoehe-linienendpunkt" (list (rtos hoehe-fallback 2 1))))))
(if (null hoehe-neu) (setq hoehe-neu hoehe-fallback))
(setq deltaH (- hoehe-neu (caddr p-aktuell)))
(setq richtung (if (>= deltaH 0.0) "Auf" "Ab"))
(setq deltaH (abs deltaH))
(vfl-echo-endpunkt-hoehe p-aktuell deltaL hz-neu hoehe-neu deltaH richtung)
;; Kettenende-Modus (Option 4): Der abgefragte Endpunkt (XY+Z)
;; ist das exakte Ende der Kette NACH Separator + ES-Element.
;; Deren Footprint (Separator 300 mm bei ~3 Grad + ES-Element
;; ein-dx/ein-dz) muss vom baubaren GF/VF-Segment reserviert
;; (abgezogen) werden, damit das ES-Element genau am Zielpunkt
;; endet. Naeherung: Separator-Neigung = 3 Grad (Auslauf).
(if linie-ende-modus
(progn
(princ (ssg-text "vfl-gf-laenge-modus-header"))
(princ (ssg-text "vfl-gf-laenge-modus-opt-endpunkt"))
(princ (ssg-text "vfl-gf-laenge-modus-opt-hoehe"))
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-gf-steigend-untermodus-impl nil))
(setq linie-ende-untermodus
(vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-gf-laenge-modus-opt-endpunkt")
(ssg-text "vfl-gf-laenge-modus-opt-hoehe")) 1
"vfl-gf-laenge-modus-header"))
(if (= linie-ende-untermodus "2")
;; Zielhoehe fest, Winkel fix *vfk-gefaelle-winkel*
;; -> Laenge wird daraus berechnet (ersetzt die
;; oben gemessene/reservierte deltaL).
(progn
(setq winkel *vfk-gefaelle-winkel*)
(setq deltaL
(/ deltaH (/ (sin (* winkel (/ pi 180.0))) (cos (* winkel (/ pi 180.0))))))
(if (< deltaL 1.0)
(setq typ nil)
(setq typ "GF" L_GF nil L_VF nil)))
;; Endpunkt (deltaL) fest, Winkel aus deltaL +
;; Zielhoehe berechnen.
(progn
(setq winkel (* (atan (/ deltaH deltaL)) (/ 180.0 pi)))
(if (> winkel *vfk-gefaelle-winkel*)
(setq typ nil)
(setq typ "GF" L_GF nil L_VF nil)))
)
(setq rad3 (* (float (ssg-cfg-or "vario" "gefaelle_winkel" 3))
(/ pi 180.0)))
(setq deltaL (max 1.0 (- deltaL (* *vfk-separator-laenge* (cos rad3))
(abs (if ein-dx ein-dx 0.0)))))
(setq deltaH (max 0.0 (- deltaH (* *vfk-separator-laenge* (sin rad3))
(abs (if ein-dz ein-dz 0.0)))))
(princ (ssg-textf "vfl-info-kettenende-footprint"
(list (rtos deltaL 2 0) (rtos deltaH 2 0))))
)
)
)
;; --- Nicht eindeutig zuordenbar: bisherige Automatik ---
(t
(setq entscheidung (vfl-segment-entscheidung deltaL deltaH richtung))
(setq typ (nth 0 entscheidung) winkel (nth 1 entscheidung)
L_GF (nth 2 entscheidung) L_VF (nth 3 entscheidung)))
)
)
)
(if (equal linie-ende-familie "GF")
(progn
;; --- Startpunkt als GF-Familie erkannt ---
;; Dieselbe Endpunkt-/Zielhoehe-Wahl wie "Neue
;; Linie: GF" (Zweig A/B) statt der generischen
;; Automatik - eine reine Gefaellestrecke kann
;; nicht steigen. Stufe-2-Diagnosevariablen
;; zuruecksetzen: dieser Zweig ruft
;; vfl-vf-entscheidung NICHT auf, ein evtl. noch
;; von einem frueheren Versuch gesetzter Text/
;; Vorschlag darf bei einem hier fehlschlagenden
;; GF-Segment nicht faelschlich mit angezeigt
;; werden (siehe gemeinsamer "typ=nil"-
;; Meldungsblock unten).
(setq *vfl-stufe2-diagnose-text* nil)
(setq *vfl-stufe2-minl-vorschlag* nil *vfl-stufe2-minh-vorschlag* nil)
(if (= richtung "Auf")
(setq typ nil)
(progn
(princ (ssg-text "vfl-gf-laenge-modus-header"))
(princ (ssg-text "vfl-gf-laenge-modus-opt-endpunkt"))
(princ (ssg-text "vfl-gf-laenge-modus-opt-hoehe"))
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-gf-steigend-untermodus-impl nil))
(setq linie-ende-untermodus
(vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-gf-laenge-modus-opt-endpunkt")
(ssg-text "vfl-gf-laenge-modus-opt-hoehe")) 1
"vfl-gf-laenge-modus-header"))
(if (= linie-ende-untermodus "2")
(progn
(setq winkel *vfk-gefaelle-winkel*)
(setq deltaL
(/ deltaH (/ (sin (* winkel (/ pi 180.0))) (cos (* winkel (/ pi 180.0))))))
(if (< deltaL 1.0)
(setq typ nil)
(setq typ "GF" L_GF nil L_VF nil)))
(progn
(setq winkel (* (atan (/ deltaH deltaL)) (/ 180.0 pi)))
(if (> winkel *vfk-gefaelle-winkel*)
(setq typ nil)
(setq typ "GF" L_GF nil L_VF nil)))
)
)
)
)
;; --- Nicht eindeutig zuordenbar: bisherige Automatik ---
(progn
(setq entscheidung (vfl-segment-entscheidung deltaL deltaH richtung))
(setq typ (nth 0 entscheidung) winkel (nth 1 entscheidung)
L_GF (nth 2 entscheidung) L_VF (nth 3 entscheidung)))
)
)
)
(if (null typ)
(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)
" richtung=" richtung ")"))))
(progn
(if (= typ "GF")
(progn
;; --- reine Gefaellestrecke ---
(if dbg-an
(dbgmsg (strcat "GEOMETRIE: vfl-insert-gf-segment (deltaL=" (rtos deltaL 2 0)
" hz=" (rtos hz-neu 2 1) " winkel=" (rtos (float winkel) 2 1) ")")))
(setq frame (vfl-insert-gf-segment (car frame) hz-neu deltaL winkel))
(setq anzahl-gf (1+ anzahl-gf))
;; GF-Segment erfassen (Schraeglaenge = deltaL/cos(winkel))
(vfl-acc-gf-seg (/ deltaL (cos (* (float winkel) (/ pi 180.0)))) winkel)
(setq letzter-typ "GF")
(setq p-aktuell (car frame))
(if dbg-an
(dbgmsg (strcat "GEOMETRIE ERFOLG: GF-Segment gebaut, neue Position="
(dbg-tostring p-aktuell))))
;; Kettenende-Modus (Option 4): ohne Frage direkt ES setzen.
;; Sonst nachfragen, ob die Kette hier endet.
(if linie-ende-modus
(setq antwort "1")
(setq antwort (vfl-frage-ist-kettenende))
)
(cond
((= antwort "1")
(setq es-seite (vfl-frage-es-seite nil))
(setq frame (vfl-insert-es-element "GF" frame hz-neu winkel
(caddr (car frame)) es-seite))
(setq fertig t))
((= antwort "2") (setq fertig t))
)
)
(progn
;; --- VarioFoerderer-Einheit (Umlenk..Motor, mehrsegmentig) ---
;; linie-ende-modus=T -> direkt Kettenende (Separator + ES).
(if dbg-an
(dbgmsg (strcat "GEOMETRIE: vfl-vf-einheit-abschluss (deltaL=" (rtos deltaL 2 0)
" deltaH=" (rtos deltaH 2 0) " richtung=" richtung
" winkel=" (rtos (float winkel) 2 1)
" L_GF=" (rtos L_GF 2 0) " L_VF=" (rtos L_VF 2 0)
" linie-ende-modus=" (if linie-ende-modus "T" "nil") ")")))
(setq vf-einheit-res
(vfl-vf-einheit-abschluss frame hz-neu richtung winkel L_GF L_VF
linie-ende-modus nil nil))
(setq frame (nth 0 vf-einheit-res))
(setq anzahl-vf (+ anzahl-vf (nth 1 vf-einheit-res)))
(if (nth 2 vf-einheit-res) (setq fertig t))
(if (nth 3 vf-einheit-res) (setq es-seite (nth 3 vf-einheit-res)))
(setq letzter-typ "VF")
(setq p-aktuell (car frame))
(if dbg-an
(dbgmsg (strcat "GEOMETRIE ERFOLG: VF-Einheit gebaut, neue Position="
(dbg-tostring p-aktuell))))
)
)
)
)
)
)
(if (null typ)
(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)
" richtung=" richtung ")"))))
(progn
(if (= typ "GF")
(progn
;; --- reine Gefaellestrecke ---
(if dbg-an
(dbgmsg (strcat "GEOMETRIE: vfl-insert-gf-segment (deltaL=" (rtos deltaL 2 0)
" hz=" (rtos hz-neu 2 1) " winkel=" (rtos (float winkel) 2 1) ")")))
(setq frame (vfl-insert-gf-segment (car frame) hz-neu deltaL winkel))
(setq anzahl-gf (1+ anzahl-gf))
;; GF-Segment erfassen (Schraeglaenge = deltaL/cos(winkel))
(vfl-acc-gf-seg (/ deltaL (cos (* (float winkel) (/ pi 180.0)))) winkel)
(setq letzter-typ "GF")
(setq p-aktuell (car frame))
(if dbg-an
(dbgmsg (strcat "GEOMETRIE ERFOLG: GF-Segment gebaut, neue Position="
(dbg-tostring p-aktuell))))
;; Kettenende-Modus (Option 4): ohne Frage direkt ES setzen.
;; Sonst nachfragen, ob die Kette hier endet.
(if linie-ende-modus
(setq antwort "1")
(setq antwort (vfl-frage-ist-kettenende))
)
(cond
((= antwort "1")
(setq es-seite (vfl-frage-es-seite nil))
(setq frame (vfl-insert-es-element "GF" frame hz-neu winkel
(caddr (car frame)) es-seite))
(setq fertig t))
((= antwort "2") (setq fertig t))
)
)
(progn
;; --- VarioFoerderer-Einheit (Umlenk..Motor, mehrsegmentig) ---
;; linie-ende-modus=T -> direkt Kettenende (Separator + ES).
(if dbg-an
(dbgmsg (strcat "GEOMETRIE: vfl-vf-einheit-abschluss (deltaL=" (rtos deltaL 2 0)
" deltaH=" (rtos deltaH 2 0) " richtung=" richtung
" winkel=" (rtos (float winkel) 2 1)
" L_GF=" (rtos L_GF 2 0) " L_VF=" (rtos L_VF 2 0)
" linie-ende-modus=" (if linie-ende-modus "T" "nil") ")")))
(setq vf-einheit-res
(vfl-vf-einheit-abschluss frame hz-neu richtung winkel L_GF L_VF
linie-ende-modus nil nil))
(setq frame (nth 0 vf-einheit-res))
(setq anzahl-vf (+ anzahl-vf (nth 1 vf-einheit-res)))
(if (nth 2 vf-einheit-res) (setq fertig t))
(if (nth 3 vf-einheit-res) (setq es-seite (nth 3 vf-einheit-res)))
(setq letzter-typ "VF")
(setq p-aktuell (car frame))
(if dbg-an
(dbgmsg (strcat "GEOMETRIE ERFOLG: VF-Einheit gebaut, neue Position="
(dbg-tostring p-aktuell))))
)
)
)
)
)
)
)
)
)
)
)