(gile)

Wikipédia est ton ami : Opération de bit à bit. Pour le couleurs, chaque valeur R, G ou B est codée sur un octet (8 bits) de 0 à 225 en décimal (ou de 00 à FF en hexadécimal), du bit0 au bit 7 pour le bleu du bit 8 au bit 15 pour le vert et du bit 16 au bit 23 pour le vert (les bits 24 à 31 étant réservés à la transparence)*. Avec les valeurs hexadécimales, comme un octet est représenté par deux caractères, on comprendra peut-être plus facilement à quoi correspond cet entier qui représente les couleurs RGB (le code DXF 420) et aussi pourquoi les couleurs sont représentées avec ces valeurs hexadécimales (en HTML par exemple). Si on considère une couleur dont le RGB est : (170, 187, 204), soit (AA, BB, CC) en hexadécimal (notée #AABBCC en HTML), le code DXF sera la valeur décimale de AABBCC ou 11189196 (soit AA0000 + BB00 + CC ou, plus rigoureusement : 00AA0000 | 0000BB00 | 000000CC (où | est le OR logique dans beaucoup de langages). 00AA0000 correspond au décalage de 16 bits à gauche de la valeur R (AA). 0000BB00 correspond au décalage de 8 bits à gauche de la valeur G (BB). 000000CC correspond à la valeur B (CC) qui n'est pas décalée. Soit, en LISP : (logior (lsh r 16) (lsh g 8) b) Dans l'autre sens, on a un entier 11189196 ou 00AABBCC. On trouve la valeur de R en décalant l'entier 00AABBCC de 16 bits à droite ce qui fait perdre les valeurs en deçà du bit 0 : 000000AA. En LISP : (lsh i -16) Pour les autres valeurs, on utilise le fait que, avec les entiers codés sur 32bits, si on décale à gauche, on perd les valeurs au delà du bit 31. En décalant à gauche de 16 bits la valeur 00AABBCC, on obtient : BBCC0000 qui décalé à droite de 24 bits donne : 000000BB. En LISP : (lsh (lsh i 16) -24) En décalant à gauche de 24 bits la valeur 00AABBCC, on obtient : CC000000 qui décalé à droite de 24 bits donne : 000000CC. En LISP : (lsh (lsh i 24) -24) * Attention, Microsoft, dans l'environnement OLE (Excel par exemple), utilise une notation inversée : BGR

As-tu essayé d'exécuter les expressions données dans la console de l'éditeur Visual LISP ? Ça devrait t'aider à comprendre. Les fonctions fondamentales (au sens littéral) concernant les listes en LISP sont : cons, car et cdr. Ces fonctions ont un fonctionnement cohérent avec les listes comme avec les paires pointées. cons sert à construire une liste ou une paire pointée (qui est une forme de liste particulière) (cons 0 "CIRCLE") ; -> (0 . "CIRCLE") (cons 10 '(5.0 8.0 0.0)) ; -> (10 5.0 8.0 0.0) car sert à obtenir le premier élément de la liste (ou paire pointée) (car '(10 5.0 8.0 0.0)) ; -> 10 (car '(0 . "CIRCLE")) ; -> 0 cdr sert à obtenir la liste (ou paire pointée) sans le premier élément (cdr '(10 5.0 8.0 0.0)) ; -> (5.0 8.0 0.0) (cdr '(0 . "CIRCLE")) ; -> "CIRCLE" De plus amples explications ici (au moins le premier message).

Salut, Tu as mis la barre un peu haut pour débuter avec entmake. Pour avoir la liste DXF d'un calque : (entget (tblobjname "layer" nomDuCalque)) Les codes DXF 1000 et plus sont réservés aux données étendues (xdata). pour avoir la liste DXF d'un calque avec toutes ses données étendues : (entget (tblobjname "layer" nomDuCalque) '("*")) Pour convertir les valeurs RGB (RVB en français) en un entier, il faut décaler la valeur R (rouge) de 16 bits vers la gauche et la valeur G (vert) de 8 bits vers la gauche : (defun rgb2int (r g b) (logior (lsh r 16) (lsh g 8) b) ) Pour la fonction inverse, on décale l'entier de 16 bits vers la droite pour récupérer le R et pour le G et le B on décale d'abord vers la gauche de 16 ou 24 bits pour supprimer les bits du R (et du V pour le bleu) puis on revient de 24 bits vers la droite. (defun int2rgb (i) (list (lsh i -16) (lsh (lsh i 16) -24) (lsh (lsh i 24) -24) ) )

Essaye : (cons 0 "CIRCLE") et (cons 10 '(5.0 8.0 0.0))

Comme je crains le pire avec un environnement sombre (et qu'il semble qu'une majorité en ce sens se dégage), j'ai voulu voir si c'était difficile de mettre en place la possibilité de basculer entre environnements clair et sombre. Et bien, ça ne semble pas bien compliqué, j'ai réussi avec quelques lignes de CSS et une pincée de JavaScript : voilà gileCAD recoloré avec la palette solarisé de Ethan Schoonover et la possibilité de basculer entre thème clair et sombre en un clic. Alors, quitte à changer le thème de couleurs, autant faire en sorte qu'on conserve le choix. Si j'y suis arrivé malgré que je sois une vraie quiche en matière de Design Web, ça ne devrait pas être insurmontable pour de vrais pros.

Je n'avais pas l'impression : Est-ce que les fonctions urlEncode et urlDecode définies dans le FAS attaché répondent à la demande ? J'attends pour poster le code . _$ (urlEncode "https://fr.wikipedia.org/wiki/Saint-Barthélemy-d'Anjou") "https://fr.wikipedia.org/wiki/Saint-Barth%C3%A9lemy-d'Anjou" _$ (urlDecode "https://fr.wikipedia.org/wiki/Saint-Barth%C3%A9lemy-d'Anjou") "https://fr.wikipedia.org/wiki/Saint-Barthélemy-d'Anjou" _$ (urlEncode "aB 09_éùl'o @£") "aB%2009_%C3%A9%C3%B9l'o%20@%C2%A3" _$ (urlDecode "aB%2009_%C3%A9%C3%B9l'o%20@%C2%A3") "aB 09_éùl'o @£" url_encode_decode.fas

Essaye avec une url complète. La fonction encodeURIComponent encode les ':' et '/' (%3A et %2F), la fonction encodeURI ne les encode pas.

encodeUriComponent encode les caractères réservés, encodeURI ne les encode pas. Regarde plus bas dans la page : Description

Si j'en crois la page donnée en lien :

Donc, il s'agit d'implémenter en AutoLISP l'équivalent de la fonction JavaScript encodeURI (et pas encodeURIComponent).

Salut, Si je ne me trompe pas, il y a une petite coquille dans l'exemple : "aB 09_éùl'o @£" -> "aB%2009_%C3%A9%C3%B9l'o%20%40%C2%A3" le résultat devrait plutôt être : "aB%2009_%C3%A9%C3%B9l%27o%20%40%C3%63" (encodage de l'apostrophe qui est un caractère réservé).

Ces challenges ne poussent pas toujours à prendre du recul ni à faire les choses sereinement. On a un peu tendance à se focaliser (parfois avec des œillères) sur le problème posé (surtout quand il est mal posé comme ici) et à vouloir y répondre vite (avant les autres) en privilégiant la concision, l'élégance, l'efficience. C'est le jeu, et je m'y suis laissé prendre avec plaisir plus souvent qu'à mon tour. Là j'ai le beau rôle en lançant ce challenge avec une réponse quasiment toute faite à partir de fonctions écrites depuis longtemps. Mais, si je peux me permettre de tirer "la morale de cette histoire" ça serait : 1. Quand on est face à un problème "complexe" il faut essayer de le décomposer en plusieurs problèmes plus simples (et plus facile à résoudre et à tester séparément). 2. Quand on résout un problème, essayer de généraliser la solution afin qu'elle puisse resservir pour d'autres problèmes (une fonction de groupage générique peut avoir de nombreuses autres utilités).

Veut dire qu'une fonction qui espérait un jeu de sélection en argument a reçu nil.

Les langages mieux lotis que le LISP pour traiter des données fournissent souvent une méthode de groupage des données (SQL, .NET avec Ling, F# avec les listes et séquences, ...). Ces méthodes permettent de grouper les données à l'aide d'une clé (souvent une propriété du type de donnée ou un champ dans une base de données). Comme je suis un gros paresseux (et que je répondais à une demande sur le forum .NET), c'est cette route que j'ai emprunté. Il ne restait plus qu'à trouver comment générer une clé de groupage pour des nombres : en arrondissant à la valeur de la tolérance. F# est, hormis AutoLISP, mon langage de prédilection pour prototyper. il existe une fonction native groupBy et une fonction round mais celle-ci arrondi à la valeur entière la plus proche. La méthode .NET System.Math.Round qui accepte en second argument un entier pour spécifier le nombre de décimale ne fait pas directement mon affaire. Qu'à cela ne tienne on écrit une petite fonction au multiple le plus proche. let roundTo multiple value = round (value / multiple) * multiple On utilise ensuite cette fonction pour grouper les points : let groupPointsByX tolerance (pts: Point2d list) = pts |> List.groupBy (fun p -> roundTo tolerance p.X) Si on veut grouper par X et Y, il suffit de modifier la fonction de groupage : let groupPointsByXY tolerance (pts: Point2d list) = pts |> List.groupBy (fun p -> roundTo tolerance p.X, roundTo tolerance p.Y) Vous pouvez tester tout ça sans rien installer avec Try F#. On va maintenant transcrire tout ça dans un langage moins confidentiel. AutoLISP ne fournit pas de fonction pour arrondir les nombres mais ça a été fait maintes fois (il me semble que ça avait l'objet d'un challenge il a quelque temps maintenant). De même, pour arrondir au multiple le plus proche rien de bien sorcier (CF ci-dessus). Reste la fonction de groupage. Avec AutoLISP pour grouper des valeurs en s'inspirant de ce qui se fait ailleurs, on utiliserait une liste d'association (le premier élément de chaque sous liste est la "clé"). Pour ne pas refaire le boulot à chaque fois, il peut-être intéressant de définir une fonction groupBy "générique" qui pourrait resservir dans dans d'autres cas. Cette fonction devra être une fonction dite "d'ordre supérieur" à savoir une fonction qui en prend une autre en argument (comme apply, mapcar, vl-remove-if, ...). En fait, tout ça existait déjà dans les bibliothèques MathGeom.lsp et List.lsp en bas de cette page. Donc je ne me suis pas foulé : ;; gc:round ;; Arrondit à la valeur entière la plus proche ;; ;; Arguments ;; num : le nombre à arrondir (defun gc:round (num) (if (minusp num) (fix (- num 0.5)) (fix (+ num 0.5)) ) ) ;; gc:roundTo ;; Arrondit au multiple de prec le plus proche ;; ;; Arguments ;; prec : le nombre spécifiant la précision de l'arrondi ;; num : le nombre à arrondir (defun gc:roundTo (prec num) (if (zerop (setq prec (abs prec))) num (* prec (gc:round (/ num prec))) ) ) ;; gc:groupBy ;; Regroupe les éléments d'une liste selon la clé générée par la fonction spécifiée. ;; Retourne un liste de sous listes dont le premier élément est la clé. ;; ;; Arguments ;; fun : la fonction génératrice de clé ;; lst : la liste (defun gc:groupBy (fun lst / f key sub res) (setq f (eval fun)) (foreach n lst (setq res (if (setq sub (assoc (setq key (f n)) res)) (subst (cons key (cons n (cdr sub))) sub res) (cons (list key n) res) ) ) ) ) Et ensuite : (defun grouperPointsParX (tol pts) (gc:groupBy '(lambda (p) (gc:roundTo tol (car p))) pts) ) (defun grouperPointsParXY (tol pts) (gc:groupBy '(lambda (p) (list (gc:roundTo tol (car p)) (gc:roundTo tol (cadr p))) ) pts ) ) Les listes renvoyées sont des listes d'association avec comme premier élément de chaque sous liste la valeur du multiple (ou de la paire de multiples), ce qui pourrait être utile pour des recherches ultérieures ou être facilement supprimé par un (mapcar 'cdr ...). ( (-10.0 (-6.6 4.7) (-13.6 7.5) (-6.3 14.2) (-14.3 14.3)) (0.0 (2.4 -4.9) (-1.9 -3.2) (4.8 0.7)) (10.0 (6.6 11.2) (9.3 4.7) (8.0 0.9) (14.4 4.7)) ) ( ((-10.0 10.0) (-13.6 7.5) (-6.3 14.2) (-14.3 14.3)) ((10.0 10.0) (6.6 11.2)) ((-10.0 0.0) (-6.6 4.7)) ((0.0 0.0) (2.4 -4.9) (-1.9 -3.2) (4.8 0.7)) ((10.0 0.0) (9.3 4.7) (8.0 0.9) (14.4 4.7)) )

Pourrais-tu préciser ce que tu cherches à faire parce que TextFinder fonctionne comme il faut sur W10. Tu dis avoir testé avec des dwg. Le problème vient certainement de là TextFinder est prévu pour rechercher dans des fichiers texte (.txt, .csv, .lsp, .cs, .html, ...).

Salut, Il ne faut pas confondre les raccourcis clavier (touches de fonction F1, F2, ... ou combinaisons de touches Ctrl+C, Ctrl+Maj+Esp...) qui n'ont pas besoin d'être validés et les alias qui ne sont "abréviations" des noms de commande et qui, comme le dit Fraid doivent être validé pour que le logiciel puisse faire la différence entre P (PAN), PO (POLYLIGNE), PAN etc. Mais on peut définir des raccourcis clavier via l'interface de personnalisation (commande IUP).

Désolé, je ne comprends pas de quoi tu parles. indique en général un problème d’appariement de parenthèses, bien faire attention quand on fait le copier coller.

@VDH-Bruno Bravo ! J'attends encore au moins jusqu'à ce soir pour poster ma copie.

Ah oui, en plus elle l'avait écrit quelques messages plus haut... J'ai les neurones rouillées, ça doit être l'age.

Oui, tu as raison. Je vais me coucher...

Là on s'éloigne carrément. L'idée de ce challenge m'est venue de cette demande sur le forum Autodesk .NET et j'ai repensé à ce challenge sur TheSwamp où qjchen, qui lance les hostilités avec une routine LISP qui traite 10000 points en 45 secondes arrivera à traiter ces mêmes points en 3.2 secondes toujours en LISP mais en implémentant un algorithme "divide and conqueer" qui utilise le groupement des points "par colonnes" (réponse #23), puis en 0.79 secondes en groupant les points dans un quadrillage (CF réponse #41). Il s'agirait donc bien de grouper les points par plages de 10 unités - soit dans des intervalles de ... [-15, -5[, [-5, 5[, [5, 15[ - soit en partant du plus petit X mais en respectant le pas de 10 : [-14.3, -4.3[, [-4.3, 4.3[, 4.3, 14.3[ ...

Salut, Ouvrir l'extrait de dessin en lien avec la commande RECUPERER corrige 12 erreurs, donc lancer la commande CONTROLE (_AUDIT) avec l'option corriger les erreurs = Oui devrait déjà résoudre certains problèmes. Passer en vue Avant et Sélectionner tout (Ctrl + A) permet de voir qu'il ne reste plus qu'une ligne de repère multiple à une altitude incongrue

Je suis vraiment désolé pour la confusion. Au départ, dans mon esprit, c'était un groupage par intervalles de 10 unités du type [-15, -5[, [-5, 5[, [5, 15[ ... Mais quand @Fraid a commencé du plus petit x, je me suis dit pourquoi pas, tant qu'on respecte un pas de 10 unités. En plus je trouvais intéressante l'idée de commencer par trier la liste. Je n'ai pas voulu fermer de porte, mais avec un groupage par la distance depuis le 1er point de chaque groupe, on n'a plus forcément un pas régulier. C'est exactement à ça que je pensais. On peut envisager de spécifier le pas via un argument (ou deux pour un pas différent en X et en Y).

Non, (14.4 4.7) est dans la plage [5.0, 15.0[

OK, au temps pour moi, j'ai mal posé l'énoncé. Ton algorithme fonctionne avec l’énoncé tel que posé dans le premier message. Quand je parlais d'une tolérance de 10 unités, je pensais les points dont la coordonnée X est dans une plage [n-5.0, n+5.0[, autrement grouper les points par colonnes de 10 unités de large, parce que pour la suite, j'envisageais un groupage par X et Y (quadrillage 10x10 ou nxn).