(gile)

Le code source est disponible sur GitHub.

Salut, Si j'ai bien compris, tu pourrais traiter le jeu de sélection pour grouper les références de bloc par valeur de l'attribut NUMCDV dans une liste d'association dont le 'car' serait la valeur de l'attribut et le 'cdr' la liste des blocs avec cette valeur d'attribut. ;; grouper les références de bloc du jeu de sélection par valeur d'attribut "NUMCDV") (setq blocsParCdv nil) (if (setq ss (ssget "_X" '((0 . "INSERT") (2 . "JOINT_VOIE*")))) (repeat (setq i (sslength ss)) (setq bloc (ssname ss (setq i (1- i))) cdv (getpropertyvalue bloc "NUMCDV") blocsParCdv (if (setq entry (assoc cdv blocsParCdv)) (subst (cons cdv (cons bloc (cdr entry))) entry blocsParCdv) (cons (cons cdv (list bloc)) blocsParCdv) ) ) ) ) Cette liste peut ensuite être manipulée avec les nombreuse fonctions de traitement des liste que fournit AutoLISP. Filtrer les doublons : (setq doublons (vl-remove-if '(lambda (x) (< 1 (length (cdr x))))) blocsParCdv) Compter les doublons par valeur d'attribut : (mapcar '(lambda (x) (cons (car x) (length (cdr x)))) doublons) Lister les doublons par PK : (apply 'append (mapcar '(lambda (x) (mapcar '(lambda (y) (strcat "cdv " (car x) " au PK " (getpropertyvalue y "PKT")) ) (cdr x) ) doublons ) ) ) Sélection tous les blocs ayant des doublons : (setq ssDoublons (ssadd)) (foreach x (apply 'append (mapcar 'cdr doublons)) (ssadd x ssDoublons) ) (sssetfirst nil ssDoublons) etc.

Mise à jour 1.0.10 Corrections mineures Léger réusinage du code Un screencast qui montre l'inspection des propriétés d'une surface lissée.

C'est que JohnK (qui a certainement commencé le LISP avant l'arrivée de Visual LISP avec la version R14) considère lui que les fonction vl-* (qui sont arrivées aussi avec Visual LISP) ne sont pas du "pur AutoLISP". Ce n'est pas bien grave, il suffit de comprendre la "règle du jeu" : Using only AutoLISP" = pas de fonction vl.

C'est juste l'inverse. avec les fonction vla_* on n'accède qu'à l'API COM d'autoCAD, avec les fonction vlax-* on utilise ActiveX pour accéder à des applications externes (y compris l'API COM d'autoCAD). Il te manque (vlr-*) pour les réacteurs. J'imagine que JohnK (anciennement Se7en) donne cette règle à ces challenges pour que soient abordés les fondamentaux d'AutoLISP. Ces clones supportent depuis plusieurs versions le "Visual LSIP".

Salut, Faut lire la ligne de commande... (command "_-VPORTS" "_Toggle")

Salut, Ces challenges ne sont pas nouveaux, il existent sur TheSwamp depuis belle lurette et je me souviens m'y être frotté à des pointures de l'époque (ElpanovEvgeniy, Mickael Puckett, Vovka, Tim Willey, Kerry Brown, ...). On y a même vu arriver et progresser le talentueux Lee Mac. Je me suis beaucoup amusé et j'ai énormément appris avec ces exercices ludiques. Le regretté Patrick_35 les avait importé sur CADxp en 2007 (voir ici) et, depuis on a essayé d'en lancer de nouveaux mais avec moins de succès que sur TheSwamp. Une recherche avec "challenge" dans les forums LISP de CADxp donne quand même 3 pages de résultats. Il y a toujours moyen de s'entrainer avec ces sujets si on s'efforce de cherche avant de regarder les solutions...

Le 'q' vient de la fonction quote (ne pas évaluer) : set quote. (setq a 1) est équivalent à : (set 'a 1) qui est une abréviation pour : (set (quote a) 1).

Les "djeunes", je suis désolé de jouer les "vieux cons", mais il faut vous rendre à la raison, se lancer dans la programmation suppose qu'il va falloir faire des efforts (beaucoup) et qu'apprendre demande du travail (mes connaissances en programmation ne sont pas tombées du ciel, elle sont le fruit d'une vingtaine d'années d'apprentissage). Apprendre les rudiments d'anglais technique nécessaire pour comprendre les différentes aides ce n'est pas comme lire du Shakespeare dans le texte et ce n'est vraiment pas grand chose comparé à apprendre à utiliser un langage informatique. À mon avis, si on ne sent pas capable de faire ce petit effort (avec l'aide des traducteurs en ligne si besoin), ce n'est pas la peine d'aller plus loin...

C'était juste une remarque "pour être rigoureux", car je pense que c'est une qualité primordiale quand on se lance dans la programmation. Mais le VB(A) tolère ce genre de manque de rigueur et c'est une des raisons pour lesquelles je n'aime pas ce langage. Ceci n'est pas propre au VBA AutoCAD, c'est une caractéristique de tous les dialectes du VB. Sinon, plus important, ma première remarque devrait répondre à pourquoi : VBA bloque au "For Each ATT", "Objet requis"... Tu utilises dans ta procédure BlkRefObj qui n'est ni un argument de la procédure, ni une variable initialisée dans la procédure qui doit donc être Nothing d'où le : "Objet requis". Je pense que BlkRefObj devrait être un argument de la procédure MajAtt comme Attribut et Texte.

D'où vient BlkRefObj dans la fonction MajAttrib ? D'ailleurs, pour être rigoureux (et rigueur et logique sont fondamentales en programmation) MajAttrib devrait être une procédure (Sub) plutôt qu'une fonction (Function) puisque la méthode ne renvoie rien, mais la rigueur n'est vraiment pas une caractéristique du VB(A).

Si tu ne fais pas l'effort de comprendre les pages de l'aide (certes en anglais, mais il existe de nombreux outils de traduction sur le web) qui sont toujours organisées de la même façon et qui fournissent des exemples, tu auras toujours besoin de demander de l'aide à d'autres ce qui ne te feras pas vraiment progresser.

Je pense qu ce n'est pas tant que l'aide soit plus ou moins bien faite qui a changé, c'est plutôt l'illusion qu'avec Internet on obtient immédiatement une réponse qui nous dispense de chercher, d'analyser, d'étudier... On apprend et on retient bien mieux ce qu'on a trouvé et expérimenté par soi même. Un exemple tout frais ici.

Salut, Il ne s'agit pas d'une "astuce", juste de la lecture de la documentation : la méthode GetAttributes permet d'accéder à la collection des objets AttributeReference du bloc.

Le LISP ne fonctionne que dans le contexte du document dans lequel il a été lancé. Pour travailler sur d'autres dwg, tu peux utiliser ObjectDBX qui permet d'accéder à la base de donnée d'un fichier fermer (en fait de l'ouvrir en mémoire mais pas dans l'éditeur). Cette méthode n'autorise que les fonction vla_ ou vlax- pour lire/écrire dans le fichier. Sinon, SAS est très bien pour faire du traitement par lot.

Pas tout à fait, je disais "Puis, tant que le premier caractère ..." et ta routine évalue toute la chaîne même si les derniers caractères ne sont pas de chiffres. On pourrait utiliser un argument à T ou nil pour s'arrêter au dernier chiffre trouvé: (defun f (s p) (cond ((= s "") "") ((wcmatch (substr s 1 1) "#") (strcat (substr s 1 1) (f (substr s 2) T))) (p "") (T (f (substr s 2) p)) ) ) _$ (f "Ma80cm" nil) "80"

Mise à jour 1.0.9 Corrections mineures Réusinage du code

Pour capturer un ou plusieurs nombres, entiers ou réels, négatifs ou positifs, j'utiliserais les expressions régulières. (defun getFirstNumber (str) (caar (RegExpExecute str "(-?\\d+(?:\\.\\d+)?)" nil nil)) ) (defun getAllNumbers (str) (mapcar 'car (RegExpExecute str "(-?\\d+(?:\\.\\d+)?)" nil T)) ) _$ (getFirstNumber "Ma80cm") "80" _$ (getFirstNumber "Surface = 42.23m (+NGF)") "42.23" _$ (getAllNumbers "Surface = 42.23m² Température = -4°C") ("42.23" "-4") Petite explication du motif (pattern) utilisé : ( début de groupe capturé -? zero ou un - \\d+ un ou plusieurs chiffres (?: début de groupe non capturé \\.\\d+ un point suivi de un ou plusieurs chiffres ) fin de groupe non capturé ? zero ou un groupe ) fin de groupe capturé

Tu n'as pas du chercher bien loin... getdist

"un bloc inséré" n'est qu'une référence à une définition de bloc. On ne peut pas modifier les entités d'une référence de bloc, il faut modifier la définition du bloc et la modification sera répercutée dans toutes les références. Pour modifier la définition du bloc, le plus simple est d'utiliser l'éditeur de bloc.

(defun fun1 (input / output) (while (not (wcmatch (substr input 1 1) "#")) (setq input (substr input 2)) ) (setq output "") (while (wcmatch (substr input 1 1) "#") (setq output (strcat output (substr input 1 1)) input (substr input 2) ) ) output ) (defun fun2 (str / lst res) (setq lst (vl-string->list str)) (while (and lst (not (< 47 (car lst) 58))) (setq lst (cdr lst)) ) (while (and lst (< 47 (car lst) 58)) (setq res (cons (car lst) res) lst (cdr lst) ) ) (vl-list->string (reverse res)) ) (defun fun3 (str) (vl-list->string (vl-remove-if-not '(lambda (c) (< 47 c 58)) (vl-string->list str) ) ) )

Donc, tant que le premier caractère de la chaine en entrée n'est pas un chiffre, on supprime le premier caractère de la chaine en entrée. Puis, tant que le premier caractère de la chaîne de la chaine en entrée est un chiffre, on ajoute ce caractère à la fin de la chaîne en sortie et on supprime le premier caractère de la chaine en entrée. Voir les fonctions : while, substr, wcmatch, et strcat. Ou, plus efficient, traiter les chaînes comme des listes de caractère ascii (nombres entiers en LISP). Voir les fonctions vl-string->list, vl-list->string et les fondamentales car, cdr et cons. Ou encore, si la chaîne ne contient qu'un nombre, plus concis et élégant avec : vl-string->list, vl-list->string, vl-remove-if-not et lambda.

Mise à jour 1.0.8 : Inspection de Material Corrections mineures Réusinage du code

en quoi est-ce différent de : ou : Ce qui donne en code testable : (defun c:test1 (/ Rep LiGbBt) ;; initialisation et stockage de la valeur par défaut dans une variable globale (if (not LiGbBtOld) (setq LiGbBtOld "Oui") ) (initget "Oui Non") (if (not (setq Rep (getkword (strcat "\nLiaison en attente sur semelle [Oui/Non] <" LiGbBtOld "> : ") ;_ Fin de strcat ) ;_ Fin de getkword ) ;_ Fin de setq ) ;_ fin de not (setq Rep LiGbBtOld) ) ;_ Fin de if (setq LiGbBt Rep) ;; mise à jour de la valeur par défaut (setq LiGbBtOld Rep) (prompt (strcat "\nLiGbBt: " LiGbBt)) (princ) ) ou : (defun c:test2 (/ Rep) ;; initialisation et stockage de la valeur par défaut dans une variable globale (if (not *LiGbBt*) (setq *LiGbBt* "Oui") ) (initget "Oui Non") (if (setq Rep (getkword (strcat "\nLiaison en attente sur semelle [Oui/Non] <" *LiGbBt* "> : ") ;_ Fin de strcat ) ;_ Fin de getkword ) ;_ Fin de setq (setq *LiGbBt* Rep) ) ;_ Fin de if (prompt (strcat "\n*LiGbBt*: " *LiGbBt*)) (princ) )

Salut, Tu utilises une expression (or ...) mais il n'y a qu'une seule expression (setq ...) dans cette expression. en mauvais français, ça revient à dire : "l'utilisateur spécifie une option ou". Plutôt que d'utiliser une expression logique (or ...) que tu ne semble pas complètement maitriser, essaye plutôt avec son équivalent dans ce cas précis : (if (not ...) ...) Algo : si l'utilisateur ne spécifie pas d'options on affecte à Rep la valeur de LiGbBtOld, puis on affecte à LiGbBt la valeur de Ref. (initget "Oui Non") (if (not (setq Rep (getkword (strcat "\nLiaison en attente sur semelle [Oui/Non] <" LiGbBtOld "> : ") ;_ Fin de strcat ) ;_ Fin de getkword ) ;_ Fin de setq ) ;_ fin de not (setq Rep LiGbBtOld) ) ;_ Fin de if (setq LiGbBt Rep) Mais on peut écrire les choses de façon plus simple sans multiplier les variables. Algo : si l'utilisateur spécifie une option, on l'affecte à LiGbBt). (initget "Oui Non") (if (setq tmp (getkword (strcat "\nLiaison en attente sur semelle [Oui/Non] <" LiGbBt "> : ") ;_ Fin de strcat ) ;_ Fin de getkword ) ;_ Fin de setq (setq LiGbBt tmp) ) ;_ Fin de if Tout ça n'est que de la logique binaire qu'il est toujours préférable d'exprimer le plus simplement possible.