(gile)

Là encore, il faut bien l'exécuter ce code malicieux qui va modifier acad20XXdoc.lsp ou la base de registre...

Merci Olivier de rappeler la possibilité d'utiliser les fichiers .lsp à chargement automatique (méthode utilisée au début des années 2010 (voir ici par exemple). Mais là encore, un fichier .lsp, .fas, .vlx ou mnl inconnu devrait toujours inspirer une certaine méfiance (a fortiori s'il s'appelle AutoCAD, acaddoc, acad20XX, ou acad20XXdoc).

Salut, Petit rappel : le meilleur anti-virus se situe entre nos deux oreilles. Une règle de base consiste à ne jamais ouvrir des pièces jointes si on n'est pas certain de leur provenance, ne jamais charger du code compilé (.fas, .vlx, .dll, .arx) dont on n'est pas sûr de la provenance et pour le code non compilé (.lsp) dont on n'est pas sûr de la provenance, il vaut mieux le lire avant de le charger. Toutefois, je me souviens que Luis Esquivel avait montré sur TheSwamp comment un code LISP compilé en VLX dans un espace de nom différent pouvait s'exécuter automatiquement à l'ouverture d'un DWG qui serait dans le même répertoire que le VLX (voir ici). Ceci dit, je trouve cet article un peu "léger" : je doute un peu de l'utilisation d'AutoLISP (même complîlé en .fas ou .vlx) à des fins d'espionnage industriel (à ce niveau, il existe des technologies tellement plus puissantes). Et la lecture des commentaires qu'il suscite montrent le niveau de connaissance et de réflexion de ceux qui fréquente ce blog. Mais, on trouve de tout sur internet, et même parfois des choses vraies...

Salut, On dirait que vous n'avez pas trop cherché... (defun c:zel (/ ctab vp) (or *acad* (setq *acad* (vlax-get-acad-object))) (or *acdoc* (setq *acdoc* (vla-get-ActiveDocument *acad*))) (setq ctab (getvar 'ctab)) (vlax-for layout (vla-get-Layouts *acdoc*) (if (/= (vla-get-Name layout) "Model") (progn (vla-put-ActiveLayout *acdoc* layout) (vla-ZoomExtents *acad*) ) ) ) (setvar 'ctab ctab) (princ) )

Salut, Tu peux essayer le LISP Soustrac.lsp sur cette page qui effectue une soustraction de régions ou solides 3d sans faire d'union et propose de conserver les objets soustraits.

@PHILPHIL, si tu lis attentivement mon message, le problème n'est pas tant les expressions inutiles qui ne font qu'alourdir le code (et son exécution) que le fait que tu modifies des variables système : par exemple, exécuter ta routine désactive tous les accrochages aux objets, certes ça ne plante pas AutoCAD mais ce n'est pas vraiment ce qu'est censé faire la routine.

@PHILPHIL, Juste une remarque en passant, au début de ton code tu fais : (setvar "cmdecho" 0) (setvar "dimzin" 0) (setvar "osmode" 0) Ce qui semble être une habitude (voire un tic) puisque dans la suite du code il n'y a aucun appel à (command ...) qui justifierait de toucher à CMDECHO ni aucune instruction qui pourrait interagir avec OSMODE. Ça pourrait être juste inutile si tu remettais les variables à leur valeur initiale, mais ce n'est pas le cas, là tu modifies l'environnement de ceux qui utiliseront ta routine et qui s'étonneront par la suite que des variables système "sautent". En règle générale, en programmation, on évite de faire des choses inutiles, mais surtout, quand on modifie l'environnement uniquement pour les besoins de l'exécution de la routine, on s'assure que l'environnement initial est bien restauré, et ce, quoi qu'il advienne. Donc, la bonne habitude ce n'est pas de systématiquement désactiver les accrochages aux objets ou l'écho des invites de commande, mais bien d'avoir une gestion d'erreur qui garantisse que l'environnement initial sera restauré même si une erreur intervient ou que l'utilisateur fait Ecahp (ce qui est traité comme erreur par AutoCAD).

L'essentiel du langage LISP (tous dialectes confondus) est régit par trois règles : un programme LISP est une liste d'expressions ; une expression peut être un atome ou une liste d'expressions (récursion) ; un atome est soit : un nombre, un nom, une chaîne de caractères, un opérateur. Donc, comme dit plus haut, un minimum de rigueur est nécessaire pour se faire comprendre par des humains (ceux à qui tu demandes de l'aide) et a fortiori par une machine. Le vocabulaire est la base de cette rigueur, et pour moi, l'orthographe importe aussi. À partir d'un certain nombre de fautes, je décroche.

Salut, On peut aussi le faire avec substr. Le setq est inutile, une fonction LISP renvoie toujours le résultat de la dernière évaluation. (defun cut (pat str) (substr str 1 (vl-string-search pat str)) )

Je crains que si... En tout cas, personnellement, je n'ai rien compris. Je pense que si on n'arrive pas à exprimer clairement un problème dans sa langue maternelle, on aura beaucoup plus de mal à le transcrire dans un langage de programmation. Je te recommande (re)lire attentivement ce sujet (au moins les premières réponses) et d'essayer de poser correctement ton problème avec ce qui permet de "parler" à une machine, à savoir : de la rigueur et de la logique.

Salut, Tu devrais pouvoir t'inspirer de Pline_Block.

Salut, Il m'arrive toujours de tracer des épures à l'échelle 1, directement sur le plancher, si mes genoux me le permettent encore...

Salut, D'abord, il faut essayer d'être précis : on ne peut pas créer de variables système avec setvar, on peut créer des variables d'environnement avec setenv. Pour retrouver ces variables, tu peux utiliser la fonction vlax-user-product-key qui retourne la clé du registre dans HKEY_CURRENT_USER (pour les plus vieilles versions d'AutoCAD la fonction était vlax-product-key). (strcat "HKEY_CURRENT_USER\\" (vlax-user-product-key) "\\FixedProfile\\General") Mais dans la mesure où tu vas devoir utiliser vl-registry-delete avec ce chemin, pourquoi ne pas carrément t'affranchir des fonctions setenv et getenv ainsi que des versions d'AutoCAD et créer tes propres clés dans le registre avec les fonctions vl-registry-* ? Tu peux stocker le chemin dans une variable globale ou dans une fonction : (setq *aleck-product-key* "HKEY_CURRENT_USER\\Software\\Aleck\\AutoLISP\\Variables") ou (defun aleck-product-key () "HKEY_CURRENT_USER\\Software\\Aleck\\AutoLISP\\Variables") Et ensuite, pour écrire la valeur "42" dans la variable "var1" : (vl-registry-write (aleck-product-key) "var1" "42") pour lire la variable "var1" : (vl-registry-read (aleck-product-key) "var1") pour supprimer la variable "var1" : (vl-registry-delete (aleck-product-key) "var1") pour supprimer tout le contenu de la clé : (vl-registry-delete (aleck-product-key))

Salut, Les points dans les variables EXTMAX et EXTMIN sont toujours définis en coordonnées générales (SCG) les fonctions LISP qui utilisent l'éditeur (command, getpoint, etc.) utilisent les coordonnées du SCU courant. Il faut donc que tu convertisse le point renvoyé par (getvar 'extmax) en coordonnées SCU avec la fonction trans pour le passer à (command ...) (trans (getvar 'extmax) 0 1)

En LISP, comme dans les autres langages utilisant la programmation fonctionnelle que je connais, les fonctions sont des objets dit "de première classe" ce qui signifie qu'on peut les manipuler comme tous les types de base (entiers, réels, chaînes, etc.). Par exemple, on peut les passer en argument d'une autre fonction (dite "d'ordre supérieur"), les définir ou les annihiler avec setq exactement comme une "variable". En F# (ou Ocaml) par exemple, il n'y a qu'une seule fonction : let pour assigner une valeur à un symbole, cette valeur peut aussi bien être un type primitif ou une fonction (let est à la fois équivalent à setq et à defun). Donc pour les fonctions, comme pour les "variables", je trouve plus pertinent de parler de fonctions locales ou globales suivant que leur portée est limitée à une autre fonction ou pas. (defun foo (arg ...) ...) ; fonction globale (defun c:cmd (/ bar ...) ...) ; commande définie en LISP (fonction globale) (defun bar (arg ...) ...) ; fonction locale à c:cmd (foo ...) (bar ...) )

Salut, Question vocabulaire, en LISP (langage fonctionnel), une fonction stricto sensu c'est aussi bien : c:foo dans (defun c:foo ...), bar dans (defun bar ...), lambda, defun, car, ... La première est une fonction qui définit une commande (FOO). La seconde est une fonction définie par l'utilisateur. Les autres sont des fonctions prédéfinies. Mais à proprement parler, il n'existe pas de "sous-fonction". En informatique, une routine (un anglicisme, il me semble) désigne une fonction (une procédure) qui fait partie d'un programme plus large. En LISP, c'est typiquement une fonction définie par l'utilisateur du type : (defun bar ([args...]) ...) parfois appelée "sous-routine" (ce qui est un pléonasme) ou (improprement) "sous-fonction".

Comme les parallèles à la bissectrice peuvent servir à définir à la fois l'arc sur le quels sont situés les points d'inflexion et le segment de droite sur lequel sont les milieux, j'ai essayé de faire une vidéo décrivant la méthode qui me semble la plus simple en utilisant le LISP Bsc_Med_Per_Tan.lsp.

Bien vu ;)

Salut, J'ai la prétention de penser que je ne suis pas trop mauvais en géométrie (et en traçage) mais là, j'avoue avoir eu du mal. J'ai finalement réussi par trouver une méthode. On commence par tracer le raccordement avec un premier rayon arbitraire (comme dans la méthode de lrdb@home). https://gilecad.azurewebsites.net/Resources/Doucine/doucine1.png On trace BE perpendiculaire à AB d'une longueur arbitraire, E sera le centre d'un des arcs. On trace CF perpendiculaire à CD de même longueur que BE. L'intersection du prolongement de CF avec la médiatrice du segment EF donne G le centre de l'autre arc, H est le point d'inflexion entre les deux arcs. https://gilecad.azurewebsites.net/Resources/Doucine/doucine2.png On trace l'arc BHC qui porte tous les points d’inflexion des raccordements par deux arcs (comme expliqué précédemment). https://gilecad.azurewebsites.net/Resources/Doucine/doucine3.png On définit des points M et N sur les perpendiculaires à AB et CD pour que les segments BM et CN soient de même longueur. On trace la droite reliant le milieu de MN et le milieu de BC. Quelle que soit la longueur y des segments BM et CN, le milieu de MN sera sur cette droite, c'est la deuxième condition qui doit être remplie pour nos arcs de rayons égaux. Le point K à l'intersection de l'arc et de cette droite est donc le point d'inflexion des deux arcs de raccordement de rayons égaux. https://gilecad.azurewebsites.net/Resources/Doucine/doucine4.png Les intersections des médiatrices des segments BK et CK avec les perpendiculaires à AB et CD donnent les centre I et J des arcs de raccordement de même rayon. PS: l'utilisation du LISP Bsc_Med_Per_Tan.lsp (sur cette page) pour tracer les perpendiculaires, bissectrices et médiatrices est fortement recommandé.

Salut, Pour ajouter à ce qu'a dit bonuscad, dans le initget, on ne met que les "mots clé" à savoir un seul mot par "mot clé"; mais dans l'invite, on peut mettre des espaces et/ou des tirets bas. La valeur retournée par getkword est le "mot clé" D'autre part, si on ne spécifie pas le bit 1 dans le initget (pour refuser que l'utilisateur fasse Entrée), il est préférable de spécifier une option par défaut. (initget "Parent Numero Etudes 4 5") (setq chn_setq_getkword (getkword "\nQuel dossier ouvrir [Parent/Numero dossier/Etudes/test 4/test 5] <Parent>: ")) (cond ((= chn_setq_getkword "Numero") (alert "Numero") ) ((= chn_setq_getkword "Etudes") (alert "Etudes") ) ((= chn_setq_getkword "4") (alert "4") ) ((= chn_setq_getkword "5") (alert "5") ) (T (alert "Parent")) )

Salut, Vite fait. (defun c:swapatt (/ getAtts tag1 tag2 ss i br) (defun getAtts (ent / elst atts) (while (= (cdr (assoc 0 (setq elst (entget (setq ent (entnext ent)))))) "ATTRIB") (setq atts (cons (cons (cdr (assoc 2 elst)) elst) atts)) ) ) (if (and (setq tag1 (strcase (getstring "\nEtiquette du premier attribut: "))) (setq tag2 (strcase (getstring "\nEtiquette du second attribut: "))) (setq ss (ssget '((0 . "INSERT") (66 . 1)))) ) (repeat (setq i (sslength ss)) (setq atts (getAtts (ssname ss (setq i (1- i))))) (if (and (setq att1 (cdr (assoc tag1 atts))) (setq att2 (cdr (assoc tag2 atts))) ) (progn (entmod (subst (assoc 1 att1) (assoc 1 att2) att2)) (entmod (subst (assoc 1 att2) (assoc 1 att1) att1)) ) ) ) ) (princ) )

"Avantage" je ne sais pas mais, contrairement à similarity, similartext renvoie les mêmes résultats que ceux de cette page. $ (setq s1 "PHP IS GREAT" s2 "WITH MYSQL") "WITH MYSQL" _$ (similarity s1 s2) 0.0833333 _$ (similarity s2 s1) 0.0833333 _$ (similartext s1 s2) (3 27.2727) _$ (similartext s2 s1) (2 18.1818)

Une implémentation AutoLISP de similar_text plus proche des exemples que j'ai trouvé. (defun similartext (str1 str2 / similarStr similarSum lst1 lst2) (defun similarStr (begin1 len1 begin2 len2 / pos1 pos2 len end1 end2 p q r pr qr isEqual) (setq pos1 begin1) (setq pos2 begin2) (setq len 0) (setq end1 (+ begin1 len1) end2 (+ begin2 len2) ) (setq p begin1) (repeat len1 (setq q begin2) (repeat len2 (setq r 0 pr p qr q isEqual T ) (while (and (< pr end1) (< qr end2) isEqual ) (if (= (nth pr lst1) (nth qr lst2)) (setq r (1+ r)) (setq isEqual nil) ) (setq pr (1+ pr) qr (1+ qr) ) ) (if (< len r) (progn (setq len r) (setq pos1 p) (setq pos2 q) ) ) (setq q (1+ q)) ) (setq p (1+ p)) ) (list pos1 pos2 len) ) (defun similarSum (begin1 len1 begin2 len2 / lst pos1 pos2 len sum e1 e2) (setq lst (similarStr begin1 len1 begin2 len2) pos1 (car lst) pos2 (cadr lst) len (caddr lst) ) (setq sum len) (if (/= sum 0) (progn (if (and (< begin1 pos1) (< begin2 pos2)) (setq sum (+ sum (similarSum begin1 (- pos1 begin1) begin2 (- pos2 begin2)))) ) (setq e1 (+ pos1 len) e2 (+ pos2 len) ) (if (and (< e1 (+ begin1 len1)) (< e2 (+ begin2 len2))) (setq sum (+ sum (similarSum e1 (+ len1 begin1 (- e1)) e2 (+ len2 begin2 (- e2))))) ) ) ) sum ) (setq lst1 (vl-string->list str1) len1 (length lst1) lst2 (vl-string->list str2) len2 (length lst2) ) (if (= 0 (+ len1 len2)) '(0 0.0) (list (setq similar (similarSum 0 len1 0 len2)) (/ (* similar 200.) (+ len1 len2)) ) ) )

J'ai pensé (comme dans les implémentations que j'ai trouvé) qu'il était préférable de tenir compte de la casse par défaut, ce qui laisse toujours la possibilité d'appeler la fonction avec les arguments passés en majuscules pour l'ignorer. (LevenshteinDistance (strcase str1) (strcase str2))

Pour similar_text, tu peux utiliser LevenshteinDistance : (defun Similarity (str1 str2) (- 1. (/ (float (LevenshteinDistance str1 str2)) (max (strlen str1) (strlen str2)))) )