refactor: Kettenfoerderer als Seitenansicht mit Beschriftung und Hoehenmass, Draufsicht als eigener Hilfsblock KF2D_n
- Hauptblock KF_n: flache, ungedrehte Seitenansicht mit Beschriftung und Hoehenmass; nur er wird exportiert - Draufsicht KF_2D als getrennter Hilfsblock KF2D_n (projizierte Laenge, frei verschiebbar, per KF_EDIT regenerierbar), Verknuepfung ueber XDATA-Schluessel - L_KF_mm = waagerechte Laenge, Sivas-Zeile ohne Laenge, Export nur KF_<Ziffern> - ensure-block-loaded: Block ohne ILS-Datei (KF_2D) nicht mehr als fehlend melden - Layer kettenfoerderer_beschriftung, Dispatcher-Zweig KF2D_*, Sprachdateien und Unit-Tests angepasst Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
+347
-248
@@ -26,6 +26,14 @@
|
||||
;; insert-block-by-ks/insert-block-ks-skaliert, die Rz*Ry-Primitiven des
|
||||
;; VarioFoerderers werden hier nicht gebraucht.
|
||||
;;
|
||||
;; HAUPT- UND HILFSBLOCK: KF_<n> ist die Seitenansicht (ungedreht, Einfuege-
|
||||
;; punkt = KS_EIN der Umlenkung) mit Beschriftung und Hoehenmass; nur dieser
|
||||
;; Block wird exportiert. Die Draufsicht KF_2D ist ein getrennter Hilfsblock
|
||||
;; KF2D_<n> (zum Anschliessen von Schienen), der aus der projizierten Laenge
|
||||
;; entsteht, beim ersten Mal 1000 mm unter dem Hauptblock liegt, frei
|
||||
;; verschiebbar und loeschbar ist und per Doppelklick auf KF_<n> neu erzeugt
|
||||
;; wird. Beide tragen denselben Schluessel in der XDATA (SSG_KF_EDIT).
|
||||
;;
|
||||
;; Die Einbauhoehe H (Abstand KS_EIN der Umlenkung bis KS_AUS des Antriebs auf
|
||||
;; der Y-Achse) bestimmt die Laenge des Zwischenstuecks ueber die
|
||||
;; Hoehenbilanz, siehe kf-laenge-berechnen.
|
||||
@@ -223,7 +231,8 @@
|
||||
;; STANDARD_STEUERUNG - Merkmal 361, "1"/"0" ueber Transform ja_nein.
|
||||
;; Steht direkt hinter WINKEL, wie im Merkmalstamm.
|
||||
;; H_EINBAUHOEHE_mm - Merkmal 360
|
||||
;; L_KF_mm - Laenge des skalierten Zwischenstuecks, CSV-Spalte
|
||||
;; L_KF_mm - WAAGERECHTE Laenge des ganzen Foerderers (der Draufsicht
|
||||
;; KF_2D), CSV-Spalte "Laenge"
|
||||
;; FARBE - Merkmal 354
|
||||
;; ANTRIEBSMOTOR - Merkmal 355 (eigenes Merkmal, nicht Teil von 354)
|
||||
;; ANTRIEBSART - Merkmal 357, FEST "1.1 kW" (Wert aus der JSON,
|
||||
@@ -327,27 +336,6 @@
|
||||
(if (and (null treffer) (findfile k)) (setq treffer (findfile k))))
|
||||
treffer)
|
||||
|
||||
;; ============================================================
|
||||
;; AUFRICHTUNG: die Baugruppe steht im Modell
|
||||
;; ============================================================
|
||||
;; Die Bausteine sind in der XY-Ebene gezeichnet (X = Fahrtrichtung,
|
||||
;; Y = Hoehe) - eine Seitenansicht. Eingebaut werden sie AUFGERICHTET: um
|
||||
;; 90 Grad um die Fahrtrichtungsachse gekippt, sodass die Hoehe nach Z
|
||||
;; wandert. Von oben sieht man dann die Draufsicht KF_2D, von der Seite die
|
||||
;; Kette; beide bilden EIN Objekt ohne Versatz.
|
||||
;;
|
||||
;; Gesamtdrehung je Baustein: Rz(basis) * Rx(90) * Rz(eigen)
|
||||
;; Rz(eigen) richtet den Baustein in seiner EIGENEN Zeichenebene aus
|
||||
;; (der aus den KS gemessene Verkettungswinkel, s. kf-hz-folge)
|
||||
;; Rx(90) richtet die Ebene auf - Y_lokal wird zu Z_welt
|
||||
;; Rz(basis) dreht die fertige Baugruppe in der Draufsicht
|
||||
;; Die Reihenfolge ist nicht beliebig: Rz(eigen) muss VOR dem Aufrichten
|
||||
;; wirken (es ist eine Drehung in der Blockebene), Rz(basis) danach (es ist
|
||||
;; eine Drehung im Modell).
|
||||
(defun kf-matrix-aufrecht (basis-hz eigen-hz)
|
||||
(mat3-mul-mat3 (ks-rot-z basis-hz)
|
||||
(mat3-mul-mat3 (ks-rot-x 90.0) (ks-rot-z eigen-hz))))
|
||||
|
||||
;; ============================================================
|
||||
;; GEOMETRIE EINER VARIANTE MESSEN
|
||||
;; ============================================================
|
||||
@@ -433,156 +421,261 @@
|
||||
(list laenge skala nil)))))))
|
||||
|
||||
;; ============================================================
|
||||
;; KETTE BAUEN (aufgerichtet, 3D)
|
||||
;; KETTE BAUEN (Seitenansicht)
|
||||
;; ============================================================
|
||||
;; Fuegt die drei Bausteine ab startpunkt verkettet ein - AUFGERICHTET, die
|
||||
;; Hoehe laeuft also in Z (siehe kf-matrix-aufrecht). basis-hz dreht die
|
||||
;; fertige Baugruppe in der Draufsicht.
|
||||
;; Fuegt die drei Bausteine ab startpunkt verkettet ein. Die Kette ist eine
|
||||
;; SEITENANSICHT: sie liegt flach in der XY-Ebene (X = Fahrtrichtung,
|
||||
;; Y = Hoehe), so wie die Bausteine gezeichnet sind. Es wird nichts
|
||||
;; aufgerichtet und nichts gedreht; jeder Baustein bekommt nur den aus den KS
|
||||
;; gemessenen Verkettungswinkel (kf-hz-folge).
|
||||
;; (Zwischenzeitlich wurde die Kette aufgerichtet in Z eingebaut - nach
|
||||
;; Abstimmung wieder zurueckgenommen; die Draufsicht ist jetzt ein EIGENER
|
||||
;; Hilfsblock, siehe kf-hilfsblock-bauen.)
|
||||
;; Rueckgabe: Weltpunkt des KS_AUS der Antriebsstation (Kettenende).
|
||||
(defun kf-kette-bauen (variante geo skala startpunkt basis-hz / pt)
|
||||
(defun kf-kette-bauen (variante geo skala startpunkt / pt)
|
||||
(setq pt startpunkt)
|
||||
(setq pt (insert-block-ks-matrix
|
||||
(ssg-json-get variante "block_umlenkung")
|
||||
pt
|
||||
(kf-matrix-aufrecht basis-hz (cdr (assoc "hz-um" geo)))
|
||||
1.0))
|
||||
(setq pt (insert-block-ks-matrix
|
||||
(ssg-json-get variante "block_laenge")
|
||||
pt
|
||||
(kf-matrix-aufrecht basis-hz (cdr (assoc "hz-l" geo)))
|
||||
skala))
|
||||
(setq pt (insert-block-ks-matrix
|
||||
(ssg-json-get variante "block_antrieb")
|
||||
pt
|
||||
(kf-matrix-aufrecht basis-hz (cdr (assoc "hz-an" geo)))
|
||||
1.0))
|
||||
(setq pt (insert-block-by-ks
|
||||
(ssg-json-get variante "block_umlenkung") pt
|
||||
(cdr (assoc "hz-um" geo))))
|
||||
(setq pt (insert-block-ks-skaliert
|
||||
(ssg-json-get variante "block_laenge") pt
|
||||
(cdr (assoc "hz-l" geo)) skala))
|
||||
(setq pt (insert-block-by-ks
|
||||
(ssg-json-get variante "block_antrieb") pt
|
||||
(cdr (assoc "hz-an" geo))))
|
||||
pt)
|
||||
|
||||
;; ------------------------------------------------------------
|
||||
;; DRAUFSICHT (KF_2D) - deckungsgleich mit der Kette
|
||||
;; MASSE AUS START- UND ENDPUNKT (reine Rechenkerne)
|
||||
;; ------------------------------------------------------------
|
||||
;; KF_2D gehoert in DIESELBE Lage wie die Kette, nicht daneben: sein KS_EIN
|
||||
;; faellt mit KS_EIN der Umlenkung zusammen, sein KS_AUS mit KS_AUS des
|
||||
;; Antriebs. Dadurch ist die Baugruppe EIN Koerper - von oben sieht man die
|
||||
;; Draufsicht, von der Seite die Kette.
|
||||
;;
|
||||
;; Zwischenzeitlich lagen beide Ansichten 1000 mm uebereinander (versatz_y).
|
||||
;; Das war eine Hilfskonstruktion, solange die Kette flach in der XY-Ebene
|
||||
;; lag; seit sie aufgerichtet eingebaut wird, ist sie unnoetig.
|
||||
;;
|
||||
;; KF_2D ist selbst flach gezeichnet und wird darum NICHT aufgerichtet,
|
||||
;; sondern nur um die Steigung GENEIGT (Rz(basis) * Ry(-winkel)) und auf die
|
||||
;; SCHRAEGLAENGE skaliert. In der Draufsicht erscheint es dadurch genau mit
|
||||
;; der Grundrisslaenge - die Verkuerzung uebernimmt die Projektion, sie muss
|
||||
;; nicht gerechnet werden.
|
||||
|
||||
;; Neigungswinkel und Schraeglaenge aus Start- und Endpunkt der Kette.
|
||||
;; Rueckgabe: (schraeglaenge winkel-grad), oder nil bei Laenge 0.
|
||||
;; Reiner Rechenkern - der eigentliche Pruefpunkt der 3D-Umstellung.
|
||||
(defun kf-neigung-aus-punkten (p1 p2 basis-hz / rad dx dy dz horiz laenge)
|
||||
;; Horizontalanteil von p1 nach p2, auf die Kettenrichtung (basis-hz, Grad)
|
||||
;; projiziert und nicht die blosse X-Differenz - sonst stimmt es bei einem von
|
||||
;; Hand gedrehten Block nicht. Die Hoehe (Y) geht NICHT ein.
|
||||
(defun kf-horiz-projektion (p1 p2 basis-hz / rad dx dy)
|
||||
(setq rad (* (float basis-hz) (/ pi 180.0)))
|
||||
(setq dx (- (car p2) (car p1))
|
||||
dy (- (cadr p2) (cadr p1))
|
||||
dz (- (cond ((caddr p2)) (0.0)) (cond ((caddr p1)) (0.0))))
|
||||
;; Horizontalanteil auf die Kettenrichtung projiziert (nicht die blosse
|
||||
;; X-Differenz) - sonst stimmt es bei gedreht eingefuegter Kette nicht.
|
||||
(setq horiz (+ (* dx (cos rad)) (* dy (sin rad))))
|
||||
(setq laenge (sqrt (+ (* horiz horiz) (* dz dz))))
|
||||
(if (< laenge 1e-6)
|
||||
nil
|
||||
(list laenge (/ (* 180.0 (atan dz horiz)) pi))))
|
||||
dy (- (cadr p2) (cadr p1)))
|
||||
(+ (* dx (cos rad)) (* dy (sin rad))))
|
||||
|
||||
;; Draufsicht einfuegen - deckungsgleich mit der Kette.
|
||||
;; kette-start/kette-ende = KS_EIN der Umlenkung bzw. KS_AUS des Antriebs.
|
||||
;; Rueckgabe: die verwendete Schraeglaenge (mm), sonst nil.
|
||||
(defun kf-ansicht-2d-bauen (daten kette-start kette-ende basis-hz /
|
||||
cfg bname masse laenge winkel ks ein-dx skala R)
|
||||
;; WAAGERECHTE (projizierte) Laenge der Kette = Laenge der Draufsicht KF_2D.
|
||||
;; Das ist der Wert im Attribut L_KF_mm. Immer positiv.
|
||||
(defun kf-waagerecht-laenge (p1 p2 basis-hz)
|
||||
(abs (kf-horiz-projektion p1 p2 basis-hz)))
|
||||
|
||||
;; Neigungswinkel der Variante als nackte Ganzzahl ("26"/"30"), bewusst ueber
|
||||
;; itoa/fix statt rtos: rtos haengt an DIMZIN/LUPREC/LUNITS der Zeichnung. Der
|
||||
;; Wert steht im Attribut WINKEL und ist Schluessel der Tabelle
|
||||
;; [kf_typ_anzeige] im Sivas-Export - er muss profilunabhaengig sein.
|
||||
(defun kf-winkel-text (variante)
|
||||
(itoa (fix (+ 0.5 (cond ((kf-zahl (ssg-json-get variante "winkel"))) (0.0))))))
|
||||
|
||||
;; Punkt um versatz-y in Y verschoben (Z bleibt, fehlendes Z = 0).
|
||||
(defun kf-versatzpunkt (p versatz-y)
|
||||
(list (car p) (+ (cadr p) (float versatz-y)) (cond ((caddr p)) (0.0))))
|
||||
|
||||
;; Versatz des Hilfsblocks (Draufsicht) gegen den Hauptblock beim ERSTEN
|
||||
;; Einfuegen, in mm (Y). Steht in der JSON, nicht im Code; Vorgabe -1000.
|
||||
;; (Pruefung ueber if, nicht ueber and/or: and liefert T statt der Zahl.)
|
||||
(defun kf-hilfsblock-versatz (daten / cfg wert)
|
||||
(setq cfg (ssg-json-get daten "ansicht_2d"))
|
||||
(setq bname (if cfg (ssg-json-get cfg "block")))
|
||||
(if (or (null bname) (= bname ""))
|
||||
nil
|
||||
(setq wert (if cfg (kf-zahl (ssg-json-get cfg "versatz_y"))))
|
||||
(cond (wert) (-1000.0)))
|
||||
|
||||
;; ------------------------------------------------------------
|
||||
;; BESCHRIFTUNG UND HOEHENMASS
|
||||
;; ------------------------------------------------------------
|
||||
;; Beschriftung wie bei VF_/GF_ (gf-make-label): ein TEXT, Hoehe 100, auf
|
||||
;; einem eigenen Layer aus cfg/layer.cfg. Haupt- und Hilfsblock tragen
|
||||
;; dieselbe Zeile: "KF_1 26 Grad-Zeichen H=1500mm L_horizontal=4951mm".
|
||||
(defun kf-label-text (nummer winkel-str hoehe waagerecht)
|
||||
(strcat "KF_" (itoa nummer) " " winkel-str (chr 176)
|
||||
" H=" (itoa (fix (+ 0.5 (float hoehe)))) "mm"
|
||||
" L_horizontal=" (itoa (fix (+ 0.5 (float waagerecht)))) "mm"))
|
||||
|
||||
;; Layer der Beschriftung (Baugruppe "kettenfoerderer_beschriftung" in
|
||||
;; cfg/layer.cfg), sonst Hartwert - wie bei GF_/VF_.
|
||||
(defun kf-beschriftungs-layer ( / lay)
|
||||
(setq lay (ssg-layer-anlegen "kettenfoerderer_beschriftung" nil))
|
||||
(if (null lay)
|
||||
(progn
|
||||
(setq masse (kf-neigung-aus-punkten kette-start kette-ende basis-hz))
|
||||
(if (null masse)
|
||||
(progn (princ (ssg-text "kf-2d-laenge-null")) nil)
|
||||
(setq lay "KF_Beschriftung")
|
||||
(ssg-make-layer lay "7" nil)))
|
||||
lay)
|
||||
|
||||
(defun kf-label-zeichnen (txt pt lay)
|
||||
(entmake
|
||||
(list '(0 . "TEXT")
|
||||
(cons 10 pt)
|
||||
(cons 11 pt)
|
||||
'(40 . 100.0)
|
||||
(cons 1 txt)
|
||||
'(7 . "Standard")
|
||||
(cons 8 lay)
|
||||
'(72 . 1)
|
||||
'(73 . 2)))
|
||||
(princ))
|
||||
|
||||
;; Senkrechtes Hoehenmass zwischen p-unten und p-oben, rechts neben dem
|
||||
;; Kettenende. Echtes DIMENSION-Objekt per ActiveX (AddDimRotated, 90 Grad) -
|
||||
;; kein Befehlsaufruf, der bei einem Fehler im Befehl haengen bleiben koennte.
|
||||
;; Jeder Schritt laeuft unter vl-catch-all-apply: scheitert das Mass, geht der
|
||||
;; Bau OHNE Mass weiter und meldet es (Hinweis, kein Abbruch). Textgroesse und
|
||||
;; Pfeile werden gesetzt, damit das Mass neben der 100-mm-Beschriftung lesbar
|
||||
;; ist; fehlt eine Eigenschaft, bleibt der Wert der Bemassungsvariablen.
|
||||
(defun kf-hoehenmass-zeichnen (p-unten p-oben lay / obj)
|
||||
(setq obj (vl-catch-all-apply 'vla-AddDimRotated
|
||||
(list modelspace
|
||||
(vlax-3d-point p-unten)
|
||||
(vlax-3d-point p-oben)
|
||||
(vlax-3d-point (list (+ (car p-oben) 400.0)
|
||||
(/ (+ (cadr p-unten) (cadr p-oben)) 2.0)
|
||||
(caddr p-oben)))
|
||||
(/ pi 2.0))))
|
||||
(if (vl-catch-all-error-p obj)
|
||||
(progn (princ (ssg-text "kf-bemassung-fehlt")) nil)
|
||||
(progn
|
||||
(setq laenge (car masse) winkel (cadr masse))
|
||||
(if (null (kf-block-laden bname))
|
||||
(progn (princ (ssg-textf "kf-fehler-block-datei" (list bname))) nil)
|
||||
(foreach prop (list (list 'vla-put-TextHeight 100.0)
|
||||
(list 'vla-put-ArrowheadSize 50.0)
|
||||
(list 'vla-put-PrimaryUnitsPrecision 0)
|
||||
(list 'vla-put-Layer lay))
|
||||
(vl-catch-all-apply (car prop) (cons obj (cdr prop))))
|
||||
T)))
|
||||
|
||||
;; Alles seit last-ent Entstandene als Auswahlsatz (fuer _.-BLOCK).
|
||||
(defun kf-sammeln (last-ent / ss ent)
|
||||
(setq ss (ssadd))
|
||||
(setq ent (if last-ent (entnext last-ent) (entnext)))
|
||||
(while ent
|
||||
(ssadd ent ss)
|
||||
(setq ent (entnext ent)))
|
||||
ss)
|
||||
|
||||
;; Referenz um rot-rad (Bogenmass) um ihren Einfuegepunkt drehen. Der Block
|
||||
;; wird immer ungedreht gebaut (ssg-block-wrap-welt fuegt mit Drehung 0 ein);
|
||||
;; eine von Hand vorgenommene Drehung wird so beim Neuaufbau wieder aufgesetzt.
|
||||
(defun kf-rotation-setzen (ent rot-rad / ed)
|
||||
(if (and ent rot-rad (/= rot-rad 0.0))
|
||||
(progn
|
||||
(setq ks (ks-block-messen bname))
|
||||
(setq ein-dx (car (cond ((ks-versatz ks)) ('(0.0 0.0 0.0)))))
|
||||
(setq skala (kf-skala-berechnen laenge ein-dx))
|
||||
(if (null skala)
|
||||
(progn (princ (ssg-textf "kf-2d-ks-fehlt" (list bname))) nil)
|
||||
(progn
|
||||
;; Ry(-winkel) hebt die flache Scheibe um die Steigung an;
|
||||
;; das Vorzeichen folgt der Rechte-Hand-Regel (positives dz
|
||||
;; = Drehung gegen den Uhrzeigersinn um die Y-Achse).
|
||||
(setq R (mat3-mul-mat3 (ks-rot-z basis-hz)
|
||||
(ks-rot-y (- winkel))))
|
||||
(insert-block-ks-matrix bname kette-start R skala)
|
||||
(princ (ssg-textf "kf-2d-gebaut"
|
||||
(list bname (rtos laenge 2 0) (rtos winkel 2 1))))
|
||||
laenge)))))))))
|
||||
(setq ed (entget ent))
|
||||
(if (assoc 50 ed)
|
||||
(entmod (subst (cons 50 rot-rad) (assoc 50 ed) ed)))))
|
||||
ent)
|
||||
|
||||
;; ============================================================
|
||||
;; DREHWINKEL DES BLOCKS (XDATA)
|
||||
;; SCHLUESSEL ZWISCHEN HAUPT- UND HILFSBLOCK (XDATA)
|
||||
;; ============================================================
|
||||
;; Der Drehwinkel der Baugruppe wird beim Bau in die GEOMETRIE eingerechnet
|
||||
;; (kf-matrix-aufrecht), nicht ueber die Drehung der Blockreferenz:
|
||||
;; ssg-block-wrap-welt fuegt den fertigen Block immer mit Drehung 0 ein. Die
|
||||
;; Referenz traegt damit nirgends mehr, wie die Kette gedreht wurde - KF_EDIT
|
||||
;; wuerde sie beim Neuaufbau ungedreht neu bauen. Darum steht der Winkel als
|
||||
;; XDATA am Block (Projektregel: Editierdaten gehoeren in XDATA, nicht in
|
||||
;; .dbg). Eine spaetere Drehung der Referenz von Hand kommt ueber
|
||||
;; Gruppencode 50 hinzu und wird addiert.
|
||||
;; Haupt- (KF_<n>) und Hilfsblock (KF2D_<n>) tragen denselben Schluessel als
|
||||
;; XDATA. Der Name taugt dafuer nicht: die Nummer wechselt bei JEDEM Neuaufbau
|
||||
;; (KF_EDIT vergibt eine neue). Mit dem Schluessel findet KF_EDIT den
|
||||
;; Hilfsblock auch dann, wenn der Benutzer ihn verschoben hat, und erzeugt ihn
|
||||
;; an seiner jetzigen Stelle neu (Projektregel: Editierdaten gehoeren in
|
||||
;; XDATA, nicht in .dbg).
|
||||
(setq *kf-xdata-app* "SSG_KF_EDIT")
|
||||
|
||||
;; Gesamtdrehung = gebauter Winkel (XDATA, Grad) + Drehung der Referenz
|
||||
;; (Gruppencode 50, Bogenmass), auf -180..180 Grad normalisiert. Reiner
|
||||
;; Rechenkern; fehlende Werte zaehlen als 0 (Altbestand ohne XDATA).
|
||||
(defun kf-drehung-gesamt (xdata-grad dxf50-rad / g r)
|
||||
(setq g (cond (xdata-grad (float xdata-grad)) (0.0)))
|
||||
(setq r (cond (dxf50-rad (float dxf50-rad)) (0.0)))
|
||||
(ks-winkel-normalisieren (+ g (/ (* 180.0 r) pi))))
|
||||
(defun kf-neuer-key () (ssg-timestamp))
|
||||
|
||||
(defun kf-xdata-schreiben (ent drehung-grad / eintrag)
|
||||
(defun kf-xdata-schreiben (ent key / eintrag)
|
||||
(regapp *kf-xdata-app*)
|
||||
(setq eintrag (list *kf-xdata-app*
|
||||
(cons 1000 "kf-edit")
|
||||
(cons 1040 (float drehung-grad))))
|
||||
(cons 1000 key)))
|
||||
(entmod (append (entget ent) (list (list -3 eintrag))))
|
||||
ent)
|
||||
|
||||
;; Gebauter Drehwinkel (Grad) aus der XDATA, nil wenn keine vorhanden ist.
|
||||
(defun kf-xdata-lesen (ent / xd daten paar)
|
||||
(setq xd (entget ent (list *kf-xdata-app*)))
|
||||
(setq daten (cdr (assoc -3 xd)))
|
||||
;; Schluessel aus einer entget-Liste mit XDATA (reiner Kern, testbar): das
|
||||
;; ZWEITE 1000-Feld; nil bei fehlender oder Altbestands-XDATA (nur Marker).
|
||||
(defun kf-key-aus-xdata (xd / daten teile)
|
||||
(setq daten (cdr (assoc -3 xd)) teile '())
|
||||
(if daten
|
||||
(foreach p (cdr (car daten))
|
||||
(if (= (car p) 1000) (setq teile (append teile (list (cdr p)))))))
|
||||
(if (>= (length teile) 2) (cadr teile) nil))
|
||||
|
||||
(defun kf-xdata-key (ent)
|
||||
(kf-key-aus-xdata (entget ent (list *kf-xdata-app*))))
|
||||
|
||||
;; Hilfsblock (KF2D_*) mit diesem Schluessel suchen; nil, wenn es keinen gibt
|
||||
;; (nie gebaut oder vom Benutzer geloescht).
|
||||
(defun kf-hilfsblock-finden (key / ss i e treffer)
|
||||
(setq treffer nil)
|
||||
(if key
|
||||
(progn
|
||||
(setq paar (assoc 1040 (cdr (car daten))))
|
||||
(if paar (cdr paar) nil))
|
||||
nil))
|
||||
(regapp *kf-xdata-app*)
|
||||
(setq ss (ssget "X" (list '(0 . "INSERT") '(2 . "KF2D_*")
|
||||
(list -3 (list *kf-xdata-app*)))))
|
||||
(if ss
|
||||
(progn
|
||||
(setq i 0)
|
||||
(while (and (null treffer) (< i (sslength ss)))
|
||||
(setq e (ssname ss i))
|
||||
(if (equal (kf-xdata-key e) key) (setq treffer e))
|
||||
(setq i (1+ i)))))))
|
||||
treffer)
|
||||
|
||||
;; ============================================================
|
||||
;; HILFSBLOCK KF2D_<n> (Draufsicht)
|
||||
;; ============================================================
|
||||
;; Die Draufsicht KF_2D ist KEIN Teil des Foerderers, sondern ein
|
||||
;; Hilfsblock, an dem der Benutzer Schienen anschliesst. Darum:
|
||||
;; - eigener Block KF2D_<n> (nicht KF_*): die Export-Muster erfassen ihn nicht,
|
||||
;; exportiert wird nur der Hauptblock KF_<n>
|
||||
;; - flach in der XY-Ebene, auf die PROJIZIERTE Laenge des Foerderers skaliert
|
||||
;; - unabhaengig verschiebbar; loescht der Benutzer ihn, bleibt der Hauptblock
|
||||
;; unberuehrt, und KF_EDIT erzeugt ihn bei Bedarf neu
|
||||
;; - traegt dieselbe Beschriftung wie der Hauptblock
|
||||
;; Rueckgabe: die Referenz, sonst nil.
|
||||
(defun kf-hilfsblock-bauen (daten nummer key winkel-str hoehe waagerecht
|
||||
einfuegepunkt rot-rad /
|
||||
cfg bname ks ein-dx skala last-ent lay hname ss ins)
|
||||
(setq cfg (ssg-json-get daten "ansicht_2d"))
|
||||
(setq bname (if cfg (ssg-json-get cfg "block")))
|
||||
(cond
|
||||
((or (null bname) (= bname "")) nil)
|
||||
((null (kf-block-laden bname))
|
||||
(princ (ssg-textf "kf-fehler-block-datei" (list bname)))
|
||||
nil)
|
||||
(t
|
||||
(setq ks (ks-block-messen bname))
|
||||
(setq ein-dx (car (cond ((ks-versatz ks)) ('(0.0 0.0 0.0)))))
|
||||
(setq skala (kf-skala-berechnen waagerecht ein-dx))
|
||||
(if (null skala)
|
||||
(progn (princ (ssg-textf "kf-2d-ks-fehlt" (list bname))) nil)
|
||||
(progn
|
||||
(setq hname (strcat "KF2D_" (itoa nummer)))
|
||||
(setq last-ent (ssg-lastent-ohne-attribute))
|
||||
(insert-block-ks-skaliert bname einfuegepunkt 0.0 skala)
|
||||
(setq lay (kf-beschriftungs-layer))
|
||||
(kf-label-zeichnen
|
||||
(kf-label-text nummer winkel-str hoehe waagerecht)
|
||||
(list (+ (car einfuegepunkt) (/ waagerecht 2.0))
|
||||
(+ (cadr einfuegepunkt) 250.0)
|
||||
(cond ((caddr einfuegepunkt)) (0.0)))
|
||||
lay)
|
||||
(setq ss (kf-sammeln last-ent))
|
||||
(ssg-block-wrap-welt hname einfuegepunkt ss)
|
||||
(setq ins (entlast))
|
||||
(ssg-layer-setzen ins (cond ((ssg-json-get daten "layer")) ("kettenfoerderer")))
|
||||
(kf-rotation-setzen ins rot-rad)
|
||||
(kf-xdata-schreiben ins key)
|
||||
(princ (ssg-textf "kf-2d-gebaut" (list hname (rtos waagerecht 2 0))))
|
||||
ins)))))
|
||||
|
||||
;; ============================================================
|
||||
;; BLOCK ABSCHLIESSEN
|
||||
;; ============================================================
|
||||
;; Sammelt alle seit last-ent erzeugten Objekte, legt die ATTDEFs an, fasst
|
||||
;; alles zu KF_<n> zusammen und beschriftet den fertigen Block.
|
||||
;; Vorbild: gf-block-erstellen (Gefaellestrecke.lsp).
|
||||
(defun kf-block-erstellen (variante geo hoehe laenge verbindung
|
||||
startpunkt last-ent kf-nummer
|
||||
farbe antriebsmotor movimot steuerung drehung /
|
||||
kf-bname kf-ss ent kf-insert winkel-str)
|
||||
;; Beschriftung und Hoehenmass zeichnen, alle seit last-ent erzeugten Objekte
|
||||
;; sammeln, ATTDEFs anlegen und alles zu KF_<n> zusammenfassen. Vorbild:
|
||||
;; gf-block-erstellen (Gefaellestrecke.lsp).
|
||||
;; waagerecht = projizierte Laenge (Attribut L_KF_mm), key = Schluessel zum
|
||||
;; Hilfsblock, rot-rad = von Hand gesetzte Drehung der Referenz (0 beim ersten
|
||||
;; Einfuegen).
|
||||
(defun kf-block-erstellen (variante geo hoehe waagerecht verbindung
|
||||
startpunkt endpunkt last-ent kf-nummer
|
||||
farbe antriebsmotor movimot steuerung key rot-rad /
|
||||
kf-bname kf-ss kf-insert winkel-str lay z)
|
||||
(setq kf-bname (strcat "KF_" (itoa kf-nummer)))
|
||||
;; Winkel als nackte Ganzzahl ("26"/"30") - bewusst ueber itoa/fix statt
|
||||
;; rtos: rtos haengt an DIMZIN/LUPREC/LUNITS der Zeichnung und liefert je
|
||||
;; nach Zeichnungsprofil unterschiedliche Schreibweisen. Dieser Wert landet
|
||||
;; als Attribut WINKEL am Block und wird vom Sivas-Export als Schluessel der
|
||||
;; Tabelle [kf_typ_anzeige] verwendet - er muss profilunabhaengig sein
|
||||
;; (gleiche Ueberlegung wie bei ssg-sepliste-fmt-koord).
|
||||
(setq winkel-str (itoa (fix (+ 0.5 (kf-zahl (ssg-json-get variante "winkel"))))))
|
||||
(setq winkel-str (kf-winkel-text variante))
|
||||
(setq z (cond ((caddr startpunkt)) (0.0)))
|
||||
;; ATTDEFs (unsichtbar, am Startpunkt) nach dem KF-Schema
|
||||
(foreach def (kf-attrib-defs)
|
||||
(entmake
|
||||
@@ -596,18 +689,20 @@
|
||||
'(70 . 1)
|
||||
'(72 . 0)
|
||||
'(74 . 0))))
|
||||
;; Alle Entities seit last-ent einsammeln
|
||||
(setq kf-ss (ssadd))
|
||||
(setq ent (if last-ent (entnext last-ent) (entnext)))
|
||||
(while ent
|
||||
(ssadd ent kf-ss)
|
||||
(setq ent (entnext ent)))
|
||||
;; Beschriftung unter der Kette, Hoehenmass rechts neben dem Kettenende
|
||||
(setq lay (kf-beschriftungs-layer))
|
||||
(kf-label-zeichnen
|
||||
(kf-label-text kf-nummer winkel-str hoehe waagerecht)
|
||||
(list (/ (+ (car startpunkt) (car endpunkt)) 2.0) (- (cadr startpunkt) 300.0) z)
|
||||
lay)
|
||||
(kf-hoehenmass-zeichnen (list (car endpunkt) (cadr startpunkt) z)
|
||||
(list (car endpunkt) (cadr endpunkt) z)
|
||||
lay)
|
||||
(setq kf-ss (kf-sammeln last-ent))
|
||||
;; Block definieren und einfuegen (OSMODE/ELEVATION/BKS werden dabei sauber
|
||||
;; abgeschaltet, siehe ssg-block-wrap-welt)
|
||||
(ssg-block-wrap-welt kf-bname startpunkt kf-ss)
|
||||
(setq kf-insert (entlast))
|
||||
;; Gebauten Drehwinkel festhalten, damit KF_EDIT ihn wiederfindet
|
||||
(kf-xdata-schreiben kf-insert drehung)
|
||||
(ssg-layer-setzen kf-insert (cond ((ssg-json-get variante "layer"))
|
||||
((ssg-json-get (kf-daten) "layer"))
|
||||
("kettenfoerderer")))
|
||||
@@ -620,7 +715,9 @@
|
||||
("Schraegfoerderer Stahl")))
|
||||
(cons "WINKEL" winkel-str)
|
||||
(cons "H_EINBAUHOEHE_mm" (itoa (fix (+ 0.5 (float hoehe)))))
|
||||
(cons "L_KF_mm" (itoa (fix (+ 0.5 (float laenge)))))
|
||||
;; WAAGERECHTE (projizierte) Laenge des ganzen Foerderers, nicht die
|
||||
;; Laenge des schraegen Mittelstuecks
|
||||
(cons "L_KF_mm" (itoa (fix (+ 0.5 (float waagerecht)))))
|
||||
(cons "FARBE" (cond (farbe) ("RAL 7035")))
|
||||
(cons "ANTRIEBSMOTOR" (cond (antriebsmotor) ("Europa 50 Hz")))
|
||||
(cons "ANTRIEBSART" (kf-antriebsart (kf-daten)))
|
||||
@@ -629,6 +726,9 @@
|
||||
(cons "VERBINDUNGSELEMENTE" (cond (verbindung) ("Nein")))
|
||||
(cons "ARTINR" (cond ((ssg-json-get variante "sivas_id")) ("")))))
|
||||
(ssg-id-generate kf-insert)
|
||||
;; Reihenfolge: erst Drehung (entmod der Referenz), ZULETZT die XDATA
|
||||
(kf-rotation-setzen kf-insert rot-rad)
|
||||
(kf-xdata-schreiben kf-insert key)
|
||||
kf-insert)
|
||||
|
||||
;; Naechste freie KF-Nummer in der Zeichnung.
|
||||
@@ -655,9 +755,10 @@
|
||||
(while (apply belegt-p (list n)) (setq n (1+ n)))
|
||||
n)
|
||||
|
||||
;; Ist die Block-DEFINITION KF_<n> in der Zeichnung vorhanden?
|
||||
;; Ist die Block-DEFINITION KF_<n> ODER KF2D_<n> in der Zeichnung vorhanden?
|
||||
(defun kf-nummer-belegt-p (n)
|
||||
(not (null (tblsearch "BLOCK" (strcat "KF_" (itoa n))))))
|
||||
(not (null (or (tblsearch "BLOCK" (strcat "KF_" (itoa n)))
|
||||
(tblsearch "BLOCK" (strcat "KF2D_" (itoa n)))))))
|
||||
|
||||
;; Naechste freie KF-Nummer. Bewusst NICHT nur ueber die Referenzen im Modell:
|
||||
;; loescht man einen Foerderer (oder baut KF_EDIT ihn neu auf), lebt seine
|
||||
@@ -756,8 +857,8 @@
|
||||
;; zwei Punkte in der Zeichnung gewaehlt (z.B. Oberkante Zufuehrung und
|
||||
;; Oberkante Abgabe) und ihr Hoehenunterschied uebernommen.
|
||||
;;
|
||||
;; Gemessen wird die Differenz in Z: die Baugruppe steht aufgerichtet im Modell
|
||||
;; (siehe kf-matrix-aufrecht), ihre Hoehe ist also die Hoehe der Zeichnung.
|
||||
;; Gemessen wird die Differenz in Z (die Hoehe der Punkte in der Zeichnung); die
|
||||
;; Differenz in Y wird nur mit ausgegeben.
|
||||
;; Damit nachvollziehbar bleibt, was gemessen wurde, nennt die Meldung BEIDE
|
||||
;; Differenzen (dZ und dY): wer in einer DRAUFSICHT pickt, sieht sofort, dass
|
||||
;; dort dZ = 0 ist, und kann es melden.
|
||||
@@ -982,31 +1083,23 @@
|
||||
(kf-auswahl-wert steuerungen *kf-dlg-steuerung* "0")))
|
||||
|
||||
;; ============================================================
|
||||
;; C:KETTENFOERDERER - Hauptbefehl
|
||||
;; KF_BAUEN - gemeinsamer Bau fuer Befehl und Edit
|
||||
;; ============================================================
|
||||
(defun c:KETTENFOERDERER ( / daten eingabe variante hoehe verbindung
|
||||
farbe antriebsmotor movimot steuerung
|
||||
geo erg laenge skala endpunkt
|
||||
lmin lmax startpunkt drehung last-ent kf-nummer ent
|
||||
t0)
|
||||
;; Laufzeit des Dialogaufbaus protokollieren (Schalter "kf-zeit", siehe
|
||||
;; ssg_dbg.lsp). Hintergrund: der Dialog erschien beim ersten Menueklick
|
||||
;; spuerbar verzoegert. Statt zu raten, wird die Zeit bis zum Dialog
|
||||
;; gemessen - so laesst sich unterscheiden, ob das Lazy-Laden des Moduls,
|
||||
;; das Lesen der JSON oder der Dialogaufbau selbst die Zeit kostet.
|
||||
(setq t0 (getvar "MILLISECS"))
|
||||
(setq daten (kf-daten))
|
||||
(kf-zeit "Daten geladen" t0)
|
||||
(if (null daten)
|
||||
(princ (ssg-text "kf-fehler-daten-leer"))
|
||||
(progn
|
||||
(setq lmin (kf-zahl (ssg-json-get (ssg-json-get daten "laenge") "min"))
|
||||
lmax (kf-zahl (ssg-json-get (ssg-json-get daten "laenge") "max")))
|
||||
(kf-zeit "vor Dialog" t0)
|
||||
(setq eingabe (if (ssg-gui-p) (kf-dialog daten) (kf-konsole daten)))
|
||||
(if (null eingabe)
|
||||
(princ (ssg-text "kf-abgebrochen"))
|
||||
(progn
|
||||
;; Baut Hauptblock KF_<n> (Seitenansicht mit Beschriftung + Hoehenmass) und
|
||||
;; danach den Hilfsblock KF2D_<n> (Draufsicht). Beide Bloecke werden ungedreht
|
||||
;; gebaut; eine Drehung (Edit eines von Hand gedrehten Blocks) setzt
|
||||
;; kf-rotation-setzen danach wieder auf.
|
||||
;; eingabe = Ergebnis von kf-dialog/kf-konsole (Variante, Hoehe, ...)
|
||||
;; startpunkt = KS_EIN der Umlenkstation (Einfuegepunkt Hauptblock)
|
||||
;; rot-rad = Drehung des Hauptblocks, hilfs-pt/hilfs-rot = Lage des Hilfsblocks
|
||||
;; key = Schluessel Haupt <-> Hilfsblock (nil -> neuer)
|
||||
;; Rueckgabe: Liste (Blockname Hoehe Laenge) bei Erfolg, sonst nil (die
|
||||
;; Fehlermeldung ist dann schon ausgegeben, die Zeichnung unveraendert).
|
||||
(defun kf-bauen (daten eingabe startpunkt rot-rad hilfs-pt hilfs-rot key
|
||||
loeschen /
|
||||
variante hoehe verbindung farbe antriebsmotor movimot steuerung
|
||||
geo erg laenge skala lmin lmax endpunkt waagerecht
|
||||
last-ent kf-nummer winkel-str)
|
||||
(setq variante (nth 0 eingabe)
|
||||
hoehe (nth 1 eingabe)
|
||||
verbindung (nth 2 eingabe)
|
||||
@@ -1014,39 +1107,66 @@
|
||||
antriebsmotor (nth 4 eingabe)
|
||||
movimot (nth 5 eingabe)
|
||||
steuerung (nth 6 eingabe))
|
||||
(setq lmin (kf-zahl (ssg-json-get (ssg-json-get daten "laenge") "min"))
|
||||
lmax (kf-zahl (ssg-json-get (ssg-json-get daten "laenge") "max")))
|
||||
(setq geo (kf-geometrie-messen variante))
|
||||
(setq erg (kf-laenge-fuer-hoehe geo hoehe lmin lmax))
|
||||
(if (caddr erg)
|
||||
(progn
|
||||
(cond
|
||||
((caddr erg)
|
||||
(if (ssg-gui-p) (alert (ssg-text (caddr erg))))
|
||||
(princ (ssg-text (caddr erg))))
|
||||
(progn
|
||||
(princ (ssg-text (caddr erg)))
|
||||
nil)
|
||||
(t
|
||||
(setq laenge (car erg) skala (cadr erg))
|
||||
(setq startpunkt (getpoint (ssg-text "kf-prompt-startpunkt")))
|
||||
(if (null startpunkt)
|
||||
(princ (ssg-text "kf-abgebrochen"))
|
||||
(progn
|
||||
(setq drehung (getangle startpunkt (ssg-text "kf-prompt-drehung")))
|
||||
(setq drehung (if drehung (/ (* 180.0 drehung) pi) 0.0))
|
||||
(ssg-start "Kettenfoerderer" '(("OSMODE") ("ATTREQ") ("ATTDIA")))
|
||||
(setvar "OSMODE" 0)
|
||||
(setvar "ATTREQ" 0)
|
||||
(setvar "ATTDIA" 0)
|
||||
;; Edit: alte Bloecke (Liste von Enames) erst jetzt loeschen
|
||||
(foreach e loeschen (if e (entdel e)))
|
||||
(if (null key) (setq key (kf-neuer-key)))
|
||||
(setq last-ent (ssg-lastent-ohne-attribute))
|
||||
(setq kf-nummer (kf-naechste-nummer))
|
||||
;; Kette und Draufsicht liegen DECKUNGSGLEICH - beide
|
||||
;; beginnen am gewaehlten Punkt. Die Draufsicht gehoert mit
|
||||
;; in dieselbe Baugruppe, darum VOR kf-block-erstellen.
|
||||
(setq endpunkt (kf-kette-bauen variante geo skala startpunkt drehung))
|
||||
(kf-ansicht-2d-bauen daten startpunkt endpunkt drehung)
|
||||
(setq ent (kf-block-erstellen variante geo hoehe laenge verbindung
|
||||
startpunkt last-ent kf-nummer farbe antriebsmotor movimot
|
||||
steuerung drehung))
|
||||
(setq winkel-str (kf-winkel-text variante))
|
||||
(setq endpunkt (kf-kette-bauen variante geo skala startpunkt))
|
||||
(setq waagerecht (kf-waagerecht-laenge startpunkt endpunkt 0.0))
|
||||
(kf-block-erstellen variante geo hoehe waagerecht verbindung
|
||||
startpunkt endpunkt last-ent kf-nummer
|
||||
farbe antriebsmotor movimot steuerung key rot-rad)
|
||||
(kf-hilfsblock-bauen daten kf-nummer key winkel-str hoehe waagerecht
|
||||
hilfs-pt hilfs-rot)
|
||||
(ssg-end)
|
||||
(list (strcat "KF_" (itoa kf-nummer)) hoehe laenge))))
|
||||
|
||||
;; ============================================================
|
||||
;; C:KETTENFOERDERER - Hauptbefehl
|
||||
;; ============================================================
|
||||
(defun c:KETTENFOERDERER ( / daten eingabe startpunkt erg t0)
|
||||
;; Laufzeit des Dialogaufbaus protokollieren (Schalter "kf-zeit", siehe
|
||||
;; ssg_dbg.lsp): unterscheidet Lazy-Laden, JSON-Lesen und Dialogaufbau.
|
||||
(setq t0 (getvar "MILLISECS"))
|
||||
(setq daten (kf-daten))
|
||||
(kf-zeit "Daten geladen" t0)
|
||||
(if (null daten)
|
||||
(princ (ssg-text "kf-fehler-daten-leer"))
|
||||
(progn
|
||||
(kf-zeit "vor Dialog" t0)
|
||||
(setq eingabe (if (ssg-gui-p) (kf-dialog daten) (kf-konsole daten)))
|
||||
(if (null eingabe)
|
||||
(princ (ssg-text "kf-abgebrochen"))
|
||||
(progn
|
||||
(setq startpunkt (getpoint (ssg-text "kf-prompt-startpunkt")))
|
||||
(if (null startpunkt)
|
||||
(princ (ssg-text "kf-abgebrochen"))
|
||||
(progn
|
||||
;; Hilfsblock beim ersten Mal 1000 mm unter dem Hauptblock
|
||||
(setq erg (kf-bauen daten eingabe startpunkt 0.0
|
||||
(kf-versatzpunkt startpunkt (kf-hilfsblock-versatz daten))
|
||||
0.0 nil nil))
|
||||
(if erg
|
||||
(princ (ssg-textf "kf-fertig"
|
||||
(list (strcat "KF_" (itoa kf-nummer))
|
||||
(rtos (float hoehe) 2 0)
|
||||
(rtos laenge 2 0))))))))))))
|
||||
(list (car erg) (rtos (float (cadr erg)) 2 0)
|
||||
(rtos (caddr erg) 2 0)))))))))))
|
||||
(princ))
|
||||
|
||||
;; ============================================================
|
||||
@@ -1056,10 +1176,11 @@
|
||||
;; an SEINER Stelle neu auf. Vorbild: GEFAELLESTRECKE_EDIT.
|
||||
;;
|
||||
;; Einfuegepunkt und Drehung kommen aus dem Block selbst (Gruppencode 10 und
|
||||
;; 50), nicht aus XDATA: der Kettenfoerderer hat keine Aufbau-Historie, die
|
||||
;; ueber diese beiden Werte hinausgeht - alles Uebrige steht in den
|
||||
;; Attributen. Ein von Hand verschobener oder gedrehter Block wird dadurch
|
||||
;; korrekt an seiner NEUEN Lage neu gebaut.
|
||||
;; 50), alles Uebrige steht in den Attributen. Ein von Hand verschobener oder
|
||||
;; gedrehter Block wird dadurch an seiner NEUEN Lage neu gebaut. Die XDATA
|
||||
;; traegt nur den Schluessel zum Hilfsblock KF2D_<n>: er wird mit dem Hauptblock
|
||||
;; neu erzeugt (auch wenn der Benutzer ihn geloescht hatte) und behaelt die
|
||||
;; Lage, an die der Benutzer ihn zuletzt gelegt hat.
|
||||
;;
|
||||
;; Der alte Block wird erst geloescht, wenn der Benutzer den Dialog mit OK
|
||||
;; bestaetigt hat - ein Abbruch laesst die Zeichnung unveraendert.
|
||||
@@ -1115,13 +1236,10 @@
|
||||
(setq i (1+ i)))
|
||||
(cond (treffer) (0)))
|
||||
|
||||
(defun c:KF_EDIT ( / ss ent ed bname attribs daten eingabe variante hoehe
|
||||
verbindung farbe antriebsmotor movimot steuerung
|
||||
geo erg laenge skala lmin lmax startpunkt drehung
|
||||
last-ent kf-nummer endpunkt)
|
||||
(defun c:KF_EDIT ( / ss ent ed bname attribs daten eingabe startpunkt
|
||||
rot-rad key hilfs hilfs-pt hilfs-rot erg)
|
||||
;; Erst die VORGEWAEHLTE Auswahl (Doppelklick setzt sie), nur ohne sie per
|
||||
;; Klick nachfragen - wie GEFAELLESTRECKE_EDIT/KreiselEdit. Vorher fragte
|
||||
;; KF_EDIT auch nach einem Doppelklick noch einmal nach einer Auswahl.
|
||||
;; Klick nachfragen - wie GEFAELLESTRECKE_EDIT/KreiselEdit.
|
||||
(setq ss (ssget "I"))
|
||||
(setq ent (if (and ss (= (sslength ss) 1))
|
||||
(ssname ss 0)
|
||||
@@ -1132,8 +1250,7 @@
|
||||
(setq ed (entget ent))
|
||||
(setq bname (cdr (assoc 2 ed)))
|
||||
;; Nur echte Foerderer "KF_<n>": die Bausteine (KF_UM_26, KF_2D, ...)
|
||||
;; tragen ebenfalls das Praefix KF_, haben aber keine Attribute - ein
|
||||
;; Neuaufbau aus ihnen waere sinnlos und wuerde sie loeschen.
|
||||
;; tragen ebenfalls das Praefix KF_, haben aber keine Attribute.
|
||||
(if (or (/= (cdr (assoc 0 ed)) "INSERT") (null (kf-nummer-aus-name bname)))
|
||||
(alert (ssg-text "kf-edit-kein-kf"))
|
||||
(progn
|
||||
@@ -1143,51 +1260,33 @@
|
||||
(progn
|
||||
(setq attribs (ssg-attrib-read ent))
|
||||
(setq startpunkt (cdr (assoc 10 ed)))
|
||||
;; Der gebaute Winkel steckt in der XDATA, eine nachtraegliche
|
||||
;; Drehung der Referenz in Gruppencode 50 - beides zaehlt.
|
||||
(setq drehung (kf-drehung-gesamt (kf-xdata-lesen ent)
|
||||
(cdr (assoc 50 ed))))
|
||||
(setq rot-rad (cond ((cdr (assoc 50 ed))) (0.0)))
|
||||
;; Schluessel zum Hilfsblock; Altbestand ohne Schluessel -> nil,
|
||||
;; dann gibt es keinen auffindbaren Hilfsblock und ein neuer
|
||||
;; entsteht an der Standardposition.
|
||||
(setq key (kf-xdata-key ent))
|
||||
(setq hilfs (kf-hilfsblock-finden key))
|
||||
(if hilfs
|
||||
(setq hilfs-pt (cdr (assoc 10 (entget hilfs)))
|
||||
hilfs-rot (cond ((cdr (assoc 50 (entget hilfs)))) (0.0)))
|
||||
(setq hilfs-pt (kf-versatzpunkt startpunkt
|
||||
(kf-hilfsblock-versatz daten))
|
||||
hilfs-rot 0.0))
|
||||
(kf-dlg-aus-attributen daten attribs)
|
||||
(setq lmin (kf-zahl (ssg-json-get (ssg-json-get daten "laenge") "min"))
|
||||
lmax (kf-zahl (ssg-json-get (ssg-json-get daten "laenge") "max")))
|
||||
(setq eingabe (if (ssg-gui-p) (kf-dialog daten) (kf-konsole daten)))
|
||||
(if (null eingabe)
|
||||
(princ (ssg-text "kf-abgebrochen"))
|
||||
(progn
|
||||
(setq variante (nth 0 eingabe)
|
||||
hoehe (nth 1 eingabe)
|
||||
verbindung (nth 2 eingabe)
|
||||
farbe (nth 3 eingabe)
|
||||
antriebsmotor (nth 4 eingabe)
|
||||
movimot (nth 5 eingabe)
|
||||
steuerung (nth 6 eingabe))
|
||||
(setq geo (kf-geometrie-messen variante))
|
||||
(setq erg (kf-laenge-fuer-hoehe geo hoehe lmin lmax))
|
||||
(if (caddr erg)
|
||||
(progn
|
||||
(if (ssg-gui-p) (alert (ssg-text (caddr erg))))
|
||||
(princ (ssg-text (caddr erg))))
|
||||
(progn
|
||||
(setq laenge (car erg) skala (cadr erg))
|
||||
(ssg-start "Kettenfoerderer Edit"
|
||||
'(("OSMODE") ("ATTREQ") ("ATTDIA")))
|
||||
(setvar "OSMODE" 0)
|
||||
(setvar "ATTREQ" 0)
|
||||
(setvar "ATTDIA" 0)
|
||||
;; Erst jetzt loeschen - ein Abbruch oben laesst die
|
||||
;; Zeichnung unveraendert.
|
||||
(entdel ent)
|
||||
(setq last-ent (ssg-lastent-ohne-attribute))
|
||||
(setq kf-nummer (kf-naechste-nummer))
|
||||
(setq endpunkt (kf-kette-bauen variante geo skala
|
||||
startpunkt drehung))
|
||||
(kf-ansicht-2d-bauen daten startpunkt endpunkt drehung)
|
||||
(kf-block-erstellen variante geo hoehe laenge verbindung
|
||||
startpunkt last-ent kf-nummer farbe antriebsmotor
|
||||
movimot steuerung drehung)
|
||||
(ssg-end)
|
||||
;; Der Hilfsblock wird bei JEDEM Edit neu erzeugt, damit er
|
||||
;; zur neuen Hoehe/Laenge passt - an der Stelle, an der der
|
||||
;; Benutzer ihn zuletzt hingelegt hat.
|
||||
(setq erg
|
||||
(kf-bauen daten eingabe startpunkt rot-rad hilfs-pt hilfs-rot
|
||||
(cond (key) (kf-neuer-key))
|
||||
(list ent hilfs)))
|
||||
(if erg
|
||||
(princ (ssg-textf "kf-edit-fertig"
|
||||
(list bname (strcat "KF_" (itoa kf-nummer)))))))))))))))
|
||||
(list bname (car erg)))))))))))))
|
||||
(princ))
|
||||
|
||||
;; ============================================================
|
||||
|
||||
@@ -462,6 +462,12 @@
|
||||
)
|
||||
)
|
||||
|
||||
;; Hilfsblock (Draufsicht) des Kettenfoerderers: kein eigener Edit - er wird
|
||||
;; mit dem Hauptblock KF_<n> neu erzeugt (Doppelklick dort).
|
||||
((wcmatch bname "KF2D_*")
|
||||
(princ (ssg-text "cmd-kf2d-hilfsblock"))
|
||||
)
|
||||
|
||||
;; Omniflo-Bloecke -> OMNI_EDIT
|
||||
;; Erkennung: TEILEART-Attribut vorhanden, AP110-Blockname oder rein numerisch
|
||||
((progn
|
||||
|
||||
+16
-4
@@ -85,10 +85,21 @@
|
||||
;; Realer Fehler, den das behebt: die KS-Messung eines KF-Bausteins lief ins
|
||||
;; Leere und meldete "KS_EIN/KS_AUS fehlt", obwohl beide KS im Block vorhanden
|
||||
;; waren - gesucht wurde nur ein Blockname, den es nicht gibt.
|
||||
;;
|
||||
;; Zweiter Sonderfall - Namen, die SELBST auf _2D/_3D enden (z.B. die
|
||||
;; Kettenfoerderer-Draufsicht "KF_2D"): ssg-ils-blockname laesst solche Namen
|
||||
;; unveraendert (eff = blockname), die Bedingung "eff existiert nicht" kann
|
||||
;; dann nie zutreffen, und der Block ging in den ILS-Ladepfad. Der suchte
|
||||
;; data/ils/KF_2D.dwg und meldete "Block-Datei nicht gefunden", obwohl der
|
||||
;; Block in der Zeichnung vorhanden war. Massgeblich ist darum, ob es fuer den
|
||||
;; Namen ueberhaupt eine ILS-Datei gibt: ohne Datei ist es kein ILS-Block und
|
||||
;; die vorhandene Definition wird genommen. Echte ILS-Bloecke haben eine Datei
|
||||
;; und laufen unveraendert durch den Ladepfad (Aktualisierung aus der Datei).
|
||||
(defun ensure-block-loaded (blockname / eff)
|
||||
(setq eff (ssg-ils-blockname blockname))
|
||||
(if (and (not (tblsearch "BLOCK" eff))
|
||||
(tblsearch "BLOCK" blockname))
|
||||
(if (and (tblsearch "BLOCK" blockname)
|
||||
(or (= eff blockname) (not (tblsearch "BLOCK" eff)))
|
||||
(null (ssg-ils-block-datei blockname)))
|
||||
blockname
|
||||
(progn
|
||||
(if (not (ssg-ils-block-laden blockname))
|
||||
@@ -558,8 +569,9 @@
|
||||
;; Bewusst matrixbasiert statt mit einem weiteren Winkelparameter: die
|
||||
;; Aufrichtung ist nur EIN Anwendungsfall, und jeder weitere haette eine
|
||||
;; weitere Spezialfunktion gebraucht. Den Aufrufern bleibt freigestellt,
|
||||
;; welche Drehungen sie kombinieren (beim Kettenfoerderer
|
||||
;; Rz(basis) * Rx(90) * Rz(eigen), siehe kf-matrix-aufrecht).
|
||||
;; welche Drehungen sie kombinieren. (Der Kettenfoerderer hat sie kurz fuer
|
||||
;; Rz(basis) * Rx(90) * Rz(eigen) genutzt, ist inzwischen aber wieder eine flache
|
||||
;; Seitenansicht - aktuell ohne Aufrufer.)
|
||||
|
||||
;; Elementare Rotationsmatrizen (3x3, Winkel in GRAD).
|
||||
(defun ks-rot-x (grad / r c s)
|
||||
|
||||
@@ -174,6 +174,8 @@ planquadrate = ZZ_Planquadrate, 8
|
||||
# ZUSAMMENGEBAUTE Baugruppe ohne eigene Blockdatei, der Layer muss darum hier
|
||||
# stehen. Die drei Bausteine darin behalten ihre eigenen Layer.
|
||||
kettenfoerderer = Omni_Kettenfoerderer, 4
|
||||
; Beschriftung (KF_n ... H=, L projiziert=) und Hoehenmass, auf Haupt- und Hilfsblock
|
||||
kettenfoerderer_beschriftung = KF_Beschriftung, 7
|
||||
|
||||
|
||||
# ============================================================
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
"einbauhoehe": { "vorgabe": 1500, "min": 300, "max": 8000 },
|
||||
"laenge": { "min": 100, "max": 20000 },
|
||||
|
||||
"_hinweis_ansicht": "KF_2D liegt DECKUNGSGLEICH mit der Kette (KS_EIN auf KS_EIN der Umlenkung, KS_AUS auf KS_AUS des Antriebs) - die Baugruppe ist EIN Koerper. Den frueheren Versatz (versatz_y) gibt es nicht mehr, seit die Kette aufgerichtet eingebaut wird.",
|
||||
"ansicht_2d": { "block": "KF_2D" },
|
||||
"_hinweis_ansicht": "KF_2D ist ein eigener Hilfsblock KF2D_<n> (Draufsicht zum Anschliessen von Schienen), kein Teil des Foerderers. Er wird auf die projizierte Laenge skaliert und beim ERSTEN Einfuegen versatz_y mm (Y) gegen den Hauptblock versetzt; danach liegt er, wo der Benutzer ihn hinlegt.",
|
||||
"ansicht_2d": { "block": "KF_2D", "versatz_y": -1000 },
|
||||
|
||||
"_hinweis_antriebsart": "Merkmal 357 ist beim Kettenfoerderer FEST: die Liste hat genau EINEN Eintrag, der im Dialog als Dropdown erscheint und zwingend gewaehlt ist. Weitere Antriebsarten (z.B. 0.55 kW) waeren einfach eine weitere Zeile.",
|
||||
"antriebsart": [
|
||||
|
||||
+4
-4
@@ -1300,11 +1300,11 @@
|
||||
"kf-prompt-messpunkt-2": "\nZweiten Messpunkt waehlen (Hoehenbezug oben): ",
|
||||
"kf-messung-ergebnis": "\n>>> Gemessen: Hoehendifferenz dZ = %1 mm (zur Kontrolle dY = %2 mm).",
|
||||
"kf-konsole-hoehe-hinweis": "\n(0 eingeben, um die Hoehe aus zwei Punkten zu messen)",
|
||||
"kf-2d-gebaut": "\n>>> Draufsicht %1 eingefuegt: Schraeglaenge %2 mm, Neigung %3 Grad.",
|
||||
"kf-2d-laenge-null": "\nDraufsicht uebersprungen: die Kette hat keine messbare Grundrisslaenge.",
|
||||
"kf-2d-gebaut": "\n>>> Hilfsblock %1 (Draufsicht) eingefuegt: KF waagerechte Laenge %2 mm.",
|
||||
"kf-bemassung-fehlt": "\nHinweis: Das Hoehenmass konnte nicht gezeichnet werden - der Foerderer wurde trotzdem gebaut.",
|
||||
"cmd-kf2d-hilfsblock": "\nHilfsblock (Draufsicht): kein eigener Dialog - Doppelklick auf den Hauptblock KF_<n> erzeugt ihn neu.",
|
||||
"kf-2d-ks-fehlt": "\nDraufsicht uebersprungen: %1 hat kein messbares KS_EIN/KS_AUS.",
|
||||
"kf-prompt-startpunkt": "\nEinfuegepunkt waehlen (KS_EIN der Draufsicht; die Seitenansicht entsteht darueber): ",
|
||||
"kf-prompt-drehung": "\nDrehwinkel der Kette: ",
|
||||
"kf-prompt-startpunkt": "\nEinfuegepunkt waehlen (KS_EIN der Umlenkstation): ",
|
||||
"kf-abgebrochen": "\nAbgebrochen.",
|
||||
"kf-fertig": "\n>>> %1 erstellt: Einbauhoehe %2 mm, Zwischenstueck %3 mm.",
|
||||
"kf-konsole-variante-header": "\n\nSchraegfoerderer Stahl Typ waehlen:",
|
||||
|
||||
+4
-4
@@ -1300,11 +1300,11 @@
|
||||
"kf-prompt-messpunkt-2": "\nSelect second measuring point (upper reference): ",
|
||||
"kf-messung-ergebnis": "\n>>> Measured: height difference dZ = %1 mm (for reference dY = %2 mm).",
|
||||
"kf-konsole-hoehe-hinweis": "\n(enter 0 to measure the height from two points)",
|
||||
"kf-2d-gebaut": "\n>>> Plan view %1 inserted: slope length %2 mm, inclination %3 deg.",
|
||||
"kf-2d-laenge-null": "\nPlan view skipped: the chain has no measurable plan length.",
|
||||
"kf-2d-gebaut": "\n>>> Helper block %1 (plan view) inserted: KF horizontal length %2 mm.",
|
||||
"kf-bemassung-fehlt": "\nNote: the height dimension could not be drawn - the conveyor was built anyway.",
|
||||
"cmd-kf2d-hilfsblock": "\nHelper block (plan view): no dialog of its own - double-click the main block KF_<n> to regenerate it.",
|
||||
"kf-2d-ks-fehlt": "\nPlan view skipped: %1 has no measurable KS_EIN/KS_AUS.",
|
||||
"kf-prompt-startpunkt": "\nSelect insertion point (KS_EIN of the plan view; the side view is built above it): ",
|
||||
"kf-prompt-drehung": "\nRotation angle of the chain: ",
|
||||
"kf-prompt-startpunkt": "\nSelect insertion point (KS_EIN of the return station): ",
|
||||
"kf-abgebrochen": "\nCancelled.",
|
||||
"kf-fertig": "\n>>> %1 created: installation height %2 mm, intermediate section %3 mm.",
|
||||
"kf-konsole-variante-header": "\n\nSelect inclined steel conveyor type:",
|
||||
|
||||
+12
-4
@@ -313,8 +313,8 @@ def kettenfoerderer_signature(block):
|
||||
Merkmale wuerden schon hier dieselbe Gruppe ergeben. Sonst wuerde dort
|
||||
"anzahl" addiert, waehrend 353 unveraendert stehen bliebe.
|
||||
|
||||
Die Laenge des Zwischenstuecks (L_KF_mm) ist eine FOLGE der Einbauhoehe und
|
||||
steht darum nicht eigens im Schluessel.
|
||||
Die waagerechte Laenge (L_KF_mm) ist eine FOLGE der Einbauhoehe (und des
|
||||
Winkels) und steht darum nicht eigens im Schluessel.
|
||||
"""
|
||||
attribs = block.get("attribs", {})
|
||||
return (
|
||||
@@ -702,7 +702,11 @@ def process_blocks(blocks, anzahl_weichen_ils=0):
|
||||
# 359/360/391) gingen dabei verloren. Anders als das Geruest werden
|
||||
# BAUGLEICHE Foerderer zu einer Zeile zusammengefasst, weil Merkmal
|
||||
# 353 genau diese Stueckzahl verlangt.
|
||||
if matches_any(bname, BLOCKPATTERNS.get("pattern_kettenfoerderer", [])):
|
||||
# Nur echte Foerderer "KF_<n>": das Muster KF_* erfasst sonst auch
|
||||
# lose Bausteine (KF_UM_26, KF_2D). Der Hilfsblock KF2D_<n> passt nicht
|
||||
# aufs Muster und wird nie exportiert.
|
||||
if (matches_any(bname, BLOCKPATTERNS.get("pattern_kettenfoerderer", []))
|
||||
and re.fullmatch(r"KF_\d+", bname, re.IGNORECASE)):
|
||||
sig = kettenfoerderer_signature(block)
|
||||
if sig not in kettenfoerderer_groups:
|
||||
kettenfoerderer_groups[sig] = {"block": block, "ids": [], "anzahl": 0}
|
||||
@@ -996,7 +1000,11 @@ def process_blocks(blocks, anzahl_weichen_ils=0):
|
||||
"bezeichnung": attribs.get("Bezeichnung", ""),
|
||||
"dispgruppe": 20,
|
||||
"anzahl": gruppe["anzahl"],
|
||||
"laenge_mm": attribs.get("L_KF_mm", ""),
|
||||
# Bewusst LEER: Sivas berechnet ZL, EL und die Kettenlaenge selbst, aus
|
||||
# dem Kettenfoerderer wird nur die Hoehe (360) uebernommen. L_KF_mm
|
||||
# (waagerechte Laenge des Foerderers) steht als Attribut am Block,
|
||||
# geht aber nicht in die Sivas-Zeile.
|
||||
"laenge_mm": "",
|
||||
"ids": gruppe["ids"],
|
||||
"details": build_kettenfoerderer_details(block, gruppe["anzahl"]),
|
||||
})
|
||||
|
||||
+65
-60
@@ -2892,66 +2892,71 @@
|
||||
(tu-eq "kf-frei/Start-mitten" 5
|
||||
(kf-freie-nummer 3 '(lambda (n) (member n '(3 4)))))
|
||||
|
||||
;; --- kf-drehung-gesamt: Drehwinkel fuer KF_EDIT ---
|
||||
;; Regression: der Drehwinkel wird beim Bau in die Geometrie eingerechnet,
|
||||
;; die Blockreferenz selbst hat IMMER Drehung 0 (ssg-block-wrap-welt).
|
||||
;; KF_EDIT las nur Gruppencode 50 und baute eine mit 90 Grad gebaute
|
||||
;; Kette ungedreht neu. Der gebaute Winkel steht jetzt als XDATA.
|
||||
(tu-eqf "kf-drehung/nur-xdata" 90.0 (kf-drehung-gesamt 90.0 0.0))
|
||||
;; Referenz nachtraeglich von Hand um 90 Grad gedreht (Gruppencode 50 in
|
||||
;; Bogenmass) -> beides addiert sich
|
||||
(tu-eqf "kf-drehung/xdata-plus-referenz" 180.0
|
||||
(kf-drehung-gesamt 90.0 (/ pi 2.0)))
|
||||
;; Altbestand ohne XDATA: nur die Referenzdrehung (bisheriges Verhalten)
|
||||
(tu-eqf "kf-drehung/ohne-xdata" 45.0 (kf-drehung-gesamt nil (/ pi 4.0)))
|
||||
;; nichts bekannt -> 0, kein Absturz und kein nil
|
||||
(tu-eqf "kf-drehung/nichts" 0.0 (kf-drehung-gesamt nil nil))
|
||||
(tu-true "kf-drehung/ist-zahl" (numberp (kf-drehung-gesamt nil nil)))
|
||||
;; Summe ueber 180 Grad wird auf -180..180 gefaltet (270 = -90)
|
||||
(tu-eqf "kf-drehung/normalisiert" -90.0
|
||||
(kf-drehung-gesamt 180.0 (/ pi 2.0)))
|
||||
;; ganze Zahl aus der XDATA (nicht real) darf nicht abstuerzen
|
||||
(tu-eqf "kf-drehung/ganzzahl" 30.0 (kf-drehung-gesamt 30 0.0))
|
||||
;; --- kf-label-text: Beschriftung von Haupt- UND Hilfsblock ---
|
||||
;; Eine Zeile wie bei VF_/GF_: Nummer, Winkel mit Gradzeichen, Hoehe,
|
||||
;; projizierte Laenge (ganze mm)
|
||||
(tu-eq "kf-label/normal"
|
||||
(strcat "KF_1 26" (chr 176) " H=1500mm L_horizontal=4951mm")
|
||||
(kf-label-text 1 "26" 1500.0 4951.4))
|
||||
;; rundet kaufmaennisch auf ganze mm, nimmt auch Ganzzahlen
|
||||
(tu-eq "kf-label/rundet-auf"
|
||||
(strcat "KF_12 30" (chr 176) " H=2000mm L_horizontal=3001mm")
|
||||
(kf-label-text 12 "30" 2000 3000.5))
|
||||
|
||||
;; --- kf-neigung-aus-punkten: Kern der 3D-Aufrichtung ---
|
||||
;; Liefert (Schraeglaenge Neigungswinkel) aus Ketten-Start und -Ende.
|
||||
;; Die Kette wird AUFGERICHTET eingebaut, die Hoehe laeuft also in Z.
|
||||
;; 3-4-5-Dreieck: 3000 waagerecht, 4000 hoch -> 5000 schraeg
|
||||
(tu-eqf "kf-neigung/3-4-5-laenge" 5000.0
|
||||
(car (kf-neigung-aus-punkten '(0.0 0.0 0.0) '(3000.0 0.0 4000.0) 0.0)))
|
||||
;; 45 Grad: gleiche Betraege waagerecht und hoch
|
||||
(tu-eqf "kf-neigung/45-grad" 45.0
|
||||
(cadr (kf-neigung-aus-punkten '(0.0 0.0 0.0) '(1000.0 0.0 1000.0) 0.0)))
|
||||
;; waagerecht -> Winkel 0, Laenge = Horizontalabstand
|
||||
(tu-eqf "kf-neigung/waagerecht" '(2000.0 0.0)
|
||||
(kf-neigung-aus-punkten '(0.0 0.0 0.0) '(2000.0 0.0 0.0) 0.0))
|
||||
;; Der Horizontalanteil wird auf die KETTENRICHTUNG projiziert, nicht
|
||||
;; auf die Welt-X-Achse: bei 90 Grad Basisdrehung laeuft die Kette in Y.
|
||||
;; Ohne Projektion kaeme hier 0 heraus und der Winkel waere 90 statt 45.
|
||||
(tu-eqf "kf-neigung/gedreht-90" '(1414.213562 45.0)
|
||||
(kf-neigung-aus-punkten '(0.0 0.0 0.0) '(0.0 1000.0 1000.0) 90.0))
|
||||
;; fallende Kette -> negativer Winkel
|
||||
(tu-eqf "kf-neigung/fallend" -45.0
|
||||
(cadr (kf-neigung-aus-punkten '(0.0 0.0 1000.0) '(1000.0 0.0 0.0) 0.0)))
|
||||
;; Start = Ende -> nil statt Division durch 0
|
||||
(tu-nil "kf-neigung/nulllaenge"
|
||||
(kf-neigung-aus-punkten '(5.0 5.0 5.0) '(5.0 5.0 5.0) 0.0))
|
||||
;; --- kf-winkel-text: Neigung als nackte Ganzzahl (Attribut WINKEL) ---
|
||||
(tu-eq "kf-winkel-text/real" "26" (kf-winkel-text '(("winkel" . 26.0))))
|
||||
(tu-eq "kf-winkel-text/string" "30" (kf-winkel-text '(("winkel" . "30"))))
|
||||
(tu-eq "kf-winkel-text/fehlt" "0" (kf-winkel-text '(("name" . "x"))))
|
||||
|
||||
;; --- kf-matrix-aufrecht: Y_lokal wird zu Z_welt ---
|
||||
;; Das ist die Kernaussage der Aufrichtung. Geprueft wird sie an den
|
||||
;; Bildern der Einheitsvektoren, nicht an den Matrixeintraegen - so
|
||||
;; bleibt der Test lesbar und unabhaengig von der Schreibweise.
|
||||
(tu-eqf "kf-matrix/Y-lokal-wird-Z-welt" '(0.0 0.0 1.0)
|
||||
(mat3-mul-vec3 (kf-matrix-aufrecht 0.0 0.0) '(0.0 1.0 0.0)))
|
||||
;; Die Fahrtrichtung (X) bleibt bei Basisdrehung 0 die Welt-X-Achse
|
||||
(tu-eqf "kf-matrix/X-bleibt-X" '(1.0 0.0 0.0)
|
||||
(mat3-mul-vec3 (kf-matrix-aufrecht 0.0 0.0) '(1.0 0.0 0.0)))
|
||||
;; Basisdrehung 90 Grad dreht die Fahrtrichtung in die Welt-Y-Achse,
|
||||
;; die Hoehe bleibt dabei in Z
|
||||
(tu-eqf "kf-matrix/basis-90-dreht-X-nach-Y" '(0.0 1.0 0.0)
|
||||
(mat3-mul-vec3 (kf-matrix-aufrecht 90.0 0.0) '(1.0 0.0 0.0)))
|
||||
(tu-eqf "kf-matrix/basis-90-haelt-Z" '(0.0 0.0 1.0)
|
||||
(mat3-mul-vec3 (kf-matrix-aufrecht 90.0 0.0) '(0.0 1.0 0.0)))
|
||||
;; --- kf-versatzpunkt: Hilfsblock beim ersten Einfuegen unter dem Hauptblock ---
|
||||
(tu-eqf "kf-versatzpunkt/minus-1000" '(100.0 -980.0 5.0)
|
||||
(kf-versatzpunkt '(100.0 20.0 5.0) -1000))
|
||||
;; 2D-Punkt ohne Z -> Z = 0, kein Absturz
|
||||
(tu-eqf "kf-versatzpunkt/ohne-z" '(0.0 -1000.0 0.0)
|
||||
(kf-versatzpunkt '(0.0 0.0) -1000.0))
|
||||
|
||||
;; --- kf-hilfsblock-versatz: Wert steht in der JSON, Vorgabe -1000 ---
|
||||
(tu-eqf "kf-versatz/aus-daten" -500.0
|
||||
(kf-hilfsblock-versatz '(("ansicht_2d" ("block" . "KF_2D") ("versatz_y" . -500)))))
|
||||
(tu-eqf "kf-versatz/ohne-feld" -1000.0
|
||||
(kf-hilfsblock-versatz '(("ansicht_2d" ("block" . "KF_2D")))))
|
||||
(tu-eqf "kf-versatz/ohne-ansicht" -1000.0
|
||||
(kf-hilfsblock-versatz '(("id" . "x"))))
|
||||
;; Zahl, nicht T (and/or-Typfalle)
|
||||
(tu-true "kf-versatz/ist-zahl"
|
||||
(numberp (kf-hilfsblock-versatz '(("id" . "x")))))
|
||||
|
||||
;; --- kf-key-aus-xdata: Schluessel Haupt- <-> Hilfsblock ---
|
||||
(tu-eq "kf-key/aus-xdata" "20261030120000"
|
||||
(kf-key-aus-xdata
|
||||
'((-3 ("SSG_KF_EDIT" (1000 . "kf-edit") (1000 . "20261030120000"))))))
|
||||
;; Altbestand: nur der Marker, kein Schluessel -> nil (-> neuer Schluessel)
|
||||
(tu-nil "kf-key/nur-marker"
|
||||
(kf-key-aus-xdata '((-3 ("SSG_KF_EDIT" (1000 . "kf-edit"))))))
|
||||
(tu-nil "kf-key/keine-xdata" (kf-key-aus-xdata '((0 . "INSERT"))))
|
||||
(tu-nil "kf-key/nil" (kf-key-aus-xdata nil))
|
||||
|
||||
;; --- kf-waagerecht-laenge: Wert des Attributs L_KF_mm ---
|
||||
;; Waagerechte Laenge des GANZEN Foerderers (der Draufsicht KF_2D), also
|
||||
;; ohne die Steigung - nicht die Laenge des schraegen Mittelstuecks.
|
||||
;; 3-4-5: 3000 waagerecht, 4000 hoch -> waagerecht bleibt 3000 (nicht 5000)
|
||||
(tu-eqf "kf-waagerecht/ohne-steigung" 3000.0
|
||||
(kf-waagerecht-laenge '(0.0 0.0 0.0) '(3000.0 0.0 4000.0) 0.0))
|
||||
;; nur Hoehe, keine waagerechte Strecke -> 0
|
||||
(tu-eqf "kf-waagerecht/nur-hoehe" 0.0
|
||||
(kf-waagerecht-laenge '(0.0 0.0 0.0) '(0.0 0.0 1500.0) 0.0))
|
||||
;; auf die KETTENRICHTUNG projiziert: bei 90 Grad Basisdrehung laeuft die
|
||||
;; Kette in Y, die Welt-X-Differenz waere 0
|
||||
(tu-eqf "kf-waagerecht/gedreht-90" 1000.0
|
||||
(kf-waagerecht-laenge '(0.0 0.0 0.0) '(0.0 1000.0 1000.0) 90.0))
|
||||
(tu-eqf "kf-waagerecht/gedreht-45" 1000.0
|
||||
(kf-waagerecht-laenge '(0.0 0.0 0.0) '(707.10678 707.10678 500.0) 45.0))
|
||||
;; fallende Kette / Ende "hinter" dem Start: Betrag, nie negativ
|
||||
(tu-eqf "kf-waagerecht/immer-positiv" 2000.0
|
||||
(kf-waagerecht-laenge '(2000.0 0.0 0.0) '(0.0 0.0 800.0) 0.0))
|
||||
;; muss eine Zahl sein (Typfalle: nie T/nil)
|
||||
(tu-true "kf-waagerecht/ist-zahl"
|
||||
(numberp (kf-waagerecht-laenge '(0.0 0.0 0.0) '(10.0 0.0 0.0) 0.0)))
|
||||
|
||||
;; --- Standard-Variante: steht in den DATEN, nicht im Code ---
|
||||
(tu-true "kf-variante-standard-p/markiert"
|
||||
@@ -2970,8 +2975,8 @@
|
||||
(kf-standard-index '((("winkel" . 26)) (("winkel" . 30)))))
|
||||
|
||||
;; --- kf-punkt-differenzen: zweite Hoehen-Eingabeart (2 Punkte) ---
|
||||
;; Gemessen wird die Differenz in Z - die Baugruppe steht aufgerichtet im
|
||||
;; Modell. Zurueckgegeben wird (dz dy): die HOEHE zuerst, dY nur zur
|
||||
;; Gemessen wird die Differenz in Z (Hoehe der gepickten Punkte).
|
||||
;; Zurueckgegeben wird (dz dy): die HOEHE zuerst, dY nur zur
|
||||
;; Kontrolle (wer in einer Draufsicht pickt, sieht dz = 0).
|
||||
(tu-eqf "kf-punkt-diff/dz" '(1500.0 0.0)
|
||||
(kf-punkt-differenzen '(0.0 0.0 0.0) '(2000.0 0.0 1500.0)))
|
||||
|
||||
Reference in New Issue
Block a user