VDH-Bruno

Bonsoir, (gile) une fois de plus un grand merci pour ton lien à la première lecture des codes ça a l’air beaucoup plus sympa que ce à quoi j’étais laborieusement arrivé. A l’occasion je m’essayerai au self ou letn (let nommé)… :D Patrick j’ai également bien aimé l'article sur EXMATERIA, dans la foulé j’ai voulu consulté les Articles en rapport et je me suis offert une erreur: Je suppose que pour voir la suite il faut s’inscrire.. A+

Salut, Les lignes que tu as simplifiées sont tout simplement des contrôles de validité sur les arguments (var et val) de la fonction SAVE&SET_VAR. Pour économiser un progn, la fonction cond suppose un progn implicite, après le calcul du prédicat. Pour économiser l’emploie d’un setq et d’une variable, littéralement le premier appel à (getvar var) sert de prédicat, le deuxième appel extrait la valeur. Justement on utilise if au cas ou un petit malin appelerai la fonction SAVE&SET_VAR avec nil pour valeur de l’argument val Maintenant si tu es intéressé par les changements des valeurs de variables système et leur restauration, je vais paraphraser l’auteur de la routines que tu cite en t’invitant à regarder la routine ai_sysvar définie dans acad20XXdoc.lsp (donc automatiquement chargée dans chaque document). A+ Bruno (Ps : Si vraiment la routine SAVE&SET_VAR t’interesse tu en trouvera une autre variante ici toujours de (gile) mais avec cette fois d’avantage de contrôle).

Salut, Pour l’anecdote et pour rebondir à cet article qui parle je crois plus du LISP d’une façon général que d'AutoLISP.. J’apporte mon témoignage bien que je me définisse plus comme un "hobbyiste" du Lisp, que comme un vrai Lispeur. En m’intéressant au Lisp (comme d’écrit dans l’article) j’ai eu la satisfaction de sortir d’une grande léthargie intellectuelle (sur un plan personnel cela fut très gratifiant). Bien qu’actuellement (et contrairement à mes débuts) je ne dégage plus le nombre d’heures suffisante pour passer à la vitesse supérieur, le Lisp a su susciter suffisamment d’intérêt à mes yeux pour qu’il devienne le but à atteindre alors qu’initialement cela devrai être un moyen d’augmenter ma productivité sur AutoCAD (je ne m’en plains pas). Le seul inconvénient à "trop" s’intéresser, c’est d’aller par curiosité voir ce qu’il ce fait dans d’autres implémentations Lisp. Et la j’avoue que l’absence de certains concepts dans AutoLISP comme par exemples: Les P-LIST ou Listes de propriétés attachées aux atomes Les MACRO fonctions La fonction LET La possibilité de créer des fonctions à nombre quelconque d’argument (ex: append) La possibilité de créer des fonctions à arguments optionnelles (ex: ssget) Crée une certaine frustration (lorsque l’on entrevoie l’intérêt de tel ou tel concept), car même si certains sembles gadget et qu’il est possible de palier à leurs absences, leurs existences en AutoLISP amélioreraient fortement l’élégance, la concision et le plaisir à l’écriture de certains codes. Cette état provient certainement du fait que la version LISP implémenté dans AutoCAD date des années 80, alors que depuis le LISP à continué d’évoluer.. Et l’intégration de l’automation ActiveX des années 2000 avec VLISP est plus une extension de langage, qu’une réelle évolution dans les concepts de bases de l'AutoLISP. Voilà à chaud les deux ou trois pensées que m’ont évoqué la lecture de ce sujet. A+ (Ps : Sur un plan personnel, vous aurez compris que je ne regrette pas mon temps investie dans le LISP)

Bonjour Didier Ce que Patrick_35 suggère c’est de t’inspirer des Lisp de (gile) dans la rubrique routines lisp: A+ (Désolé j'ai pas fait de lien..)

Bonjour, Oui très bien ;) Pareil pour moi sur une version antérieur à 2012 comment je me l’expliquais, l’accrochage perpendiculaire différé semble contrarié par le fait que les commandes de cotation garde en mémoire le dernier point cliqué pour les commandes _dimbaseline et _dimcontinue (en espérant qu’à l’occasion de quelques testes tu retombe sur mes conclusions), visiblement 2012 résoud le problème à moins que Bred n'est pas testé sur la création du 1er point de cotation... Normal comme pour les commandes : _circle, _spline ect.. Hé oui une polyligne peut être également un objet curviligne ceci explique sans doute cela. A+

Bonsoir Micka, Je n’avais pas percuté que tu souhaitais effectué un décompte par type de blocs, deux approches possibles : La première en reprenant l’idée évoqué par fredbross , ce qui pourrait ce coder comme ceci : ;; CompteBloc ;; Retourne une liste de paire pointées ((Bloc1 . Nbr1) (Bloc2 . Nbr2) ...) ;; ;; Arguments ;; Pt1 : 1er coin de la fenête de sélection ;; Pt2 : 2ème coin de la fenête de sélection ;; LstBloc : Une liste des noms de blocs à comptabiliser (defun CompteBloc (Pt1 Pt2 LstBloc) (mapcar '(lambda (x / ss) (cons x (if (setq ss (ssget "_W" Pt1 Pt2 (list '(0 . "INSERT") (cons 2 x)))) (sslength ss) 0 ) ) ) LstBloc ) ) Pour tester par exemple sur une fenêtre sélectionnant 1 bloc nommé TOTO1, 3 blocs nommé TOTO2 et 5 blocs nommé TOTO3 (CompteBloc (setq pt (getpoint "\nSpécifiez le premier coin: ")) (getcorner pt "Spécifiez le coin opposé: ") '("TOTO1" "TOTO2" "TOTO3") ) La fonction retourne (("TOTO1" . 1) ("TOTO2" . 3) ("TOTO3" . 5)) La seconde méthode consisterait à ne faire qu’une seule sélection (pour éviter de devoir filtrer plusieurs fois la base de donné) comme expliqué précédemment, puis à parcourir la sélection avec la fonction ssname afin de comptabiliser les différents types de blocs composant la sélection. Cordialement, Edite du 13/09: Modifié le code en exemple pour tenir compte des sélections vides

Re, Non ça c’était plus la proposition fredbross, personnellement j’avais plutôt suggéré de les regrouper dans le code de groupe 2 pour n’avoir qu’un seul jeu de sélection a traiter. (ssget '((0 . "INSERT") (2 . "TOTO1,TOTO2,TOTO3"))) Cas de 3 blocs respectivement nommé TOTO1, TOTO2 et TOTO3 A+ Bruno

Bonjour -=micka=- Je vais essayer de te faire une réponse le plus détaillé possible (hélas en temps limité) et espérant compléter les réponses précédentes, sans ajouter de confusion ( et dire trop d’ânerie). Pour faire une sélection, d’une façon général c’est la fonction ( ssget [sel-method] [pt1 [pt2]] [pt-list] [filter-list]). La fonction (ssget) sans argument permet les modes de sélection suivant (A tester sur la ligne de commande) : Pour forcer un mode de sélection, il suffit de le spécifier en argument de la fonction [sel-method] [pt1 [pt2]], exemple pour une fenêtre de sélection : (ssget "_W" (setq pt (getpoint "\nSpécifiez le premier coin: ")) (getcorner pt "Spécifiez le coin opposé: ") ) Pour filtrer un type spécifique d’entité, une fois de plus il suffit de spécifier en argument de la fonction ssget une liste de filtre [filter-list] basé sur la nomenclature des codes DXF. Exemple pour sélectionner une(ou plusieurs) référence du bloc (code 0) nommé TOTO1 (code 2). (ssget '((0 . "INSERT") (2 . "TOTO1"))) Exemple pour sélectionner un ensemble de blocs (code 0) nommés TOTO1, TOTO2, TOTO3 (code 2). (ssget '((0 . "INSERT") (2 . "TOTO1,TOTO2,TOTO3"))) Ou (ssget '((0 . "INSERT") (2 . "TOTO*"))) (Notes : Dans la construction du code 2 toutes les syntaxes admises par la fonction wcmatch sont supportées. Par convention j’ai spécifié le code 0, même si dans ce cas il peut être omis. Le mode de sélection et la liste de filtre de sélection peuvent être combinés, si la liste de filtre est composée de variables ces dernières ne doivent pas être quoté ( '), exemples : (setq Nom-Blk "TOTO1,TOTO2,TOTO3") (ssget "_W" (setq pt (getpoint "\nSpécifiez le premier coin: ")) (getcorner pt "Spécifiez le coin opposé: ") (list '(0 . "INSERT") (cons 2 Nom-Blk)) ) Personnellement si les coordonnées de la sélection ne sont pas spécifié par programmation, je préfère ne pas préciser le mode de sélection car même si cela demande un clic de plus (celui de la validation de la sélection), cela laisse la possibilité d’ajout/suppression d’élément dans la constitution du jeu de sélection. La fonction ssget retourne un jeu de sélection référençant les entités sélectionnées ou nil (absence de sélection valide), _$ (ssget) $ (type (ssget)) PICKSET La fonction sslength renvoie un entier contenant le nombre d'objets (entités) dans un jeu de sélection. Exemple d’une fonction qui retournerait le nombre de bloc TOTO1, TOTO2, TOTO3 sélectionnés : (if (setq jss (ssget '((0 . "INSERT") (2 . "TOTO1,TOTO2,TOTO3")))) (sslength jss) 0 ) Pour cette dernière demande j’espère que quelqu’un d’autre pourra compléter, sinon j’essayerai de le faire ultérieurement, à l’occasion de plus de disponibilité… A+ Bruno

Bonjour, Oui j’ai déjà lu ce genre de propos notamment celui-ci http:// http://forums.augi.com/showthread.php?p=1138397#post1138397 avec un traducteur automatique, d’ailleurs je ne sais qu’en penser, notamment sur une possible (et réelle) évolution du VLisp, qu’imposerai les problèmes de compatibilité avec AutoCAD pour Mac. Même si je n’utilise pas Mac un avis éclairé m’intéresserait.. A+ (Ps : Depuis que j’ai modestement regardé d’autres versions Lisp, il y a bien 2 ou 3 fonctionnalités que je souhaiterai retrouver dans AutoLisp, peut être serait-ce l’occasion?)

Bonsoir, Dans l’aide DXF et en français: http:// http://docs.autodesk.com/ACD/2011/FRA/filesDXF/WS1a9193826455f5ff18cb41610ec0a2e719-7a04.htm Si tu n’es pas familier des codes dxf , cela veut dire que dans ta sélection tu as filtré les références de bloc (Cons 0 "INSERT"), ayant pour nom NGFX (Cons 2 bn), et ayant un ou plusieurs attributs (Cons 66 1). Pour simplifier on peut directement filtrer une référence de bloc avec son nom. (ssget "_X" '((2 . "NGFX"))) A+

Bonsoir, C’est une méthode parmi d’autres ( d’ailleurs didier l’avait donné avant), celle que tu envisageais au départ me semblant encore un peu ardu pour un début. Néanmoins je te conseil de ne pas faire l’impasse sur les précieux conseils de (gile) car si tu ne veux pas macroter éternellement avec command, il te faudra bien en passer par un peu de théorie Lispienne. A+ (Ps : Perso j’utilise plutôt les gabarits et les palettes d’outils pour ce type de besoin).

Bonjour, Au contraire cela t’avance énormément c’est même fondamental de comprendre comment fonctionne l’évaluation d’une fonction Lisp, personnellement c’est ce type d’explication qui m’a permis de décoller dans ma compréhension du Lisp, bien plus que l’emploie de telle ou telle fonction plus ou moins sophistiqué.. Pour en revenir à ton problème lorsque l’on débute la règle doit être de faire simple pour aboutir et comprendre. Sais-tu que si tu insères ton dessin gabaritcote.dwg dans ton dessin courant tu vas insérer également les styles de cotes qu’il contient. Donc si tu fais : (command "_insert" "L:\\PLECHE Damien PROJET FONDATION\\gabaritcote.dwg" '(0.0 0.0) "" "" "" ) Cela devrait également bien marché (à la condition que ton fichier ne contienne que des définitions de style de cote). Sinon pour une remarque d’ordre plus général, une bonne utilisation des fichiers gabarit (dwt) permet de faire gagner beaucoup de lignes de code. A+ ------------------------------------------------------------- Edit Oupss, désolé pour l’écho je n’avais pas réactualisé la page et je n’avais pas vu les réponses précédentes. [Edité le 23/8/2011 par VDH-Bruno]

Re, C’est le principal, c’est bien :) . En reprenant le cheminement proposé par (gile) tu aurais également pu y arriver comme cela avec GetAttribs: (defun c:NGF () (atof (cdar (GetAttribs (ssname (ssget "_X" '((2 . "NGFX"))) 0)))) ) Sinon je profite de l’occasion pour te conseiller d’archiver la réponse n°16 de (gile), cela te fera un excellent support sur les blocs. Je suis admiratif de la qualité et de la richesse de son intervention. Bon courage pour la suite A+ (Ps : Au passage (gile) si tu me lis je te remercie pour l’article sur les vecteurs déposé sur AcadLabs) (Ps bis : Et merci à Didier d’être l’initiateur d’AcadLabs (site que je découvre), pour l’instant j’exploite ses ressources en espérant pouvoir l’enrichir un jour..).

Bonjour ASTERIXII, Le problème posé, n’est pas vraiment un souci de programmation mais plutôt un problème d’inconnue en trop ( ou d’une donnée manquante), explications : Ce que je connais : Ce que je cherche : Comment je procède : Bien tenté mais hélas ça ne suffit pas. Effectivement il connait le nom de la référence de bloc (NGFX), et dans le cas ou j’ai un seul bloc NGFX insérer dans mon dessin je peux me servir de cette donnée pour sélectionner mon bloc et extraire la valeur de l’attribut NGFZ. Mais dans le cas ou j’ai plusieurs référence du bloc NGFX insérer dans mon dessin comment faire, comment cibler la valeur que je veux extraire, au mieux si il y a 5 références du bloc NGFX je peux les sélectionner et extraire les valeurs de leurs attributs respectifs soit 5 valeurs sans savoir laquelle je recherche en particulier. Voilà ou on bloque pour pouvoir t’aider par la suite.. A+

Bonjour, Merci pour le partage, c’est en effet une bonne source d’inspiration. Au passage quelqu’un connaitrait il un descriptif assez complet sur la syntaxe constituant les champs.. (Et les textes multi-lignes). Ou une méthode autre que l’expérimentation et le tâtonnement. A+

Bonjour, Si ton bloc et bien le dernier élément insérer dans ton dessin, l’option de commande d suffit, que vient faire bloc1 dans ta macro ??? A+

Bonjour à tous, Bien que je sois persuadé qu’avec : bonuscad a donné la plus simple et la meilleure formulation. Néanmoins l’exercice m’a tout de même inspiré, alors j’y vais également de ma petite variante qui répond aux conditions suivante : Sortie de boucle - Echappe (prévoir tout de même la gestion d’erreur) - Barre d’espacement ou Entrée - Saisie clavier avec Q ou Quitter (ou Clic BD) La fonction boucle pour - Une saisie arbitraire au clavier - Un clic sur une zone vide du dessin ou une entité non valide (autre qu’un bloc) - Un bloc cliqué avec le curseur en affichant le non d’entité principal Le code : ((lambda (/ pt ss) ;; Apparence curseur: pointage -> sélection (type R12) (ai_sysvar (list (cons "aperture" (getvar "pickbox")) '("autosnap" . 0) '("osmode" . 512) ) ) (setq pt T) (while (not (or (= pt "Quitter") (null pt))) (initget 128 "Quitter") (setq pt (getpoint "\nChoix d'un objet ou [Quitter]: ")) (if (listp pt) (if (setq ss (ssget pt '((0 . "INSERT")))) ;; affiche le nom d'entité (print (ssname ss 0)) ) ) ) ;; resitue aux variables leurs valeurs (ai_sysvar nil) ) ) [Edité le 11/8/2011 par VDH-Bruno]

Bonjour, Oui comme évoqué ci-dessus, j’ai effectivement commencé à regarder quelque chose dans ce sens, travaux que j’ai un peu délaissé, au profit d’autres. Il faudrait néanmoins que je retrouve la motivation de mener cette routine à terme même si je suis arrivé à la conclusion qu’elle ne pourra couvrir tous les cas.. Et ce en partie pour les raisons précédemment (et brillamment) exposé par Tramber A+

Bonjour, tu parle de: (setvar "ATTREQ" 1) (setvar "ATTDIA" 0) (setvar "DIMZIN" 1) Oui bien c’est de celles-ci qu’il s’agit, et d’une manière général de toute celles que tu es amené à modifier avec la fonction setvar. Avec la fonction getvar tu interroge et mémorise l’état de ta variable système avant de la modifier avec setvar, puis en sortie de programme tu restitue son état initial à ta variable système . Si tu relis un de tes précédents messages tu verras qu’ici j’avais déjà évoqué cette fonction. Sinon si tu veux un exemple concret sur l’utilisation de getvar tu peux éventuellement consulter ce message, tu y trouveras également en fin de post une introduction à la gestion d’erreurs. A+

Bonsoir, C’est surtout le fait que les points soient alignés (2 ou plus) que j’ai voulu souligner, ainsi que la présence d’un bit 32 (bit non documenté comme tu l’avais remarqué). Par exemple si je reprends le cas d’une spline rectiligne ( définie par 3 points alignés), si je l’interroge de la façon suivante : (entget (car (entsel))) J’obtiend : Le code 70 vaut 56 (soit 8+16+32) pour s’en convaincre il me suffit d’interroger la spline de la façon suivante : Les infos renvoyées par la commande _list (à la ligne propriété) me confirme bien qu’il y a bien un bit 8 ( plan) normal les points sont alignées donc ils appartiennent au même plan, par contre il n’y a pas de bit 2 ( Non périodique) n’y de bit 4 ( Non rationnelle), de plus la spline n’étant pas close (ne pouvant pas l’être car linaire bit 16) il n’y a pas non plus de bit 1. Il nous reste donc bien un bit 32 non documenté pour arrivé à 56, si cela peut rassurer je n’ai à ce jour jamais réussie à me démontrer la présence d’autres bits. Concernant le bit 16 (linéaire), je suis arrivé à la conclusion qu’il trouvait sa justification dans le fait qu’il n’est pas possible de fermer la spline via la fenêtre de propriété , à bien y réfléchir c’est tout à fait normal car pour ce faire il faudrait que la spline face un angle de PI sur son dernier sommet ( rappel : la spline est une courbe). A la relecture de mon message précédent je me suis aperçu que mes doigts avaient fourchés: Il fallait lire filtre à la place de sélection, personnellement pour ta sélection j’avais plus vu quelque chose comme ça : (ssget "_+.:E:S" (list (cons -4 " (cons -4 " (cons 0 "*POLYLINE") (cons -4 " (cons -4 "&") (cons 70 112) (cons -4 "NOT>") (cons -4 "AND>") (cons -4 " (cons 0 "SPLINE,LINE,ARC,CIRCLE,ELLIPSE") (cons -4 "AND>") (cons -4 "OR>") (cons 67 (if (eq (getvar "CVPORT") 2) 0 1)) (cons 410 (if (eq (getvar "CVPORT") 2) "Model" (getvar "CTAB"))) ) ) C'est du pareil au même, plus une histoire de gout qu’autre chose… ;) A+

Bonsoir bonuscad, Je vais pas t’être d’un grand secours car les splines ne sont pas des entitées que j’ai l’habitude de côtoyer dans mon secteur d’activité et je vais certainement répondre à côté.. J’ai néanmoins déjà pu constater ce que tu décris sur la somme des bits dépassant la valeur 31 (somme des bits documentés). Une astuce qui t’aidera peut être a trouver des éléments de réponses (les bits non documenté) est de comparer la valeur du code 70 avec la description des propriétés retourné par la commande _list d’AutoCAD A l’époque où je m’y suis intéressé, j'étais arrivé à la conclusion (peut être je me trompe) que le bit 16 correspond à une spline rectiligne, sa caractéristique principale étant de ne pouvoir être fermé (à tester avec la fenêtre de propriété) , exemple : Cas d'une spline rectiligne (ne peut être clos) ((-1 . ) (0 . "SPLINE") (330 . d'entité: 7ee5acf8>) (5 . "232") (100 . "AcDbEntity") (67 . 0) (410 . "Model") (8 . "0") (62 . 1) (100 . "AcDbSpline") (210 0.0 0.0 1.0) (70 . 56) (71 . 3) (72 . 10) (73 . 6) (74 . 4) (42 . 1.0e-010) (43 . 1.0e-010) (44 . 1.0e-010) (40 . 0.0) (40 . 0.0) (40 . 0.0) (40 . 0.0) (40 . 454.114) (40 . 1266.18) (40 . 1634.81) (40 . 1634.81) (40 . 1634.81) (40 . 1634.81) (10 1631.47 3653.65 0.0) (10 1782.84 3653.65 0.0) (10 2204.9 3653.65 0.0) (10 2749.83 3653.65 0.0) (10 3143.4 3653.65 0.0) (10 3266.28 3653.65 0.0) (11 1631.47 3653.65 0.0) (11 2085.58 3653.65 0.0) (11 2897.64 3653.65 0.0) (11 3266.28 3653.65 0.0)) La même en lui déplaçant un sommet (peut être clos par la suite) ((-1 . ) (0 . "SPLINE") (330 . d'entité: 7ee5acf8>) (5 . "237") (100 . "AcDbEntity") (67 . 0) (410 . "Model") (8 . "0") (62 . 1) (100 . "AcDbSpline") (210 0.0 0.0 1.0) (70 . 40) (71 . 3) (72 . 10) (73 . 6) (74 . 4) (42 . 1.0e-010) (43 . 1.0e-010) (44 . 1.0e-010) (40 . 0.0) (40 . 0.0) (40 . 0.0) (40 . 0.0) (40 . 592.942) (40 . 1346.25) (40 . 1714.89) (40 . 1714.89) (40 . 1714.89) (40 . 1714.89) (10 1599.17 3965.63 0.0) (10 1781.1 4078.95 0.0) (10 2194.18 4336.23 0.0) (10 2733.69 3921.27 0.0) (10 3110.25 3954.66 0.0) (10 3233.98 3965.63 0.0) (11 1599.17 3965.63 0.0) (11 2147.0 4192.48 0.0) (11 2865.35 3965.63 0.0) (11 3233.98 3965.63 0.0)) Pourquoi ne pas faire 2 sélections (en 2 temps) une sur les POLYLIGNE en écartant les maillages comme tu le fais, et une autre sur les autres entitées curvilignes puis fusionner les 2 sélections en une seul, bien que ce soit la solution que tu voulais éviter.. . A+

Bonsoir, Il n’y a pas de quoi, pour la suite j’ai bien peur de ne plus être d’un grand secours car j’ai peu de temps et beaucoup de mal à comprendre tes questions (même si le ferraillage et un domaine qui ne m’est pas totalement étranger). Si ton objectif est de créer un ensemble de routines permettant d’automatiser la production de plans de ferraillage (Au vu d’une rapide recherche sur tes différents post), je ne pense pas qu’il soit nécessaire dans l’immédiat de te pencher sur les problèmes de nomenclature (c’est comme en dessin la nomenclature on l’établie toujours une fois le plan réalisé, cela évite les ratures). Je pense que tu gagneras plus à te recentrer sur l’automatisation de tes dessins (soit pas la personnalisation et/ou la programmation), car je ne suis pas sur que ce point soit complètement atteint. Par la suite tu attaqueras plus facilement les problèmes de mise en page et de nomenclature (très certainement avec une approche toute différente). Si tu me permets un petit conseil amical fixe toi des objectifs simple et clair mènent les à leurs termes, évite d’attaquer plusieurs codes en même temps (même si c’est très tentant au début) au risque de n’en terminer aucun . A+ [Edité le 21/7/2011 par VDH-Bruno]

Bonsoir, Oui effectivement j’avais tout faux, j’ai fais une confusion avec entre ton lisp et la version Metre2Cell&Field.lsp de BonusCAD qui utilise les champs et les tableaux. Et non je ne suis pas déçu sauf que les réacteurs, je les mets de côté pour quant je serai plus grand car pour l’instant je tâtonne (je débute encore) avec l’Automation ActiveX, j’essai d’assimiler (à mes heures perdus) les petits bouts de codes très formateur donné par toi et d’autres sur le forum. Merci d'avoir pris le temps de me réorienter sur des pistes plus en relation avec mes recherches du moment. A+

Merci beaucoup (gile) Ca tombe très bien, car depuis peu je commence à être curieux de codes qui mélange les tableaux, les champs et les blocs dynamiques, je vais étudier ces lignes de codes avec un réel intérêt. :) A+

Salut, Oui avec diviser ( _divide) ou avec mesurer ( _measure) ça marche également, ces 2 façons de faire font appel aux blocs c’est la leurs intérêts, si tu veux varianter encore tu peux aussi tenter avec la commande reseau ( _array). Il me semble qu’il est même possible de faire quelque chose avec une veille commande AutoCAD non documenté mais là ma mémoire me joue des tours et je n’arrive plus à retrouver la syntaxe exacte pour vérifier si AutoCAD la supporte encore.. ( une sorte d’insertion multiple). Sinon dans ton code, cette ligne ne sert à rien : (setq D2 (getint "/n donner le diamètre acier")) Et les suivantes : (command "inserer" "cercle" ptac3 1 1 0 D2 "") (command "inserer" "cercle" ptac4 1 1 0 D2 "") Seraient mieux écrite comme ceci : (command "inserer" "cercle" ptac3 1 1 0) (command "inserer" "cercle" ptac4 1 1 0) Pour t’en convaincre teste ton code en faisant varier le diamètre de tes aciers, tu verras que la variation n’est pas prise en compte. Si tu veux insérer des cercles (sous forme de bloc) symbolisant une répartition d’acier sur un axe (de façon simple et en gardant l’esprit de tes routines). Sur ton premier code - Tu craies ton bloc « cercle » avec un cercle unitaire - Tu propose à l’utilisateur d’entrer le diamètre que tu mémorise comme tu l’as réalisé dans ton deuxième code (au passage les diamètres d’aciers étant normalisés tu peux verrouiller les saisies avec la fonction initget) - Puis tu fais varier l’échelle x et y de ton bloc à l’insertion. Sur ton second code avec diviser (pour l’exercice et pour faire simple) - Tu craies autant de bloc que tu as de section d’acier normalisé (ex : cercle8 cercle10 cercle12 ect..). -Tu verrouille les saisies du type HA8 HA10 HA12 avec la fonction initget (avant la saisie du diamètre par l’utilisateur). -Puis avec un cond tu fais correspondre pour chaque saisie possible le bloc correspondant à insérer. Cordialement,