(gile)

Si la question est bien : Si angle est supérieur à 300 ou inférieur à 100, alors la valeur 0 est attribuée à la variable Ya. En LISP çà donne : (if (or ( 100 anngle)) (setq Ya 0))

Je ne suis pas sûr de moi mais il me semble que dans les fonctions appelées par la fonction principale FixCn une autre définition soit attribuée à *error*, c'est donc cette nouvelle définition qui est active quand tu fais "echap" (probablement la fonction acet-init-error dont je ne suis pas parvenu à trouver la définition, mais qui est reconnue par l'interpréteur de lisp). Dans ce cas, s'il y a annulation après que cette nouvelle définition soit active, c'est la fonction mon_err qui est restaurée et non la fonction *error* originelle. Si, après l'annulation, tu tapes !*error* à la ligne de commande tu auras quelque chose du genre # si c'est mon_err qui a été restaurée, ou # si c'est bien la fonction *error* originelle. C'est l'inconvénient de ce type de programme constituée de multiples routines qu'on ne contrôle pas toujours.[Edité le 7/4/2006 par (gile)] [Edité le 7/4/2006 par (gile)]

Quand la stimulation est réciproque, c'est de l'émulation, non ? ;) Ta méthode m'en a rappelé une autre, et m'inspire une suggestion : en récupérant les distances entre les points directement avec (distance ... ta routine devrait fonctionner en 3D. Autre façon d'afficher l'angle entre 3 points : ;;; ACOS Retourne l'arc cosinus du nombre, en radians (defun ACOS (num) (if ( (atan (sqrt (- 1 (expt num 2))) num) (princ "\nErreur: L'argument pour ACOS doit être compris entre -1 et 1" ) ) ) ;;; C:ANG_3PTS Affiche l'angle défini par 3 points 3D (defun c:ang_3pts (/ som pt1 pt2 d1 d2 d3 ang) (initget 1) (setq som (getpoint "\nSpécifiez le sommet de l'angle: ") pt1 som pt2 som ) (while (equal pt1 som) (initget 1) (setq pt1 (getpoint som "\nSpécifiez la première extrémité: ")) ) (while (equal pt2 som) (initget 1) (setq pt2 (getpoint som "\nSpécifiez la seconde extrémité: ")) ) (setq d1 (distance som pt1) d2 (distance som pt2) d3 (distance pt1 pt2) ) (setq ang (ACOS (/ (+ (* d1 d1) (* d2 d2) (- (* d3 d3))) (* 2 d1 d2) ) ) ) (princ (strcat "\nAngle: " (angtos ang) " ou: " (angtos (- (* 2 pi) ang)) ) ) (princ) ) Encore une fois un grand merci à Bonuscad et Pythagore.

Çà marche très bien, j'ai pensé à une améliortion, c'est une suggestion, il serait peut-être intéressant, puisque la taille de la pointe de la flèche est celle des cotations d'intégrer l'échelle des cotations courante en remplaçant les (getvar "DIMASZ") par (* (getvar "DIMSCALE") (getvar "DIMASZ"))

Très joli coup, j'aime beaucoup la méthode. Dans le même esprit mais pour un fonctionnement en 3D : ;;; VEC1 Retourne le vecteur normé (1 unité) de p1 à p2 (nil si p1 = p2) (defun vec1 (dep ext) (if (not (equal dep ext 1e-009)) (mapcar '(lambda (x) (/ x (distance dep ext))) (mapcar '- ext dep) ) ) ) ;;; ASIN Retourne l'arc sinus du nombre, en radians (defun ASIN (num) (if ( (atan num (sqrt (- 1 (expt num 2)))) (princ "\nErreur: L'argument pour ASIN doit être compris entre -1 et 1" ) ) ) ;;; ANGLE_3PTS Retourne l'angle (radians) défini par son sommet et deux points ;;; L'angle retourné est toujours positif et inférieur à pi radians. (defun angle_3pts (som p1 p2 / v1 v2) (if (and (setq v1 (vec1 som p1)) (setq v2 (vec1 som p2)) ) (cond ((equal v1 v2 1e-009) 0.0) ((equal v1 (mapcar '- v2) 1e-009) pi) (T (* 2 (asin (/ (distance v1 v2) 2)))) ) (Prompt "\nErreur: points confondus.") ) ) ;;; C:ANG_3PTS Affiche l'angle 3D défini par 3 points (defun c:ang_3pts (/ som pt1 pt2 ang) (initget 1) (setq som (getpoint "\nSpécifiez le sommet de l'angle: ")) (initget 1) (setq pt1 (getpoint som "\nSpécifiez la première extrémité: ")) (initget 1) (setq pt2 (getpoint som "\nSpécifiez la seconde extrémité: ")) (if (setq ang (angle_3pts som pt1 pt2)) (princ (strcat "\nAngle: " (angtos ang) " ou: " (angtos (- (* 2 pi) ang)) ) ) ) (princ) ) [Edité le 6/4/2006 par (gile)]

Salut, J'ai dû configurer ma souris Logitech : paramétrer la roulette comme "troisième bouton" ou "bouton du milieu", je ne sais plus exactement.

Salut, Tu peux aller voir ici. Tu peux aussi appeler la calculatrice géométrique : (if (not (member "geomcal.arx" (arx))) (arxload "geomcal") ) (cal "ang(p1,p2,p3)") NOTA : dans le premier cas l'angle est retouné en radians, dans le second en degrés.

Bonuscad, Je pense que c'est dû à l'utilisation de (angle pt1 pt2) dans la définition de pt_x, si la direction est colinéaire au Z du SCU, les projections de pt1 et pt2 sur le plan sont confondues, donc pas d'angle mesurable. Je pense avoir trouvé un moyen de définir pt_x sans passer par angle et polar, avec un peu de calcul vectoriel (encore !!!) : (setq pt_x (mapcar '- pt2 (mapcar '(lambda (x) (* x (/ (getvar "DIMASZ") (distance pt1 pt2)))) (mapcar '- pt2 pt1) ) ) ) qu'on peut écrire, en utilisant Vec1 : (setq pt_x (mapcar '- pt2 (mapcar '(lambda (x) (* x (getvar "DIMASZ"))) (vec1 pt1 pt2) ) ) ) Pour déterminer Z_dir, on peut donc prendre n'importe quel plan contenant pt1 et pt2, avec le calcul vectoriel (encore !!!) on peut faire un Norm_3pts avec pt1 pt2 et n'importe quel autre point qui ne soit pas aligné avec les deux premiers, par exemple (un peu comme SCU 3points) : (defun z_dir (p1 p2 / x_dir y_pt) ;; Axe des X (setq x_dir (vec1 p1 p2)) ;; Point arbitraire dans les Y positif (if (and (equal (car x_dir) 0.0 1e-009) (equal (cadr x_dir) 0.0 1e-009) ) (setq y_pt '(0 1 0)) (setq y_pt (list (- (cadr x_dir)) (car x_dir) (caddr x_dir)) ) ) (norm_3pts '(0 0 0) x_dir y_pt) ) [Edité le 6/4/2006 par (gile)]

Oui çà marche. C'est un peu hors sujet, il ne s'agit plus de polyligne, mais de flèche 3D (solide) (defun arr_err (msg) (if (= msg "Fonction annulée") (princ) (princ (strcat "\nErreur: " msg)) ) (command "_.ucs" "_restore" "scu_init") (command "_.ucs" "_delete" "scu_init") (command "_.undo" "_end") (setvar "cmdecho" echo) (setvar "delobj" delo) (setvar "osmode" osmo) (setq *error* m:err m:err nil ) (princ) ) ;;; VEC1 Retourne le vecteur normé (1 unité) de p1 à p2 (defun vec1 (p1 p2) (if (not (equal p1 p2 1e-009)) (mapcar '(lambda (x) (/ x (distance p1 p2))) (mapcar '- p2 p1) ) ) ) (defun c:3d_arrow (/ osmo echo delo pt1 pt2 pt3 long) (setq m:err *error* *error* arr_err echo (getvar "cmdecho") delo (getvar "delobj") osmo (getvar "osmode") ) (command "_.undo" "_begin") (setvar "cmdecho" 0) (command "_.ucs" "_save" "scu_init") (initget 9) (setq pt1 (getpoint "\nPoint de départ de la flèche: ") pt2 pt1 ) (initget 9) (while (equal pt2 pt1) (setq pt2 (getpoint pt1 "\nPoint d'arrivée de la flèche: ")) (if (equal pt2 pt1) (progn (princ "\nLe point de départ et d'arrivée sont confondus!") (initget 9) ) ) ) (setq pt01 (trans pt1 1 0) pt02 (trans pt2 1 0) long (getvar "DIMASZ") pt03 (mapcar '- pt02 (mapcar '(lambda (x) (* x long)) (vec1 pt01 pt02)) ) ) (setvar "osmode" 0) (command "_ucs" "_zaxis" pt1 pt2) (foreach pt '(pt01 pt02 pt03) (set pt (trans (eval pt) 0 1)) ) (command "_.circle" pt01 (/ long 50)) (command "_.extrude" (entlast) "" (distance pt01 pt03) 0.0) (setq ent (entlast)) (command "_.circle" pt03 (/ long 5)) (command "_.extrude" (entlast) "" long (angtos (atan (/ long 5) long) (getvar "aunits") 14 ) ) (command "_.union" ent (entlast) "") (command "_.ucs" "_restore" "scu_init") (command "_.ucs" "_delete" "scu_init") (command "_.undo" "_end") (setvar "cmdecho" echo) (setvar "delobj" delo) (setvar "osmode" osmo) (setq *error* m:err m:err nil ) )

Petite précision, il me semble qu'on parle de variables globales quand elles ne sont pas déclarées (et conservent leurs valeurs pendant toutes la session du dessin) et de variables locales pour les variables déclarées. De plus amples expilcations, en anglais, dans Aide aux dévellopeurs -> AutoLISP Developer's Guide ->Using the AutoLISP Language -> AutoLISP Basics -> Symbol and Function Handling -> Local Variables in Functions -> Local Variables versus Global Variables et, en français dans le Didactitiel AutoLISP -> Utilisation des outils de débogage Visual LISP -> Différenciation entre les variables locales et les variables globales

Salut Bonus, Çà ne marche pas chez moi (à moins que je n'ai pas compris ce que tu voulais faire), et çà me rassure plutôt ! http://xs75.xs.to/pics/06143/Arrow.PNG.xs.jpg Géométriquement parlant, Z_dir, la direction d'extrusion ou normale du plan XY est le vecteur normé (de 1 unité) perpendiculaire à ce plan. Or un plan ne peut être défini uniquement par 2 points. 2 points définissent une droite unique qui peut être contenue par une infinité de plans (rotation3D). Je n'ai pas décortiqué ta routine, mais il y a forcément quelque chose d'arbitraire là dedans.

Je serais bien incapable (et je mets quiconque au défi ;) ) de définir un seul plan avec seulement 2 points. Avec 3 points, c'est exactement pour cet usage que Norm_3pts a été faite. Sinon, j'avais aussi fait des flèches, assez sommaires, dont l'utilité était de dessiner les vecteurs représentant les forces en statique graphique, la pointe est proportionnelle à la longueur de la flèche. Une autre routine permet de récupérer les coordonnées du vecteur et sa norme, une troisiéme pour les coordonnées du vecteur normé (si çà peut servir à quelqu'un). ;;; C:VEC ;;; Crée une polyligne 2D symbolisant un vecteur et affiche ses coordonnées et sa norme ;;; Redéfinition de *error* (defun VEC_ERR (msg) (if (= msg "Fonction annulée") (princ) (princ (strcat "\nErreur: " msg)) ) (setq *error* m:err m:err nil ) (princ) ) ;;; Fonction principale (defun c:vec (/ pt1 pt2 ang dist) (setq m:err *error* *error* VEC_ERR ) (princ "Vecteur") (initget 1) (setq pt1 (getpoint "\nSpécifiez l'origine du vecteur: ")) (initget 1) (setq pt2 (getpoint pt1 "\nSpécifiez l'extrémité du vecteur: ")) (DRAW_VEC pt1 pt2) (setq *error* m:err m:err nil ) (princ) ) (defun DRAW_VEC (pt1 pt2 / ang dist pt3 pt4) (setq ang (angle pt1 pt2) dist (/ (distance pt1 pt2) 10) pt3 (polar pt2 (angle pt2 pt1) dist) Norm (trans '(0 0 1) 1 0 T) ) (command "_regen") (entmake (list '(0 . "LWPOLYLINE") '(100 . "AcDbEntity") '(100 . "AcDbPolyline") '(90 . 5) ;_ nombre de sommets '(70 . 0) ;_ ouverte (0) ou fermée (1) (cons 38 (- (caddr pt1) (caddr (trans '(0 0) 0 1)))) ;_ élévation (cons 10 (trans pt1 1 Norm)) (cons 10 (trans pt3 1 Norm)) (cons 40 (/ dist 2)) ;_ largeur de la pointe (cons 41 0.0) (cons 10 (trans pt2 1 Norm)) (cons 210 Norm) ;_ direction d'extrusion ) ) ) ;;; C:GETVEC ;;; Affiche les coordonnées et la norme d'un vecteur défini par son origine et son extrémité (defun C:GETVEC (/ vec pt1 pt2) (initget 1) (setq pt1 (getpoint "\nSpécifiez l'origine du vecteur: ")) (initget 1) (setq pt2 (getpoint pt1 "\nSpécifiez l'extrémité du vecteur: ")) (princ (strcat "\nVecteur: " (PT->COORD (mapcar '- pt2 pt1)) " Norme: " (rtos (distance pt1 pt2)) ) ) (princ) ) ;;; C:NORMVEC ;;; Affiche les coordonnées du vecteur normé décrit par un segment (defun C:NORMVEC (/ vec pt1 pt2) (initget 1) (setq pt1 (getpoint "\nSpécifiez l'origine du segment: ")) (initget 1) (setq pt2 (getpoint pt1 "\nSpécifiez un autre point sur le segment: ") ) (princ (strcat "\nVecteur normé: " (PT->COORD (mapcar '(lambda (x) (/ x (distance pt1 pt2))) (mapcar '- pt2 pt1) ) ) ) ) (princ) ) [Edité le 5/4/2006 par (gile)]

Salut, As-tu bien copié les points-virgules (;) au début de la routine. On dirait qu'AutoCAD essaye d'interpréter (mesh-to-solid) situé dans les commentaires.

Je veux bien essayer de t'aider, mais je manque de temps en ce moment. Ce n'est pas de la mauvaise volonté, mais je crains de ne pas avoir celui (le temps) nécessaire à l'épluchage to LISP qui est, semble-t-il, fort long! Tu peux tout de même me l'envoyer à gilecantel(at)wanadoo.fr je peux essayer de tester de mon côté.

Pour Esbe, Vraiment, je ne vois pas. Le message numberp: nil signifie qu'une fonction (ou une commande) attend un nombre et qu'à la place de ce nombre elle reçoit une variable Lisp nulle (nil) ou contenant autre chose qu'un nombre, or tous les nombres requis sont renseignés par des nombres ou par la fonction angle qui calcule un angle à partir des points spécifiés. Il ne me semble pas que cela puisse provenir d'une variable système (surtout si d'autres LISPs fonctionnent) Il n'y a pas d'histoire d'espace dans cette routine. Ou alors un truc du type de ce qui est arrivé à Kallain (conflit entre 2 LISPs de même nom) essaye de remplacer c:fleche par autre chose : c:fleche1 par exemple.

Pour Esbe, Bizarre, je ne comprends pas, le viens de faire un copier/coller et un test, çà marche :casstet:

La couleur des ceintures n'a rien à voir avec la capacité à répondre à des questions plus ou moins complexes, elle est liée au nombre de messages postés et, à l'allure où tu postes, tu ne devrais pas tarder à être ceinture méga foncée ;)

Je ne suis pas sûr de comprendre ce que tu veux (essaye d'être plus clair). :casstet: S'il s'agit d'appliquer un angle toujours compris entre 0 et pi radians, tu peux essayer çà (en LISP, parcque j'y suis plus à l'aise qu'en Diesel) : (command "_.text" "_j" "_c" pause 0.08 (angtos (rem (getvar "SNAPANG") pi) (getvar "AUNITS") 14) "Bureau") [Edité le 4/4/2006 par (gile)]

14, c'est pour la précision, c'est 14 décimales, le maximum pour AutoCAD. Une explication sur angtos ici et dans les réponses suivantes.

Oh Tramber, C'est pas un peu comme (angle ptb pta) :casstet:

Salut, Un petit LISP vite fait, taper fleche à la ligne de commande : (defun c:fleche (/ p1 p2 p3) (initget 1) (setq p1 (getpoint "\nPointe de la flèche: ")) (initget 1) (setq p2 (getpoint p1 "\nTalon de la flèche: ")) (setq p3 (polar p1 (angle p1 p2) 0.2)) (command "_.pline" "_non" p1 "_w" 0.0 0.3 "_non" p3 "_w" 0.1 0.1 "_non" p2 "") (princ) )

Le test que je te propose fonctionne sur le même principe : c:test fait appel à test1 pour la saisie des points qui fait appel à test2 pour le choix du type d'entité et la création de l'entité.

Je suis curieux que cela puisse fonctionner (même un temps) pour deux raisons : 1 - SNAPANG n'est pas une variable environnement (accessible avec getenv), mais une variable système (accessible avec getvar) 2 - Si SNAPANG tapé directement à la ligne de commande retourne la valeur de l'angle dans le type d'unité angulaire courant (variable système AUNITS), $m=$(getvar,"SNAPANG") retourne toujours l'angle en radians, une solution consiste à utiliser angtos pour convertir les radians en unités courantes. Ce qui donne, en Diesel : [bureau]^C^Ctexte;j;c;\.08;$m=$(angtos,$(getvar,"SNAPANG"),$(getvar,"AUNITS"),14);Bureau; Ou en LISP (si tu as une version complète) : ^C^C(command "_.text" "_j" "_c" pause 0.08 (angtos (getvar "SNAPANG") (getvar "AUNITS") 14) "Bureau");

On peut extruder en utilisant une polyligne 3D comme chemin, c'est avec une spline 3D que çà ne marche pas.

OOOPS !!! Au temps pour moi, si tu as utilisé le code que je donnais au dessus pour mon_err, il est normal que çà n'ait pas fonctionné : il y a un paranthèse fermante de trop :mad2: J'ai posté çà ce matin en vitesse sans vérifications. :cool: Tu aurais dû être averti par un message du style : ; erreur: parenthèse fermante supplémentaire en entrée Si tu veux re-essayer avec ce petit assemblage, je l'ai testé, il fonctionne que l'on fasse "echap" pendant l'exécution de test1 (spécification des points) ou test2 (spécification du type d'entité). J'ai rajouté, pour l'exemple, la gestion d'une variable système (BLIPMODE) et la fonction (redraw), tu remarqueras que la fin de la fonction principale (c:test) et la fin de mon_err sont similaires. (defun mon_err (ch) (cond ((or (eq ch "Fonction annulée") (eq ch "Function cancelled") ) (princ "\nProcédure d'annulation en cours, patientez....") (alert "fonction aborted") ) (T (princ (strcat "\nErreur: " ch))) ) ;_ cond [color=#990000](redraw) (setvar "blipmode" old_blip)[/color] (setq *error* olderr ;_ Restauration de *error* olderr nil ;_ Renvoi de olderr à nil ) (princ) ) ;_ defun (defun test1 (/ pt1 pt2 pt3) [color=#990000](setvar "blipmode" 1)[/color] (initget 1) (setq pt1 (getpoint "\nPremier point: ")) (initget 1) (setq pt2 (getpoint "\nSecond point: ")) (initget 1) (setq pt3 (getpoint "\nTroisième point: ")) (test2 pt1 pt2 pt3) ) (defun test2 (p1 p2 p3) (initget "Ligne Polyligne") (if (= (getkword "\nType d'entité [Ligne/Polyligne] : ") "Polyligne" ) (command "_.pline" p1 p2 p3 "_c") (command "_.line" p1 p2 p3 "_c") ) ) (defun c:test (/ [color=#990000]old_blip[/color]) (setq olderr *error* *error* mon_err ) [color=#990000](setq old_blip (getvar "blipmode"))[/color] (test1) [color=#990000](redraw) (setvar "blipmode" old_blip)[/color] (setq *error* olderr olderr nil ) (princ) ) [Edité le 3/4/2006 par (gile)]