;----------------------------------------------------------
;Linien-Pakete ABRUNDEN oder FASEN
;
;Mehrere Linien können in einem Zug bearbeitet werden
;
;Geeignet sind Linien / Polylinien (auch untereinander)
;und geschlossene Polylinien - sofern die AutoCAD-Version 
;das unterstützt (getestet auf AutoCAD 2004).
;
;Kreisbögen sind nicht geeignet ! 
;
;Wenn beide Endpunkte einer offenen Polylinie bearbeitet werden 
;sollen - Polylinie vorher schließen (z.B. Eigenschaftsfenster).
;
;Variante 'Alle Ecken' kann zu unerwarteten Ergebnissen
;führen - dann 'Eine Ecke' wählen !
;Sind Ecken bereits mehrfach gerundet/gefast, können
;Probleme oder unerwartete Ergebnisse auftreten
;
;Für die Größe von Radien/Abständen sind sinnvolle Parameter
;zu wählen (wird nicht geprüft)
;
;
;
;+++++++++++++++++++++ AUSWAHLPRINZIP +++++++++++++++++++++ 
;
;          
;               Punkt1*    //   \\     *Punkt3  
;                        //       \\
;                      //           \\
;                    //       *       \\    
;                  //      Punkt2       \\
;
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
;
;
;
;Flaschenpost - cad.de - 14.02.2005
;Hinweise auch über flaschenpost2000@gmx.de
;
;
;-------------------- ! VIEL SPASS ! ----------------------





(defun C:LPF (/ entscheidung z1 z2 osmode_alt p1 p2 p3 p_liste1 p_liste2 
             linwahl1 linwahl2 vergleich_z a1 b1 c1 a2 b2 c2 schnp1 schnp2
             schnp1_liste schnp2_liste daten_p1 daten_p11 datenp2 datenp22
             schalter pp1_a pp1_b pp2_a pp2_b objpu1 abst1 abstli1 rad1 xpu ypu)
  (command "_.UCS" "_D" "flaschenpost_aktuell") 
  (command "_.UCS" "_S" "flaschenpost_aktuell")  
  (command "_.UCS" "_W")
  (setq entscheidung "F") 
  (prompt "\nAbstandsfestlegung bei Staffel-Fasen aus Paket 1 (rote Markierung) !")  
  (setq rad_eck "Eine Ecke")
  (linien_auswahl)
)  

(defun C:LPA (/ entscheidung z1 z2 osmode_alt p1 p2 p3 p_liste1 p_liste2 
             linwahl1 linwahl2 vergleich_z a1 b1 c1 a2 b2 c2 schnp1 schnp2
             schnp1_liste schnp2_liste daten_p1 daten_p11 datenp2 datenp22
             schalter pp1_a pp1_b pp2_a pp2_b objpu1 abst1 abstli1 rad1 xpu ypu)
  (command "_.UCS" "_D" "flaschenpost_aktuell") 
  (command "_.UCS" "_S" "flaschenpost_aktuell")  
  (command "_.UCS" "_W")
  (setq entscheidung "A")
  (prompt "\nAbstandsfestlegung bei Staffel-Radien aus Paket 1 (rote Markierung) !")
  (setq rad_eck "Eine Ecke")
  (linien_auswahl)
)   



(defun linien_auswahl ()

 
  ;Mittelpunkt
  (defun Pu_add/2 (z1 z2) (/ (+ z1 z2) 2) ) 
  ;Punkt 1/10 von 2 Auswahlpunkten
  (defun Pu_add/10 (z1 z2) (+ (/ (- z2 z1) 10) z1) )
 
  (setq osmode_alt (getvar "OSMODE"))
  (setvar "OSMODE" 0)
  
  (initget 33) 
  (setq p1 (getpoint "\nErsten Punkt (außen) wählen: "))
  (initget 33)
  (setq p2 (getpoint p1 "\nZweiten Punkt (innen) wählen: ")) 

  (grdraw p1 p2 1 1)

  (setq p_liste1 (list p1 p2))
  (setq linwahl1 
        (ssget "_F" p_liste1 '((-4 . "<OR")(0 . "LINE")(0 . "LWPOLYLINE")(-4 . "OR>")) ))
  (if (/= linwahl1 nil)
    (progn
     (setq n -1) 
     (repeat (sslength linwahl1)
             (redraw (ssname linwahl1 (setq n (1+ n))) 3)
     )
    );progn 
  );if

  (initget 33)
  (setq p3 (getpoint p2 "\nDritten Punkt (außen) wählen:"))

  (grdraw p2 p3 -1 1)
 
  (setq p_liste2 (list p3 p2))
  (setq linwahl2 
        (ssget "_F" p_liste2 '((-4 . "<OR")(0 . "LINE")(0 . "LWPOLYLINE")(-4 . "OR>")) ))
  (if (/= linwahl2 nil)
    (progn
     (setq n -1) 
     (repeat (sslength linwahl2)
             (redraw (ssname linwahl2 (setq n (1+ n))) 3)
     )
    );progn
  );if

  (setq vergleich_z "ok")
  (if (and (/= linwahl1 nil) (/= linwahl2 nil)
           (= (sslength linwahl1) (sslength linwahl2))
      );and     
      (progn       
      (setq n 0) 
   (while (> (sslength linwahl1) n)
      (if (= (cdr (assoc 0 (entget (ssname linwahl1 n)))) "LINE")
         (progn
          (setq a1  (last (cdr (assoc 10 (entget (ssname linwahl1 n))))) ) 
          (setq b1  (last (cdr (assoc 11 (entget (ssname linwahl1 n))))) )
         )  
         (progn
          (setq a1  (cdr (assoc 38 (entget (ssname linwahl1 n)))) )
          (setq b1 a1)
         )
      );if 
      (if (= (cdr (assoc 0 (entget (ssname linwahl2 n)))) "LINE")
         (progn
          (setq a2  (last (cdr (assoc 10 (entget (ssname linwahl2 n))))) ) 
          (setq b2  (last (cdr (assoc 11 (entget (ssname linwahl2 n))))) )
         )  
         (progn
          (setq a2  (cdr (assoc 38 (entget (ssname linwahl2 n)))) )
          (setq b2 a2)
         )
       );if 
       (setq vergleich_z "nicht koplanar")        
       (if (= a1 b1 a2 b2)
           (setq vergleich_z "ok")
           (progn  
             (setq vergleich_z "nicht koplanar")
             (setq n (sslength linwahl1))    
            );progn
        );if         
       (setq n (1+ n))  
    );while
   );progn
  );if


  (cond 
   ((and (/= linwahl1 nil) (= linwahl2 nil))
           (progn 
            (command "_.redraw")
            (prompt "\nUngültige Auswahl - jeweils gleiche Anzahl Linien erforderlich !")
            (setq n -1) 
            (repeat (sslength linwahl1)
                    (redraw (ssname linwahl1 (setq n (1+ n))) 4)
            )
            (linien_auswahl)
           ); progn
   )  
   ((and (= linwahl1 nil) (/= linwahl2 nil))
           (progn 
            (command "_.redraw")
            (prompt "\nUngültige Auswahl - jeweils gleiche Anzahl Linien erforderlich !")
            (setq n -1) 
            (repeat (sslength linwahl2)
                    (redraw (ssname linwahl2 (setq n (1+ n))) 4)
            )
            (linien_auswahl)
           ); progn
   )  
   ((and (/= linwahl1 nil) (/= linwahl2 nil)
         (/= (sslength linwahl1) (sslength linwahl2)) );and   
           (progn 
            (command "_.redraw")
            (prompt "\nUngültige Auswahl - jeweils gleiche Anzahl Linien erforderlich !")
            (setq n -1) 
            (repeat (sslength linwahl1)
                    (redraw (ssname linwahl1 (setq n (1+ n))) 4)
            )
            (setq n -1) 
            (repeat (sslength linwahl2)
                    (redraw (ssname linwahl2 (setq n (1+ n))) 4)
            )
            (linien_auswahl)
           ); progn
   )  

   ((or (= linwahl1 nil) (= linwahl2 nil)) (lpa_lpf_ende))

   ((= vergleich_z "nicht koplanar") 
         (progn 
           (command "_.redraw")
           (setq n -1) 
           (repeat (sslength linwahl1)
                   (redraw (ssname linwahl1 (setq n (1+ n))) 4)
           )
           (setq n -1) 
           (repeat (sslength linwahl2)
                   (redraw (ssname linwahl2 (setq n (1+ n))) 4)
           )
           (lpa_lpf_ende)
         );progn  
   ) 
   ((wahl_radius_abstand))
  );cond  
 

);defun   


(defun wahl_radius_abstand ()
 
  (setq dimzin_alt (getvar "DIMZIN"))  
  (setvar "DIMZIN" 0)
  
  (if (= rad_alt nil)(setq rad_alt 0) )
  (if (= rad_mod nil)(setq rad_mod "Staffel-") )
  

  
  (if (= entscheidung "F")
    (setq rad_wahl (getstring
    (strcat "\nFASEN>>> Innenfase <" (rtos rad_alt 2 3) "> --- [Staffel-]/[Gleiche] 45°-Fasen <" 
             rad_mod "> --- [Eine]/[Alle] PL-Ecken(n) <" rad_eck ">: "))   ) 
    (setq rad_wahl (getstring
    (strcat "\nRUNDEN>>> Innenradius <" (rtos rad_alt 2 3) "> +++ [Staffel-]/[Gleiche] Radien <" 
             rad_mod "> +++ [Eine]/[Alle] PL-Ecken(n) <" rad_eck ">: "))     ) 
  );if
  
  (cond 
   ((or (= rad_wahl "s")(= rad_wahl "S"))  
    (progn (setq rad_mod "Staffel-")(setq rad_alt rad) (wahl_radius_abstand)) ) 
  
   ((or (= rad_wahl "g")(= rad_wahl "G"))
    (progn (setq rad_mod "Gleiche")(setq rad_alt rad) (wahl_radius_abstand)) )
  
   ((or (= rad_wahl "e")(= rad_wahl "E"))
    (progn (setq rad_eck "Eine Ecke")(setq rad_alt rad) (wahl_radius_abstand)) )
 
   ((or (= rad_wahl "a")(= rad_wahl "A"))
    (progn 
      (setq rad_eck "Alle Ecken")
      (setq rad_alt rad) 
      (setq n 0)
         (while (> (sslength linwahl1) n)
          (if (or (= (cdr (assoc 0 (entget (ssname linwahl1 n)))) "LINE")
                  (= (cdr (assoc 0 (entget (ssname linwahl2 n)))) "LINE")  )
            (progn
             (prompt "\nAlle Ecken können nur bei Polylinien mit einmal abgefast/abgerundet werden !")       
             (setq rad_eck "Eine Ecke")
             (setq n (sslength linwahl1))
            );progn  
          (setq n (1+ n)) 
         );if
       );while
      );progn 
   (wahl_radius_abstand)
   )

   ((and (= (atof rad_wahl) 0)(/= rad_wahl "0")) 
    (progn (setq rad rad_alt)(setq rad_alt rad)(setvar "DIMZIN" dimzin_alt)
            (punkte_ermitteln) ) )
 
   ((setq rad (atof rad_wahl)) 
    (progn (setq rad_alt rad)(setvar "DIMZIN" dimzin_alt)(punkte_ermitteln) ))
 
 );cond

 
);defun (wahl_radius_abstand)


;;;Schnittpunkte
(defun punkte_ermitteln ()


  (setq linien_anz (sslength linwahl1))

  ;Punkte für PAKET 1
  (setq punktliste_p1 nil)
  (setq schnp1_liste nil)
  (setq schalter 0)
  (setq n1 -1) 

  (repeat linien_anz
     (setq daten_p1 (entget (ssname linwahl1 (setq n1 (1+ n1)))) )
     (setq daten_p11 (entget (ssname linwahl1 n1)) ) 
      (while (setq daten_p1 (member (assoc 10 daten_p1) daten_p1))
            (setq punkte_p1 (cons (cdr (car daten_p1)) punktliste_p1 ) )
            (setq daten_p1 (cdr daten_p1))
            (setq punktliste_p1 punkte_p1) 
      );while
      (if (= (cdr (assoc 70 (entget (ssname linwahl1 n1)))) 1); geschlossene P-linien
          (setq punktliste_p1 (cons (last punktliste_p1) punktliste_p1) )
      )
      (if (= (cdr (assoc 0 (entget (ssname linwahl1 n1)))) "LINE"); einfache Linien
          (progn 
           (setq daten_p11 (cdr (assoc 11 daten_p11)) )
           (setq punktliste_p1 (cons daten_p11 punktliste_p1) )
          )
      )
      (setq n 0) 
      (while (= schalter 0)
            (setq pp1_a (list (car (nth n punktliste_p1))(cadr (nth n punktliste_p1)) 0.0) )
            (setq pp1_b (list (car (nth (1+ n) punktliste_p1))(cadr (nth (1+ n) punktliste_p1)) 0.0) )
            (if (= (setq schnp1 (inters p1 p2 pp1_a pp1_b)) nil)
                (setq schalter 0)
                (setq schalter 1)
            ) 
            (setq n (1+ n))
       );while
       (setq schalter 0)
       (setq punktliste_p1 nil)
       (setq schnp1_liste (cons schnp1 schnp1_liste))
  );repeat


  ;Punkte für PAKET 2
  (setq punktliste_p2 nil)
  (setq schnp2_liste nil)
  (setq schalter 0)
  (setq n2 -1) 

  (repeat linien_anz
     (setq daten_p2 (entget (ssname linwahl2 (setq n2 (1+ n2)))) )
     (setq daten_p22 (entget (ssname linwahl2 n2)) ) 
     (while (setq daten_p2 (member (assoc 10 daten_p2) daten_p2))
            (setq punkte_p2 (cons (cdr (car daten_p2)) punktliste_p2 ) )
            (setq daten_p2 (cdr daten_p2))
            (setq punktliste_p2 punkte_p2) 
     );while
     (if (= (cdr (assoc 70 (entget (ssname linwahl2 n2)))) 1); geschlossene P-linien
         (setq punktliste_p2 (cons (last punktliste_p2) punktliste_p2) )
     )
     (if (= (cdr (assoc 70 (entget (ssname linwahl2 n2)))) nil); einfache Linien
          (progn 
           (setq daten_p22 (cdr (assoc 11 daten_p22)) )
           (setq punktliste_p2 (cons daten_p22 punktliste_p2) )
          )
     )
    (setq n 0)
    (while (> (length punktliste_p1) n)
       (if (/= (last (nth n punktliste_p1)) 0)
         (progn
           (prompt "\nZ-Koordinaten müssen 0 sein !")       
           (setq n (length punktliste_p1))
           (lpa_lpf_ende)
         );progn  
         (setq n (1+ n)) 
      );if
   );while
   (setq n 0)
   (while (= schalter 0)
           (setq pp2_a (list (car (nth n punktliste_p2))(cadr (nth n punktliste_p2)) 0.0) )
           (setq pp2_b (list (car (nth (1+ n) punktliste_p2))(cadr (nth (1+ n) punktliste_p2)) 0.0) ) 
           (if (= (setq schnp2 (inters p2 p3 pp2_a pp2_b)) nil)
               (setq schalter 0)
               (setq schalter 1)
           ) 
           (setq n (1+ n))
     );while
   (setq schalter 0)
   (setq punktliste_p2 nil)
   (setq schnp2_liste (cons schnp2 schnp2_liste))
  );repeat

  (abstaende_ermitteln)


);defun (punkte_ermitteln)


(defun abstaende_ermitteln () 

  ;;;Abstände ermitteln 1
  (setq objpu1 (nth 0 schnp1_liste))
  (command "_.UCS" "_N" "_OB" objpu1)
  (setq abst1 nil)
  (setq n1 0)
  (setq abstli1  (list 0))
  (repeat (1- linien_anz)
      (setq abst1 (abs (- (cadr (trans (nth n1 schnp1_liste) 0 1)) 
            (cadr (trans (nth (1+ n1) schnp1_liste)0 1) )  ) ))
      (setq abst1 (append (list abst1) abstli1 ))
      (setq abstli1  abst1) 
      (setq n1 (1+ n1))
  )
  (command "_.UCS" "_W")
 
  (setq rad1 rad)  

  (if (= entscheidung "A")
      (linien_abrunden)
      (linien_fasen)
  )

); defun (abstaende_ermitteln)



(defun linien_fasen ()

  (setvar "CHAMFERA" rad)
  (setvar "CHAMFERB" rad)   

  (defun kath22-5 (b)(* (/ (sin (/ pi 8))(cos (/ pi 8))) b)  )

   (setq n -1)
   (repeat linien_anz
      (setq xpu (nth (setq n (1+ n)) schnp1_liste)) 
      (setq ypu (nth n schnp2_liste) )
      (if (= rad_mod "Staffel-"); Staffel- oder Gleiche Radien            
         (progn
           (setvar "CHAMFERA" (setq rad1 (- (+ rad1 (nth n (reverse abstli1 )))
                    (kath22-5 (nth n (reverse abstli1 ))) )) )
           (setvar "CHAMFERB" rad1)
         )
       );if   
     (If (= rad_eck "Eine Ecke")
        (command "_.CHAMFER" xpu ypu)
        (progn
          (if (and (= rad_eck "Alle Ecken")(eq (ssname linwahl1 n) (ssname linwahl2 n) ))
          (command "_.CHAMFER" "_P" xpu)
            (progn    
              (command "_.CHAMFER" xpu ypu)
              (command "_.CHAMFER" "_P" xpu)
            )  
          );if 
        );progn
      );if    
  );repeat
  
  (setvar "OSMODE" osmode_alt)
  (command "_.UCS" "_R" "flaschenpost_aktuell")
  (command "_.UCS" "_D" "flaschenpost_aktuell") 
  (command "_.REDRAW")  
  (princ)
  

);defun (linien_fasen)




(defun linien_abrunden ()

  (setvar "FILLETRAD" rad)
  (setq n -1)
  (repeat linien_anz
   (setq xpu (nth (setq n (1+ n)) schnp1_liste)) 
   (setq ypu (nth n schnp2_liste) )
   (if (= rad_mod "Staffel-"); Staffel- oder Gleiche Radien            
       (setvar "FILLETRAD" (setq rad1 (+ rad1 (nth n (reverse abstli1)))) )        
   );if   
   (if (= rad_eck "Eine Ecke")
       (command "_.fillet" xpu ypu)
       (progn
        (if (and (= rad_eck "Alle Ecken")(eq (ssname linwahl1 n)(ssname linwahl2 n) ))
                 (command "_.fillet" "_P" xpu)
                 (progn    
                 (command "_.fillet" xpu ypu)
                 (command "_.fillet" "_P" xpu)
            )  
        );if 
      );progn 
   );if    
  );repeat
 

  (setvar "OSMODE" osmode_alt) 
  (command "_.UCS" "_R" "flaschenpost_aktuell")
  (command "_.UCS" "_D" "flaschenpost_aktuell") 
  (command "_.REDRAW")   
  (princ)

);(defun (linien_abrunden)

(defun lpa_lpf_ende ()

  (if (/= linwahl1 nil) 
     (progn
      (setq n -1) 
      (repeat (sslength linwahl1)
         (redraw (ssname linwahl1 (setq n (1+ n))) 4)
      )
     )  
  )
 
  (if (/= linwahl2 nil) 
     (progn
      (setq n -1) 
       (repeat (sslength linwahl2)
          (redraw (ssname linwahl2 (setq n (1+ n))) 4)
       )
     )
  )


  (command "_.REDRAW")   
  (prompt "\nKeine geeigneten Objekte gefunden ! ")

  (if (or (ssget "_F" p_liste1 '((0 . "POLYLINE")) )
          (ssget "_F" p_liste2 '((0 . "POLYLINE")) )
      )
     (progn
       (if (or (ssget "_F" p_liste1 '((70 . 8)) )
               (ssget "_F" p_liste2 '((70 . 8)) )
           )
        (prompt "3D-Polylinien sind nicht geeignet !")
        (prompt "2D-Polylinien erst konvertieren !")
       )  
    );progn 
 );if    

  (if (= vergleich_z "nicht koplanar")(prompt "Unterschiedliche Z-Koordinaten !"))

  (princ)

);defun


;;;;;;;;;;
(prompt "\nLinien-Pakete Abrunden/Fasen geladen - Start mit LPA oder LPF !")
(princ)