(gile)

Salut, Tu peux aussi utiliser le menu contextuel si tu paramètres le bouton droit pour les menus contextuels (il te reste les touches entrée et espace pour rappeller la dernière commande). http://img98.imageshack.us/img98/4586/sanstitredf8.png

Qui dit ombre dit 3D, j'ai donc un peu modifié le LISP pour qu'il fonctionne quelque soient le SCU courant et les SCO des polylignes.

Salut, C'est "brut de coffrage" et pas testé en profondeur, mais tu sauras l'améliorer ;) PS : ça ne fonctionne qu'avec les polylignes de largeur constante. (defun c:pl2r (/ os ec ss1 elst wid p1 p2 ang ss2 pl1 pl2) (setq os (getvar "osmode") ec (getvar "cmdecho") ) (if (setq ss1 (ssget '((0 . "LWPOLYLINE") (-4 . ">") (43 . 0)))) (progn (setvar "osmode" 0) (setvar "cmdecho" 0) (foreach pl (vl-remove-if 'listp (mapcar 'cadr (ssnamex ss1))) (setq elst (entget pl) wid (/ (cdr (assoc 43 elst)) 2) p1 (trans (append (cdr (assoc 10 elst)) (list (cdr (assoc 38 elst))) ) pl 1 ) p2 (trans (append (cdr (assoc 10 (cdr (member (assoc 10 elst) elst)))) (list (cdr (assoc 38 elst))) ) pl 1 ) ang (angle p1 p2) ss2 (ssadd) ) (command "_.offset" wid pl (polar p1 (+ ang (* pi 0.5)) 1.0) "" ) (setq pl1 (entlast)) (entmod (subst '(43 . 0) (assoc 43 (entget pl1)) (entget pl1)) ) (ssadd pl1 ss2) (command "_.offset" wid pl (polar p1 (+ ang (* pi 1.5)) 1.0) "" ) (setq pl2 (entlast)) (entmod (subst '(43 . 0) (assoc 43 (entget pl2)) (entget pl2)) ) (ssadd pl2 ss2) (command "_.line" (trans (append (cdr (assoc 10 (entget pl1))) (list (cdr (assoc 38 (entget pl1)))) ) pl1 1 ) (trans (append (cdr (assoc 10 (entget pl2))) (list (cdr (assoc 38 (entget pl2)))) ) pl2 1 ) "" ) (ssadd (entlast) ss2) (command "_.line" (trans (append (cdr (assoc 10 (reverse (entget pl1)))) (list (cdr (assoc 38 (entget pl2)))) ) pl1 1 ) (trans (append (cdr (assoc 10 (reverse (entget pl2)))) (list (cdr (assoc 38 (entget pl2)))) ) pl2 1 ) "" ) (ssadd (entlast) ss2) (command "_.region" ss2 "") (command "_.erase" ss2 "") ) ) ) (setvar "osmode" os) (setvar "cmdecho" ec) (princ) ) [Edité le 3/11/2006 par (gile)]

Salut, Je pense que les calculs sont faits avec 16 décimales, mais il y a forcément une perte de précision, notament avec des rotations 3D de SCU. Personnellement, dans des tests de comparaisons entre coordonnées avec une tolérence au millardième (9 décimales) je n'ai jamais été pris en défaut. Ce qui reste tout à fait raisonnable un milliardième c'est un micron pour un kilomètre ;)

Salut et bienvenue, Les solides offrent plus de possibilités que les surfaces. Tu peux extraire l'intersection de deux solides (intersect) puis copier des arrêtes (edition de solides). http://img169.imageshack.us/img169/7830/penetrit7.png [Edité le 3/11/2006 par (gile)]

As-tu bien cliqué sur le bouton (dans la rectangle rouge) ? http://img112.imageshack.us/img112/7015/raccourci2yk2.png Puis dans la boite de dialogue appuyé sur SHIFT et F3 ? http://img518.imageshack.us/img518/6239/raccourci3lg1.png

Salut et bienvenue, Pour extraire des blocs (même sans attributs) tu peux utiliser la commande EXTATTBE (ou _EATTEXT). Pour des calculs de surfaces tu peux utiliser le LISP pline_block, voir ce sujet, puis faire une extraction.

Salut, Tu peux essayer comme ça, en appelant et en renseignant chaque options : ^C^C_-insert;bloc;x;;y;;z;;r;;/;

Salut, Tu ouvres la fenêtre "Personnaliser l'interface utilisateur" (commande CUI ou IUP), Tu crées une nouvelle commande (appelée Osnaphatch dans l'exemple), avec la macro suivante : 'osnaphatch $M=$(if,$(getvar,osnaphatch),0,1) Tu fais glisser cette commande dans l'arborescece des "Raccourcis clavier" > "Touches de raccourci". Tu la sélectionnes, et tu cliques dans la partie "Touches" des "Propriétés", puis tu cliques sur le bouton avec 3 petits point (...) et ensute dans la boite de dialogue qui s'ouvre tu tapes ton ensemble de touche (SHIFT+F3), OK, OK. http://img266.imageshack.us/img266/1629/raccourcive7.png Voir dans l'aide : Guide de personnalisation >> Personnalisation de l'interface utilisateur >> Ajout de touches de raccourci et de touches de remplacement temporaire [Edité le 2/11/2006 par (gile)]

Comme dit plus haut, substr traite une chaine de caractères (premier argument). Tu veux traiter une liste, donc oublie substr. Comme dit plus haut toujours, pour avoir la somme de tous les nombres contenus dans list_plength, tu peux utiliser la fonction apply : (apply '+ '(1.414 1.732 2.285)) ->5.431 La fonction apply équivaut à un (eval (cons ...)), on pourait donc écrire : (eval (cons '+ '(1.414 1.732 2.285))) qui est interprété, en décomposant : (eval '(+ 1.414 1.732 2.285))) -> (+ 1.414 1.732 2.285) -> 5.431

Salut, Le LISP ne fait que désactiver les accrochages aux objets le temps de dessiner la spline, puis les restaure. C'est peut-être en faisant "ANNULER" ("U"), et en ne remontant pas j'usqu'à annuler la désactivation des accrochages, que tes "parametres d'aide au dessin sautent". Je modifie le LISP pour faire un groupe d'annulation de façon à ce qu'en annulant une seule opération, tout soit annulé.

Salut, La commande contour analyse les éléments visibles, les projette sur le plan XY du SCU courant (quelque soit leur élévation ou orientation) ainsi que la point spécifié et cherche un contour fermé autour de ce point projeté, puis crée une polyligne ou une région si le contour existe. Je vois mal comment un LISP pourrait faire ça mieux. Si tu veux accélérer la procédure, tu peux zoomer pour limiter le nombre d'éléments visibles à l'écran, sachant que le contour que tu veux faire doit être, lui, entièrement visible.

substr est une fonction qui retourne une portion de chaine de caractère (string) : (substr "string" 3) retourne "ring" (substr "string" 2 3) retourne "tri" Je ne comprends pas bien ce que tu veux faire, alors quelques exemples : (nth 0 '(1.414 1.732 2.285)) retourne 1.414 pemier élément (nth 1 '(1.414 1.732 2.285)) retourne 1.732 deuxième élément (nth 2 '(1.414 1.732 2.285)) retourne 2.285 troisième élément (member 1.732 '(1.414 1.732 2.285)) retourne (1.732 2.285) la liste à partir de 1.732 Hé ben, c'est qui Lucky Luke ? [Edité le 31/10/2006 par (gile)]

Bonsoir, J'ai essayé de faire une réponse polyvalente avec une fonction plus aboutie. Les dimensions proposées par défaut pour la pointe de la flèche sont celles des flèches des cotes courantes (type Fermée pleine). Les valeurs utilisées (longueur de la pointe et rapport hauteur/largeur) seront reproposées au prochain lancement de la commande dans le dessin. Après le dessin de la pointe, l'utilisateur reprend la main, et peut dessiner des segments droits ou en arc. Le repérage polaire par rapport au dernier segment est activé pour faciliter le dessin d'un segment dans le prolongement de la pointe. Nouvelle version (defun c:ARROW (/ asn pol arrow_err leng ratio start ang) (defun arrow_err (msg) (if (= msg "Fonction annulée") (princ) (princ (strcat "\nErreur: " msg)) ) (command) (setvar "AUTOSNAP" asn) (setvar "POLARMODE" pol) (setq *error* m:err m:err nil ) (princ) ) (setq asn (getvar "AUTOSNAP") pol (getvar "POLARMODE") m:err *error* *error* arrow_err ) (if (not *arrow-length*) (setq *arrow-length* (if (= 0 (getvar "DIMASZ")) (if (= 0 (getvar "DIMSCALE")) 1.0 (getvar "DIMSCALE") ) (if (= 0 (getvar "DIMSCALE")) (getvar "DIMASZ") (* (getvar "DIMSCALE") (getvar "DIMASZ")) ) ) ) ) (if (not *arrow-ratio*) (setq *arrow-ratio* (/ 1.0 3)) ) (if (not (setq leng (getdist (strcat "\nLongueur de la pointe (rtos *arrow-length*) ">: " ) ) ) ) (setq leng *arrow-length*) (setq *arrow-length* leng) ) (if (not (setq ratio (getreal (strcat "\nRapport hauteur/largeur de la pointe (rtos *arrow-ratio*) ">: " ) ) ) ) (setq ratio *arrow-ratio*) (setq *arrow-ratio* ratio) ) (initget 1) (setq start (getpoint "\nPoint de départ de la flèche: ")) (initget 1) (setq ang (getorient start "\nAngle de la flèche")) (command "_.pline" start "_W" 0.0 (* leng ratio) (polar start ang leng) "_W" 0.0 0.0 ) (if (= 0 (getvar "ORTHOMODE")) (progn (setvar "POLARMODE" (+ pol (boole 2 1 pol))) (setvar "AUTOSNAP" (+ asn (boole 2 24 asn))) ) ) (while (not (zerop (getvar "CMDACTIVE"))) (command pause) ) (setvar "AUTOSNAP" asn) (setvar "POLARMODE" pol) (setq *error* m:err m:err nil ) (princ) ) Pour Yalta, Si tu veux donner une largeur de polyligne de 0.13 au(x) segment(s), remplace : (command "_.PLINE" start "_W" 0.0 (* leng ratio) (polar start ang leng) "_W" [surligneur]0.0 0.0[/surligneur] ) par : (command "_.PLINE" start "_W" 0.0 (* leng ratio) (polar start ang leng) "_W" [surligneur]0.13 0.13[/surligneur] ) [Edité le 31/10/2006 par (gile)] [Edité le 1/11/2006 par (gile)]

Re, Au vu des remarques, j'ai modifié le code ci-dessus. Vue la méthode utilisée, le produit du nombre de spires par le nombre de points de lissage doit être un entier. Dans la première version, pour simplifier je limitais le nombre de spires à un nombre entier. On peut désormais entrer un nombre réel (ou fraction) pour le nombre de spires. Si le produit nombre de spires par nobre de points de lissage n'est pas un entier, il est arrondi à l'entier le plus proche. Exemple : -nombre de spires = 2.7 points de lissage = 12 - > 12*2.4=28.8 arrondi à 29 soit un nombre de spires réel de 29/12=2.41666... Alors là, vraiment je ne comprends pas ce que tu veux dire. Dans l'exemple ci-dessus, il est demandé 2 spires, et il est réalisé 2 spires. Il est désormais possible de choisir entre un pas à droite (défaut) ou un pas à gauche. Je te souhaite d'arriver à faire une bicyclette ;) Pour un peu "alléger" la commande, il est possible de supprimer la dernière invite et de systématiquement effacer le maillage, en remplaçant : (initget "Oui Non") (if (/= "Non" (getkword "\nEffacer la surface de révolution ? [Oui/Non] : " ) ) (entdel surf) ) par (entdel surf)

Ma méthode est simple, comme la seule entité AutoCAD pour tracer ce type de courbe est la spline, il faut déterminer des points de lissage. Pour avoir une succession de points incrémentés en hauteur et de manière angulaire situés sur le profil (surface ou solide de révolution), le plus simple, à mon avis, est de récupérer la liste des sommets d'une surface de révolution (maillage polygonal) puis dans cette liste ne retenir que les points qui nous intéressent : un pour chaque maille horizontale décalé d'une maille verticale à chaque fois (comme un escalier). Ces points servent ensuite à créer la spline. Tu peux essayer le LISP, après avoir sélectionné l'objet (spline ou polyligne) qui subira a révolution et l'axe de révolution, il faut spécifier le nombre de spires puis le nombre de points de lissage par spire (ce qui donnera la précision). Le maillage est créé en fonction de ces paramètres, il est proposer de le supprimer quand la spline est dessinée.

C'est fait, j'ai modifié le code ci-dessus.

Quelque chose comme ça ? (defun c:ARROW (/ SP ANGP ARRANG LENG EP) (setq LENG (getdist "\nLongueur de la pointe: ")) (setq RAP (getreal "\nRapport hauteur\\largeur de la pointe: ")) (setq SP (getpoint "\nPoint de départ de la flèche: ")) (setq ANGP (getpoint SP "\nAngle de la flèche")) (setq ARRANG (angle sp angp)) (setq EP (polar sp arrang LENG)) (command "_.PLINE" sp "_W" "0.0" (* LENG RAP) EP "_W" "0.0" "0.0" "_ARC" ) ) [Edité le 30/10/2006 par (gile)]

Salut, Il faut mettre la variable système UCSFOLLOW à 0, et ce, dans chaque fenêtre.

Voilà un petit LISP (je ne connais pas le VBA), qui crée une spline suivant les sommets d'un maillage (surface de révolution). http://img172.imageshack.us/img172/3864/spirevnn4.png Nouvelle version (01/11/06) Invites : Commande: spirev Sélectionnez l'objet qui subira une révolution: Sélectionnez l'objet qui définit l'axe de révolution: Spécifiez le nombre de spires: 2 Spécifiez le nombre de points de lissage par spire: 30 Spécifiez le sens du pas [Droite/Gauche] : Effacer la surface de révolution ? [Oui/Non] : Le code : (defun c:spirev (/ OS EC S1 S2 sp_err prof axe prec sens tr ent surf mv nv pt pts n lst) (defun sp_err (msg) (if (= msg "Fonction annulée") (princ) (princ (strcat "\nErreur: " msg)) ) (command) (command "_.undo" "_end") (setvar "SURFTAB1" S1) (setvar "SURFTAB2" S2) (setvar "CMDECHO" EC) (setvar "OSMODE" OS) (setq *error* m:err m:err nil ) (princ) ) (setq OS (getvar "OSMODE") EC (getvar "CMDECHO") S1 (getvar "SURFTAB1") S2 (getvar "SURFTAB2") m:err *error* *error* sp_err ) (while (not (setq prof (car (entsel "\nSélectionnez l'objet qui subira une révolution: " ) ) ) ) ) (while (not (setq axe (car (entsel "\nSélectionnez l'objet qui définit l'axe de révolution: " ) ) ) ) ) (initget 7) (setq tr (getreal "\nSpécifiez le nombre de spires: ")) (initget 7) (setq prec (getint "\nSpécifiez le nombre de points de lissage par spire: " ) ) (initget "Droite Gauche") (if (/= (setq sens (getkword "\nSpécifiez le sens du pas [Droite/Gauche] : " ) ) "Gauche" ) (setq sens "Droite") ) (command "_.undo" "_begin") (setvar "SURFTAB1" prec) (setvar "SURFTAB2" (round (* prec tr))) (setvar "CMDECHO" 0) (setvar "OSMODE" 0) (command "_.revsurf" prof axe "" "") (setq ent (entlast) surf ent mv (cdr (assoc 71 (entget ent))) nv (cdr (assoc 72 (entget ent))) ) (while (setq pt (cdr (assoc 10 (entget (entnext ent))))) (setq ent (entnext ent) pts (cons (trans pt 0 1) pts) ) ) (setq pts (reverse pts) lst (list (nth 0 pts)) ) (if (= sens "Droite") (setq n 0) (setq n (* nv mv)) ) (repeat (1- nv) (if (= sens "Droite") (setq n (rem (+ 1 nv n) (* nv mv))) (setq n (- n (1- nv))) ) (if (minusp n) (setq n (+ n (* nv mv))) ) (setq lst (cons (nth n pts) lst)) ) (command "_.spline") (mapcar 'command (reverse lst)) (command "" "" "") (initget "Oui Non") (if (/= "Non" (getkword "\nEffacer la surface de révolution ? [Oui/Non] : " ) ) (entdel surf) ) (command "_.undo" "_end") (setvar "SURFTAB1" S1) (setvar "SURFTAB2" S2) (setvar "CMDECHO" EC) (setvar "OSMODE" OS) (setq *error* m:err m:err nil ) (princ) ) ;;; Arrondit un nombre à l'entier le plus proche (defun round (num) (if ( (abs (- num (1+ (fix num)))) ) (fix num) (1+ (fix num)) ) ) [Edité le 31/10/2006 par (gile)] [Edité le 1/11/2006 par (gile)]

Re, Normalement, si on peut le dessiner, on doit pouvoir le programmer, mais ça n'est pas toujours simple. Je ne peux rien te promettre, mais je vais essayer de faire quelque chose. Je viens d'avoir une idée pour dessiner la spline à partir des sommets d'une surface de révolution. http://img410.imageshack.us/img410/60/torsades4vq9.png

Un exemple : http://img64.imageshack.us/img64/3440/torsadesnq7.png Et un petit rendu : http://img130.imageshack.us/img130/9392/torsades3gc2.png [Edité le 29/10/2006 par (gile)]

Salut, Je ne pense pas que tu puisse faire ça à partir d'une hélice. L'hélice (nouveauté 2007) s'inscrit autour d'un cylindre ou d'un cône. Tu vas devoir faire un peu comme "sur le papier" définir les points de lissage de ton "hélice" et la dessiner avec une SPLINE qui pourra servir de chemin pour extruder ton profil avec les commande LISSAGE ou BALAYAGE

Re, Peut-être n'est tu pas familier avec les fonctions vla-... Pour faire la même chose en AutoLISP, ce qui n'est pas vraiment plus simple : ;;; Récupérer la liste DXF du dictionnaire des présentations (setq layout_dict (dictsearch (namedobjdict) "ACAD_LAYOUT")) ;;; Faire une liste des noms d'entités de toutes les présentations (setq layout_ename_lst (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= 350 (car x))) layout_dict ) ) ) ;;; faire une liste de paires pointées du type : ;;; (numéro_d'ordre . nom_de_la_présentation) (setq laypout_assoc_lst (mapcar '(lambda (x) (cons (cdr (assoc 71 (entget x))) (cdr (assoc 1 (reverse (entget x)))) ) ) layout_ename_lst ) ) ;;; faire la liste des nom_de_présentation triée par leur numéro_d'ordre ;;; privée de son premier élément : "model" (setq layout_lst (cdr (mapcar 'cdr (vl-sort laypout_assoc_lst '(lambda (x1 x2) ( ) ) ) ) [Edité le 29/10/2006 par (gile)]

Salut, (vlax-for l (vla-get-layouts (vla-get-ActiveDocument (vlax-get-acad-object)) ) (setq lst (cons (cons (vla-get-TabOrder l) (vla-get-Name l)) lst)) ) (setq lst (cdr (mapcar 'cdr (vl-sort lst '(lambda (x1 x2) ( ) ) )