VDH-Bruno

Salut Patrick_35, Oui, mais pas sur une ligne, un cercle etc.., en fait dans ce cas je me suis servi de vlax-method-applicable-p comme d’un filtre de sélection pour la fonction entsel. Mais merci pour l’observation cela aurait pu… Car je ne suis pas complétement à l’aise avec l'Automation ActiveX, je m’exerce donc un peu sur le forum dans l’espoir que d’autres Lispeurs (plus aguerri) comme toi me reprennent en cas d’errements. A+ et merci, (Ps: Comme je te l'ai déjà dit, j'aime bien lorsque l'on ajoute son grain de sel, ça fait avancer..)

Re, Pour les codes en vla-, mes propositions : Dans ce cas la méthode la plus direct, avec vlax-invoke (vl-load-com) ((lambda (/ obj) (if (vlax-method-applicable-p (setq obj (vlax-ename->vla-object (car (entsel)))) 'GetAttributes) (mapcar 'vla-get-TextString (vlax-invoke obj 'GetAttributes)) ) )) Sinon avec vlax-invoke-method ((lambda (/ obj) (if (vlax-method-applicable-p (setq obj (vlax-ename->vla-object (car (entsel)))) 'GetAttributes) (mapcar 'vla-get-TextString (vlax-safearray->list (vlax-variant-value (vlax-invoke-method obj 'GetAttributes)))) ) )) Ou alors avec vla-method ((lambda (/ obj) (if (vlax-method-applicable-p (setq obj (vlax-ename->vla-object (car (entsel)))) 'GetAttributes) (mapcar 'vla-get-TextString (vlax-safearray->list (vlax-variant-value (vla-GetAttributes obj )))) ) )) Pour les fichiers d’aide sur ActiveX, en faisant une rapide recherche sur le forum tu devrais rapidement trouver ton bonheur. A+

Personnellement je ne connais pas les caractéristiques du profil que tu cherches à obtenir, soit tu as fait une erreur de frappe, ou il y a une coquille dans ton livre. Le mieux à faire dans ce cas c’est de « dérouler le programme à la main » pour trouver ou ça cloche. A+

Bonjour, Cas classique d’exemples prévu pour tourner sur une version anglaise d’AutoCAD, pour les exemples de ton livre fait précéder les appels aux commandes AutoCAD par _. et les options de commande par _ ,ce qui internationalisera ces dernières. Illustration sur ton code précédent : (command "_.pline" O "_w" 0 0 pt1 pt2 pt3 pt4 pt5 pt6 pt7 pt8 pt9 pt10 pt11 pt12 O "") (command "_.fillet" "_r" R) (command "_.fillet" pt3 pt4 pt4 pt5 pt9 pt10 pt10 pt11 "") Cordialement,

Salut, Oui comme ceci et sans vla (mapcar 'cdr (GetAttribs (car (entsel)))) Je t’invite à consulter ce post tu y trouveras notamment le code de la fonction GetAttribs pour faire tourner l’exemple.. A+

Salut, En adaptant légèrement le code posté par Tramber, il n’y a rien de plus aisé. Le plus dure était de comprendre le problème.. Le code à tester : (defun c:zcot (/ i ss ent dxoj dxf13 dxf14) (and (setq i 0 ss (ssget '((0 . "DIMENSION"))) ) (while (setq ent (ssname ss i)) (setq i (1+ i) dxoj (entget ent) dxf13 (assoc 13 dxoj) dxf14 (assoc 14 dxoj) ) (entmod (subst (list 13 (cadr dxf13) (caddr dxf13) 0.0) dxf13 (subst (list 14 (cadr dxf14) (caddr dxf14) 0.0) dxf14 dxoj) ) ) ) ) (princ) ) A+

Salut, Une petite remarque en passant, même si ça fait un moment que je n’établis plus de plan de ferraillages, par convention du moins celle que j’utilisais lorsque je dessinais à la main (convention que j’ai transposé par la suite sur AutoCAD) En matière de cotation des aciers transversaux, ils existent 2 écoles (à adapter suivant l’échelle du dessin, sa complexité et les habitudes de ton entreprise). Soit tu as dessiné tous les aciers transversaux, dans ce cas en général tu ne cotes et représente que les changements d’intervalles dans ta cotation, auquel cas en forçant le texte de cotation puis en définissant un style de cotation qui va bien. Tu devrais pouvoir arriver à un résultat satisfaisant (cela peut même s’automatiser simplement en Lisp). Soit tu ne représentes que les aciers transversaux qui correspondent aux changements d’intervalles puis tu cotes les changements d’intervalles, en prenant soin de symboliser tous les intervalles avec un trait plus petit sur ta ligne de cotation (traits correspondant aux aciers non dessinés), Dans ton exemple on voit les 2 méthodes employés simultanément, ça fait un peu doublons au niveau de l’information, tu ne trouves pas ? Cordialement, Ps: Souvent le mieux est l’ennemi du bien

Re, En relisant l’exemple que tu donne pour obtenir ta liste de points, je me demande si tout simplement tu ne souhaitais pas dessiner directement une polyligne de façon dynamique, dans ce cas il y a un sur le forum un « célèbre » code avec command Le code (command "_.pline") (while (< 0 (getvar 'cmdactive)) (command pause)) Que tu peux retrouver ici et ailleurs. A+

Salut, Pour aller dans le sens de (gile), en plus de foreach qui va bien, il est également possible de varianter avec mapcar et apply (command "_pline") (mapcar 'command (reverse lst)) (command "") ou (command "_pline") (apply 'command (reverse lst)) (command "") A+

Bonjour, Allez une dernière petite variante de lsubst , certes ce n’est pas la version la plus performante mais c’est sans l’utilisation de vl-position, member, subst, assoc et autres fonctions spécialisées… (defun lsubst (n o l) (mapcar '(lambda (l / x) (mapcar '(lambda (n o) (if (equal o l) (setq x (list n)))) n o ) (if x (car x) l) ) l ) ) A+

Re, Pour Evgeniy, j’ai regardé les testes proposés je pense que pour test2 et test3 la répétition des éléments identiques dans new et old n’a pas de sens cela devrait être contrôlé en amont. Для Evgeniy, я посмотрел на предлагаемые испытания Я думаю, для test2 и test3 повторение одинаковых элементов в new и old не имеет смысла, она должна быть проверена заранее. -------------------------------- J’édite mon message pour diffuser les résultats des évaluations Benchmark En ce qui concerne les codes proposés, ils sont de trois types ceux construit avec vl-position (et member qui utilise le même algorithme), subst et assoc. Pour les comparer et les soumettre au teste du Benchmark, j’ai gardé la version la plus optimisée pour chaque famille d’algorithme à savoir : Avec assoc J’ai retenu le code donné par ElpanovEvgeniy réponse n°8 Pour vl-position Code donné par Patrick_35 et bryce puis optimisé par ElpanovEvgeniy réponse n°10 Pour subst La version que je propose en réponse n°12 Les résultats des évaluations donnés au Benchmark le sont pour les valeurs proposées en réponse n°11 (benchmark (mapcar '(lambda (fun)(list fun 'new 'old 'lst)) '(lsubst:assoc lsubst:vl-position lsubst:subst) ) ) Teste1 Teste 2 Teste 3 A+

Bonjour, Sur le même algorithme que ma réponse n°4 mais en bouclant cette fois avec mapcar.. (defun bv:lsubst (newlst oldlst lst) (setq lst (mapcar 'cons lst lst)) (mapcar '(lambda (n o) (setq lst (subst n o lst))) (mapcar 'cons newlst oldlst) (mapcar 'cons oldlst oldlst) ) (mapcar 'car lst) ) Pour les testes sur les longues listes je suis d'accord avec vous Evgeniy. Comme je ne l'ai pas fait j'ai donné un teste qui donnait tout le monde gagnant.. Pour bien faire il faudrait même faire varier le nombre d’éléments identiques, car la version avec subst travaille différemment des autres versions. Для испытаний на длинный список я согласен с вами, Evgeniy. Поскольку я не я дал тест, который дал каждому победителю .. В идеале она должна быть еще варьировать количество одинаковых элементов, так как версия с subst работает иначе, чем в других версиях. Cordialement (Modifié code en remplaçant 'list par 'cons)

Bonsoir, J’ai rallumé mon micro trop tard, EpanovEvgeniy a été plus rapide pour la variante avec assoc, je le félicite (Я поздравляю)!!! Lorsque je vous ai lu j’étais comme (gile), il me fallait encore affiner le (lsubst '(b c nil) '(c b a) '(a b c d c)). Mon code, c’est sans regret j’étais de toutes façons moins efficace avec une liste au lieu d’une paire pointée. (defun bv:lsubst (new old lst / old-new) (setq old-new (mapcar 'list old new)) (mapcar '(lambda (x / y) (cond ((setq y (assoc x old-new)) (cadr y)) (x))) lst) ) Pour la forme et faire plaisir à Tramber un petit Benchmark (benchmark (mapcar '(lambda (fun)(list fun ''(b c d) ''(c B) ''(a b c d c b c a d c))) '(bryce:lsubst Patrick:lsubst ElpanovEvgeniy:lsubst bv:lsubst) ) ) (Ps: Pourquoi utiliser function car malgré plusieurs tests, à ce jour je n'ai jamais réussi à percevoir son intéret..) A+

Salut, Rapidement, c’est un problème de syntaxe au sujet des appels de fonctions, depuis un lisp cela diffère légèrement de la ligne de commande. Si tu défini une fonction avec c:DEMARRAGE, tu dois appeler (c :DEMARRAGE) dans s::startup Si tu défini une fonction avec DEMARRAGE , tu dois appeler (DEMARRAGE) dans s::startup Je te conseil la lecture de ce très bon sujet concernant l’emploie de S::STARTUP , tu verra que ta fonction DEMARRAGE ne sert à rien tu peux directement lancer tes commandes depuis s::startup, comme cela tu n'as pas à te soucier de savoir si tes définitions de fonctions seront chargés ou non avant leurs appels. A+

Bonjour, Très heureux de voir qu’il a des participants, mention à vous deux, même si je m’attendais à voir surgir les réponses avec vl-position. Je saluts l’effort de Patrick_35 pour sa variante avec member. Pour ma part j’avais tenté une autre approche plus évidente que j’aurais cru plus efficace (sans l’utilisation de vl-position), mais cela n’a pas été le cas.. En récursion enveloppante (defun lsubst (newlst oldlst lst / fun) (defun fun (new old lst) (if (and new old) (subst (car new) (car old) (fun (cdr new) (cdr old) lst)) lst ) ) (mapcar 'car (fun (mapcar 'list newlst oldlst) (mapcar 'list oldlst oldlst) (mapcar 'list lst lst) ) ) ) En récursion terminale (defun lsubst (newlst oldlst lst / fun) (defun fun (new old lst) (if (and new old) (fun (cdr new) (cdr old) (subst (car new) (car old) lst)) lst ) ) (mapcar 'car (fun (mapcar 'list newlst oldlst) (mapcar 'list oldlst oldlst) (mapcar 'list lst lst) ) ) ) Et comme la forme récursive ne se justifie pas du tout En version itérative (defun bv:lsubst (newlst oldlst lst) (setq newlst (mapcar 'list newlst oldlst) oldlst (mapcar 'list oldlst oldlst) lst (mapcar 'list lst lst) ) (while (and newlst oldlst) (setq lst (subst (car newlst) (car oldlst) lst) newlst (cdr newlst) oldlst (cdr oldlst) ) ) (mapcar 'car lst) ) Allez hop! Un petit coup de benchmark (benchmark '((bv:lsubst '(b c d) '(c B) '(a b c d c b c a d c)) (bryce:lsubst '(b c d) '(c B) '(a b c d c b c a d c)) (Patrick1:lsubst '(b c d) '(c B) '(a b c d c b c a d c)) (Patrick2:lsubst '(b c d) '(c B) '(a b c d c b c a d c)) ) ) Dans l’attente d’autres solutions, pendant ce temps je regarde si il y a moyen de faire mieux mais cela me semble difficile, à voir..

Bonsoir, Voilà en corrigeant une coquille dans une de mes routines, j’ai pensé que la routine en question pourrait faire l’objet d’un petit challenge pas trop compliqué de début d’année. Il s’agit simplement d’émuler un peu la fonction subst de façon à ce que cette nouvelle version ne travaille plus sur un seul élément à remplacer, mais sur un ensemble d’éléments fourni sous forme de liste. Syntaxe (lsubst lst-nouv-élemt lst-anc-élemt lst) Arguments lst-nouv-élemt: Liste des nouveaux éléments lst-anc-élemt : Liste des anciens éléments lst : Liste de réference Valeur en retour Une liste modifié ou les nouveaux éléments remplacent les anciens, la liste est inchangée pour les éléments introuvablent Quelques exemples de résultats attendus: (lsubst '(x y z) '(a c e) '(a b c d c)) retourne (X B Y D Y) (lsubst '(b c nil) '(c b a) '(a b c d c)) retourne (nil C B D B) (lsubst '(b c) '(c b a) '(a b c d c)) retourne (A C B D B) (lsubst '(b c d) '(c B) '(a b c d c)) retourne (A C B D B) (lsubst '(z y w) '(a b c) '(a b c d c)) retourne (Z Y W D W) (lsubst '(b c a) '(a b c) '(a b c d c)) retourne (B C A D A) En espérant avoir été suffisamment explicite, sinon ne pas hésiter à demander un complément d’information. A+

Bonjour, Si je ne me trompe c’est un peu le même souci exprimé différemment que dans ta première intervention, à savoir créer un nom de variable lui affecter une valeur et récupérer le nom de variable plutôt que la valeur qui lui est transmis. Pour faire cela tu ne peux éviter l’emploi d’une variable ou fonction auxiliaire, ce que j’ai fait en utilisant la fonction lambda dans l’exemple précédent avec cette ligne de code. ((lambda (sym) (set sym pt) sym) (read (strcat "point" (itoa i)))) En l’adaptant à ton exemple on obtiendrait: _$ ((lambda (sym) (set sym '(0 0)) sym) (read (strcat "point" (itoa 0)))) POINT0 _$ POINT0 (0 0) _$ Sur le fond je te conseille de suivre les recommandations de (gile) à savoir stocker tes valeurs de points dans une liste et d’y accéder avec la fonction nth car effectivement les points ont beau être affectés à des symboles, ces symboles ne sont pas directement utilisés. Sinon si tu tiens vraiment (pour des raisons qui te son propre) à lier tes valeurs à une étiquette (ou clef) , je ne saurai trop te conseiller à t’intéresser aux listes d’associations au cas ou tu cela ne te serai pas famillié, on y accède facilement avec la fonction assoc (c’est le procédé utilisé lorsque tu travailles avec les codes DXF). Un exemple avec une liste d’association : ;; Fonction de création d'une liste de point associative ((clef x y z) ...) (defun lstdepoint (/ i pt lst) (setq i 0) (while (setq pt (getpoint)) (setq lst (cons (cons (strcat "point" (itoa (setq i (1+ i)))) pt) lst)) ) (reverse lst) ) Création de la liste de point (ex liste de 4 points cliqués) _$ (setq ass-lst (lstdepoint)) (("point1" 25.0 25.0 0.0) ("point2" 25.0 100.0 0.0) ("point3" 100.0 100.0 0.0) ("point4" 100.0 25.0 0.0)) Accés au "point3" _$ (assoc "point3" ass-lst) ("point3" 100.0 100.0 0.0) ou _$ (cdr (assoc "point3" ass-lst)) (100.0 100.0 0.0) Une dernière petite précision au cas ou la notion de liste d’association te serai étrangère en plus d’avoir un accès facile au moyen de la fonction assoc, tu peux tout aussi facilement modifier et mettre à jour ta liste avec la fonction subst (fonction de substitution). Modification des coordonnées du point3 dans ass-lst _$ (setq ass-lst (subst '("point3" 50.0 50.0 0.0) (assoc "point3" ass-lst) ass-lst)) (("point1" 25.0 25.0 0.0) ("point2" 25.0 100.0 0.0) ("point3" 50.0 50.0 0.0) ("point4" 100.0 25.0 0.0)) A+

Re, Je m’étais il y a plusieurs mois déjà, amusé sur les concaténations de car et cdr à écrire un code qui travaillait sur la création de symbole ne le retrouvant plus, je vais faire comme capde06, y aller de mon petit exemple et faire ce que tu proposes, à savoir saisir plusieurs points en les appelants point1, point2 point3 ect.. Même si comme l’a précisé (gile) il est préférable de stoker directement les coordonnées des points. La fonction: ;; Renvoie une liste de symbol (chaques symbols contenant les coordonnées du point cliqué) (defun point-xxx (i pt) (if pt (cons ((lambda (sym) (set sym pt) sym) (read (strcat "point" (itoa i))))(point-xxx (1+ i) (getpoint))) ) ) Exemple en débutant l'incrémentation à 3 et en cliquant 4 points, la fonction renvoi une liste des variables créer pour chaques points cliqué. _$ (setq lstpoint (point-xxx 3 (getpoint))) (POINT3 POINT4 POINT5 POINT6) Pour extraire collectivement les coordonnées des points correspondants _$ (mapcar 'eval lstpoint) ((10.0 10.0 0.0) (10.0 50.0 0.0) (35.0 50.0 0.0) (35.0 10.0 0.0)) Pour mettre toutes les variables à nil et libérer la mémoire _$ (mapcar '(lambda (sym) (set sym nil)) lstpoint) (nil nil nil nil) Ou _$ (foreach sym lstpoint (set sym nil)) nil A+

Bonjour et bonne année à tous, Je suis d’accord avec (gile) surtout pour ce cas précis, néanmoins je trouve tout de même intéressant (ne serai ce que pour des raisons de compréhensions et de culture général) de connaître la possibilité de travailler directement sur les symboles. Extrait de la définition d’un symbole Lisp sur wikipédia: Le fait d’utilisé directement le nom de symbole, était beaucoup plus répandu (utilisé notamment comme texte) en Lisp lorsque celui-ci ne gérait pas les chaînes de caractères, ce qui n’est plus le cas aujourd’hui et ce qui ne l’a jamais été en AutoLISP. Ce qui explique que pour faire ce que tu souhaites tu sois obligé d’utiliser les fonctions de manipulations de chaînes de caractères, puis d’employer read pour faire une conversion du type STR vers le type SYM. Alors que dans d’autres versions LISP, il existe d’autres façons d’accéder au nom d’un symbole et il y a également des fonctions spécialisées permettant de traiter directement le nom de symbole comme par exemple les fonctions EXPLODE et IMPLODE A+

Salut, A ce que je vois les agrimensores et autres libratores du forum sont en passe d'écrire un nouveau traité gromatique.. Amicalement

(setq val (getstring "\nValeur initiale: ")) (setq val (atoi val)) (gile) astucieuse l’émulation avec atoi sur le getstring en lieu et place d’un classique getint.. Clap, clap, clap tu viens de me faire découvrir le comportement d’atoi sur les caractères non exclusivement numérique et je t’en remercie. A+ (ps: tout à fait le genre d'astuce dont je suis friand..)

Merci, pour toutes ces précisions. C’est un peu, pourquoi je ne l’ai pas cité, à moins que cela ne change, car si un jour je me lance en .NET le choix du langage se fera dans un premier temps en fonction de l’importance de sa communauté (communauté francophone de préférence). Plus passionné que programmeur et ce n'est pas vraiment d’actualité mais disons que je ne m’interdit plus rien depuis que je me suis aperçu que passé du diesel au lisp n’a rien eu d’insurmontable et du Lisp au VLisp non plus même si pour ce dernier je m’étais laissé impressionné un bon moment par les termes: propriétés, méthodes , objet, Automations ActiveX, variants etc.. Sinon pour rester un peu dans le sujet, j’ai vu qu’il existait également d’autres possibilité que celles cités précédemment, notamment Delphi (pour créer des ARX, il me semble) mais je sais plus si tous cela est encore d’actualité.. A+ (Ps: J’ai même un moment pensé à Common Lisp, avant de rapidement laisser tomber l’idée n’ayant pas trouvé de communauté francophone suffisamment vivante pour débuter sérieusement..)

Bonjour, (gile) je voudrai profiter de ton intervention pour avoir un avis plus personnel, j’ai lu que tu avais choisie au départ C# pour l’apprentissage de l’environnement .NET pourquoi n’avoir pas choisie directement C++ (il me semble que le langage est supporté par l’environnement .NET). Est-ce parce que C++ est un langage de plus bas niveau et donc plus «beaucoup» difficile d’accès que C# (en plus de l’apprentissage de .NET)? Si je m’interroge sur tes choix, c’est que je me sens dans une bonne dynamique d’apprentissage et d’assimilation, aujourd’hui mes modestes objectifs initiaux en matière de programmation sont quasi atteint voir même dépassé dans certain cas, à savoir créer acquérir une certaine autonomie dans l’élaboration de mes propres routines. En continuant sur cette voie, je me dis que peut être l’envie et la motivation me pousseront à sortir de l’environnement AutoCAD. Même si ce n’est pas d’actualité disons que je commence à m’interroger sur des notions qui me sont étrangères, en cherchant à évaluer le temps et la difficulté que cela représenterai.. Merci,

Bonsoir, Je sais que didier à répondu à ton besoin, je te propose tout de même une petite variante avec la commande _rectang et la mémorisation des demi-valeurs pour te simplifier les calculs par la suite.. (defun c:rc1 (/ demi-larg demi-long pt) (setq demi-larg (/ (getreal "\nLargeur : ") 2) demi-long (/ (getreal "\nLongueur : ") 2) pt (getpoint "\npoint d'insertion : ") ) (command "_rectang" (list (- (car pt) demi-long) (- (cadr pt) demi-larg)) (list (+ (car pt) demi-long) (+ (cadr pt) demi-larg)) ) (princ) ) Une autre variante possible est de laisser la possibilité à l’utilisateur d’orienter son rectangle.. (defun c:rc2 (/ demi-larg demi-long pt) (setq demi-larg (/ (getreal "\nLargeur : ") 2) demi-long (/ (getreal "\nLongueur : ") 2) pt (getpoint "\npoint d'insertion : ") ) (command "_rectang" (list (- (car pt) demi-long) (- (cadr pt) demi-larg)) (list (+ (car pt) demi-long) (+ (cadr pt) demi-larg)) ) (command "_rotate" (entlast) "" pt "pause") (princ) ) A+

Salut Comme toi x_all je pense que l’extraction d’attribut est un bon outil (je l’utilise depuis 2005 un peu par obligation sur LT à l’époque) peut être un peu difficile d’accès au premier abord. Avec le lien de x_all je viens de remarquer que la fonction a positivement évolué sur 2011 faut dire que je l’ai pas eu suffisamment longtemps pour m’en rendre compte je suis repassé sur 2007 (même si j’ai pas désinstallé la version 2011 à mon domicile), pas le choix c’était ça ou une version LT on peut dire que j’ai échappé à l’"apoca-LISP", mais bon c’est reculer pour mieux sauter car je viens d’apprendre qu’il n’y aurait plus de mise à jour et qu’a terme c’était l’"AutoCADlypse" qui s’annonçait dans l'entreprise à l'horizon d’un ou deux ans.. Dur dur je pense que c’est une belle c....rie mais c’est comme cela quant les décideurs (diseurs) ne sont pas les faiseurs.. Espérons qu'ils s'en rendent compte avant.. Sinon pour Autocadavre Tu n’aurais pas plutôt un problème de synchronisation de référence de bloc, sinon avant l’apparition de la commande d’édition des blocs, il suffisait de redéfinir le bloc pour faire la même chose. A+