From 9e3e8e16aeaef0627ac62e9d584f4fd1b4decccd Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Wed, 28 Oct 2026 09:52:10 +0100 Subject: [PATCH 1/6] fix(tests): Testlauf haengt nicht mehr an Export-Rueckfragen, Laufprotokoll je Test TEST_LINIENZUG (ebenso hmrec:stubs-aus und vsp-headless-aus) schaltete die GUI am Ende pauschal wieder ein. Unter SSG_RUN_ALL_TESTS fragte der direkt folgende EXPORTSIVAS dann nach Hoehen-Check/Bereinigen und der Lauf blieb stehen. Alle drei stellen jetzt den Vorzustand von *ssg-gui-aus* wieder her. SSG_RUN_ALL_TESTS schaltet zusaetzlich *csv-hoehencheck-fragen* und *csv-bereinigen-vor-export* fuer den Lauf ab (unmittelbar vor jedem Export erneut, export.lsp belegt nil beim Nachladen wieder mit T), erzwingt GUI aus mit Warnung und stellt am Ende die Vorgaben wieder her. Neues Laufprotokoll DXFM_LOG/testlauf_.dbg je Test (Debug-Schalter "testlauf", Standard ein): Zustand vor/nach dem Test, Fehler, Ergebnis-JSON, Export-Schritte. Eigene Datei mit sofortigem Schreiben statt dbgopen, damit die Module mit ihren eigenen .dbg-Dateien es nicht umlenken und bei einem Haenger der letzte Schritt sichtbar ist. Co-Authored-By: Claude Opus 5.5 --- Lisp/ssg_dbg.lsp | 10 +++- Lisp/vf_spec.lsp | 5 +- tests/test_hm_recformat.lsp | 3 +- tests/test_linienzug.lsp | 11 +++-- tests/test_run_all.lsp | 94 +++++++++++++++++++++++++++++++++++-- 5 files changed, 111 insertions(+), 12 deletions(-) diff --git a/Lisp/ssg_dbg.lsp b/Lisp/ssg_dbg.lsp index 178fd1a..70bb309 100644 --- a/Lisp/ssg_dbg.lsp +++ b/Lisp/ssg_dbg.lsp @@ -90,8 +90,16 @@ ;; (Daten lesen / Dialogaufbau), siehe kf-zeit in ;; KettenFoerderer.lsp. Standard 0 - nur einschalten, ;; wenn der Dialog spuerbar verzoegert erscheint. +;; testlauf - Laufprotokoll je Test von SSG_RUN_ALL_TESTS nach +;; DXFM_LOG/testlauf_.dbg (eigene Datei, nicht +;; ueber *dbg-path*; jede Zeile sofort geschrieben, +;; damit bei einem haengenden Test der letzte Schritt +;; sichtbar ist). Standard 1 - kostet nur ein paar +;; Zeilen je Test, siehe testrun:log in +;; tests/test_run_all.lsp. ;; ------------------------------------------------------------ -(foreach nm '(("vf-sepliste" . 1) ("csv_leave_proxies" . 0) ("kf-zeit" . 0)) +(foreach nm '(("vf-sepliste" . 1) ("csv_leave_proxies" . 0) ("kf-zeit" . 0) + ("testlauf" . 1)) (if (not (assoc (car nm) *dbg-schalter*)) (setq *dbg-schalter* (cons nm *dbg-schalter*)))) diff --git a/Lisp/vf_spec.lsp b/Lisp/vf_spec.lsp index d24a2bb..c053280 100644 --- a/Lisp/vf_spec.lsp +++ b/Lisp/vf_spec.lsp @@ -681,6 +681,7 @@ (setq *vsp-alt-headless* (if (boundp '*vfl-headless*) *vfl-headless*)) (setq *vfl-wizard-mode* nil) (setq *vfl-headless* T) + (setq *vsp-alt-gui* (if (boundp '*ssg-gui-aus*) *ssg-gui-aus*)) (if (car (atoms-family 1 '("SSG-GUI-AUS"))) (ssg-gui-aus)) (setq *vsp-prompts* 0) (princ)) @@ -693,7 +694,9 @@ alert *vsp-alt-alert*) (setq *vfl-wizard-mode* *vsp-alt-wizard*) (setq *vfl-headless* *vsp-alt-headless*) - (if (car (atoms-family 1 '("SSG-GUI-AN"))) (ssg-gui-an)) + ;; Vorzustand zurueck statt pauschal ssg-gui-an: unter SSG_RUN_ALL_TESTS + ;; muss die GUI fuer den Export danach aus bleiben. + (setq *ssg-gui-aus* *vsp-alt-gui*) (princ)) diff --git a/tests/test_hm_recformat.lsp b/tests/test_hm_recformat.lsp index 84a23bf..d5d96a0 100644 --- a/tests/test_hm_recformat.lsp +++ b/tests/test_hm_recformat.lsp @@ -477,6 +477,7 @@ ;; aufgehen und warten). (setq *hmrec-alt-wizard* (if (boundp '*vfl-wizard-mode*) *vfl-wizard-mode*)) (setq *vfl-wizard-mode* nil) + (setq *hmrec-alt-gui* (if (boundp '*ssg-gui-aus*) *ssg-gui-aus*)) (if (car (atoms-family 1 '("SSG-GUI-AUS"))) (ssg-gui-aus)) ;; Headless-Riegel der Produktion einschalten: eine erschoepfte Replay-Queue ;; ist dann ein harter, lokalisierter Abbruch statt eines stillen Rueckfalls @@ -497,7 +498,7 @@ alert *hmrec-alt-alert*) (setq *vfl-wizard-mode* *hmrec-alt-wizard*) (setq *vfl-headless* *hmrec-alt-headless*) - (if (car (atoms-family 1 '("SSG-GUI-AN"))) (ssg-gui-an)) + (setq *ssg-gui-aus* *hmrec-alt-gui*) ; Vorzustand, nicht pauschal an (princ) ) diff --git a/tests/test_linienzug.lsp b/tests/test_linienzug.lsp index 1b4f820..1752dbd 100644 --- a/tests/test_linienzug.lsp +++ b/tests/test_linienzug.lsp @@ -148,7 +148,7 @@ ;; ebenfalls nur einen einzigen Testfall pro Lauf kennt). (defun tlz-run-datei (json-datei test-id befehl-anzeige / daten meta schritte-anz rest-anz status - old-vgp old-gs old-gi old-gr err) + old-vgp old-gs old-gi old-gr err old-gui) (if (or (not *lib-initialized*) (null bogen-auf)) (init-bibliothek)) (if (null (car (atoms-family 1 '("VF-LINIENZUG-MODUS")))) (progn @@ -185,6 +185,7 @@ ;; GUI aus: keine Wizard-DCL-Dialoge waehrend des automatischen Replays - ;; die Eingaben kommen aus der Mock-Queue (getstring/getint/getreal), siehe ;; ssg-gui-aus/ssg-gui-p in ssg_core.lsp und vfl-wizard-mode-p. + (setq old-gui (if (boundp '*ssg-gui-aus*) *ssg-gui-aus*)) (if (car (atoms-family 1 '("SSG-GUI-AUS"))) (ssg-gui-aus)) ;; --- Eingabe-Funktionen sichern und durch Mocks ersetzen --- @@ -201,9 +202,11 @@ ;; --- Eingabe-Funktionen wiederherstellen (IMMER) --- (setq vfl-getpoint old-vgp getstring old-gs getint old-gi getreal old-gr) - ;; GUI wieder einschalten (auch nach Fehler), damit eine folgende interaktive - ;; Sitzung nicht headless bleibt. - (if (car (atoms-family 1 '("SSG-GUI-AN"))) (ssg-gui-an)) + ;; GUI-Zustand von VOR dem Test wiederherstellen (auch nach Fehler) - NICHT + ;; pauschal einschalten: unter SSG_RUN_ALL_TESTS ist sie fuer den ganzen + ;; Batch aus, und ein pauschales ssg-gui-an liess den anschliessenden + ;; EXPORTSIVAS nach Hoehen-Check/Bereinigen fragen (Lauf hing). + (setq *ssg-gui-aus* old-gui) (setq rest-anz (length *tlz-q*)) diff --git a/tests/test_run_all.lsp b/tests/test_run_all.lsp index 8512036..80d244e 100644 --- a/tests/test_run_all.lsp +++ b/tests/test_run_all.lsp @@ -69,6 +69,45 @@ ;; --- Hilfsfunktion: String-Wert aus JSON-Objekt-Zeile lesen --- ;; Sucht "key": "value" in obj-str und gibt value zurueck. ;; Rueckgabe: String (nicht leer) oder nil (key fehlt, null, leer). +;; ------------------------------------------------------------ +;; Laufprotokoll je Test (Debug-Schalter "testlauf", Standard EIN) +;; ------------------------------------------------------------ +;; DXFM_LOG/testlauf_.dbg - eine Datei je Test, bei jedem Lauf neu. +;; Bewusst NICHT ueber dbgopen/*dbg-path*: die getesteten Module oeffnen und +;; schliessen dort ihre eigenen .dbg-Dateien (vfl_modus1.dbg ...) und wuerden +;; das Protokoll mitten im Test umlenken. Jede Zeile wird SOFORT angehaengt +;; (kein Puffer) - haengt ein Test, steht der letzte erreichte Schritt drin. +(if (not (boundp '*testrun-log*)) (setq *testrun-log* nil)) + +(defun testrun:log-start (name / dir fh) + (setq *testrun-log* nil) + (if (and (car (atoms-family 1 '("DBG-SCHALTER-P"))) (dbg-schalter-p "testlauf")) + (progn + (setq dir (cond ((getenv "DXFM_LOG")) ((strcat (getenv "DXFMAKRO") "/logs")))) + (vl-mkdir dir) + (setq *testrun-log* (strcat dir "/testlauf_" name ".dbg")) + (if (setq fh (open *testrun-log* "w")) + (progn (write-line (strcat "=== TESTLAUF " name " ===") fh) (close fh)) + (setq *testrun-log* nil)))) + *testrun-log*) + +(defun testrun:log (text / fh) + (if (and *testrun-log* (setq fh (open *testrun-log* "a"))) + (progn + (write-line (strcat (if (car (atoms-family 1 '("DBG-TIMESTAMP"))) (dbg-timestamp) "") + " " text) + fh) + (close fh))) + (princ)) + +;; Schalter, die in einem Testlauf eine Rueckfrage ausloesen koennen. +(defun testrun:zustand () + (strcat "GUI=" (if (and (boundp '*ssg-gui-aus*) *ssg-gui-aus*) "aus" "AN") + " hoehencheck-fragen=" (vl-princ-to-string (if (boundp '*csv-hoehencheck-fragen*) *csv-hoehencheck-fragen*)) + " bereinigen=" (vl-princ-to-string (if (boundp '*csv-bereinigen-vor-export*) *csv-bereinigen-vor-export*)) + " wizard=" (vl-princ-to-string (if (boundp '*vfl-wizard-mode*) *vfl-wizard-mode*)) + " DWGNAME=" (getvar "DWGNAME"))) + ;; Dateiname ohne fuehrenden Praefix (sonst unveraendert). Gegenstueck zu ;; export:dwg-praefix, den der Export selbst vor den Namen setzt. (defun testrun:ohne-praefix (dateiname praefix) @@ -162,7 +201,7 @@ out-path dwg-pfad dxf-pfad old-json test-result old-filenames csv-name sivas-name csv-pfad sivas-pfad csv-ok sivas-ok old-filedia - praefix) + praefix old-hoehencheck old-bereinigen) (setq tests-pfad (strcat (getenv "DXFMAKRO") "/tests")) (setq tests-out-dir (strcat tests-pfad "/output")) @@ -220,6 +259,13 @@ ;; oeffnet DCL-/Wizard-Dialoge, die den automatischen Lauf blockieren wuerden. ;; Am Ende wieder einschalten. Siehe ssg-gui-aus/-an in ssg_core.lsp. (if (car (atoms-family 1 '("SSG-GUI-AUS"))) (ssg-gui-aus)) + ;; Rueckfragen des Exports (export.lsp) fuer den ganzen Lauf abschalten - + ;; zusaetzlich zur GUI-Sperre, damit auch ein Test, der die GUI wieder + ;; einschaltet, den Export nicht anhalten kann. + (setq old-hoehencheck (if (boundp '*csv-hoehencheck-fragen*) *csv-hoehencheck-fragen*) + old-bereinigen (if (boundp '*csv-bereinigen-vor-export*) *csv-bereinigen-vor-export*)) + (setq *csv-hoehencheck-fragen* nil + *csv-bereinigen-vor-export* 'aus) ;; Tests laden und ausfuehren ;; Jeder Test bekommt eine eigene neue Zeichnung (statt die aktuelle @@ -279,10 +325,18 @@ ;; Testreihenfolge ab und jeder Referenz-Diff wurde unruhig. (setq #VF_LetzteNr 0 #GF_LetzteNr 0 #Kreisel_LetzteNr 0 #Eckrad_LetzteNr 0) + (testrun:log-start name) + (testrun:log (strcat "Test " (itoa idx) "/" (itoa anz) ": " befehl + " Modul=" (if module module "-") + " save=" (if save-fmt save-fmt "-") + " Modus=" (if auto-export "Automatik" "Kontrolle"))) + (testrun:log (strcat "Vor Test: " (testrun:zustand))) + (if (findfile datei) (progn (load datei) ;; Test mit Fehlerbehandlung ausfuehren + (testrun:log (strcat "Starte " befehl)) (setq test-result (vl-catch-all-apply '(lambda () @@ -292,12 +346,18 @@ ) ) (if (vl-catch-all-error-p test-result) - (princ (strcat "\n FEHLER in " befehl ": " - (vl-catch-all-error-message test-result))) - ) + (progn + (princ (strcat "\n FEHLER in " befehl ": " + (vl-catch-all-error-message test-result))) + (testrun:log (strcat "FEHLER in " befehl ": " + (vl-catch-all-error-message test-result)))) + (testrun:log (strcat befehl " beendet"))) + (testrun:log (strcat "Nach Test: " (testrun:zustand))) ;; JSON-Export (immer) (apply export-fn (list tests-out-dir)) + (testrun:log (strcat "Ergebnis-JSON " name "_results.json: " + (if (findfile old-json) "vorhanden" "FEHLT"))) (setq out-path (strcat tests-out-dir "/" name "_tests")) @@ -364,22 +424,40 @@ (T p))) old-filenames)) + ;; Unmittelbar vor dem Export erneut erzwingen: export.lsp setzt + ;; *csv-hoehencheck-fragen* beim (Nach-)Laden von nil auf T, und + ;; ein Test kann die GUI wieder eingeschaltet haben. + (if (not (and (boundp '*ssg-gui-aus*) *ssg-gui-aus*)) + (progn + (testrun:log "WARNUNG: GUI war nach dem Test wieder AN - fuer den Export abgeschaltet") + (princ "\n WARNUNG: GUI war nach dem Test wieder an - abgeschaltet.") + (ssg-gui-aus))) + (setq *csv-hoehencheck-fragen* nil + *csv-bereinigen-vor-export* 'aus) + (testrun:log (strcat "Vor Export: " (testrun:zustand))) + (princ (strcat "\n CSV-Export -> " csv-name)) + (testrun:log (strcat "EXPORTCSV -> " csv-pfad)) (c:EXPORTCSV) (setq csv-ok (testrun:wait-for-file csv-pfad 30.0)) (princ (if csv-ok "\n CSV OK" "\n CSV TIMEOUT/FEHLER")) + (testrun:log (if csv-ok "EXPORTCSV OK" "EXPORTCSV TIMEOUT/FEHLER - Datei nicht entstanden")) (princ (strcat "\n Sivas-Export -> " sivas-name)) + (testrun:log (strcat "EXPORTSIVAS -> " sivas-pfad)) (c:EXPORTSIVAS) (setq sivas-ok (testrun:wait-for-file sivas-pfad 30.0)) (princ (if sivas-ok "\n Sivas OK" "\n Sivas TIMEOUT/FEHLER")) + (testrun:log (if sivas-ok "EXPORTSIVAS OK" "EXPORTSIVAS TIMEOUT/FEHLER - Datei nicht entstanden")) (setq *export-filenames* old-filenames) ;; Zeichnung schliessen: der urspruenglich schon offene Tab ;; bleibt unangetastet, BricsCAD erzeugt daher kein neues ;; Blank-Dokument samt Modul-/Menue-Reload. + (testrun:log "Zeichnung schliessen") (vla-close new-doc :vlax-false) + (testrun:log "Test fertig") ) ;; ========================================================== @@ -441,7 +519,9 @@ ) ) ) - (princ (strcat "\n WARNUNG: " datei " nicht gefunden - uebersprungen")) + (progn + (princ (strcat "\n WARNUNG: " datei " nicht gefunden - uebersprungen")) + (testrun:log (strcat "WARNUNG: " datei " nicht gefunden - uebersprungen"))) ) ) ;; end (progn ...) des aktiven Zweigs ) ;; end (if (cdr (assoc "disabled" entry)) ...) @@ -449,6 +529,10 @@ ;; GUI wieder einschalten (Batch fertig). (if (car (atoms-family 1 '("SSG-GUI-AN"))) (ssg-gui-an)) + ;; nil = "nie gesetzt" (export.lsp belegt dann mit der Vorgabe vor) + (setq *csv-hoehencheck-fragen* (if old-hoehencheck old-hoehencheck T) + *csv-bereinigen-vor-export* (if old-bereinigen old-bereinigen 'an)) + (setq *testrun-log* nil) (setq *export-test-override* nil) From c3b4bf9db3becb72588c7031097bbc46f9419133 Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Wed, 28 Oct 2026 11:02:44 +0100 Subject: [PATCH 2/6] fix(kreisel): Mindestabstand 800mm gegen beruehrende Endkreise Unterhalb des Kreisel-Durchmessers (*kreisel-durchmesser*, Default 800mm) wuerden sich AN8/SP8 beruehren bzw. ueberschneiden. draw-module prueft das als harte Sperre fuer alle Aufrufer; KreiselInsert/-Connect/-Redraw fragen bei Unterschreitung erneut ab statt abzubrechen, KreiselEdit zeigt den Dialog erneut (Projektmuster wie GERUEST). Co-Authored-By: Claude Sonnet 5 --- Lisp/KreiselInsert.lsp | 234 +++++++++++++++++++++++++---------------- lang/de_DE.json | 1 + lang/en_GB.json | 1 + 3 files changed, 145 insertions(+), 91 deletions(-) diff --git a/Lisp/KreiselInsert.lsp b/Lisp/KreiselInsert.lsp index 94780ab..c46735c 100644 --- a/Lisp/KreiselInsert.lsp +++ b/Lisp/KreiselInsert.lsp @@ -420,6 +420,18 @@ att-entity att-data att-tag new-value beforeAtt) + ;; Mindestabstand: unterhalb des Durchmessers wuerden sich die Endkreise + ;; (AN8/SP8) beruehren bzw. ueberschneiden - harte Sperre fuer alle Aufrufer + ;; (Insert/Connect/Redraw/Edit/Script), da draw-module der einzige + ;; gemeinsame Zeichenpfad ist. + (if (< abstand *kreisel-durchmesser*) + (progn + (ssg-emsg (ssg-textf "kreisel-emsg-abstand-zu-klein" + (list (rtos abstand 2 0) (rtos *kreisel-durchmesser* 2 0)))) + (exit) + ) + ) + ;; Attribute vorbereiten (setq attribs (ssg-attrib-merge attribs *kreisel-attrib-defs*)) (setq attribs (subst (cons "ABSTAND" (rtos abstand 2 0)) @@ -695,11 +707,23 @@ ) ;; 2. Abstand (Tangentenlaenge) - Linie gibt auch den Winkel vor - (setq p2 (getpoint pt (ssg-textf "kreisel-prompt-abstand" - (list (rtos *kreisel-default-laenge* 2 0))))) - (setq erg (kreisel-insert-richtung pt p2 *kreisel-default-laenge*) - abstand (car erg) - rotation (cadr erg)) + ;; Mindestabstand = Kreisel-Durchmesser (sonst beruehren/ueberschneiden + ;; sich die Endkreise) - bei Unterschreitung erneut abfragen. + (setq abstand nil) + (while (null abstand) + (setq p2 (getpoint pt (ssg-textf "kreisel-prompt-abstand" + (list (rtos *kreisel-default-laenge* 2 0))))) + (setq erg (kreisel-insert-richtung pt p2 *kreisel-default-laenge*) + abstand (car erg) + rotation (cadr erg)) + (if (< abstand *kreisel-durchmesser*) + (progn + (ssg-emsg (ssg-textf "kreisel-emsg-abstand-zu-klein" + (list (rtos abstand 2 0) (rtos *kreisel-durchmesser* 2 0)))) + (setq abstand nil) + ) + ) + ) (princ (ssg-textf "kreisel-abstand-ausgabe" (list (rtos abstand 2 0)))) ;; 3. Hoehe (Z-Koordinate) @@ -747,24 +771,29 @@ (progn (ssg-end) (princ (ssg-text "kreisel-abgebrochen")) (princ) (exit)) ) - ;; 2. Endpunkt (aeusserster Punkt SP-Seite) mit Gummiband - (setq ptEnd (getpoint ptStart (ssg-text "kreisel-prompt-endpunkt"))) - (if (null ptEnd) - (progn (ssg-end) (princ (ssg-text "kreisel-abgebrochen")) (princ) (exit)) - ) + ;; 2. Endpunkt (aeusserster Punkt SP-Seite) mit Gummiband - der Abstand + ;; (Kreismitten-Tangentenlaenge = dist - Durchmesser) muss mindestens dem + ;; Durchmesser entsprechen, sonst beruehren/ueberschneiden sich die + ;; Endkreise; bei Unterschreitung erneut abfragen statt abzubrechen. + (setq abstand nil) + (while (null abstand) + (setq ptEnd (getpoint ptStart (ssg-text "kreisel-prompt-endpunkt"))) + (if (null ptEnd) + (progn (ssg-end) (princ (ssg-text "kreisel-abgebrochen")) (princ) (exit)) + ) - ;; 3. Geometrie berechnen - (setq dx (- (car ptEnd) (car ptStart)) - dy (- (cadr ptEnd) (cadr ptStart))) - (setq dist (sqrt (+ (* dx dx) (* dy dy)))) - (setq abstand (- dist *kreisel-durchmesser*)) + ;; 3. Geometrie berechnen + (setq dx (- (car ptEnd) (car ptStart)) + dy (- (cadr ptEnd) (cadr ptStart))) + (setq dist (sqrt (+ (* dx dx) (* dy dy)))) + (setq abstand (- dist *kreisel-durchmesser*)) - (if (<= abstand 0.0) - (progn - (ssg-emsg (ssg-textf "kreisel-emsg-distanz-klein" - (list (rtos dist 2 0) (rtos *kreisel-durchmesser* 2 0)))) - (ssg-end) - (exit) + (if (< abstand *kreisel-durchmesser*) + (progn + (ssg-emsg (ssg-textf "kreisel-emsg-distanz-klein" + (list (rtos dist 2 0) (rtos (* 2.0 *kreisel-durchmesser*) 2 0)))) + (setq abstand nil) + ) ) ) @@ -883,7 +912,7 @@ ;; geaendertem) Abstand neu. Alle Attribute bleiben ;; erhalten. ;; ----------------------------------------------- -(defun c:KreiselRedraw ( / sel ent ed attribs basePoint rotation newAbstand) +(defun c:KreiselRedraw ( / sel ent ed attribs basePoint rotation newAbstand gueltig) (ssg-start (ssg-text "kreisel-start-redraw") '(("CECOLOR"))) @@ -910,11 +939,20 @@ (cdr (assoc "HOEHE" attribs)) (cdr (assoc "KREISELART" attribs))))) - ;; 3. Neuen Abstand abfragen (Enter = beibehalten) - (initget 6) - (setq newAbstand (getdist (ssg-textf "kreisel-prompt-neuer-abstand" (list (cdr (assoc "ABSTAND" attribs)))))) - (if (null newAbstand) - (setq newAbstand (atof (cdr (assoc "ABSTAND" attribs)))) + ;; 3. Neuen Abstand abfragen (Enter = beibehalten); Mindestabstand = + ;; Kreisel-Durchmesser, sonst beruehren/ueberschneiden sich die Endkreise. + (setq newAbstand nil gueltig nil) + (while (not gueltig) + (initget 6) + (setq newAbstand (getdist (ssg-textf "kreisel-prompt-neuer-abstand" (list (cdr (assoc "ABSTAND" attribs)))))) + (if (null newAbstand) + (setq newAbstand (atof (cdr (assoc "ABSTAND" attribs)))) + ) + (if (< newAbstand *kreisel-durchmesser*) + (ssg-emsg (ssg-textf "kreisel-emsg-abstand-zu-klein" + (list (rtos newAbstand 2 0) (rtos *kreisel-durchmesser* 2 0)))) + (setq gueltig T) + ) ) ;; NEU - Neue Höhe abfragen: (setq newHoehe (getreal (ssg-textf "kreisel-prompt-neue-hoehe" (list (cdr (assoc "HOEHE" attribs)))))) @@ -991,7 +1029,7 @@ ;; 3. Bei OK: Block loeschen und mit neuen Werten neu zeichnen ;; ----------------------------------------------- (defun c:KreiselEdit ( / sel ss ent ed attribs basePoint rotation - dcl-pfad dat ergebnis + dcl-pfad dat ergebnis fertig dlg-name dlg-abstand dlg-hoehe dlg-ausrichtung dlg-drehrichtung dlg-kreiselart dlg-geruest-einzelmodul dlg-geruest-typ @@ -1049,73 +1087,87 @@ (princ (ssg-textf "kreisel-edit-bestehend" (list (cdr (assoc "ABSTAND" attribs)) (rtos rotation 2 1) (cdr (assoc "KREISELART" attribs))))) - ;; 3. DCL-Dialog laden - (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/kreisel_edit.dcl")) - (setq dat (load_dialog dcl-pfad)) - (if (not (new_dialog "kreisel_edit" dat)) - (progn (alert (ssg-textf "kreisel-edit-dialog-fehlt" (list dcl-pfad))) (ssg-end) (exit)) - ) + ;; 3. DCL-Dialog laden; bei zu kleinem Abstand (< Kreisel-Durchmesser, + ;; sonst beruehren/ueberschneiden sich die Endkreise) erneut anzeigen, + ;; statt den fehlerhaften Wert zu uebernehmen (Projektmuster wie GERUEST). + (setq dlg-abstand (cdr (assoc "ABSTAND" attribs))) + (setq fertig nil) + (while (not fertig) + (setq dcl-pfad (strcat (getenv "DXFM_DCL") "/kreisel_edit.dcl")) + (setq dat (load_dialog dcl-pfad)) + (if (not (new_dialog "kreisel_edit" dat)) + (progn (alert (ssg-textf "kreisel-edit-dialog-fehlt" (list dcl-pfad))) (ssg-end) (exit)) + ) - ;; Ausrichtungs-Labels fuer popup_list aufbauen - (setq ausrichtLabels "") - (foreach entry *kreisel-ausrichtungen* - (if (= ausrichtLabels "") - (setq ausrichtLabels (car entry)) - (setq ausrichtLabels (strcat ausrichtLabels "\n" (car entry))) + ;; Ausrichtungs-Labels fuer popup_list aufbauen + (setq ausrichtLabels "") + (foreach entry *kreisel-ausrichtungen* + (if (= ausrichtLabels "") + (setq ausrichtLabels (car entry)) + (setq ausrichtLabels (strcat ausrichtLabels "\n" (car entry))) + ) + ) + + ;; Tiles initialisieren (Abstand aus vorherigem Versuch uebernehmen) + (set_tile "name" (cdr (assoc "Bezeichnung" attribs))) + (set_tile "abstand" dlg-abstand) + (set_tile "hoehe" (cdr (assoc "HOEHE" attribs))) + + (start_list "ausrichtung") + (foreach entry *kreisel-ausrichtungen* + (add_list (car entry)) + ) + (end_list) + (set_tile "ausrichtung" (itoa (kreisel-rotation-to-idx rotation))) + + (start_list "drehrichtung") + (add_list "UZS") + (add_list "GUZ") + (end_list) + (set_tile "drehrichtung" (if (equal (cdr (assoc "DREHRICHTUNG" attribs)) "GUZ") "1" "0")) + + (start_list "kreiselart") + (add_list "STANDARD") + (add_list "PIN") + (end_list) + (set_tile "kreiselart" (if (equal (cdr (assoc "KREISELART" attribs)) "PIN") "1" "0")) + + (set_tile "geruest_einzelmodul" + (if (equal (cdr (assoc "GERUEST_EINZELMODUL" attribs)) "1") "1" "0")) + + (start_list "geruest_typ") + (foreach opt *ssg-geruest-optionen* (add_list opt)) + (end_list) + (set_tile "geruest_typ" (itoa (ssg-geruest-typ-to-idx (cdr (assoc "GERUEST_TYP" attribs))))) + + ;; Actions + (action_tile "accept" + (strcat + "(setq dlg-name (get_tile \"name\"))" + "(setq dlg-abstand (get_tile \"abstand\"))" + "(setq dlg-hoehe (get_tile \"hoehe\"))" + "(setq dlg-ausrichtung (get_tile \"ausrichtung\"))" + "(setq dlg-drehrichtung (get_tile \"drehrichtung\"))" + "(setq dlg-kreiselart (get_tile \"kreiselart\"))" + "(setq dlg-geruest-einzelmodul (get_tile \"geruest_einzelmodul\"))" + "(setq dlg-geruest-typ (get_tile \"geruest_typ\"))" + "(done_dialog 1)" + ) + ) + (action_tile "cancel" "(done_dialog 0)") + + (setq ergebnis (start_dialog)) + (unload_dialog dat) + + (cond + ((/= ergebnis 1) (setq fertig T)) + ((< (atof dlg-abstand) *kreisel-durchmesser*) + (ssg-emsg (ssg-textf "kreisel-emsg-abstand-zu-klein" + (list (rtos (atof dlg-abstand) 2 0) (rtos *kreisel-durchmesser* 2 0))))) + (t (setq fertig T)) ) ) - ;; Tiles initialisieren - (set_tile "name" (cdr (assoc "Bezeichnung" attribs))) - (set_tile "abstand" (cdr (assoc "ABSTAND" attribs))) - (set_tile "hoehe" (cdr (assoc "HOEHE" attribs))) - - (start_list "ausrichtung") - (foreach entry *kreisel-ausrichtungen* - (add_list (car entry)) - ) - (end_list) - (set_tile "ausrichtung" (itoa (kreisel-rotation-to-idx rotation))) - - (start_list "drehrichtung") - (add_list "UZS") - (add_list "GUZ") - (end_list) - (set_tile "drehrichtung" (if (equal (cdr (assoc "DREHRICHTUNG" attribs)) "GUZ") "1" "0")) - - (start_list "kreiselart") - (add_list "STANDARD") - (add_list "PIN") - (end_list) - (set_tile "kreiselart" (if (equal (cdr (assoc "KREISELART" attribs)) "PIN") "1" "0")) - - (set_tile "geruest_einzelmodul" - (if (equal (cdr (assoc "GERUEST_EINZELMODUL" attribs)) "1") "1" "0")) - - (start_list "geruest_typ") - (foreach opt *ssg-geruest-optionen* (add_list opt)) - (end_list) - (set_tile "geruest_typ" (itoa (ssg-geruest-typ-to-idx (cdr (assoc "GERUEST_TYP" attribs))))) - - ;; Actions - (action_tile "accept" - (strcat - "(setq dlg-name (get_tile \"name\"))" - "(setq dlg-abstand (get_tile \"abstand\"))" - "(setq dlg-hoehe (get_tile \"hoehe\"))" - "(setq dlg-ausrichtung (get_tile \"ausrichtung\"))" - "(setq dlg-drehrichtung (get_tile \"drehrichtung\"))" - "(setq dlg-kreiselart (get_tile \"kreiselart\"))" - "(setq dlg-geruest-einzelmodul (get_tile \"geruest_einzelmodul\"))" - "(setq dlg-geruest-typ (get_tile \"geruest_typ\"))" - "(done_dialog 1)" - ) - ) - (action_tile "cancel" "(done_dialog 0)") - - (setq ergebnis (start_dialog)) - (unload_dialog dat) - ;; 4. Bei OK: Block loeschen und neu zeichnen (if (= ergebnis 1) (progn diff --git a/lang/de_DE.json b/lang/de_DE.json index dbdb4e4..8f73389 100644 --- a/lang/de_DE.json +++ b/lang/de_DE.json @@ -320,6 +320,7 @@ "kreisel-edit-bestehend": "\n-> Bestehend: Abstand=%1 Drehung=%2 Art=%3", "kreisel-edit-dialog-fehlt": "Dialog nicht verfuegbar: %1", "kreisel-eingefuegt": "\n-> Kreisel #%1 eingefügt: %2 (Höhe=%3)", + "kreisel-emsg-abstand-zu-klein": "Abstand zu klein! (%1 < %2) - die Endkreise wuerden sich beruehren/ueberschneiden.", "kreisel-emsg-distanz-klein": "Distanz zu klein! (%1 < %2)", "kreisel-hoehe-aus-3dpunkt": "\n-> Hoehe aus 3D-Punkt uebernommen: %1", "kreisel-hoehe-aus-basispunkt": "\n-> Höhe aus Basispunkt übernommen: %1", diff --git a/lang/en_GB.json b/lang/en_GB.json index e42686c..442afc3 100644 --- a/lang/en_GB.json +++ b/lang/en_GB.json @@ -320,6 +320,7 @@ "kreisel-edit-bestehend": "\n-> Existing: Distance=%1 Rotation=%2 Type=%3", "kreisel-edit-dialog-fehlt": "Dialog not available: %1", "kreisel-eingefuegt": "\n-> Kreisel #%1 inserted: %2 (height=%3)", + "kreisel-emsg-abstand-zu-klein": "Distance too small! (%1 < %2) - the end circles would touch/overlap.", "kreisel-emsg-distanz-klein": "Distance too small! (%1 < %2)", "kreisel-hoehe-aus-3dpunkt": "\n-> Height taken from 3D point: %1", "kreisel-hoehe-aus-basispunkt": "\n-> Height taken from base point: %1", From 2bb00bb48f478c375dc2f9cb5dcf0c25d023b42a Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Wed, 28 Oct 2026 17:22:36 +0100 Subject: [PATCH 3/6] fix(export): freie Separatoren nach Lage in die Kette ihrer Strecke einsortieren Eigenstaendige Separatoren, deren Zuordnung eine VF/GF nennt, die aber nicht beim Bau der Strecke entstanden, fehlten in deren sepliste und damit in TrackIds und Nachbarn (Mubea VF_3: 0037/0038). Sie werden jetzt beim Export nach Lage zwischen AS und ES aufgenommen - nur im Speicher des Laufs, die sepliste-XDATA bleibt Bauprotokoll (Lisp paart sie per Anzahl je Typ mit den Bausteinen und fuehrt reservierte AS/ES-IDs unter der lfdnr). Co-Authored-By: Claude Opus 5.5 --- lib/export_csv.py | 7 + lib/export_neighbors.py | 189 +++++++++++++++++++++++++ tests/test_export_freie_separatoren.py | 168 ++++++++++++++++++++++ 3 files changed, 364 insertions(+) create mode 100644 tests/test_export_freie_separatoren.py diff --git a/lib/export_csv.py b/lib/export_csv.py index 1abee2e..9f5aad7 100644 --- a/lib/export_csv.py +++ b/lib/export_csv.py @@ -42,6 +42,7 @@ from export_neighbors import ( compute_kreisel_touch_switches, lisp_touch_switches, load_lisp_kreisel_weichen, + einsortieren_freie_separatoren, compute_sep_kette, compute_kreisel_umlauf, SENSOR_TEILEARTEN, @@ -1543,6 +1544,12 @@ def process_blocks(blocks, lookup, dbg=None, lisp_weichen=None): if item.get("teileart", "") == "ILS 2.0 Scanner" and separator_id: item["merkmale"]["Naechster Separator"] = separator_id + # Freie Separatoren, deren Zuordnung eine VF_n/GF_n nennt, die aber nicht + # beim Bau der Strecke entstanden sind (fehlen darum in ihrer sepliste), + # nach Lage in die Kette aufnehmen - nur fuer diesen Lauf, die XDATA am + # Block bleibt unveraendert (siehe einsortieren_freie_separatoren). + einsortieren_freie_separatoren(items, NEIGHBOR_TOLERANCE_MM, dbg=dbg) + # Ketteninterne Separator-/AS-/ES-Reihenfolge aus der neuen "sepliste"- # XDATA (siehe ssg-sepliste-xdata-schreiben) - leeres dict, wenn keine # Strecke eine sepliste traegt (reiner Altbestand ohne neue XDATA). diff --git a/lib/export_neighbors.py b/lib/export_neighbors.py index aa78ad1..03ae7bb 100644 --- a/lib/export_neighbors.py +++ b/lib/export_neighbors.py @@ -1255,6 +1255,190 @@ def _asel_collision_boxes(item, half_tol, box_dims): # Ersetzt das bisherige Raten der Ketten-internen Reihenfolge (die Linie # selbst wird nicht exportiert) durch die tatsaechliche Bau-Reihenfolge. +def sepliste_einsortier_positionen(kette_xy, kandidaten): + """Reiner Rechenkern fuer einsortieren_freie_separatoren: wohin gehoert + jeder Kandidat in eine vorhandene Kette? + + kette_xy = [(x, y), ...] Lage der Kettenglieder in Kettenfolge (AS ... + ES), mindestens zwei Punkte. Sie bilden einen Polygonzug - so + folgt die Zuordnung auch einer Kette, die um eine Kurve laeuft, + statt nur einer Geraden AS->ES. + kandidaten = [(key, x, y), ...] + + Jeder Kandidat wird dem naechstgelegenen Abschnitt (Glied i -> i+1) + zugeordnet. Liegt er dabei VOR dem ersten oder HINTER dem letzten Glied, + wird er verworfen - eingefuegt wird nur zwischen AS und ES. + + Rueckgabe (einfuegen, verworfen): einfuegen = {i: [key, ...]} - nach + Glied i einzufuegen, untereinander in Kettenrichtung sortiert; + verworfen = [key, ...]. + """ + abschnitte = [] + for i in range(len(kette_xy) - 1): + (ax, ay), (bx, by) = kette_xy[i], kette_xy[i + 1] + dx, dy = bx - ax, by - ay + l2 = dx * dx + dy * dy + if l2 > 1e-12: + abschnitte.append((i, ax, ay, dx, dy, l2)) + letzter = len(kette_xy) - 2 + + einfuegen = {} + verworfen = [] + for key, x, y in kandidaten: + best = None + for i, ax, ay, dx, dy, l2 in abschnitte: + t = ((x - ax) * dx + (y - ay) * dy) / l2 + tc = min(max(t, 0.0), 1.0) + d = math.hypot(x - (ax + tc * dx), y - (ay + tc * dy)) + if best is None or d < best[0] - 1e-9: + best = (d, i, t) + if best is None: + verworfen.append(key) + continue + _d, i, t = best + if (i == 0 and t <= 0.0) or (i == letzter and t >= 1.0): + verworfen.append(key) + continue + einfuegen.setdefault(i, []).append((min(max(t, 0.0), 1.0), key)) + + return ({i: [key for _t, key in sorted(liste)] for i, liste in einfuegen.items()}, + verworfen) + + +def _kettenglied_xy(entry, item, strecke): + """Lage eines sepliste-Glieds fuer den Polygonzug: AS/ES ueber K1/K2 der + Strecke (Ein-/Auslauf - der ZZ_ASES_MARKER sitzt auf dem Einfuegepunkt + des Elements und kann bis ~600 mm seitlich davon liegen), sonst bzw. + ohne K1/K2 der Bounding-Box-Mittelpunkt des vertretenden Items.""" + typ = entry.get("typ", "") + if typ in ("AS", "ES"): + k1_xy, k2_xy = _asel_kos_xy(strecke) + pt = k1_xy if typ == "AS" else k2_xy + if pt is not None: + return pt + bbox = (item or {}).get("_bbox") + if not bbox: + return None + return (bbox.get("cx", 0.0), bbox.get("cy", 0.0)) + + +def einsortieren_freie_separatoren(items, tolerance_mm, dbg=None): + """Nimmt freie Separatoren in die sepliste ihrer VF_n/GF_n-Strecke auf. + + Die sepliste entsteht beim BAU der Strecke (ssg-sepliste-sammeln) und + kennt nur die Separatoren, die dabei erzeugt wurden. Ein eigenstaendiger + Separator_SP-Block, der spaeter (oder aus einer frueheren Fassung der + Strecke) auf ihr liegt, fehlt darin - obwohl seine ZUORDNUNG + (cs-zuordnung-lauf) die Strecke nennt. Ohne diesen Schritt fehlt er in + TrackIds und Nachbarn (realer Fall Mubea VF_3: 0037/0038 zwischen 0062 + und 0063). + + Aufgenommen wird ein Separator nur, wenn + - seine Zuordnung die Strecke nennt, + - er in keiner sepliste steht, + - sein Mittelpunkt in der Bounding-Box der Strecke liegt (+ tolerance_mm/2), + - er laengs der Kette zwischen AS und ES liegt + (sepliste_einsortier_positionen). + + Bewusst NUR im Speicher dieses Exportlaufs: die sepliste-XDATA am Block + bleibt das Bauprotokoll. Lisp ordnet ihre Eintraege den eingebauten + Bausteinen ueber die Anzahl je Typ zu (csv:sepliste-kette-paare) und + fuehrt reservierte AS/ES-IDs unter der lfdnr - ein in die XDATA + eingefuegter fremder Separator verschoebe beides. Ausserdem schreibt jeder + Neuaufbau der Strecke die XDATA neu; hier wird bei jedem Export frisch + aus dem aktuellen Zeichnungsstand gerechnet. + + Aendert items in-place: item["sepliste"] der Strecke bekommt neue + SEP-Eintraege (lfdnr "frei", "id" = TeileId des Separators, + "frei": True); der Separator bekommt "_in_strecke_kette" (Strecken- + TeileId, damit compute_kreisel_umlauf ihn nicht zusaetzlich einem + Kreisel zuschlaegt) und einen Hinweis in "warnung". + Muss NACH der Separator-Zuordnung und VOR compute_sep_kette laufen. + """ + half_tol = tolerance_mm / 2.0 + by_teileid = {it.get("teileid", ""): it for it in items if it.get("teileid", "")} + in_ketten = set() + for it in items: + if it.get("teileart", "") in GF_VF_TEILEARTEN: + for e in it.get("sepliste") or []: + eid = str(e.get("id", "")).strip() + if eid: + in_ketten.add(eid) + + if dbg: + dbg("=== einsortieren_freie_separatoren ===") + + for strecke in items: + if strecke.get("teileart", "") not in GF_VF_TEILEARTEN: + continue + sepliste = strecke.get("sepliste") + sbbox = strecke.get("_bbox") + if not sepliste or not sbbox: + continue + sid = strecke.get("teileid", "") + sbounds = _bounds(sbbox, half_tol) + + kandidaten = [] + for it in items: + if it.get("teileart", "") != "ILS 2.0 Separator": + continue + tid = it.get("teileid", "") + if not tid or tid in in_ketten: + continue + zuordnung = ((it.get("merkmale") or {}).get("Zuordnung") + or it.get("_zuordnung_attr") or "").strip() + if zuordnung != sid: + continue + bbox = it.get("_bbox") + if not bbox: + continue + cx, cy = bbox.get("cx", 0.0), bbox.get("cy", 0.0) + if not (sbounds[0] <= cx <= sbounds[1] and sbounds[2] <= cy <= sbounds[3]): + if dbg: + dbg(f" Strecke {sid}: Separator {tid} ausserhalb der Strecken-BBox " + f"- nicht einsortiert") + continue + kandidaten.append((tid, cx, cy)) + if not kandidaten: + continue + + kette_xy = [] + for e in sepliste: + pt = _kettenglied_xy(e, by_teileid.get(str(e.get("id", "")).strip()), strecke) + if pt is None: + break + kette_xy.append(pt) + if len(kette_xy) != len(sepliste) or len(kette_xy) < 2: + if dbg: + dbg(f" Strecke {sid}: Kettenglieder nicht vollstaendig lokalisierbar " + f"- freie Separatoren {[k[0] for k in kandidaten]} nicht einsortiert") + continue + + einfuegen, verworfen = sepliste_einsortier_positionen(kette_xy, kandidaten) + if dbg and verworfen: + dbg(f" Strecke {sid}: {verworfen} liegen nicht zwischen AS und ES " + f"- nicht einsortiert") + if not einfuegen: + continue + + neu = [] + for i, entry in enumerate(sepliste): + neu.append(entry) + for tid in einfuegen.get(i, []): + neu.append({"typ": "SEP", "lfdnr": f"frei{tid}", "id": tid, "frei": True}) + sep = by_teileid[tid] + sep["_in_strecke_kette"] = sid + hinweis = (f"nicht im Bau von {sid} erzeugt - per Lage in dessen " + f"Kette einsortiert") + bisherige = sep.get("warnung", "") + sep["warnung"] = f"{bisherige}; {hinweis}" if bisherige else hinweis + in_ketten.add(tid) + strecke["sepliste"] = neu + if dbg: + dbg(f" Strecke {sid}: Kette jetzt " + f"{' -> '.join(str(e.get('id', '')) for e in neu)}") + + def compute_sep_kette(items, dbg=None): """Baut je VF_n/GF_n-Item MIT "sepliste" die ketteninterne Vorgaenger-/ Nachfolger-Beziehung AS -> Sep1 -> ... -> SepN -> ES. @@ -1392,6 +1576,11 @@ def compute_kreisel_umlauf(items, tolerance_mm, durchmesser_mm=800.0, for item in items: if item.get("teileart", "") not in KREISEL_UMLAUF_TEILEARTEN: continue + # Freier Separator, den einsortieren_freie_separatoren in die Kette + # einer Strecke aufgenommen hat - gehoert nicht zusaetzlich auf einen + # Kreisel, auch wenn seine Box einen beruehrt. + if item.get("_in_strecke_kette"): + continue teileid = item.get("teileid", "") bbox = item.get("_bbox") if not bbox: diff --git a/tests/test_export_freie_separatoren.py b/tests/test_export_freie_separatoren.py new file mode 100644 index 0000000..3396fa1 --- /dev/null +++ b/tests/test_export_freie_separatoren.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +test_export_freie_separatoren.py - freie Separatoren in der Kette einer Strecke. +Laeuft komplett ohne BricsCAD (reine Python-Logik, siehe lib/export_neighbors.py). + +Szenario nach einem realen Mubea-Befund (VF_3 = 0015): die sepliste aus dem +Bau kennt nur AS 0061, SEP 0062, SEP 0063, ES 0064. Die eigenstaendigen +Separatoren 0037/0038 liegen auf der Strecke, ihre Zuordnung nennt 0015 - sie +fehlten aber in TrackIds und Nachbarn. einsortieren_freie_separatoren nimmt +sie nach Lage auf. + +Alle Daten sind hier fest eingetragen (Stand des Mubea-Exports 2026-10-28) und +werden aus keiner Datei gelesen - aendert sich die Mubea-Zeichnung, bleibt +dieser Test unberuehrt. Er prueft den Algorithmus, nicht die Szene. +""" + +import os +import sys + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "lib")) + +from export_neighbors import ( # noqa: E402 + compute_sep_kette, + einsortieren_freie_separatoren, + sepliste_einsortier_positionen, +) +from export_csv import ( # noqa: E402 + map_sepliste_kette_items, + resolve_umlauf_und_sepliste_nachbarn, + write_separatorliste_merkmale, +) + +TOL_MM = 100.0 + + +def _sep(teileid, x, y, zuordnung): + return { + "teileart": "ILS 2.0 Separator", + "teileid": teileid, + "merkmale": {"Zuordnung": zuordnung}, + "nachbarn": "", + "_bbox": {"cx": x, "cy": y, "cz": 0.0, "dx": 150.0, "dy": 210.0}, + } + + +def _ases(teileart, teileid, x, y, zuordnung): + return { + "teileart": teileart, + "teileid": teileid, + "_zuordnung": zuordnung, + "merkmale": {}, + "nachbarn": "", + "_bbox": {"cx": x, "cy": y, "cz": 0.0, "dx": 200.0, "dy": 200.0}, + } + + +def _mubea_vf3(): + strecke = { + "teileart": "ILS 2.0 Strecke", + "teileid": "0015", + "nachbarn": "0002-L", + "merkmale": {}, + "k1": "", "k2": "", + "_bbox": {"cx": -631.28, "cy": 6543.11, "cz": 1624.70, + "dx": 1018.09, "dy": 12791.0}, + "sepliste": [ + {"typ": "AS", "lfdnr": 1, "id": "0061"}, + {"typ": "SEP", "lfdnr": 2, "id": "0062"}, + {"typ": "SEP", "lfdnr": 3, "id": "0063"}, + {"typ": "ES", "lfdnr": 4, "id": "0064"}, + ], + } + return [ + strecke, + _ases("ILS Ausschleuselement", "0061", -400.00, 270.54, "0015"), + _sep("0062", -898.87, 1134.60, "0015"), + _sep("0063", -702.98, 12307.81, "0015"), + _ases("ILS Einschleuselement", "0064", -400.00, 12832.58, "0015"), + _sep("0037", -1026.00, 10723.05, "0015"), + _sep("0038", -1026.00, 5250.05, "0015"), + ] + + +def _by_id(items, teileid): + return next(it for it in items if it.get("teileid") == teileid) + + +def _pipeline(items): + einsortieren_freie_separatoren(items, TOL_MM) + sep_kette = compute_sep_kette(items) + sep_kette_by_key = map_sepliste_kette_items(items, sep_kette) + write_separatorliste_merkmale(items, sep_kette_by_key) + resolve_umlauf_und_sepliste_nachbarn(items, {}, sep_kette, sep_kette_by_key, {}) + return items + + +class TestEinsortierPositionen: + """Reiner Rechenkern, ohne Items.""" + + KETTE = [(0.0, 0.0), (0.0, 1000.0), (0.0, 5000.0), (0.0, 6000.0)] + + def test_zwei_kandidaten_im_selben_abschnitt_sortiert(self): + einfuegen, verworfen = sepliste_einsortier_positionen( + self.KETTE, [("B", 50.0, 4000.0), ("A", -50.0, 2000.0)]) + assert einfuegen == {1: ["A", "B"]} + assert verworfen == [] + + def test_vor_as_und_hinter_es_verworfen(self): + einfuegen, verworfen = sepliste_einsortier_positionen( + self.KETTE, [("vor", 0.0, -500.0), ("hinter", 0.0, 6500.0)]) + assert einfuegen == {} + assert sorted(verworfen) == ["hinter", "vor"] + + def test_kette_um_eine_kurve(self): + """Polygonzug statt Gerade AS->ES: ein Separator auf dem zweiten + Schenkel einer L-Kette gehoert in DEN Abschnitt, nicht nach + seiner Projektion auf die Diagonale.""" + kette = [(0.0, 0.0), (0.0, 3000.0), (3000.0, 3000.0)] + einfuegen, _ = sepliste_einsortier_positionen(kette, [("S", 1500.0, 3050.0)]) + assert einfuegen == {1: ["S"]} + + def test_entartete_kette(self): + einfuegen, verworfen = sepliste_einsortier_positionen( + [(0.0, 0.0), (0.0, 0.0)], [("S", 10.0, 10.0)]) + assert einfuegen == {} + assert verworfen == ["S"] + + +class TestMubeaVf3: + + def test_trackids_mit_freien_separatoren(self): + items = _pipeline(_mubea_vf3()) + assert _by_id(items, "0015").get("trackids") == \ + "0061, 0062, 0038, 0037, 0063, 0064" + + def test_nachbarn_der_kette(self): + items = _pipeline(_mubea_vf3()) + assert _by_id(items, "0062")["nachbarn"] == "0061, 0038" + assert _by_id(items, "0038")["nachbarn"] == "0062, 0037" + assert _by_id(items, "0037")["nachbarn"] == "0038, 0063" + assert _by_id(items, "0063")["nachbarn"] == "0037, 0064" + + def test_hinweis_am_freien_separator(self): + items = _pipeline(_mubea_vf3()) + assert "0015" in _by_id(items, "0037").get("warnung", "") + assert _by_id(items, "0062").get("warnung", "") == "" + + def test_fremde_zuordnung_bleibt_draussen(self): + items = _mubea_vf3() + _by_id(items, "0037")["merkmale"]["Zuordnung"] = "0002-L" + _pipeline(items) + assert _by_id(items, "0015").get("trackids") == "0061, 0062, 0038, 0063, 0064" + + def test_ausserhalb_der_strecken_bbox_bleibt_draussen(self): + items = _mubea_vf3() + _by_id(items, "0038")["_bbox"]["cx"] = -3000.0 + _pipeline(items) + assert _by_id(items, "0015").get("trackids") == "0061, 0062, 0037, 0063, 0064" + + def test_ohne_ids_kein_einsortieren(self): + """Altbestand ohne aufgeloeste IDs: Glieder nicht lokalisierbar -> + sepliste bleibt wie gebaut.""" + items = _mubea_vf3() + for e in _by_id(items, "0015")["sepliste"]: + e["id"] = "" + einsortieren_freie_separatoren(items, TOL_MM) + assert len(_by_id(items, "0015")["sepliste"]) == 4 From 5368f5b44768c64f5170df1bcc183fb6cb69a17b Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Wed, 28 Oct 2026 18:20:54 +0100 Subject: [PATCH 4/6] Drehrichtungen der Kreisel waren falsch rum eingetragen --- tests/testdata/mubea.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/testdata/mubea.json b/tests/testdata/mubea.json index 3712186..9f33bef 100644 --- a/tests/testdata/mubea.json +++ b/tests/testdata/mubea.json @@ -8,6 +8,7 @@ "abstand": 5000, "rotation": 0.0, "typ": "STANDARD", + "drehrichtung": "GUZ", "expect_block_prefix": "KREISEL_", "expect_hoehe": "1554", "expect_kreiselart": "STANDARD", @@ -22,7 +23,7 @@ "abstand": 20015, "rotation": 90.0, "typ": "STANDARD", - "drehrichtung": "GUZ", + "drehrichtung": "UZS", "expect_block_prefix": "KREISEL_", "expect_hoehe": "1554", "expect_kreiselart": "STANDARD", From 321dcfde642f16f358001cd5e89c5024d4f825c5 Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Wed, 28 Oct 2026 23:12:50 +0100 Subject: [PATCH 5/6] feat(export): Merkmal "Einsortiert in" an nach Lage einsortierten Separatoren Folgewerkzeuge (sps_skel: sepliste-Gegenprobe) erkennen daran, dass ein Separator in TrackIds, aber zu Recht nicht im Bauprotokoll der Strecke steht. CLAUDE.md beschreibt den neuen Export-Schritt. Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 2 +- lib/export_neighbors.py | 6 +++++- tests/test_export_freie_separatoren.py | 6 ++++++ 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 756661c..1e7ede1 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -208,7 +208,7 @@ Abhaengigkeiten: `ezdxf`, Standard-Library. Benoetigen Umgebungsvariablen (`DXFM | `set_einfuegepkt.py` | Setzt `$INSBASE` (Einfuegepunkt) in Omniflo-DXF-Dateien. Schalter je Typ: `--boegen`, `--weichen45`, `--weichen90`, `--weichenkoerper`, `--weichen-parallel`, `--delta`, `--dreifachweiche`, `--sternweiche`, `--show-omniflo` | | `set_koords.py` | Setzt Koordinatensystem-Bloecke (K1-K4) in Omniflo-DXF-Dateien. Schalter: `--k1set` bis `--k4set`, `--set-all`, `--force`, `--show-omniflo`, `--test`, `--number` | | `export_sivas.py` | Erzeugt Sivas-Export-CSV mit Summierungszeilen (ILS Automation, Omniflo Sum). Omniflo-Elemente werden ueber das TEILEART-Attribut (`Omniflo *`) erkannt, ihre Sivas-Nummern kommen - wie beim Geruest - NUR aus dem kommagetrennten `ARTINR`-Attribut (eine Zeile je Nummer, TEF-Teile `0_B*` als `Omniflo TEF`); KEIN Katalog-Lookup mehr (den nutzt nur noch `export_csv.py` fuer die Merkmale). Schreibt zusaetzlich immer `_zusammengefasst.csv`: Zeilen, die sich nur in Nr/Anzahl/IDs unterscheiden (v.a. Geruest, je Block eine Zeile), zu einer Zeile zusammengefasst (`items_zusammenfassen`, Anzahl addiert, IDs vereinigt); die Hauptdatei bleibt unveraendert. **ILS 2.0 Weiche (6216)**: eine Summenzeile (Anzahl 1), sobald `kreisel_weichen.json` (LISP-Export, siehe KreiselInsert.lsp) Beruehrpunkte enthaelt - je Beruehrpunkt eine Weichenkombination aus 1x aktiv (3371) + 1x passiv (3372), Zuordnung in `cfg/sivas.cfg` `[weichen]` ueber das synthetische Attribut `ANZAHL_WEICHEN`; dieselbe Zahl geht in Merkmal 4403 der Automation-Zeile. Aufruf: `python export_sivas.py ` | -| `export_csv.py` | Erzeugt einfache Item-Liste als CSV (ohne Summierung). Aufruf: `python export_csv.py ` | +| `export_csv.py` | Erzeugt einfache Item-Liste als CSV (ohne Summierung). Spalten `Nachbarn`/`TrackIds` einer VF_n/GF_n kommen aus deren `sepliste` (Bauprotokoll, nur beim Bau per `entnext` gesammelt). **Freie Separatoren** (eigenstaendige `Separator_SP`-Bloecke, deren Zuordnung die Strecke nennt, die aber nicht beim Bau entstanden - realer Fall Mubea VF_3: 0037/0038) nimmt `einsortieren_freie_separatoren` (export_neighbors.py) vor `compute_sep_kette` nach Lage in die Kette auf: nur wenn Mittelpunkt in der Strecken-BBox UND laengs des Linienzugs der Kettenglieder zwischen AS und ES (reiner Kern `sepliste_einsortier_positionen`); der Separator bekommt das Merkmal `"Einsortiert in": ` (sps_skel zieht ihn darueber von der sepliste-Gegenprobe ab) und einen Hinweis in `Warnungen`. **Bewusst nur im Speicher des Exportlaufs, NICHT in die sepliste-XDATA zurueckgeschrieben**: Lisp paart die sepliste-Eintraege ueber die Anzahl je Typ mit den eingebauten Bausteinen (`csv:sepliste-kette-paare`) und fuehrt reservierte AS/ES-IDs unter der `lfdnr` (`csv:asmark-res-key`) - ein fremder Eintrag verschoebe beides; ausserdem schreibt jeder Neuaufbau/Edit der Strecke die XDATA neu. Test `tests/test_export_freie_separatoren.py`. Aufruf: `python export_csv.py ` | | `split_block_library.py` | Teilt `ils_library.dxf` in einzelne DXF-Dateien pro Block auf (mit Abhaengigkeiten). Export-Prefixe: Vario_, Staustrecke_, _3D_AS_, _3D_ES_ | | `vf_journal_export.py` | Liest die Eingabe-Journale der `VF_n`-Bloecke (XDATA-App `SSG_VF_EDIT`, Marker `"linienzug"`) aus einer Zeichnung und schreibt sie als Frage-Antwort-Protokoll im Schema von `tests/testdata/linienzug_tests.json` (Gegenstueck zu `vfl-entry->string`; kein ezdxf, reine Gruppencode-Lesung). Optional `--csv ` fuer Strecken-ID und Erwartungswerte je Kette. Aufruf: `python vf_journal_export.py [--csv ...] [--kein-startpunkt-fix]` — erzeugt `tests/testdata/hm_recformat.json` aus `data/polylines.dxf` (die Aufzeichnung, aus der `tests/testdata/hundm05.json` als Spec abgeleitet wird) | | `dxf_vf_abbild.py` | Abbild der `VF_`/`GF_`-Wrapperbloecke einer Testzeichnung: Attribute UND Bausteinzusammensetzung je Kette, Ketten ueber den Einfuegepunkt der Spec zugeordnet (der Blockname taugt nicht - die VF-Nummer beginnt in jeder Zeichnung neu bei 1). Regressionsnetz fuer Umbauten am Bau-Ablauf: `--referenz` vergleicht gegen `tests/reference/hundm05_attribute.json` (Exit 1 bei Abweichung), `--schreibe-referenz` frischt sie nach einem GEPRUEFTEN Lauf auf. Faengt genau das, was der Ergebnis-Record nicht sieht - eine vertauschte `vfl-acc-*`-Reihenfolge (Komma-Listen `L_VF_m`/`L_GF_m`/`GF_WINKEL`, in der Zeichnung unsichtbar, im Sivas-Export falsch) und eine falsche Blockvariante. Liest ASCII-DXF streamend; binaere DXF kann `dxf_scan_components.py`. Genutzt von `tests/test_vf_geometrie.py` | diff --git a/lib/export_neighbors.py b/lib/export_neighbors.py index 03ae7bb..05ef9d1 100644 --- a/lib/export_neighbors.py +++ b/lib/export_neighbors.py @@ -1352,7 +1352,8 @@ def einsortieren_freie_separatoren(items, tolerance_mm, dbg=None): SEP-Eintraege (lfdnr "frei", "id" = TeileId des Separators, "frei": True); der Separator bekommt "_in_strecke_kette" (Strecken- TeileId, damit compute_kreisel_umlauf ihn nicht zusaetzlich einem - Kreisel zuschlaegt) und einen Hinweis in "warnung". + Kreisel zuschlaegt), das Merkmal "Einsortiert in" (Strecken-TeileId, + in der CSV-Spalte Merkmale) und einen Hinweis in "warnung". Muss NACH der Separator-Zuordnung und VOR compute_sep_kette laufen. """ half_tol = tolerance_mm / 2.0 @@ -1428,6 +1429,9 @@ def einsortieren_freie_separatoren(items, tolerance_mm, dbg=None): neu.append({"typ": "SEP", "lfdnr": f"frei{tid}", "id": tid, "frei": True}) sep = by_teileid[tid] sep["_in_strecke_kette"] = sid + # Fuer Folgewerkzeuge (sps_skel: sepliste-Gegenprobe): dieser + # Separator steht in TrackIds, aber nicht im Bauprotokoll. + sep.setdefault("merkmale", {})["Einsortiert in"] = sid hinweis = (f"nicht im Bau von {sid} erzeugt - per Lage in dessen " f"Kette einsortiert") bisherige = sep.get("warnung", "") diff --git a/tests/test_export_freie_separatoren.py b/tests/test_export_freie_separatoren.py index 3396fa1..26c671d 100644 --- a/tests/test_export_freie_separatoren.py +++ b/tests/test_export_freie_separatoren.py @@ -146,6 +146,12 @@ class TestMubeaVf3: assert "0015" in _by_id(items, "0037").get("warnung", "") assert _by_id(items, "0062").get("warnung", "") == "" + def test_merkmal_einsortiert_in(self): + items = _pipeline(_mubea_vf3()) + assert _by_id(items, "0037")["merkmale"].get("Einsortiert in") == "0015" + assert _by_id(items, "0038")["merkmale"].get("Einsortiert in") == "0015" + assert "Einsortiert in" not in _by_id(items, "0062")["merkmale"] + def test_fremde_zuordnung_bleibt_draussen(self): items = _mubea_vf3() _by_id(items, "0037")["merkmale"]["Zuordnung"] = "0002-L" From 0d4b7c4cfc1d5915da96d2e2b9fd73677ba13f23 Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Thu, 29 Oct 2026 10:20:50 +0100 Subject: [PATCH 6/6] test: Referenzdateien nach gepruefter Lauf-Analyse aktualisiert Nur Dateien, deren Abweichung gegenueber dem letzten Lauf erklaert und unbedenklich ist (reine Attribut-/Merkmal-Erweiterung, Namenszaehler-Fix, Kreisel-Hoehen-Neuberechnung, Zuordnungs-Logik aus fea6014) - siehe Vergleichsprotokoll in der Session. Bewusst NICHT aktualisiert: foerderer_results.json (unerklaerte ~1mm-Drift), mubea_* (VF_4-Etage-Solver- Aenderung + Kreisel2-Drehrichtung brauchen fachliche Pruefung), hundm05_attribute.json (braucht dxf_vf_abbild.py --schreibe-referenz statt Kopie), kreisel_export.csv/kreisel_sivas.csv/kreisel_tests.dxf (kein frischer Lauf in dieser Session). Co-Authored-By: Claude Sonnet 5 --- tests/reference/foerderer_tests_sivas.csv | 28 +++++++++---------- .../reference/gefaellestrecke_tests_sivas.csv | 10 +++---- tests/reference/hundm05_tests_export.csv | 12 ++++---- tests/reference/hundm05_tests_sivas.csv | 12 ++++---- tests/reference/kreisel_results.json | 16 +++++------ tests/reference/kreisel_tests_sivas.csv | 15 +++++----- tests/reference/linienzug_results.json | 2 +- tests/reference/linienzug_tests_sivas.csv | 4 +-- 8 files changed, 50 insertions(+), 49 deletions(-) diff --git a/tests/reference/foerderer_tests_sivas.csv b/tests/reference/foerderer_tests_sivas.csv index c5c6f93..4235705 100644 --- a/tests/reference/foerderer_tests_sivas.csv +++ b/tests/reference/foerderer_tests_sivas.csv @@ -1,15 +1,15 @@ Nr;TeileArt;SivasNummer;Bezeichnung;Dispogruppe;Anzahl;Laenge[mm];IDs;details -1;"ILS 2.0 Strecke";"6220";"VF_13";20;1;;"0013";{"Anlagenhöhe in Meter": "-1.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.0", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.707", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.055", "Streckengruppe - Varioförderer 001-Richtung": "ab", "Streckengruppe - Varioförderer 001- Winkel": "39", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -2;"ILS 2.0 Strecke";"6220";"VF_12";20;1;;"0012";{"Anlagenhöhe in Meter": "0.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.084", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.0", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.478", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "21", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -3;"ILS 2.0 Strecke";"6220";"VF_11";20;1;;"0011";{"Anlagenhöhe in Meter": "1.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.166", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.166", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.207", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "51", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -4;"ILS 2.0 Strecke";"6220";"VF_10";20;1;;"0010";{"Anlagenhöhe in Meter": "-1", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.541", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.541", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "2.731", "Streckengruppe - Varioförderer 001-Richtung": "ab", "Streckengruppe - Varioförderer 001- Winkel": "27", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -5;"ILS 2.0 Strecke";"6220";"VF_9";20;1;;"0009";{"Anlagenhöhe in Meter": "1", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.206", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.206", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.07", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "39", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -6;"ILS 2.0 Strecke";"6220";"VF_8";20;1;;"0008";{"Anlagenhöhe in Meter": "-2", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.15", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.15", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "4.067", "Streckengruppe - Varioförderer 001-Richtung": "ab", "Streckengruppe - Varioförderer 001- Winkel": "45", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -7;"ILS 2.0 Strecke";"6220";"VF_7";20;1;;"0007";{"Anlagenhöhe in Meter": "-1.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.354", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.354", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.055", "Streckengruppe - Varioförderer 001-Richtung": "ab", "Streckengruppe - Varioförderer 001- Winkel": "39", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -8;"ILS 2.0 Strecke";"6220";"VF_6";20;1;;"0006";{"Anlagenhöhe in Meter": "-1", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.013", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.013", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.701", "Streckengruppe - Varioförderer 001-Richtung": "ab", "Streckengruppe - Varioförderer 001- Winkel": "21", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -9;"ILS 2.0 Strecke";"6220";"VF_5";20;1;;"0005";{"Anlagenhöhe in Meter": "-0.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.486", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.486", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.056", "Streckengruppe - Varioförderer 001-Richtung": "ab", "Streckengruppe - Varioförderer 001- Winkel": "9", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -10;"ILS 2.0 Strecke";"6220";"VF_4";20;1;;"0004";{"Anlagenhöhe in Meter": "1.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.166", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.166", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.207", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "51", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -11;"ILS 2.0 Strecke";"6220";"VF_3";20;1;;"0003";{"Anlagenhöhe in Meter": "1", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.206", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.206", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.07", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "39", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -12;"ILS 2.0 Strecke";"6220";"VF_2";20;1;;"0002";{"Anlagenhöhe in Meter": "0.5", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.042", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.042", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "3.478", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "21", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -13;"ILS 2.0 Strecke";"6220";"VF_1";20;1;;"0001";{"Anlagenhöhe in Meter": "0", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "0.615", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "0.615", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "2.74", "Streckengruppe - Varioförderer 001-Richtung": "auf", "Streckengruppe - Varioförderer 001- Winkel": "9", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -14;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"Automation": "Ja", "Anzahl der Kreisel": "0", "Anzahl der Separatoren - Kreisel ohne PINBAND": "0", "Anzahl der Kreisel mit PINBAND": "0", "Anzahl der Separatoren - Kreisel mit PINBAND": "0", "Anzahl der Verbindungskreisel": "0", "Längen aller Kreisel": "0.00", "Anzahl der Weichen": "0", "Anzahl der Eckräder": "0", "Anzahl der einzelnen Gefällestrecken": "0", "Anzahl der einzelnen Vario-Förderer": "0", "Anzahl der Streckengruppen": "13", "Längen aller Gefällestrecken": "0.00", "Anzahl der Motoren in Vario - Förderer": "13", "Längen aller Vario - Förderer": "41.915000000000006", "Anzahl der ETFs": "0", "Längen aller ETFS und Zusatzstücke (Gefällestrecken)": "0.0", "Anzahl der Separatoren in der Anlage": "26", "Anzahl der Scanner in der Anlage": "0", "Zusatzmodul - Anzahl der BT-Beladung": "0", "Zusatzmodul - Anzahl der Abwurfstation": "0", "Pneumatik": "Ja"} +1;"ILS 2.0 Strecke";"6220";"VF_13";20;1;;"0013";{"2950": "-1.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.0", "4391": "3", "4314": "Ja", "4319": "0.707", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.055", "4354": "ab", "4386": "39", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +2;"ILS 2.0 Strecke";"6220";"VF_12";20;1;;"0012";{"2950": "0.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.084", "4391": "3", "4314": "Ja", "4319": "0.0", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.478", "4354": "auf", "4386": "21", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +3;"ILS 2.0 Strecke";"6220";"VF_11";20;1;;"0011";{"2950": "1.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.166", "4391": "3", "4314": "Ja", "4319": "0.166", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.207", "4354": "auf", "4386": "51", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +4;"ILS 2.0 Strecke";"6220";"VF_10";20;1;;"0010";{"2950": "-1", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.541", "4391": "3", "4314": "Ja", "4319": "0.541", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "2.731", "4354": "ab", "4386": "27", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +5;"ILS 2.0 Strecke";"6220";"VF_9";20;1;;"0009";{"2950": "1", "4431": "Ja", "4427": "90 °", "4428": "rechts", "4432": "Ja", "4429": "90 °", "4430": "rechts", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.206", "4391": "3", "4314": "Ja", "4319": "0.206", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.07", "4354": "auf", "4386": "39", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +6;"ILS 2.0 Strecke";"6220";"VF_8";20;1;;"0008";{"2950": "-2", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.15", "4391": "3", "4314": "Ja", "4319": "0.15", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "4.067", "4354": "ab", "4386": "45", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +7;"ILS 2.0 Strecke";"6220";"VF_7";20;1;;"0007";{"2950": "-1.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.354", "4391": "3", "4314": "Ja", "4319": "0.354", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.055", "4354": "ab", "4386": "39", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +8;"ILS 2.0 Strecke";"6220";"VF_6";20;1;;"0006";{"2950": "-1", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.013", "4391": "3", "4314": "Ja", "4319": "0.013", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.701", "4354": "ab", "4386": "21", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +9;"ILS 2.0 Strecke";"6220";"VF_5";20;1;;"0005";{"2950": "-0.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.486", "4391": "3", "4314": "Ja", "4319": "0.486", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.056", "4354": "ab", "4386": "9", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488", "4437": "-0.512"} +10;"ILS 2.0 Strecke";"6220";"VF_4";20;1;;"0004";{"2950": "1.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.166", "4391": "3", "4314": "Ja", "4319": "0.166", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.207", "4354": "auf", "4386": "51", "4433": "-0.012", "4434": "0.488", "4435": "0.988", "4436": "1.488"} +11;"ILS 2.0 Strecke";"6220";"VF_3";20;1;;"0003";{"2950": "1", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.206", "4391": "3", "4314": "Ja", "4319": "0.206", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.07", "4354": "auf", "4386": "39", "4433": "-0.012", "4434": "0.488", "4435": "0.988"} +12;"ILS 2.0 Strecke";"6220";"VF_2";20;1;;"0002";{"2950": "0.5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.042", "4391": "3", "4314": "Ja", "4319": "0.042", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "3.478", "4354": "auf", "4386": "21", "4433": "-0.012", "4434": "0.488"} +13;"ILS 2.0 Strecke";"6220";"VF_1";20;1;;"0001";{"2950": "0", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "0", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.615", "4391": "3", "4314": "Ja", "4319": "0.615", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "2.74", "4354": "auf", "4386": "9", "4433": "-0.012"} +14;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"4000": "Ja", "4400": "0", "4413": "0", "4401": "0", "4414": "0", "4402": "0", "4419": "0.00", "4403": "0", "4404": "0", "4425": "0", "4426": "0", "4407": "13", "4418": "0.00", "4408": "13", "4420": "41.915000000000006", "4409": "0", "4417": "0.0", "4410": "26", "4411": "0", "4421": "0", "4422": "0", "4100": "Ja"} diff --git a/tests/reference/gefaellestrecke_tests_sivas.csv b/tests/reference/gefaellestrecke_tests_sivas.csv index 40b4d49..2f38de8 100644 --- a/tests/reference/gefaellestrecke_tests_sivas.csv +++ b/tests/reference/gefaellestrecke_tests_sivas.csv @@ -1,6 +1,6 @@ Nr;TeileArt;SivasNummer;Bezeichnung;Dispogruppe;Anzahl;Laenge[mm];IDs;details -1;"ILS 2.0 Gefaellestrecke";"6220";"GF_8";20;1;;"0008";{"Anlagenhöhe in Meter": "5", "Streckengruppe": "ein Objekt", "Gefällestrecke oder Vario-Förderer": "Gefällestrecke", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "9.261", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "1", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -2;"ILS 2.0 Gefaellestrecke";"6220";"GF_7";20;1;;"0007";{"Anlagenhöhe in Meter": "2", "Streckengruppe": "mehrere Objekte", "Gefällestrecke oder Vario-Förderer": "Gefällestrecke", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "7.274,5.264", "Streckengruppe - Gefällestrecke 001 -Winkel": "0.2,0.2", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "2", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -3;"ILS 2.0 Gefaellestrecke";"6220";"GF_6";20;1;;"0006";{"Anlagenhöhe in Meter": "5", "Streckengruppe": "ein Objekt", "Gefällestrecke oder Vario-Förderer": "Gefällestrecke", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "8.838", "Streckengruppe - Gefällestrecke 001 -Winkel": "2.8", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "1", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -4;"ILS 2.0 Gefaellestrecke";"6220";"GF_5, GF_4, GF_3, GF_2, GF_1";20;1;;"0005, 0004, 0003, 0002, 0001";{"Anlagenhöhe in Meter": "5", "Streckengruppe": "ein Objekt", "Gefällestrecke oder Vario-Förderer": "Gefällestrecke", "Strecken- zu fertigende Menge": "5", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "8.851", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "1", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Gerüst für Einzelmodul": "Nein", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -5;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"Automation": "Ja", "Anzahl der Kreisel": "0", "Anzahl der Separatoren - Kreisel ohne PINBAND": "0", "Anzahl der Kreisel mit PINBAND": "0", "Anzahl der Separatoren - Kreisel mit PINBAND": "0", "Anzahl der Verbindungskreisel": "0", "Längen aller Kreisel": "0.00", "Anzahl der Weichen": "0", "Anzahl der Eckräder": "0", "Anzahl der einzelnen Gefällestrecken": "8", "Anzahl der einzelnen Vario-Förderer": "0", "Anzahl der Streckengruppen": "0", "Längen aller Gefällestrecken": "62.35", "Anzahl der Motoren in Vario - Förderer": "0", "Längen aller Vario - Förderer": "0.0", "Anzahl der ETFs": "0", "Längen aller ETFS und Zusatzstücke (Gefällestrecken)": "0.0", "Anzahl der Separatoren in der Anlage": "9", "Anzahl der Scanner in der Anlage": "0", "Zusatzmodul - Anzahl der BT-Beladung": "0", "Zusatzmodul - Anzahl der Abwurfstation": "0", "Pneumatik": "Ja"} +1;"ILS 2.0 Gefaellestrecke";"6220";"GF_8";20;1;;"0008";{"2950": "5", "4431": "Ja", "4427": "30 °", "4428": "links", "4432": "Ja", "4429": "30 °", "4430": "links", "4384": "Gefällestrecke", "4318": "9.261", "4391": "3", "4337": "1", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "ein Objekt", "4311": "1"} +2;"ILS 2.0 Gefaellestrecke";"6220";"GF_7";20;1;;"0007";{"2950": "2", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4384": "Gefällestrecke", "4318": "7.274,5.264", "4391": "0.2,0.2", "4337": "2", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1"} +3;"ILS 2.0 Gefaellestrecke";"6220";"GF_6";20;1;;"0006";{"2950": "5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4384": "Gefällestrecke", "4318": "8.838", "4391": "2.8", "4337": "1", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "ein Objekt", "4311": "1"} +4;"ILS 2.0 Gefaellestrecke";"6220";"GF_5, GF_4, GF_3, GF_2, GF_1";20;1;;"0005, 0004, 0003, 0002, 0001";{"2950": "5", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4384": "Gefällestrecke", "4318": "8.851", "4391": "3", "4337": "1", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "3992": "Nein", "3993": "Schönenberger-Gerüst", "4300": "ein Objekt", "4311": "5"} +5;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"4000": "Ja", "4400": "0", "4413": "0", "4401": "0", "4414": "0", "4402": "0", "4419": "0.00", "4403": "0", "4404": "0", "4425": "8", "4426": "0", "4407": "0", "4418": "62.35", "4408": "0", "4420": "0.0", "4409": "0", "4417": "0.0", "4410": "9", "4411": "0", "4421": "0", "4422": "0", "4100": "Ja"} diff --git a/tests/reference/hundm05_tests_export.csv b/tests/reference/hundm05_tests_export.csv index 55c5db7..6eaff99 100644 --- a/tests/reference/hundm05_tests_export.csv +++ b/tests/reference/hundm05_tests_export.csv @@ -5,20 +5,20 @@ Elementnummer;TeileArt;TeileId;Bezeichnung;Planquadrat;Anzahl;Position;Boundingb 4;"ILS 2.0 Strecke";"0004";"VF_4";"H/1-J/4";1;"18465.07, 4300.26, 2119.66";"2518.90, 6404.92, 848.78";"f///EdR0IN4QAAAAAAAAAAAA";"AqAYAC2kAFQk";"AwJzAC2kAFQk";"";"";"0006-L";"0038, 0039, 0040, 0041";"nur ein Partner";"";{"Typ": "Streckengruppe", "Seite_AS": "links", "Seite_ES": "links", "Winkel": "3,3", "VF_Winkel": "0,0,18", "DeltaH_mm": "0", "DeltaL_mm": "1907", "L_VF_m": "0.269,0.458,1.663", "L_GF_m": "4.166,1.658", "Montagehoehe_m": "2.154", "Hoehe_Von_mm": "2154", "Hoehe_Bis_mm": "2154", "Antriebfahrtrichtung": "horizontal,horizontal,Auf", "Anzahl_Separator": "2", "Anzahl_Scanner": "0"} 5;"ILS 2.0 Strecke";"0005";"VF_5";"J/1-K/4";1;"22239.27, 4299.16, 2119.66";"2518.90, 6404.92, 848.78";"f///EdAoIN4QAAAAAAAAAAAA";"AzOGAC2ZAFQk";"A5XhAC2ZAFQk";"";"";"0006-L";"0042, 0043, 0044, 0045";"nur ein Partner";"";{"Typ": "Streckengruppe", "Seite_AS": "links", "Seite_ES": "links", "Winkel": "3,3", "VF_Winkel": "0,0,18", "DeltaH_mm": "0", "DeltaL_mm": "1907", "L_VF_m": "0.269,0.458,1.663", "L_GF_m": "4.166,1.658", "Montagehoehe_m": "2.154", "Hoehe_Von_mm": "2154", "Hoehe_Bis_mm": "2154", "Antriebfahrtrichtung": "horizontal,horizontal,Auf", "Anzahl_Separator": "4", "Anzahl_Scanner": "1"} 6;"ILS 2.0 Kreisel";"0006";"Kreisel1";"A/1-M/1";1;"13594.00, 767.00, 2154.00";"24100.00, 800.00, 1.00";"F49AC7QYIN4QAAAAAAAAAAAA";"";"";"";"";"0005, 0004, 0003, 0002, 0001";"0021, 0022, 0007, 0008, 0024, 0029, 0010, 0030, 0033, 0012, 0034, 0037, 0014, 0038, 0041, 0016, 0042, 0045, 0018, 0020, 0023";"";"";{"Abstand (Kreiselachse A - Kreiselachse) in Meter": "23.3", "Anzahl der Separatoren": "4", "Kreiselart": "STANDARD", "Anzahl der Scanner": "4", "Anzahl der Rampen": "0", "Höhe in m": "2.15", "Drehrichtung": "UZS", "Drehung": 0, "Name": "Kreisel1", "Geruest fuer Einzelmodul": true} -7;"ILS 2.0 Separator";"0007";"Separator :20";"A/1";1;"2414.95, 365.00, 2155.50";"209.90, 150.00, 3.00";"I+84BZHIIN4QAAAAAAAAAAAA";"AFv+AA5CAFQk";"";"";"";"0022, 0008";"";"";"";{"Zuordnung": "0006-R", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 0, "Typ": ""} +7;"ILS 2.0 Separator";"0007";"Separator :20";"A/1";1;"2414.95, 365.00, 2155.50";"209.90, 150.00, 3.00";"I+84BZHIIN4QAAAAAAAAAAAA";"AFv+AA5CAFQk";"";"";"";"0022, 0008";"";"";"";{"Zuordnung": "0001", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 0, "Typ": ""} 8;"ILS 2.0 Separator";"0008";"Separator :19";"B/1";1;"4056.38, 1165.90, 2155.50";"209.90, 150.00, 3.00";"Ps9qEcpMIN4QAAAAAAAAf///";"AKDLAC2LAFQk";"";"";"";"0007, 0024";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} 9;"ILS 2.0 Scanner";"0009";"Scanner :6";"B/1";1;"4095.50, 804.10, 2154.00";"150.00, 280.00, 1.00";"Pn4MEcNEIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0008"} -10;"ILS 2.0 Separator";"0010";"Separator :18";"D/1";1;"8555.49, 1169.50, 2155.50";"209.90, 150.00, 3.00";"f///EdhcIN4QAAAAAAAAf///";"AVCKAC2vAFQk";"";"";"";"0029, 0030";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} -11;"ILS 2.0 Scanner";"0011";"Scanner :5";"D/1";1;"8598.69, 807.70, 2154.00";"150.00, 280.00, 1.00";"f///EdFUIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0010"} +10;"ILS 2.0 Separator";"0010";"Separator :18";"D/1";1;"8555.49, 1169.50, 2155.50";"209.90, 150.00, 3.00";"f///EdhcIN4QAAAAAAAAf///";"AVCKAC2vAFQk";"";"";"";"0029, 0030";"";"";"";{"Zuordnung": "0002", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} +11;"ILS 2.0 Scanner";"0011";"Scanner :5";"D/1";1;"8598.69, 807.70, 2154.00";"150.00, 280.00, 1.00";"f///EdFUIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0002", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0010"} 12;"ILS 2.0 Separator";"0012";"Separator :17";"F/1";1;"12631.71, 1168.20, 2155.50";"209.90, 150.00, 3.00";"f///EdNIIN4QAAAAAAAAf///";"Ae/EAC2iAFQk";"";"";"";"0033, 0034";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} 13;"ILS 2.0 Scanner";"0013";"Scanner :4";"F/1";1;"12669.10, 806.40, 2154.00";"150.00, 280.00, 1.00";"f///EcxAIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0012"} 14;"ILS 2.0 Separator";"0014";"Separator :16";"H/1";1;"16799.72, 1171.70, 2155.50";"209.90, 150.00, 3.00";"f///EeD0IN4QAAAAAAAAf///";"ApKUAC3FAFQk";"";"";"";"0037, 0038";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} 15;"ILS 2.0 Scanner";"0015";"Scanner :3";"H/1";1;"16839.52, 809.80, 2154.00";"150.00, 280.00, 1.00";"f///EdmIIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"Distanz-Zuordnung unsicher: 0006 (3270mm) vs. 0004 (3527mm)";{"Zuordnung": "0006-L", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0014"} 16;"ILS 2.0 Separator";"0016";"Separator :15";"J/1";1;"20577.16, 1166.20, 2155.50";"209.90, 150.00, 3.00";"f///Ect4IN4QAAAAAAAAf///";"AyYjAC2OAFQk";"";"";"";"0041, 0042";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} -17;"ILS 2.0 Scanner";"0017";"Scanner :2";"J/1";1;"20807.70, 804.30, 2154.00";"150.00, 280.00, 1.00";"f///EcQMIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0005", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0016"} +17;"ILS 2.0 Scanner";"0017";"Scanner :2";"J/1";1;"20807.70, 804.30, 2154.00";"150.00, 280.00, 1.00";"f///EcQMIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0016"} 18;"ILS 2.0 Separator";"0018";"Separator :14";"L/1";1;"23678.05, 1170.60, 2155.50";"209.90, 150.00, 3.00";"f///EdyoIN4QAAAAAAAAf///";"A59EAC26AFQk";"";"";"";"0045, 0020";"";"";"";{"Zuordnung": "0005", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} -19;"ILS 2.0 Scanner";"0019";"Scanner :1";"L/1";1;"23780.80, 808.80, 2154.00";"150.00, 280.00, 1.00";"f///EdWgIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0018"} -20;"ILS 2.0 Separator";"0020";"Separator :13";"L/1";1;"24570.15, 1167.20, 2155.50";"209.90, 150.00, 3.00";"f///Ec9gIN4QAAAAAAAAf///";"A8IdAC2YAFQk";"";"";"";"0018, 0023";"";"";"";{"Zuordnung": "0006-L", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} +19;"ILS 2.0 Scanner";"0019";"Scanner :1";"L/1";1;"23780.80, 808.80, 2154.00";"150.00, 280.00, 1.00";"f///EdWgIN4QAAAAAAAApX2I";"";"";"";"";"";"";"";"";{"Zuordnung": "0005", "ARTINR": "829534306", "Höhe": "2154", "Drehung": 270, "Typ": "", "Naechster Separator": "0018"} +20;"ILS 2.0 Separator";"0020";"Separator :13";"L/1";1;"24570.15, 1167.20, 2155.50";"209.90, 150.00, 3.00";"f///Ec9gIN4QAAAAAAAAf///";"A8IdAC2YAFQk";"";"";"";"0018, 0023";"";"";"";{"Zuordnung": "0005", "ARTINR": "200000077", "Höhe": "2154", "Drehung": 180, "Typ": ""} 21;"ILS 2.0 BTMT Beladung";"0021";"BTMT Beladung :2";"B/1-C/1";1;"5532.67, 265.14, 2109.31";"652.35, 408.38, 316.02";"ULuUBaYYIN4QAAAAAAAAf/7S";"AON9AANLAFSv";"AMu/AA6CAFQk";"";"";"0023, 0022";"";"";"";{"ARTINR": "829662012", "Höhe": "2154", "Drehung": 179} 22;"ILS 2.0 BTMT Beladung";"0022";"BTMT Beladung :1";"B/1";1;"4503.25, 269.77, 2109.31";"651.33, 406.70, 316.02";"QQVQBbW4IN4QAAAAAAAAf/8o";"ALtMAAOBAFSv";"AKOGAA6oAFQk";"";"";"0021, 0007";"";"";"";{"ARTINR": "829662012", "Höhe": "2154", "Drehung": 179} 23;"ILS 2.0 BTMT Entladung";"0023";"BTMT Entladung :1";"L/1-M/1";1;"25014.37, 1545.51, 2001.09";"1475.51, 961.98, 467.01";"f///Edt8IN4QAAAAAAAAARVf";"A7q4AC1/AFQk";"A+0BAE7eAEX5";"";"";"0020, 0021";"";"";"";{"ARTINR": "400100156", "Höhe": "2154", "Drehung": 1} diff --git a/tests/reference/hundm05_tests_sivas.csv b/tests/reference/hundm05_tests_sivas.csv index 3ae375d..cb564cb 100644 --- a/tests/reference/hundm05_tests_sivas.csv +++ b/tests/reference/hundm05_tests_sivas.csv @@ -1,9 +1,9 @@ Nr;TeileArt;SivasNummer;Bezeichnung;Dispogruppe;Anzahl;Laenge[mm];IDs;details -1;"ILS 2.0 Kreisel";"6200";"Kreisel12";20;1;;"0006";{"2952": "2.154", "3510": "Kreisel", "3511": "1", "3512": "23.3", "3515": "4", "3517": "4", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} +1;"ILS 2.0 Kreisel";"6200";"Kreisel1";20;1;;"0006";{"2952": "2.154", "3511": "1", "3515": "4", "3517": "4", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel", "3512": "23.3"} 2;"ILS 2.0 Zusatzmodul";"6215";"";20;1;;"0022, 0021, 0023";{"3501": "Ja", "3503": "2", "3502": "Ja", "3504": "1"} -3;"ILS 2.0 Strecke";"6220";"VF_9";20;1;;"0005";{"2950": "2.154", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "4", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "1", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -4;"ILS 2.0 Strecke";"6220";"VF_8";20;1;;"0004";{"2950": "2.154", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -5;"ILS 2.0 Strecke";"6220";"VF_7";20;1;;"0003";{"2950": "2.154", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -6;"ILS 2.0 Strecke";"6220";"VF_6";20;1;;"0002";{"2950": "2.154", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "3", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "1", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -7;"ILS 2.0 Strecke";"6220";"VF_5";20;1;;"0001";{"2950": "2.154", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.727", "4391": "3", "4314": "Ja", "4319": "0.201", "4392": "3", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "2", "4353": "3.704", "4354": "horizontal", "4386": "0", "4373": "0", "4374": "0", "4375": "1", "4376": "2", "4377": "0", "4378": "1", "4381": "5", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} +3;"ILS 2.0 Strecke";"6220";"VF_5";20;1;;"0005";{"2950": "2.154", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "4", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "1", "3992": "Ja", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4433": "1.800", "4434": "1.800", "4435": "2.071"} +4;"ILS 2.0 Strecke";"6220";"VF_4";20;1;;"0004";{"2950": "2.154", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4433": "1.800", "4434": "1.800", "4435": "2.071"} +5;"ILS 2.0 Strecke";"6220";"VF_3";20;1;;"0003";{"2950": "2.154", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4433": "1.800", "4434": "1.800", "4435": "2.071"} +6;"ILS 2.0 Strecke";"6220";"VF_2";20;1;;"0002";{"2950": "2.154", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "3", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "1", "3992": "Ja", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4433": "1.800", "4434": "1.800", "4435": "2.071"} +7;"ILS 2.0 Strecke";"6220";"VF_1";20;1;;"0001";{"2950": "2.154", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "1", "4376": "2", "4377": "0", "4378": "1", "4381": "5", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "0.727", "4391": "3", "4314": "Ja", "4319": "0.201", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "2", "4353": "3.704", "4354": "horizontal", "4386": "0", "4433": "1.980", "4434": "1.980", "4435": "1.875", "4436": "2.076", "4437": "2.282"} 8;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"4000": "Ja", "4400": "1", "4413": "4", "4401": "0", "4414": "0", "4402": "0", "4419": "23.30", "4403": "0", "4404": "0", "4425": "0", "4426": "0", "4407": "5", "4418": "0.00", "4408": "17", "4420": "0.0", "4409": "0", "4417": "0.0", "4410": "20", "4411": "6", "4421": "2", "4422": "1", "4100": "Ja"} diff --git a/tests/reference/kreisel_results.json b/tests/reference/kreisel_results.json index d3b91d4..4e83daf 100644 --- a/tests/reference/kreisel_results.json +++ b/tests/reference/kreisel_results.json @@ -3,7 +3,7 @@ "test_id": "KR_Kreuz_Q1_0Grad", "status": "executed", "block_name": "KREISEL_1_STANDARD_2000", - "block_handle": "13A", + "block_handle": "186", "insert_point": [500, 500, 2500], "actual_attributes": { "ID": "0001", @@ -28,7 +28,7 @@ "test_id": "KR_Kreuz_Q2_90Grad", "status": "executed", "block_name": "KREISEL_2_STANDARD_3000", - "block_handle": "187", + "block_handle": "1D7", "insert_point": [-500, 500, 2500], "actual_attributes": { "ID": "0002", @@ -53,7 +53,7 @@ "test_id": "KR_Kreuz_Q3_180Grad", "status": "executed", "block_name": "KREISEL_3_STANDARD_4000", - "block_handle": "1D3", + "block_handle": "227", "insert_point": [-500, -500, 2500], "actual_attributes": { "ID": "0003", @@ -78,7 +78,7 @@ "test_id": "KR_Kreuz_Q4_270Grad", "status": "executed", "block_name": "KREISEL_4_STANDARD_5000", - "block_handle": "21F", + "block_handle": "277", "insert_point": [500, -500, 2500], "actual_attributes": { "ID": "0004", @@ -103,7 +103,7 @@ "test_id": "KR_Schraeg_Q1_30Grad", "status": "executed", "block_name": "KREISEL_5_STANDARD_3000", - "block_handle": "26B", + "block_handle": "2C7", "insert_point": [3000, 3000, 3000], "actual_attributes": { "ID": "0005", @@ -128,7 +128,7 @@ "test_id": "KR_Pin_Q1_0Grad", "status": "executed", "block_name": "KREISEL_6_PIN_3000", - "block_handle": "2BC", + "block_handle": "31C", "insert_point": [500, 6000, 1500], "actual_attributes": { "ID": "0006", @@ -153,7 +153,7 @@ "test_id": "KR_Pin_Q1_90Grad", "status": "executed", "block_name": "KREISEL_7_PIN_4000", - "block_handle": "30C", + "block_handle": "370", "insert_point": [-500, 6500, 1500], "actual_attributes": { "ID": "0007", @@ -178,7 +178,7 @@ "test_id": "KR_Pin_Q1_30Grad_Schraeg", "status": "executed", "block_name": "KREISEL_8_PIN_3000", - "block_handle": "35C", + "block_handle": "3C4", "insert_point": [3000, 8000, 1500], "actual_attributes": { "ID": "0008", diff --git a/tests/reference/kreisel_tests_sivas.csv b/tests/reference/kreisel_tests_sivas.csv index b1f0eb4..21ce73a 100644 --- a/tests/reference/kreisel_tests_sivas.csv +++ b/tests/reference/kreisel_tests_sivas.csv @@ -1,8 +1,9 @@ Nr;TeileArt;SivasNummer;Bezeichnung;Dispogruppe;Anzahl;Laenge[mm];IDs;details -1;"ILS 2.0 Kreisel";"6200";"Kreisel8, Kreisel6";20;2;;"0008, 0006";{"2952": "1.5", "3510": "Kreisel mit PINBAND", "3511": "1", "3512": "3.0", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -2;"ILS 2.0 Kreisel";"6200";"Kreisel7";20;1;;"0007";{"2952": "1.5", "3510": "Kreisel mit PINBAND", "3511": "1", "3512": "4.0", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -3;"ILS 2.0 Kreisel";"6200";"Kreisel5, Kreisel2";20;2;;"0005, 0002";{"2952": "3", "3510": "Kreisel", "3511": "1", "3512": "3.0", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -4;"ILS 2.0 Kreisel";"6200";"Kreisel4";20;1;;"0004";{"2952": "2.5", "3510": "Kreisel", "3511": "1", "3512": "5.0", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -5;"ILS 2.0 Kreisel";"6200";"Kreisel3";20;1;;"0003";{"2952": "2.5", "3510": "Kreisel", "3511": "1", "3512": "4.0", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -6;"ILS 2.0 Kreisel";"6200";"Kreisel1";20;1;;"0001";{"2952": "2.5", "3510": "Kreisel", "3511": "1", "3512": "2.0", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst"} -7;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"4000": "Ja", "4400": "8", "4413": "0", "4401": "3", "4414": "0", "4402": "0", "4419": "27.00", "4403": "0", "4404": "0", "4425": "0", "4426": "0", "4407": "0", "4418": "0.00", "4408": "0", "4420": "0.0", "4409": "0", "4417": "0.0", "4410": "0", "4411": "0", "4421": "0", "4422": "0", "4100": "Ja"} +1;"ILS 2.0 Kreisel";"6200";"Kreisel8, Kreisel6";20;2;;"0008, 0006";{"2952": "1.5", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel mit PINBAND", "3512": "3.0"} +2;"ILS 2.0 Kreisel";"6200";"Kreisel7";20;1;;"0007";{"2952": "1.5", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel mit PINBAND", "3512": "4.0"} +3;"ILS 2.0 Kreisel";"6200";"Kreisel5";20;1;;"0005";{"2952": "3", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel", "3512": "3.0"} +4;"ILS 2.0 Kreisel";"6200";"Kreisel4";20;1;;"0004";{"2952": "2.5", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel", "3512": "5.0"} +5;"ILS 2.0 Kreisel";"6200";"Kreisel3";20;1;;"0003";{"2952": "2.5", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel", "3512": "4.0"} +6;"ILS 2.0 Kreisel";"6200";"Kreisel2";20;1;;"0002";{"2952": "2.5", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel", "3512": "3.0"} +7;"ILS 2.0 Kreisel";"6200";"Kreisel1";20;1;;"0001";{"2952": "2.5", "3511": "1", "3515": "0", "3517": "0", "3519": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "3510": "Kreisel", "3512": "2.0"} +8;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"4000": "Ja", "4400": "8", "4413": "0", "4401": "3", "4414": "0", "4402": "0", "4419": "27.00", "4403": "0", "4404": "0", "4425": "0", "4426": "0", "4407": "0", "4418": "0.00", "4408": "0", "4420": "0.0", "4409": "0", "4417": "0.0", "4410": "0", "4411": "0", "4421": "0", "4422": "0", "4100": "Ja"} diff --git a/tests/reference/linienzug_results.json b/tests/reference/linienzug_results.json index 17e4db5..a218203 100644 --- a/tests/reference/linienzug_results.json +++ b/tests/reference/linienzug_results.json @@ -2,7 +2,7 @@ { "test_id": "LZ_Standard", "status": "OK", - "schritte_gesamt": 37, + "schritte_gesamt": 34, "schritte_offen": 0 } ] diff --git a/tests/reference/linienzug_tests_sivas.csv b/tests/reference/linienzug_tests_sivas.csv index e67527a..c51126c 100644 --- a/tests/reference/linienzug_tests_sivas.csv +++ b/tests/reference/linienzug_tests_sivas.csv @@ -1,3 +1,3 @@ Nr;TeileArt;SivasNummer;Bezeichnung;Dispogruppe;Anzahl;Laenge[mm];IDs;details -1;"ILS 2.0 Strecke";"6220";"VF_1";20;1;;"0001";{"Anlagenhöhe in Meter": "2.154", "Streckengruppe": "mehrere Objekte", "Strecken- zu fertigende Menge": "1", "Streckengruppe - Gefällestrecke": "Ja", "Streckengruppe - Gefällestrecke 001-Länge in Meter": "4.166", "Streckengruppe - Gefällestrecke 001 -Winkel": "3", "Streckengruppe - Gefällestrecke 002": "Ja", "Streckengruppe - Gefällestrecke 002-Länge in Meter": "1.658", "Streckengruppe - Gefällestrecke 002- Winkel": "3", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke links 30°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 90°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 60°": "0", "Streckengruppe - Anzahl der Kurven - Gefällestrecke rechts 30°": "0", "Streckengruppe - Anzahl der Separatoren - Gefällestrecke": "0", "Streckengruppe - Bearbeitung Gefällestreckenteilstück für Separator (829516050)": "ohne HARTCOAT HRC 50 ± 5", "Streckengruppe - Anzahl der Scanner": "0", "Streckengruppe - Varioförderer": "Ja", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (links)": "0", "Streckengruppe - Anzahl der Motoren für Vario-Förderer (rechts)": "1", "Streckengruppe - Varioförderer 001-Länge in Meter": "0.269", "Streckengruppe - Varioförderer 001-Richtung": "horizontal", "Streckengruppe - Varioförderer 001- Winkel": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 90°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Außenbogen 30°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 90°": "2", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 60°": "0", "Streckengruppe - Anzahl der Kurven - Varioförderer Innenbogen 30°": "0", "Streckengruppe - Anzahl der Separatoren - Varioförderer": "2", "Gerüst für Einzelmodul": "Ja", "Gerüstoption für Einzelmodul": "Schönenberger-Gerüst"} -2;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"Automation": "Ja", "Anzahl der Kreisel": "0", "Anzahl der Separatoren - Kreisel ohne PINBAND": "0", "Anzahl der Kreisel mit PINBAND": "0", "Anzahl der Separatoren - Kreisel mit PINBAND": "0", "Anzahl der Verbindungskreisel": "0", "Längen aller Kreisel": "0.00", "Anzahl der Weichen": "0", "Anzahl der Eckräder": "0", "Anzahl der einzelnen Gefällestrecken": "0", "Anzahl der einzelnen Vario-Förderer": "0", "Anzahl der Streckengruppen": "1", "Längen aller Gefällestrecken": "0.00", "Anzahl der Motoren in Vario - Förderer": "3", "Längen aller Vario - Förderer": "0.0", "Anzahl der ETFs": "0", "Längen aller ETFS und Zusatzstücke (Gefällestrecken)": "0.0", "Anzahl der Separatoren in der Anlage": "2", "Anzahl der Scanner in der Anlage": "0", "Zusatzmodul - Anzahl der BT-Beladung": "0", "Zusatzmodul - Anzahl der Abwurfstation": "0", "Pneumatik": "Ja"} +1;"ILS 2.0 Strecke";"6220";"VF_1";20;1;;"0001";{"2950": "2.154", "4431": "Ja", "4427": "90 °", "4428": "links", "4432": "Ja", "4429": "90 °", "4430": "links", "4329": "0", "4330": "0", "4331": "0", "4332": "0", "4333": "0", "4334": "0", "4373": "0", "4374": "0", "4375": "0", "4376": "2", "4377": "0", "4378": "0", "4381": "2", "4382": "ohne HARTCOAT HRC 50 ± 5", "4383": "0", "3992": "Ja", "3993": "Schönenberger-Gerüst", "4300": "mehrere Objekte", "4311": "1", "4312": "Ja", "4318": "4.166", "4391": "3", "4314": "Ja", "4319": "1.658", "4392": "3", "4337": "0", "4338": "ohne HARTCOAT HRC 50 ± 5", "4339": "0", "4340": "Ja", "4341": "0", "4342": "1", "4353": "0.269", "4354": "horizontal", "4386": "0", "4433": "1.800", "4434": "1.800", "4435": "2.071"} +2;"ILS 2.0 Automation und Pneumatik - Gesamtanlage";"6269";"";20;1;;"";{"4000": "Ja", "4400": "0", "4413": "0", "4401": "0", "4414": "0", "4402": "0", "4419": "0.00", "4403": "0", "4404": "0", "4425": "0", "4426": "0", "4407": "1", "4418": "0.00", "4408": "3", "4420": "0.0", "4409": "0", "4417": "0.0", "4410": "2", "4411": "0", "4421": "0", "4422": "0", "4100": "Ja"}