VF-Linienzug Modus 2 (Ziel-Hoehe) fertig , AS/ES 30/90 Grad bei GF und VF waehlbar.

Lisp/Gefaellestrecke.lsp

@@ -1001,6 +1001,7 @@
                               ss n i j obj obj-liste kette segmente seg
                               startpunkt endpunkt-ref deltaH grade antwort idx
                               as-seite es-seite as-block es-block
+                              gf-as-winkel gf-es-winkel
                               entry-hz exit-hz
                               first-idx last-idx neu-l
                               aktuell-frame nach-aus-pt
@@ -1068,22 +1069,27 @@
   (setq entry-hz (cadr (car segmente)))
   (setq exit-hz  (gf-exit-hz segmente))
 
-  ;; Seite fuer AUS-Element (vor Winkelberechnung, da Laengenanpassung davon abhaengt)
+  ;; AUS-Element: 30/90 (vor Seite), dann Seite (vor Winkelberechnung, da die
-  (princ "\n\nAUS-Element (AS_Element_90_*) - Seite waehlen:")
+  ;; Laengenanpassung von der AS/ES-Masse abhaengt). Masse fuer Variante setzen.
+  (setq gf-as-winkel (vf-frage-element-winkel "AUS-Element"))
+  (princ "\n\nAUS-Element (AS_Element_*) - Seite waehlen:")
   (princ "\n  1 - Links")
   (princ "\n  2 - Rechts")
   (setq antwort (getstring "\nIhre Wahl (1/2) [1]: "))
   (setq as-seite (if (= antwort "2") "rechts" "links"))
+  (vf-set-as-masse gf-as-winkel as-seite)
 
-  ;; Seite fuer EIN-Element
+  ;; EIN-Element: 30/90 + Seite
-  (princ "\n\nEIN-Element (ES_Element_90_*) - Seite waehlen:")
+  (setq gf-es-winkel (vf-frage-element-winkel "EIN-Element"))
+  (princ "\n\nEIN-Element (ES_Element_*) - Seite waehlen:")
   (princ "\n  1 - Links")
   (princ "\n  2 - Rechts")
   (setq antwort (getstring "\nIhre Wahl (1/2) [1]: "))
   (setq es-seite (if (= antwort "2") "rechts" "links"))
+  (vf-set-es-masse gf-es-winkel es-seite)
 
-  (setq as-block (strcat "AS_Element_90_" as-seite))
+  (setq as-block (strcat "AS_Element_" gf-as-winkel "_" as-seite))
-  (setq es-block (strcat "ES_Element_90_" es-seite))
+  (setq es-block (strcat "ES_Element_" gf-es-winkel "_" es-seite))
 
   ;; Segmentlaengen anpassen.
   ;; Die gezeichneten Linien enthalten die Laengen von AUS-/EIN-Element UND Separatoren.
@@ -1175,8 +1181,9 @@
       (while (and (< iter 4) (> (abs (- grade grade-prev)) 0.001))
         (setq grade-prev grade)
         (setq rad-v-korr (* grade (/ pi 180.0)))
-        ;; AS-Element: KS_EIN zeigt 90 Grad zur Fahrtrichtung
+        ;; AS-Element: gemessener Ebenen-Schwenk -> KS_EIN so, dass KS_AUS entlang hz
-        (setq ein-hz-as-k (if (= as-seite "rechts") (+ entry-hz 90.0) (- entry-hz 90.0)))
+        (setq ein-hz-as-k (- entry-hz
+                             (vf-element-plan-turn (strcat "AS_Element_" gf-as-winkel "_" as-seite))))
         (setq rad-h-as-k  (* (float ein-hz-as-k) (/ pi 180.0)))
         (setq xu-as-meas (list (* (cos rad-h-as-k)(cos rad-v-korr))
                                (* (sin rad-h-as-k)(cos rad-v-korr))
@@ -1236,11 +1243,10 @@
 
       ;; AUS-Element: KS_EIN so ausrichten, dass KS_AUS in Fahrtrichtung entry-hz zeigt.
       ;; Beweis: KS_AUS.xu = -yu(target-frame). Fuer KS_AUS||entry-hz gilt:
-      ;;   rechts (Rechtskurve): KS_EIN = entry-hz + 90deg
+      ;; Gemessener Ebenen-Schwenk des AS-Blocks -> KS_EIN so drehen, dass KS_AUS
-      ;;   links  (Linkskurve):  KS_EIN = entry-hz - 90deg
+      ;; entlang der Fahrtrichtung hz zeigt (ein-hz = hz - plan-turn).
-      (setq ein-hz-as (if (= as-seite "rechts")
+      (setq ein-hz-as (- entry-hz
-                        (+ entry-hz 90.0)
+                         (vf-element-plan-turn (strcat "AS_Element_" gf-as-winkel "_" as-seite))))
-                        (- entry-hz 90.0)))
       (setq rad-h-as (* (float ein-hz-as) (/ pi 180.0)))
       (setq rad-v-as (* (float grade)     (/ pi 180.0)))
       (setq xu-entry (list (* (cos rad-h-as)(cos rad-v-as))
@@ -1530,15 +1536,18 @@
 
 ;; deltaL-total: gesamte Horizontaldistanz (fuer DELTA_L-Attribut)
 ;; hz: Fahrtrichtung in Grad (0=Ost, 90=Nord, 180=West, 270=Sued)
-(defun gefaellestrecke-einfuegen (L_stau winkel startpunkt as-seite es-seite hz deltaL-total /
+(defun gefaellestrecke-einfuegen (L_stau winkel startpunkt as-seite es-seite hz deltaL-total
+                                   as-winkel es-winkel /
                                    as-block es-block endpunkt
                                    gf-nummer last-ent rad-hz rad-v xu-incl
                                    ein-hz rad-ein xu-ein
                                    startframe aktuell-frame
                                    stau-endpunkt sep-endpunkt sep-frame
                                    gf-deltaH L-gf-str nach-aus-pt gf-insert)
-  (setq as-block (strcat "AS_Element_90_" as-seite))
+  (if (null as-winkel) (setq as-winkel "90"))
-  (setq es-block (strcat "ES_Element_90_" es-seite))
+  (if (null es-winkel) (setq es-winkel "90"))
+  (setq as-block (strcat "AS_Element_" as-winkel "_" as-seite))
+  (setq es-block (strcat "ES_Element_" es-winkel "_" es-seite))
   (if (not *lib-initialized*) (gf-init-bibliothek))
 
   ;; GF-Nummer und Entity-Grenze vor erster Einfuegung
@@ -1552,11 +1561,9 @@
                       (* (sin rad-hz)(cos rad-v))
                       (- (sin rad-v))))
 
-  ;; KS_EIN-Richtung fuer AS-Element: so dass KS_AUS in Fahrtrichtung hz zeigt.
+  ;; KS_EIN-Richtung fuer AS-Element: gemessener Ebenen-Schwenk des Blocks, so
-  ;; Beweis: KS_AUS.xu = -yu (target-frame), yu = links-senkrecht zu xu.
+  ;; dass KS_AUS in Fahrtrichtung hz zeigt (ein-hz = hz - plan-turn).
-  ;;   rechts (Rechtskurve): KS_AUS = KS_EIN - 90deg  =>  KS_EIN = hz + 90deg
+  (setq ein-hz (- hz (vf-element-plan-turn (strcat "AS_Element_" as-winkel "_" as-seite))))
-  ;;   links  (Linkskurve):  KS_AUS = KS_EIN + 90deg  =>  KS_EIN = hz - 90deg
-  (setq ein-hz (if (= as-seite "rechts") (+ hz 90.0) (- hz 90.0)))
   (setq rad-ein (* (float ein-hz) (/ pi 180.0)))
   (setq xu-ein (list (* (cos rad-ein)(cos rad-v))
                      (* (sin rad-ein)(cos rad-v))
@@ -1632,7 +1639,7 @@
 ;; ============================================================
 
 (defun c:GEFAELLESTRECKE ( / antwort eingabe-modus deltaL winkel rad L_stau sep-x
-                             as-seite es-seite
+                             as-seite es-seite gf-as-winkel gf-es-winkel
                              line-points startpunkt endpunkt differenz
                              deltaX deltaY startpunkt-fuer-einfuegen hz-winkel)
 
@@ -1744,21 +1751,25 @@
        )
      )
 
-     ;; Seite AUS-Element waehlen
+     ;; AUS-Element: 30/90 (vor Seite) + Seite, dann Masse fuer Variante setzen
-     (princ "\n\nAUS-Element (AS_Element_90_*) - Seite waehlen:")
+     (setq gf-as-winkel (vf-frage-element-winkel "AUS-Element"))
+     (princ "\n\nAUS-Element (AS_Element_*) - Seite waehlen:")
      (princ "\n  1 - Links")
      (princ "\n  2 - Rechts")
      (setq antwort (getstring "\nIhre Wahl (1/2) [1]: "))
      (setq as-seite (if (= antwort "2") "rechts" "links"))
+     (vf-set-as-masse gf-as-winkel as-seite)
 
-     ;; Seite EIN-Element waehlen
+     ;; EIN-Element: 30/90 + Seite
-     (princ "\n\nEIN-Element (ES_Element_90_*) - Seite waehlen:")
+     (setq gf-es-winkel (vf-frage-element-winkel "EIN-Element"))
+     (princ "\n\nEIN-Element (ES_Element_*) - Seite waehlen:")
      (princ "\n  1 - Links")
      (princ "\n  2 - Rechts")
      (setq antwort (getstring "\nIhre Wahl (1/2) [1]: "))
      (setq es-seite (if (= antwort "2") "rechts" "links"))
+     (vf-set-es-masse gf-es-winkel es-seite)
 
-     ;; Laengenberechnung
+     ;; Laengenberechnung (aus-dx/ein-dx jetzt fuer die gewaehlte Variante)
      ;; deltaL = aus_dx + L_stau*cos(rad) + sep*cos(rad) + ein_dx
      (setq sep-x (* (ssg-cfg-or "gefaelle" "separator_breite" 300.0) (cos rad)))
      (setq L_stau (/ (- deltaL aus-dx ein-dx sep-x) (cos rad)))
@@ -1785,7 +1796,7 @@
      ;; Bestaetigung
      (setq antwort (getstring "\nEinfuegen? (1=Ja / 2=Nein) [1]: "))
      (if (not (= antwort "2"))
-       (gefaellestrecke-einfuegen L_stau (fix winkel) startpunkt-fuer-einfuegen as-seite es-seite hz-winkel deltaL)
+       (gefaellestrecke-einfuegen L_stau (fix winkel) startpunkt-fuer-einfuegen as-seite es-seite hz-winkel deltaL gf-as-winkel gf-es-winkel)
        (princ "\nAbgebrochen.")
      )
     )

Lisp/vf_core.lsp

@@ -688,6 +688,84 @@
                               " Z=" (rtos (caddr P-out) 2 2)))
   (list P-out xu-out yu-out zu-out))
 
+;; ============================================================
+;; AS-/ES-Element: Winkel-Variante (30 / 90 Grad)
+;; ============================================================
+;; Masse (KS_EIN->KS_AUS als (dx dy dz)) eines Elements aus dem Block ziehen.
+(defun vf-element-masse (blockname / temp-obj ks-data ke ka)
+  (ensure-block-loaded blockname)
+  (if (not (tblsearch "BLOCK" blockname))
+    nil
+    (progn
+      (setq temp-obj (vla-InsertBlock modelspace
+                       (vlax-3D-point '(0 0 0)) blockname 1.0 1.0 1.0 0))
+      (setq ks-data (extract-ks-from-block temp-obj))
+      (if (not (vlax-erased-p temp-obj)) (vla-Delete temp-obj))
+      (setq ke (cadr (assoc "KS_EIN" ks-data))  ka (cadr (assoc "KS_AUS" ks-data)))
+      (if (and ke ka)
+        (list (- (caar ka) (caar ke))
+              (- (cadr (car ka)) (cadr (car ke)))
+              (- (caddr (car ka)) (caddr (car ke))))
+        nil))))
+
+;; Ebenen-Schwenk (Grad) eines Elements: Winkel von KS_EIN.xu nach KS_AUS.xu in
+;; der XY-Ebene, direkt aus dem Block gemessen (unabhaengig davon, ob 30/90-Turn
+;; oder gerade). Wird genutzt, um KS_EIN so zu drehen, dass KS_AUS entlang hz
+;; zeigt:  ein-hz = hz - plan-turn. Fallback 90 (Vorgabe fuer 90-Grad-Element).
+(defun vf-element-plan-turn (blockname / temp-obj ks-data fe fa)
+  (ensure-block-loaded blockname)
+  (if (not (tblsearch "BLOCK" blockname))
+    90.0
+    (progn
+      (setq temp-obj (vla-InsertBlock modelspace
+                       (vlax-3D-point '(0 0 0)) blockname 1.0 1.0 1.0 0))
+      (setq ks-data (extract-ks-from-block temp-obj))
+      (if (not (vlax-erased-p temp-obj)) (vla-Delete temp-obj))
+      (setq fe (ks-frame-extract (cadr (assoc "KS_EIN" ks-data))))
+      (setq fa (ks-frame-extract (cadr (assoc "KS_AUS" ks-data))))
+      (if (and fe fa)
+        (- (* (atan (cadr (cadr fa)) (car (cadr fa))) (/ 180.0 pi))
+           (* (atan (cadr (cadr fe)) (car (cadr fe))) (/ 180.0 pi)))
+        90.0))))
+
+;; KS-Info eines Elements (im Block, Einbau-Rotation 0):
+;;   Rueckgabe (ein-ang aus-ang vx vy)
+;;     ein-ang / aus-ang : Ebenen-Winkel (Grad) von KS_EIN.xu bzw. KS_AUS.xu
+;;     vx / vy           : KS_AUS.origin - KS_EIN.origin (Block-XY)
+;; Damit laesst sich die KS_AUS-Lage + Achsrichtung analytisch vorausberechnen.
+(defun vf-element-ks-info (blockname / temp-obj ks-data fe fa)
+  (ensure-block-loaded blockname)
+  (if (not (tblsearch "BLOCK" blockname))
+    nil
+    (progn
+      (setq temp-obj (vla-InsertBlock modelspace
+                       (vlax-3D-point '(0 0 0)) blockname 1.0 1.0 1.0 0))
+      (setq ks-data (extract-ks-from-block temp-obj))
+      (if (not (vlax-erased-p temp-obj)) (vla-Delete temp-obj))
+      (setq fe (ks-frame-extract (cadr (assoc "KS_EIN" ks-data))))
+      (setq fa (ks-frame-extract (cadr (assoc "KS_AUS" ks-data))))
+      (if (and fe fa)
+        (list (* (atan (cadr (cadr fe)) (car (cadr fe))) (/ 180.0 pi))
+              (* (atan (cadr (cadr fa)) (car (cadr fa))) (/ 180.0 pi))
+              (- (car  (car fa)) (car  (car fe)))
+              (- (cadr (car fa)) (cadr (car fe))))
+        nil))))
+
+;; 30/90-Wahl fuer ein AS/ES-Element. Rueckgabe: "30" oder "90" (Vorgabe 90).
+(defun vf-frage-element-winkel (label)
+  (princ (strcat "\n\n" label " - Winkel:  1 - 90 Grad   2 - 30 Grad"))
+  (if (= (getstring "\nIhre Wahl (1/2) [1]: ") "2") "30" "90"))
+
+;; AS-/ES-Masse-Globals (aus-dx/dy/dz bzw. ein-dx/dy/dz) fuer die gewaehlte
+;; Winkel-/Seiten-Variante neu setzen (fuer berechne-alle-winkel, GF-Winkel,
+;; Trimmungen). Ohne gueltigen Block bleiben die Werte unveraendert.
+(defun vf-set-as-masse (winkel seite / m)
+  (setq m (vf-element-masse (strcat "AS_Element_" winkel "_" seite)))
+  (if m (setq aus-dx (car m)  aus-dy (cadr m)  aus-dz (caddr m))))
+(defun vf-set-es-masse (winkel seite / m)
+  (setq m (vf-element-masse (strcat "ES_Element_" winkel "_" seite)))
+  (if m (setq ein-dx (car m)  ein-dy (cadr m)  ein-dz (caddr m))))
+
 ;; hz: horizontale Fahrtrichtung in Grad (0=Ost/+X, 90=Nord/+Y, ...),
 ;; winkel: vertikale Neigung in Grad. Rotation = Rz(hz)*Ry(winkel).
 (defun insert-inclined-scaled-block (blockname startpunkt laenge winkel hz /
@@ -1172,7 +1250,17 @@
   ;; vf_linienzug.lsp. Dispatcht hier direkt und beendet den Standard-Ablauf.
   (if (= anlage-typ "linienzug")
     (progn
-      (vf-linienzug-modus)
+      (princ "\n\nLinienzug-Modus waehlen:")
+      (princ "\n  1 - Manuelle Eingabe (Punkte klicken)")
+      (princ "\n  2 - 3D-Objekte + Ziel-Hoehe (Randwert-Solver, fertig)")
+      (princ "\n  3 - 3D-Objekte stueckweise (Vorwaerts-Nachbau, in Arbeit)")
+      (setq wahl (getint "\nIhre Wahl (1/2/3) [1]: "))
+      ;; Konsolen-Nummer -> interne Funktion:
+      ;;   2 = fertiger Ziel-Hoehe-Modus (intern vf-linienzug-modus3)
+      ;;   3 = alter Vorwaerts-Nachbau  (intern vf-linienzug-modus2, wird umgebaut)
+      (cond ((= wahl 2) (vf-linienzug-modus3))
+            ((= wahl 3) (vf-linienzug-modus2))
+            (t          (vf-linienzug-modus)))
       (exit)
     )
   )