(gile)

Tout simplement impressionnant :o Il faut plus de temps pour charger la vidéo, que pour dessiner la cuisine, et faire le rendu !

Pour certains calculs ou comparaisons en 3D, il peut être intéressant d'utiliser des vecteurs normés (vecteur de une unité). Mis à jour le 07/10/06 (nouvelles routines) Pour trouver le vecteur normé d'un segment défini par ses extrémités, on "déplace" le départ en (0.0 0.0 0.0) et l'extrémité à une unité du départ : ;;; VEC1 Retourne le vecteur normé (1 unité) de p1 à p2 (nil si p1 = p2) (defun vec1 (p1 p2) (if (not (equal p1 p2 1e-009)) (mapcar '(lambda (x1 x2) (/ (- x2 x1) (distance p1 p2)) ) p1 p2 ) ) ) ;; ou (defun vec1 (p1 p2) (vunit (mapcar '- p2 p1)) ) Produit scalaire de deux vecteurs. Le résultat est un nombre réel. Si le produit scalaire de deux vecteur est égal à 0, les vecteurs sont perpendiculaires. ;;; VXV Retourne le produit scalaire (réel) de deux vecteurs (defun vxv (v1 v2) (apply '+ (mapcar '* v1 v2)) ) Le produit scalaire d'un vecteur par lui même retourne le carré de sa norme (sa longueur). ;;; VLEN Retourne la longueur (norme) d'un vecteur (defun vlen (v) (sqrt (vxv v v)) ) Pour trouver le vecteur unitaire de même sens et direction qu'un vecteur quelconque. ;;; VUNIT Retourne le vecteur unitaire d'un vecteur (defun vunit (v / l) (if (/= 0 (setq l (vlen v))) (mapcar '(lambda (x) (/ x l)) v) ) ) Produit vectoriel de deux vecteurs. Le résultat est un vecteur perpendiculaire aux deux vecteurs. ;;; V^V Retourne le produit vectoriel (vecteur) de deux vecteurs (defun v^v (v1 v2) (if (inters '(0 0 0) v1 '(0 0 0) v2) (list (- (* (cadr v1) (caddr v2)) (* (caddr v1) (cadr v2))) (- (* (caddr v1) (car v2)) (* (car v1) (caddr v2))) (- (* (car v1) (cadr v2)) (* (cadr v1) (car v2))) ) ;; '(0.0 0.0 0.0) ) ) Il peut être intéressant aussi de connaître le vecteur normal (ou la normale) d'un un plan défini par 3 points, pour déterminer le code dxf 210 ou la propriété Normal en Vlisp (les coordonnées des points 3d doivent alors être définies dans le SCG). Norm_3dpts utilise la fonction LINEARP définie plus bas. ;;; NORM_3PTS retourne le vecteur normal du plan défini par 3 points 3D (defun norm_3pts (p0 p1 p2 / norm) (foreach v '(p1 p2) (set v (mapcar '- (eval v) p0)) ) (mapcar '(lambda (x) (/ x (distance '(0 0 0) norm))) (setq norm (v^v p1 p2)) ) ) ;; ou (defun norm_3pts (p0 p1 p2 / norm) (vec1 '(0 0 0) (v^v (vec1 p0 p1) (vec1 p0 p2)) ) ) La direction du vecteur normal est fonction de l'ordre dans lequel sont spécifiés les points : p0 comme origine et p1 et p2 dans le sens trigonométrique. Exemple : (norm_3pts '(0 0 0) '(1 0 0) '(0 1 0)) retourne (0.0 0.0 1.0) (norm_3pts '(0 0 0) '(0 1 0) '(1 0 0)) retourne (0.0 0.0 -1.0) http://img347.imageshack.us/img347/3500/normal3as.png Les deux routines ci-dessus retournent les mêmes résultats que les expressions vec1(dep,ext) et nor(p0,p1,p2) employés avec la calculatrice géométrique. Exemples d'utilisation des vecteurs normés : Ces routines utilisant les vecteurs fonctionnent quelque soit le système de coordonnées courant et quelque soit celui dans lequel les coordonnées des points sont définies (le même pour tous les points, quand même !). Pour trouver la valeur d'un angle, définis par trois points 3D : ;;; 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.") ) ) ;;; ou, par le "théorème d'Al Kashi" (defun [b]angle_3pts[/b] (som p1 p2 / d1 d2 d3) (setq d1 (distance som p1) d2 (distance som p2) d3 (distance p1 p2) ) (if (and (< 0 d1) (< 0 d2)) (acos (/ (+ (* d1 d1) (* d2 d2) (- (* d3 d3))) (* 2 d1 d2) ) ) ) ) Pour trouver la valeur d'un angle, définis par quatre points 3D (les extrémités de 2 segments) : ;;; ANGLE_4PTS Retourne l'angle entre 2 segments définis par leurs extrémités respectives (defun angle_4pts (p1 p2 p3 p4 / som v1 v2) (cond ((or (equal p1 p2 1e-009) (equal p3 p4 1e-009) ) (prompt "\nErreur: points confondus.") ) ((linearp (remove_doubles (list p1 p2 p3 p4))) (cond ((equal (vec1 p1 p2) (vec1 p3 p4) 1e-009) 0.0) ((equal (vec1 p1 p2) (vec1 p4 p3) 1e-009) pi) ) ) ((cond ((setq som (inters p1 p2 p3 p4 nil)) (if (null (setq v1 (vec1 som p1))) (setq v1 (vec1 som p2)) ) (if (null (setq v2 (vec1 som p3))) (setq v2 (vec1 som p4)) ) (* 2 (asin (/ (distance v1 v2) 2))) ) (T (if (coplanp (list p1 p2 p3 p4)) (prompt "\nErreur: segments parallèles.") (prompt "\nErreur: points non coplanaires.") ) ) ) ) ) ) Les trois dernières routines utilisent les fonctions ASIN et ACOS pour retourner un arc sinus ou cosinus, curieusement asin et acos ne sont pas des fonctions AutoLISP prédéfinies : ;;; ASIN et ACOS Retournent l'arc sinus ou l'arc cosinus du nombre, en radians (defun ASIN (num) (if (<= -1 num 1) (atan num (sqrt (- 1 (expt num 2)))) (princ "\nErreur: L'argument pour ASIN doit être compris entre -1 et 1" ) ) ) (defun ACOS (num) (if (<= -1 num 1) (atan (sqrt (- 1 (expt num 2))) num) (princ "\nErreur: L'argument pour ACOS doit être compris entre -1 et 1" ) ) ) L'utilisation de vecteurs permet aussi de réaliser des tests sur des listes de points 3D : Evaluer si les points d'une liste sont colinéaires : ;;; LINEARP Retourne T si tous les points de la liste sont alignés (defun linearp (lst) (cond ((= 2 (length lst)) T) ((or (equal (vec1 (car lst) (cadr lst)) (vec1 (car lst) (caddr lst)) 1e-009 ) (equal (vec1 (car lst) (cadr lst)) (vec1 (caddr lst) (car lst)) 1e-009 ) ) (linearp (cdr lst)) ) ) ) Evaluer si tous les points d'une liste sont coplanaires : ;;; COPLANP Retourne T si tous les points de la liste sont coplanaires (defun coplanp (lst) (cond ((= 3 (length lst)) T) ((or (inters (car lst) (cadr lst) (caddr lst) (cadddr lst) nil) (equal (vec1 (car lst) (cadr lst)) (vec1 (caddr lst) (cadddr lst)) 1e-009 ) (equal (vec1 (car lst) (cadr lst)) (vec1 (cadddr lst) (caddr lst)) 1e-009 ) ) (coplanp (cdr lst)) ) ) ) PS : J'ai ajouté "angle_4pts" et des contrôles dans "angle_3pts" et "norm_3pts". [Edité le 5/3/2006 par (gile)][Edité le 17/3/2006 par (gile)] [Edité le 20/3/2006 par (gile)] [Edité le 7/10/2006 par (gile)]

Il me semble que c'est à ton patron/formateur (le Conseil Régional) de payer la licence ! Tu ne trouveras pas ici de solution illégale.

Au vu du DWF, la section vrille, pour les solides débillardés le LISP M2S semble avoir encore quelques beaux jours devant lui. La vue de la trémie et la question de CDL : me pousse à demander si ce genre de chose est possible : extruder un objet (ellipse par exemple) sur un chemin et contraindre le solide dans un autre objet (cercle par exemple) en cours de chemin (comme on peut le fair avec Inventor il me semble). les objets en blanc , le chemin en jaune : http://img211.imageshack.us/img211/4528/20072wa.png pour obtenir çà, mais en solide (surfaces gauches ici) : http://img323.imageshack.us/img323/1045/200722lk.png

Bientôt une solution beaucoup plus simple (quoique quelque peu onéreuse) : passer à AutoCAD 2007

Merci Patrick, çà répond tout à fait à ma question. Et bien, en voilà des améliorations qui donnent envie de changer de version ! À tout hasard as tu essayé avec un rectangle à la place du cercle, pour voir si la section est débillardée ou vrillée ?

Salut, J'utilise http://imageshack.us, tu peux mettre l'adresse dans tes favoris (ou marque page si firefox).

J'yvais aussi de ma petite question : Est-ce qu'on pourra extruder le long d'un chemin spline 3D quelconque, ou est-ce qu'on pourra seulement faire des solides tors (ressort) ? Parceque çà, j'y arrivais déjà (voir ici ).

Voilà la nouvelle version, elle joint les traces jointives en une polyligne unique et conserve les largeurs même si les traces ont été étirés à l'aide de leur poignées. Les traces : http://img128.imageshack.us/img128/2815/trace17ka.png Tranformées en polylignes : http://img397.imageshack.us/img397/6868/trace21qt.png La baguette magique : Nouvelle version (05/03/06) possibilité de choisir entre générer une polyligne unique ou une polyligne par trace pour les traces jointives et de même largeur. ;;; Trace2poly Transforme les traces sélectionnées (ou Toutes) en lwpolylignes ;;; L'utilsateur choisit si les traces jointives génèrent une seule polyligne ou des segments. ;;; Les largeurs sont conservées. (defun c:trace2poly (/ dxf mid dep_w end_w ss opt n cnt_t cnt_p tr_lst sub_lst pt_lst prec ) ;;; ************************ SOUS ROUTINES ************************ ;;; ;; DXF retourne la valeur dxf de l'entité pour le code spécifié (defun dxf (code ent) (cdr (assoc code (entget ent))) ) ;; MID Retourne le milieu de deux points (defun mid (pt1 pt2) (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2)) pt1 pt2) ) ;; DEP_W Largeur de départ d'une trace (defun dep_w (tr / ang) (setq ang (- (angle (dxf 10 tr) (dxf 12 tr)) (angle (dxf 10 tr) (dxf 11 tr)) ) ) (if (minusp ang) (setq ang (+ (* 2 pi) ang)) ) (abs (* (sin ang) (distance (dxf 10 tr) (dxf 11 tr)))) ) ;; END_W Largeur de fin d'une trace (defun end_w (tr / ang) (setq ang (- (angle (dxf 12 tr) (dxf 10 tr)) (angle (dxf 12 tr) (dxf 13 tr)) ) ) (if (minusp ang) (setq ang (+ (* 2 pi) ang)) ) (abs (* (sin ang) (distance (dxf 12 tr) (dxf 13 tr)))) ) ;;; ************************ FONCTION PRINCIPALE ************************ ;;; ;; Sélection des objets (prompt "\nSélectionnez les traces à transformer < Toutes >: " ) (if (not (setq ss (ssget '((0 . "TRACE"))))) (setq ss (ssget "_X" '((0 . "TRACE")))) ) ;; Si la sélection existe (if ss (progn ;; Choix du type d'objet à créer (initget "Oui Non") (setq opt (getkword "\nJoindre les segments ? [Oui/Non] < O >: " ) ) (if (not opt) (setq opt "Oui") ) ;; Création d'une liste (tr_lst) contenant toutes les traces du dessin (setq n (sslength ss) cnt_t n cnt_p 0 ) (repeat n (setq n (1- n) tr_lst (cons (ssname ss n) tr_lst) ) ) ;_ Fin de repeat ;; Tant que tr_lst n'est pas vide (while tr_lst ;; Si option "Oui" (if (= opt "Oui") (progn ;; Mise en tête de liste d'une trace non jointive à son extrémité (while (vl-member-if '(lambda (x) (and (equal (dxf 12 (car tr_lst)) (dxf 10 x) 1e-009) (equal (dxf 13 (car tr_lst)) (dxf 11 x) 1e-009) ) ) (cdr tr_lst) ) ;_ Fin de vl-member-if (setq tr_lst (reverse (cons (car tr_lst) (reverse (cdr tr_lst)))) ) ) ;_ Fin de while ;; Création d'une liste des traces jointives (sub_lst) (setq sub_lst (cons (car tr_lst) sub_lst) tr_lst (cdr tr_lst) ) ;; Tant qu'il existe une trace jointive à la première de sub_lst (while (setq prec (car (vl-member-if '(lambda (x) (and (equal (dxf 10 (car sub_lst)) (dxf 12 x) 1e-009 ) (equal (dxf 11 (car sub_lst)) (dxf 13 x) 1e-009 ) ) ) tr_lst ) ;_ Fin de vl-member-if ) ) ;_ Fin de setq ;; Cette trace est ajoutée à sub_lst et supprimée de tr_lst (setq sub_lst (cons prec sub_lst) tr_lst (vl-remove prec tr_lst) ) ) ;_ Fin de while ) ;_ Fin de progn ;; Si option "Non" (setq sub_lst (cons (car tr_lst) sub_lst) tr_lst (cdr tr_lst) ) ) ;_ Fin de if ;; Création de la liste des sommets de la polyligne et des ;; largeurs aux sommets (setq pt_lst (apply 'append (mapcar '(lambda (x) (list (cons 10 (mid (dxf 10 x) (dxf 11 x))) (cons 40 (dep_w x)) (cons 41 (end_w x)) ) ) sub_lst ) ;_ Fin de mapcar ) ;_ Fin de apply ) ;_ Fin de setq (setq pt_lst (append pt_lst (list (cons 10 (mid (dxf 12 (last sub_lst)) (dxf 13 (last sub_lst)) ) ) ) ) ;_ Fin de append ) ;_ Fin de setq ;; Création de la polyligne (entmake (append (list '(0 . "LWPOLYLINE") '(100 . "AcDbEntity") '(100 . "AcDbPolyline") '(70 . 0) (cons 90 (/ (+ 2 (length pt_lst)) 3)) (cons 8 (dxf 8 (car sub_lst))) (cons 210 (dxf 210 (car sub_lst))) (cons 39 (dxf 39 (car sub_lst))) ) pt_lst ) ) ;_ Fin de entmake ;; Suppresion des traces traitées (mapcar 'entdel sub_lst) (setq sub_lst nil cnt_p (1+ cnt_p) ) ) ;_ Fin de while (prompt (strcat "\n\t" (itoa cnt_t) " traces ont été transformées en " (itoa cnt_p) " polylignes." ) ) ) ;_ Fin de progn (prompt "\nLe dessin ne contient pas de trace.") ) ;_ Fin de if (princ) ) ;_ Fin de defun [Edité le 2/3/2006 par (gile)] [Edité le 6/3/2006 par (gile)]

Merci Boris, Bonne nuit ...

Salut, Voici un LISP qui semble marcher (il est tard, je n'ai pas mis de commentaires, peut-être demain ...) : Version commentée ;;; tr2pl Transforme toutes les traces du dessin en autant de segments de lwpolyligne (defun c:tr2pl (/ ss e_lst ang) ;; Sélection de tous les objets "trace" (setq ss (ssget "_X" '((0 . "TRACE")))) ;; Si la sélection n'est pas vide, (if ss ;; pour chaque objet, (repeat (setq n (sslength ss)) (apply '(lambda (x) (setq e_lst (entget x)) ;; calcul de l'angle à l'extrémité (setq ang (- (angle (cdr (assoc 10 e_lst)) (cdr (assoc 12 e_lst))) (angle (cdr (assoc 10 e_lst)) (cdr (assoc 11 e_lst))) ) ) (if (minusp ang) (setq ang (+ ang (* pi 2))) ) ;; création de la polyligne (entmake (list '(0 . "LWPOLYLINE") '(100 . "AcDbEntity") '(100 . "AcDbPolyline") '(90 . 2) ; nombre de sommets '(70 . 0) ; ouverte (cons 8 (cdr (assoc 8 e_lst))) ;; sommet de départ (cons 10 (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2)) (cdr (assoc 10 e_lst)) (cdr (assoc 11 e_lst)) ) ) ;; sommet de fin (cons 10 (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2)) (cdr (assoc 12 e_lst)) (cdr (assoc 13 e_lst)) ) ) ;; largeur (cons 43 (* (sin ang) (distance (cdr (assoc 10 e_lst)) (cdr (assoc 11 e_lst)) ) ) ) (cons 210 (cdr (assoc 210 e_lst))) (cons 39 (cdr (assoc 39 e_lst))) ) ; fin de list ) ; fin de entmake ;; suppression de la trace (entdel x) ) ; fin de lambda (list (ssname ss (setq n (1- n)))) ) ; fin de apply ) ; fin de repeat ) ; fin de if (princ) ) ; fin de defun PS : en l'état, le LISP ne crée que des segments de polyligne (1 trace -> 1poly), je n'aurais ni le temps ni les moyens avant ce soir (après le boulot) de modifier le code pour qu'il joigne les segments en une unique poly quand les objets sources était jointifs.[Edité le 1/3/2006 par (gile)] [Edité le 2/3/2006 par (gile)]

AutoCAD fait tous les calculs pour les angles en radians, si tu fais : (setq ang (getangle "\nSpécifiez l'angle: ")) Si tu réponds 45 (avec AUNITS = 0, ANGBASE = 0.0 et ANGDIR = 0), la valeur attribuée à ang sera 0.785398 soit pi / 4 radians. Mais quand tu utilises command les valeurs d'angles doivent être exprimées dans les unités courantes, comme quand tu tapes une valeur d'angle à la ligne de commande. D'où l'intérêt de angtos qui traduit une valeur numérique en radians en une chaine de caractères représentant la valeur de l'angle dans le système d'unités courant (à moins de spécifier une valeur de AUNITS différente comme premier argument). (angtos (/ pi 4)) retourne "45.00" (avec AUNITS = 0, AUPREC = 2, ANGBASE = 0.0 et ANGDIR = 0). angtos peut être utilisé directement avec command -sans passer par un (atof (angtos ... ou un (read (angtos ...- parcque command accepte les valeurs numérique aussi bien sous forme de réél ou entier que sous forme de chaine de caractères. Pour reprendre ton exemple : (command "texte" pt ht [surligneur]45.0[/surligneur] "txt" "" ) fonctionne comme : (command "texte" pt ht [surligneur]"45.0"[/surligneur] "txt" "" ) ou comme : (command "texte" pt ht (angtos (/ pi 4) 0 14) "txt" "" ) L'intérêt de spécifier le deuxième argument pour angtos (14 étant le nombre maximal de décimales accepté) est de conserver toute la précision d'AutoCAD. Cet argument nécessite que le premier (unités) soit spécifié, d'où le (getvar "AUNITS") proposé plus haut pour récupérer le type d'unités courant. [Edité le 28/2/2006 par (gile)]

Ben, oui ... Le plus souvent, quand il y a une question en VisualLISP, c'est Patrick_35 qui a la solution ;)

Petite précision : GETANGLE tient compte des variables ANGDIR et ANGBASE GETORIENT ne tient pas compte de ces variables (toujours 0.0 à l'est et sens trigonmétrique) Sinon, pour d'autres raisons, j'avais commis 2 petits LISP ici (ang2str et str2ang) qui font comme ANGTOS et ANGTOF mais sans tenir compte des variables ci-dessus. (angtos (getorient)) équivaut donc à (ang2str (getangle)) et les deux fonctionnent quelques soient les valeurs de ANGDIR et ANGBASE. Si dans le cas qui nous préoccupe, l'angle est défini dans le LISP sans intervention de l'utilisateur (récupération des valeurs dxf 10 et 11 d'une ligne, par exemple) c'est bien la fonction ANGLE qu'il faut utiliser, et dans ce cas, ANGTOS fonctionne. [Edité le 28/2/2006 par (gile)]

Oui, je l'ai testée sur 2005, çà fonctionne. Je pense que Tramber a mis le doigt sur le hic, j'avais dit dans mon premier message (de manière pas très explicite, il est vrai :

J'ai trouvé, Patrick en parle ici et le téléchargement c'est là Mais chez moi la fonction ne marche pas vraiment, à l'écran, je ne vois ni clignotement ni changement de couleur et la fenêtre d'AutoCAD (F2) affiche 292 "Commande: _.redraw" :casstet:

(command "texte" pt [surligneur]ht (angtos pangle 0 8)[/surligneur] "txt" "" ) Devrait marcher, angtos retourne l'angle sous forme de chaine (accepté par command) en prenant en compte les variables AUNITS, AUPREC , ANGDIR et ANGBASE. Si ht est une variable (setq), il ne faut pas de guillemets. Pour que ta routine soit plus "universelle" (qu'elle marche pour ceux qui travaillent avec d'autres unité que les degrés) il faudrait écrire (angtos pangle (getvar "AUNITS") 8). [Edité le 27/2/2006 par (gile)]

Merci Patrick_35, je vais chercher çà.

Merci, c'est nettement plus propre que mon mauvais bricolage, mais tu l'as trouvée où, cette fonction ?

Ah ben là, je crois que j'ai compris :D Mais je peux pas essayer, j'ai pas 2006 :( Avec AutoCAD 2005 : http://img353.imageshack.us/img353/7636/jeu3xo.png [Edité le 26/2/2006 par (gile)]

Re, Si tu es effectivement sur 2006, tu n'as pas de chance, la personnalisation des icônes et des menus a changé, et c'est pas vraiment plus pratique, notamment pour les icônes. Je vais quand même essayer de t'expliquer ce dont je me souviens (je n'ai pas 2006 sous la main) Tout d'abord, pour ouvrir la boite de dialogue "Personnalisation de l'interface utilisateur" tape CUI ou IUP à la ligne de commande. Dans la partie gauche de la boite, en bas, il y a les commandes. Choisis "Nouvelle comande". Dans la partie droite, tu renommes "Nouvelle commande" (Mes fenêtres, par exemple) c'est ce nouveau nom qui s'affichera dans l'info bulle si tu fais une icone ou dans le Menu si tu fais un nouveau menu ou ajoute cette nouvelle commande à un menu existant. En dessous tu peux mettre un commentaire (c'est ce qui s'affichera sur la ligne d'état quand ton pointeur est sur l'icône). En dessous encore tu vas mettre la macro : ^C^C_-vports;_r;mesfenetres; Attention à bien recopier le code ! Tu peux bien sûr remplacer "mesfenetres" par ce que tu veux, mais ne rajoutes pas d'espace ou de caractères dans le reste de la macro (un espace équivaut à un "ENTER". Ensuite il faut faire une icône (sauf si tu veux seulement mettre ta nouvelle commande dans un menu) et là je ne sais plus très bien, je n'en ai pas fais beaucoup avec 2006. Je crois que le plus simple est de partir d'une icône existante que tu fais apparaître en haut de ce côté de la fenêtre. ensuite tu clique sur "Editer" et tu peux modifier l'icône dans la nouvelle boite de dialogue qui doit s'être ouverte. Tu enregistres ton icône et de retour dans la grande boite de dialogue tu charges le fichier .bmp que tu viens de créer dans la case "Petite icône". Voilà ta commande est à présent créée. Retour dans la partie gauche de la fenêtre, tu déploies l'arborescence des barres d'outils ou des menus et tu déposes ta nouvelle commande par cliquer/glisser là où tu le désires, dans une barre d'outils ou un menu existant ou que tu auras créé (clic droit -> Nouveau -> Renommer). Quant à l'autre commande (fenêtre unique) elle devrait déjà exister, tu dois pouvoir la retrouver dans les commandes (en bas à gauche). Mes explications ne sont peut-être pas très claires, tu peux aussi faire une recherche dans les forums avec CUI, icones ou personnaliser, et bien sûr consulter l'aide d'AutoCAD rubrique personnalisation. Et si un PRO de la 2006 passe par ici, il pourra compléter/corriger ce que j'ai dit. [Edité le 26/2/2006 par (gile)]

Et bien, voilà, LA PISTE AUX ÉTOILES ... Attention ce LISP n'est pas du tout un bon exemple pour les débutants, le style est particulièrement lourdingue, mais c'est le moyen employé pour avoir des clignotements. J'ai quand même fait l'effort de le commenter, puisque d'aucuns apprécient. Charger le code, taper STARS et attendre que çà finisse (c'est pas trop long). (defun c:stars (/ draw_star icon color star_lst ang col star n) ;; sous-routine pour la création d'une étoile (defun draw_star (cen ang dist / s1 s2 s3 s4 s5 s6 s7 s8 s9 s10) (setq s1 (polar cen ang dist) s3 (polar cen (+ ang (/ (* 2 pi) 5)) dist) s5 (polar cen (+ ang (/ (* 4 pi) 5)) dist) s7 (polar cen (+ ang (/ (* 6 pi) 5)) dist) s9 (polar cen (+ ang (/ (* 8 pi) 5)) dist) s2 (inters s3 s9 s1 s5) s4 (inters s1 s5 s3 s7) s6 (inters s3 s7 s5 s9) s8 (inters s5 s9 s1 s7) s10 (inters s1 s7 s3 s9) ) (command "_.pline" s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 "_close") ) ; fin de defun ;; Fonction principale ;; Début du groupe UNDO (command "_.undo" "_begin") ;; Sauvegarde des valeurs initiales de CECOLOR et UCSICON (setq color (getvar "cecolor") icon (getvar "ucsicon") ) ;; Désactivation de l'accrochage aux objets (setvar "osmode" (+ (getvar "osmode") 16384)) ;; Suppressin de l'affichage de l'icone SCU (setvar "ucsicon" 0) ;; Définition de l'angle et de la couleur de départ (setq ang (/ pi 2) col 1 ) ;; Réglage du zoom (command "_.zoom" "_w" '(-120 -80) '(120 80)) ;; 50 tours (repeat 50 ;; Création des 10 étoiles en cercle (repeat 10 (command "_.-color" col) ; Changement de couleur (draw_star (polar '(0 0) ang 50.0) ang 10.0); Création d'une étoile (setq star_lst (cons (entlast) star_lst)); Récupération de l'entité créée (command "_.hatch" "_s" (entlast) "") ; Hachurage "solide" (setq star_lst (cons (entlast) star_lst)) (setq ang (+ ang (/ pi 5)) ; Incrémentation de l'angle, col (cond ; et de la couleur ((zerop (rem (+ col 1) 6)) 6 ) (T (rem (+ col 1) 6)) ) ; fin de cond ) ; fin de setq ) ; fin de repeat 10 ;; Efface les entité créées (clignotement) (repeat (setq n 20) (command "_.erase" (nth (setq n (1- n)) star_lst) "") ) (setq star_lst nil) ;; Crée ou efface l'étoile centrale (1 tour sur 2) (cond (star (command "_.erase" star "") (setq star nil) ) (T (draw_star '(0 0) (/ pi 2) 20.0) (setq star (entlast)) (command "_.hatch" "_s" star "") (command "_.erase" star "") (setq star (entlast)) ) ) ; fin de cond ) ; fin de repeat 50 ;; Restauration de l'environnement initial (command "_.erase" (entlast) "") (command "_.undo" "_end") (setvar "osmode" (- (getvar "osmode") 16384)) (setvar "cecolor" color) (setvar "ucsicon" icon) ) ; fin de defun [Edité le 27/2/2006 par (gile)]

Salut, Deux petites macros à mettre dans des boutons ou des menus. Pour une fenêtre unique : ^C^C_-vports;_si; Pour des fenêtres nommées (mesfenetres): ^C^C_-vports;_r;mesfenetres; Nota : il faut que la fenêtre nommée mesfenetres ait été créée dans le dessin en cours. [Edité le 26/2/2006 par (gile)]

Tu as raison Tramber, je me suis laissé emporté par mon enthousisasme :casstet: En fait, c'est pas mieux :(

Un autre petit dessin, pour le fun :) Avec des SCU orthogonaux, c'est plus facile. Pour le ressort, un LISP ici. http://img106.imageshack.us/img106/9985/siphon0nl.png C'est ce que je dis dans le premier message, d'ailleurs le chemin jaune en est une. [Edité le 25/2/2006 par (gile)]