VDH-Bruno

Re, strcat tes doigts ont dérapé sur le clavier en programmation cela ne pardonne pas... Tu n'utilises pas l'IDE Visual Lisp d'AutoCAD? A+

Slt, Presque il te manquais atof ;) (setq Zgs (rtos (- (atof "63.83") (atof "0.95")))) A+

Slt, Rapidement pour le principe une solution parmi d'autres, en s'appuyant sur la routine gc:str2lst de (gile), une routine très confortable d'utilisation lorsqu'il s'agit de "briser" des chaînes de caractères en fonction de caractères identifiables. La routine: ;; gc:str2lst ;; Transforme un chaine avec séparateur en liste de chaines ;; ;; Arguments ;; str : la chaîne ;; sep : le séparateur (defun gc:str2lst (str sep / pos) (if (setq pos (vl-string-search sep str)) (cons (substr str 1 pos) (gc:str2lst (substr str (+ (strlen sep) pos 1)) sep)) (list str) ) ) L'application à ton cas: ;; Chaîne de texte de départ (setq txt "(0.80) Zs=52.78") ; "(0.80) Zs=52.78" ;; Séparation de la chaîne de caractères en une liste de 2 chaînes (setq txt (gc:str2lst txt " ")) ; ("(0.80)" "Zs=52.78") ;; prf = Supression du 1er et dernier caractère de la 1ère chaîne de caractères (setq prf (substr (car txt) 2 (- (strlen (car txt)) 2))) ; "0.80" ;; ZGs = Séparation de la seconde chaîne de caractères, en gardant le 2ème élèment (setq ZGs (cadr (gc:str2lst (cadr txt) "="))); "52.78" Edit: Réponse rapide mais visiblement pas assez, BonusCAD est en grande forme à ce que je vois :)

Slt, Essaye avec -texte, qui de mémoire correspond à la ligne de texte unique, avant la fusion des commande texte et txtdyn.. (defun c:testeTxt () (setq x_alpha 52.89) (setq Texte "TexteAPlacer") (setq xy (getpoint "\nSpécifiez un point d'insertion pour le texte : ")) (command "-texte" xy "" x_alpha Texte) ) Edit: Si je ne me trompe de mémoire le problème de txtdyn et le même que pour la commande mainlev, ils utilisent le mode dynamique du périphérique de pointage ce qui fait qu'ils ne sont pas "macrotable" sans la validation de l'utilisateur A+

Re, Dans ce cas et rapidement la macro lisp de ce que je t'ai proposé précédemment, bien que cela ce fait très bien en natif avec filtre et la fenêtre de propriété d'Autocad. ;;;================================================================= ;;; VPBD.LSP V1.01 VDH-Bruno ;;; ;;; "Verrouille" Les propriétés dynamiques des références de blocs. ;;; (Modifie l'échelle d'insertion en Z de la référence de bloc) ;;; (defun c:vpbd (/ ss i e dxf oldEchZ newEchZ) (vl-load-com) (vla-startundomark (vla-get-activedocument (vlax-get-acad-object))) (repeat (setq i (if (setq ss (ssget '((0 . "INSERT")))) (sslength ss) 0 ) ) (setq e (ssname ss (setq i (1- i)))) (if (vlax-invoke (vlax-ename->vla-object e) 'GetDynamicBlockProperties) (progn (setq dxf (entget e) oldEchZ (assoc 43 dxf) newEchZ (cons (car oldEchZ) (1+ (cdr oldEchZ))) ) (entmod (subst newEchZ oldEchZ dxf)) ) ) ) (vla-endundomark (vla-get-activedocument (vlax-get-acad-object))) (princ) ) La fonction réciproque pour rétablir l'accès aux propriétés dynamique de ta référence de bloc ;;;================================================================= ;;; DVPBD.LSP V1.01 VDH-Bruno ;;; ;;; "DéVerrouille" Les propriétés dynamiques des références de blocs. ;;; (Homogénise l'échelle d'insertion en Z de la référence de bloc ;;; en fonction des valeurs d'échelle en X et Y) ;;; (defun c:Dvpbd (/ ss i e dxf EchX EchY EchZ) (vl-load-com) (vla-startundomark (vla-get-activedocument (vlax-get-acad-object))) (repeat (setq i (if (setq ss (ssget '((0 . "INSERT")))) (sslength ss) 0 ) ) (setq e (ssname ss (setq i (1- i))) dxf (entget e) EchX (assoc 41 dxf) EchY (assoc 42 dxf) ) (if (= (cdr EchX) (cdr EchY)) (entmod (subst (cons 43 (cdr EchX)) (assoc 43 dxf) dxf)) ) ) (vla-endundomark (vla-get-activedocument (vlax-get-acad-object))) (princ) ) Et enfin une version plus définitive qui convertie tes références de blocs dynamiques en blocs anonymes, de ce fait ils perdent définitivement l'accès à leurs propriétés dynamiques. ;;;================================================================== ;;; SPBD.LSP V1.01 VDH-Bruno ;;; ;;; Supprime les propriétés dynamiques des références de blocs. ;;; (Convertie les références de blocs dynamiques en référence de ;; bloc anonyme). ;;; (defun c:SPBD (/ adoc ss) (setq adoc (vla-get-activedocument (vlax-get-acad-object))) (vla-startundomark adoc) (cond ((ssget '((0 . "INSERT"))) (vlax-for obj (setq ss (vla-get-activeselectionset adoc)) (and (vlax-invoke obj 'GetDynamicBlockProperties) (vla-ConvertToAnonymousBlock obj)) ) (vla-delete ss) ) ) (vla-endundomark adoc) (princ) ) A+

Slt, Pour faire cela facilement si tes références de bloc sont en 2D, l'astuce consiste à modifier un des paramètre d'échelle d'insertion de ta référence de bloc (Echelle en Z bien souvent pour ne pas avoir d'incidence graphique) l'élément n'ayant plus une échelle d'insertion homogène, ses propriétés dynamique sont "verrouillé"... (l'opération inverse permet d'accéder à nouveau aux propriétés dynamiques) A+ Bruno

Les fonctions vlax-* Comme rappelé dans ce sujet Les fonctions vlax- peuvent se classer en 2 types, pour les secondes (c.a.d. celles qui ne font pas explicitement appel à l'interface COM) il peut être utile de préciser qu'il est tout à fait possible de les appeler avec les types ENAME ouVLA-OBJECT (contrairement à ce que peut laisser penser l'aide). Exemple: (setq ent (entmakex '((0 . "CIRCLE") (10 0.0 0.0 0.0) (40 . 10.0))) obj (vlax-ename->vla-object ent) ) _$ (vlax-curve-getArea ent) 314.159 _$ (vlax-curve-getArea obj) 314.159 Si l'on s'attache aux détails, on s'aperçoit qu'en cas de choix la première écriture est à préférer, car en interne dans ces fonctions c'est le type ENAME qui est privilégié.. _$ (benchmark '((vlax-read-enabled-p ent) (vlax-read-enabled-p obj))) Benchmarking ...................Elapsed milliseconds / relative speed for 65536 iteration(s): (vlax-read-enabled-p ENT).....1186 / 2.04 <fastest> (vlax-read-enabled-p OBJ).....2418 / 1 <slowest> _$ (benchmark '((vlax-curve-getEndPoint ent) (vlax-curve-getEndPoint obj))) Benchmarking ...................Elapsed milliseconds / relative speed for 65536 iteration(s): (vlax-curve-getEndPoint ENT).....1357 / 1.98 <fastest> (vlax-curve-getEndPoint OBJ).....2683 / 1 <slowest> Liste de fonctions vlax- supportant le type ENAME: vlax-curve-getPointAtParam vlax-curve-getClosestPointTo vlax-curve-getArea vlax-curve-getSecondDeriv vlax-curve-getPointAtDist vlax-curve-getDistAtParam vlax-curve-getDistAtPoint vlax-curve-getStartPoint vlax-curve-getClosestPointToProjection vlax-curve-getFirstDeriv vlax-curve-getEndParam vlax-curve-getParamAtDist vlax-curve-getStartParam vlax-curve-getParamAtPoint vlax-curve-isPeriodic vlax-curve-isClosed vlax-curve-isPlanar vlax-erased-p vlax-ename->vla-object vlax-read-enabled-p vlax-write-enabled-p

Bonjour, En quoi est-ce ridicule 2 décimales? Que cela ne te conviennent pas je peux le comprendre, après il faut savoir que dans certains corps de métier, si on part du principe que l'unité (m, cm, mm) est fonction du projet, par convention le nombre de chiffre significatif pour la partie décimal est fonction de la dimension: - 1 décimale pour les longueurs - 2 décimale pour les surfaces - 3 décimale pour les volumes A+

Slt, A voir si cela peut te convenir http://cadxp.com/topic/40858-lister-lensemble-des-calques/page__view__findpost__p__229340 (UCSLIST) A+ Edit: grillé par Patrick_35 qui a été le plus rapide

Effectivement un post de dernière minute (ou date de dernière minute) qui laisse perplexe Edit: (-1 virtuel pour le crabe qui à joué avec la modération du forum 2016 pour prendre un max de poissons dans ses filets :D )

J'ignorai cette petite subtilité très interessante, merci (gile) de nous la faire partager. A+ Bruno (Ps: Je me coucherai plus riche que je me suis levé, c'est ce que j'appel une bonne journée)

Slt, Personnellement j'aurais dit tu peux économiser entget, massoc, car, reverse... avec vlax-curve-getStartPoint & vlax-curve-getEndPoint qui supportent très bien les ename. ;) (setq PTD1 (vlax-curve-getStartPoint poly1)) (setq PTD2 (vlax-curve-getStartPoint poly2)) (setq PTF1 (vlax-curve-getEndPoint poly1)) (setq PTF2 (vlax-curve-getEndPoint poly2)) A+ (Ps: J'aime bien l'esprit de ton l'algorithme zebulon_)

Re, Oui et (gile) t'as donné la correction pour s'affranchir du réglage de la variable SHORTCUTMENU, si paramétré par exemple à 11 (sa valeur initial), tu as le "focus" sur la valeur par défaut dans ton menu contextuel (renseigné avec tes valeurs entre crochet), donc si tu valide ce choix, c'est ce dernier qui t'est retourné… Voilà pour le complément. Pour ce qui est de mon exemple, je voulais montrer que pour un usage unique il n'est pas nécessaire d'introduire des variables dans le code (je sais que l'emploi de variable cela aide au début). En prime avec la correction apporté sur la fonction question, tu as une illustration de l'intérêt d'écrire des fonctions spécialisés car il est plus agréable de faire la correction sur une ligne qui se répercutera dans tout le code, que de répéter la modification plusieurs fois dans le programme. A+

Bonjour et bienvenu Gjulien Si tu me permet deux ou trois petites remarques pour tes débuts: - Je te conseil d'internationaliser tes commandes et options de commandes, surtout que tu travailles avec une version anglaise. - Pense à localiser tes variables après ton defun ex: (defun c:cscc (/ LaRec Purge Save) -Pour paramétrer tes variables AutoCAD tu peux passer par la fonction lisp setvar Si tu veux t'amuser à comparer, voici comment j'aurais écrit ce code: (defun c:cscc (/ question) (setvar "MSLTSCALE" 0) (setvar "PSLTSCALE" 0) (setvar "LTSCALE" 1) (defun question (msg rep) (initget "Oui Non") (getkword (strcat msg " [Oui/Non] <" rep ">: "))) (alert (strcat "Configuration modifiée: " (if (= "Oui" (question "Voulez-vous rapprocher les calques ?" "Oui")) (progn (command "_-LAYER" "_RECONCILE" "*" "") "\n -> Calques rapprochés") "\n -> Calques non rapprochés" ) (if (= "Oui" (question "Voulez-vous purger votre dessin ?" "Oui")) (progn (command "_-PURGE" "_A" "*" "_N") "\n -> Dessin purgé") "\n -> Dessin non purgé" ) (if (= "Oui" (question "Voulez-vous sauvegarder votre dessin ?" "Oui")) (progn (command "_QSAVE") "\n -> Dessin sauvegardé") "\n -> Dessin non sauvegardé" ) ) ) ) A+ (Ps: code non testé car il n'y a pas l'option rapproché sur ma version 2007 d'AutoCAD)

Re, Pas sur ma version 2007, et je n'ai pas connaissance d'une variable qui gère cela, je ne peux rien dire de plus. A+

En ce qui me concerne, c'était il y a 22 ans... (Ps: Didier, désolé pour le hors-sujet)

zebulon_, un petit (entupd ATT) en sortie de code après le entmod sera du plus belle effet ;) Amicalement, Bruno

Bonjour, Je ne te propose pas de solution miracle mais une méthodologie un peu différente qui devrait théoriquement accélérer le traitement à moindre frais, à avoir si ça le rendra acceptable je te laisse juge… 6) Là je ne suis moins d'accord depuis ma version 2007, il faut d'abord lancer la commande _hatchedit (EDITHACH) puis sélectionner LA hachure globale (la surbrillance de la sélection et moins couteuse que de gripper une ANSI31). Et convertir LA hachure globale en hachure globale solide. 7) Puis relancer la commande _hatchedit sur LA hachure globale solide pour "Separer les hachures" cela allégera un peu le calcul. 8) Modifier une des hachures solide séparé en ANSI31, puis un coup de _matchprop sur les autres hachures pour les convertir en ANSI31. Après si cela te semble acceptable je te fais confiance pour automatiser cela. A+ Bruno

Ouais, as te lire je m'aperçois que je me débrouille mieux en lisp qu'à l'écrit, si seulement j'avais formulé ma réponse comme la tienne, on aurait tous 2 gagné notre temps <_< . Oui, ces débats sont toujours intéressant ;) A+

Re, Le premier oui me rassure, mais vraisemblablement pour le reste je me suis très mal exprimé, je revoie ma copie et tente une approche plus lispienne que littéral, en proposant une autre factorisation de l'expression car dans foo, factorisation plus juste et certainement plus parlante… (defun foo1 (l1 l2) (apply 'append (mapcar '(lambda (p1) (setq p1 (car p1)) (mapcar '(lambda (p2) (cons p1 (cdr p2))) l2) ) l1 ) ) ) Ecrit comme cela on voit mieux l'optimisation du (car p1) dans foo1 qui est appliqué à chaque élément de L1 et est valable pour tous les éléments de L2 qui suivent. Maintenant pour factoriser le cdr, il faut le faire en amont de la boucle sur L1: (defun foo2 (l1 l2) (setq l2 (mapcar 'cdr l2)) (apply 'append (mapcar '(lambda (p1) (setq p1 (car p1)) (mapcar '(lambda (p2) (cons p1 p2)) l2)) l1) ) ) La fonction cdr est appliquée à tous les éléments de L2, et est valable pour tous les éléments de L1. Alors que dans la fonction foo d'origine les fonctions car et cdr ne sont plus dépendants dans leurs appels aux nombres d'éléments présents dans les listes L1 et L2, leurs nombres d'appels est directement lié aux nombres d'élément contenue dans la liste résultat LR = L1 x L2. Le nombre d'éléments contenus dans la liste résultat étant multiplicatif, il croit plus vite que le nombre d'appel contenu dans l'expression suivante qui est additif malgré le coût amené par mapcar: (setq l1 (mapcar 'car l1) l2 (mapcar 'cdr l2) ) A+ (Ps: Pas sûr d'avoir été plus clair sur ce coup-là, tout cela restant très anecdotique)

Salut, Même si la modif en ajoutant 2 boucles supplémentaires avec mapcar est plus un clin d'œil d'encouragement adressé bigsyke sur ce sujet. Tu penses bien qu'avant de reprendre des lignes de codes derrière (gile), j'ai pesé mes mots en parlant de "légère optimisation" dans le cas de "nombreux points" ;) . Donc si on veut tenter de quantifier le terme de nombreux points, pour positionner un curseur il faut avoir en tête la valeur d'accroissement de la liste final soit: (longueur de la liste L1) x (longueur de la liste L2) = (longueur de la liste résultat) Dans le premier code la fonction (car p1) est multiplié par le nombre d'élément présent dans L2 et la fonction (cdr p2) est multiplié par le nombre d'élément présent dans L1. Dans la seconde version de foo, les car de L1 et les cdr de L2 sont mémorisé au début du code pour être réutilisé par la suite dans le corps de la fonction, les car et cdr sont traité au moyen de la fonction mapcar qui est effectivement une boucle que l'on pourrais éventuellement réécrire comme ceci : (defun bv:mapcar (f l) (if l (cons ((eval f) (car l)) (bv:mapcar f (cdr l))))) Si on considère que les fonctions ont un coup sensiblement équivalent, pour mémoriser un car dans L1 ou un cdr dans L2, cela coute environ un if, cons, eval , car, bv:mapcar, cdr soit grosso modo 6 opérations. En conclusion les expressions (mapcar 'car l1) et (mapcar 'cdr l2) doivent être gagnante dès que les listes L1 et L2 ont plus de 6 éléments, donc dans le cas où la liste résultante contient au moins 7x7 éléments, résultat qui se retrouve au Benchmark. A+ Bruno (Ps: l'optimisation reste très légère car elle est rapporté à l'ensemble de la fonctions foo et porte sur des fonctions lisp très peu couteuse que sont car et cdr..)

Bonsoir, Pour compléter et détailler la réponse de Patrick_35, un lien => Les fonctions passées comme argument Et toujours avec mapcar , une légère optimisation possible de la fonction foo proposé par (gile) dans le cas ou tu aurais de nombreux points à traiter. (defun foo (l1 l2) (setq l1 (mapcar 'car l1) l2 (mapcar 'cdr l2) ) (apply 'append (mapcar '(lambda (x1) (mapcar '(lambda (yz2) (cons x1 yz2)) l2) ) l1 ) ) ) A+

Bonjour, Un truc très simple et aussi vieux que la possibilité de faire des blocs sous AutoCAD, consiste à dessiner un "carré unitaire" avec une croix au milieu, puis tu en fait un bloc "classique" avec le coin inférieur gauche comme point d'insertion, sans unité et sans mise à l'échelle de façon uniforme. Puis si l'échelle d'insertion est spécifié à l'écran, ton bloc s'insère comme avec la commande rectangle en 2 clic sur la diagonale et à la bonne dimension. Par la suite si tu veux modifier ses dimensions via la palette de propriété avec l'échelle en X ou en Y, c'est possible. A+ Dessin2.zip Ps: J'utilise ce truc depuis plus de 20 ans pour schématiser rapidement des réservations, des poteaux etc.., bien que depuis j'ai la capacité d'écrire des lisp ou de faire des blocs dynamique ;) .

Bonjour, C'est possible également avec rtos, comme précisé dans les messages précédents il suffit de faire attention à la valeur de DIMZIN.. Rapidement pour le principe une variante de ton lisp qui devrait fonctionner, (acceptant un nombre au format chaîne de caractère ou numérique): (defun AjoutZero (nbr n) (if (numberp (setq nbr (distof (vl-princ-to-string nbr) ))) ((lambda (v) (setvar 'dimzin 0) (setq nbr (rtos nbr 2 n)) (setvar 'dimzin v) nbr) (getvar 'dimzin)) ) ) _$ (AjoutZero "5.130" 6) "5.130000" _$ (AjoutZero 5.13 6) "5.130000" _$ (AjoutZero "toto" 6) nil _$ A+