Ellipse -> polyligne

[(gile)]

Certaines machines à commande numériques (et certaines chartes graphiques) n'acceptent pas les ellipses.

La variable système PELLIPSE permet, quand elle est à 1, de dessiner une polyligne 2d (old-style) représentant une ellipse avec la commande du même nom. Mais dans ce cas l'option Arc disparaît.

voici donc une routine qui transforme une ellipse (ou un arc elliptique) en polyligne optimisée, et deux commandes :

- EL2PL pour tranformer les ellipses sélectionnées en polylignes

- PELL pour dessiner une polyligne (ou un arc) représentant une ellipse avec toute les options de la commande ELLIPSE

 

EDIT : réparé un dysfonctionnement avec les arcs suivant le point de départ de la polyligne/ellipse

 

EDIT : (20/09/09) réparé un bug avec les arcs elliptiques et fonctionnement quel que soit le plan de construction des ellipses

 

;; ELLIPSE->POLYLINE
;; Tranforme une ellipse (ou un arc elliptique) en polyligne
;;
;; Arguement
;; ent : une ellipse (ename)

(defun ellipse->polyline (ent / elst ucs os ec pe cen ext pa1 pa2 grd prd ang
                         pt1 pt2 mat line ed)
 (setq elst (entget ent))
 (or
   (equal (trans '(0 0 1) 1 0 T) (cdr (assoc 210 elst)) 1e-9)
   (and
     (setq ucs T)
     (command "_.ucs" "_zaxis" '(0 0 0) (trans (cdr (assoc 210 elst)) ent 1 T))
   )
 )
 (setq ec   (getvar "cmdecho")
       pe   (getvar "pellipse")
       elst (entget ent)
       cen  (cdr (assoc 10 elst))
       elv  (caddr (trans cen 0 (cdr (assoc 210 elst))))
       ext  (trans (mapcar '+ cen (cdr (assoc 11 elst))) 0 1)
       cen  (trans cen 0 1)
       pa1  (cdr (assoc 41 elst))
       pa2  (cdr (assoc 42 elst))
       grd  (distance cen ext)
       prd  (* grd (cdr (assoc 40 elst)))
       ang  (angle cen ext)
 )
 (entdel ent)
 (setvar "cmdecho" 0)
 (setvar "pellipse" 1)
 (command "_.ellipse" "_c" "_non" cen "_non" (polar cen ang grd) prd)
 (if (or (/= pa1 0.0) (/= pa2 (* 2 pi)))
   (progn
     (setq ent (entlast)
           pt1 (list (* grd (cos pa1)) (* prd (sin pa1)))
           pt2 (list (* grd (cos pa2)) (* prd (sin pa2)))
           mat (list (list (cos ang) (- (sin ang)) 0)
                     (list (sin ang) (cos ang) 0)
                     '(0 0 1)
               )
           pt1 (mapcar '+ cen (mxv mat pt1))
           pt2 (mapcar '+ cen (mxv mat pt2))
     )
     (command "_.line" "_non" pt1 "_non" pt2 "")
     (setq line (entlast))
     (cond
       ((equal ext pt2 1e-9)
        (command "_.break" ent "_non" pt1 "_non" pt1)
        (entdel (entnext line))
       )
       ((equal ext pt1 1e-9)
        (command "_.break" ent "_non" pt2 "_non" pt2)
        (entdel (entlast))
       )
       ((< (atof (angtos pa2)) (atof (angtos pa1)))
        (setq ed (getvar "EDGEMODE"))
        (setvar "EDGEMODE" 1)
        (command "_.trim" line "" (polar cen (+ ang pi) grd) "")
        (setvar "EDGEMODE" ed)
        (command "_.pedit" (entlast) "_j" (entnext line) "" "")
       )
       (T
        (setq ed (getvar "EDGEMODE"))
        (setvar "EDGEMODE" 1)
        (command "_.trim" line "" ext "")
        (setvar "EDGEMODE" ed)
       )
     )
     (entdel line)
   )
 )
 (command "_.convert" "_p" "_s" (entlast) "")
 (and ucs (command "_.ucs" "_previous"))
 (setvar "cmdecho" ec)
 (setvar "pellipse" pe)
)

;;===================================================;;

;; MXV
;; Applique une matrice de transformation à un vecteur -Vladimir Nesterovsky-
;;
;; Arguments : une matrice et un vecteur

(defun mxv (m v)
 (mapcar (function (lambda (r) (apply '+ (mapcar '* r v)))) m)
)

;;===================================================;;

;; PELL
;; Crée une polyligne représentant une ellipse (ou un arc elliptique)

(defun c:pell (/ *error* ec pe old ent)

 (defun *error* (msg)
   (if (= msg "Fonction annulée")
     (princ)
     (princ (strcat "\nErreur: " msg))
   )
   (setvar "cmdecho" ec)
   (setvar "pellipse" pe)
   (princ)
 )

 (setq ec  (getvar "cmdecho")
       pe  (getvar "pellipse")
       old (entlast)
 )
 (setvar "cmdecho" 1)
 (setvar "pellipse" 0)
 (command "_.ellipse")
 (while (/= 0 (getvar "cmdactive"))
   (command pause)
 )
 (if (not (eq old (setq ent (entlast))))
   (ellipse->polyline ent)
 )
 (setvar "cmdecho" ec)
 (setvar "pellipse" pe)
 (princ)
)

;;===================================================;;

;; EL2PL
;; Change les ellipses (ou arcs elliptiques) en polylignes
(defun c:el2pl (/ ss n)
 (setq n 0)
 (if (setq ss (ssget '((0 . "ELLIPSE"))))
   (progn
     (command "_.undo" "_begin")
     (repeat (sslength ss)
       (ellipse->polyline (ssname ss n))
       (setq n (1+ n))
     )
     (command "_.undo" "_end")
   )
 )
 (princ (strcat "\n\t" (itoa n) " ellipse(s) convertie(s) en polyligne(s)."))
 (princ)
) 

[Edité le 17/9/2007 par (gile)]

[usegomme]

(gile), le champion des transformations , rien de te résiste et ce lisp je ne l'avais pas vu ou perdu de vue , screugneugneu , il n'est pas dans ta liste de lisp !

Ah! au fait , merci.

[(gile)]

Salut,

 

Effectivement il n'est pas dans la liste, mais je ne peux pas tout y mettre non plus et celui-ci semble avoir suscité très peu d'intérêt (1 seule réponse 2 ans après...).

 

Par contre, il devrait pouvoir te servir pour tes fonds elliptiques.

Géométriquement parlant, on ne peut pas décaler une vraie ellipse (la parallèle à une ellipse n'en est pas une). les polylignes elliptiques (pellipse) créées par AutoCAD sont constituées d'une succession d'arcs de cercle tangents, et les arcs de cercle, eux, peuvent être décalé...

[usegomme]

Salut (gile) , merci pour les explications.

Tu as oublier d'insérer dans ton lisp la fonction MXV

;; mxv Apply a transformation matrix to a vector by Vladimir Nesterovsky
(defun mxv (m v)
 (mapcar '(lambda (row) (apply '+ (mapcar '* row v))) m)
) 

 

Sinon lorsqu' une portion d'ellipse a été créée directement avec la cde autocad , lors de la transformation en polyligne, il arrive que ce soit le morceau manquant qui soit reconstitué.

Je crois que c'est une question de sens de création.

 

[(gile)]

Nouvelle version :

- il y avait un bug avec les arcs elliptiques suivant les angles de départ et de fin.

- fonctionne désormais quelque soit le plan de construction des ellipses

[usegomme]

Bonjour (gile) , je trouve ce lisp vraiment très intêressant et j'essaie d'en comprendre le fonctionnement , avec beaucoup de mal d'ailleurs.

Entre autre, je coince sur la notion de déplacement de la fonction "trans".

(trans pt from to [disp])

disp

If present and is not nil, this argument specifies that pt is to be treated as a 3D displacement rather than as a point.

Mon neurone lispeur est grippé , si tu as un peu d'huile ,ce sera bien volontier. Merci.

[(gile)]

Salut,

 

Comme dit (en anglais) dans l'aide, si l'argument disp est spécifié et non nil, l'argument point est considéré comme un vecteur et non comme un point.

 

Si on prend un exemple simple avec un SCU dont les coordonnées de l'origine dans le SCG sont 10,20,0 et n'ayant subit aucune rotation.

Dans ce SCU, un point de coordonnées 1,0,0 est fixe et ces coordonnées dans le SCG sont :

(trans '(1 0 0) 1 0) -> (11.0 20.0 0.0)

Un vecteur, par contre n'est pas fixe et ses coordonnées sont toujours relatives à l'origine du SC quel qu'il soit :

(trans (1 0 0) 1 0 T) -> (1 0 0)

 

Un peu plus avant, si on fait subir une rotation de 45° sur Z à notre SCU

(trans '(1 0 0) 1 0) ->(10.7071 20.7071 0.0)

(trans '(1 0 0) 1 0 t) -> (0.707107 0.707107 0.0)

 

On voit bien que les coordonnées du point correspondent à celles de l'origine du SCU dans le SCG plus celles du vecteur dans le SCG, c'est pourquoi in parle de déplacement (displacement).

 

L'expression (trans '(0 0 1) 1 0 T) traduit le vecteur directeur de l'axe Z du SCU en coordonnées SCG et retourne un vecteur de même norme (même longueur) égale à 1.

[usegomme]

Merci (gile) , t'es un "chef" et je pense avoir compris cet épisode :)