(gile)

Le lien pour l'aide de la version 2019 (tu peux changer la version dans l'url) à mettre dans tes favoris : https://help.autodesk.com/view/OARX/2019/ENU/

Ça c'est ce que je recommande, surtout en phase de tests. On ouvre le fichier, on récupère les données et on referme le fichier. Si on traite les données dans la même boucle et qu'une erreur de se produit, la routine plante et le fichier reste ouvert.

@DenisHen La rubrique DXF Reference de l'aide aux développeurs est en français (et ce depuis que je connais AutoCAD). Il est bon de lire la rubrique DXF Format pour bien comprendre le reste de cette aide. Ensuite, les codes des entités graphiques sont dans la rubrique Entities Section, ceux des différentes tables (calques, types de ligne, styles de texte, etc.) dans Tables Sections. Et puis il faut expérimenter, tester, tester, et encore tester. On a la chance en LISP de pouvoir entrer des expressions LISP directement dans la ligne de commande ou, mieux, dans la console de l'éditeur Visual LISP. (entget (car (entsel))) renvoie la liste DXF de l'entité sélectionnée (entget (tblobjname "layer" "0") renvoie la liste DXF du calque "0" (remplacer "0" par un autre nom de calque du dessin. Dans l'éditeur, tu peux copier la liste renvoyée dans une nouvelle fenêtre pour la formater afin qu'elle soit plus facilement lisible. Pour connaître les codes de groupe indispensables à la fonction entmake, là encore il faut tester (ce ne sont pas toujours le mêmes suivant les objets). Encore un fois, teste par toi même en faisant : (entget (tblobjname "layer" nomDuCalque) avec des noms de calque ayant des épaisseurs de ligne différentes. C'est comme ça qu'on apprend et qu'on retient le mieux.

Un algorithme qui devrait pouvoir être implémenté en LISP : Concave hull: A k-nearest neighbours approach for the computation of the region occuppied by a set of points

INSUNITS gère l'échelle d'insertion des blocs dans le dessin pour les blocs qui ne sont pas définis "sans unité". Par exemple un bloc défini avec unité = centimètre inséré dans un dessin avec INSUNITS = 6 (mètre) aura un facteur d'unité de 0.01. De côté là ça semble OK. Si tu sélectionnes ton bloc et que tu ouvres la palette des propriétés, tu devrais avoir : Facteur d'unité = 0.01, mais que disent les champs Unité de bloc et Echelle X ? PS : INSUNITSDEFSOURCE et INSUNITSDEFTARGET servent pour mettre à l'échelle les blocs quand INSUNITS est égal à 0..

@Bortch59 Tu dis que ton bloc est défini en centimètres, mais quelles sont les valeurs des variables INSUNITS, INSUNITSDEFSOURCE et INSUNITSDEFTARGET ?

Je savais bien, voir ce message et le suivant.

Non, avec l'union des régions, il faut que les objets soient sécants. Cherche plutôt du côté de l'enveloppe convexe (convex hull). Une implémentation en .NET sur CADxp mais il me semble l'avoir aussi fait en LISP (peut-être sur TheSwamp)

Salut, J'ai déjà fait un truc dans ce genre en vlisp en créant des régions, puis en faisant une union de ces régions, puis une décomposition de la (ou des) région(s) résultantes. J'avais mal lu la demande. Tout ce que je peux te proposer comme piste mais qui ne répond pas vraiment à ta demande, c'est l'enveloppe convexe (convex hull).

parce que cons ne fait qu'ajouter un élément à une liste déjà existante en mémoire et que append (mal implémenté) reconstruit intégralement toutes les listes qui lui sont passées. _$ (setq l0 '(1 2 3)) (1 2 3) _$ (setq l1 (cons 0 l0)) (0 1 2 3) _$ (setq l2 (append '(0) l0)) (0 1 2 3) _$ (eq (cdr l1) l0) T _$ (eq (cdr l2) l0) nil La récursivité est incontournable quand on traite des structures récursives comme les arborescences (un répertoire est un dossier qui peut contenir des fichiers et des répertoires). Et si on ne l'utilise pas systématiquement, la comprendre est à mon avis indispensable pour comprendre intimement le LISP qui est un langage fondamentalement récursif : Un programme LISP est une liste d'expressions LISP Une expression LISP est soit un atome ; soit une liste d'expressions LISP. Idem pour les listes chainées en LISP (CF ce sujet).

Tes premières versions avec la "fonction lambda enveloppante" est vraiment très élégante. Personnellement, je n'ai pas trop cherché plus loin que ce premier jet (surtout depuis que tu as dit que ma solution était plus efficiente). Je me suis juste dit, dans un souci d'efficience : 1. éviter append (reverse ne cout vraiment pas cher), 2. ne faire le (eval fun) qu'une fois au début.

Il ne s'agit pas de "mon environnement". J'ai utilisé la palette 'Solarized" de Ethan Schoonover qui est très probablement la palette de couleurs avec thèmes clair et sombre pour éditeur de code pour laquelle la mise au point a été la plus minutieuse (6 mois de travail). Ceci dit, ce n'est peut-être pas la plus adaptée pour les sites web.

Je parlais d'autres environnements dans lesquels la couleur et la transparence sont exprimées en ARGB où A est le canal Alpha qui représente la transparence. De la même manière que pour le RGB, ça permet de stocker et de retrouver facilement 4 valeurs dans un seul nombre qu'on écrit le plus souvent en hexadécimal ce qui rend la décomposition entre les 4 canaux immédiatement visible : #80FF0000 est un rouge (R = 255, G = 0 B = 0) avec 50% de transparence (A = 128). La notation montrée dans le premier message, est appelé "notation en complément à 2". Elle est cohérente quand on utilise un nombre de bits déterminé (ici 32). Elle permet que l'addition d'un nombre positif et d'un nombre négatif soit juste parce qu'on ignore les dépassements (au delà du bit 31) 1 + -1 = 0 : 0 0 0 0 ... 0 0 0 1 + 1 1 1 1 ... 1 1 1 1 = 0 0 0 0 ... 0 0 0 0 En résumé, si on veut faire des opérations bit à bit sur les nombres, on utilise les fonctions décrites ci-dessus qui sont prévues pour ça. De ce côté là AutoLISP est aussi bien équipé que les autres langages de programmation. Essayer de transcrire en opérations arithmétiques sur les décimaux certaines des opérations bit à bit relèverait plus du challenge.

4. lsh La fonction lsh sert à décaler une valeur binaire vers la gauche ou vers la droite du nombre de bits spécifié. Décalage à gauche 5 ... 0 0 0 1 0 1 (5) (lsh 5 1) ... 0 0 1 0 1 0 (10) (lsh 5 3) ... 1 0 1 0 0 0 (40) Arithmétiquement parlant, ça consiste à multiplier le nombre par 2^x où x est le nombre de bits de décalage. Décalage à droite 11 0 0 1 0 1 1 (11) (lsh 11 -1) 0 0 0 1 0 1 (5) (lsh 11 -3) 0 0 0 0 0 1 (1) Arithmétiquement parlant, ça consiste à faire une division entière du nombre par 2^x où x est le nombre de bits de décalage. Les décalages peuvent servir à convertir les valeurs R, G et B des 'couleurs vraies' en un seul entier (celui utilisé par le groupe DXF 420) Chaque valeur RGB est comprise ente 0 et 255 soit 8 bits (un octet). En décalant vers la gauche le rouge (R) de 16 bits et le vert (G) de 8 bits, puis en faisant le OR logique de ces valeurs on obtient un entier unique sur 24 bits qui a conservé les 3 valeurs RGB (B du bit 0 au bit 7, G du bit 8 au bit 15 et R du bit 16 au bit 23). Il sera donc possible de faire la conversion inverse toujours avec des décalages. Conversion de RGB en entier : (defun rgb2int (r g b) (logior (lsh r 16) (lsh g 8) b) ) Dans l'autre sens, pour le R, il suffit de la décaler de 16 bits vers la droite pour retrouver la valeur, pour les autres, on décale d'abord l'entier vers la gauche de façon à placer les valeurs plus a gauche au delà du bit 31 afin de les éliminer. Puis on décale le résultat vers la droite jusqu'au bit 0. (defun int2rgb (i) (list (lsh i -16) (lsh (lsh i 16) -24) (lsh (lsh i 24) -24) ) ) Ou, peut-être de manière plus parlante, on fait un AND logique avec 255 et R décalé de 16 bits vers la droite, G décalé de 8 bits vers la droite et B sans décalage. (defun int2rgb (i) (list (logand 255 (lsh i -16)) (logand 255 (lsh i -8)) (logand 255 i) ) )

3. logand ,logior et exemples pratique Pour les opérations les plus courantes (AND et OR), AutoLISP fournit des fonctions qui remplacent la fonction boole. (logand x y) est équivalent à (boole 1 x y) (logior x y) est équivalent à (boole 7 x y) Dans la pratique, les codes binaires sont un moyen très efficient pour stocker des états au moyen de drapeaux (flags). Par exemple, AutoCAD utilise ces codes binaire pour stocker l'état des accrochages aux objet courant dans la variable système OSMODE. Chaque mode d'accrochage correspond à un code binaire (1, 2, 4, 8, ...). Si les accrochages actifs sont EXTrémité (1), MILieu (2) et INTersection (32), OSMODE vaut (1 + 2 + 32 = 35). Quand on veut modifier les accrochages, pour en ajouter ou en supprimer un par exemple, on ne peut pas se contenter d'additionner ou de soustraire le code binaire correspondant sans savoir si l'accrochage est déjà actif ou pas. Si je pense ajouter l'accrochage au MILieu par addition alors qu'il est déjà actif : (+ 35 2) -> 37 soit 32 + 4 + 1, j'ai en fait désactivé MILieu et activé CENtre On pourrait tester si un accrochage est actif (code binaire est présent) avant de l'ajouter (if (= (logand (getvar 'osmode) 2) 0) (setvar 'osmode (+ (getvar 'osmode) 2)) ) Mais avec la fonction logior, on peut activer un accrochage sans se soucier de savoir s'il est déjà actif. (setvar 'osmode (logior (getvar 'osmode) 2)) De même pour désactiver un accrochage, avec logand et l'opérateur ~ (tilde) on n'a pas à se soucier de savoir si l'accrochage est actif ou non. (setvar 'osmode (logand (getvar 'osmode) (~ 2))) AutoCAD utilise le code binaire 16384 pour désactiver les accrochages actifs sans avoir à modifier les autres valeurs. Pour désactiver les accrochages, on ajoute 16384 s'il n'est pas déjà présent, pour les réactiver on supprime ce code binaire. Avec l'opérateur logique XOR et ce code, on peut basculer entre accrochages actifs et inactifs (ce que fait la touche F3). (setvar 'osmode (boole 6 (getvar 'osmode) 16384))

2. boole C'est la fonction générale pour toutes les opérations 'bit à bit' (bitwise). Les opérations se font au niveau de chaque bit de même rang des nombres passé en argument. Le premier argument de la fonction boole est un entier entre 0 et 15 qui représente une des 16 opérations booléennes possible. Les arguments suivants sont les entiers à traiter 'bit à bit' (avec un seul entier, boole renvoie cet entier quel que soit l'opérateur). Avec 0 comme opérateur (premier argument) le résultat est toujours 0. Les opérateurs fondamentaux sont 1, 2, 4 et 8. les autres sont des combinaisons de ceux-ci. Pour une meilleur visibilité, dans les exemples suivants on ne traitera que deux entiers. S'il y en a plus, boole traite les deux premiers, puis les suivants avec le résultat précédent. L'opérateur 1 renvoie : 1, quand les bits du premier et du second nombre valent tous les deux 1 ; 0, dans tous les autres cas. C'est l'opérateur logique AND 0 1 0 1 (5) 0 1 1 0 (6) (boole 1 5 6) 0 1 0 0 (4) L'opérateur 2 renvoie : 1, si le bit du premier nombre vaut 1 et celui du second vaut 0 ; 0, dans tous les autres cas. 0 1 0 1 (5) 0 1 1 0 (6) (boole 2 5 6) 0 0 0 1 (1) L'opérateur 4 renvoie : 1, si le bit du premier nombre vaut 0 et celui du second vaut 1 ; 0, dans tous les autres cas. 0 1 0 1 (5) 0 1 1 0 (6) (boole 4 5 6) 0 0 1 0 (2) L'opérateur 8 renvoie : 1, quand les bits du premier et du second nombre valent tous les deux 0 ; 0, dans tous les autres cas. C'est l'opérateur logique NOT appliqué à deux nombres (ou plus). 0 ... 0 1 0 1 (5) 0 ... 0 1 1 0 (6) (boole 8 5 6) 1 ... 1 0 0 0 (-8) Les autres opérateurs sont des combinaisons de ceux ci dessus, dont les plus utilisés sont : L'opérateur 6 (combinaison des opérateurs 2 et 4) renvoie : 1, si le bit du premier nombre vaut 1 et celui du second vaut 0 ou si le bit du premier nombre vaut 0 et celui du second vaut 1 ; 0, dans tous les autres cas. C'est l'opérateur logique XOR (ou exclusif). 0 1 0 1 (5) 0 1 1 0 (6) (boole 6 5 6) 0 0 1 1 (3) L'opérateur 7 (combinaison des opérateurs 1, 2 et 4) renvoie : 1 si un des bits du premier ou du deuxième nombre vaut 1 ; 0, si les deux bits valent 0. C'est l'opérateur logique OR (ou inclusif). 0 1 0 1 (5) 0 1 1 0 (6) (boole 7 5 6) 0 1 1 1 (7)

1. ~ (tilde) Cette fonction renvoie le "complément à 1" d'un nombre (bitwise NOT). Autrement dit, elle inverse tous les bits (les 0 deviennent 1 et vice-versa) y compris le bit de poids fort, donc le signe. 5 0 0 ... 0 0 1 0 1 (5) (~ 5) 1 1 ... 1 1 0 1 0 (-6) L'équivalent arithmétique de : (~ n) serait : (- (* n -1) 1) On verra comment on peut l'utiliser dans la pratique plus bas.

Ce sujet s'adresse aux autres. Posons d'abord les bases. AutoLISP utilise des nombres entiers signés codés sur 32 bits. Ça signifie qu'un entier représenté par sa valeur binaire (en base 2) occupe 32 unités binaires (bits), chacune ayant une valeur de 1 ou 0. Le bit dit "de poids fort" ou bit 31 (le plus à gauche), sert à déterminer le signe : positif si égal à 0 ; négatif si égal à 1. Les nombres entiers sont donc compris entre -2^31 (-2147483648) et 2^31 - 1 (2147483647). 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -2147483648 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 -2147483647 ... 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 -3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 -2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 3 ... 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 2147483646 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2147483647 Cette représentation des nombres entiers (outre le fait que ce soit celle utilisée à bas niveau par les ordinateurs) permet de faciliter certaines opérations appelées "opérations de bit à bit" (bitwise en anglais), notamment les opérations de logique booléenne. AuotLISP fournit des fonctions pour ce type d'opérations : ~ (tilde), boole, logand, logior et lsh que je vais tâcher d'expliquer dans les messages suivants. EDIT : Une discussion récente m'a fait remarqué que j'avais oublié de citer les codes binaires dans certains groupes de code DXF et les filtres de sélection. J'ai donc ajouté un "chapitre".

Je mets la mienne : (defun cut-if-not (fun lst / loop) (defun loop (f l s a) (cond ((null l) (reverse a)) ((null (cdr l)) (reverse (cons (reverse (cons (car l) s)) a))) ((f (car l) (cadr l)) (loop f (cdr l) (cons (car l) s) a)) (T (loop f (cdr l) nil (cons (reverse (cons (car l) s)) a))) ) ) (loop (eval fun) lst nil nil) ) (defun cut-if (fun lst / loop) (defun loop (f l s a) (cond ((null l) (reverse a)) ((null (cdr l)) (reverse (cons (reverse (cons (car l) s)) a))) ((not (f (car l) (cadr l))) (loop f (cdr l) (cons (car l) s) a)) (T (loop f (cdr l) nil (cons (reverse (cons (car l) s)) a))) ) ) (loop (eval fun) lst nil nil) )

Salut, On peut désormais insérer des images par copier/coller ou glisser/déposer comme on ajoute des fichiers. C'est très bien. Dans l'ancienne version, pour insérer des images dans les messages, il fallait utiliser l'url de l'image avec des balises. Le problème c'est qu’aujourd’hui à la place de l'image dans le message on n'a plus que le texte du lien (exemple ici). J'ai essayé de corriger le message en modifiant le HTML (via le bouton Source) mais rien à faire, pas moyen d'afficher l'image. À défaut de restaurer toutes ces images (ce qui risque d'être complexe) pourrait-on retrouver un bouton d'insertion d'image acceptant une url, ce qui nous permettrait de réparer nous même certains messages.

Ma copie : (defun hex->dec (s / f) (defun f (l a / c) (if (setq c (car l)) (f (cdr l) (+ (cond ((< 96 c 103) (- c 87)) ((< 64 c 71) (- c 55)) ((< 47 c 58) (- c 48)) ) (lsh a 4) ) ) a ) ) (f (vl-string->list s) 0) ) (defun dec->hex (n) (cond ((< 15 n) (strcat (dec->hex (lsh n -4)) (dec->hex (rem n 16)))) ((< n 10) (itoa n)) (T (chr (+ n 55))) ) ) (defun urlEncode (url / f xpt) (defun f (l) (if l (strcat (cond ((or (< 47 (car l) 58) ; [0-9] (< 64 (car l) 91) ; [A-Z] (< 96 (car l) 123) ; [a-z] (member (car l) xpt) ; caractères spéciaux non encodés ) (chr (car l)) ) ((< (car l) 128) (strcat "%" (dec->hex (car l))) ) ((< (car l) 192) (strcat "%C2%" (dec->hex (car l))) ) ((< (car l) 256) (strcat "%C3%" (dec->hex (- (car l) 64))) ) ) (f (cdr l)) ) "" ) ) (setq xpt (vl-string->list "-_.!~*'()") ; JScript ;;(vl-string->list "-._~") ; the Internet Society ;;(vl-string->list "-_.!*()") ; .NET ) (f (vl-string->list url)) ) (defun urlDecode (url / f) (defun f (l) (cond ((null l) nil) ((= (car l) 37) ; "%" (cond ((and (= (cadr l) 67) ; "%C3" (= (caddr l) 51) ) (cons (+ 64 (hex->dec (strcat (chr (car (cddddr l))) (chr (cadr (cddddr l))) ) ) ) (f (cddr (cddddr l))) ) ) ((and (= (cadr l) 67) ; "%C2" (= (caddr l) 50) ) (cons (hex->dec (strcat (chr (car (cddddr l))) (chr (cadr (cddddr l))) ) ) (f (cddr (cddddr l))) ) ) (T (cons (hex->dec (strcat (chr (cadr l)) (chr (caddr l)) ) ) (f (cdddr l)) ) ) ) ) (T (cons (car l) (f (cdr l)))) ) ) (vl-list->string (f (vl-string->list url))) )

Ton problème ne vient pas ni de eval ni de lambda. Le message : "; erreur: type d'argument incorrect: numberp: nil" signifie qu'une fonction qui attend un nombre et reçoit nil.

Si, on peut l'écrire, mais ça donne une liste "normale", pas une paire pointée Essaye : (cdr '(0 . "CIRCLE")) et (cdr '(0 "CIRCLE"))

voir cette réponse, et plus loin dans le sujet une optimisation d'ElpanovEvgeniy que j'ai reprise.

Tu n'as pas lu assez attentivement l'article donné en lien. '(0 . "CIRCLE") n'est qu'une abréviation de (cons 0 "CIRCLE") '(10 50.0 80.0 0.0) n'est qu'une abréviation de (cons 10 (cons 50.0 (cons 80.0 (cons 0.0 nil))))