Extraction des points d'une polyligne

[Aleck_Ultimate]

Bonjour à tous.

 

Je cherche à extraire sous forme de liste les cordonnées des points d'une polyligne.

 

Je comptait passer par entget puis assoc et reconstruire ma liste avec des paires pointées numérotées dans l'ordre des sommets dans la polyligne exploitable par mon future code, sauf que dans la liste que me retourne entget je ne retrouve que le point de base (10 0.0 0.0 0.0), les autres points de la polyligne n’apparaissent pas, et je tourne en rond inutilement en cherchant où ils sont passés. Quid des autres points qui devraient être marqués par 11-18, 21-28 et 31-37 ?

 

Merci de votre aide.

[x_all]

un petit code rapide pour lister les propriété DXF d'un objet sélectionnées...

 

tu devrai retrouver tes points

(defun c:dxf ()
 (setq ent (ssname (ssget) 0))
 (setq lst-dxf (entget ent))
 (print lst-dxf)
)
;; autre liste de propriété
;;  (dumpallproperties (ssname (ssget) 0))
;; voir aussi getproperties et setproperties

 

donc tu verra que tes points sont répéré par le code 10

pour en faire la liste tu peux utiliser ça (poly étant la variable ou est stoké la poly)

(setq lst-pts (mapcar 'cdr (vl-remove-if-not ' (lambda (x) (= (car x) 10)) (entget poly) ) ) )

[lecrabe]

Hello

 

Ci-apres une vieille Routine Lisp qui exporte dans un fichiet Texte TOUS les Points XY d'une LWPOLYLINE (non splinee, non lissee) et IDEM pour les Points graphiques (POINT) !

Cela pourra peut etre t'aider !?

 

Bye, lecrabe

 

;; Routine : PTEXPORT  - Chargement par : APPLOAD
;;
;; Export vers un fichier TXT des XYZ des Points graphiques 
;;                         OU des XYZ des Sommets/Vertex de Polylignes 2D simples (NON Splinees, NON Lissees) 
;;
;; Micro-Micro-Modif par Patrice pour avoir des ; et non pas des , entre chaque coordonnee XYZ 

; ----------------------------------------------------------------------
;             (Export LWPOLYLINE Vertices & Points to File)
;            Copyright (C) 2000 DotSoft, All Rights Reserved
;                   Website: http://www.dotsoft.com
; ----------------------------------------------------------------------

(defun c:PTExport ()

 (setq sset (ssget '((-4 . "<OR")
                                 (0 . "POINT")
                                 (0 . "LWPOLYLINE")
                     (-4 . "OR>"))))
 (if sset
   (progn
     (setq itm 0 num (sslength sset))
     (setq fn (getfiled "Point Export File" "" "txt" 1))
     (if (/= fn nil)
       (progn
         (setq fh (open fn "w"))
         (while (< itm num)
           (setq hnd (ssname sset itm))
           (setq ent (entget hnd))
           (setq obj (cdr (assoc 0 ent)))
           (cond
             ((= obj "POINT")
               (setq pnt (cdr (assoc 10 ent)))
               (princ (strcat 

;;                             (rtos (car  pnt) 2 8) ","
;;                             (rtos (cadr pnt) 2 8) ","

                              (rtos (car  pnt) 2 8) ";"
                              (rtos (cadr pnt) 2 8) ";"

                              (rtos (caddr pnt) 2 8)) fh)
               (princ "\n" fh)
             )
             ((= obj "LWPOLYLINE")
               (if (= (cdr (assoc 38 ent)) nil)
                 (setq elv 0.0)
                 (setq elv (cdr (assoc 38 ent)))
               )
               (foreach rec ent
                 (if (= (car rec) 10)
                   (progn
                     (setq pnt (cdr rec))
                     (princ (strcat 

;;                                   (rtos (car  pnt) 2 8) ","
;;                                   (rtos (cadr pnt) 2 8) ","

                                    (rtos (car  pnt) 2 8) ";"
                                    (rtos (cadr pnt) 2 8) ";"


                                    (rtos elv 2 8)) fh)
                     (princ "\n" fh)
                   )
                 )
               )
             )
             (t nil)
           )
           (setq itm (1+ itm))
         )
         (close fh)
       )
     )
   )
 )
 (princ)
)

(princ "\nPoint/Vertex Export loaded, type PTEXPORT to run. ")
(princ)

[didier]

Coucou

 

Je vais expliquer ça en détail bientôt sur mon site, si tant est que je reste en vie, et je ferai le tour des extractions de sommets

Attention avec la méthode de de x_all, (qui fonctionne très bien depuis que Patrick nous l'a montrée il y a quelques années) :

elle ne tient pas compte des bulges, à savoir les raccordements circulaires, c'est peut-être sans importance dans ce cas mais il faut le savoir car, sans lui manquer de respect, quand je vois chercher des codes DXF 11-18, 21-28 et 31-37 je détecte que celui qui pose la question n'a pas été voir bien loin dans l'aide.

Attention à l'apprentissage : toujours se donner des buts faciles à atteindre, l'extraction des sommets d'une polyligne n'est pas dans les premières choses qu'on voit.

 

Amicalement

[lecrabe]

Hello

 

Autre routine interessante : Inserer UN Bloc a chaque Vertex d'une PLine ...

 

Bye, lecrabe

 

;; 
;; Insert a Block at each Vertex of a PLine
;; Block Name = BEAUTIFUL_TREE
;; http://discussion.autodesk.com/forums/thread.jspa?threadID=279644&tstart=125
;; Scale X = Scale Y = 1  -  Rotation = 0 
;; 
;; Patrice >>> If your Block has Attributes :
;; Patrice >>> Please ATTREQ = 0 before Running routine and after ATTREQ = 1
;; 

(vl-load-com) 

(defun C:BlockVert (/ plobj inc)
 (setq
   plobj (car (entsel "\nSelect Polyline: "))
   inc 0
 ); end setq
 (while (<= inc (vlax-curve-getEndParam plobj))
   (command
     "_.insert"
;;    "yourblockname"
     "BEAUTIFUL_TREE"
     (vlax-curve-getPointAtParam plobj inc)
     "" "" 
     ""
   ); end command
   (setq inc (1+ inc))
 ); end while
); end defun

[(gile)]

Bonjour à tous.

 

Je cherche à extraire sous forme de liste les cordonnées des points d'une polyligne.

 

[...], sauf que dans la liste que me retourne entget je ne retrouve que le point de base (10 0.0 0.0 0.0), les autres points de la polyligne n’apparaissent pas, et je tourne en rond inutilement en cherchant où ils sont passés. Quid des autres points qui devraient être marqués par 11-18, 21-28 et 31-37 ?

 

D'après ce que tu décris, l'objet sélectionné n'est pas une polyligne "optimisée" (LWPOLYLINE) mais peut-être une polyligne 2d "lourde" ou une polyligne 3d (POLYLINE dans ces deux cas).

Regarde ce que te contient le code de groupe 0 :

(0 . "LWPOLYLINE") => polyligne "optimisée" => un groupe 10 pour chaque sommet dans système de coordonnées de l'objet (SCO)

(0 . "POLYLINE") => polyligne 2d / 3d (ou maillage), il s'agit d'une entité dite "complexe", c'est à dire composée de sous-entités de type VERTEX, il faut dans ce cas parcourir ces entités avec entnext pour récupérer leurs positions avec le code 10 de leur liste DXF.

 

PS: les codes 20-29 et 30-39 ne sont utilisés que dans les fichiers DXF pour, respectivement, les coordonnées x et y. Dans les listes retournées par entget seuls les groupes 10 (et parfois 11) sont utilisés.

[Aleck_Ultimate]

Merci de votre aide.

 

Je crin de ne pas avoir été suffisamment précis.

 

Premièrement il s'agit de poly3D, et pas de simples polylignes, chose dont j'ais du sous-estimer l’importance (dans mon esprit c'est relativement la même chose sauf que les 2D sont en 2D uniquement et que les 3D n'ont pas d'arcs).

 

Ensuit au tout début de mes premiers tâtonnements j'ais dessiné un poly3D de 6 segments, j'ais bricolé (setq poly_0 (entlast)) (entget poly_0) pour tester et obtenu :

 

(setq poly_0 (entlast))
(entget poly_0)
<Nom d'entité: 7ff6a6b04c70>
((-1 . <Nom d'entité: 7ff6a6b04c70>) 
(0 . "POLYLINE") 
(330 . <Nom d'entité: 7ff6a6b03f00>) 
(5 . "627") (100 . "AcDbEntity") 
(67 . 0) (410 . "Model") 
(8 . "___Trais_de_contruction") 
(100 . "AcDb3dPolyline") 
(66 . 1) 
(10 0.0 0.0 0.0)
(70 . 8) 
(40 . 0.0) 
(41 . 0.0) 
(210 0.0 0.0 1.0) 
(71 . 0) 
(72 . 0) 
(73 . 0) 
(74 . 0) 
(75 . 0))

 

Comme je ne retrouvait pas la même configuration que sur le site de X_all, c'est à dire une seul paires pointées avec la clé 10 au lieu de une clé 10 par sommet, j'ais voulu approfondir en vérifiant sur l'aide AutoCAD à quoi correspondait tel ou tel clé, et lesquelles chercher, d'où le 11-18, 21-28 et 31-37.

 

C'est parce que je n'ais ensuit pas réussit à trouver un LISP fini d'extraction des points pour le décortiquer que je suis venu vers vous.

 

Mon but est de créer une liste du type ((1 . x1 y1 z1) (2 . x2 y2 z2) (3 . x3 y3 z3) ex...) mais je voudrait être capable de tout coder moi-même, même si vue mon niveau il me faudra probablement plusieurs semaines continues pour finir mon code. Car oui, j'ais bien conscience de m’être fixé un objectif relativement élevé, mais qui devrait être à ma portée si je fractionne tout en petits morceaux.

 

EDIT : Un certain nombre de réponses ont étés postés par (gile) pendant que je rédigeait ce message

[bonuscad]

Comme le souligne (gile) l'extraction des code entre une (0 . "POLYLINE") et une (0 . "LWPOLYLINE") en DXF par (assoc) n'est pas identique.

 

Pour s'affranchir de cette contrainte, on peut se tourner vers les fonctions (vlax-curve_get...)

Cela donne un code plus générique qui fonctionnera quelque soit la polyligne 2D (splinée ou ajustée), 3D ou polyligne légère.

 

(vl-load-com)
(defun c:listpt_po ( / js AcDoc Space lst_pt n ename obj pr)
 (princ "\nSélectionner la polyline.")
 (while
   (null
     (setq js
       (ssget "_+.:E:S"
         (list
           (cons 0 "*POLYLINE")
           (cons 67 (if (eq (getvar "CVPORT") 1) 1 0))
           (cons 410 (if (eq (getvar "CVPORT") 1) (getvar "CTAB") "Model"))
           (cons -4 "<NOT")
             (cons -4 "&") (cons 70 112)
           (cons -4 "NOT>")
         )
       )
     )
   )
   (princ "\nSélection vide, ou ce n'est pas une polyligne valable!")
 )
 (setq
   AcDoc (vla-get-ActiveDocument (vlax-get-acad-object))
   Space
   (if (= 1 (getvar "CVPORT"))
     (vla-get-PaperSpace AcDoc)
     (vla-get-ModelSpace AcDoc)
   )
 )
 (setq
   lst_pt nil
   ename (ssname js 0)
   obj (vlax-ename->vla-object ename)
   pr -1
 )
 (repeat (fix (vlax-curve-getEndParam obj))
   (setq
     pr (1+ pr)
     lst_pt (cons (vlax-curve-GetPointAtParam obj pr) lst_pt)
   )
 )
 (setq lst_pt (cons (vlax-curve-GetPointAtParam obj (1+ pr)) lst_pt))
)

[(gile)]

Aleck Ultimate, si tu veux utiliser les listes DXF telles que retournées par entget, il faut étudier attentivement ces listes en te servant de l'aide (en français).

 

Comme dit plus haut, pour récupérer les sommets d'une entité de type POLYLINE, il faut parcourir ses sous entité de type VERTEX.

On fait ça avec entnext en testant que l'entité est bien du type VERTEX.

(defun vertices (ent / elst pts)
 (setq ent  (entnext ent)              ; entité suivante dans la base de données
       elst (entget ent)               ; liste DXF de l'entité
 )
 (while (= (cdr (assoc 0 elst)) "VERTEX") ; tant que l'entité est de type VERTEX
   (setq pts  (cons (cdr (assoc 10 elst)) pts) ; on ajoute le sommet à la liste
         ent  (entnext ent)            ; on passe à l'entité suivante
         elst (entget ent)             ; et à sa liste DXF
   )
 )
 (reverse pts)                         ; on remet la liste dans l'ordre pour la retourner
)

ou, récursivement :

(defun vertices (ent / elst)
 (setq ent  (entnext ent)
       elst (entget ent)
 )
 (if (= (cdr (assoc 0 elst)) "VERTEX")
   (cons (cdr (assoc 10 elst)) (vertices ent))
 )
)

 

Comme montré par bonuscad, on peut aussi utiliser les fonctions vlax-curve-*, dans ce cas, ça fonctionne avec tous les types de polylignes.

(defun vertices (ent / i pts)
 (vl-load-com)
 (setq i (1+ (fix (vlax-curve-getEndParam ent))))
 (repeat i
   (setq lst (cons (vlax-curve-getPointAtParam ent (setq i (1- i))) lst))
 )
)

[Aleck_Ultimate]

Ha ouais, quand même

 

Mes estimations du temps qu'il me faudrait pour finaliser mon code viennent de quadrupler. J'était loin d’imaginer que ce serait aussi complexe de "juste" extraire des sommets.

 

Bon, et bien avec tout le grain à moudre que vous m'avez donnés, j'en ais pour un moment à tout comprendre et intégrer.

 

Merci beaucoup pour votre aide.

[x_all]

ou, récursivement :

punaise, je m'y ferrai jamais...

Comme quoi le code, il faut en bouffer quant on est petit ... jeune je veux dire...

 

 

(gile) t'as pas le droit de gouter t'es tombé dedans quand tu était petit... jeune je veux dire ...

[(gile)]

Comprendre la récursivité (de même que comprendre les fonctions dites d'ordre supérieur comme mapcar ou apply et les expressions lambda) est une étape importante (si ce n'est essentielle) dans l'apprentissage du LISP (ou de tout autre langage fonctionnel).

 

LISP est définit récursivement : une expression LISP est un atome ou une liste d'expressions LISP.

De même les listes LISP (listes chaînées) sont des structures de données récursives.

 

Une expression LISP contenant des expressions imbriquées est une sorte d'arborescence (structure récursive) comparable à un "empilement" d'appels récursifs. Son évaluation fonctionne comme le "dépilement" dans l'évaluation d'une fonction récursive.

 

Compare la version itérative et la version récursive, j'ai modifiée cette dernière pour bien faire apparaître les similitudes et les différences entre les deux.