[ADD] Lager: Darstellung Gitterrost/Gitterkorb unter Regalreihen, Farben aus lager.json, LG_DARSTELLUNG

Lisp/LagerInsert.lsp

@@ -768,12 +768,51 @@
             ""))
 )
 
-;; Reihe: Rechteck L x T um die Schienenlinie (0,0)-(L,0).
-(defun lg-reihe-blockdef (laenge tiefe / h)
-  (setq h (/ tiefe 2.0))
+;; ------------------------------------------------------------
+;; Farben (lager.json: ACI-Nummer 1..255 oder RGB-Text "r,g,b")
+;; ------------------------------------------------------------
+
+;; "r,g,b" -> (r g b), sonst nil. Rein, getestet.
+(defun lg-farbe-rgb (farbe / teile)
+  (if (= (type farbe) 'STR)
+    (progn
+      (setq teile (mapcar '(lambda (s) (atoi (vl-string-trim " " s)))
+                          (ssg-sepliste-split-feld farbe ",")))
+      (if (and (= (length teile) 3) (vl-every '(lambda (x) (<= 0 x 255)) teile)) teile)))
+)
+
+;; Farbe als DXF-Gruppen fuer entmake: ACI -> ((62 . n)), RGB -> ((420 . rgb)),
+;; nil/ungueltig -> nil (VONLAYER). Rein, getestet.
+(defun lg-farbe-dxf (farbe / rgb)
+  (cond
+    ((and (numberp farbe) (<= 1 (fix farbe) 255)) (list (cons 62 (fix farbe))))
+    ((setq rgb (lg-farbe-rgb farbe))
+      (list (cons 420 (+ (* 65536 (car rgb)) (* 256 (cadr rgb)) (caddr rgb)))))
+    (T nil)
+  )
+)
+
+;; Farbe auf ein ActiveX-Objekt setzen; ohne gueltige Farbe -> sonst
+;; (ACI-Nummer, z.B. 0 = VONBLOCK, 256 = VONLAYER).
+(defun lg-farbe-setzen (obj farbe sonst / rgb c)
+  (cond
+    ((and (numberp farbe) (<= 1 (fix farbe) 255)) (vla-put-Color obj (fix farbe)))
+    ((setq rgb (lg-farbe-rgb farbe))
+      (setq c (vla-get-TrueColor obj))
+      (vla-SetRGB c (car rgb) (cadr rgb) (caddr rgb))
+      (vla-put-TrueColor obj c))
+    (T (vla-put-Color obj sonst))
+  )
+)
+
+;; Reihe: Rechteck L x T um die Schienenlinie (0,0)-(L,0), Farbe aus
+;; lager.json darstellung.reihe.farbe (sonst VONLAYER).
+(defun lg-reihe-blockdef (laenge tiefe / h f)
+  (setq h (/ tiefe 2.0)
+        f (lg-farbe-dxf (lg-vorgabe '("darstellung" "reihe" "farbe") nil)))
   (lg-blockdef (lg-reihe-blockname laenge tiefe)
-    (append (list (lg-geom-rechteck 0.0 (- h) laenge h)
-                  (lg-geom-linie '(0.0 0.0 0.0) (list laenge 0.0 0.0)))
+    (append (list (append (lg-geom-rechteck 0.0 (- h) laenge h) f)
+                  (append (lg-geom-linie '(0.0 0.0 0.0) (list laenge 0.0 0.0)) f))
             (lg-attdefs-unsichtbar *lg-schema-reihe*)))
 )
 
@@ -795,33 +834,53 @@
 
 (if (not (boundp '*lg-schraffur-gemeldet*)) (setq *lg-schraffur-gemeldet* nil))
 
-;; Schraffur in eine vorhandene Blockdefinition einsetzen: umrandet die
-;; erste Polylinie der Definition, Layer 0 + Farbe VONBLOCK (erbt den
-;; Geschoss-Layer der Referenz). vorgabe = (muster massstab winkel-grad).
-;; Rueckgabe: T oder nil (Muster unbekannt o.ae., Meldung).
-(defun lg-schraffur-einsetzen (bname vorgabe / blk pl h res)
+;; Schraffur anlegen (Block oder Modellbereich): owner = Block-/Bereichs-
+;; objekt, pl = geschlossene Polylinie (vla) als Umgrenzung, vorgabe =
+;; (muster massstab winkel-grad), farbe aus lager.json, sonst-farbe wie bei
+;; lg-farbe-setzen, z = Erhebung. Rueckgabe: Hatch-Objekt oder nil (Meldung).
+(defun lg-schraffur-anlegen (owner pl vorgabe farbe sonst-farbe layer z wo / h res)
   (setq res
     (vl-catch-all-apply
       '(lambda ()
-         (setq blk (vla-Item (vla-get-Blocks (vla-get-ActiveDocument (vlax-get-acad-object))) bname))
-         (vlax-for o blk
-           (if (and (null pl) (= (vla-get-ObjectName o) "AcDbPolyline")) (setq pl o)))
-         (setq h (vla-AddHatch blk 1 (car vorgabe) :vlax-false))   ; 1 = vordefiniert
-         (vla-put-Layer h "0")
-         (vla-put-Color h 0)                                       ; 0 = VONBLOCK
+         (setq h (vla-AddHatch owner 1 (car vorgabe) :vlax-false))   ; 1 = vordefiniert
+         (vla-put-Layer h layer)
+         (lg-farbe-setzen h farbe sonst-farbe)
          (vla-put-PatternScale h (cadr vorgabe))
          (vla-put-PatternAngle h (* (/ (caddr vorgabe) 180.0) pi))
+         (if (and z (/= z 0.0)) (vla-put-Elevation h z))
          (vlax-invoke h 'AppendOuterLoop (list pl))
          (vla-Evaluate h)
-         T)))
+         h)))
   (if (vl-catch-all-error-p res)
     (progn
       (if h (vl-catch-all-apply 'vla-Delete (list h)))
-      (princ (ssg-textf "lg-schraffur-fehler" (list (car vorgabe) bname (vl-catch-all-error-message res))))
+      (princ (ssg-textf "lg-schraffur-fehler" (list (car vorgabe) wo (vl-catch-all-error-message res))))
       nil)
     res)
 )
 
+(defun lg-bloecke ()
+  (vla-get-Blocks (vla-get-ActiveDocument (vlax-get-acad-object)))
+)
+
+;; Schraffur in eine vorhandene Blockdefinition einsetzen: umrandet die
+;; erste Polylinie der Definition, Layer 0; ohne farbe VONBLOCK (erbt den
+;; Geschoss-Layer der Referenz). Rueckgabe: T oder nil.
+(defun lg-schraffur-einsetzen (bname vorgabe farbe / blk pl)
+  (setq blk (vl-catch-all-apply 'vla-Item (list (lg-bloecke) bname)))
+  (if (not (vl-catch-all-error-p blk))
+    (progn
+      (vlax-for o blk
+        (if (and (null pl) (= (vla-get-ObjectName o) "AcDbPolyline")) (setq pl o)))
+      (if (and pl (lg-schraffur-anlegen blk pl vorgabe farbe 0 "0" nil bname)) T)))
+)
+
+;; Farbe der Gangschraffur eines Belags (belag_schraffur.<belag>.farbe).
+(defun lg-schraffur-farbe (belag tabelle / e)
+  (if (and belag (= (type belag) 'STR) (setq e (ssg-json-get tabelle belag)) (listp e))
+    (ssg-json-get e "farbe"))
+)
+
 (defun lg-gang-blockdef (laenge breite belag / h bname tab vorgabe)
   (setq h (/ breite 2.0)
         bname (lg-gang-blockname laenge breite belag)
@@ -838,7 +897,7 @@
   ;; Schraffur nur einmal je Definition (auch nach einer Neudefinition)
   (if (and vorgabe
            (not (vl-some '(lambda (ed) (= (cdr (assoc 0 ed)) "HATCH")) (lg-blockdef-objekte bname))))
-    (lg-schraffur-einsetzen bname vorgabe))
+    (lg-schraffur-einsetzen bname vorgabe (lg-schraffur-farbe belag tab)))
   bname
 )
 
@@ -873,7 +932,9 @@
 ;; anwenden) - fuer das Bearbeiten von Hand. Rueckgabe: neuer ename.
 (defun lg-linie-neu-aufbauen-sperre (ent werte / neu)
   (if (setq neu (lg-linie-neu-aufbauen ent werte))
-    (lg-sperre-anwenden neu))
+    (progn
+      (lg-sperre-anwenden neu)
+      (lg-darstellung-geschoss (atoi (cond ((cdr (assoc "GESCHOSS" (ssg-attrib-read neu)))) ("0"))))))
   neu
 )
 
@@ -1398,6 +1459,7 @@
       (lg-attribute-setzen bereich-ent (list (cons "RESTBREITE_mm" (lg-mm-str (cadr erg)))))
       (princ (ssg-textf "lg-bereich-gefuellt"
                (list (cdr (assoc "NR" a)) (itoa n-reihen) (itoa n-gaenge) (lg-mm-str (cadr erg)))))
+      (lg-darstellung-geschoss (atoi gs))
       (list n-reihen n-gaenge (cadr erg))
     )
   )
@@ -1696,14 +1758,146 @@
         (progn
           (lg-ldata-setzen "GESCHOSS_AKTIV" (car erg))
           (princ (ssg-text "lg-kopie-hinweis-aktiv"))))
+      (foreach nr erg (lg-darstellung-geschoss nr))
       (reverse erg))
   )
 )
 
+;; ============================================================
+;; DARSTELLUNG (Absturzsicherung unter den Reihen, Farben)
+;; ============================================================
+;; Unter den Reihen einer Buehne wird die Sicherung je UNTER_REIHE gezeigt:
+;; gitterrost / gitterkorb als Schraffur (Muster/Farbe aus lager.json
+;; darstellung.unter_reihe), der Gitterkorb zusaetzlich mit seiner
+;; seitlichen Abgrenzung als dicke Linie - aber nur an den OFFENEN Kanten:
+;; wo eine andere Reihe anliegt (Ruecken an Ruecken), gibt es keine
+;; Abgrenzung (lg-sicherung-geometrie, gleiche Regel wie der Export).
+;; Die Objekte sind lose (Layer LG_Sicherung_G<n>, XDATA rolle=sicherung)
+;; und werden bei jedem Neuaufbau des Geschosses komplett ersetzt.
+
+;; wirksames UNTER_REIHE einer Reihe (Bereich ueber XDATA, sonst Vorgabe).
+(defun lg-reihe-unter-ent (ent buehne-p / b)
+  (setq b (lg-ent-aus-handle (lg-xdata-wert ent "bereich")))
+  (lg-unter-reihe-wert (if b (cdr (assoc "UNTER_REIHE" (ssg-attrib-read b))))
+                       (lg-unter-reihe-vorgabe) buehne-p)
+)
+
+;; Alle Sicherungs-Objekte auf layer loeschen. Rueckgabe: Anzahl.
+(defun lg-sicherung-loeschen (layer / ss i)
+  (setq i 0)
+  (if (setq ss (ssget "_X" (list (cons 8 layer) (list -3 (list *lg-app*)))))
+    (repeat (sslength ss)
+      (if (= (lg-xdata-wert (ssname ss i) "rolle") "sicherung") (entdel (ssname ss i)))
+      (setq i (1+ i))))
+  i
+)
+
+(defun lg-sicherung-markieren (ent)
+  (lg-xdata-setzen ent (list (cons "rolle" (cons 1000 "sicherung"))))
+  ent
+)
+
+;; LWPOLYLINE in WCS (2D-Punkte + Erhebung z) per entmake. Rueckgabe: ename.
+(defun lg-lwpoly-make (pts z layer geschlossen breite farbe / )
+  (entmakex
+    (append
+      (list '(0 . "LWPOLYLINE") '(100 . "AcDbEntity") (cons 8 layer))
+      (lg-farbe-dxf farbe)
+      (list '(100 . "AcDbPolyline") (cons 90 (length pts)) (cons 70 (if geschlossen 1 0)) (cons 38 z))
+      (if breite (list (cons 43 breite)))
+      (mapcar '(lambda (p) (list 10 (car p) (cadr p))) pts)))
+)
+
+;; Sicherung unter den Reihen eines Geschosses neu zeichnen. Auf
+;; Hallenboden wird nur geloescht. Rueckgabe: Anzahl neuer Objekte.
+(defun lg-darstellung-geschoss (nr / g lay buehne ents reihen zs tab vorgabe rand-farbe breite n pl h ent)
+  (setq n 0)
+  (if (setq g (lg-geschoss-finden nr))
+    (progn
+      (setq lay (lg-layer "sicherung" nr))
+      (lg-sicherung-loeschen lay)
+      (setq buehne (lg-buehne-p (cdr (assoc "BELAG_ART" (caddr g)))))
+      (if buehne
+        (progn
+          (setq ents (vl-remove-if-not '(lambda (e) (= (cdr (assoc "GESCHOSS" (ssg-attrib-read e))) (itoa nr)))
+                                       (lg-alle-bloecke "LG_REIHE_*"))
+                reihen (mapcar '(lambda (e) (list (lg-linie-polygon e) (lg-reihe-unter-ent e T))) ents)
+                zs (mapcar '(lambda (e) (cond ((caddr (cdr (assoc 10 (entget e))))) (0.0))) ents)
+                tab (lg-vorgabe '("darstellung" "unter_reihe") nil)
+                rand-farbe (lg-vorgabe '("darstellung" "unter_reihe" "gitterkorb" "rand" "farbe") nil)
+                breite (lg-zahl (lg-vorgabe '("darstellung" "unter_reihe" "gitterkorb" "rand" "breite_mm") 50)))
+          (foreach x (lg-sicherung-geometrie reihen 1.0)
+            (if (= (car x) "flaeche")
+              (if (setq vorgabe (lg-schraffur-vorgabe (cadr x) tab))
+                (progn
+                  (setq pl (lg-lwpoly-make (caddr x) (nth (cadddr x) zs) lay T nil nil)
+                        h (lg-schraffur-anlegen (lg-modelspace) (vlax-ename->vla-object pl) vorgabe
+                                                (lg-schraffur-farbe (cadr x) tab) 256 lay
+                                                (nth (cadddr x) zs) lay))
+                  (entdel pl)
+                  (if h (progn (lg-sicherung-markieren (vlax-vla-object->ename h)) (setq n (1+ n))))))
+              (if (setq ent (lg-lwpoly-make (list (cadr x) (caddr x)) (nth (cadddr x) zs) lay nil breite rand-farbe))
+                (progn (lg-sicherung-markieren ent) (setq n (1+ n)))))))))
+  )
+  n
+)
+
+;; Belag einer Gang-Blockdefinition aus ihrem Namen LG_GANG_<L>_<B>_<BELAG>.
+;; Rein, getestet.
+(defun lg-gang-belag-aus-name (bname / teile)
+  (setq teile (ssg-sepliste-split-feld bname "_"))
+  (if (> (length teile) 4) (strcase (ssg-join (cddddr teile) "_") T))
+)
+
+;; Vorhandene Blockdefinitionen an die Farben/Schraffuren aus lager.json
+;; anpassen: LG_REIHE_* bekommen die Reihenfarbe, LG_GANG_* ihre Schraffur
+;; neu (Muster und Farbe je Belag).
+(defun lg-darstellung-definitionen ( / rf tab nm hs belag vorgabe)
+  (setq rf (lg-vorgabe '("darstellung" "reihe" "farbe") nil)
+        tab (lg-vorgabe '("belag_schraffur") nil))
+  (vlax-for b (lg-bloecke)
+    (setq nm (strcase (vla-get-Name b)))
+    (cond
+      ((wcmatch nm "LG_REIHE_*")
+        (vlax-for o b
+          (if (member (vla-get-ObjectName o) '("AcDbPolyline" "AcDbLine"))
+            (lg-farbe-setzen o rf 256))))
+      ((wcmatch nm "LG_GANG_*")
+        (setq hs nil)
+        (vlax-for o b (if (= (vla-get-ObjectName o) "AcDbHatch") (setq hs (cons o hs))))
+        (foreach h hs (vla-Delete h))
+        (setq belag (lg-gang-belag-aus-name nm))
+        (if (setq vorgabe (lg-schraffur-vorgabe belag tab))
+          (lg-schraffur-einsetzen (vla-get-Name b) vorgabe (lg-schraffur-farbe belag tab))))
+    )
+  )
+)
+
+;; Alles neu: Definitionen und die Sicherung aller Geschosse.
+(defun lg-darstellung-alle ( / n)
+  (lg-darstellung-definitionen)
+  (setq n 0)
+  (foreach g (lg-geschosse) (setq n (+ n (lg-darstellung-geschoss (cadr g)))))
+  n
+)
+
 ;; ============================================================
 ;; BEFEHLE
 ;; ============================================================
 
+;; Darstellung aktualisieren: Farben/Schraffuren aus lager.json auf alle
+;; Reihen-/Gang-Definitionen, Sicherung unter den Reihen aller Geschosse
+;; neu (z.B. nach Loeschen von Hand oder Aenderung von lager.json).
+(defun c:LG_DARSTELLUNG ( / n)
+  (ssg-start (ssg-text "lg-titel-darstellung") nil)
+  (setq *lg-daten* nil)                  ; lager.json neu lesen
+  (setq n (lg-darstellung-alle))
+  (command "_.REGEN")
+  (princ (ssg-textf "lg-darstellung-fertig" (list (itoa n))))
+  (ssg-end)
+  (princ)
+)
+
 (defun c:LG_GESCHOSS ( / kontur nr werte blk)
   (ssg-start (ssg-text "lg-titel-geschoss") nil)
   (setq kontur (lg-kontur-waehlen (ssg-text "lg-prompt-kontur-geschoss")))
@@ -1923,6 +2117,7 @@
           (setq n (lg-linien-schleife (ssg-text "lg-prompt-reihe-start")
                     '(lambda (p1 p2) (lg-manuell-einfuegen "reihe" p1 p2 werte))
                     nil))
+          (if (> n 0) (lg-darstellung-geschoss gs))
           (princ (ssg-textf "lg-reihen-eingefuegt" (list (itoa n))))))))
   (ssg-end)
   (princ)
@@ -1984,6 +2179,8 @@
           (setq n (lg-linien-schleife (ssg-text "lg-prompt-gang-start")
                     '(lambda (p1 p2) (lg-gang-einfuegen p1 p2 werte))
                     '(lambda (ecken) (lg-gang-rechteck-einfuegen ecken werte))))
+          ;; ein Gang kann Reihen zerschneiden -> neue offene Kanten
+          (if (> n 0) (lg-darstellung-geschoss gs))
           (princ (ssg-textf "lg-gaenge-eingefuegt" (list (itoa n))))))))
   (ssg-end)
   (princ)
@@ -1997,7 +2194,10 @@
     ((= name "LG_GESCHOSS")
       ;; Nummer bleibt fest - an ihr haengen Layer und GESCHOSS der Kinder
       (if (setq neu (lg-dialog "lg_geschoss" *lg-felder-geschoss* a '("nr")))
-        (progn (lg-attribute-setzen ent neu) (princ (ssg-text "lg-geaendert")))))
+        (progn (lg-attribute-setzen ent neu)
+               ;; Belag kann zwischen Buehne und Hallenboden wechseln
+               (lg-darstellung-geschoss (atoi (cond ((cdr (assoc "NR" a))) ("0"))))
+               (princ (ssg-text "lg-geaendert")))))
     ((= name "LG_BEREICH")
       (if (setq neu (lg-dialog "lg_bereich" *lg-felder-bereich* a nil))
         (progn
@@ -2290,13 +2490,13 @@
        (<= (cadr (car b)) (+ (cadr (cadr a)) tol)) (<= (cadr (car a)) (+ (cadr (cadr b)) tol)))
 )
 
-;; Offener Teil der Kante (p q): Laenge minus die Abschnitte, auf denen eine
-;; Kante eines Nachbar-Rechtecks kollinear (Abstand < tol) aufliegt.
-(defun lg-kante-offen (kante nachbarn tol / p q len ux uy zu c d dx dy dl t1 t2 lo hi)
+;; Offene Abschnitte der Kante (p q) als ((t0 t1) ...) in mm ab p: die
+;; Kante ohne die Abschnitte, auf denen eine Kante eines Nachbar-Rechtecks
+;; kollinear (Abstand < tol) aufliegt. Stuecke bis tol fallen weg.
+(defun lg-kante-offen-intervalle (kante nachbarn tol / p q len ux uy zu c d dx dy dl t1 t2 lo hi)
   (setq p (car kante) q (cadr kante) zu nil
         len (distance (list (car p) (cadr p)) (list (car q) (cadr q))))
-  (if (< len 1e-9)
-    0.0
+  (if (>= len 1e-9)
     (progn
       (setq ux (/ (- (car q) (car p)) len) uy (/ (- (cadr q) (cadr p)) len))
       (foreach f nachbarn
@@ -2313,22 +2513,35 @@
                     lo (max 0.0 (min t1 t2))
                     hi (min len (max t1 t2)))
               (if (> (- hi lo) tol) (setq zu (cons (list lo hi) zu)))))))
-      (apply '+ (cons 0.0 (mapcar '(lambda (i) (- (cadr i) (car i)))
-                                  (ssg-intervalle-minus (list (list 0.0 len)) zu))))))
+      (vl-remove-if '(lambda (i) (<= (- (cadr i) (car i)) tol))
+                    (ssg-intervalle-minus (list (list 0.0 len)) zu))))
+)
+
+;; Offene Laenge der Kante (Summe von lg-kante-offen-intervalle).
+(defun lg-kante-offen (kante nachbarn tol)
+  (apply '+ (cons 0.0 (mapcar '(lambda (i) (- (cadr i) (car i)))
+                              (lg-kante-offen-intervalle kante nachbarn tol))))
+)
+
+;; Ecken der Rechtecke aus ecken-liste, deren Huelle die von Nr. i beruehrt
+;; (ohne i selbst). bbs = Huellen in derselben Reihenfolge.
+(defun lg-nachbarn (i ecken-liste bbs tol / j erg)
+  (setq j 0 erg nil)
+  (foreach f ecken-liste
+    (if (and (/= i j) (lg-bbox-beruehrt-p (nth i bbs) (nth j bbs) tol))
+      (setq erg (cons f erg)))
+    (setq j (1+ j)))
+  erg
 )
 
 ;; Offene Kantenlaenge je Reihe. ecken-liste = je Reihe die 4 Ecken (2D)
 ;; aus lg-linie-polygon. Eine Kante ist dort zu, wo eine Kante einer ANDEREN
 ;; Reihe kollinear darauf liegt (z.B. Ruecken an Ruecken). Rueckgabe je
 ;; Reihe (offen-laengs offen-stirn) in mm.
-(defun lg-reihen-offene-kanten (ecken-liste tol / bbs erg i j k bb nachbarn l s o)
+(defun lg-reihen-offene-kanten (ecken-liste tol / bbs erg i k nachbarn l s o)
   (setq bbs (mapcar 'ssg-poly-bbox ecken-liste) erg nil i 0)
   (foreach e ecken-liste
-    (setq bb (nth i bbs) nachbarn nil j 0 l 0.0 s 0.0 k 0)
-    (foreach f ecken-liste
-      (if (and (/= i j) (lg-bbox-beruehrt-p bb (nth j bbs) tol))
-        (setq nachbarn (cons f nachbarn)))
-      (setq j (1+ j)))
+    (setq nachbarn (lg-nachbarn i ecken-liste bbs tol) l 0.0 s 0.0 k 0)
     (foreach kante (lg-rechteck-kanten e)
       (setq o (lg-kante-offen kante nachbarn tol))
       (if (= 0 (rem k 2)) (setq l (+ l o)) (setq s (+ s o)))
@@ -2337,6 +2550,39 @@
   (reverse erg)
 )
 
+;; Geometrie der Absturzsicherung unter den Reihen EINES Geschosses (rein,
+;; getestet). reihen = ((ecken unter) ...), ecken 2D aus lg-linie-polygon,
+;; unter = gitterrost/gitterkorb/keine. Rueckgabe:
+;;   ("flaeche" unter ecken i)  je Reihe mit gitterrost oder gitterkorb
+;;   ("rand" p1 p2 i)           je OFFENEM Kantenabschnitt einer Gitterkorb-
+;;                              Reihe - wo eine andere Reihe (gleich welche
+;;                              Sicherung) anliegt, gibt es keine Abgrenzung
+;; i = Index der Reihe (fuer Z und Zuordnung).
+(defun lg-sicherung-geometrie (reihen tol / alle bbs erg i e u nachbarn p q len ux uy)
+  (setq alle (mapcar 'car reihen) bbs (mapcar 'ssg-poly-bbox alle) erg nil i 0)
+  (foreach r reihen
+    (setq e (car r) u (cadr r))
+    (if (member u '("gitterrost" "gitterkorb"))
+      (setq erg (cons (list "flaeche" u e i) erg)))
+    (if (= u "gitterkorb")
+      (progn
+        (setq nachbarn (lg-nachbarn i alle bbs tol))
+        (foreach k (lg-rechteck-kanten e)
+          (setq p (car k) q (cadr k)
+                len (distance (list (car p) (cadr p)) (list (car q) (cadr q))))
+          (if (> len 1e-9)
+            (progn
+              (setq ux (/ (- (car q) (car p)) len) uy (/ (- (cadr q) (cadr p)) len))
+              (foreach iv (lg-kante-offen-intervalle k nachbarn tol)
+                (setq erg (cons (list "rand"
+                                      (list (+ (car p) (* ux (car iv))) (+ (cadr p) (* uy (car iv))))
+                                      (list (+ (car p) (* ux (cadr iv))) (+ (cadr p) (* uy (cadr iv))))
+                                      i)
+                                erg))))))))
+    (setq i (1+ i)))
+  (reverse erg)
+)
+
 ;; Gitterkorb der Reihen EINES Geschosses vervollstaendigen: Reihen mit
 ;; gitterkorb (OBJ hoehe_mm) bekommen Boden (Laenge x Tiefe), offene Kanten
 ;; (gegen alle Reihen des Geschosses) und Seitenflaeche (offen x Hoehe).

Lisp/README.md

@@ -885,6 +885,7 @@ Phase 0 + 1 (Mengen, 2D).
 | `c:LG_GANG` | Einzelne Gaenge (Dialog `lg_gang`: Breite, Art gang/randgang/quergang, Belag), mittig auf der Linie - oder ueber die Option `Rechteck` als Flaeche, gezeichnet mit dem BricsCAD-Befehl RECHTECK samt aller seiner Optionen (Abmessungen, Flaeche, Drehung ...; `lg-rechteck-zeichnen`, Auswertung `lg-rechteck-ecken-aus-poly`, Fase/Rundung wird abgelehnt) (Lage und Breite aus dem Rechteck, laengere Seite = Gangrichtung; Kern `lg-gang-aus-ecken`, `lg-gang-rechteck-einfuegen`, `Linie` schaltet zurueck); liegt die Mitte in einem Bereich, wird der Gang mit ihm verknuepft. Der Gang schneidet seine Flaeche aus den automatisch erzeugten Reihen/Gaengen heraus (`lg-sperre-anwenden`), OHNE den Bereich neu zu berechnen - von Hand geloeschte oder geaenderte Objekte bleiben, wie sie sind; bei jeder Neuberechnung bleibt er stehen (Sperrflaeche) |
 | `c:LG_EDIT` | Bearbeiten (auch per Doppelklick ueber `SSG_BLOCKEDIT`, Zweig `LG_*`): Bereich -> Neuberechnung (von Hand eingefuegte und geaenderte Reihen/Gaenge bleiben stehen und werden ausgespart), Reihe/Gang -> Neuaufbau, danach Zuschnitt der rangniedrigeren Objekte (`auto` < `auto_geaendert` < `manuell`, `lg-quelle-rang`) statt Neuberechnung des Bereichs |
 | `c:LG_REGALE` | Regalreihen `LG_REIHE_*` zaehlen (`lg-reihe-eintrag` + `lg-reihen-auswerten`): Anzahl, Laenge und Laenge x Haengeebenen je Geschoss plus Gesamtsumme in der Befehlszeile |
+| `c:LG_DARSTELLUNG` | Darstellung aktualisieren: Farben/Schraffuren aus `lager.json` (`darstellung`, `belag_schraffur`) auf die Reihen-/Gang-Definitionen, Absturzsicherung unter den Reihen aller Geschosse neu zeichnen (Gitterrost/Gitterkorb als Schraffur, Gitterkorb-Abgrenzung nur an offenen Kanten, Layer `LG_Sicherung_G<n>`). Geschieht nach Aenderungen automatisch fuer das betroffene Geschoss |
 | `c:LAGER_EXPORT` | `<dwg>_lager.json` in `DXFM_RESULTS`: alle Geschosse, Bereiche, Reihen und Gaenge mit Attributen und Geometrie, Kennwerte je Geschoss und gesamt (inkl. Gitterkorb mit offenen Kanten), Herkunft je Kennwert, Warnungen. Kein Python-Schritt |
 | `c:LG_REGELN` | Regelprofil (`cfg/stahlbau/regelwerk/<Land>.json`) mit aufgeloesten Werten und Quellen anzeigen |