Dessiner une Polyligne


Méthodes de création
d'une entité "Polyligne"


Il existe deux méthodes principalement pour créer une entité POLYLIGNE dans AutoCAD depuis un programme, deux méthodes en AutoLisp du moins, les méthodes avec Visual Lisp seront expliquées ailleurs et quand ce sera fait je mettrai un lien de redirection pour relier ces méthodes.

Une méthode avec "COMMAND"
et une autre avec "ENTMAKE"
(les liens renvoient vers la ligne dans la page)

Tout d'abord je vais faire une routine qui va stocker les points cliqués à l'écran dans une liste (list), cette routine servira pour les deux méthodes, "command" et  "entmake".

Dans les deux cas de figure les données de départ pour dessiner cette polyligne sont enregistrées dans une liste de points sous forme de liste (list) de triplets (x y z) de coordonnées sous la forme :
((x1 y1 z1) (x2 y2 z2) (x3 y3 z3) (xn yn zn)...)


Le principe de cette saisie est de demander à l'utilisateur des points à l'écran, il peut choisir d'utiliser l'accrochage aux objets s'il le souhaite, vous remarquerez que j'ai activé une (très) ancienne variable : "blipmode", elle sert à visualiser les points cliqués à l'écran, pour ceux qui ne la connaissent pas : ce n'est que du pixel, au moindre zoom les marques disparaissent, à la fin je remets cette variable obsolète dans son état initial.

Ensuite je renseigne une variable de liste (list) vide puis en lançant une boucle avec (while) je laisse l'utilisateur cliquer autant de points qu'il a besoin, à chaque clic la liste se complète du dernier point cliqué par concaténation avec la fonction (cons) en appuyant sur Entrée (validation) la boucle s'arrête et la liste est enregistrée pour être traitée ultérieurement.

Image du programme pour vous habituer à "fabriquer" vous-même, (bien sûr le code "copiable sera en fin de page comme toujours).

Puisqu' avec la fonction (defun) il y a un "c:" on peut doit taper la commande SP en ligne de commande, il va vous être demandé de cliquer des points, rien ne se passe visuellement (à part les marques de blipmode) mais la variable pt-lst se renseigne petit à petit de chaque point cliqué pour prendre cette forme (par exemple car il y a peu de chance que vos valeurs soient celles-là) à la fin de la saisie :

((13.781 11.3792 0.0) (15.6537 8.93817 0.0) (13.3196 6.95821 0.0) (10.9855 9.562 0.0) (7.59288 7.12094 0.0))

Cette liste (list) se fabrique par concaténation des points au fur et à mesure des choix, si l'ordre de tracé est important il va falloir la retourner à la fin de la routine car la polyligne va se dessiner en prenant le premier point de la liste comme départ, ce premier point de la liste étant le dernier sélectionné à l'écran, si vous voulez retourner la liste (list) il suffit de rajouter cette ligne :

Pour mémoire : pour interroger une variable dans l'IDE en console on tape simplement son nom ou bien en ligne de commande on tape son nom mais précédé d'un point d'exclamation !


Utilisation de COMMAND

Cette méthode est parfaite pour les débutants, elle se rapproche de ce qu'on fait "à la main" ou "à la souris" dans AutoCAD, on lance la commande, on clique les sommets et à la fin on décide de clore ou pas la polyligne créée.
Dans notre cas de figure on ne va pas avoir à cliquer les points puisqu'on a pris le soin de les stocker sous forme de liste de points dans une variable précédemment.
On peut tout à fait imaginer ne pas faire de sous-routine de saisie et de faire la polyligne "à la volée", j'en mettrai une version en fin de page.

Image du code :

Que fait ce code ?

Lancement de la commande "_.pline", commande polyligne en langage originel du logiciel car précédé d'un "underscore" (tiret bas) et d'un point qui oblige à utiliser la vraie commande native pour ignorer le cas où elle ait été redéfinie sur votre machine (redefine).
Puis parcours de chaque élément de la liste (item) des points en interdisant tout accrochage aux objets par l'utilisation du "_non"
Une fois que toute la liste est parcourue on ferme la polyligne  par l'appel de "_close"

Derrière le (defun) il n'y a pas c: donc il faut lancer la commande avec le nom de la variable qui contient les points à relier ainsi :
(poc1 pt-lst)

Simple, précis, efficace, merci qui ? merci AutoLISP.

Pourquoi ai-je donc nommé ainsi cette commande poc1 ?, habitué à faire quasiment tout au clavier je raccourcis tous les noms de commande, vous êtes libre de la nommer "POlyligne-par-utilisation-de-Command" si ça vous chante et que vous aimez tant les touches, j'ai pris poc1 pour signifier POlyligne1, le 1 c'est pour la version "command" le 2 ce sera la version 2 qui utilise "entmake".
Au départ le C de POC était pour la version (command), puis je me suis emmêlé le clavier et j'ai gardé le C dans la version (entmake), si j'avais suivi ma logique initiale on aurait eu POC et POE je vous en demande pardon mais j'ai la flemme de refaire mes images.


Une autre façon d'utiliser (command) est de dessiner la polyligne "à l'avancée" ... Je ne colle qu'une image du code, un : c'est simple à comprendre, deux : ça vous apprend à taper...

On est d'accord, c'est assez simple , utilisez le formulaire de contact si ce n'est pas le cas.


Utilisation de ENTMAKE

La routine de saisie des points va être réutilisée pour ce programme de dessin de polyligne qui utilise la fonction (entmake).
En effet on a besoin de la même forme de liste, pour mémoire : 
((x1 y1 z1) (x2 y2 z2) (x3 y3 z3) (xn yn zn)...)

Image du code :

J'ai remarqué une différence de fonctionnement
entre les deux méthodes :

Avec command si le premier point sélectionné a une valeur d'altitude la polyligne va prendre cette valeur comme "élévation", l'élévation est une valeur altimétrique appliquée à tous les sommets de la polyligne, ce n'est pas vraiment du 3D avec différentes valeurs de Z sur chaque sommets.

Avec entmake même si le premier point sélectionné a une valeur d'altitude la polyligne n'aura pas d'élévation, elles sera dessinée à un Z = 0 (zéro)

Si vous ne constatez pas ce que je viens d'écrire, je vous remercie de me le faire savoir par le formulaire de contact pour que je fasse plus de tests et corrige ma prose le cas échéant.


L'utilisateur ne verra pas la différence entre les deux routines, il lui sera demandé dans les deux cas de saisir des points, et une polyligne reliant ces points sera créée, j'ai mis les deux méthodes dans cet exercice pour que vous ayez moyen de choisir celle qui vous sied le mieux.
Je vous souhaite une bonne programmation...


Voici venu le temps de déposer le code copiable...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
(defun poc1 (liste_points / item)
   (command "_.pline")
   (foreach item liste_points (command "_non" item))
   (command "_close")
   (princ)
);fin de poc1
 
(defun poc2 (liste_points)
   (entmake
      (append
         (list
            '(0 . "LWPOLYLINE")
            '(100 . "AcDbEntity")
            '(100 . "AcDbPolyline")
             (cons 90 (length liste_points))
            '(70 . 1) ;1 pour fermée, 0 pour ouverte
          )
          (mapcar '(lambda (p) (cons 10 p)) liste_points)
       )
    )
  (princ)
);fin de poc2
 
(defun c:sp ( / pt) ;sp comme SaisiePoints
   (setq pt-lst '())
   (setvar "blipmode" 1) ;clics visibles à l'écran
   (while 
      (setq pt (getpoint "\nCliquez un point... (Valid pour arrêter)"))
      (setq pt-lst (cons pt pt-lst))
   )
(setvar "blipmode" 0);remise en état de l'affichage sans blips
(setq pt-lst (reverse pt-lst))
);fin se sp

 


haut de page

retour aux exercices sur polylignes


09 août 2018