Luna

Coucou, Malheureusement nan, je n'ai pas vraiment eu le temps d'étudier le sujet. Désolée, Luna

Oki I get it ! Simplement il faut mettre le nom de tes grues entre guillemets ^^' (MDT219 Ici cela indique qu'il faut exécuter la fonction nommée (MDT219). Il te faut écrire : "MDT219" Bisous, Luna

Coucou, J'ai testé sans problème... Peux-tu m'envoyer l'erreur que tu rencontres ? Bisous, Luna

Coucou, En me basant sur les lignes de codes suivantes : ;; ---------[ DEVELOPPER PARAMS ]--------- ;; ;; This section allows the developper to change quickly the parameters used by the program based on their need ;; Each parameters can be set as constants, ignored (= nil) or develop a full question if it needs to be set ;; by the user instead. (setq dimtxt nil ; Defines the text height (nil → use DIMTXT value instead) angtxt nil ; Defines the axis angle on which the text will be aligned on (nil → 0 (East)) algtxt nil ; Defines the text alignment mode (cd. MTEXT(DXF), code 71) (nil → 5 (Middle Center)) radiusPrec nil ; Defines the precision (number of decimal) for the crane boom length (nil → 2) weightPrec nil ; Defines the precision (number of decimal) for the weight (nil → 2) maskBoxScale 1.2 ; Defines the fill box scale value for the text background mask (nil → no mask) capacities ; Defines the different capacities based on the crane model and their length '( ;; ---------[ GRUE_DIAG219 ]--------- ;; (219 (25 (20 20) (25 8.4)) (30 (20 10) (25 8.6) (30 7)) (35 (21 10) (25 8.5) (30 6.9) (35 5.8)) (40 (20 10) (25 8.4) (30 6.9) (35 5.8) (40 5)) (45 (20 10) (25 8.3) (30 6.8) (35 5.7) (40 4.9) (45 4.3)) (50 (20 10) (25 8.3) (30 6.7) (35 5.6) (40 4.7) (45 4) (50 3.5)) (55 (20 10) (25 7.9) (30 6.4) (35 5.4) (40 4.5) (45 3.9) (50 3.3) (55 2.95)) (60 (20 9.4) (25 7.3) (30 6) (35 4.6) (40 4.2) (45 3.6) (50 3.1) (55 2.6) (60 2.2)) (65 (20 8.88) (25 6.9) (30 5.6) (35 4.6) (40 3.9) (45 3.3) (50 2.85) (55 2.4) (60 1.95) (65 1.6)) ) ; End GRUE_DIAG219 params ) ) ; End of DEVELOPPER PARAMS ;; You can change the default value below if needed also (setq dimtxt (cond (dimtxt) ((getvar "DIMTXT"))) angtxt (cond (angtxt) (0)) algtxt (cond (algtxt) (5)) radiusPrec (cond (radiusPrec) (2)) weightPrec (cond (weightPrec) (2)) ) ; End default params values Pour ajouter des nouveau modèles de grues, il suffit d'ajouter une liste comme ceci : ;; ---------[ GRUE_DIAG219 ]--------- ;; (219 (25 (20 20) (25 8.4)) (30 (20 10) (25 8.6) (30 7)) (35 (21 10) (25 8.5) (30 6.9) (35 5.8)) (40 (20 10) (25 8.4) (30 6.9) (35 5.8) (40 5)) (45 (20 10) (25 8.3) (30 6.8) (35 5.7) (40 4.9) (45 4.3)) (50 (20 10) (25 8.3) (30 6.7) (35 5.6) (40 4.7) (45 4) (50 3.5)) (55 (20 10) (25 7.9) (30 6.4) (35 5.4) (40 4.5) (45 3.9) (50 3.3) (55 2.95)) (60 (20 9.4) (25 7.3) (30 6) (35 4.6) (40 4.2) (45 3.6) (50 3.1) (55 2.6) (60 2.2)) (65 (20 8.88) (25 6.9) (30 5.6) (35 4.6) (40 3.9) (45 3.3) (50 2.85) (55 2.4) (60 1.95) (65 1.6)) ) ; End GRUE_DIAG219 params Le premier élément de la liste (ici 219) sert de clé. En l'état actuel j'ai considéré que les clés étaient de type integer mais cela peut se changer "relativement" facilement (il faut cependant modifier le code également un peu plus bas, ligne 88 du fichier : (getkdh (quote (getint msg)) ;; <-- line 88 "\nVeuillez sélectionner le type de grue" (list (apply 'strcat (mapcar '(lambda (x) (strcat (vl-princ-to-string (car x)) " ")) capacities))) ": " (caar capacities) "" ;You can add any help message for this question in order to guide the users on the options ) Remplacer (getint) par (getkword), comme ceci : (getkdh (quote (getkword msg)) "\nVeuillez sélectionner le type de grue" (list (apply 'strcat (mapcar '(lambda (x) (strcat (vl-princ-to-string (car x)) " ")) capacities))) ": " (caar capacities) "" ;You can add any help message for this question in order to guide the users on the options ) Pour l'explication (getint) ne permet que la saisie de nombres entiers, tandis que (getkword) attend la saisie de mots clés (vui c'est dans le nom ^^). Comme tu souhaites utiliser des clés sous forme de chaîne de caractères (offrant plus de libertés), la fonction (getkword) est plus adaptée. Et pour ce qui est de la fonction (getkdh), c'est une fonction que j'utilise absolument partout qui me permet de construire facilement des questions utilisateurs (de son nom complet GET-Keywords/Default/Help). C'est sûrement un peu (très beaucoup) compliqué à lire comme programme donc c'est juste un petit plus dont je ne peux plus me passer quand je programme. C'est à la suite de ta clé principale de la liste 'capacities'. Mais comme tu as trouvé, je suppose que tout va bien ! L'angle et la hauteur de texte sont défini au début dans les "Paramètres développeurs". Pour le style de police, il s'agit du code DXF 7 (cf. >>ici<<), par défaut AutoCAD considère "STANDARD" si non précisé. Pour l'ajouter, c'est ici à la fin de la (list) : (list '(0 . "MTEXT") '(100 . "AcDbEntity") '(100 . "AcDbMText") (cons 10 pt0txt) (cons 40 dimtxt) (cons 50 (- angtxt (/ pi 2.))) (cons 71 algtxt) (cons 1 (strcat (rtos radius 2 radiusPrec) "m - " (rtos weight 2 weightPrec) "t")) ; ← if you need to change the text output ; ex: "25.00m - 7.90t" (cons 7 "MyWonderfulFont") ; <-- Remplacer "MyWonderfulFont" par la police souhaitée, ou bien même une variable déclarée plus haut dans les params développeurs ) Le code DXF 8 permet de définir le calque d'un objet, si pas précisé il considère le calque courant. Si jamais c'est un calque connu et toujours le même, je dirais qu'il faut faire exactement comme pour le code DXF 7. Si c'est un choix utilisateur, ma solution préférée est (ListBox) développé par (gile) (cf. >>ici<< par exemple). Sinon libre à toi. Il faut cependant checker me semble-t-il si le calque existe (à vérifier). Attention à ajouter ce code DXF 8 aux deux types d'entités crées : MTEXT et CIRCLE ! Si tu ne veux pas t'embêter, le plus simple et juste de copier/coller le contenu de chaque fichier dans 1 seul et unique fichier à la suite (par exemple tu colles tous les fichiers "Ut..." à la suite dans le fichier "GRUE.lsp"). Si je comprends bien tu insères un bloc dynamique de grue (qui n'intègre pas les courbes de charge) et le LISP a pour but de créer une nouvelle définition de bloc (si pas déjà existante) puis d'insérer une référence de ce bloc au point d'insertion du bloc grue ? Dans ce cas j'ai plusieurs questions : Pourquoi ne pas intégrer les courbes de charge directement dans le bloc (dans un calque spécifique) et ainsi il suffit uniquement de geler/dégeler le calque pour voir les courbes momentanément ? Cela permettra notamment de gérer qu'un seul et unique bloc. (Bien que je reconnais que du coup, le bloc risque d'être un peu vénère) Est-ce qu'un simple groupe peut satisfaire le besoin ? j'avais une autre question mais j'ai un trou de mémoire, sorry... Bisous, Luna

Coucou, Juste à titre d'exemple (désolée, la passion à pris le dessus ^^') j'ai retravaillé ton code dans sa globalité pour qu'il soit un peu plus poussé (sans intégrer la partie concernant les blocs) et plus facilement modifiable (les paramètres développeurs notamment, car je reconnais que pour le reste c'est peut-être plus difficile à comprendre désormais). Il s'agit du fichier GRUE.lsp (mais il est dépendant des fonctions (getkdh), (lst2str) et (str2lst) d'où leur présence également mais rien ne t'empêche de tout regrouper dans le même fichier) et le nom de la commande est GRUE. Bisous (et désolée pour le dérangement), Luna UtDac . lst2str.lsp UtDac . str2lst.lsp UtUse . getkdh.lsp GRUE.lsp

Coucou, Tu parles d'avoir les courbes de charge de plusieurs grues sous forme de commandes séparées, or je doute que le fond du code change drastiquement. Je suppose que les seules informations qui changent réellement sont celles que l'on trouve dans la variable 'capacites' ? Au vu du programme, il y a de nombreuses choses que l'on peut vraiment améliorer pour un rendu plus professionnel, mais pour cela il faudrait l'ensemble du LISP et quelques infos supplémentaires (notamment qu'entends-tu par "les courbes de charge soient crées dans un bloc" ?). Si en revanche tu souhaites effectuer ces modifications de ton côté : Il faut ajouter : (setq point (getpoint "\nSpécifier le point d'insertion : ") x (car point) y (cadr point) ) juste après la ligne (setq valeur ... et modifier les 2 lignes comme suit : ;; remplacer '(0 0) par point (command "_circle" point (rtos rayon 2 2)) ;; remplacer (list rayon 0) par (list (+ x rayon) y) afin d'ajouter les coordonnées du point d'origine au calcul des coordonnées du texte (command "_text" (list (+ x rayon) y) "1" "90" (strcat (rtos rayon 2 2) "m - " (rtos charge 2 2) "t")) Pour cela, j'aurais besoin d'un peu plus de détail et en fonction des réponses, cela changera la nature du code. Souhaite tu créer des définitions de blocs ou souhaites-tu insérer des références de blocs ? Dans le premier cas, ne serait-il pas plus simple de créer les définitions de blocs à la main (puisqu'il ne me semble pas que cela représente de nombreuses heures de travail) et cela permettrait en plus de créer des blocs dynamiques. Dans le second cas, cela suppose que les définitions de blocs existent déjà. Ou bien est-ce un programme qui se veut "intelligent" c'est-à-dire qu'il insère des références de blocs, et si la définition de bloc n'existe pas encore dans le dessin, alors il faut dans un premier temps créer cette définition de bloc pour ensuite insérer une référence de bloc ? Pour poser une question à un utilisateur (et dans ton cas je te suggère de n'autoriser que certaines valeurs), tu peux utiliser (getkword) avec la fonction (initget). Voir un exemple ci dessous (pas le plus opti) : (initget 1 "219 218 178") (setq grueNum (getkword "\nVeuillez choisir le type de grue [219/218/178] : ")) (cond ((grueNum = "218") (c:GRUE_DIAG218)) ((grueNum = "219") (c:GRUE_DIAG219)) ((grueNum = "178") (c:GRUE_DIAG178)) ) Bisous, Luna

Coucou, Cela signifie que les "textes" en question sont des attributs je pense et donc lorsque tu décomposes un bloc (via la commande DECOMPOSER), c'est la définition d'attribut qui apparaît (avec le nom de l'étiquette et non la valeur de ton attribut de référence de bloc). Pour cela, je te conseille plutôt la commande BURST des ExpressTools, cela permet de convertir les attributs en TEXT ou MTEXT lors de la décomposition d'une référence de bloc en conservant ainsi la valeur de texte. De manière générale, en CAO c'est normal de devoir prendre le temps de nettoyer et corriger les fichiers que l'on reçoit (dans la limite des contraintes client évidemment) en faisant attention tout de même de ne pas engendrer de problèmes lors de futur échanges de fichier (modification de la localisation du projet, etc...), d'où l'intérêt des XREF. Donc il est souvent nécessaire d'adapter nos méthodes de nettoyage de fichiers en fonction des dessins que l'on reçoit. Sinon, de manière bourrine il existe toujours des solutions en LISP (non testée donc j'ai peut-être fait des erreurs) : (defun c:TXTHEIGHT-ALL (/ hgt txt blc jsel i name entlist b blk) (setq hgt (cond ((getdist (strcat "\nVeuillez définir la hauteur de texte <" (getvar "DIMTXT") "> : "))) ((getvar "DIMTXT"))) jsel (ssget "_X" '((0 . "TEXT,MTEXT"))) txt 0 blc 0 ) (princ "\n...Processing the TEXT and MTEXT entities . . . ") (repeat (setq i (sslength jsel)) (setq name (ssname jsel (setq i (1- i))) entlist (entget name) ) (entmod (subst (cons 40 hgt) (assoc 40 entlist) entlist)) (setq txt (1+ txt)) ) (princ (strcat "\nUn total de " (itoa txt) " textes du dessin ont été traités (hauteur = " (rtos hgt 2 2) ")")) (setq txt 0) (princ "\n\n...Processing the BLOCK DEFINITION entities . . . ") (while (setq blk (tblnext "BLOCK" (not b))) (setq name (cdr (assoc -2 (entget blk)))) (while name (if (member (cdr (assoc 0 (setq entlist (entget name)))) '("TEXT" "MTEXT")) ;; Add "ATTRIB" to the list if needed (ATTSYNC would be necessary) (progn (entmod (subst (cons 40 hgt) (assoc 40 entlist) entlist)) (setq txt (1+ txt)) ) ) (setq name (entnext name)) ) (entupd blk) (setq blc (1+ blc) b T ) ) (princ (strcat "\nUn total de " (itoa txt) " textes présent dans les " (itoa blc) " définitions de blocs du dessin ont été traités (hauteur = " (rtos hgt 2 2) ")")) (princ) ) Bisous, Luna

Coucou, En commande, je sais qu'il existe StripMText (mais du coup cela modifie les entités or tu veux juste récupérer la valeur textuelle sans modifier l'objet). Sinon il semblerait que Lee Mac ait travaillé sur une fonction à cet effet (cependant je ne l'ai jamais utilisé donc je ne sais pas si cela correspond à ton besoin : https://www.lee-mac.com/gettruecontent.html Edit: Olivier aura été plus réactif :3 Bisous, Luna

Coucou @DessProj429, En complément des réponses de Didier et Olivier, je te suggère dans un premier temps de consulter ce post (>>ici<<) concernant le chargement d'un fichier .lsp dans AutoCAD. Car, comme le souligne si bien Olivier, avant même de parler de programmation il faut savoir comment implémenter ces programmes LISP dans AutoCAD et pouvoir les utiliser. Une fois ces différentes solutions maîtrisées (chargement ponctuel, chargement automatique, utilisation de fichiers LISP définis par AutoCAD ou des fichiers personnels, etc..), on peut alors s'attaquer aux bases de la programmation. Pour cela, de nombreux sites très bien fait peuvent t'aider à explorer le monde de la programmation AutoLISP : https://www.da-code.fr/ https://programmation.developpez.com/tutoriels/autolisp/introduction-autolisp/ Maintenant si l'on rentre un peu plus dans le vif du sujet, il n'existe jamais une seule et unique solution de programmation pour un problème bien défini. Avant même de parler d'AutoLISP (qui est un langage permettant d'écrire des programmes complexes), on peut déjà considérer des solutions beaucoup plus adaptées lorsqu'on débute en programmation AutoCAD, au même titre que les macros Excel. Pour cela, rien de bien compliqué puisqu'il suffit de réaliser la manipulation manuellement et de noter l'ensemble des commandes, options, données utilisateurs nécessaires à la suite d'instructions. Dans ton cas, il suffit de comprendre ton besoin : Tracer une polyligne Décaler la dernière polyligne crée d'une valeur rentrée par l'utilisateur Ajouter un sommet depuis le dernier sommet de la polyligne n°1 vers le dernier sommet de la polyligne n°2 Joindre les 2 polylignes Clore la polyligne L'ensemble de ces manipulations font appel à des commandes et des entrées utilisateur, donc cela peut être traduit par une suite d'instruction qui fait appel aux commandes. On appelle cela des macros, comme par exemple la macro donnée par Olivier qui répond aux points 3 et 4 (si je ne dis pas de bêtises). Évidemment, plus on progresse en programmation et plus on va chercher à optimiser notre programme pour améliorer sa performance, étendre son principe de fonctionnement, gestion des erreurs, etc... C'est d'ailleurs pour cela qu'il faut prendre les problèmes comme un ensemble de sous-problèmes, plus simple à traiter individuellement puis de les mettre bout à bout. Viendra ensuite l'optimisation de la programmation (par exemple, commencer par écrire une macro qui n'est rien d'autre que la suite d'instructions que tu effectues manuellement, puis ensuite d'essayer de traduire cela en AutoLISP simple, avec des (command) et ensuite on pourra encore améliorer avec des (entget), (entmake), ...), mais chaque choses en son temps. Si je comprends ta démarche d'utilisateur, tu désires apprendre/comprendre le code que tu comptes utiliser et donc pour cela, il ne faut pas partir d'une programmation complexe dès le début. Je pense donc en effet que la meilleure démarche pour ce genre de demande est de commencer par écrire la suite d'instructions que tu fais en ligne de commande, voir quelles options peuvent être directement renseignées (par exemple par le biais de variables système ou des constantes) et lesquelles requiert une intervention utilisateur. Cela permettra donc de connaître et d'identifier rapidement l'ensemble des informations requises pour faire fonctionner le programme et parmi ces informations, lesquelles sont déjà accessibles et lesquelles ne le sont pas. Ensuite lorsque tu voudras optimiser le programme tu verras que tu pourras supprimer certaines interventions utilisateur. Bref, donc pour la partie "joindre" 2 polylignes, tu as déjà la macro proposée par Olivier mais si on s'amuse à la décrypter on a : ^C^C correspond à un double Echap (permet de s'assurer qu'aucun programme n'est en cours d'utilisation à l'exécution de notre macro), cf. https://help.autodesk.com/view/OARXMAC/2024/FRA/?guid=GUID-D991386C-FBAA-4094-9FCB-AADD98ACD3EF _PEDIT; Lancement de la commande PEDIT en langue internationale grâce au caractère "_" (la commande _PEDIT est ici nommée PEDIT aussi bien international qu'en FR, mais par exemple la commande COPIER en FR est _COPY en international). Cela est une "convention" en programmation afin de s'assurer que quelque soit la langue locale de l'AutoCAD utilisant notre programme, le résultat soit identique (pas d'erreur car la commander COPIER par exemple n'est pas reconnue sur un AutoCAD anglophone). Le caractère ";" est équivalent à une validation (ENTER). _M; correspond à l'option _Multiple de la commande _PEDIT, afin de sélectionner plusieurs entités, cf. https://help.autodesk.com/view/ACD/2024/ENU/?guid=GUID-0C422AA9-23DD-4650-AD66-68E9D7989E3F \\; correspond à une pause, indiquant ici que l'utilisateur doit répondre à la question de la commande (en l'occurrence ici il s'agit de la sélection des 2 polylignes que l'on souhaite joindre). Je tiens tout de même signaler que cela peut poser un problème syntaxique, car comme le souligne Olivier, il n'y a pas de contrôle. Par exemple l'option _Multiple peut poser une question supplémentaire si certains objets sélectionnés ne sont pas des polylignes (en effet, _PEDIT va alors demander si Oui ou Non on désire convertir les objets en polylignes, à condition évidemment que la variable PEDITACCEPT est à 0). _J; correspond à l'option _Join de la commande _PEDIT. ... Bref tu vois le principe. En conclusion, décortiquer un problème en sous-problèmes simples ; commencer par des instructions basiques et compréhensibles ; améliorer au fur et à mesure que tu maîtrises les bases. Si tu as des questions, n'hésite pas ! Comme tu peux le voir tu trouveras toujours des personnes qui accepteront de t'aider, sous réserve que la demande est claire, concise et que tu précises le type d'aide que tu souhaites (pistes de recherche, solution toute faite et "parfaite", documentation, etc...). Bisous, Luna

Coucou, Je pense que ce dont suggérait @didier c'est que les info-bulles proposées par AutoCAD sont parfois pleines de ressources ! La plupart du temps lorsqu'une case à cocher ou à remplir fait référence à une variable système, AutoCAD affiche des info-bulles (il suffit de laisser sa souris au-dessus de la case) pour expliquer le rôle de cette option et également la référence par rapport à la variable système associée. Ce qui est très pratique lorsqu'on sait où modifier l'option manuellement dans une boîte de dialogue et que l'on cherche à faire la même opération mais en programmation 🙂 Bisous, Luna

Coucou @nen, En complément de la réponse de @(gile), qui fait alors référence à une commande, je te propose la fonction de LeeMac à cet effet : https://www.lee-mac.com/boundingbox.html Cependant, cela ne permet d'obtenir que le plus petit rectangle englobant une unique entité selon le SCG. Je me souviens avoir développé une fonction en m'appuyant sur le travail de LeeMac, (gile) et Douglas C. Broad. La fonction (UCSssBoundingBox) permet, comme son nom l'indique de renvoyer les coordonnées bas/gauche et haut/droit du plus petit rectangle englobant un jeu de sélection passé en argument en considérant le SCU courant pour chaque objet. Pour cela elle s'appuie sur les fonctions (WCS2UCSMatrix) et (UCS2WCSMatrix) de Douglas, et le reste de la fonction n'est qu'une piètre adaptation des codes de LeeMac et (gile). Tu trouveras également en PJ la fonction (LM:ssBoundingBox) développée par LeeMac qui fait le même travail mais sans la conversion vers le SCU des coordonnées d'objets. Dans les deux cas, les coordonnées du rectangles sont calculées selon les axes SCG. Je m'autorise également une petite remarque concernant ton filtre de sélection (setq ss (ssget '((0 . "INSERT")))) ; Sélection des blocs En effet tu marques dans ton message que tu ne traites que les blocs avec attributs : Pour cela, au lieu de sélectionner uniquement l'ensemble des blocs (0 . "INSERT"), tu ajoutes un filtre supplémentaire pour justement ne conserver que les blocs avec attributs (code DXF 66) : (setq ss (ssget '((0 . "INSERT") (66 . 1)))) ; Sélection des blocs Et si jamais tu souhaites traiter des blocs ayant une dénomination particulière, alors il suffit de rajouter un code DXF 2 (ATTENTION aux blocs dynamiques cependant !). Je vous laisse y réfléchir pour intégrer tout chat comme vous le souhaitez et si vous avez encore besoin d'aide/conseils surtout n'hésitez pas :3 Bisous, Luna DtSel . UCSssBoundingBox.lsp DtSel . LM.ssBoundingBox.lsp VlMet . UCS2WCSMatrix.lsp VlMet . WCS2UCSMatrix.lsp

Coucou, En programmation, la clé c'est de toujours se demander "quelles sont les manipulations que je fais à la main ?" pour ensuite les décortiquer et les traduire sous forme de langage informatique. En l'occurrence ici si je comprends bien, on peut décortiquer ainsi : 1. Création d'une polyligne ayant 4 sommets 2. Sélection de la polyligne dernièrement crée 3. Création d'une hachure à partir du contour de la polyligne sélectionnée Ensuite en langage AutoLISP, pour l'étape 1, si je comprends bien c'est déjà fait. Pour l'étape 2, tu peux utiliser la fonction (entlast) et pour l'étape 3, je te conseille de passer par la commande en ligne de commande (donc ajouter un "-" devant le nom de la commande) pour crée ta hachure. Si jamais tu as besoin de plus d'aide, n'hésite pas. Bisous, Luna

Coucou, Petite question juste pour être sûre : tu cherches à remplacer les propriétés (calques, couleur, type de ligne) pour les objets devant composer la nouvelle définition de bloc, ou bien pour la nouvelle référence de bloc ? Car si c'est bien les sous-objets, je pense qu'il est alors préférable de faire ces modifications en amont afin de lancer la commande BLOC à la toute fin. Le problème des boîtes de dialogue dans une macro ou autre, c'est qu'une fois qu'elle est ouverte, le programme n'a plus la main sur quoi que ce soit et donc rien ne se fait. C'est pour cela que les commandes utilisant des boîtes de dialogue ont toujours une version homonyme qui utilisent uniquement la ligne de commande (il suffit d'ajouter un "-" devant le nom de la commande). Je ne maîtrise pas les macros mais peut-être que dans ce genre de cas, afin de permettre à la macro de terminer son exécution, il utilise les versions sans boîtes de dialogue si jamais des actions sont nécessaires après l'exécution de la boîte de dialogue. Bisous, Luna

Coucou @VDH-Bruno, Ahah vui, c'est sûr que se pencher sur les programmes de cette nature écrit par les grands noms de la programmation LISP, chat peut prendre un peu de temps. J'avais moi aussi quelques programmes/idées qu'il me faudrait étudier car le sujet est remarquablement intéressant. Mais pour l'instant je vais surtout essayer de me concentrer sur l'apprentissage d'un nouveau langage 🙂 Bon courage pour tes recherches en tout cas ! Bisous, Luna

Coucou, Commande PURGER et Trouver élém. non purgeables : https://help.autodesk.com/view/ACD/2024/FRA/?guid=GUID-C6B62BBD-C363-4DC7-AF43-036A7B287473 Il te suffit ensuite de sélectionner les styles de texte et regarder où ils sont référencés 🙂 (enfin c'est une des solutions, si chat se trouve ils font autrement ^^') Bisous, Luna

Attention, tu risques de te faire taper sur les doigts 😉 Bisous, Luna

Merci @VDH-Bruno, Etonnament je me suis douté qu'en passant par des champs générés par programmation, c'était possible (la commande CHAMPS ne montre pas toutes l'étendue des possibilité en terme de création de champs dynamiques, car certaines propriété n'apparaissent pas dans la liste mais fonctionnent pourtant si utilisé via programmation). Cependant je n'ai pas pris le temps d'étudier davantage cette piste de recherche donc je te remercie pour tes explications et l'exemple ! 🙂 Il faudrait vraiment que j'apprivoise un peu plus la création de champs dynamiques mais le manque de temps restreint un peu les recherches ^^ Merci pour tes lumières en tout cas, je regarderais tout chat en détails à tête reposée :3 Bisous, Luna

Coucou @didier, Je remarque que je ne suis clairement pas une 'morning-person' (même à 11h ^^).. J'aime beaucoup l'utilisation des propriétés Visual LISP qui simplifie grandement la récupération des valeurs (préfixe et suffixe notamment ^^) J'avoue que je me suis grandement compliqué la vie ! Chapeau l'artiste 🙂 Petite remarque malgré tout, le texte de remplacement peut dans certains cas remplacer complètement la cotation (donc c'est un simple texte) et sinon, le "<>" peut se situer aussi bien à la fin, au début ou en milieu de chaîne de remplacement 😉 Bisous, Luna

Coucou, Bon, malgré la participation de @didier voici ma proposition : (defun c:COPYCOT (/ jsel name fuzz entlist rep dim xdt pos pre suf txt) (and (setq jsel (ssget "_+.:E:S" '((0 . "DIMENSION")))) (setq name (ssname jsel 0)) (setq fuzz (vla-get-PrimaryUnitsPrecision (vlax-ename->vla-object name))) (setq entlist (entget name '("ACAD"))) (setq rep (cdr (assoc 1 entlist))) (setq dim (cdr (assoc 42 entlist))) (setq xdt (cdadr (assoc -3 entlist))) (setq xdt (cdr (assoc 1000 (cdr xdt)))) (setq pos (vl-string-search "<>" xdt)) (setq pre (cond ((= pos 0) "") ((substr xdt 1 pos)))) (setq suf (cond ((= (setq pos (+ pos 2)) (strlen xdt)) "") ((substr xdt (1+ pos))))) (setq txt (strcat pre (rtos dim 2 fuzz) suf)) (setq pos (vl-string-search "<>" rep)) (setq txt (cond ( (= 2 (strlen rep)) txt) ( (= pos 0) (strcat txt (substr rep 2)) ) ( (= (+ pos 2) (strlen rep)) (strcat (substr rep 1 pos) txt) ) ( (strcat (substr rep 1 pos) txt (substr rep (+ pos 3)))) ) ) (setq jsel (ssget "_+.:E:S" '((0 . "MTEXT,TEXT")))) (setq name (ssname jsel 0)) (entmod (subst (cons 1 txt) (assoc 1 (entget name)) (entget name))) (princ "\nLe texte de cotation a été copié avec succès") ) (princ) ) Bisous, Luna

Coucou, S'il s'agit de côte NGF alors il ne s'agit en théorie pas de cotations AutoCAD. Pour les cotations de niveaux (avec cotes NGF), je conseille vivement de passer par des blocs et attributs. Cela permet plus de flexibilité et notamment de gérer les données via des champs dynamiques. Par exemple, placer le plan en respectant une élévation NGF, ainsi tu peux récupérer les coordonnées Z du bloc pour afficher les cotes NGF, ou bien de placer une côte de référence et faire un champ pour calculer les écarts de position (Y par exemple si jamais tu dessines dans le plan XY) et déterminer une cotation NGF. Car en théorie, la cotation en jaune 160,36m sur ton .dwg d'exemple n'est jamais représentée dans le plan 🙂 Bisous, Luna

Coucou, Il ne me semble pas possible de faire d'addition/soustraction pour les cotations. En revanche une solution alternative serait d'afficher la longueur de la cotation et de lui ajouter un suffixe " +7,00m" par exemple 🙂 Par pure curiosité, dans quelle mesure est-il nécessaire d'ajouter une valeur fixe à une cotation. Car pour moi une cotation permet d'afficher les dimensions d'un élément linéaire, donc s'il faut ajouter 7m à la mesure, c'est que l'élément dessiné ne fait pas les bonnes dimensions, nan ? Bisous, Luna

Coucou, A première vue j'aurais tendance à dire qu'il s'agit de l'accrochage à la grille (F9) mais comme tu précises je pense que le mieux serait déposer le fichier problématique pour regarder spécifiquement d'où peut venir le problème. Il y a également la commande MODIFVAR (que je ne connaissais pas, merci yusukens82) si jamais tu veux comparer 2 dessins pour trouver les variables qui diffèrent. Pour cela je dirais que le mieux est de lister toutes les variables systèmes dans un fichier .txt de 2 dessins différents (dont ton .dwg qui pose problème) puis de comparer ces 2 fichiers .txt (Visual Studio Code a cette fonctionnalité mais je suppose qu'il existe d'autres méthodes). Bisous, Luna

Coucou, Pour le coup, j'ai un peu la même vision que toi sur ce point. Une IA est peut-être en mesure de pondre des programmes LISP à peu près corrects (tout dépend de la personne qui a fait la demande à l'IA et de la pertinence des questions ayant servies à l'élaboration du code) mais cela répondra uniquement à un besoin à un instant T. Le programme ne sera, je pense, jamais réfléchi de manière à faciliter les évolutions futures en ajoutant/regroupant un ensemble de paramètres permettant d'adapter le programme aux différentes pratiques et/ou utilisateurs. C'est d'ailleurs pour cette raison que je considère que l'IA peut éventuellement aider les développeurs en manque d'imagination et de logique, mais l'IA (à ce jour) ne pourra jamais à elle seule avoir un rendu professionnel et fonctionnel dans le temps. Il y a beaucoup de travail à fournir en amont ET en aval du résultat fourni par l'IA et j'ai peur que la majorité des utilisateurs de l'IA aujourd'hui n'ont pas notion du boulot nécessaire pour retravailler les programmes proposés par l'IA. La plupart des utilisateurs sont des novices de la programmation qui font confiance à 100% dans l'efficacité de l'IA. Ce qui me terrifie d'ailleurs c'est qu'avec ce nouveau genre d'utilisateurs, les demandes du genre "ChatGPT m'a fourni ce programme mais il ne marche pas et je ne sais pas pourquoi, vous pouvez m'aider" seront de plus en plus nombreuses et les rares bénévoles sur les forums vont bientôt uniquement faire du SAV des erreurs de l'IA. En clair, l'humain va finir par travailler pour l'IA et non l'inverse. D'autant plus qu'avec ces messages (bien que je ne maîtrise pas du tout le sujet sur le fonctionnement d'une IA), je suppose que tous ces programmes "incomplets" et "erronés" vont finir par se rajouter à la base de données que l'IA utilisera pour développer de nouveaux programmes. Peut-être que les experts de l'IA pourront répondre à cette question mais "est-ce possible que l'IA utilise ses propres erreurs pour se développer et étoffer sa base de données ?". Car si c'est le cas, je crains que l'IA ne s'abrutisse de plus en plus au lieu de s'élever vers le haut. Bref, je pense que l'apparition de l'IA est en soit une bonne nouvelle et une excellente avancée technologique, mais personnellement ce n'est pas l'IA qui me fait peur mais plus la masse de personnes incompétentes qui ne sont pas formées pour dialoguer avec une IA et avoir un esprit critique sur les résultats obtenus. "Le savoir est une arme", j'espère juste que l'on sera en mesure de démêler le vrai du faux car sinon cela risque de se retourner contre nous. Pour en revenir au sujet, cela peut s'avérer un bon outil pour les développeurs expérimentés ou bien pour les novices (qui posent les bonnes questions) qui souhaiteraient savoir si oui ou non un programme existe déjà. D'ailleurs question : que répond l'IA lorsque l'on décrit un besoin et que l'on demande à ce qu'elle cherche des programmes existants pouvant s'en rapprocher le plus ? Car j'ai l'impression que les débutants en programmation n'ont jamais essayé de vérifier si un programme n'avait pas déjà été programmé par un vrai développeur, ils préfèrent demander à l'IA un truc sur mesure à chaque fois... Bisous, Luna

@aLb1, Aucun des messages ci-dessous n'ont vocations à être méprisant, hautain ou je-ne-sais-quoi... Je trouve cela triste de voir qu'une simple remarque du genre "il faut apprendre avec notre propre cerveau" peut déclencher chez vous du dégoût. Bien que la formulation peut sembler agressive pour certaines personnes, la valeur du message est cohérente et parfaitement raisonnable. Sachez que les personnes que vous considérez "méprisantes" sont des personnes bénévoles qui, durant de nombreuses années d'expériences, n'ont jamais cessé d'apprendre, d'instruire et d'aider autrui. Donc en terme d'intelligence, je pense qu'il va de soi que ces personne savent de quoi elles parlent et sont parfaitement apte à voir d'un mauvais œil ChatGPT. Et le problème est simple : le langage AutoLISP est un langage élitiste avec bien trop peu d'exemples qui traînent sur Internet (et encore moins sans erreurs). A commencer déjà par la proportion d'utilisateurs anglophones par rapport au reste du monde, et les conséquences de cette répartition se retrouvent dans le code que ChatGPT a proposé initialement d'ailleurs : le nom des commandes/options étaient en anglais, sans considérer la langue internationale. Bref, je comprends votre désir de vous aider de ChatGPT pour apprendre l'AutoLISP et c'est normal, c'est dans l'ère du temps. Cependant ChatGPT est encore un enfant en pleine croissance, et c'est d'autant plus vrai pour le domaine de la programmation sous AutoCAD. C'est d'ailleurs pour cette raison que les utilisateurs se tournent vers des experts comme @didier ou @(gile) qui surpassent en tout point ChatGPT ! Je rejoins l'avis de ces experts, l'apprentissage via ChatGPT est une fausse bonne idée. ChatGPT peut se tromper et il VA se tromper, c'est une évidence. Le problème se pose donc "comment savoir identifier les erreurs de ChatGPT si l'on s'appuie sur lui pour apprendre ?". Car je suis certaine que la réponse que vous attendiez concernant la résolution de votre problème n'était très certainement pas "il faut rajouter un underscore" 🙂 C'est pour cela que les experts qui sont intervenus ont évoquer l'existence de leur site internet respectifs. Nullement pour faire de la promotion mais uniquement pour vous aider dans votre apprentissage avec des sources sûres, le bon vocabulaire et en français. C'est sûrement nul et outdated de penser ainsi mais... "c'est en forgeant que l'on devient forgeron", donc vui... il faut malheureusement apprendre les bases de l'AutoLISP. Je ne condamne absolument pas l'utilisation de ChatGPT, au contraire je suis sûre que l'IA est en mesure d'aider le cerveau humain à façonner un chemin mais il ne faut pas oublier que l'humain reste l'expert pour paver son chemin solide et intemporel. Si cela peut te rassurer, j'ai découvert l'existence de l'AutoLISP il y a 6 ans à peine. En 1 an seulement, les bases sont déjà acquises si on est suffisamment curieux pour apprendre comprendre (pardon, je n'aime pas le terme "apprendre", "comprendre" est bien plus complet sur le plan éducatif). Veuillez m'excuser pour ce long pavé... PS: Aucune envie de nuire, rabaisser ou insulter n'est présente dans nos message, on est juste humains avec nos problèmes et émotions. Il est parfois délicat d'être objectif et détaché. Bisous, Luna

Coucou, Alors dans un premier temps, je remarque que ton ChatGPT ne connaît pas le principe des commandes/options internationales (ce qui peut poser problème si ton AutoCAD n'est pas anglais...). Pour cela, il suffit de rajouter un underscore _ devant les noms de commandes et/ou options (certaines commandes/options avaient déjà un underscore dans ton programme). Ci-dessous le programme avec les options internationales (j'ai ajouté en commentaire ce que j'ai ajouté dans la ligne) : (defun c:dxfauto (/ docName docPath dxfName cmd ss layoutName pdfFile allObjects) ;; Sauvegarder la valeur actuelle de CMDECHO (setq cmd (getvar 'cmdecho)) ;; Désactiver l'affichage des commandes (setvar 'cmdecho 0) ;; Enregistrer le fichier DWG en cours (command "_.QSAVE") ;; Mettre le calque COTATIONS en arrière-plan (setq ss (ssget "_X" (list (cons 8 "COTATIONS")))) ;;; _ (if ss (command "_.DRAWORDER" ss "" "_B") ;;; _ (princ "\nAucun objet trouvé sur le calque COTATIONS.") ) ;; Obtenir le nom et le chemin du fichier DWG ouvert (setq docName (getvar "DWGNAME")) (setq docPath (getvar "DWGPREFIX")) ;; Imprimer le layout "AVEC COTES" en PDF en couleur (setq layoutName "AVEC COTES") (if (member layoutName (layoutlist)) (progn (setq pdfFile (strcat docPath (vl-filename-base docName) "_AVEC_COTES.pdf")) (setvar 'CTab layoutName) (command "_-PLOT" ;;; _ "_Y" ;;; _ "" "DWG To PDF.pc3" "ISO_A4_(210.00_x_297.00_MM)" "_Millimeters" ;;; _ "_LANDSCAPE" ;;; _ "_N" ;;; _ "_E" ;;; _ "_F" ;;; _ "_C" ;;; _ "_Y" ;;; _ "" ;; Aucun style de tracé (pour couleur) "_Y" ;;; _ "_N" ;;; _ "_N" ;;; _ "_N" ;;; _ pdfFile "_N" ;;; _ "_Y" ;;; _ ) ) (princ "\nLe layout 'AVEC COTES' n'existe pas.") ) ;; Se positionner sur le calque COUPES BRUTES (command "_-layer" "_Set" "COUPES BRUTES" "") ;; Supprimer les calques spécifiés avec confirmation automatique (command "_-laydel" "name" "COTATIONS" "" "_Y") ;;; _ _ (command "_-laydel" "name" "INDICATIONS" "" "_Y") ;;; _ _ (command "_-laydel" "name" "PROLINER" "" "_Y") ;;; _ _ (command "_-laydel" "name" "CADRE" "" "_Y") ;;; _ _ ;; Revenir au layout "Model" (setvar 'CTab "Model") ;; Sélectionner tous les objets visibles (setq allObjects (ssget "_X")) ;; Exploser tous les objets sélectionnés (if allObjects (progn (foreach ent (vl-remove-if 'listp (mapcar 'cadr (ssnamex allObjects))) (command "_.EXPLODE" ent "") ) ) ) ;; Créer le nom du fichier DXF (setq dxfName (strcat docPath (vl-filename-base docName) ".dxf")) ;; Enregistrer le fichier en DXF (command "_.DXFOUT" dxfName "16") ;; Ajouter un délai pour s'assurer que le fichier est bien enregistré (vl-cmdf "_.delay" 1000) ;; Ouvrir le fichier DXF dans un nouvel onglet en utilisant l'API ActiveX/COM (setq acadApp (vlax-get-acad-object)) (setq acadDocs (vla-get-documents acadApp)) (vla-open acadDocs dxfName) ;; Restaurer la valeur initiale de CMDECHO (setvar 'cmdecho cmd) ;; Afficher un message de confirmation (princ (strcat "\nFichier enregistré sous : " dxfName)) (princ) ) ;; Appel de la fonction principale (c:dxfauto) Ensuite concernant ta demande A ma connaissance un LISP n'est pas en mesure de s'exécuter d'un fichier à un autre. Donc si tu exécutes ton LISP dans ton DWG, et que tu ouvres un autre fichier pour le rendre courant (via le LISP) alors le programme continuera de s'exécuter dans ton DWG initial il me semble (ou bien il met fin à son exécution, je ne sais pas exactement). Donc sur le principe, il n'est pas possible de faire ce que tu souhaites en LISP, c'est-à-dire à partir d'un DWG, créer un DXF pour ensuite apporter des modifications dans ce nouveau fichier DXF. En revanche (bien que je n'y connais rien), je pense que ce genre de choses peuvent se faire via un script (donc externe à AutoCAD) pour ouvrir un DWG, faire les modifications DWG, créer un fichier DXF pour ensuite exécuter la suite du programme sur ce fichier. Enfin, pour cette demande si jamais tu as des commandes qui requiert des validations imprévues (cela ne fonctionne pas si tu dois saisir des options différentes cependant), tu peux vérifier la valeur de la variable "CMDACTIVE" (cf. >>ici<<) et l'intégrer dans une boucle comme ceci par exemple : (command "_.EXPLODE" ent "") (while (= 1 (logand 1 (getvar "CMDACTIVE"))) (command "") ) Et si tu veux filtrer ton jeu de sélection pour 3 calques uniquement alors il faut l'intégrer à ton (ssget) via le code DXF 2 comme ceci (tu remarqueras l'utilisation de la virgule , pour séparer 2 éléments au sein d'une chaîne de caractères) : (setq allObjects (ssget "_X" (list (cons 8 "Calque1,Calque2,Calque3")))) Désolée je manque de temps pour regarder ton problème plus en détail... Bisous, Luna