Numéros de point Covadis et lisp

[essepe]

Bonsoir,

J'utilise MAP3D 2014 et Covadis 14.0.

Je cherche à utiliser les numéros de points topo Covadis dans des commandes simples (SCU par 3 points et Cercle par 3 points) appelées par le lisp suivant :

 

(defun c:1 ()

(setq P1 (getstring "Point 1 ?")) ; saisie du matricule du point

(setq P2 (getstring "Point 2 ?")) ; saisie du matricule du point

(setq P3 (getstring "Point 3 ?")) ; saisie du matricule du point

(command "scu" "3P" P1 P2 P3)

(command "cercle" "3P" P1 P2 P3)

(command "scu" "G")

)

 

AutoCad me renvoie un message d'erreur.

N'est-il pas possible d'utiliser la fonction d'accrochage aux matricules de Covadis (ctrl+F12) dans un lisp ?

Merci par avance.

Stéphane

[didier]

Coucou

 

sans doute que non, car l'appel des points par leur numéro est sans doute un lisp, et si tu ne mets pas le code de la fonction covadis dans le tien tu ne peux pas appeler un lisp dans un autre

à ce sujet j'avais écrit (pour le fun) un code qui faisait la recherche par matricule mais je me demande bien ce qu'il est devenu, mais il marchait bien et je mettais ma propre fonction dans le lisp principal et ça donnait de bon résultat (sauf avec les alpha de mémoire...)

 

allez! au boulot!, écris ton code perso, mais il faut se remonter les manches ce n'est plus de la macro, c'est du programme, private joke sur la discussion macro ou pas ?

ce que je vois comme code tient de la macro par exemple.

 

amicalement

[essepe]

Merci pour ta réponse.

Je suis complètement débutant en lisp (en macro ? ☺) .

Afin de simplifier mon travail, je pensais pouvoir saisir mes matricules une seule fois.

Tant pis pour moi, je me remonte les manches... pour saisir mes points.

Sincèrement.

Stéphane

[bonuscad]

Bonjour,

 

J'ai retrouvé un truc fais il y a pas mal de temps (2007), je te le livre tel quel.

 

(defun c:matricule (/ mat mlst ss n bloc att lst opt cnt ind pt)
(if (and
(setq mat (car (nentsel "\nSélectionnez un matricule: ")))
(setq mlst (entget mat))
(= "ATTRIB" (cdr (assoc 0 mlst)))
(= (type (read (cdr (assoc 1 mlst)))) 'INT)
(setq ss (ssget "_X"
(list '(0 . "INSERT")
(assoc 2 (entget (cdr (assoc 330 mlst))))
)
)
)
)
(progn
(repeat (setq n (sslength ss))
(setq bloc (ssname ss (setq n (1- n)))
att (entnext bloc)
)
(while (not (equal (assoc 2 (entget att)) (assoc 2 mlst)))
(setq att (entnext att))
)
(setq lst (cons (cons (atoi (cdr (assoc 1 (entget att))))
(trans (cdr (assoc 10 (entget bloc))) bloc 1)
)
lst
)
)
)
(while (progn
(initget "2d 3d")
(setq opt (getkword
"\nSpécifiez le type de polyligne [2d/3d] <Quitter>: "
)
)
)
(cond
((= opt "2d") (command "_.pline"))
((= opt "3d") (command "_.3dpoly"))
(T (command))
)
(setq cnt 0)
(while (/= 0 (getvar "CMDACTIVE"))
(setvar "CMDECHO" 0)
(cond
((< 2 cnt) (initget "Clore annUler"))
((< 1 cnt) (initget "annUler"))
)
(setq ind (getint
(strcat
"\nEntrez le matricule du point"
(cond
((< cnt 2) "")
((< cnt 3) " ou [annUler]")
(T " ou [Clore/annUler]")
)
": "
)
)
)
(cond
((numberp ind)
(cond
((setq pt (cdr (assoc ind lst)))
(command "_none" pt)
(setq cnt (1+ cnt))
)
(T
(princ "\nMatricule non valide.")
)
)
)
((= ind "Clore") (command "_Close"))
((= ind "annUler")
(command "_Undo")
(setq cnt (1- cnt))
)
(T (command))
)
(setvar "CMDECHO" 1)
)
)
)
)
(princ)
)

 

[Edit] J'ai retrouvé dans la foulée un lien

Celui du lien permet de relier automatiquement par matricule sucessifs. (par ex: du 553 au 637)

Modifié le 20 mars 2015 par bonuscad

[zebulon_]

Bonjour,

 

une piste pour étayer ta recherche

 

(vl-load-com)
(defun extract_attrib (E ETIQ / LATT ATT REP)
 (if (= (type E) 'ENAME)
   (setq E (vlax-ename->vla-object E))
 )
 (setq LATT (vlax-invoke E 'getAttributes))
 (foreach ATT LATT
   (if (= (vla-get-TagString ATT) ETIQ)
     (setq REP (vla-get-TextString ATT))
   )
 )
 REP
)



(defun c:3p ()
 (setq M1 (getstring "\nPoint 1 ? ")) ; saisie du matricule du point
 (setq M2 (getstring "\nPoint 2 ? ")) ; saisie du matricule du point
 (setq M3 (getstring "\nPoint 3 ? ")) ; saisie du matricule du point

 (setq LMAT (list M1 M2 M3))

 ;; jeu de sélection qui contient tous les blocs dont le nom est "TCPOINT" 
 (setq js (ssget "_X" '((0 . "INSERT") (2 . "TCPOINT"))))
 
 (setq LREP nil)
 (setq I 0)

 (while (and (< I (sslength js)) (< (length LREP) 3))
   (setq e (ssname js I))
   (setq I (+ I 1))
   ;; si l'attribut "MAT" est l'un des 3 saisis on met dans la liste LREP le point d'insertion du bloc
   (if (member (extract_attrib e "MAT") LMAT)
     (setq LREP (cons (cdr (assoc 10 (entget e))) LREP))
   )
 ) 

 (if (< (length LREP) 3)
   (alert "pas assez de points")
   (progn
     (command "_ucs" "_3P" "_non" (trans (nth 0 LREP) 0 1) "_non" (trans (nth 1 LREP) 0 1) "_non" (trans (nth 2 LREP) 0 1))
     (command "_circle" "_3P" "_non" (trans (nth 0 LREP) 0 1) "_non" (trans (nth 1 LREP) 0 1) "_non" (trans (nth 2 LREP) 0 1))
     (command "_ucs" "_p")
   )
 )
)

 

je n'ai pas Covadis et j'ai supposé que les points topo sont des blocs qui s'appellent "TCPOINT" avec un attribut qui s'appelle "MAT" et qui représente le matricule. Si ce n'est pas ça, tu pourras changer facilement dans le lisp.

 

Je t'invite à bien assimiler dans un premier temps la fonction ssget (et toutes ses petites copines ssname, sslength...) et regarder ce qu'en dit l'aide. Elle est vraiment très importante.

Ensuite, il est plus malin de mettre les commandes en anglais dans les (command...), pour des raisons de traduction qui peuvent varier entre les différentes versions d'autocad et aussi pour permettre au lisp de fonctionner même sur un autocad non français.

 

Ensuite, quand on commence à jouer avec les scu, il faut faire attention à ce que le lisp nous renvoie : c'est toujours des points en scu général. Donc, il ne faut pas oublier de transformer ces points pour les avoir en scu local lorsqu'on utilise une ligne (command...). D'où l'utilité de la fonction trans. Il faut aussi veiller à la variable "UCSFOLLOW". Si elle est active la modification du SCU génère une vue en plan du nouveau SCU dans la fenêtre courante. Donc, c'est mieux qu'elle soit inactive si on ne veut pas se taper des regénérations intempestives.

 

Enfin, il faut aussi faire attention aux accrochages aux objets quand on utilise (command ...) et qu'on lui injecte un ou des points. Si l'accrochage aux objets est actif, on peut s'accorcher à une extrémité, un centre... qui peuvent être parfois très éloignés du point qu'on désire avoir (ou pas... mais le problème reste le même, ce n'est pas le bon point !). D'où l'importance du "_non" avant d'injecter un point pour éviter un accrochage "parasite"

 

Amicalement

Vincent

[essepe]

Bonjour,

Merci Bonuscad et Vincent pour vos réponses.

J'étais sur un chantier à l'extérieur d'où ma réponse un peu tardive.

Vincent, ton lisp fonctionne parfaitement, merci.

Cela correspond tout à fait à ce dont j'ai besoin pour un travail en cours.

Pour ce qui est de la programation en lisp, quand je souhaite optimiser un travail, je pioche à droite à gauche en modifiant les lisp existants mais de manière plutôt empirique.

J'utilise un vieux manuel Autolisp d'une version 10 (pas 2010, 10 ! ☺) qui m'aide pour les fonctions basiques.

L'aide d'Autolisp sur mon Map3D 2014 français est en anglais, cela ne facilite pas les choses.

Merci encore et bon WE.

Stéphane

[zebulon_]

J'étais sur un chantier à l'extérieur

C'est mieux de préciser, Mais, même avec un chantier à l'intérieur, c'est moins simple pour bosser dans de bonnes conditions :D

...de manière plutôt empirique...

ta première mouture n'avait aucune chance de fonctionner. Je rejoins ce que disait Didier : allez! au boulot!. Tu as quelque chose qui semble fonctionner comme tu aurais voulu que ça fonctionne. Maintenant, essaye de comprendre comment. C'est toujours à partir d'exemples qu'on décortique pas à pas qu'on découvre le mieux, j'en suis convaincu. Ce n'est pas de l'empirisme, c'est de l'apprentissage... mais ça prend du temps. Apprendre à marcher, ça prend du temps aussi, mais c'est mieux que de passer sa vie à ramper, non ?

J'utilise un vieux manuel Autolisp d'une version 10 (pas 2010, 10 ! ☺)

moi, c'est un moins vieux manuel de la version 12 (pas 2012, 12 !) édité en septembre 1992. Put.. ça fait 23 ans que je le potasse, ce bouquin !

 

Amicalement

Vincent