Luna

Coucou, Je pense que tu devrais relire le chapitre sur la fonction (defun) ^^" Ce qui se situe avant le "/" son appelé "Arguments", ils sont fréquemment utilisé pour les fonctions afin de spécifier des données d'entrées pour le bon fonctionnement de la fonction. S'ils sont présent dans la définition de la fonction, il doivent obligatoirement être définie lors de l'appel de la fonction, en clair même si on considère un argument comme inutile pour le fonctionnement de la fonction, il faudra tout de même préciser nil pour l'argument en question. Ce qui se situe après le "/" correspond aux "variables locales", en clair à chaque fois que l'appel de la fonction est terminé (soit la fonction est arrivée au bout de son développement, soit elle a été annulée, ...), l'ensemble des variables déclarées après le "/" sont redéfinie à leur état initial (généralement nil). Une variable présente dans un programme mais non déclarée comme variable locale est alors une "variable globale", donc même après la fin de l'exécution de la commande/fonction, elle conservera sa valeur finale jusqu'à la fermeture du fichier (ou AutoCAD). Ne pas déclarer ses variables comme locales entraîne de nombreux problèmes lorsque plusieurs fonctions font appel à une variable de même nom et sans remise à zéro de ces variables (essentiellement les listes construites par la fonction cons) Ex : (defun test (i) (repeat i (setq lst (cons (setq i (1- i)) lst)) ) ) ; Premier lancement de la fonction : (test 3) (0 1 2) ; Second lancement de la fonction : (test 5) (0 1 2 3 4 0 1 2) ; etc... Ici, la variables lst n'est pas déclarée comme variable locale, donc à chaque lancement de la fonction, elle ajoute les valeurs de la fonction appelée à sa valeur actuelle, créant ainsi une erreur. Car le résultat attendu de (test 5) doit être (0 1 2 3 4), or ici c'est le résultat de (append (test 5) (test 3)) dans le cas ou les variables seraient déclarées comme variables locales. Je ne sais pas si c'est assez clair, mais tu devrais retrouver tout ça dans les cours de (gile) ou de didier je pense :3 Bisous, Luna

Coucou, Juste pour info, le "c:" permet de définir une commande AutoCAD personnalisée, donc comme pour une commande normale, elle ne prend pas en compte les arguments (il faut donc pour cela prévoir la définition des arguments au sein de l'expression de la commande). En revanche, pour tester un programme séparé en plusieurs fonctions, il est plus simple de conserver l'écriture en fonction (donc ne pas mettre de "c:" devant le nom de la fonction), tu auras ainsi accès aux arguments. Pour tester une commande dans une fenêtre AutoCAD, il suffit d'écrire directement le nom de la commande, pour une fonction, il faut ajouter des parenthèses (comme si tu étais dans l'éditeur Visual Lisp) : (defun c:TEST (/ pt1) (setq pt1 (getpoint "\nPoint : ")) ) > Commande: TEST Point : (0.0 0.0 0.0) (defun TEST (pt1) (princ pt1) ) > Commande: (TEST (getpoint "\nPoint : ")) Point : (0.0 0.0 0.0) Cette différence doit sûrement être expliquée plus clairement sur le site de (gile) Introduction à AutoLISP :3 Aller bon courage ! Chat fait plaisir de voir des personnes qui préfèrent apprendre au lieu de copier-coller :) Bisous, Luna

Coucou, Tu as quel AutoCAD au juste ? Moi ça semble fonctionner sur AutoCAD 2019... Peut-être que certaines fonctions ont été retravaillées sur AutoCAD MEP 2018...no lo sé.. Existe-t-il des différences de programmation entre les différents logiciel d'AutoCAD ou bien est-ce strictement le même système ? Bisous, Luna

Coucou, Je suis d'accord avec (gile) :3 Sinon, j'ai l'impression qu'il te manque une parenthèse à la ligne 5 car tu ne fermes pas la fonction (vla-put-name) donc il te manque une parenthèse pour terminer la fonction (defun)... Bisous, Luna

Coucou, Bon bah chat va plus vite quand l'auteur passe dans le coin à priori :3 Bisous, Luna

Coucou, Le plus simple pour trier c'est à partir d'une liste. Donc comme le programme effectue la création du tableau à partir d'un jeu de sélection, il faut modifier un peu le programme pour le faire correspondre à une liste. L'idée serait de créer une liste de paire pointée avec le nom de la pièce et le nom de l'objet et ainsi de créer le tableau à partir de la liste triée. Je n'ai pas beaucoup de temps aujourd'hui mais lorsque ce sera bon, je reviendrai vers toi :3 Bisous, Luna

Salut, La fonction (lambda) est équivalent à la fonction (defun), la seule différence entre ces deux fonctions, c'est le fait que defun permet de nommer la définition de fonction (ce que (lambda) ne fait pas donc à usage unique). La fonction (mapcar) permet d'appliquer une fonction pour chaque élément d'une liste donnée. De manière générale, on utilise très souvent la fonction (lambda) car on souhaite effectuer des choses parfois complexes avec (mapcar). Mais il est également possible que la fonction utilisée soit une fonction ne possédant qu'un unique argument. Ex : (mapcar 'car '((0 . "LWPOLYLINE")(8 . "Calque1"))) renvoie (0 8). Donc pour les fonctions ne possèdant qu'un seul argument, on peut les utiliser directement, sinon on passe toujours par (lambda) pour les fonctions nécessitant plusieurs arguments (ou plusieurs fonctions d'affilés). Ici, ta liste se nomme ListFich donc pour éviter toute confusion, je te conseille de prendre un nom d'argument différent pour ta fonction (lambda). Cela t'évitera des problèmes à l'avenir :3 Ensuite, n'existe-t-il pas des extensions possédant plus de 3 caractères ? (je pense à ".xlsm" par exemple) Auquel cas, il serait préférable de récupérer la position du dernier "." de la chaîne de caractères (les fichiers peuvent comporter des "." dans leur nom). Bisous, Luna

Dans le code écrit par (gile), le nouveau et l'ancien préfixe ne doivent pas contenir les caractères "*". Peut-être que l'erreur vient de là... En clair pour l'utilisation décrite ci-dessus (remplacer les AAA* par BBB*), il faut : (changerPrefixeCalques "AAA" "BBB") Normalement cela devrait fonctionner... Bisous, Luna

Oki doki, juste pour savoir tu renommes uniquement les calques en modifiant la chaîne de début ? En clair, la chaîne de caractères que tu modifies se situe toujours en début de nom de calque ou bien elle peut se situer en milieu ou fin de chaîne aussi ?

Si je comprends bien, ce n'est pas un soucis d'utilisation régulière mais plus une intégration de la fonctionnalité de la commande RENOMMER AAA* en BBB* dans un fichier lisp n'est-ce pas ? Car en effet, la commande RENOMMER est capable de renommer un groupe de calques via la boîte de dialogue, mais cette fonctionnalité n'est pas possible depuis la commande en version -RENOMMER (sans boîte de dialogue) qui est préférable car discrète et automatisable en utilisation LISP. @willy95, dans quelle mesure as-tu besoin d'aide pour ton fichier lisp ? Souhaites-tu des pistes de recherches, ou bien un début de soluce, ou une soluce toute faite ? :3 Tu parles de commande TEXTE, quel lien avec le nom des calques ? Ensuite, pour quelle raison renommer l'ensemble des calques n'est pas possible en le faisant un à un (dans une boucle via la commande -CALQUE ou -RENOMMER) ? Est-ce trop long ou bien y a-t-il une autre raison ? Bisous, Luna

Coucou, Pourquoi ne pas passer par la commande -CALQUE plutôt, avec l'option "Renommer" ? mais bien entendu, il faudra prévoir une boucle car tu devras les renommer un par un :3 Autrement tu peux également passer par la liste DXF (ça évite d'utiliser les commandes) via les fonctions (tblsearch) pour récupérer la liste de calques commençant par "AAA" (un simple (wcmatch layer "AAA*") dans une boucle créer via (tblnext) devrait fonctionner), puis (tblobjname) pour récupérer le nom d'entité du calque et ainsi (entmod) + (subst) pour remplacer le code DXF 2 contenant le nom du calque en remplaçant la chaîne "AAA" par "BBB" :3 Dans tous les cas, il est impossible à mes yeux de renommer un ensemble de calques en une seule fois étant donné qu'ils possèdent tous des noms différents.. (je ne sais pas si je suis claire et je peux te donner la soluce mais c'est tout de même plus intéressant que tu écrives ton propre code si tu souhaites progresser :3 Bisous, Luna

Salut, Si jamais tu veux tout de même prendre en compte les "MTEXT" en plus des "TEXT", tu peux utiliser ceci : (wcmatch (cdr (assoc 0 (entget tex))) "TEXT,MTEXT") ou bien (member (cdr (assoc 0 (entget tex))) '("TEXT" "MTEXT")) Après comme le dit didier, la solution d'un (ssget) avec l'option "_+.:E:S" permet de simuler une sélection via (entsel) sauf que tu peux filtrer ta sélection au passage. Le seul bémol, comme pour chaque (ssget) c'est l'affichage d'un message personnalisé qui est un peu galère... Bisous, Luna

Merci pour le signalement, je n'y avais pas fait attention, le code est à jour dans le post #1 :3 C'est gentil mais je manque encore d'expérience, cela doit faire 1-2ans que j'ai découvert la programmation et AutoLISP ^^" Autant aider quand on en a les moyens, et les grands pontes de cadxp.com ne peuvent pas non plus répondre à tout et tout le monde (surtout quand les mêmes questions reviennent sans cesse ^^). Et puis aider les autres revient à s'aider soi-même alors il n'y a rien à perdre et tout à y gagner :3 Bisous, Luna

Ohayo ! Petit partage pour ceux que ça intéresse (c'est essentiellement pour la modification de réseaux élec' ou autre je pense) de deux commandes nommées PolyAddPoint et PolyDelPoint. Le fonctionnement est basé sur le menu contextuel d'un sommet d'une polyligne (si les grip sont actifs) permettant d'ajouter un sommet à la suite de ce dernier, de supprimer le sommet ou bien d'étirer le sommet. Lorsqu'il y a 1 ou 2 polylignes qui partagent un tracé commun, la modification se fait facilement via ce menu contextuel. Cependant, lorsqu'une vingtaine, cinquantaine voire plus de polylignes partagent un tracé commun (ou des sommets communs) la modification du tracé est plus longue car ce menu contextuel ne fonctionne que pour une polyligne uniquement. L'option "étirer le sommet" fonctionne déjà avec la sélection multiple de polyligne donc pas besoin de s'en occuper, mais si on veut rajouter un sommet commun pour un ensemble de polylignes ou bien en supprimer un, il n'y a pas encore d'alternative à le faire une par une. C'est la raison de ces deux commandes (je travaille avec un plug-in permettant de tracé du câblage électrique automatiquement et les câbles sont donc tous présents sur AutoCAD pour faciliter les extract et le travail mais si le tracé est faux et/ou modifié, ça devient vite un enfer à modifier !). Sur le plan du fonctionnement c'est assez simple, elles fonctionnent toutes deux avec la pré-sélection d'objets (filtrée sur les objets de type "LWPOLYLINE" pour PolyAddPoint et "ARC,LINE,LWPOLYLINE,POLYLINE" pour PolyDelPoint, les splines sont plus complexes à gérer à cause de la différence entre la liste de points (entget) et les sommets cliquables à l'écran via "OSMODE"). PolyAddPoint : Après sélection des polylignes, on détermine le point précédent (même principe que le menu contextuel) et on spécifie le nouveau point à ajouter. Le point précédent peut ne pas appartenir à l'ensemble des polylignes car pour chaque polyligne, le point précédent correspond en réalité au sommet le plus proche du point spécifié par l'utilisateur. Le nouveau point sera ajouter à la suite, suivant le sens de création des polylignes (aucun aperçu du rendu lors de la sélection du nouveau point mis en place, à faire ?). Un retour dans l'historique de commande permet d'avoir un aperçu sur le bon fonctionnement de la commande. (defun C:POLYADDPOINT (/ jsel i name n pt Add-pt) (if (not (setq jsel (last (ssgetfirst)))) (setq jsel (ssget '((0 . "LWPOLYLINE")))) (setq jsel (ssget "_I" '((0 . "LWPOLYLINE")))) ) (sssetfirst nil jsel) (if jsel (while (setq pt (getpoint "\nSélectionner le point précédant le nouveau point à ajouter (ENTER pour terminer) : ")) (setvar "LASTPOINT" pt) (setq i 0 n 0 Add-pt (getpoint "\nSpécifier un nouveau point : ") ) (while (< i (sslength jsel)) (setq name (ssname jsel i) i (1+ i) ) (if (Add-Poly2D-Point name (trans pt 1 0) (trans Add-pt 1 0)) (setq n (1+ n)) ) ) (prompt (strcat "\nLe sommet spécifié appartient désormais à " (itoa n) " / " (itoa (sslength jsel)) " polyligne(s)." "\n" ) ) ) (prompt "\nAucun jeu de sélection n'a été trouvé après application du filtre.") ) (sssetfirst nil nil) (princ) ) ; Permet de récupérer la liste des sommets de l'entité sélectionnée sous forme de liste de coordonnées (2D ou 3D selon le type d'objet) : ;--- La fonction (get-pt-list) possède 1 argument ;--- name correspond au nom de l'entité étudié ;--- Renvoie la liste de coordonnées de chaque points de l'entité dans le repère WCS (à confirmer !) ;--- A étudier en détails sur les transpositions de coordonnées (erreurs de calcul ?) (defun Get-pt-list (name / ent-list pt-list) (if (= (type name) 'ENAME) (progn (setq ent-list (entget name)) (while (setq ent-list (member (assoc 10 ent-list) ent-list)) (setq pt-list (cons (cdr (assoc 10 ent-list)) pt-list) ent-list (cdr ent-list) ) ) ) (prompt "\nL'argument spécifié n'est pas un nom d'entité.\n") ) (if pt-list (cond ((= (cdr (assoc 0 (entget name))) "HATCH") (setq pt-list (cdr (reverse (cdr pt-list)))) ) ((= (cdr (assoc 0 (entget name))) "ARC") (setq pt-list (append pt-list (list (polar (car pt-list) (cdr (assoc 50 (entget name))) (cdr (assoc 40 (entget name)))) (polar (car pt-list) (cdr (assoc 51 (entget name))) (cdr (assoc 40 (entget name)))) ) ) ) ) ((= (cdr (assoc 0 (entget name))) "LINE") (setq pt-list (reverse (cons (cdr (assoc 11 (entget name))) pt-list))) ) ((= (cdr (assoc 0 (entget name))) "POLYLINE") (setq ent-list (entget name)) (while (/= (cdr (assoc 0 ent-list)) "SEQEND") (setq ent-list (entget (setq name (entnext name)))) (if (assoc 10 ent-list) (setq pt-list (cons (cdr (assoc 10 ent-list)) pt-list)) ) ) (setq pt-list (reverse (cdr (reverse pt-list)))) ) (t (setq pt-list (reverse pt-list)) ) ) nil ) ) ; Permet de récupérer les coordonnées du sommet d'une polyligne le plus proche d'un point spécifié en argument : ;--- La fonction (osnap-poly) possède 2 argument ;--- name correspond au nom de l'entité étudié ;--- Point correspond au point de départ qui sera étudié ;--- Renvoie les coordonnées du sommet le plus proche du point de départ appartenant à l'entité name, nil si la fonction (get-pt-list) retourne nil (defun osnap-poly (name Point / pt-list dist pt) (if (setq pt-list (Get-pt-list name)) (progn (foreach pt pt-list (setq dist (cons (cons (distance pt Point) pt) dist)) ) (setq Point (cdr (assoc (apply 'min (mapcar 'car dist)) dist))) ) ) ) ; Permet d'ajouter un point pour les polylignes 2D uniquement à partir du point précédent spécifié en argument : ;--- La fonction (Add-Poly2D-Point) possède 3 arguments ;--- name correspond au nom de l'entité polyligne ;--- Start-pt correspond au point de départ appartenant à la polyligne (ajout de la fonction (osnap-poly) pour utilisation dans un jsel) ;--- Add-pt correspond au point que l'on souhaite ajouter à la polyligne ;--- Renvoie la liste DXF de la nouvelle polyligne si fonctionnnelle, sinon nil (defun Add-Poly2D-Point (name Start-pt Add-pt / entlist pt-list pos add) (if (= (cdr (assoc 0 (entget name))) "LWPOLYLINE") (setq entlist (entget name) pt-list (Get-pt-list name) Start-pt (osnap-poly name Start-pt) pos (+ 5 (- (length entlist) (length (member Start-pt (mapcar 'cdr entlist))))) add (list (assoc 40 (sublist entlist (- pos 4) nil)) (assoc 41 (sublist entlist (- pos 4) nil)) (assoc 42 (sublist entlist (- pos 4) nil)) (assoc 91 (sublist entlist (- pos 4) nil)) ) entlist (entmod (append (sublist entlist 1 pos) (append (list (cons 10 (if (/= 2 (length Add-pt)) (setq Add-pt (list (car Add-pt) (cadr Add-pt))) Add-pt))) add) (sublist entlist (1+ pos) nil) ) ) ) ) ) ; Permet de renvoyer une sous-liste d'une liste spécifiée en argument (similaire à la fonction (substr)) : ;--- La fonction (sublist) possède 3 arguments ;--- lst correspond à la liste que l'on souhaite découper ;--- start correspond à la position de la première valeur conservée. Le premier élément de la liste correspond à 1 ;--- lngth correspond au nombre d'éléments à conserver dans la liste retournée ;--- Renvoit la sous-liste (defun sublist (lst s l) (repeat (1- s) (setq lst (cdr lst))) (setq lst (reverse lst)) (if (or (null l) (minusp l) (not (<= l (- (length lst) (1- s)))) ) lst (repeat (- (length lst) l) (setq lst (cdr lst)) ) ) (reverse lst) ) PolyDelPoint : Après la sélection des objets linéaires (exceptés les splines), supprime chaque sommet spécifié ("OSMODE" = 1) appartenant aux objets linéaires. Un retour dans l'historique de commande permet de quantifier le nombre d'objets linéaires impactés par le sommet spécifié et le nombre d'entités actuellement sélectionnées. Dans le cas d'une entité ne possédant plus que deux sommets dans sa liste et dont on supprime un sommet, cette entité est supprimée du dessin et retirée du jeu de sélection. Dans le cas où le jeu de sélection est vide, la commande s'arrête automatiquement. (defun C:POLYDELPOINT (/ *error* msg osmode jsel i name n d p pt pt-list) (defun *error* (msg) (setvar "OSMODE" osmode) (princ msg) ) (if (not (setq jsel (last (ssgetfirst)))) (setq jsel (ssget '((0 . "ARC,LINE,LWPOLYLINE,POLYLINE")))) (setq jsel (ssget "_I" '((0 . "ARC,LINE,LWPOLYLINE,POLYLINE")))) ) (setq osmode (getvar "OSMODE")) (setvar "OSMODE" 1) (sssetfirst nil jsel) (if jsel (while (and (> (sslength jsel) 0) (null (prompt (strcat "\n" (itoa (sslength jsel)) " objet(s) actuellement sélectionnés"))) (setq pt (getpoint "\nSélectionner un point à supprimer (ENTER pour terminer) : ")) ) (setq i 0 n 0 d 0 ) (while (< i (sslength jsel)) (setq name (ssname jsel i) pt-list (get-pt-list name) p (if (< (length (car pt-list)) (length (setq p (trans pt 1 0)))) (reverse (cdr (reverse p))) p) i (1+ i) ) (if (pt-member p pt-list 0.01) (progn (cond ((member (cons 10 p) (entget name)) (entmod (vl-remove (cons 10 p) (entget name))) ) ((member (cons 11 p) (entget name)) (entmod (vl-remove (cons 11 p) (entget name))) ) ) (if (or (wcmatch (cdr (assoc 0 (entget name))) "LINE,ARC") (<= (length (get-pt-list name)) 1) ) (progn (ssdel name jsel) (entdel name) (setq d (1+ d) i (1- i) ) ) ) (setq n (1+ n)) ) ) ) (sssetfirst nil jsel) (prompt (strcat "\nLe sommet spécifié appartenait à " (itoa n) " / " (itoa (+ d (sslength jsel))) " entité(s) linéaire(s)." (if (/= d 0) (strcat " Parmi ces " (itoa n) " entité(s), " (itoa d) " ont été supprimé du dessin." ) "" ) "\n" ) ) ) (prompt "\nAucun jeu de sélection n'a été trouvé après application du filtre.") ) (sssetfirst nil nil) (setvar "OSMODE" osmode) (princ) ) ; Permet de récupérer la liste des sommets de l'entité sélectionnée sous forme de liste de coordonnées (2D ou 3D selon le type d'objet) : ;--- La fonction (get-pt-list) possède 1 argument ;--- name correspond au nom de l'entité étudié ;--- Renvoie la liste de coordonnées de chaque points de l'entité dans le repère WCS (à confirmer !) ;--- A étudier en détails sur les transpositions de coordonnées (erreurs de calcul ?) (defun Get-pt-list (name / ent-list pt-list) (if (= (type name) 'ENAME) (progn (setq ent-list (entget name)) (while (setq ent-list (member (assoc 10 ent-list) ent-list)) (setq pt-list (cons (cdr (assoc 10 ent-list)) pt-list) ent-list (cdr ent-list) ) ) ) (prompt "\nL'argument spécifié n'est pas un nom d'entité.\n") ) (if pt-list (cond ((= (cdr (assoc 0 (entget name))) "HATCH") (setq pt-list (cdr (reverse (cdr pt-list)))) ) ((= (cdr (assoc 0 (entget name))) "ARC") (setq pt-list (append pt-list (list (polar (car pt-list) (cdr (assoc 50 (entget name))) (cdr (assoc 40 (entget name)))) (polar (car pt-list) (cdr (assoc 51 (entget name))) (cdr (assoc 40 (entget name)))) ) ) ) ) ((= (cdr (assoc 0 (entget name))) "LINE") (setq pt-list (reverse (cons (cdr (assoc 11 (entget name))) pt-list))) ) ((= (cdr (assoc 0 (entget name))) "POLYLINE") (setq ent-list (entget name)) (while (/= (cdr (assoc 0 ent-list)) "SEQEND") (setq ent-list (entget (setq name (entnext name)))) (if (assoc 10 ent-list) (setq pt-list (cons (cdr (assoc 10 ent-list)) pt-list)) ) ) (setq pt-list (reverse (cdr (reverse pt-list)))) ) (t (setq pt-list (reverse pt-list)) ) ) nil ) ) (defun pt-member (pt pt-list fuzz / d) (setq d (strlen (substr (vl-princ-to-string fuzz) (1+ (cond ((= (type fuzz) 'REAL) (vl-string-position (ascii ".") (vl-princ-to-string fuzz))) (t 0)))))) (if (> (length pt) (length (car pt-list))) (setq pt (reverse (cdr (reverse pt)))) ) (while (and pt-list (not (equal (mapcar '(lambda (x) (rtos x 2 d)) pt) (mapcar '(lambda (x) (rtos x 2 d)) (car pt-list)) fuzz)) ) (setq pt-list (cdr pt-list)) ) pt-list ) Ces deux commandes fonctionnent correctement avec les SCU. Et puis comme ça, ça pourra toujours servir d'exemple au besoin pour d'autres programmes :3 Bisous, Luna

oki doki pas de soucis alors ;3 Bisous, Luna

Quand tu dis, ça ne fonctionne pas, quel est le problème exactement ? Quelle erreur rencontres-tu et à quel niveau ? Ensuite je pense que tu peux t'épargner la déclaration de variables (telles que Pos_X et Pos_Y ^^") Bisous, Luna

Salut, Petit conseil, je te suggère de déclarer l'ensemble de tes variables en local (à la suite de ta variable "aligner" sur la ligne du "defun", variable que je ne vois nulle part d'ailleurs ^^"). Cela t'évitera bien des problèmes :3 Ensuite, si je comprend bien ta demande, (ssget "_P") ne fonctionnera pas comme tu l'entends malheureusement. En effet la commande copier renvoie le jeu de sélection initial comme jeu de sélection précédent, en clair (ssget "_P") est identique à ton jeu de sélection nommé jeusel. Le problème est simple dans le cas d'un jeu de sélection composé d'un seul objet (jeusel) et dans le cas d'un lancement non multiple (= la commande copier est lancée une seule fois) : (ssget "_L") ; ou bien (ssadd (entlast)) ; pour conserver la nature de l'objet comme une sélection En revanche cela ne fonctionne que pour la dernière entité créée (ce qui correspond aux contraintes définies au-dessus. Donc dans le cas d'un jeu de sélection composé de plusieurs entité, ça devient plus complexe car il faut ajouter une boucle et ne pas utiliser la commande copier (ce qui permet de traiter les objets un par un et pas tous d'un coup). Désolée si je ne suis pas claire, c'est pas toujours évident de trouver les mots justes tout en vulgarisant le soucis ^^" Bisous, Luna

Vouih la commande SELECTSIMILAR correspond parfaitement à ta demande, tu peux accéder aux paramètres de la commande en la lançant en ayant aucune sélection en cours. Tu peux donc ensuite cocher les cases "Nom" et "Calques" pour obtenir ce que tu veux. Ces paramètres sont conserver via la variable système SELECTSIMILARMODE donc tu as juste à les définir une seule fois :3 Elle fonctionne avec un ou plusieurs objets donc tu peux lui sélectionner un ou plusieurs type d'objet et un ou plusieurs calques. Bisous, Luna

Hiya, (vl-load-com) (defun c:dbl_offset ( / val_offset del_ent js ent vla_obj jsel i) (initget 6) (setq val_offset (getdist (strcat "\nLargeur totale du décalage <" (rtos (getvar "USERR1")) ">:"))) (if (not val_offset) (setq val_offset (getvar "USERR1")) (setvar "USERR1" val_offset)) (initget "Oui Non _Yes No") (setq del_ent (if (eq (getkword "\nSupprimer l'entité sélectionnée [Oui/Non] <Non>: ") "Yes") T nil)) (if (or (setq jsel (ssget "_I")) (setq jsel (ssget)) ) (progn (repeat (setq js (ssadd) i (sslength jsel)) (setq ent (ssname jsel (setq i (1- i))) vla_obj (vlax-ename->vla-object ent) ) (vla-Offset vla_obj (/ val_offset 2.0)) (setq js (ssadd (entlast) js)) (vla-put-Layer (vlax-ename->vla-object (entlast)) (getvar "CLAYER")) (vla-Offset vla_obj (- (/ val_offset 2.0))) (setq js (ssadd (entlast) js)) (vla-put-Layer (vlax-ename->vla-object (entlast)) (getvar "CLAYER")) (if del_ent (entdel ent)) ) (if js (sssetfirst nil js)) ) ) (princ) ) Permet la pré-sélection si besoin (je ne connais pas la fonction vla-offset donc je ne sais pas comment ça se passe dans le cas d'une sélection d'objets non "décalables") et supprime la question "Sortir ?" :3 Bisous, Luna

Il me semble qu'il y a une parenthèse en trop à la suite du (setq long (vlax-get-property axevla 'Length)) donc cela équivaut à la fin du (defun), en début de programme. En revanche, le programme de didier ne prend en compte que les blocs TCPOINT (mise en place d'un filtre lors de la sélection des points), donc si les points que tu utilises sont nommés comme dans l'exemple, il faudrait modifier légèrement la ligne du filtre de sélection : ; Code sur le site de didier : ( prompt "\nChoix des points à traiter" ) ; affichage d'un message en ligne de commande ;création d'un jeu de sélection avec filtre sur entités BLOC et NOM du BLOC ( setq jeupoints ( ssget ( list ( cons 0 "INSERT" ) ( cons 2 "tcpoint" ) ) ) ) ; Code modifié pour pouvoir sélectionner les blocs nommés "Bloc-Pts" : ( prompt "\nChoix des points à traiter" ) ; affichage d'un message en ligne de commande ;création d'un jeu de sélection avec filtre sur entités BLOC et NOM du BLOC ( setq jeupoints ( ssget ( list ( cons 0 "INSERT" ) ( cons 2 "tcpoint,Bloc-Pts" ) ) ) ) Bisous, Luna

Hiya ! Vouih, mes cours de maths remontent à pas si longtemps, ça doit venir de là hihi ^^ Par contre j'avoue que les produits scalaires dans l'espace, je n'avais jamais fait, mais ça fait du bien de faire travailler le cerveau de temps en temps ! °u° Et puis l'approche vectorielle me paraissait la plus simple. Le soucis actuel de cette fonction c'est qu'elle ne dépend pas d'une entité et fonctionne avec 3 points donc une amélioration pourrait être envisagée pour une utilisation plus récurrente en parlant de vecteur et non de point, ce qui permettrait ainsi de définir la dérivée de la courbe et ainsi travailler avec un vecteur directeur dynamique pour conserver cette étude de l'entité (en passant par la fonction (vlax-curve-getfirstderiv)) mais bon, le but était de répondre à la demande alors j'ai fait au plus court <3 Et je m'avoue vaincu devant une telle simplicité de code correspondant à une simple fonction (vlax-curve-getclosestpointto) ==" Décidément je manque de vocabulaire !! Quoi qu'il en soit, à un problème, il y aura toujours une infinité de solutions :3 Bisous, Luna

Le fichier a été légèrement modifié (suppression de la désactivation forcée de l'accrochage aux objets) ci-dessus (#15) Qu'est-ce que tu n'as pas compris ? La version finale consisterait à ajouter un export vers un fichier .xls comme demandé, mais je suis pas douée avec le visual LISP pour ça... ^^" Si cela te convient, ça me va, mais si quelqu'un est capable de te programmer l'extract Excel ça serait mieux :3 Bisous, Luna

Petite mise à jour du programme (en PJ) sur la définition de l'axe (peut se simplifier si cela est trop complexe, le but étant que la commande puisse fonctionner pour d'autres personnes aussi et d'autres utilisations). Je tenterais de m'occuper de l'intégration sous un fichier Excel ensuite, mais je ne maîtrise pas parfaitement les exports sur fichier donc ça prendra sûrement un peu plus de temps qu'il ne m'a fallu pour le coeur du programme. Tu as réussi à charger le programme dans un fichier .lsp sur ton AutoCAD ? D'ailleurs à ce sujet, quel version d'AutoCAD as-tu ? Il est possible que certaines fonctions ne soient pas accessible si ton AutoCAD est trop anciens. PS : Je me suis permise d'ajouter la prise en compte de bloc de point topo standard (souvent nommés "TCPOINT" et dont leur matricule vaut "MAT") ainsi que de simples points non nommés en plus de tes "Bloc-Pts" histoire de le rendre plus accessible suivant les circonstances. Pour les points non nommés, un MTEXT est ajouté à proximité du point (sa hauteur de texte équivaut au cinquantième de la distance séparant les points de référence), appartenant au calque "GPDFL" et avec une dénomination par défaut histoire de les retrouver lors d'un extract :3 Bisous, Luna TOPO-94.lsp

Si tu souhaites le tester, il faut en effet l'enregistrer sous format .lsp (tu peux faire ça depuis un fichier bloc note) et ensuite, il te faut l'enregistrer dans une chemin de support approuvé (Option > Fichiers > Chemin de recherche de fichiers de support / Emplacements approuvés > Ajouter > Parcourir). Une fois le chemin enregistré, il te suffit de taper APPLOAD et tu vas chercher ton fichier .lsp (APPLOAD > Sélection du fichier .lsp > Charger > Fermer) et si jamais tu souhaites qu'il soit charger à chaque session d'AutoCAD de manière automatique, ce qui n'est pas très utile ici car il s'agit d'un simple brouillon (APPLOAD > Contenu > Ajouter > Sélection du fichier .lsp > Fermer > Fermer) Comme je l'ai dit, cela n'est qu'un brouillon mais il te permettra de me dire si cela fonctionne chez toi dans un premier temps et ensuite si tu vois quelques changements à apporter. Juste pour savoir, les points de référence que tu sélectionnes, sont-ils toujours des blocs avec un matricule (comme sur l'exemple) ou bien, s'il faut ajouter la possibilité de nommer ces points dans AutoCAD (création d'un texte à proximité) pour conserver le repérage entre l'export .xls et le fichier source .dwg ? Pour la petite explication du programme final, il devrait prendre en compte la pré-sélection (à condition que PICKFIRST = 1) concernant les points à calculer, tu aura la possibilité de cliquer sur deux points randoms ou bien sélectionner une ligne (on se limitera à une ligne car le nombre n de sommets des polylignes modifie grandement l'exécution du programme mais si c'est un besoin, je regarderais ça), la sélection des points sera un peu plus souple (ne filtrera pas les blocs uniquement nommés "Bloc-Pts", tu auras la possibilité de sélectionner de simples points également si besoin), ajouter un texte afin de nommer les points ne possédant pas de matricule, ajout de la possibilité de calculer les données en étant en SCU (et pas uniquement en SCG), extraction des données selon le format de fichier de COVADIS que tu as transmis (avec tri des résultats en fonction du matricule du point). Les calculs sont fait en 3D donc tu as les coordonnées Z en plus et les points sélectionnés ne sont pas considérer comme un axe mais comme un vecteur, donc le premier point de référence sera la base de calcul et les points en dehors de la projection de l'axe seront quand même calculés (abscisses négatives si les points sont situés dans le sens opposé du vecteur AB). En revanche, j'aurais besoin de savoir, sur le fichier que tu as envoyé, tu considères l'abscisse comme le vecteur AB (A étant le premier point, B le second) mais les résultats pour les ordonnées considères que l'axe des ordonnées correspond au vecteur AB avec une rotation de -pi/2 (dans le sens trigo) soit finalement, le miroir de l'axe traditionnel (X , Y). Ayant considéré un axe non inversé, les résultats au niveau des ordonnées diffèrent au niveau du signe. Donc faut-il que je considère l'axe des ordonnées dans l'autre sens pour être en corrélation avec tes résultats ? Bisous, Luna

Ohayo, Bon je n'ai pas beaucoup de temps pour faire quelque chose de radieux donc je vais procéder par étape si tu veux bien :3 J'ai un programme brouillon qui pour le moment affiche le résultat dans l'historique de commande et il ne donne pas toutes les infos (le but sera de ne pas afficher sur AutoCAD mais dans Excel mais au moins comme ça on peut vérifier les résultats ^^ (defun space-scale-3pt (A B M / xA xB xM yA yB yM zA zB zM Sx Sy Sz l) (setq xA (car A) yA (cadr A) zA (caddr A) xB (car B) yB (cadr B) zB (caddr B) xM (car M) yM (cadr M) zM (caddr M) Sx (+ (* xB xM) (expt xA 2) (- (* xB xA)) (- (* xA xM))) Sy (+ (* yB yM) (expt yA 2) (- (* yB yA)) (- (* yA yM))) Sz (+ (* zB zM) (expt zA 2) (- (* zB zA)) (- (* zA zM))) l (/ (- 0.0 Sx Sy Sz) (- 0.0 (expt (- xB xA) 2) (expt (- yB yA) 2) (expt (- zB zA) 2))) ) (list l (+ (* (- xB xA) l) xA) (+ (* (- yB yA) l) yA) (+ (* (- zB zA) l) zA) ) ) (defun c:GPDFL (/ get-angle seg n jsel i name sc pt mat lst) (defun get-angle (a) (cond ((minusp a) (get-angle (setq a (+ a (* 2 pi))))) ((> a (* 2 pi)) (get-angle (setq a (- a (* 2 pi))))) (t a) ) ) (setq seg (list (setq pt (getpoint "\nVeuillez spécifier le point de base de l'axe : ")) (getpoint pt "\nVeuillez spécifier le second point de référence de l'axe : ") ) n 0 ) (if (or (setq jsel (ssget "_I" '((0 . "INSERT") (2 . "Bloc-Pts")))) (progn (prompt "\nVeuillez sélectionner les \"Bloc-Pts\" par rapport à l'axe :") (setq jsel (ssget '((0 . "INSERT") (2 . "Bloc-Pts")))) ) ) (progn (repeat (setq i (sslength jsel)) (setq name (ssname jsel (setq i (1- i))) sc (space-scale-3pt (car seg) (cadr seg) (cdr (assoc 10 (entget name))) ) pt (cdr sc) mat (getpropertyvalue name "P.1") lst (cons (list (cons -1 mat) (assoc 10 (entget name)) (cons 1041 (if (minusp (car sc)) (- (distance (car seg) pt)) (distance (car seg) pt) ) ) (cons 1041 (if (> (get-angle (- (angle (car seg) (cdr (assoc 10 (entget name))) ) (angle (car seg) (cadr seg)) ) ) pi ) (- (distance pt (cdr (assoc 10 (entget name))))) (distance pt (cdr (assoc 10 (entget name)))) ) ) ) lst ) ) (prompt (strcat "\nPoint n°" (itoa (setq n (1+ n))) " :" "\n Matricule \"" mat "\"" "\n Abscisse = " (rtos (cdr (assoc 1041 (car lst)))) "\n Ordonnée = " (rtos (cdr (last (car lst)))) "\n X = " (rtos (car (cdr (assoc 10 (car lst))))) "\n Y = " (rtos (cadr (cdr (assoc 10 (car lst))))) "\n Z = " (rtos (caddr (cdr (assoc 10 (car lst))))) "\n" ) ) ) ) (prompt "\nErreur : Aucune sélection") ) (princ) ) Didier, si jamais tu souhaites me corriger sur le principe, il n'y a pas de soucis ! Je reprendrais ce brouillon de manière propre pour les extracts Excel ce we quand j'aurais un peu plus de temps. @TOPO-94, pour le moment le programme est très spécifique et ne permet pas de répondre à toutes tes demandes mais ne t'en fais pas, il s'agit juste d'un premier jet basé essentiellement sur les calculs de perpendiculaire dans l'espace et sur les distances algébriques entre points. Le reste, c'est du confort :3 Aller bonne soirée et bisous, Luna