Merge branch 'master' of https://gitea.schoenenberger.de/Schoenenberger_Systeme_GmbH/dxfmakros

Lisp/Gefaellestrecke.lsp

@@ -992,6 +992,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
@@ -1059,22 +1060,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
+  ;; Laengenanpassung von der AS/ES-Masse abhaengt). Masse fuer Variante setzen.
+  (setq gf-as-winkel (vf-frage-element-winkel "vf-winkel-aus-header"))
   (princ (ssg-text "gf-seite-aus-header"))
   (princ (ssg-text "gf-seite-links"))
   (princ (ssg-text "gf-seite-rechts"))
   (setq antwort (getstring (ssg-text "prompt-wahl-1-2")))
   (setq as-seite (if (= antwort "2") "rechts" "links"))
+  (vf-set-as-masse gf-as-winkel as-seite)
 
-  ;; Seite fuer EIN-Element
+  ;; EIN-Element: 30/90 + Seite
+  (setq gf-es-winkel (vf-frage-element-winkel "vf-winkel-ein-header"))
   (princ (ssg-text "gf-seite-ein-header"))
   (princ (ssg-text "gf-seite-links"))
   (princ (ssg-text "gf-seite-rechts"))
   (setq antwort (getstring (ssg-text "prompt-wahl-1-2")))
   (setq es-seite (if (= antwort "2") "rechts" "links"))
+  (vf-set-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.
@@ -1165,8 +1171,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))
@@ -1226,11 +1233,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))
@@ -1519,15 +1525,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
@@ -1541,11 +1550,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))
@@ -1618,7 +1625,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)
 
@@ -1729,21 +1736,25 @@
        )
      )
 
-     ;; Seite AUS-Element waehlen
+     ;; AUS-Element: 30/90 (vor Seite) + Seite, dann Masse fuer Variante setzen
+     (setq gf-as-winkel (vf-frage-element-winkel "vf-winkel-aus-header"))
      (princ (ssg-text "gf-seite-aus-header"))
      (princ (ssg-text "gf-seite-links"))
      (princ (ssg-text "gf-seite-rechts"))
      (setq antwort (getstring (ssg-text "prompt-wahl-1-2")))
      (setq as-seite (if (= antwort "2") "rechts" "links"))
+     (vf-set-as-masse gf-as-winkel as-seite)
 
-     ;; Seite EIN-Element waehlen
+     ;; EIN-Element: 30/90 + Seite
+     (setq gf-es-winkel (vf-frage-element-winkel "vf-winkel-ein-header"))
      (princ (ssg-text "gf-seite-ein-header"))
      (princ (ssg-text "gf-seite-links"))
      (princ (ssg-text "gf-seite-rechts"))
      (setq antwort (getstring (ssg-text "prompt-wahl-1-2")))
      (setq es-seite (if (= antwort "2") "rechts" "links"))
+     (vf-set-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)))
@@ -1768,7 +1779,7 @@
      ;; Bestaetigung
      (setq antwort (getstring (ssg-text "gf-prompt-einfuegen")))
      (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 (ssg-text "gf-status-abgebrochen"))
      )
     )

Lisp/KreiselInsert.lsp

@@ -73,11 +73,11 @@
 ;; Attribut-Definitionen: ((TAG DEFAULT) ...)
 (setq *kreisel-attrib-defs*
   '(("NAME"           "")
-    ("DREHRICHTUNG"  "UZS")
+    ("DREHRICHTUNG"     "UZS")
-    ("N_SEPARATOREN" "2")
+    ("ANZAHL_SEPARATOR" "2")
-    ("KREISELART"    "STANDARD")
+    ("KREISELART"       "STANDARD")
-    ("N_SCANNER"     "0")
+    ("ANZAHL_SCANNER"   "0")
-    ("N_RAMPEN"      "0")
+    ("N_RAMPEN"         "0")
     ("DREHUNG"       "0")
     ("ABSTAND"       "2300")
     ("NUMMER"        "0")

Lisp/count_sep_scan.lsp

@@ -0,0 +1,356 @@
+;;; ============================================================
+;;; count_sep_scan.lsp  -  Eigenstaendiges Zaehl-Werkzeug
+;;; ------------------------------------------------------------
+;;; Zaehlt die manuell platzierten Bloecke "Scanner" und
+;;; "Separator_SP" je ILS-Block (Kreisel / VarioFoerderer /
+;;; Gefaellestrecke) und schreibt die Anzahlen in die Attribute
+;;; des jeweiligen ILS-Blocks. Anschliessend QSAVE.
+;;;
+;;; Zuordnung eines Sensors zu einem ILS-Block:
+;;;   - Der geometrische Mittelpunkt (X/Y) des Sensors (Zentrum
+;;;     seiner eigenen Bounding-Box, unabhaengig vom $INSBASE)
+;;;     muss in der achsparallelen Bounding-Box des ILS-Blocks
+;;;     liegen (Z wird ignoriert).
+;;;   - Liegt der Punkt in mehreren Boxen (Ueberlappung), wird
+;;;     der ILS-Block mit dem naechstgelegenen Box-Zentrum gewaehlt.
+;;;   - Ein optionaler Toleranzrand (*senstol*) vergroessert die
+;;;     Box, damit Sensoren knapp am Rand noch erfasst werden.
+;;;
+;;; Aufruf:  ZAEHLE_SEP_SCAN
+;;; Laden:   per APPLOAD oder (load "count_sep_scan")
+;;; ============================================================
+
+(vl-load-com)
+
+;;; ------------------------------------------------------------
+;;; KONFIGURATION (bei Bedarf anpassen)
+;;; ------------------------------------------------------------
+
+;; Toleranzrand um die ILS-Block-Box in Zeichnungseinheiten (mm).
+;; 0.0 = exakte Box. Groesserer Wert = Sensoren knapp ausserhalb
+;; werden noch dem ILS-Block zugerechnet.
+(if (null *senstol*) (setq *senstol* 0.0))
+
+;; Blockname-Muster (wcmatch, Grossschreibung) fuer die manuell
+;; platzierten Sensoren.
+(setq *scanner-pattern*   "SCANNER,SCANNER_*")
+(setq *separator-pattern* "SEPARATOR_SP,SEPARATOR_SP_*")
+
+;; Blockname-Muster fuer die INTERN im ILS-Block (in der Kette)
+;; gezeichneten Separatoren. Diese bilden die Basis fuer
+;; ANZAHL_SEPARATOR und werden bei jedem Lauf frisch gezaehlt.
+(setq *intern-separator-pattern* "STAUSTRECKE_SEPARATOR_SP*")
+
+;;; ------------------------------------------------------------
+;;; ILS-Block-Erkennung und zugehoerige Attribut-Tags
+;;;   Alle ILS-Bloecke (Kreisel / VF / GF) verwenden einheitlich
+;;;   ANZAHL_SCANNER und ANZAHL_SEPARATOR.
+;;;   Rueckgabe: (scanner-tag  separator-tag)  oder nil
+;;; ------------------------------------------------------------
+(defun cs-carrier-tags (nm / up)
+  (setq up (strcase nm))
+  (if (or (wcmatch up "KREISEL_*")
+          (wcmatch up "VF_*")
+          (wcmatch up "GF_*"))
+    (list "ANZAHL_SCANNER" "ANZAHL_SEPARATOR")
+    nil
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Sensor-Erkennung
+;;;   Rueckgabe: 'scanner | 'separator | nil
+;;; ------------------------------------------------------------
+(defun cs-sensor-kind (nm / up)
+  (setq up (strcase nm))
+  (cond
+    ((wcmatch up *scanner-pattern*)   'scanner)
+    ((wcmatch up *separator-pattern*) 'separator)
+    (t nil)
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Punkt-Rueckgabe von vla-getboundingbox in eine Liste wandeln.
+;;;   BricsCAD liefert ein Safearray, AutoCAD ein Variant mit
+;;;   Safearray - beide Faelle werden hier abgedeckt.
+;;; ------------------------------------------------------------
+(defun cs-pt->list (v)
+  (cond
+    ((= (type v) 'variant)   (vlax-safearray->list (vlax-variant-value v)))
+    ((= (type v) 'safearray) (vlax-safearray->list v))
+    ((listp v)               v)
+    (t                       nil)
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Bounding-Box eines INSERT holen (WCS, achsparallel).
+;;;   Erzwingt vorher ein vla-update (Regen des Objekts), da
+;;;   vla-getboundingbox sonst auf nicht-regenerierten oder auf
+;;;   eingefrorenen Layern liegenden Bloecken scheitert.
+;;;   Rueckgabe: (minx miny maxx maxy)  oder nil bei Fehler.
+;;;   *cs-last-error* enthaelt bei Fehler den echten COM-Fehlertext.
+;;; ------------------------------------------------------------
+(defun cs-bbox (ent / obj res)
+  (setq *cs-last-error* nil)
+  (setq obj (vlax-ename->vla-object ent))
+  ;; Objekt regenerieren (Fehler ignorieren)
+  (vl-catch-all-apply 'vla-update (list obj))
+  (setq res
+    (vl-catch-all-apply
+      '(lambda ( / ll ur)
+         (vla-getboundingbox obj 'll 'ur)
+         (list (cs-pt->list ll) (cs-pt->list ur)))))
+  (if (vl-catch-all-error-p res)
+    (progn
+      (setq *cs-last-error* (vl-catch-all-error-message res))
+      nil)
+    (list (car  (car res)) (cadr (car res))    ;; minx miny
+          (car  (cadr res)) (cadr (cadr res))) ;; maxx maxy
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Referenzpunkt eines Sensors: geometrischer Mittelpunkt seiner
+;;; eigenen Bounding-Box (X/Y). Unabhaengig vom $INSBASE der
+;;; Sensor-DWG. Fallback auf den Einfuegepunkt, falls die Box
+;;; nicht ermittelbar ist.
+;;; ------------------------------------------------------------
+(defun cs-sensor-point (ent ed / bb)
+  (setq bb (cs-bbox ent))
+  (if bb
+    (list (/ (+ (nth 0 bb) (nth 2 bb)) 2.0)
+          (/ (+ (nth 1 bb) (nth 3 bb)) 2.0))
+    (cdr (assoc 10 ed))
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Liegt Punkt pt (X/Y) in ILS-Block-Record rec (mit Toleranz)?
+;;;   rec = (ename tagScan tagSep minx miny maxx maxy cx cy)
+;;; ------------------------------------------------------------
+(defun cs-in-box (pt rec / x y)
+  (setq x (car pt) y (cadr pt))
+  (and (>= x (- (nth 3 rec) *senstol*))
+       (<= x (+ (nth 5 rec) *senstol*))
+       (>= y (- (nth 4 rec) *senstol*))
+       (<= y (+ (nth 6 rec) *senstol*)))
+)
+
+;;; ------------------------------------------------------------
+;;; Sensor-Punkt einem ILS-Block zuordnen.
+;;;   Rueckgabe: ILS-Block-Record oder nil (keine Zuordnung).
+;;;   Bei mehreren Treffern: naechstes Box-Zentrum (X/Y).
+;;; ------------------------------------------------------------
+(defun cs-assign (pt carriers / matches best bestd d)
+  (setq matches nil)
+  (foreach rec carriers
+    (if (cs-in-box pt rec) (setq matches (cons rec matches))))
+  (cond
+    ((null matches) nil)
+    ((= (length matches) 1) (car matches))
+    (t
+      (setq best nil bestd nil)
+      (foreach rec matches
+        (setq d (distance (list (car pt) (cadr pt))
+                          (list (nth 7 rec) (nth 8 rec))))
+        (if (or (null bestd) (< d bestd))
+          (setq bestd d  best rec)))
+      best)
+  )
+)
+
+;;; ------------------------------------------------------------
+;;; Zaehler in einer Assoc-Liste (Schluessel = ename) erhoehen.
+;;; ------------------------------------------------------------
+(defun cs-bump (alist key / pair)
+  (setq pair (assoc key alist))
+  (if pair
+    (subst (cons key (1+ (cdr pair))) pair alist)
+    (cons (cons key 1) alist))
+)
+
+;;; ------------------------------------------------------------
+;;; Attributwert an einem INSERT setzen (Tag ohne Gross/Klein).
+;;;   Rueckgabe: T wenn Tag gefunden und gesetzt, sonst nil.
+;;; ------------------------------------------------------------
+(defun cs-set-att (ins tag val / e ed done ok)
+  (setq e (entnext ins) done nil ok nil)
+  (while (and e (not done))
+    (setq ed (entget e))
+    (cond
+      ((= (cdr (assoc 0 ed)) "ATTRIB")
+        (if (= (strcase (cdr (assoc 2 ed))) (strcase tag))
+          (progn
+            (entmod (subst (cons 1 val) (assoc 1 ed) ed))
+            (entupd e)
+            (setq ok t))))
+      ((= (cdr (assoc 0 ed)) "SEQEND") (setq done t))
+    )
+    (setq e (entnext e))
+  )
+  ok
+)
+
+;;; ------------------------------------------------------------
+;;; Zaehlt rekursiv, wie oft ein Block (Muster pat) in der
+;;; Definition des Blocks bname verwendet wird - inklusive
+;;; verschachtelter Unterbloecke. Damit wird die interne Anzahl
+;;; der Kette-Separatoren aus der Geometrie ermittelt.
+;;; ------------------------------------------------------------
+(defun cs-count-nested (bname pat / e ed nm n stop)
+  (setq n 0 stop nil)
+  (setq e (tblobjname "BLOCK" bname))
+  (if e
+    (progn
+      (setq e (entnext e))
+      (while (and e (not stop))
+        (setq ed (entget e))
+        (cond
+          ((= (cdr (assoc 0 ed)) "ENDBLK") (setq stop t))
+          ((= (cdr (assoc 0 ed)) "INSERT")
+            (setq nm (cdr (assoc 2 ed)))
+            (if (wcmatch (strcase nm) pat)
+              (setq n (1+ n))
+              (setq n (+ n (cs-count-nested nm pat)))))
+        )
+        (if (not stop) (setq e (entnext e)))
+      )
+    )
+  )
+  n
+)
+
+;;; ============================================================
+;;; HAUPTBEFEHL
+;;; ============================================================
+(defun c:ZAEHLE_SEP_SCAN ( / ss i ent ed nm tags bb cx cy
+                             carriers scanpts seppts kind pt
+                             scanCounts sepCounts
+                             rec en nm2 ns nsep internSep newS newP
+                             n-scan-unassigned n-sep-unassigned
+                             okS okP)
+  (setq carriers nil scanpts nil seppts nil)
+
+  ;; Vor der Extents-Berechnung einmal regenerieren, damit
+  ;; vla-getboundingbox verlaessliche Werte liefert.
+  (vl-catch-all-apply '(lambda () (command "_.REGEN")))
+
+  ;; --- 1. Alle INSERTs sammeln und klassifizieren ---
+  (setq ss (ssget "_X" '((0 . "INSERT"))))
+  (if (null ss)
+    (progn (princ "\n>>> Keine Bloecke in der Zeichnung gefunden.") (princ))
+    (progn
+      (setq i 0)
+      (while (< i (sslength ss))
+        (setq ent (ssname ss i))
+        (setq ed  (entget ent))
+        (setq nm  (cdr (assoc 2 ed)))
+        (setq tags (cs-carrier-tags nm))
+        (cond
+          ;; --- ILS-Block ---
+          (tags
+            (setq bb (cs-bbox ent))
+            (if bb
+              (progn
+                (setq cx (/ (+ (nth 0 bb) (nth 2 bb)) 2.0))
+                (setq cy (/ (+ (nth 1 bb) (nth 3 bb)) 2.0))
+                (setq carriers
+                  (cons (list ent (car tags) (cadr tags)
+                              (nth 0 bb) (nth 1 bb) (nth 2 bb) (nth 3 bb)
+                              cx cy)
+                        carriers)))
+              (princ (strcat "\n! Bounding-Box fehlgeschlagen fuer ILS-Block '" nm "'"
+                             (if *cs-last-error*
+                               (strcat " (" *cs-last-error* ")") "")))
+            )
+          )
+          ;; --- Sensor ---
+          (t
+            (setq kind (cs-sensor-kind nm))
+            (if kind
+              (progn
+                (setq pt (cs-sensor-point ent ed))
+                (if (eq kind 'scanner)
+                  (setq scanpts (cons pt scanpts))
+                  (setq seppts  (cons pt seppts)))))
+          )
+        )
+        (setq i (1+ i))
+      )
+
+      ;; --- 2. Sensoren den ILS-Bloecken zuordnen ---
+      (setq scanCounts nil sepCounts nil
+            n-scan-unassigned 0 n-sep-unassigned 0)
+
+      (foreach pt scanpts
+        (setq rec (cs-assign pt carriers))
+        (if rec
+          (setq scanCounts (cs-bump scanCounts (car rec)))
+          (setq n-scan-unassigned (1+ n-scan-unassigned))))
+
+      (foreach pt seppts
+        (setq rec (cs-assign pt carriers))
+        (if rec
+          (setq sepCounts (cs-bump sepCounts (car rec)))
+          (setq n-sep-unassigned (1+ n-sep-unassigned))))
+
+      ;; --- 3. Attribute setzen und Bericht ausgeben ---
+      (princ "\n============================================")
+      (princ "\n  Sensor-Zaehlung je ILS-Block")
+      (princ "\n============================================")
+      (if (null carriers)
+        (princ "\n  (Keine ILS-Bloecke KREISEL_/VF_/GF_ gefunden)")
+        (foreach rec carriers
+          (setq en   (car rec))
+          (setq nm2  (cdr (assoc 2 (entget en))))
+          (setq ns   (cond ((assoc en scanCounts) (cdr (assoc en scanCounts))) (t 0)))
+          (setq nsep (cond ((assoc en sepCounts)  (cdr (assoc en sepCounts)))  (t 0)))
+          ;; interne Kette-Separatoren frisch aus der Blockdefinition zaehlen
+          (setq internSep (cs-count-nested nm2 *intern-separator-pattern*))
+          ;; Scanner  = nur neu zugeordnete
+          ;; Separator = interne Kette-Separatoren + neu zugeordnete
+          (setq newS ns)
+          (setq newP (+ internSep nsep))
+          ;; gefundene Anzahlen melden
+          (princ (strcat "\n  " nm2
+                         ": Scanner(neu)=" (itoa ns)
+                         ", Separator intern=" (itoa internSep)
+                         " + manuell=" (itoa nsep)))
+          ;; Werte schreiben und Ergebnis bestaetigen
+          (setq okS (cs-set-att en (nth 1 rec) (itoa newS)))
+          (setq okP (cs-set-att en (nth 2 rec) (itoa newP)))
+          (if (and okS okP)
+            (princ (strcat "\n     -> geschrieben: "
+                           "ANZAHL_SCANNER=" (itoa newS)
+                           ", ANZAHL_SEPARATOR=" (itoa newP)))
+            (princ (strcat "\n     -> FEHLER beim Schreiben: "
+                           (if okS "" "ANZAHL_SCANNER fehlt  ")
+                           (if okP "" "ANZAHL_SEPARATOR fehlt"))))
+        )
+      )
+      (princ (strcat "\n--------------------------------------------"
+                     "\n  ILS-Bloecke gesamt: " (itoa (length carriers))
+                     "\n  Scanner gesamt:     " (itoa (length scanpts))
+                     " (nicht zugeordnet: " (itoa n-scan-unassigned) ")"
+                     "\n  Separator gesamt:   " (itoa (length seppts))
+                     " (nicht zugeordnet: " (itoa n-sep-unassigned) ")"))
+      (if (or (> n-scan-unassigned 0) (> n-sep-unassigned 0))
+        (princ (strcat "\n  Hinweis: Nicht zugeordnete Sensoren liegen"
+                       "\n  ausserhalb aller ILS-Block-Boxen. Ggf. *senstol*"
+                       "\n  erhoehen oder Platzierung pruefen.")))
+
+      ;; --- 4. Zeichnung speichern ---
+      (princ "\n--------------------------------------------")
+      (princ "\n  Speichere Zeichnung (QSAVE) ...")
+      (command "_.QSAVE")
+      (princ "\n>>> Fertig.")
+      (princ)
+    )
+  )
+  (princ)
+)
+
+(princ "\n>>> count_sep_scan.lsp geladen. Befehl: ZAEHLE_SEP_SCAN")
+(princ)

Lisp/vf_core.lsp

@@ -680,6 +680,88 @@
           (rtos (car P-out) 2 2) (rtos (cadr P-out) 2 2) (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).
+;; headerkey: i18n-Key fuer die Kopfzeile ("vf-winkel-aus-header" oder
+;; "vf-winkel-ein-header"). Rueckgabe: "30" oder "90" (Default 90).
+(defun vf-frage-element-winkel (headerkey)
+  (princ (ssg-text headerkey))
+  (princ (ssg-text "vf-winkel-90"))
+  (princ (ssg-text "vf-winkel-30"))
+  (if (= (getstring (ssg-text "prompt-wahl-1-2")) "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 /
@@ -1159,7 +1241,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)
     )
   )

lang/de_DE.json

@@ -11,6 +11,10 @@
     "vfl-sep-vor-frage": "\n\nZusaetzlichen Separator VOR dem horizontalen Stueck?",
     "vfl-sep-nach-frage": "\n\nZusaetzlichen Separator NACH dem horizontalen Stueck?",
     "vfl-sep-an-stelle-frage": "\n\nZusaetzlichen Separator an dieser Stelle einfuegen?",
+    "vf-winkel-aus-header": "\n\nAUS-Element (AS_Element) - Winkel waehlen:",
+    "vf-winkel-ein-header": "\n\nEIN-Element (ES_Element) - Winkel waehlen:",
+    "vf-winkel-90": "\n  1 - 90 Grad",
+    "vf-winkel-30": "\n  2 - 30 Grad",
     "vfl-gf-bogen-winkel-header": "\n\nGF-Bogen - Winkel waehlen:",
     "vfl-gf-bogen-seite-header": "\nGF-Bogen - Seite waehlen:",
     "vfl-winkel-30": "\n  1 - 30 Grad",
@@ -432,8 +436,8 @@
     "extcall-skript-nicht-gefunden": "\n[SSG_LIB] FEHLER: %1 nicht gefunden!",
     "vfstart-core-nicht-gefunden": "\n[VarioFoerderer] WARNUNG: vf_core.lsp nicht gefunden - Befehle nicht verfuegbar.",
     "vfstart-etage-core-nicht-gefunden": "\n[EtageVarioFoerderer] WARNUNG: vf_core.lsp nicht gefunden - Befehle nicht verfuegbar.",
-    "gf-seite-aus-header": "\n\nAUS-Element (AS_Element_90_*) - Seite waehlen:",
+    "gf-seite-aus-header": "\n\nAUS-Element (AS_Element_*) - Seite waehlen:",
-    "gf-seite-ein-header": "\n\nEIN-Element (ES_Element_90_*) - Seite waehlen:",
+    "gf-seite-ein-header": "\n\nEIN-Element (ES_Element_*) - Seite waehlen:",
     "gf-seite-links": "\n  1 - Links",
     "gf-seite-rechts": "\n  2 - Rechts",
     "prompt-wahl-1-2": "\nIhre Wahl (1/2) [1]: ",

lang/en_GB.json

@@ -11,6 +11,10 @@
     "vfl-sep-vor-frage": "\n\nInsert additional separator BEFORE the horizontal section?",
     "vfl-sep-nach-frage": "\n\nInsert additional separator AFTER the horizontal section?",
     "vfl-sep-an-stelle-frage": "\n\nInsert additional separator at this point?",
+    "vf-winkel-aus-header": "\n\nOutput element (AS_Element) - choose angle:",
+    "vf-winkel-ein-header": "\n\nInput element (ES_Element) - choose angle:",
+    "vf-winkel-90": "\n  1 - 90 deg",
+    "vf-winkel-30": "\n  2 - 30 deg",
     "vfl-gf-bogen-winkel-header": "\n\nGF arc - choose angle:",
     "vfl-gf-bogen-seite-header": "\nGF arc - choose side:",
     "vfl-winkel-30": "\n  1 - 30 deg",
@@ -432,8 +436,8 @@
     "extcall-skript-nicht-gefunden": "\n[SSG_LIB] ERROR: %1 not found!",
     "vfstart-core-nicht-gefunden": "\n[VarioFoerderer] WARNING: vf_core.lsp not found - commands not available.",
     "vfstart-etage-core-nicht-gefunden": "\n[EtageVarioFoerderer] WARNING: vf_core.lsp not found - commands not available.",
-    "gf-seite-aus-header": "\n\nOutput element (AS_Element_90_*) - choose side:",
+    "gf-seite-aus-header": "\n\nOutput element (AS_Element_*) - choose side:",
-    "gf-seite-ein-header": "\n\nInput element (ES_Element_90_*) - choose side:",
+    "gf-seite-ein-header": "\n\nInput element (ES_Element_*) - choose side:",
     "gf-seite-links": "\n  1 - Left",
     "gf-seite-rechts": "\n  2 - Right",
     "prompt-wahl-1-2": "\nYour choice (1/2) [1]: ",

lib/export_csv.py

@@ -207,9 +207,9 @@ def build_kreisel_merkmale(block):
         hoehe_m = "0"
     return {
         "Abstand (Kreiselachse A - Kreiselachse) in Meter": abstand_m,
-        "Anzahl der Separatoren": attribs.get("N_SEPARATOREN", "2"),
+        "Anzahl der Separatoren": attribs.get("ANZAHL_SEPARATOR", attribs.get("N_SEPARATOREN", "2")),
         "Kreiselart": attribs.get("KREISELART", "STANDARD"),
-        "Anzahl der Scanner": attribs.get("N_SCANNER", "0"),
+        "Anzahl der Scanner": attribs.get("ANZAHL_SCANNER", attribs.get("N_SCANNER", "0")),
         "Anzahl der Rampen": attribs.get("N_RAMPEN", "0"),
         "Höhe in m": hoehe_m,
         "Drehrichtung": attribs.get("DREHRICHTUNG", "UZS"),

lib/export_sivas.py

@@ -224,12 +224,12 @@ def build_kreisel_details(block):
     except (ValueError, TypeError):
         hoehe_m = "0"
     return {
-        "Abstand (Kreiselachse A - Kreiselachse) in Meter": abstand_m,
-        "Anzahl der Separatoren": attribs.get("N_SEPARATOREN", "2"),
-        "Kreiselart": attribs.get("KREISELART", "STANDARD"),
-        "Anzahl der Scanner": attribs.get("N_SCANNER", "0"),
-        "Anzahl der Rampen": attribs.get("N_RAMPEN", "0"),
         "Hoehe in m": hoehe_m,
+        "Kreiselart": attribs.get("KREISELART", "STANDARD"),
+        "Abstand (Kreiselachse A - Kreiselachse) in Meter": abstand_m,
+        "Anzahl der Separatoren": attribs.get("ANZAHL_SEPARATOR", attribs.get("N_SEPARATOREN", "2")),
+        "Anzahl der Scanner": attribs.get("ANZAHL_SCANNER", attribs.get("N_SCANNER", "0")),
+        "Anzahl der Rampen": attribs.get("N_RAMPEN", "0"),
         "Drehrichtung": attribs.get("DREHRICHTUNG", "UZS"),
         "Drehung": block.get("rotation", 0.0),
     }
@@ -379,7 +379,7 @@ def process_blocks(blocks, lookup):
             kreisel_list.append(block)
             attribs = block.get("attribs", {})
             counters["anzahl_kreisel"] += 1
-            n_sep = int(attribs.get("N_SEPARATOREN", "2") or "2")
+            n_sep = int(attribs.get("ANZAHL_SEPARATOR", attribs.get("N_SEPARATOREN", "2")) or "2")
             kreiselart = attribs.get("KREISELART", "STANDARD")
             if kreiselart == "PIN":
                 counters["anzahl_kreisel_pinband"] += 1
@@ -389,7 +389,7 @@ def process_blocks(blocks, lookup):
             abstand_mm = float(attribs.get("ABSTAND", "2300") or "2300")
             counters["laengen_kreisel"] += abstand_mm / 1000.0
             counters["anzahl_separatoren"] += n_sep
-            counters["anzahl_scanner"] += int(attribs.get("N_SCANNER", "0") or "0")
+            counters["anzahl_scanner"] += int(attribs.get("ANZAHL_SCANNER", attribs.get("N_SCANNER", "0")) or "0")
             if counters["anzahl_streckengruppen"] == 0:
                 counters["anzahl_streckengruppen"] = 1
             continue

tests/alltests.json

@@ -1,6 +1,7 @@
 [
   { "name": "kreisel",          "save": "dxf", "module": "KreiselInsert"    },
   { "name": "foerderer",        "save": "dwg", "module": "VarioFoerderer"   },
+  { "name": "linienzug",        "save": "dwg", "module": "VarioFoerderer"   },
   { "name": "omniflo",          "save": "dxf", "module": "OmniModulInsert"  },
   { "name": "gefaellestrecke",  "save": "dwg", "module": "Gefaellestrecke"  }
 ]

tests/reference/kreisel_tests_sivas.csv

@@ -1,10 +1,10 @@
 Nr;TeileArt;SivasNummer;Dispogruppe;Anzahl;Laenge[mm];Hoehe[m];details
-1;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Kreiselart": "PIN", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "1.5", "Drehrichtung": "UZS", "Drehung": 30, "ID": "0008"}
+1;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "1.5", "Kreiselart": "PIN", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 30, "ID": "0008"}
-2;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "4.0", "Anzahl der Separatoren": "2", "Kreiselart": "PIN", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "1.5", "Drehrichtung": "UZS", "Drehung": 90, "ID": "0007"}
+2;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "1.5", "Kreiselart": "PIN", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "4.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 90, "ID": "0007"}
-3;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Kreiselart": "PIN", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "1.5", "Drehrichtung": "UZS", "Drehung": 0, "ID": "0006"}
+3;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "1.5", "Kreiselart": "PIN", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 0, "ID": "0006"}
-4;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Kreiselart": "STANDARD", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "3.0", "Drehrichtung": "UZS", "Drehung": 30, "ID": "0005"}
+4;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "3.0", "Kreiselart": "STANDARD", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 30, "ID": "0005"}
-5;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "5.0", "Anzahl der Separatoren": "2", "Kreiselart": "STANDARD", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "2.5", "Drehrichtung": "UZS", "Drehung": 270, "ID": "0004"}
+5;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "2.5", "Kreiselart": "STANDARD", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "5.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 270, "ID": "0004"}
-6;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "4.0", "Anzahl der Separatoren": "2", "Kreiselart": "STANDARD", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "2.5", "Drehrichtung": "UZS", "Drehung": 180, "ID": "0003"}
+6;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "2.5", "Kreiselart": "STANDARD", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "4.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 180, "ID": "0003"}
-7;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Kreiselart": "STANDARD", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "2.5", "Drehrichtung": "UZS", "Drehung": 90, "ID": "0002"}
+7;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "2.5", "Kreiselart": "STANDARD", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "3.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 90, "ID": "0002"}
-8;"ILS 2.0 Kreisel";"6200";20;1;;;{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "2.0", "Anzahl der Separatoren": "2", "Kreiselart": "STANDARD", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Hoehe in m": "2.5", "Drehrichtung": "UZS", "Drehung": 0, "ID": "0001"}
+8;"ILS 2.0 Kreisel";"6200";20;1;;;{"Hoehe in m": "2.5", "Kreiselart": "STANDARD", "Abstand (Kreiselachse A - Kreiselachse) in Meter": "2.0", "Anzahl der Separatoren": "2", "Anzahl der Scanner": "0", "Anzahl der Rampen": "0", "Drehrichtung": "UZS", "Drehung": 0, "ID": "0001"}
 9;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";20;1;;;{"Anzahl Kreisel": 8, "Anzahl Kreisel mit Pinband": 3, "Anzahl aller Separatoren in Kreisel mit PIN": 6, "Anzahl aller Separatoren in Kreisel ohne PIN": 10, "Anzahl Verbindungskreisel": 0, "Laengen aller Kreisel": 27.0, "Anzahl der Weichen": 0, "Anzahl der Eckraeder": 0, "Anzahl der einzelnen Gefaellestrecken": 0, "Anzahl der einzelnen Variofoerderer": 0, "Anzahl der Streckengruppen": 1, "Laengen aller Gefaellestrecken": 0.0, "Anzahl der Motoren Variofoerderer": 0, "Laengen aller Variofoerderer": 0.0, "Anzahl ETFs": 0, "Laengen aller ETFs": 0.0, "Anzahl aller Separatoren": 16, "Anzahl aller Scanner": 0, "Anzahl aller BTBeladung": 0, "Anzahl aller Abwurfstationen": 0}

tests/test_linienzug.lsp

@@ -8,21 +8,25 @@
 ;; Skript ab: die vier Eingabe-Funktionen werden NUR waehrend des Testlaufs
 ;; durch Mocks ersetzt (mit Save/Restore), danach wieder hergestellt.
 ;;
+;; Die Eingabe-Sequenz (Skript) wird NICHT mehr im Code hartkodiert, sondern
+;; aus tests/testdata/linienzug_tests.json geladen. Jedes JSON-Objekt mit
+;; "typ" ist ein Eingabe-Schritt in exakter Aufruf-Reihenfolge:
+;;   {"typ":"point_abs","wert":[x,y,z]}   absoluter Punkt (getpoint)
+;;   {"typ":"point_rel","dL":..,"hz":..}  Basispunkt + dL entlang Richtung hz
+;;   {"typ":"real","wert":..}             getreal
+;;   {"typ":"int","wert":..}              getint
+;;   {"typ":"string","wert":".."}         getstring
+;; Das erste Objekt (ohne "typ") enthaelt Beschreibung/Erwartung (Metadaten).
+;;
 ;; Voraussetzungen:
 ;;   - SSG_LIB geladen (VarioFoerderer.lsp inkl. vf_linienzug.lsp mit
 ;;     vfl-getpoint, Gefaellestrecke.lsp, ssg_core.lsp)
 ;;   - Umgebungsvariable DXFMAKRO gesetzt
 ;;
-;; Repliziertes Szenario (aus manuellem Test):
+;; Speichert (Konvention fuer test_run_all.lsp):
-;;   Start Z=4500, AS rechts
+;;   - tests/output/linienzug_results.json (via linienzug:export-results)
-;;   -> Neue Linie (Ab, Ziel-Z=1800, Winkel 45 Grad), GF ganz am Einlauf
-;;   -> Horizontal 900 mm mit Separator VOR + NACH (beide horizontal, 0 Grad)
-;;   -> Vario-Kurve 90 links aussen
-;;   -> Horizontal 250 mm (ohne Separatoren)
-;;   -> Vario-Kurve 90 links aussen
-;;   -> Option 3 (Kettenende definieren): Ziel-Z=4500, Winkel 45 Grad, ES rechts
 ;;
-;; Erwartetes Ergebnis (Ist-Ziel-Report):
+;; Erwartetes Ergebnis (Ist-Ziel-Report, siehe Metadaten in JSON):
 ;;   dX ~ 0, dZ ~ 0 (Ziel exakt getroffen),
 ;;   dY ~ 637 mm  = seitlicher Fussabdruck des ES_Element_90 (90-Grad-Schwenk;
 ;;                  KEIN Baufehler, sondern die Bauform des ES-Elements).
@@ -63,7 +67,67 @@
 (defun tlz-getint (a) (tlz-pop))
 (defun tlz-getreal (a) (tlz-pop))
 
-(defun c:TEST_LINIENZUG ( / old-vgp old-gs old-gi old-gr err)
+;; --- Parsierte JSON-Daten in die Skript-Queue uebersetzen ---
+;; Erwartet die von ssg-load-json gelieferte Liste von Alists.
+;; Nur Objekte mit "typ" sind Eingabe-Schritte; Objekte ohne "typ"
+;; (Metadaten) werden uebersprungen. Die Reihenfolge bleibt erhalten.
+;; Rueckgabe: Queue im Format, das die Mock-Funktionen erwarten.
+(defun tlz-daten->queue (daten / q typ)
+  (setq q nil)
+  (foreach schritt daten
+    (setq typ (ssg-val schritt "typ"))
+    (cond
+      ((= typ "point_abs")
+        (setq q (cons (cons 'A (ssg-val schritt "wert")) q)))
+      ((= typ "point_rel")
+        (setq q (cons (list 'P (ssg-val schritt "dL") (ssg-val schritt "hz")) q)))
+      ((= typ "real")
+        (setq q (cons (float (ssg-val schritt "wert")) q)))
+      ((= typ "int")
+        (setq q (cons (ssg-val schritt "wert") q)))
+      ((= typ "string")
+        (setq q (cons (ssg-val schritt "wert") q)))
+    )
+  )
+  (reverse q)
+)
+
+;; --- Metadaten-Objekt (Beschreibung/Erwartung) aus JSON-Daten holen ---
+;; Liefert die erste Alist ohne "typ" oder nil.
+(defun tlz-daten->meta (daten / meta)
+  (setq meta nil)
+  (foreach obj daten
+    (if (and (null meta) (null (ssg-val obj "typ")))
+      (setq meta obj)
+    )
+  )
+  meta
+)
+
+;; --- JSON-Export der Linienzug-Testergebnisse (Konvention fuer run-all) ---
+(defun linienzug:export-results (tests-out-dir / out-json f)
+  (if (null *linienzug-test-results*)
+    (princ "\n  Keine Linienzug-Ergebnisse vorhanden.")
+    (progn
+      (vl-mkdir tests-out-dir)
+      (setq out-json (strcat tests-out-dir "/linienzug_results.json"))
+      (setq f (open out-json "w"))
+      (if f
+        (progn
+          (write-line "[" f)
+          (write-line *linienzug-test-results* f)
+          (write-line "]" f)
+          (close f)
+          (princ (strcat "\n  Ergebnisse: " out-json))
+        )
+        (princ (strcat "\n  FEHLER: Kann " out-json " nicht schreiben!"))
+      )
+    )
+  )
+)
+
+(defun c:TEST_LINIENZUG ( / json-datei daten meta schritte-anz rest-anz status
+                            old-vgp old-gs old-gi old-gr err)
   (if (or (not *lib-initialized*) (null bogen-auf)) (init-bibliothek))
   (if (null (car (atoms-family 1 '("VF-LINIENZUG-MODUS"))))
     (progn
@@ -77,50 +141,28 @@
   (princ "\n         TEST_LINIENZUG - VF-Linienzug Replay-Test")
   (princ "\n================================================================")
 
+  ;; --- Eingabe-Skript aus JSON laden ---
+  (setq json-datei
+    (strcat (getenv "DXFMAKRO") "\\tests\\testdata\\linienzug_tests.json"))
+  (setq daten (ssg-load-json json-datei))
+  (if (null daten)
+    (progn
+      (alert (strcat "Testdaten nicht gefunden:\n" json-datei))
+      (exit)
+    )
+  )
+  (setq meta        (tlz-daten->meta daten))
+  (setq *tlz-q*     (tlz-daten->queue daten))
+  (setq schritte-anz (length *tlz-q*))
+  (princ (strcat "\n  Testdaten: " json-datei))
+  (princ (strcat "\n  Eingabe-Schritte: " (itoa schritte-anz)))
+  (if meta (princ (strcat "\n  Szenario: " (ssg-val meta "beschreibung"))))
+
   (ssg-start "TEST_LINIENZUG" '(("OSMODE") ("ATTREQ") ("ATTDIA")))
   (setvar "OSMODE" 0)
   (setvar "ATTREQ" 0)
   (setvar "ATTDIA" 0)
 
-  ;; --- Skript der Eingaben in exakter Aufruf-Reihenfolge ---
-  (setq *tlz-q*
-    (list
-      (list 'A 0 0 0)     ; getpoint  Startpunkt der Kette
-      4500.0              ; getreal   Hoehe (Z) Startpunkt
-      "2"                 ; getstring AS-Seite (rechts)
-      "1"                 ; getstring Naechstes Element (Neue Linie)
-      (list 'P 5500 0)    ; getpoint  Endpunkt Linie (frei, +X, dL=5500)
-      1800.0              ; getreal   Hoehe (Z) Linienendpunkt
-      1                   ; getint    Winkelwahl (45 Grad)
-      "2"                 ; getstring GF-Verteilung (alles am Einlauf)
-      "2"                 ; getstring Ist Endpunkt? (Nein)
-      "1"                 ; getstring Naechstes im VF (Horizontal)
-      (list 'P 900 0)     ; getpoint  Horizontal-Endpunkt (dL=900, hz=0)
-      "1"                 ; getstring Separator VOR? (Ja)
-      "1"                 ; getstring Separator NACH? (Ja)
-      "2"                 ; getstring Ist Endpunkt? (Nein)
-      "2"                 ; getstring Naechstes (Vario-Kurve)
-      1                   ; getint    Kurve-Winkel (90)
-      "1"                 ; getstring Kurve-Seite (links)
-      "1"                 ; getstring Kurve-Variante (aussen)
-      "2"                 ; getstring Ist Endpunkt? (Nein)
-      "1"                 ; getstring Naechstes (Horizontal)
-      (list 'P 250 90)    ; getpoint  Horizontal-Endpunkt (dL=250, hz=90)
-      "2"                 ; getstring Separator VOR? (Nein)
-      "2"                 ; getstring Separator NACH? (Nein)
-      "2"                 ; getstring Ist Endpunkt? (Nein)
-      "2"                 ; getstring Naechstes (Vario-Kurve)
-      1                   ; getint    Kurve-Winkel (90)
-      "1"                 ; getstring Kurve-Seite (links)
-      "1"                 ; getstring Kurve-Variante (aussen)
-      "3"                 ; getstring Ist Endpunkt? (Option 3 - Kettenende)
-      (list 'P 6215 180)  ; getpoint  Option-3-Endpunkt (dL=6215, hz=180)
-      4500.0              ; getreal   Hoehe (Z) Kettenende (ES)
-      2                   ; getint    Option-3-Winkelwahl (45 Grad)
-      "2"                 ; getstring ES-Seite (rechts)
-    )
-  )
-
   ;; --- Eingabe-Funktionen sichern und durch Mocks ersetzen ---
   ;; Punkte ueber den Produktions-Wrapper vfl-getpoint (feste 2-Arity),
   ;; getstring/getint/getreal (alle 1-argumentig) direkt.
@@ -136,21 +178,40 @@
   ;; --- Eingabe-Funktionen wiederherstellen (IMMER) ---
   (setq vfl-getpoint old-vgp  getstring old-gs  getint old-gi  getreal old-gr)
 
+  (setq rest-anz (length *tlz-q*))
+
   (princ "\n================================================================")
   (if (vl-catch-all-error-p err)
-    (princ (strcat "\n  TEST_LINIENZUG: FEHLER -> "
-                   (vl-catch-all-error-message err)))
     (progn
+      (setq status "FEHLER")
+      (princ (strcat "\n  TEST_LINIENZUG: FEHLER -> "
+                     (vl-catch-all-error-message err))))
+    (progn
+      (setq status (if (= rest-anz 0) "OK" "ABWEICHUNG"))
       (princ "\n  TEST_LINIENZUG: Kette gebaut.")
-      (if *tlz-q*
+      (if (> rest-anz 0)
-        (princ (strcat "\n  WARNUNG: " (itoa (length *tlz-q*))
+        (princ (strcat "\n  WARNUNG: " (itoa rest-anz)
                        " Skript-Eintraege NICHT verbraucht (Ablauf weicht ab)."))
         (princ "\n  Alle Skript-Eingaben verbraucht (Ablauf wie erwartet)."))
-      (princ "\n  Erwartung Ist-Ziel: dX~0, dZ~0, dY~637 mm (ES_90-Seitenversatz).")
+      (if meta
+        (princ (strcat "\n  Erwartung Ist-Ziel: dX~"
+                       (itoa (ssg-val meta "erwartung_dx_mm")) ", dZ~"
+                       (itoa (ssg-val meta "erwartung_dz_mm")) ", dY~"
+                       (itoa (ssg-val meta "erwartung_dy_mm")) " mm ("
+                       (ssg-val meta "erwartung_hinweis") ").")))
     )
   )
   (princ "\n================================================================")
 
+  ;; --- Ergebnis fuer run-all als JSON-String ablegen ---
+  (setq *linienzug-test-results*
+    (strcat "  {\n"
+      "    \"test_id\": \"LZ_Standard\",\n"
+      "    \"status\": \"" status "\",\n"
+      "    \"schritte_gesamt\": " (itoa schritte-anz) ",\n"
+      "    \"schritte_offen\": " (itoa rest-anz) "\n"
+      "  }"))
+
   (ssg-end)
   (princ)
 )

tests/testdata/linienzug_tests.json

@@ -0,0 +1,178 @@
+[
+  {
+    "beschreibung": "Standard-Linienzug (Modus 1): Start Z4500 AS rechts -> Neue Linie Ab Z1800 45deg (GF am Einlauf) -> Horizontal 900 mit Separator VOR+NACH -> Vario-Kurve 90 links aussen -> Horizontal 250 -> Vario-Kurve 90 links aussen -> Kettenende (Option 3) Z4500 45deg ES rechts",
+    "erwartung_dx_mm": 0,
+    "erwartung_dy_mm": 637,
+    "erwartung_dz_mm": 0,
+    "erwartung_hinweis": "dY~637 = seitlicher Fussabdruck ES_Element_90 (Bauform, kein Baufehler)"
+  },
+  {
+    "typ": "point_abs",
+    "wert": [0, 0, 0],
+    "kommentar": "getpoint  Startpunkt der Kette"
+  },
+  {
+    "typ": "real",
+    "wert": 4500.0,
+    "kommentar": "getreal   Hoehe (Z) Startpunkt"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring AS-Seite (rechts)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Naechstes Element (Neue Linie)"
+  },
+  {
+    "typ": "point_rel",
+    "dL": 5500,
+    "hz": 0,
+    "kommentar": "getpoint  Endpunkt Linie (frei, +X, dL=5500)"
+  },
+  {
+    "typ": "real",
+    "wert": 1800.0,
+    "kommentar": "getreal   Hoehe (Z) Linienendpunkt"
+  },
+  {
+    "typ": "int",
+    "wert": 1,
+    "kommentar": "getint    Winkelwahl (45 Grad)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring GF-Verteilung (alles am Einlauf)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Ist Endpunkt? (Nein)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Naechstes im VF (Horizontal)"
+  },
+  {
+    "typ": "point_rel",
+    "dL": 900,
+    "hz": 0,
+    "kommentar": "getpoint  Horizontal-Endpunkt (dL=900, hz=0)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Separator VOR? (Ja)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Separator NACH? (Ja)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Ist Endpunkt? (Nein)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Naechstes (Vario-Kurve)"
+  },
+  {
+    "typ": "int",
+    "wert": 1,
+    "kommentar": "getint    Kurve-Winkel (90)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Kurve-Seite (links)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Kurve-Variante (aussen)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Ist Endpunkt? (Nein)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Naechstes (Horizontal)"
+  },
+  {
+    "typ": "point_rel",
+    "dL": 250,
+    "hz": 90,
+    "kommentar": "getpoint  Horizontal-Endpunkt (dL=250, hz=90)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Separator VOR? (Nein)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Separator NACH? (Nein)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Ist Endpunkt? (Nein)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring Naechstes (Vario-Kurve)"
+  },
+  {
+    "typ": "int",
+    "wert": 1,
+    "kommentar": "getint    Kurve-Winkel (90)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Kurve-Seite (links)"
+  },
+  {
+    "typ": "string",
+    "wert": "1",
+    "kommentar": "getstring Kurve-Variante (aussen)"
+  },
+  {
+    "typ": "string",
+    "wert": "3",
+    "kommentar": "getstring Ist Endpunkt? (Option 3 - Kettenende)"
+  },
+  {
+    "typ": "point_rel",
+    "dL": 6215,
+    "hz": 180,
+    "kommentar": "getpoint  Option-3-Endpunkt (dL=6215, hz=180)"
+  },
+  {
+    "typ": "real",
+    "wert": 4500.0,
+    "kommentar": "getreal   Hoehe (Z) Kettenende (ES)"
+  },
+  {
+    "typ": "int",
+    "wert": 2,
+    "kommentar": "getint    Option-3-Winkelwahl (45 Grad)"
+  },
+  {
+    "typ": "string",
+    "wert": "2",
+    "kommentar": "getstring ES-Seite (rechts)"
+  }
+]