Luna

Coucou, Pour commencer ce n'est pas un Lisp mais une macro :3 Ensuite, il semblerait que @rrobert ait eut le même soucis sur son AutoCAD 2021 dans ces posts : Le problème peut donc venir de la version AutoCAD 2021 avec l'extension de ses limites (A prendre avec des pincettes !!! Information à vérifier avant d'y croire dur comme fer ^^"). Le plus simple serait de confirmer cette info, cela pourrait éventuellement t'aider à corriger ce soucis :3 Bisous, Luna

Ah bah vouih je suis idiote, j'allais dans "%appdata%" au lieu de "Programme files" donc forcément chat fonctionne pas ^^" Merci beaucoup !!! Bisous, Luna

Pour s'adapter aux circonstances, il suffirait de passer en argument via un flag les différents types de box utiles et utilisées je pense (donc "edit_box", "popup_list", etc). En soit, pour la plupart, c'est bien souvent le key et label qui sont nécessaire et ensuite en fonction du type de valeur, il faut définir les tiles correctement (via (start_list), (set_tile), etc). Mais je reconnais bien trop souvent que plus on généralise une fonction pour quelle s'adapte à tous les cas de figure, et plus la définition des arguments nécessite des fonctions de génération de liste ou autre (ici encore, il serait possible de les généraliser xD) Donc évidemment, l'exercice semble intéressant mais il ne faut pas non plus créer des fonctions tellement générales au point de devoir créer des fonctions annexes pour les paramétrer correctement >w< Mais en soit, c'est l'utilité des fonctions d'ordre supérieur (un vrai casse-tête à programmer, mais un vrai plaisir à utiliser une fois fait !). J'attends le jour où je n'aurais plus qu'à appuyer sur un bouton et AutoCAD s'occupera de gérer mes projets, mes plannings et tout le tointoin xD Bisous, Luna

Coucou @(gile), Petite question : j'ai beau chercher sur le NET et l'aide AutoCAD, je ne trouve aucune info concernant la fonction (ai_sysvar)...Même lorsque je suis dans VLIDE, cette fonction ne semble pas reconnue. J'ai bien trouvé ce post de toi mais je ne parviens pas à trouver le fichier AcadXXXXdoc.lsp... pour mieux comprendre. Je pense avoir bien compris son utilisation grâce à tes différents messages présentant cette fonction, mais par pur principe je préfères comprendre correctement son utilisation ^^" Bisous, Luna

Coucou, C'est en effet intéressant comme exercice :3 Il est vrai que je n'ai jamais eut à utiliser les edit_box (la plupart de mes BdL passent par la fonction (ListBox) ^^") mais en revanche, le fait qu'une BdL soit définie par un nombre de lignes variables arrive assez souvent ! Donc ce programme aidera beaucoup de monde pour comprendre comment moduler sa BdL en fonction d'une liste de longueur variable :3 Bisous, Luna

Avec ce bout de code, je peux récupérer le format d'impression d'une présentation, il faut ensuite injecter cette valeur où tu le souhaites (champ dynamique, attribut, texte, ...). (defun getPrintFormat (name / str-reverse layout-list entlist str pos) (defun str-reverse (str) (vl-list->string (reverse (vl-string->list str))) ) (if (and (setq layout-list (vla-collection->list 'layouts 0)) (assoc name layout-list) (setq entlist (entget (cdr (assoc name layout-list)))) (setq str (cdr (assoc 4 entlist))) ) (setq pos (1- (vl-string-position (ascii "(") str)) str (substr str 1 pos) str (str-reverse str) str (substr str 1 (vl-string-position (ascii "_") str)) str (str-reverse str) ) ) ) Et la fonction permettant de récupérer la liste des présentations : ;--- Nom de la fonction []-----------------------[] vla-collection->list []-----------------------[] ;--- Date de création > 05/03/2021 ;--- Dernière modification > 07/03/2021 ;--- Auteur(e) > Luna ;--- Version > 1.1.0 ;--- Classe > "VlCol" ;--- But et domaine d'application ; ; > Permet de transformer une collection VLA sous forme de liste de paires pointées avec le nom et l'ename de chaque objet ; ; présent dans la collection. Il s'agit d'une version améliorée de la fonction (flt_tbl) car on peut accéder à davantage d'objets ; ; contrairement aux Symbol Tables (plus limitées) mais sans l'outil de recherche pour filtrer la recherche sur un pattern. ; ; ; ;--- Déclaration des arguments ; ; La fonction (vla-collection->list) possède 2 argument(s) : ; ; ¤ col > correspond au nom de la collection affublée d'une quote (le nom d'une collection est toujours au pluriel) ; ; (type col) = 'SUBR | Ex. : 'materials, 'linetypes, 'blocks, ; ; ¤ flag > permet de définir si le nom de l'objet récupéré correspond à l'ename ou au VLA-object ; ; (type flag) = 'BOOLEAN | Ex. : 0 pour l'ename, 1 pour le VLA-OBJECT ; ; ; ;--- Retour ; ; La fonction (vla-collection->list) renvoie la liste de paires pointées chacunes composée du nom de l'objet sous format string ; ; et de l'ename ou VLA-Object de l'objet pour accéder à sa liste DXF ou ses propriétés. ; ; Ex. : (vla-collection->list 'linetypes 0) renvoie ; ; (("ByBlock" . <Nom d'entité: 3b058940>) ; ; ("ByLayer" . <Nom d'entité: 3b058950>) ; ; ("Continuous" . <Nom d'entité: 3b058960>) ; ; ("DASHED" . <Nom d'entité: 2300df40>)) ; ; ; ;--- Modifications apportées par rapport à la version précédente ; ; > Simplification d'écriture de la collection (activedocument uniquement) et ajout de la variable flag pour modifier le retour. ; ; ; (defun vla-collection->list (col flag / lst item i) (if (null (vl-catch-all-error-p (setq i 0 col (vl-catch-all-apply 'vlax-get (list (vla-get-activedocument (vlax-get-acad-object)) col))))) (vlax-for item col (setq lst (cons (cons (if (vlax-property-available-p item 'Name) (vla-get-name item) (strcat "Unnamed_" (itoa (setq i (1+ i)))) ) (cond ((= flag 0) (vlax-vla-object->ename item) ) (t item ) ) ) lst ) ) ) ) (reverse lst) ) L'utilisation de la fonction (getPrintFormat) est simple : elle requiert un seul argument correspondant au nom de la présentation. Pour cela tu peux l'essayer via (getPrintFormat (getvar "CTAB")) en étant sur une présentation (autre que "Model" bien que chat fonctionne...). Bisous, Luna

Coucou, J'avoue ne pas bien comprendre la demande...Est-ce que tu parles du format d'impression (Format de papier, depuis le gestionnaire de mise en page de la présentation) ? Si c'est de cela dont tu parles, alors vouih c'est une donnée récupérable mais isolée la valeur souhaitée ne sera pas une mince affaire... Une explication plus claire serait la bienvenue :3 Bisous, Luna

Pas tout-à-fait ^^" La variable TEXTSIZE correspond bel et bien à ce que tu recherches je suppose (un texte nouvellement créé aura une hauteur par défaut correpondant à TEXTSIZE). Ce que je disais c'est que la propriété TextHeight n'est applicable que pour un objet précis, sans impacter les nouveaux par exemple. En revanche (gile) parle de la propriété "fixe" de chaque style de texte. L'aide AutoCAD défini que cette propriété, si elle vaut 0.0, est égale à la variable TEXTSIZE, mais si cette valeur est non nulle, alors chaque texte créé à partir de ce style de texte précis (Arial, Verdana, etc...) aura la hauteur fixe définie. Auquel cas, la valeur de TEXTSIZE est ignorée. J'avais oublié que les styles sont défini dans la Symbol Table "STYLE", donc chaque style est défini par une liste DXF (ci-dessous l'aide d'AutoCAD) : Donc (gile) t'a donné l'accès à cette propriété en VBA, et si on regarde le tableau ci-dessus, on peut également dire que cette propriété est accessible au code 40 concernant le Style souhaité. L'exemple ci-dessous correspond à la version LISP concernant la propriété de hauteur fixe : Commande: (setq arial (tblsearch "STYLE" "Arial")) ((0 . "STYLE") (2 . "arial") (70 . 0) (40 . 0.0) (41 . 0.99) (50 . 0.0) (71 . 0) (42 . 1.0) (3 . "arial.ttf") (4 . "")) Commande: (setq arial (subst (cons 40 0.4) (assoc 40 arial) arial)) ((0 . "STYLE") (2 . "arial") (70 . 0) (40 . 0.4) (41 . 0.99) (50 . 0.0) (71 . 0) (42 . 1.0) (3 . "arial.ttf") (4 . "")) Commande: (entmod arial) ((0 . "STYLE") (2 . "arial") (70 . 0) (40 . 0.4) (41 . 0.99) (50 . 0.0) (71 . 0) (42 . 1.0) (3 . "arial.ttf") (4 . "")) Bref, (gile) t'as donné les 2 solutions VBA, à voir laquelle correspond le mieux à ta demande :3 Bisous, Luna

C'est des propriétés et méthodes utilisées en VBA, mais qui utilise la structure de langage de l'AutoLISP, donc (function_name arg1 arg2 ... argn). Donc cela permet d'accéder "autrement" à certaines propriétés accessibles en DXF et à d'autres propriétés donc cela permet "d'apprendre" le vocabulaire du VBA, sans pour autant nous apprendre la conjugaison et la grammaire du VBA ^^" Pour la comparaison, c'est comme si tu essayais d'apprendre le dictionnaire comme premier langage, tu connais peut-être plein de mots, mais tu n'as aucune idée de comment les utiliser et construire des phrases avec, du coup tu ne sais pas parler :3 Un peu comme "Je s'appelle Groot" mais en VBA xD Bisous, Luna

Et bien depuis que j'ai compris qu'un sommet de polyligne correspondait à la position du sommet au sein de la polyligne (valeur entière) avec le premier sommet = 0, j'ai compris que le paramètre correspondait à une répartition. Si l'on prend les param 0 et 1 (donc le segment entre le premier et second sommet), on peut diviser le segment en pourcentage :3 Autrement dit 0+50% correspond à 50% de la distance linéaire séparant le param 0 et 1, donc le milieu du segment. Si l'on veut diviser chaque segments en 4 parties égales, il suffit de récupérer les points aux paramètres 0+25%, 0+50% et 0+75% :3 Pour la généralisation on prend n le numéro du sommet de la polyligne (0 pour le sommet de départ) : Coordonnées de la position de la poignée milieu du segment [n, (1+ n)] définies par (vlax-curve-getPointAtParam ename (+ n 0.5)) Division d'un segment [n, (1+ n)], avec i le nombre de divisions (= (type i) 'REAL) on a (setq c 0) (repeat (1- i) (setq c (+ c (/ 1 i))) (setq pt (vlax-curve-getPointAtParam ename (+ n c))) (setq pt-list (cons pt pt-list)) ) Cela simplifie beaucoup la compréhension et l'utilisation de ces Param, car on n'a pas à utiliser les fonctions (distance) et autres ;3 Bisous, Luna

@Curlygoth tu te lances dans le LISP ou c'est qu'une illusion ? xD

@didier, les fonctions (vlax-curve-*) fonctionnent parfaitement bien avec l'ename directement (et même plus rapidement), cela évite la conversion (vlax-ename->vla-object) :3 Sinon c'est en effet un belle méthode, je n'ai encore jamais utilisée la fonction (osnap), sûrement par manque de connaissance et de temps ^^" Bisous, Luna

Coucou, En passant la souris au dessus de cette case j’obtiens : Et dans l'aide d'AutoCAD concernant la fonction (vla-put-textheight) : Je suppose donc que cette fonction ne puisse pas redéfinir cette valeur directement mais uniquement modifier la hauteur d'un objet texte (dimensions, mtext, text) uniquement si cette fameuse variable est nulle... Peut-être que la variable TEXTSIZE y correspond ? Bisous, Luna

Coucou, Petite question comme chat mais, en utilisant les (vlax-curve-*) on peut déterminer le point du milieu de la courbe via le param (fix (+ n 0.5)) nan ? (setq name (car (entsel))) (setq n 0) (setq pt1 (vlax-curve-getPointAtParam name n)) (setq pt2 (vlax-curve-getPointAtParam name (1+ n))) (setq mia (vlax-curve-getPointAtParam name (+ n 0.5))) (setq cord (distance pt1 pt2)) (setq mil (polar pt1 (angle pt1 pt2) (/ cord 2.0))) (setq fle (distance mia mil)) (if (> (/ (setq a1i (angle pt1 mia)) pi) 1) (setq a1i (* (- 1) (rem a1i pi))) ) (setq a12 (angle pt1 pt2)) (cond ((< a1i a12) (setq bulge (/ fle (/ cord 2.0))) ) ((> a1i a12) (setq bulge (* (- 1) (/ fle (/ cord 2.0)))) ) ((= fle 0) (setq bulge 0) ) ) Pas testé mais cela fonctionne-t-il en passant par les (vlax-curve-*) ? Bisous, Luna

J'ai toujours voulu apprendre ce langage depuis que j'utilise Excel, mais je n'arrivais pas à me former en autodidacte (je ne comprenais pas grand chose aux cours et mes essais étaient infructueux) donc j'ai trouvé une licence pro qui avait plein de cours intéressant dont le VBA. Malheureusement le formateur pour le VBA était le pire de tous (de simples copier-coller de codes vieux de 40ans depuis un PDF mal organisé et une absence totale du prof pour répondre aux questions)... Du coup, ce prof m'a simplement fait détester un langage que j'aurais grandement aimé apprendre ! Et puis AutoLISP correspond un peu plus à ma logique pour le moment donc je ne me suis pas acharnée sur le VBA :3 Mais bon on s'égard un peu du site de didier ^^" Bisous, Luna

Coucou @didier, Je trouve cela génial que tu élargisses les horizons de ton site vers d'autres langages comme le VBA (chat va sûrement me réconcilier avec ce langage contre lequel je me suis fâchée il y a quelques années !). Je serais une lectrice assidue :3 Concernant la partie AutoLISP, je pense qu'un sujet intéressant et qui, malgré le fait qu'il s'agisse de la base des bases, se serait de parler des fonctions d'accessibilité aux différentes propriétés d'un objet. Je pense à la fonction (entget), (dumpallproperties) (et (vlax-dump-object) en Visual LISP) et surtout à l'utilisation que tout développeur devrait en faire, c'est à dire creuser par soi-même ^^" 75% des réponses données sur cadXP ne sont rien de plus qu'une autre personne ayant farfouillé dans la liste DXF, les propriétés ActiveX ou Visual d'un objet. Et je trouve cela dommage que l'on n'apprenne pas suffisamment à regarder par nous-même 🙂 Tu as déjà une page pour la fonction (entget) mais l'idée serait d'aller un peu plus loin, de montrer l'utilité réelle de la fonction (entget) notamment en expliquant le rôle des codes 330 et 360 (montée ou descente dans la hiérarchie DXF) et sur le fait que l'on puisse à partir d'une simple polyligne récupérer des information sur le dessin, etc... Et faire en sorte que les développeurs passent plus de temps dans AutoCAD à farfouiller les propriétés, avant de se tourner vers les forums :3 Bisous, Luna

Vui j'ai également connu et apprivoisé les bulges via ce cours, mais en effet il faut pratiquer un peu l'anglais :3 Le cours de didier est certainement plus abordable pour tout le monde 😜 Bisous, Luna

Une polyligne fermée n'est-elle pas justement une polyligne dont le sommet de début et le sommet de fin sont strictement identiques ? Auquel cas il me paraît plus que naturel de conserver ce dernier point dans la liste pour mieux illustrer les segments visibles de la polyligne. Ainsi fait, on peut travailler avec les segments si on le souhaite et pour cela, on a besoin du dernier sommet (même s'il s'agit du sommet de début) car on peut spécifier un bulge pour ce segment également... Ou alors je n'ai pas bien saisi ta remarque... >w< Bisous, Luna

vui légère différence ^^"

Coucou, C'était le but premier du challenge au final ^^" J'ai fait quelques tests dont voici les résultats : ;; BENCHMARK D'UNE LWPOLYLINE DE 10 SOMMETS Elapsed milliseconds / relative speed for 8192 iteration(s): (GET-PT-LIST-BRUNO NAME).....................1466 / 3.55 <fastest> (GET-PT-LIST-CURVE NAME).....................1560 / 3.34 (VLAX-CURVE-GETPOLYLINECOORDINATES N...).....1701 / 3.06 (VGETPOINT VNAME)............................1701 / 3.06 (GET-PT-LIST-RECURSIVE-MEMBER NAME)..........1747 / 2.98 (POLYPOINTS NAME)............................1763 / 2.96 (GET-PT-LIST-MEMBER NAME)....................1778 / 2.93 (GET-PT-LIST-NTH-RECURSIVE NAME).............1825 / 2.85 (GET-PT-LIST-RECURSIVE-COORDINATES V...).....1825 / 2.85 (GET-PT-LIST-REPEAT NAME)....................1919 / 2.71 (GET-PT-LIST-MAPCAR NAME)....................3183 / 1.64 (GET-PT-LIST-REMOVE NAME)....................3557 / 1.46 (GET-PT-LIST-SEARCH NAME)....................3572 / 1.46 (GET-PT-LIST-FOREACH NAME)...................3635 / 1.43 (GET-PT-LIST-BONUSCAD NAME)..................5101 / 1.02 (GET-PT-LIST-BRUNO VNAME)....................5210 / 1.00 <slowest> ;; BENCHMARK D'UNE LWPOLYLINE DE 100 SOMMETS Elapsed milliseconds / relative speed for 2048 iteration(s): (VGETPOINT VNAME)............................1107 / 5.19 <fastest> (GET-PT-LIST-BRUNO NAME).....................1217 / 4.72 (GET-PT-LIST-RECURSIVE-COORDINATES V...).....1232 / 4.66 (GET-PT-LIST-CURVE NAME).....................1389 / 4.13 (VLAX-CURVE-GETPOLYLINECOORDINATES N...).....1482 / 3.87 (GET-PT-LIST-MEMBER NAME)....................1498 / 3.83 (GET-PT-LIST-RECURSIVE-MEMBER NAME)..........1498 / 3.83 (POLYPOINTS NAME)............................1607 / 3.57 (GET-PT-LIST-NTH-RECURSIVE NAME).............1809 / 3.17 (GET-PT-LIST-REPEAT NAME)....................1825 / 3.15 (GET-PT-LIST-REMOVE NAME)....................2028 / 2.83 (GET-PT-LIST-MAPCAR NAME)....................2808 / 2.04 (GET-PT-LIST-FOREACH NAME)...................3790 / 1.51 (GET-PT-LIST-BRUNO VNAME)....................3868 / 1.48 (GET-PT-LIST-SEARCH NAME)....................4009 / 1.43 (GET-PT-LIST-BONUSCAD NAME)..................5741 / 1.00 <slowest> ;; BENCHMARK D'UNE LWPOLYLINE DE 1 000 SOMMETS Elapsed milliseconds / relative speed for 128 iteration(s): (GET-PT-LIST-RECURSIVE-COORDINATES V...)......1045 / 14.48 <fastest> (VGETPOINT VNAME).............................1061 / 14.26 (GET-PT-LIST-BRUNO NAME)......................1077 / 14.05 (VLAX-CURVE-GETPOLYLINECOORDINATES N...)......1248 / 12.13 (GET-PT-LIST-CURVE NAME)......................1295 / 11.68 (GET-PT-LIST-RECURSIVE-MEMBER NAME)...........1388 / 10.90 (GET-PT-LIST-MEMBER NAME).....................1435 / 10.54 (POLYPOINTS NAME).............................1513 / 10.00 (GET-PT-LIST-REMOVE NAME).....................1560 / 9.70 (GET-PT-LIST-REPEAT NAME).....................1654 / 9.15 (GET-PT-LIST-MAPCAR NAME).....................2684 / 5.64 (GET-PT-LIST-BRUNO VNAME).....................2730 / 5.54 (GET-PT-LIST-NTH-RECURSIVE NAME)..............3074 / 4.92 (GET-PT-LIST-FOREACH NAME)....................4290 / 3.53 (GET-PT-LIST-SEARCH NAME).....................4446 / 3.40 (GET-PT-LIST-BONUSCAD NAME)..................15132 / 1.00 <slowest> ;; BENCHMARK D'UNE LWPOLYLINE DE 10 000 SOMMETS Elapsed milliseconds / relative speed for 32 iteration(s): (VGETPOINT VNAME)..............................1372 / 230.03 <fastest> (GET-PT-LIST-RECURSIVE-COORDINATES V...).......1420 / 222.26 (GET-PT-LIST-BRUNO NAME).......................1591 / 198.37 (VLAX-CURVE-GETPOLYLINECOORDINATES N...).......1887 / 167.25 (GET-PT-LIST-CURVE NAME).......................1903 / 165.85 (POLYPOINTS NAME)..............................2138 / 147.62 (GET-PT-LIST-MEMBER NAME)......................2152 / 146.66 (GET-PT-LIST-RECURSIVE-MEMBER NAME)............2200 / 143.46 (GET-PT-LIST-REMOVE NAME)......................2464 / 128.09 (GET-PT-LIST-REPEAT NAME)......................2605 / 121.15 (GET-PT-LIST-MAPCAR NAME)......................3884 / 81.26 (GET-PT-LIST-FOREACH NAME).....................5429 / 58.13 (GET-PT-LIST-BRUNO VNAME)......................5679 / 55.57 (GET-PT-LIST-SEARCH NAME)......................5819 / 54.24 (GET-PT-LIST-NTH-RECURSIVE NAME)..............42682 / 7.39 (GET-PT-LIST-BONUSCAD NAME)..................315606 / 1.00 <slowest> Le plus étonnant c'est la différence d'efficacité entre l'utilisation de l'ename ou du VLA-Object sur les fonctions (vlax-curve-*) ! °o° Les durées pour la fonction proposée par BonusCAD me semble quelque peu exagéré mais bon... A savoir que les fonctions (vgetpoint) et (get-pt-list-recursive-coordinates) sont strictement les mêmes, pour le coup @Fraid on a pensé à la même chose ^^" La fonction (get-pt-list-recursive-member) correspond à la fonction (massoc) utilisant la fonction (member), à savoir que j'utilise personnellement la fonction (get-pt-list-member) qui correspond à la version itérative de (massoc) :3 Evidemment, les fonctions qui vérifie chaque paire DXF au lieu de "sauter" les paires inutiles semblent plus lentes (plus de passage dans la boucle ?). Les fonctions (vlax-curve-*) semblent plus rapides que la gestion de la liste DXF de l'entité et la propriété 'Coordinates semble également un peu plus rapide que les fonctions (vlax-curve-*), bien que se soit dommage que les coordonnées ne soient pas ranger 2 à 2 directement (cela éviterait la boucle et donc il existerait une fonction existante capable de renvoyer les coordonnées d'une polyligne directement). Voici les différentes versions que j'avais essayé au fil du temps (la fonction (get-pt-list-curve) est très récente, merci @Olivier Eckmann pour m'avoir appris la signification des paramètres pour les (vlax-curve-*) ! ♥) : (defun get-pt-list-curve (name / pt-list n) (repeat (fix (setq n (1+ (vlax-curve-getEndParam name)))) (setq pt-list (cons (vlax-curve-getPointAtParam name (setq n (1- n))) pt-list ) ) ) pt-list ) (defun get-pt-list-member (name / pt-list entlist) (setq entlist (entget name)) (while (setq entlist (member (assoc 10 entlist) entlist)) (setq pt-list (cons (cdar entlist) pt-list) entlist (cdr entlist) ) ) (reverse pt-list) ) (defun get-pt-list-recursive-member (name / f entlist) (defun f (entlist) (if (setq entlist (member (assoc 10 entlist) entlist)) (cons (cdar entlist) (f (cdr entlist))) ) ) (f (entget name)) ) (defun get-pt-list-search (name / pt-list entlist) (setq entlist (entget name)) (while entlist (if (= (caar entlist) 10) (setq pt-list (cons (cdar entlist) pt-list)) ) (setq entlist (cdr entlist)) ) (reverse pt-list) ) (defun get-pt-list-repeat (name / pt-list entlist) (repeat (cdr (assoc 90 (setq entlist (entget name)))) (setq entlist (member (assoc 10 entlist) entlist) pt-list (cons (cdar entlist) pt-list) entlist (cdr entlist) ) ) (reverse pt-list) ) (defun get-pt-list-remove (name / pt-list) (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget name) ) ) ) (defun get-pt-list-mapcar (name / pt-list) (vl-remove nil (mapcar '(lambda (x) (if (= (car x) 10) (cdr x)) ) (entget name) ) ) ) (defun get-pt-list-nth-recursive (name / f) (defun f (lst i / x) (if (= (car (setq x (nth i lst))) 10) (cons (cdr x) (f lst (+ i 5))) ) ) (setq entlist (entget name)) (f entlist (vl-position (assoc 10 entlist) entlist)) ) (defun get-pt-list-recursive-coordinates (vname / f) (defun f (lst) (if lst (cons (list (car lst) (cadr lst)) (f (cddr lst))) ) ) (f (vlax-get vname 'coordinates)) ) Bisous, Luna

Coucou, Tout dépend de l'utilisation qu'on veut en faire. D'autant plus que si l'on travaille sur des polylignes courbées, je pense qu'il est plus simple de passer par les fonctions (vlax-curve-*) qui sont moins lourdes et ne nécessite pas d'utilisation de listes complexes :3 Mais il est vrai que j'ai trouvé le sujet des bulges de polylignes très intéressant et instructifs surtout ! Bisous, Luna

J'ai justement publié ma fonction (explore-dxf) ici. :S (bon j'ai remarqué que j'ai mal géré la numération lors de la récursivité rétrograde mais ce ne sont que des nombres donc chat ne change pas grand chose à l'extract ^^") Il y a la possibilité d'extraire les listes DXF dans un fichier .txt si on a besoin de creuser un peu loin (cela prend beaucoup moins de temps sur le fichier .txt plutôt que l'historique de commande, limité en nombre de lignes en plus) ! Bisous, Luna

Coucou, Explore DXF in progress from "HATCH" (<Nom d'entité: 2275b458d50>) : | (-1 . <Nom d'entité: 2275b458d50>) | (0 . "HATCH") | (330 . <Nom d'entité: 2275b4659f0>) | (5 . "215") | (100 . "AcDbEntity") | (67 . 0) | (410 . "Model") | (8 . "0") | (62 . 1) | (440 . 33554559) | (100 . "AcDbHatch") | (10 0.0 0.0 0.0) | (210 0.0 0.0 1.0) | (2 . "SOLID") | (70 . 1) | (71 . 1) | (91 . 1) | (92 . 1) | (93 . 5) | (72 . 1) | (10 -762.847 1382.57 0.0) | (11 -1019.02 993.801 0.0) | (72 . 1) | (10 -1019.02 993.801 0.0) | (11 -905.163 639.804 0.0) | (72 . 1) | (10 -905.163 639.804 0.0) | (11 -247.347 981.158 0.0) | (72 . 1) | (10 -247.347 981.158 0.0) | (11 91.0483 1448.94 0.0) | (72 . 1) | (10 91.0483 1448.94 0.0) | (11 -762.847 1382.57 0.0) | (97 . 1) | (330 . <Nom d'entité: 2275b458d20>) | (75 . 1) | (76 . 1) | (98 . 1) | (10 0.0 0.0 0.0) | (450 . 0) | (451 . 0) | (460 . 0.0) | (461 . 0.0) | (452 . 0) | (462 . 1.0) | (453 . 2) | (463 . 0.0) | (63 . 5) | (421 . 255) | (463 . 1.0) | (63 . 2) | (421 . 16776960) | (470 . "LINEAR") | 1. "BLOCK_RECORD" (<Nom d'entité: 2275b4659f0>) at 330 code, from "HATCH" object : | (-1 . <Nom d'entité: 2275b4659f0>) | (0 . "BLOCK_RECORD") | (5 . "1F") | (102 . "{ACAD_XDICTIONARY") | (360 . <Nom d'entité: 2275b45ff50>) | (102 . "}") | (330 . <Nom d'entité: 2275b465810>) | (100 . "AcDbSymbolTableRecord") | (100 . "AcDbBlockTableRecord") | (2 . "*Model_Space") | (360 . <Nom d'entité: 2275b465a00>) | (340 . <Nom d'entité: 2275b465a20>) | (70 . 0) | (280 . 1) | (281 . 0) | 2. "LWPOLYLINE" (<Nom d'entité: 2275b458d20>) at 330 code, from "HATCH" object : | (-1 . <Nom d'entité: 2275b458d20>) | (0 . "LWPOLYLINE") | (5 . "212") | (102 . "{ACAD_REACTORS") | (330 . <Nom d'entité: 2275b458d50>) | (102 . "}") | (330 . <Nom d'entité: 2275b4659f0>) | (100 . "AcDbEntity") | (67 . 0) | (410 . "Model") | (8 . "0") | (100 . "AcDbPolyline") | (90 . 5) | (70 . 1) | (43 . 0.0) | (38 . 0.0) | (39 . 0.0) | (10 -762.847 1382.57) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 -1019.02 993.801) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 -905.163 639.804) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 -247.347 981.158) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 91.0483 1448.94) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (210 0.0 0.0 1.0) | End of exploration... L'associativité se situe au second code 330 de ta hachure, et au code 330 de ton objet associatif situé entre les borne (102 . "{ACAD_REACTORS") Explore DXF in progress from "LWPOLYLINE" (<Nom d'entité: 2275b458d20>) : | (-1 . <Nom d'entité: 2275b458d20>) | (0 . "LWPOLYLINE") | (5 . "212") | (102 . "{ACAD_REACTORS") | (330 . <Nom d'entité: 2275b458d50>) | (102 . "}") | (330 . <Nom d'entité: 2275b4659f0>) | (100 . "AcDbEntity") | (67 . 0) | (410 . "Model") | (8 . "0") | (100 . "AcDbPolyline") | (90 . 5) | (70 . 1) | (43 . 0.0) | (38 . 0.0) | (39 . 0.0) | (10 -762.847 1382.57) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 -1019.02 993.801) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 -905.163 639.804) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 -247.347 981.158) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (10 91.0483 1448.94) | (40 . 0.0) | (41 . 0.0) | (42 . 0.0) | (91 . 0) | (210 0.0 0.0 1.0) | 1. "HATCH" (<Nom d'entité: 2275b458d50>) at 330 code, from "LWPOLYLINE" object : | (-1 . <Nom d'entité: 2275b458d50>) | (0 . "HATCH") | (330 . <Nom d'entité: 2275b4659f0>) | (5 . "215") | (100 . "AcDbEntity") | (67 . 0) | (410 . "Model") | (8 . "0") | (62 . 1) | (440 . 33554559) | (100 . "AcDbHatch") | (10 0.0 0.0 0.0) | (210 0.0 0.0 1.0) | (2 . "SOLID") | (70 . 1) | (71 . 1) | (91 . 1) | (92 . 1) | (93 . 5) | (72 . 1) | (10 -762.847 1382.57 0.0) | (11 -1019.02 993.801 0.0) | (72 . 1) | (10 -1019.02 993.801 0.0) | (11 -905.163 639.804 0.0) | (72 . 1) | (10 -905.163 639.804 0.0) | (11 -247.347 981.158 0.0) | (72 . 1) | (10 -247.347 981.158 0.0) | (11 91.0483 1448.94 0.0) | (72 . 1) | (10 91.0483 1448.94 0.0) | (11 -762.847 1382.57 0.0) | (97 . 1) | (330 . <Nom d'entité: 2275b458d20>) | (75 . 1) | (76 . 1) | (98 . 1) | (10 0.0 0.0 0.0) | (450 . 0) | (451 . 0) | (460 . 0.0) | (461 . 0.0) | (452 . 0) | (462 . 1.0) | (453 . 2) | (463 . 0.0) | (63 . 5) | (421 . 255) | (463 . 1.0) | (63 . 2) | (421 . 16776960) | (470 . "LINEAR") | 2. "BLOCK_RECORD" (<Nom d'entité: 2275b4659f0>) at 330 code, from "LWPOLYLINE" object : | (-1 . <Nom d'entité: 2275b4659f0>) | (0 . "BLOCK_RECORD") | (5 . "1F") | (102 . "{ACAD_XDICTIONARY") | (360 . <Nom d'entité: 2275b45ff50>) | (102 . "}") | (330 . <Nom d'entité: 2275b465810>) | (100 . "AcDbSymbolTableRecord") | (100 . "AcDbBlockTableRecord") | (2 . "*Model_Space") | (360 . <Nom d'entité: 2275b465a00>) | (340 . <Nom d'entité: 2275b465a20>) | (70 . 0) | (280 . 1) | (281 . 0) | End of exploration... Bisous, Luna

vui je sais, c'est pour cela que j'ai précisé que c'était pour la fonction (dec->Transparency) et non l'inverse, autrement on récupère la valeur DXF pour la convertir en valeur de transparence connue par l'utilisateur :3 Bisous, Luna

Vui en effet je pensais avoir clarifier ce point ^^" Donc dans l'idée il faut une fonction avec un seul argument correspondant à l'ename ou vla-object de la polyligne et le retour doit être sous forme de liste de point : ( (X1 Y1) (X2 Y2) ... (Xn-1 Yn-1) (Xn Yn) )avec n le nombre de sommets, l'indice 1 correspondant au point de départ de la polyligne, l'indice n correspondant au point d'arrivée de la polyligne. La sélection de la polyligne sera donc fait en amont par le biais d'une variable pour tester :3 En effet, le but de ce challenge c'est d'essayer de trouver plusieurs façons de faire en cherchant à approfondir les recherches au maximum. Chacun de nous à une manière de penser qui nous est propre (méthode itérative ou récursive par exemple), des fonctions de prédilection, etc. Donc ici le but étant de sortir des sentiers battus justement pour forcer les développeurs à se renseigner sur d'autres fonctions qu'ils n'ont pas l'habitude d'utiliser, de chercher les optimisations pour limiter les boucles, etc. Donc quoi de mieux pour cela que de prendre une fonction très simple qui permet un nombre d'alternatives très important ! Bien trop souvent on a nos habitudes de langage et on reste dans notre zone de confort, j'aimerais juste en sortir de cette zone pour apprendre différentes logiques, fonctions, réflexions, ... Après je me pose tout de même la question si en terme de retour on ne peut pas élargir un peu les possibilités comme des SafeArray (certains programmes, selon qu'ils soient en AutoLISP vanilla, en Visual LISP ou même VBA ne gèrent pas les listes de la même manières) donc il se peut que pour un programme en Visual, la conversion d'un SafeArray en liste pour ensuite convertir cette liste en SafeArray pour continuer un autre programme ne fasse pas grand sens... >w< Donc en résumé on va dire : (defun func_name (ObjName / ...) ... ) command: (setq name (car (entsel))) ; ou (vlax-ename->vla-object (car (entsel))) command: (func_name name) ((12.4 584.5) (123.8 1.7) (12.8 967.4)) ; ou #<safearray...> équivalent à (vlax-safearray->list #<safearray...>) = ((12.4 584.5) (123.8 1.7) (12.8 967.4)) Bisous, Luna