VDH-Bruno

Pas tout à fait, le but est justement de sortir toutes les références de bloc de la sélection, donc rien d'étonnant à ce que ta sélection soit vide car tu n'avais sélectionné que des références de bloc. A+

Bonjour, Re-teste avec l'intégralité de l'expression Lisp A+

Bonjour, Pour faire simple : (gile) -> L’emploie du caractère générique ~(tilde) - Placé en début de modèle, recherche tout excepté le modèle . (vdh) -> L’usage du "_I" (sélection Implicite) permet si tu as des objets déjà grippé à l’écran de filtrer cette pré-sélection et d'en exclure les références de bloc, sinon tu es invité à faire une sélection. (-Olivier- ) -> La fonction sssetfirst en "grippant" ta sélection te permet de la visualiser à l’écran. En conclusion la ligne suivante étant la synthèse des 3 précédentes propositions, elle devrait tout aussi bien faire ton bonheur: (sssetfirst nil (cond ((ssget "_I" '((0 . "~INSERT")))) ((ssget '((0 . "~INSERT")))))) A+

Oui, bien vu c’est effectivement plus simple et visuellement plus agréable.

Bonsoir, Pour intégrer sur un bouton, il n’est peut-être pas nécessaire de définir une fonction qui demande à être préalablement chargé. De plus dans le code précédent, on peut aisément se passer de variable.. A copier dans ta macro bouton : (sssetfirst nil (ssget '((-4 . "<NOT") (0 . "INSERT") (-4 . "NOT>")))) Si tu le souhaite, il est possible d’émuler la ligne de code de façon à filtrer également une éventuel sélection implicite. (sssetfirst nil (cond ((ssget "_I" '((-4 . "<NOT") (0 . "INSERT") (-4 . "NOT>")))) ((ssget '((-4 . "<NOT") (0 . "INSERT") (-4 . "NOT>")))) ) ) A+

A ta décharge la question était nominative, normalement personne n’était censé répondre pour toi.. A+

Salut, Voir la réponse n°24 suite à la demande de Carboleum: http://cadxp.com/index.php?/topic/35090-scandxf-beta/page__view__findpost__p__193548 A+

Bonjour, On peut également avec une liste associative, comme ceci. (setq lmini (/ (cdr (assoc ohdiametre '((0.3 . 0.96) (0.4 . 1.08) (0.5 . 1.2) (0.6 . 1.32) (0.8 . 1.76) (1.0 . 2.00) (1.2 . 2.24) (1.4 . 2.48) (1.5 . 2.60) (1.6 . 2.82) (1.8 . 2.96) (2.0 . 3.20) ) ) ) 2 ) ) A+

Bonjour, Si j’ai bien compris ces quelques lignes de codes rapidement adapté de codes similaires, devrait faire l’affaire à tester… ;; Ouvre l'explorateur depuis le répertoire courant en remontant l'arborescence du nombre d'indice spécifié. ;; --------------------------------------------------------------------------------------------------------- ;; Exemple: (OpenExplorerFromDwg 0) -> Ouvre l'explorateur sur le répertoire du dessin courant. ;; (OpenExplorerFromDwg 2) -> Ouvre l'explorateur 2 répertoires plus haut dans l'arborescence du dwg. (defun OpenExplorerFromDwg (n / f s) (defun f (m s p) (if (setq p (vl-string-search m s p)) ((lambda (x) (cond ((minusp x) (1+ x)) ((zerop x) (1+ p)) (x))) (f m s (1+ p))) (- n) ) ) (if (<= 0 n) (startapp "explorer" (substr (setq s (getvar 'dwgprefix)) 1 (cond ((< 0 (setq n (f "\\" s 0))) n) ((1+ (vl-string-search "\\" s))) ) ) ) ) (princ) ) ;; Demande en ligne de commande le nombre de répertoire à remonter dans l'arborescence du dwg courant pour lancer l'explorateur. ;; --------------------------------------------------------------------------------------------------------- (defun c:ExplorerFromDwg () (or *fromdwg* (setq *fromdwg* 0)) (initget 4) (OpenExplorerFromDwg (setq *fromdwg* (cond ((getint (strcat "\nNombre de répertoire racine à remonter depuis le dessin courant <" (itoa *fromdwg*) ">: "))) (*fromdwg*) ) ) ) ) Cordialement

Oui, tout à fait cela permet d’inverser l’ordre d’évaluation des termes de la fonction cons par l’interpréteur Lisp. Un équivalent de cette ligne de code : ((zerop to) ((lambda (l) (cons ele l)) (loop from (1- to) lst))) par composition de fonctions serait : ((zerop to) (apply 'cons (reverse (list (loop from (1- to) lst) ele)))) A+

Bonjour Titifonky, En quelque sorte, l’explication en est très simple pour cela il suffit de se rappeler qu’un programme Lisp (list processing), s’interprète comme une liste de la gauche vers la droite. Dans la fonction récursive loop, si nous avions définit la ligne du cond de la façon suivante : ((zerop to) (cons ele (loop from (1- to) lst))) Lorsque l’indice de l’élément from est supérieur à l’indice de déplacement to, la ligne de code sera évaluée, en commençant par l’expression la plus à gauche c’est-à-dire la valeur de l’élément ele qui vaut nil (car a ce stade sa valeur ne lui a pas encore été affecté), cet état est empilé (mémorisé) puis la fonction loop est appelle.. Une fonction lisp retourne toujours son résultat là ou elle a été appellé donc au retour d’appel la valeur nil précédemment interprété sera "consé". Pour pallier à cette difficulté, on a fait appel à une fonction auxiliaire, comme c’est pour un usage unique et localisé, j’ai utilisé une fonction anonyme lambda (elle aurait pu être nommé pour un usage moins localisé, et même récursive quand l’algorithme si prête => voir ICI pour un cas basique de récursion croisée) Pour en revenir à notre fonction lambda, l’écriture suivante : ((zerop to) ((lambda (l) (cons ele l)) (loop from (1- to) lst))) Fait que la fonction loop devient argument de la fonction lambda, en conséquence elle est d’abord interprété puis c’est sa valeur de retour qui est transmise à la fonction lambda pour que cette dernière puisse à son tour être interprété et que soit "conser" la valeur de ele sur la liste partiel retourné par la fonction loop. A ce stade on est sûr que la valeur variable ele est affecté d’une valeur car son interprétation n’est plus effectué pendant la descente des appels récursif (avec une affectation ou absence d’affectation suivant l’ordre des indices from et to), mais la variable ele est interprété pendant la remonté (dépilement) des appels . J’espère avoir été suffisamment explicite, l’idée général dans ce style d’exercice est de percevoir l’interprétation d’une fonction lisp sous forme de transmission d’expression, d’évaluation et de valeur en retour.. A+ Bruno (Ps : Félicitation pour ton site Titifonky, je viens d’y jeter un œil, j’aime beaucoup, bravo !)

Merci a vous deux ! C'est toujours plus facile de jouer en deuxième, et si tel était vraiment le cas, j’aurais dû écrire ;) : (defun bv:moveFromTo (from to lst / loop ele) (defun loop (from to lst) (cond ((minusp (max from to)) lst) ((zerop from) (setq ele (car lst)) (loop (1- from) to (cdr lst))) ((zerop to) ((lambda (l) (cons ele l)) (loop from (1- to) lst))) (T (cons (car lst) (loop (1- from) (1- to) (cdr lst)))) ) ) (loop from to lst) ) La condition (/= from to) n’est pas indispensable, la fonction loop est suffisamment généraliste… A+

Toujours pour le jeu, la variante avec foreach, comme cela il n’y aura pas eu que du récursif.. :) (defun insertAt (ele ind lst / val) (if (> ind (length lst)) (append lst (list ele)) (reverse (foreach x lst (if (zerop ind) (setq val (cons ele val))) (setq ind (1- ind) val (cons x val)) ) ) ) ) Amicalement Bruno Nb : Les versions mapcar et foreach étant évidemment moins bonne, car elles s’appliquent sur toutes les cellules cons de la liste, même si l’indice spécifié ne concerne que la tête de liste..

Dans ce cas ;) (defun insertAt (ele ind lst / x) (if (> ind (length lst)) (setq ind (length lst)) ) (mapcar '(lambda (a) (cond (x (setq ele x x a) ele) ((zerop ind) (setq x a) ele) (T (setq ind (1- ind)) a) ) ) (append lst (list T)) ) ) A+

C’est de mon point de vue la façon la plus naturel de parcourir une liste, une liste étant une structure définie de façon récursive, je trouve plus agréable de la parcourir de la même manière.. Si tu n’es pas trop à l’aise avec la notion de récursivité, quelques liens à consulter… http://cadxp.com/index.php?/topic/29314-ces-listes-qui-nen-sont-pas/ http://cadxp.com/index.php?/topic/10999-recursivite/ http://cadxp.com/index.php?/topic/29587-mecanique-de-la-recursion/ http://cadxp.com/index.php?/topic/5381-alternatives-a-vlisp-recursivite/ A+

Re, As te lire, je suis persuadé que si tu avais posté des exemples codés, de ce que tu n’arrivais pas à faire, nous aurions certainement pu te montrer comment le faire au moyen des fonctions assoc, member, subst et append.. Car si tu travailles avec des listes de définition organisées sous forme de listes associatives (clef valeur) accessible avec la fonction assoc, tu t’apercevras que "bien souvent" la position des listes n’a que peu d’importance. C’est là la force des listes associatives dans la gestion des données. Exemple : (entmake (cons '(0 . "CIRCLE") (list '(8 . "CalqueCercle") '(10 0.0 0.0 0.0) '(40 . 100.0)))) Est pour AutoCAD aussi recevable que : (entmake (cons '(0 . "CIRCLE") (reverse (list '(8 . "CalqueCercle") '(10 0.0 0.0 0.0) '(40 . 100.0))))) Au cas ou si tu ne veux que positionner un élément en fin de liste, les classiques du lisp : $ (append '(A B C D) (list 'E)) (A B C D E) Ou _$ (reverse (cons 'E (reverse '(A B C D)))) (A B C D E) A+

Bonjour, Une petite coquille dans le code remplace l’expression ((null lst) nil) par ((null lst) (list ele)) Le code (defun insertAt (ele ind lst) (cond ((null lst) (list ele)) ((zerop ind) (cons ele lst)) ((cons (car lst) (insertAt ele (1- ind) (cdr lst))))) ) Pour tester _$ (setq lst '(A B C D E)) (A B C D E) _$ (insertAt 'F 5 lst) (A B C D E F) _$ Sinon pour faire echo à la proposition précédente de (gile) et pour le jeu une variante plus compacte, sans recourir à la fonction nth pour lire la valeur en from et ne parcourir qu’une seul fois la liste. (defun moveFromTo (from to lst / loop ele) (defun loop (from to lst) (cond ((minusp (max from to)) lst) ((zerop from) (setq ele (car lst)) (loop (1- from) to (cdr lst))) ((zerop to) ((lambda (l) (cons ele l)) (loop from (1- to) lst))) (T (cons (car lst) (loop (1- from) (1- to) (cdr lst)))) ) ) (if (/= from to) (loop from to lst) lst ) ) A+ (Nb: Les amateurs apprécirons l’astuce avec l’usage de lambda pour différer l’évaluation de ele jusqu’à la descente complète des appels pour être certain de son affectation lors de la remonté des appels enveloppants, quelques soit le plus grand des 2 index.)

Bonjour Olivier, La deuxième version est documentée de façon implicite dans les options de sélection de la commande _select Pour développer la réponse de Bryce: L’option _X scanne la base de donné du dessin, comme si tu la parcourrais avec entnext pour effectuer la sélection, alors que l’option _A et l’équivalent de l’option de commande _ALL (TOUT), dans les options de sélection de la commande _select (et sélectionne tous les objets présents sur les calques libérés.) Option de commande US: Option de commande FR: Quant à l’usage du caractère "_" dans les options de sélection de la fonction ssget, il est visiblement devenu facultatif (utilisé par convention), car depuis les versions 2000 l’option de sélection fait toujours référence à l'option la version internationale(US), contrairement à la commande _select et aux versions antérieures d’AutoCAD. Pour ce qui est des options non-documenté pour la fonction ssget, il y a cette réponse que m’avait donné (gile) http://cadxp.com/index.php?/topic/32394-zoom-sur-objet-selectionne/page__view__findpost__p__174302 Et un lien en anglais de alanjt sur lequel il m’avait redirigé http://www.cadtutor.net/forum/showthread.php?47932-how-can-i-use-the-filter-in-ssget&p=326428&viewfull=1#post326428 A+

Bonjour, Je tourne sous AutoCAD 2007, donc je ne te serais pas d’une grande aide en ce qui concerne l’annotatif. Par contre si tu as besoin de tester 2 ou 3 trois config de dessin, tu peux me les envoyer au format 2007, je te les retournerais en pdf pour que tu puisses visualiser le résultat et te faire une idée.. A+ Bruno Mail: (apply 'strcat (mapcar 'chr '(98 114 117 110 111 46 108 115 112 64 104 111 116 109 97 105 108 46 102 114)))

Fait quelques test dans ta console VLisp, tu verras que tu peux utiliser le nom de symbol que tu souhaites, par convention on essaie d’en choisir un suffisamment explicite. Un sujet qui peut certainement t’éclairer http://cadxp.com/index.php?/topic/28642-arguments-et-variables/page__view__findpost__p__156096 A+

Oui, dans cette appel à la fonction SelTxt2Real (SelTxt2Real "\nSélectionner l'altitude du plafond : ") invite correspond à Sélectionner l'altitude du plafond : Et dans celui-ci (SelTxt2Real "\nSélectionner l'altitude du plancher : ") invite correspond à Sélectionner l'altitude du plancher : A+

Re, Oui, dans ton cas «spécifique» la fonction entsel est suffisante, mais quitte à écrire une fonction spécialisé autant la faire la plus polyvalente possible, surtout si c’est à moindre frais (le remplacement de entsel par nentsel, ce n’est pas trop couteux ;) ) Dans ce cas ce n’est pas la matrice de transformation retourné qui nous intéresse mais le fait que nentsel nous retourne l’entité sélectionné qu’elle soit entité principale (cas des textes) ou sous-entités (cas des attributs ou texte dépendant d’une référence externe). A+

Re, Cela viendra petit à petit avec le temps et la pratique. J’ai parlé de principe car la ligne suivante, n‘est pas du tout sécurisé (retourne une erreur si sélection vide, ou absence de code dxf 1 dans l’entité sélectionné). (- (atof (cdr (assoc 1 (entget (car (entsel "\nSélectionner l'altitude du plafond : ")))))) (atof (cdr (assoc 1 (entget (car (nentsel "\nSélectionner l'altitude du plancher :")))))) ) Si l’on veut sécuriser le code à minima, il est préférable de factorisé ce dernier, par la création d’une fonction de sélection spécialisé.. ;; Sélection d'un texte (non formaté) et retourne sa valeur si numérique (defun SelTxt2Real (invite / val) (while (not (numberp val)) (if (and (setq val (nentsel invite)) (setq val (cdr (assoc 1 (entget (car val)))))) (setq val (read val)) ) ) ) Le code ainsi modifié (rtos (cond ((getreal "\nConnaissez-vous la hauteur sous plafond ? Si oui, entrez-la ; si non, validez. ")) ((- (SelTxt2Real "\nSélectionner l'altitude du plafond : ") (SelTxt2Real "\nSélectionner l'altitude du plancher : ") ) ) ) 2 2 ) Et dans le cas ou la hauteur peut-être obtenue par "mesure" à l'écran (cas d'une élévation), voir la fonction getdist pour une écriture encore plus concise. (rtos (getdist "\nSaisissez la hauteur sous plafond, ou spécifiez la à l'écran : ") 2 2) Cordialement

Bonjour, Un principe, à tester voir si cela te va.. (rtos (cond ((getreal "\nConnaissez-vous la hauteur sous plafond ? Si oui, entrez-la ; si non, validez.")) ((- (atof (cdr (assoc 1 (entget (car (entsel "\nSélectionner l'altitude du plafond : ")))))) (atof (cdr (assoc 1 (entget (car (entsel "\nSélectionner l'altitude du plancher :")))))) ) ) ) 2 2 ) A+

Bonjour, Ou comme ceci: (entmake (list '(0 . "LINE") '(8 . "Tube") (cons 10 p1) (cons 11 p2))) A+