(gile)

Justement parlons "guillemets. En LISP un mot sans guillemets et sans espaces comme a ou rayon ou c:mult_r est un symbole (type SYM) comme le sont tontes les fonctions prédéfinies. On utilise des symboles pour les noms de variable et de fonction. Un symbole contient une valeur et il est évalué sauf s'il est "quoté" avec la fonction quote ou son raccourci l'apostrophe ('). Un mot entre guillemets comme "a" ou "_fillet" ou "Ceci est un exemple" est une chaîne de caractères (type STR). Un chaîne de caractère (comme un nombre entier ou réel) n'est pas évaluée, c'est une expression dite autoévaluante. La fonction command accepte que les entrées (options ou paramètres) soient de type chaîne ou du type LISP correspondant à la valeur attendue. On peut passer à command une chaîne correspondant à ce qu'on entrerait au clavier : (command "_point" "10,5") tout comme on peut lui passer un point LISP (une liste de 2 ou 3 nombres) (command "_point" '(10 5)) tout comme on peut lui passer une variable qui contient un point (la variable est alors évaluée (setq pt '(10 5)) (command "_point" pt) Il est fondamental de comprendre que toute expression LISP renvoie une valeur et que quand on appelle une fonction celle-ci renvoie une valeur qu'il est impératif de connaitre le type de cette avant d'essayer de s'en servir. La fonction getpoint renvoie un "point" (liste de 3 nombres) ou nil. La fonction getdist renvoie un nombre réel ou nil. La fonction entsel renvoie une liste contenant un nom d'entité (type ENAME) et le point cliqué (ou nil). Donc quand tu fais (tu peux essayer depuis la ligne de commande ou la console Visual LISP) : (setq ent (entsel "\nCliquez sur la premiere MPL :")) ent contient une liste du genre: ( (124.054 -13.8985 0.0)) ou nil si l'utilisateur a fait Entrée ou cliqué dans le vide. Dans notre cas, pour la suite du programme, ce qui nous intéresse c'est le nom d'entité, autrement dit le premier élément de cette liste. La fonction car (fonction fondamentale de tous les langages LISP avec cdr et cons), la fonction car, donc, renvoie le premier élément de la liste qui lui est passée en argument : (car ent) renvoie le premier élément de ent soit le nom d'entité de l'entité sélectionnée. Plutôt que d'essayer de deviner ce que fait une fonction (surtout avec le peu de connaissances que tu as encore) n'hésite pas à consulter la documentation et à faire des tests dans la console ou à la ligne de commande, c'est un énorme avantage des langages interprétés comme AutoLISP que de pouvoir évaluer directement aussi bien une simple expression ou une variable qu'un gros programme.

Les fonctions getxxx (excepté getcname) sont utilisée pour récupérer des entrées utilisateur. Toutes permettent d'entrer une valeur au clavier et la plupart de le faire aussi à l'écran avec la souris. Suivant le type de données, on choisis l'une ou l'autre et le type de valeur de retour correspond à la fonction utilisée Au clavier ou à la souris getpoint invite l'utilisateur à spécifier un point et retourne un point (liste de 3 nombres) ou nil. getcorner invite l'utilisateur à spécifier un point et retourne un point (liste de 3 nombres) ou nil. getdist invite l'utilisateur à spécifier une distance et retourne un nombre réel ou nil. getangle invite l'utilisateur à spécifier un angle et retourne un nombre réel ou nil. getorient invite l'utilisateur à spécifier une orientation et retourne un nombre réel ou nil. Au clavier uniquement getint invite l'utilisateur à spécifier un nombre entier et retourne un nombre entier ou nil. getreal invite l'utilisateur à spécifier un nombre réel et retourne un nombre réel ou nil. getstring invite l'utilisateur à spécifier une chaîne de caractères et retourne une chaîne de caractères ou "". getkword invite l'utilisateur à spécifier un mot clé (option) et retourne une chaîne de caractères ou nil. Un petit exemple fait à partir du tien pour montrer comment on récupère des entrées utilisateur pour les passer à une commande : (defun c:mult_r (/ rayon ent) ; <- déclaration locale des variables ;; force l'utilisateur à spécifier un nombre strictement positif (initget 7) ;; invite l'utilisateur à spécifier une distance (setq rayon (getdist "\nDéfinir le premier rayon : ")) ;; invite l'utilisateur à sélectionner une entité (setq ent (entsel "\nCliquez sur la premiere MPL :")) ;; lance la commande raccord ;; et lui passe les entrées utilisateurs récupérées ci-dessus (command "_fillet" "_r" rayon "_p" (car ent)) (princ) ; sortie silencieuse )

Encore un truc, vas-y progressivement. Fais d'abord une première routine pour faire les raccords que tu essayes d'aboutir, et seulement ensuite tu ajoutes d'abord un seul décalage et quand ça marche, tu passes aux décalages multiples. En faisant ainsi tu évites de te retrouver submergé par trop de choses à résoudre d'un seul coup.

Et n'hésite pas à aller voir dans l'aide (sélection de le fonction puis Ctrl+F1) et à faire des tests avec de simples expressions depuis la console de l'éditeur Visual LISP ou depuis la commande

Salut, Pour les entrées utilisateurs, utilise la fonction correspondant au type de valeur que tu veux obtenir (getpoint, c'est pour obtenir un point, getcname, ce n'est pas pour une entrée utilisateur, c'est pour avoir le nom global ou local d'une commande). Pour les entrées utilisateur, c'est chapitre 7 de Introduction à AutoLISP ou >>ici pour da-code (le site de didier).

Si les échelles des fenêtres de présentations sont différentes, un texte annotatif devrait faire l'affaire. Sélectionner le texte, dans la palette de propriété, mettre Annotatif à Oui, en dessous, dans Echelle annotative ajouter les échelles des fenêtres de présentation. Le texte sera affiché dans les présentations avec sa hauteur (1 unité = 1 mm).

Non, la mise à jour projetée pour Increment concernait le redimensionnement la boite de dialogue qui posait problème avec certaines résolutions d'écran et le problème est réglé. Pour tes suggestions, je verrais quand j'aurais du temps. La gestion des nombres négatifs n'est pas simple (surtout avec les caractères alphabétiques et les chiffres romains). En ce qui concerne le séparateur, il est écrit dans l'aide :

Souvent, ce genre d'erreur est dû à une variable pas déclarée (globale) qui est ou n'est pas initialisée ailleurs que dans le code ce qui fait que le code marche ou ne marche pas.

Salut, Je n'ai suivi de près cette conversation mais 188 réponses, je suis impressionné. Chacun a ses habitudes de nommage des variables, mais en général elst c'est une liste DXF telle que retournée par (entget ...), pour (car (entsel ...) on utilise plutôt ent. En tout cas, c'est ce que je fais. Quoi qu'il en soit, pour trouver ce qui provoque une erreur, je rappelle la procédure : ouvrir la routine dans l'éditeur Visual LISP (VLIDE) cocher "Arrêt sur erreur" dans le menu Déboguer de l'éditeur charger la routine menu Outils > "Charger le texte dans l'éditeur" (Ctrl+Alt+E) dans AutoCAD lancer la routine pour provoquer l'erreur, et basculer automatiquement dans l'éditeur Visual LISP dans le menu Déboguer cliquer sur "Source de la dernière interruption" (Ctrl+F9) L'exécution est interrompue et la source de l'erreur devrait être sélectionnée (surbrillance dans le fenêtre du code). On peut interroger les valeurs de variables dans la console. Ne pas oublier de réinitialiser (Ctrl+Q) pour sortir de l'interruption.

Super merci. C'est fait. J'ai aussi ajouté la fonction inverse : u2w

Salut, Il me semble que tu fais toujours l'erreur géométrique que j'ai noté dans mon premier message : la pente n'est pas le rapport entre le dénivelé (delta Z) et la longueur de la ligne, mais le rapport entre le dénivelé et la distance horizontale (longueur de la ligne projetée sur XY). La formule n'est donc pas : 100 * deltaZ / longueur mais, en utilisant Pythagore : 100 * deltaZ / sqrt(sqr(deltaX) + sqr(deltaY)) Un screencast.

lili2006, Relis bien le premier message et mes réponses. J'ai dit : "parallèle au plan XY", pas "parallèle à l'axe X". Nous parlons de la pente en 3D où le dénivelé correspond à la différence des coordonnées Z des points de départ et de fin et où la distance horizontale correspond à la longueur de la ligne projetée sur le plan XY. D'où l'utilisation de Pythagore ou de la trigonométrie. Si on parle de la représentation 2D d'une pente (coupe, profil), il suffit de calculer le rapport entre le delta Y et le delta X Un petit screencast. En LISP: (defun c:slope2d (/ line pt doc id) (vl-load-com) (and (setq line (car (entsel "\nSélectionnez une ligne: "))) (setq line (vlax-ename->vla-object line)) (= (vla-get-ObjectName line) "AcDbLine") (setq pt (getpoint "\nSpecifiez le point d'insertion: ")) (setq doc (vla-get-ActiveDocument (vlax-get-acad-object))) (setq id (vla-GetObjectIdString (vla-get-Utility doc) line :vlax-false)) (vla-AddMText (vla-get-Block (vla-get-ActiveLayout doc)) (vlax-3d-point pt) 0.0 (strcat "%<\\AcExpr abs(100*%<\\AcObjProp Object(%<\\_ObjId " id ">%).Delta \\f \"%pt2\">%/%<\\AcObjProp Object(%<\\_ObjId " id ">%).Delta \\f \"%pt1\">%) " "\\f \"%lu2%pr2%ps[,%]\">%" ; <- formatage du texte ) ) ) (princ) )

Je n'en sais strictement rien et je ne vais pas me payer un MAC juste pour voir tout ce qui ne marche pas !... Plus sérieusement, je suis pas sûr que ces propriétés soient directement liées à COM/ActiveX, ces mêmes propriétés existent en ObjectARX.

(defun c:PolyLength (/ doc expr ss) (vl-load-com) (if (and (ssget '((0 . "*POLYLINE") (-4 . "<NOT") (-4 . "&") (70 . 112) (-4 . "NOT>"))) (setq pt (getpoint "\nSpécifiez le point d'insertion: ")) ) (progn (setq doc (vla-get-ActiveDocument (vlax-get-acad-object)) expr "%<\\AcExpr 0" ) (vlax-for pl (setq ss (vla-get-ActiveSelectionSet doc)) (setq expr (strcat expr "+%<\\AcObjProp Object(%<\\_ObjId " (vla-GetObjectIdString (vla-get-Utility doc) pl :vlax-false) ">%).Length>%" ) ) ) (vla-Delete ss) (setq expr (strcat expr " \\f \"%lu2%pr2%ps[longueur totale: ,m]\">%")) ; formatage du champ (terpri) (prompt expr) (vla-AddMText (vla-get-Block (vla-get-ActiveLayout doc)) (vlax-3d-point pt) 0.0 expr ) ) ) (princ) )

Je n'en ai aucune idée. Tant qu'à utiliser un LISP, tu as TotalPerim (sur cette page) qui fait ça et même plus sans champ dynamique.

Merci Patrice, Je me souviens avoir eu une discussion avec bonucad concernant concernant les "propriétés cachées" utilisables dans les champs où il s'avérait que la plupart des propriétés COM/ActiveX étaient utilisables dans des champs. Par exemple pour un solide 3d, en plus Area et Volume, on peut accéder à : Centroid %%).centroid \f "%lu2%ps[centroid: ,]">% ProductOfInertia %%).productofinertia \f "%lu2%ps[productofinertia: ,]">% RadiiOfGiration %%).radiiofgyration \f "%lu2%ps[radiiofgyration: ,]">% SolidType %%).solidtype \f "%lu2%ps[solidtype: ,]">%

Salut, Suite à ce sujet, j'ai pensé qu'il pouvait être utile de référencer en un seul endroit les différentes fonctions utilisables dans les formules des champs dynamiques étant donné qu'il n'existe, à ma connaissance, aucune documentation officielle. J'ai choisi ce forum qui, bien qu'il ne soit pas spécifiquement consacré aux champs, englobe différentes forme de personnalisation accessibles à toutes les versions d'AutoCAD pleines comme LT. Donc je commence avec ce que j'ai trouvé par tâtonnement et j'invite tous ceux qui en découvriraient d'autres à les ajouter à ce sujet. Constantes pi valeur de pi 3.141593 e ??? 0.0000 Opérateurs arithmétiques + addition 3+5 => 8 - soustraction 9-2 => 7 * multiplication 4*3 => 12 / division 4/3 => 1.333333 ^ puissance 2^3 => 8.0 Fonctions abs valeur absolue abs(-4.9) => 4.9 round arrondi round(5.8) => 6 trunc valeur entière trunc(5.8) => 5 sqr carré sqr(5) => 25.0 sqrt racine carrée sqrt(16) => 4.0 exp puissance de e exp(1) => 2.718282 exp10 puissance de 10 exp10(4) => 10000.0 log logarithme décimal log(10) => 1.0 ln logarithme naturel ln(2.718282) => 1.0 d2r degrés en radians d2r(180) => 3.141593 r2d radians en degrés r2d(pi) => 180.0 sin sinus sin(30) => 0.5 cos cosinus cos(30) => 0.866025 tang tangente tang(45) => 1.0 asin arc sinus asin(0.5) => 30.0 acos arc cosinus acos(0.5) => 60.0 atan arc tangente atan(1.0) => 45.0 u2w conversion SCU -> SCG u2w(0.0, 0.0, 0.0) w2u conversion SCG -> SCU w2u(0.0, 0.0, 0.0) NOTA : pour les fonctions trigonométriques les valeurs angulaires sont exprimées dans l'unité angulaire courante (degrés dans les exemples ci-dessus).

Salut lili2006 Il semble tout simplement que ton delta Z est égal à 0.0, autrement dit que ta ligne est horizontale (parallèle au plan XY). Personnellement je n'ai pas trouvé de moyen d'obtenir directement la distance horizontale (dh), mais si tu as vu un truc qui m'aurait échappé, dis nous où ça se trouve.

Le problème, c'est qu'il n'existe pas, à ma connaissance de documentation sur les fonctions utilisables dans les formules. On donc un peu obligé d'y aller par tâtonnement. Par exemple, pour la tangente, j'ai d'abord essayé tan (comme dans les langages que je connais) et ça ne marchait pas ; j'ai ensuite essayé tg comme on écrivait quand j'étais au collège, pas mieux ; puis tangente en toutes lettres, non plus ; finalement tang a marché, mais j'ai l'impression d'avoir eu de la chance, c'est bien la première fois que je je vois ce symbole pour la tangente d'un angle.

Comme le processus est un peu fastidieux, voici un petit LISP qui crée le champ pour la ligne sélectionnée et insère un texte multiligne contenant le champ au point spécifié. Le LISP utilise les paramètre de texte courant et un formatage de champ basique. Libre à chacun de l'adapter pour ses besoins spécifiques. ;; SLOPEFIELD ;; Insère un texte multiligne contenant un champ indiquant la pente (3D) de la ligne sélectiionnée (defun c:slopefield (/ line pt doc id) (vl-load-com) (and (setq line (car (entsel "\nSélectionnez une ligne: "))) (setq line (vlax-ename->vla-object line)) (= (vla-get-ObjectName line) "AcDbLine") (setq pt (getpoint "\nSpecifiez le point d'insertion: ")) (setq doc (vla-get-ActiveDocument (vlax-get-acad-object))) (setq id (vla-GetObjectIdString (vla-get-Utility doc) line :vlax-false)) (vla-AddMText (vla-get-Block (vla-get-ActiveLayout doc)) (vlax-3d-point pt) 0.0 (strcat "%<\\AcExpr (100*tang(asin(%<\\AcObjProp Object(%<\\_ObjId " id ">%).Delta \\f \"%lu2%pt4\">%/%<\\AcObjProp Object(%<\\_ObjId " id ">%).Length>%))) " "\\f \"%lu2%pr2%ps[,%]\">%" ; <- formatage du texte ) ) ) (princ) ) Format de champ : %lu2 : unités décimales (CF la variablle système LUNITS) %pr2 : précision (2 décimales) %ps[,%] : [préfixe,suffixe]

J'avais oublié, pour une valeur en pourcentage, il suffit d'ajouter 100* au début des formules (pour multiplier le résultat par 100) ou d'affecter un facteur de conversion de 100 au champ formule (il faut faire Evaluer avant) et ont peut aussi modifier ce format (précision, suffixe).

Salut, D'abord, il me semble qu'il faut corriger une petite erreur de raisonnement. La pente c'est le rapport entre la différence d'altitudes entre les deux points et la distance horizontale (donc pas la longueur de la ligne. Ceci dit, on peut quand même y arriver, je te propose deux formules. La première en calculant la distance horizontale avec Pythagore : Delta.Z / sqrt(Delta.X * Delta.X + Delta.Y * Delta.Y) La seconde en utilisant la trigonométrie tang(asin(Delta.Z / Length)) Pour construire la formule de champ : tu lances la commande CHAMP tu choisis Objet dans le panneau de gauche et tu sélectionnes la ligne tu choisis Différence (Delta) dans le panneau central et décoches tout sauf Z dans celui de droite tu copies l'expression de champ (panneau du bas) dans le panneau de gauche, tu choisis maintenant : Formule dans la case Formule: tu colles l'expression de champ (c'est le résultat qui s'affiche) tu ajoutes derrière ce champ le signe diviser : /, puis sqrt (pour racine carrée) et enfin une parenthèse ouvrante : ( dans la panneau de gauche tu reviens à Objet (la ligne est toujours sélectionnée) tu coches X et décoches Z pour avoir le Delta X tu copies l'expression de champ tu retournes dan la Formule à la suite de ce que tu as déjà entré, tu colles le nouveau champ puis * (multiplier) puis à nouveau le champ (mise au carré) et enfin un + retour dans Objet pour copier le Delta Y et enfin, de retour dans Formule, tu fais comme pour X et tu fermes la parenthèse ) L'expression de champ dans la boite de dialogue devrait ressembler à ça (FldPtr est un pointeur sur un champ): %<\AcExpr (%<\_FldPtr 729000976>%/sqrt(%<\_FldPtr 728999792>%*%<\_FldPtr 728999120>%+%<\_FldPtr 728997744>%*%<\_FldPtr 728996048>%)) \f "%lu2">% en développé c'est ça : %<\\AcExpr (%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Delta \\f \"%lu2%pt4\">%/sqrt(%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Delta \\f \"%lu2%pt1\">%*%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Delta \\f \"%lu2%pt1\">%+%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Delta \\f \"%lu2%pt2\">%*%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Delta \\f \"%lu2%pt2\">%)) \\f \"%lu2\">% Pour l'autre formule, je te laisse faire (c'est plus rapide). L'expression dans la boite de dialogue est plus simple: %<\AcExpr (tang(asin(%<\_FldPtr 728769280>%/%<\_FldPtr 728769152>%))) \f "%lu2">% De même que l'expression développée : %<\\AcExpr (tang(asin(%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Delta \\f \"%lu2%pt4\">%/%<\\AcObjProp Object(%<\\_ObjId 8796087805376>%).Length \\f \"%lu2\">%))) \\f \"%lu2\">%

Pourquoi? coder c'est pas bosser ?

C'est super, tu avances. Mais j'avais dit : "Étape suivante, et si l'utilisateur faisait Entrée au lieu de spécifier le centre... ", essaye, juste pour voir...

Salut, Première chose, bravo. Tu l'as fait tout seul et ça marche (quand c'est toi qui teste). Maintenant il faut envisager si l'utilisateur ne fait pas exactement que tu (la routine) attends de lui. Aux invites : "Dimension du rayon" et "Longueur du tube", on a envie de répondre en entrant directement une valeur numérique au clavier, or la fonction getpoint attends un point. Si j'entre 5, par exemple, getpoint va prendre le point à 5 unités dans la direction du curseur par rapport au dernier point (celui stocké dans la variable LASTPOINT, pas le dernier spécifié dans ce LISP) ce qui, fort probablement, va donner un résultat imprévu. Le rayon et la longueur du tube sont des distance, il est donc naturel d'utiliser plutôt la fonction getdist prévue à cet effet. De plus getdist prend optionnellement comme premier argument, un point de base pour, justement spécifier un point à l'écran avec une ligne élastique et interprète correctement une entrée au clavier (getdist attend un nombre). Donc, tu peux essayer : [...] (setq a (getpoint "\nSpécifier le centre : ")) (setq b (getdist a "\nDimension du rayon : ")) [...] Étape suivante, et si l'utilisateur faisait Entrée au lieu de spécifier le centre... Peut-on l'éviter ou y remédier ? (à suivre...)