Coordonnées d'une polyligne

[DenisHen]

Bonjours à tous,

 

Je poste ce LiSP car je ne l'ai pas trouvé et je sais qu'il serait utile à quelques uns...

 

Il écrit les XY des sommets d'une polyligne aux sommets de cette polyligne...

 

(vl-load-com)
(defun c:BlexXYpoly (/)
 (setvar "CMDECHO" 0) 
 (setq ename (car (entsel "\nSelectionnez la polyligne: ")))
 (getvertices ename)
 (while (not (equal (car return) nil))
   (setq texte	(strcat	"X="
		(rtos (caar return) 2 2)
		"\nY="
		(rtos (cadar return) 2 2)
	) ;_ Fin:strcat
   ) ;_ Fin:setq
   (princ texte)
   (command "_-mtext"
     "_none"
     (car return)
     "j"
     "bg"
     "_r"
     rot
     "_w"
     "0.00"
     texte
     ""
   ) ;_ Fin:command
   (setq return (cdr return))
 ) ;_ Fin:while
) ;_ Fin:defun

 ;//////////////////////////////////////////////////////////////// trouvé sur CADXP
(defun getvertices (ename / plineget vertex vertexget)
 (setq return nil)
 (cond	((or (/= (type ename) 'ename)
     (not (setq plineget (entget ename)))
 ) ;_ Fin:or
 (setq return nil)
)
((= "POLYLINE" (cdr (assoc 0 plineget)))
 (setq vertex (entnext ename))
 (while	(= "VERTEX"
	   (cdr (assoc 0 (setq vertexget (entget vertex))))
	) ;_ Fin:=
   (setq return (cons (cdr (assoc 10 vertexget)) return))
   (setq vertex (entnext vertex))
 ) ;_ Fin:while
 (setq return (reverse return))
)
((= "LWPOLYLINE" (cdr (assoc 0 plineget)))
 (setq
   return (mapcar
	    'cdr
	    (vl-remove-if '(lambda (x) (/= (car x) 10)) plineget)
	  ) ;_ Fin:mapcar
 ) ;_ Fin:setq
)
(t (setq return nil))
 ) ;_ Fin de cond
) ;_ Fin de defun

 

Cordialement...

[Patrick_35]

Salut

 

Merci de partager ton travail.

Juste une chose, il manque la variable rot pour que le lisp fonctionne correctement.

Je me suis permis de regarder ce que tu as fait pour te proposer la même chose écrite différemment.

 

(defun c:BlexXYpoly(/ ename)
 (and (setq ename (car (entsel "\nSelectionnez la polyligne: ")))
   (mapcar '(lambda(x)
      (entmake (list	(cons   0 "MTEXT")
			(cons 100 "AcDbEntity")
			(cons 100 "AcDbMText")
			(cons  10 (cdr x))
			(cons   1 (strcat "X=" (rtos (cadr x)  2 2)
					  "\n"
					  "Y=" (rtos (caddr x) 2 2)
				  )
			)
			(cons 71 7)
			(cons 72 5)
		 )
	)
      )
      (vl-remove-if-not '(lambda(x)(eq (car x) 10)) (entget ename))
   )
 )
)

 

@+

[DenisHen]

Salut,

 

Merci Patrick_35 pour cette routine qui fonctionne impécablement, mais elle n'utilise pas le style de texte courant...

 

Denis...

[Patrick_35]

Ah oui, exact

Tu ajoutes, dans le entmake

(cons  7 (getvar "textstyle"))

 

@+

[DenisHen]

Ca marche nickel...

Merci encore...

[DenisHen]

Salutations,

 

J'ai besoin de la même chose mais avec le Z en plus car j'ai des Polylignes 3D... Je n'y arrive pas avec le CADDR pour indiquer le Z

 

(defun c:XYZpoly(/ ename)
 (and (setq ename (car (entsel "\nSelectionnez la polyligne 3D: ")))
   (mapcar '(lambda(x)
      (entmake (list	(cons   0 "MTEXT")
                               (cons   7 (getvar "textstyle"))
			(cons 100 "AcDbEntity")
			(cons 100 "AcDbMText")
			(cons  10 (cdr x))
			(cons   1 (strcat "X=" (rtos (cadr x)  2 2)
					  "\n"
					  "Y=" (rtos (caddr x) 2 2)
					  "\n"
					  "Z=" (rtos (cadddr x) 2 2)
				  )
			)
			(cons 71 7)
			(cons 72 5)
		 )
	)
      )
      (vl-remove-if-not '(lambda(x)(eq (car x) 10)) (entget ename))
   )
 )
)

 

D'avance merci,

 

Denis...

[-Olivier-]

Bonjour DenisH,

 

Il faut utiliser cdddr et non cadddr.

 

Regarde ici pour une réponse plus complète.

 

Olivier

[DenisHen]

Bonjour Olivier,

 

J'ai bien modifier mon LiSP :

(defun c:XYZpoly(/ ename)
 (and (setq ename (car (entsel "\nSelectionnez la polyligne: ")))
   (mapcar '(lambda(x)
      (entmake (list	(cons   0 "MTEXT")
                               (cons   7 (getvar "textstyle"))
			(cons 100 "AcDbEntity")
			(cons 100 "AcDbMText")
			(cons  10 (cdr x))
			(cons   1 (strcat "X=" (rtos (cadr x)  2 2)
					  "\n"
					  "Y=" (rtos (caddr x) 2 2)
					  "\n"
					  "Z=" (rtos (cdddr x) 2 2)
				  )
			)
			(cons 71 7)
			(cons 72 5)
		 )
	)
      )
      (vl-remove-if-not '(lambda(x)(eq (car x) 10)) (entget ename))
   )
 )
)

 

Mais AutoCAD me répond :

Commande:

Commande: XYZPOLY

Selectionnez la polyligne: ; erreur: type d'argument incorrect: numberp: (0.0)

 

J'ai pourtant bien une "POLYLIGNE" en 3D...

 

Merci,

 

Denis...

[-Olivier-]

Excuse moi, j'ai lu ton code un peu vite !

Tu parlais de polyligne 3D. En réalité d'après ton code, c'est une polyligne légère dessinée sur un plan 3D.

Les coordonnées des polylignes des points de ce type de polyligne sont enregistrés en 2D dans leur propre système de coordonnés (SCO : système de coordonnée objet). Il font donc récupérer les points 2D et les transférer dans le SCG.

 

Olivier

[DenisHen]

Merci Olivier pour tes réponses, mais je ne vois pas, en LiSP, comment faire la différence entre une LWPOLYLIGNE (en 2D) et une POLYLIGNE (qui elle peut être en 3D)...

 

Si quelqu'un d'autre a une réponse, je suis preneur...

 

Denis.

[(gile)]

Salut,

 

Au début, il n'y avait que les polylignes "lourdes" (heavy) dont le nom DXF est : POLYLINE.

C'est une famille d'objets qui comprend les polylignes 2d "lourdes" (AcDb2dPolyline), les polylignes 3d (AcDb3dPolyline) et les maillages polygonaux (AcDbPolygonMesh). On les différencie en LISP par leur code DXF 70 (voir les références DXF dans l'aide.

Il s'agit d'objets dits complexes parce que composés de sous entités, les VERTEX (en gros les sommets). Pour retrouver les sommets de ces polylignes, on doit passer par entnext (comme pour les attributs de bloc) pour obtenir chaque entité VERTEX.

 

Puis sont arrivées les polylignes "allégées" dont le nom DXF est LWPOLYLINE (pour light weight polyline). On les dit "allégées" parce qu'il s'agit d'entité simples, toujours 2D (ce qui signifie planes, mais pas forcément dans le plan XY du SCG), dont toutes les données sont contenues dans le même objet. Leur coordonnées définies dans les groupes 10 de la liste DXF de l'entité sont des coordonnées 2D (X et Y) définies dans le système de coordonnée de l'objet (SCO). Les autres données nécessaires pour convertir ces coordonnées en coordonnées SCG sont l'élévation de la polyligne (code DXF 38) et le vecteur normal du plan de la polyligne (code DXF 210).

 

Donc pour répondre à ta question, pour faire la différence entre LWPOLYLINE et POLYLINE il suffit d'interroger le groupe DXF 0 de la liste DXF de l'entité :

(cdr (assoc 0 (entget ent)))

 

Pour aller plus loin avec les groupes DXF (c'est la base en AutoLISP, et il n'y a aucune excuse, c'est la seule partie de l'aide à être traduite en français), un exemple qui explore une entité et qui retourne la liste de ses sommet si c'est une polyligne.

On teste d'abord le type de polyligne (groupe DXF 0),

- si c'est une polyligne allégée (LWPOLYLINE) on récupère les groupes 10 et on les transforme dans le SCG après avoir ajouté l'élévation comme coordonnée Z dans le SCO (groupe 38)

- si c'est une POLYLINE, on teste si c'est une polyligne 3d (si elle a le code binaire 8 dans groupe 70) on récupère alors les sommets dans les VERTEX (ils sont définis dans le SCG).

- sinon on s'assure que ce n'est pas un maillage (aucun des codes binaire 16, 32 ou 64) et on récupère les VERTEX (définis en X, Y, Z dans le SCO) qu'il faudra transformer dans le SCG en filtrant les points de contrôles des polylignes splinées).

 

(defun getWcsPolylineVertices (ent / elst lst)

 ;; liste de données DXF de l'entité
 (setq elst (entget ent))

 ;; polyligne allégée (LWPOLTYLINE)
 (if (= (cdr (assoc 0 elst)) "LWPOLYLINE")
   (mapcar
     '(lambda (p)
 ;; tranformer le point (x y elevation) ...
 (trans	(list (cadr p) (caddr p) (cdr (assoc 38 elst)))
	ent
	0
 )
      )
     ;; ... de tous les groupes 10
     (vl-remove-if-not '(lambda (x) (= (car x) 10)) elst)
   )

   ;; autre types polyligne (POLYLINE)
   (if	(= (cdr (assoc 0 elst)) "POLYLINE")

     ;; Polyligne 3d (code binaire 8 dans le groupe 70)
     (if (= (logand 8 (cdr (assoc 70 elst))) 8)
(progn
  ;; tant que l'entité suivante est de type VERTEX ...
  (while
    (and
      (setq ent (entnext ent))
      (setq elst (entget ent))
      (= (cdr (assoc 0 elst)) "VERTEX")
    )
     ;; ... ajouter le sommet à laliste
     (setq lst (cons (cdr (assoc 10 elst)) lst))
  )
  (reverse lst)
)

;; Polyligne 2d lourde (absence des codes binaires 16, 32 et 64)
(if (zerop (logand (+ 16 32 64) (cdr (assoc 70 elst))))
  (progn
    (progn
      ;; tant que l'entité suivante est de type VERTEX ...
      (while
	(and
	  (setq ent (entnext ent))
	  (setq elst (entget ent))
	  (= (cdr (assoc 0 elst)) "VERTEX")
	)
	 ;; ... si le vertex n'es pas un point de contrôle de polyligne splinée ...
	 (if (/= (cdr (assoc 70 elst)) 16)
	   ;; ajouter le sommet transformé en coordonnées SCG à la liste
	   (setq
	     lst (cons (trans (cdr (assoc 10 elst)) ent 0) lst)
	   )
	 )
      )
      (reverse lst)
    )
  )
)
     )
   )
 )
)

 

 

On peut faire plus simple avec les fonction vlax-curve-* qui permettent de traiter tout type de polyligne de la même façon en retournant des points SCG.

 

(defun getWcsPolylineVertices (ent / elst lst index)
 (vl-load-com)

 ;; liste de données DXF de l'entité
 (setq elst (entget ent))

 ;; si l'entité est...
 (if
   (or
     ;; ...soit de type LWPOLYLINE...
     (= (cdr (assoc 0 elst)) "LWPOLYLINE")
     ;; ...soit de type POLYLINE mais pas un maillage...
     (and
(= (cdr (assoc 0 elst)) "POLYLINE")
(zerop (logand (+ 16 32 64) (cdr (assoc 70 elst))))
     )
   )
    (progn
      ;; nombre de sommets + 1 si fermée (code binaire 1 du groupe 70)
      (setq index
      (if (= (logand 1 (cdr (assoc 70 elst))) 1)
	(fix (vlax-curve-getEndParam ent))
	(1+ (fix (vlax-curve-getEndParam ent)))
      )
      )
      ;; tant que index est supérieur à 0
      (while (< 0 index)
 ;; ajouter le sommet à l'indice index - 1 à la liste
 (setq
   lst (cons (vlax-curve-getpointAtParam ent (setq index (1- index)))
	     lst
       )
 )
      )
    )
 )
)

[x_all]

Ha la la (gile)

tes explications sont lumineuses mais ton code tellement pur, que je vais pas avoir trop des 15j de vacances, que j’attends avec impatience, pour comprendre...

[(gile)]

J'ai ajouté des commentaires dans les codes.

[DenisHen]

Salut,

 

Merci à vous pour vous pencher sur mon problème. J'ai donc écris celà :

(vl-load-com)
(defun c:XYZ3D (/)
 (setvar "CMDECHO" 0)
 (setq ent (car (entsel "\nSelectionnez la polyligne 3D : ")))
 (getWcsPolylineVertices ent)
 (while (not (equal (car lst) nil))
   (setq texte (strcat "X="
                       (rtos (caar lst) 2 2)
                       "\nY="
                       (rtos (cadar lst) 2 2)
                       "\nZ="
                       (rtos (caddr lst) 2 2)
               ) ;_ Fin:strcat
   ) ;_ Fin:setq
   (princ texte)
   (command "_-mtext"
            "_none"
            (car lst)
            "j"
            "bg"
            "_r"
            rot
            "_w"
            "0.00"
            texte
            ""
   ) ;_ Fin:command
   (setq lst (cdr lst))
 ) ;_ Fin:while
) ;_ Fin:defun



(defun getWcsPolylineVertices (ent / elst lst) ;;; de (gile)
 (setq elst (entget ent))
 (if (or (= (cdr (assoc 0 elst)) "LWPOLYLINE")
         (and (= (cdr (assoc 0 elst)) "POLYLINE")
              (zerop (logand (+ 16 32 64) (cdr (assoc 70 elst))))
         ) ;_ Fin de and
     ) ;_ Fin de or
   (progn (setq n (if (= (logand 1 (cdr (assoc 70 elst))) 1)
                    (fix (vlax-curve-getEndParam ent))
                    (1+ (fix (vlax-curve-getEndParam ent)))
                  ) ;_ Fin de if
          ) ;_ Fin de setq
          (while (< 0 n)
            (setq
              lst (cons (vlax-curve-getpointAtParam ent (setq n (1- n)))
                        lst
                  ) ;_ Fin de cons
            ) ;_ Fin de setq
          ) ;_ Fin de while
   ) ;_ Fin de progn
 ) ;_ Fin de if
) ;_ Fin de defun

 

Mais AutoCAD me répond :

Commande: XYZ3D

 

Selectionnez la polyligne 3D : nil

 

Commande:

 

Ca fait des années que je n'ai pas touché à du LiSP, et ne suis pas assez callé pour voir où sont mes erreurs...

[x_all]

merci...

 

il va me falloir plus qu'une semaine ( P) )

 

non sans rire j'ai trop de lacunes, pas assez de mémoire, (hier encore je cherchais car et cdr pour la 220eme fois) bref, je suis un cas désespéré :)

 

mais à force de vous lire, de potasser ton initiation au lisp, je commence à construire ou rassembler des petits bout de codes qui me sont utile... mais parfois je reste sans voix comme un apprenti guitariste devant Jimi Hendrix... je voie la guitare, mais j'arrive pas a suivre les doigts :)

[(gile)]

Salut DenisH,

 

Pour trouver d'où vient l'erreur :

- dans l'éditeur Visual LISP (tu codes dans l'éditeur, j'espère) menu Débogage > cocher "Arrêt sur l'erreur"

- relancer le code pour provoquer à nouveau l'erreur

- faire Ctrl + F9 pour mettre en surbrillance l'expression qui a provoqué l'erreur

- interroger les variables pour déterminer là où ça cloche

 

Je te laisse faire, c'est en corrigeant ses erreurs qu'on apprend.

Je rappelle que j'ai mis gratuitement à disposition un tutoriel : "Introduction à AutoLISP" sur Exchange Apps ou sur mon site dans lequel tout ça est expliqué.

 

Petite remarques :

 

- quand on invite l'utilisateur à sélectionner une entité (ou pour n'importe quelle autre entée utilisateur), il est préférable de tester si la valeur retournée n'est pas nil pour éviter les erreurs dans la suite du code :

(if (setq ent (car (entsel "\nSelectionnez la polyligne 3D : ")))
 (progn
   ;; ici le code qui traite l'entité sélectionnée
 )
)

- de même avec (getWcsPolylineVertices ent) qui retourne nil si ent n'est pas une polyligne.

 

- (while (not (equal (car lst) nil)) ...) n'est pas très élégant, (while lst ...) est équivalent.

 

- mais surtout, quand on fait une boucle (while condition ...), il faut que la condition change dans le bloc while, sinon on entre dans une boucle sans fin...

[(gile)]

Salut x_all,

 

Comme pour la guitare, pour progresser, il faut faire des gammes et jouer...

 

Les fonctions car et cdr sont avec cons des fonctions fondamentales en LISP (tous dialectes confondus) qu'il est indispensable de connaitre et comprendre.

Les "listes chaînées" sont les seules structures de données en AutolISP, le seul moyen pour les construire passe par cons :

(list 1 2 3) ou '(1 2 3) ne sont que des raccourcis pour (cons 1 (cons 2 (cons 3 nil)))

Et car et cdr, sont les seuls moyens de parcourir une liste (toutes les fonctions de traitement des listes utilisent en interne car et cdr). Plus d'informations sur les listes chaînées" ici.

[Olivier Eckmann]

Bonjour,

 

Sur le blog des développeurs ADN, cet article proposait d'utiliser les paramètres pour retrouver les sommets d'une polyligne.

Dans les commentaires il y avait une discussion sur le risque a utiliser cette solution car elle enfreignait la règle théorique qui stipule que les paramètres sont complètement opaques il qu'il ne faut faire aucune supposition quant à leur réalité (sur une polyligne, le premier point à le paramètre 0 et les points suivants 1, 2...).

 

Même si cette méthode fonctionne depuis toujours sur les polylignes, c'est peut-être plus risqué que de balayer la liste des code 10 sur une poly2D?

 

Olivier

[(gile)]

Merci Olivier pour ce lien.

Comme tu le dis, cette méthode a toujours fonctionné avec les polylignes, mais j'aurais tendance à faire confiance à Owen...

 

 

Il reste une troisième voie en Visual LISP, celle des objets COM AcDbPolyline, AcDb2dPolyline et AcDb3dPolyline.

Ce n'est pas la plus simple pour ceux qui ne sont pas habitués à l'interface COM (vlisp), il faut jongler avec les variants et safearrays (ou utiliser la syntaxe vlax-get, vlax-put, vlax-invoke) et les listes de coordonnées retournées par la propriété Coordinates sont des liste plates à partir des quelles il faut reconstituer des listes des points.

 

(defun getWcsPolylineVertices (ent / objname coords)
 (vl-load-com)
 ;; convertir ent en vla-object si c'est un ename
 (if (= type ent 'ENAME)
   (setq ent (vlax-ename->vla-object ent))
 )

 ;; type d'objet et coordonnées
 (setq	objname	(vla-get-ObjectName ent)
coords	(vlax-get ent 'Coordinates)
 )
 (cond
   ;; polyligne allégée
   ((= objName "AcDbPolyline")
    ;; élévation et normale
    (setq elevation (vla-get-Elevation ent)
   normal    (vlax-get ent 'Normal)
    )
    ;; transformation des points reconstitué en 3d vers le SCG
    (mapcar
      '(lambda	(p) (trans p normal 0))
      (gc:2dCoordinatesTo3dPoints coords elevation)
    )
   )
   ;; polyligne 3d
   ((= objName "AcDb2dPolyline")
    ;; normale
    (setq normal (vlax-get ent 'Normal))
    ;; transformation des points reconstitués vers le SCG
    (mapcar
      '(lambda	(p) (trans p normal 0))
      (gc:3dCoordinatesTo3dPoints coords)
    )
   )
   ;; polyligne 3d
   ((= objName "AcDb3dPolyline")
    ;; les points reconstitués
    (gc:2dCoordinatesTo3dPoints coords)
   )
   ;; autre
   (T nil) ; <- superfétatoire
 )
)

;; gc:2dCoordinatesTo3dPoints 
;; Convertit une liste de coordonnées 2D en liste de points 2D
;;
;; Argument
;; l : une liste plate de coordonnées 2d
;; z : l'élévation (coordonnée Z)
(defun gc:2dCoordinatesTo3dPoints (l z)
 (if l
   (cons (list (car l) (cadr l) z)
  (gc:2dCoordinatesTo3dPoints (cddr l))
   )
 )
)

;; gc:3dCoordinatesTo3dPoints
;; Convertit une liste de coordonnées 3D en liste de points
;;
;; Argument
;; l : une liste plate de coordonnées 3d
(defun gc:3dCoordinatesTo3dPoints (l)
 (if l
   (cons (list (car l) (cadr l) (caddr l))
  (gc:3dCoordinatesTo3dPoints (cdddr l))
   )
 )
)

[Patrick_35]

Bonjour

 

Je propose une routine pour retourner les coordonnées d'une polyligne 2D/3D

(defun lst_pts(ent / lst nb pts)
 (and (eq (type ent) 'ENAME)
   (setq ent (vlax-ename->vla-object ent))
 )
 (setq nb 0)
 (while (not (vl-catch-all-error-p (setq pts (vl-catch-all-apply 'vla-get-coordinate (list ent nb)))))
   (setq lst (cons (vlax-safearray->list (vlax-variant-value pts)) lst)
  nb (1+ nb)
   )
 )
 (reverse lst)
)

 

Pour tester

(lst_pts (car (entsel)))

(lst_pts (vlax-ename->vla-object (car (entsel))))

 

@+

[DenisHen]

Bonjour à tous, et merci de cet intérêt pour mon problème,

 

Je suis pressé par le temps, car il faut finir plein de dossier avant les vacances... Les clients ne vont pas me faire croire qu'ils vont bosser entre le 25 et le 31 ! !

 

Pour (gile)

Pour trouver d'où vient l'erreur :
- dans l'éditeur Visual LISP (tu codes dans l'éditeur, j'espère) menu Débogage > cocher "Arrêt sur l'erreur"
- relancer le code pour provoquer à nouveau l'erreur
- faire Ctrl + F9 pour mettre en surbrillance l'expression qui a provoqué l'erreur
- interroger les variables pour déterminer là où ça cloche

Visual LISP me répond dans une fenêtre : ":CALLBACK-ENTRY", je pense qu'il y a une perte de donnée entre XYZ3D et getWcsPolylineVertices

 

Encore merci à vous tous,

 

Denis...

[Patrick_35]

La version Poly 2D ou 3D

 

(defun c:BlexXYpoly(/ ename txt lst_pts)

 (defun lst_pts(ent / lst nb pts)
   (and (eq (type ent) 'ENAME)
     (setq ent (vlax-ename->vla-object ent))
   )
   (setq nb 0)
   (while (not (vl-catch-all-error-p (setq pts (vl-catch-all-apply 'vla-get-coordinate (list ent nb)))))
     (setq lst (cons (vlax-safearray->list (vlax-variant-value pts)) lst)
           nb (1+ nb)
     )
   )
   (reverse lst)
 )

 (and (setq ename (car (entsel "\nSelectionnez la polyligne: ")))
   (mapcar '(lambda(x)
      (setq txt (strcat "X=" (rtos (car x)  2 2)
			"\n"
			"Y="
			(rtos (cadr x) 2 2)
		)
      )
      (and (caddr x)
	(setq txt (strcat txt "\nZ=" (rtos (caddr x) 2 2)))
      )
             (entmake (list    (cons   0 "MTEXT")
                               (cons   7 (getvar "textstyle"))
                               (cons 100 "AcDbEntity")
                               (cons 100 "AcDbMText")
                               (cons  10 x)
                               (cons   1 txt)
                               (cons  71 7)
                               (cons  72 5)
                        )
               )
             )
             (lst_pts ename)
   )
 )
)

 

@+

[DenisHen]

Merci à tous,

 

Je teste et je reviens...

 

Denis...

[lecrabe]

Hello P35 "Le Rennais"

 

Comme d'habitude : Nickel-Chrome (Teste sur un AutoCAD 2011 32 bits ...)

 

SVP puis je me permettre de demander qq ameliorations :

 

1) Poser une question : Pour toutes les Polylignes (2D ou 3D) Ecrire le Z (Oui/Non) : ?

Car parfois les Polylignes 2D sont a une Elevation differente : courbes de niveau par exemple !

ET rarement pour des Polylignes 3D, on ne veut pas forcement le Z ...

 

2) Pouvoir selectionner N Polylignes ?

Pour simplifier la demande ci-dessus, on pourrait imaginer :

Traiter SOIT les 2D Poly SOIT les 3D Poly !

Car si il y a un melange, on pourrait quand meme lancer 2 fois la routine !!

 

Merci, Bye, lecrabe "Stephanois"

[DenisHen]

Re-Salut à tous,

 

Merci encore, le LiSP de Patrick_35 fonctionne merveilleusement bien (AutoCAD MAP 3D 64 bits, Windows 7 64 bits aussi, forcément).

 

Denis...