(gile)

Peut-être une solution ici.

Je pensais avoir trouvé un moyen pour éviter de passer par un SOLPROF (pour les versions postérieures à 2004) : Utiliser le Cacher de la barre d'outils Rendus et sélectionner l'option Comme affiché dans le Tracé de l'ombrage de la fenêtre. http://img126.imageshack.us/img126/8251/caches0ic.png En fait c'est pareil :( [Edité le 25/2/2006 par (gile)]

Salut et bienvenue, Ta question n'est pas très précise, mais je vais essayer d'y répondre. Si ton tuyau suit des courbes dans un même plan, pas de problème, AutoCAD peut extruder les objets graphiques fermés (polyligne, cercle, ellipse, région) le long d'un chemin 2D (ligne, polyligne, spline). Mais AutoCAD ne permet pas encore d'extruder suivant un chemin courbe 3D (non contenu dans un plan). Il faut alors avoir recours à certains artifices. Tu peux utiliser une polyligne 3D comme chemin, mais les 3Dpolys ne sont constituées que de segments de droite. Un autre moyen consiste à décomposer le chemin en différents objets jointifs construits dans des plans différents (SCU pivotés), d'extruder le cercle suivant le premier chemin puis d'utiliser l'option Extruder des faces des commandes Edition de solides pour les chemins suivants. Un petit exemple en dessin : http://img525.imageshack.us/img525/7650/tuyau1sl.png Dans la fenêtre de gauche : le cercle rouge est la section du futur solide (l'objet à extruder), le chemin d'extrusion est composé de polylignes (de couleurs différentes) créées dans des plans différents. Dans la fenêtre de droite le solide final. Bon courage !

Salut Pingoo, Je me permet de te recommander d'utiliser l'éditeur VisualLisp pour créer tes LISP, c'est un outil puissant, ne serait-ce que pour l'appariement des paranthèses. Par exemple, un double clic devant une paranthèse ouvrante (ou derrière une fermente) sélectionne tout le code jusqu'à la paranthèse fermante (ou ouvrante) correspondante.

Pour Pingoo, Difficile de dire si l'erreur provenait du manque de la paranthèse pour fermer le (while ... ou de la définition des variables inc ou taille_list_pt, étant donné que tu ne donnes qu'un extrait de ton code. En tout cas, comme çà, çà marche : [color=#CC0000](setq taille_list_pt (length list_pt2d_tmp)) (setq inc 0)[/color] (command "_3dpoly") (while ( (setq pointz (car list_pt_tmp)) (setq pointxy (car list_pt2d_tmp)) (setq x (list (car pointxy))) (setq y (list (cadr pointxy))) (setq z (list (caddr pointz))) (setq pt (append x y z)) (command pt) (setq list_pt_tmp (cdr list_pt_tmp)) (setq list_pt2d_tmp (cdr list_pt2d_tmp)) (setq inc (+ 1 inc)) [color=#CC0000])[/color] (command "") pour Tramber, je suis, en effet, assez sensible au "style" et je crois que si le LISP me plait tant c'est en partie à cause de çà. Certaines expressions sont d'une "pureté" qui m'émeut vraiment. Je dois avouer que je n'ai pas trouvé tout seul (mapcar 'command pts), mais que je l'ai lue quelque part, dans la FAQ AutoLISP sûrement, c'est une véritable "bible" pour ce genre d'effets de style. [Edité le 25/2/2006 par (gile)]

Salut, Je pense comme Tramber, sans vouloir t'imposer mon style, il me semble préférable de traiter d'abord la liste de points : si j'ai bien compris, tu récupères les coordonnées x et y à partir d'une liste (list_pt2d_tmp) et le z à partir d'une autre (list_pt_tmp). Tu peux faire la liste des sommets de la façon suivante : (setq pts (mapcar '(lambda (p1 p2) (list (car p1) (cadr p1) (caddr p2))) list_pt2d_tmp list_pt_tmp ) ) Et ensuite créer la polyligne directement à partir de la nouvelle liste (si elle existe) : (if pts (progn (command "_3dpoly") (mapcar 'command pts) (command "") ) )

Salut, C'est avec la commande SOLPROF que l'on choisit les solides (dans l'espace objet de la fenêtre de présentation) dont on veut générer des vues 2D (orthogonales, isométriques ou perspective).

Et Zebulon_ , et Ludwig, et Mlon, et Maximilien ... ... et on en oubliera toujours quelques uns !!!

Merci Boris, mais "star" ... :red: ... n'exagérons rien, juste ex-débutant passionné et bavard. À propos de star, pour salvanorigatore, un de mes premiers LISP, auquel j'ai rajouté force commentaires, il est très facile à comprendre. Si je peux rajouter un conseil, ne pas hésiter à consulter l'aide sur les fonction AutoLISP, en plus, çà pousse à se remettre à l'anglais: ;;; C:STAR Crée une étoile à 5 branches - 10/04/05 - (defun c:star (/ v c a d s1 s2 s3 s4 s5 s6 s7 s8 s9 s10) ;; Enregistrement de la valeur initiale de OSMODE (setq v (getvar "osmode")) ;; Début du groupe UNDO (command "_undo" "_begin") ;; Entrées utilisateur (initget 1) (setq c (getpoint "\nSpécifiez le centre de l'étoile: ")) (initget 1) (setq s1 (getpoint c "\nSpécifiez le sommet d'une des branches: ")) ;; Désactivation des accrochages aux objets (setvar "osmode" 0) ;; Calcul des sommets (setq a (angle c s1) d (distance c s1) s3 (polar c (+ a (/ (* 2 pi) 5)) d) s5 (polar c (+ a (/ (* 4 pi) 5)) d) s7 (polar c (+ a (/ (* 6 pi) 5)) d) s9 (polar c (+ a (/ (* 8 pi) 5)) d) 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) ) ;; Création de la polyligne (command "_pline" s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 "_close") ;; Fermeture du groupe UNDO (command "_undo" "_end") ;; Restauration de la valeur initiale de OSMODE (setvar "osmode" v) ;; Fin "silencieuse" (princ) )

Salut, Il me semble me souvenir (ici, je n'ai pas accès aux fichiers support d'AutoCAD) que c'est dans le fichier AutoCAD.mnl.

Salut, Pour créer une icône déroulante, dans la fenêtre Personnaliser l'interface utlisateur (commande CUI ou IUP), onglet Personnaliser, arborescene Barres d'outils tu fais clic droit et Nouveau -> Icône déroulante puis "cliquer/glisser" des commandes que tu veux dans ton icône déroulante. Tu peux aussi faire tout simplement un "cliquer/glisser" (avec la touche CTRL enfoncée si tu veux copier plutôt que déplacer) de la barre d'outils que tu veux insérer dans ton icône déroulante à l'intérieur de l'arboresence de la barre d'outils dans laquelle tu veux la placer (même procédure pour les sous-menus). Je reconnais que les CUI sont déroutants (habitude, quand tu nous tiens ...) et peu commodes pour faire une icône, mais les "cilquer/glisser" de commandes, menus, barres d'outils dans les arborescences sont bien pratiques. Pour ce qu'il en est de la modification ds fichiers .cui, il me semble que c'est possible avec un éditeur de texte, mais il faut connaître le langage XML. [Edité le 22/2/2006 par (gile)]

Salut, Je ne pense pas qu'il s'agisse d'une variable. Il y a dans certaines commande, une option par défaut ; dans la syntaxe AutoCAD elle est mis entre . Exemples : pour [Multiple] il faut taper M pour il suffit de faire "Enter" pour Oui taper O pour Non taper N ou "Enter" [Edité le 22/2/2006 par (gile)]

Salut, Si sur le poste en question, la souris est une Logitech, il me semble me souvenir qu'il faut paramétrer la roulette comme étant le bouton du milieu. Çà se fait dans un petit programme qui s'installe avec le pilote de la souris.

Salut, Voici un petit LISP vite fait qui change l'ellipse sélectionnée en polyligne (fonctionne avec PELLIPSE) et lui donne la largeur spécifiée. (defun c:el2wpl (/ pel ent l_ent cen ext dist larg) (setq pel (getvar "PELLIPSE")) (while (not (and (setq ent (car (entsel "\nSélectionnez une ellipse: "))) (= (cdr (assoc 0 (setq l_ent (entget ent)))) "ELLIPSE") ) ) (princ "\nL'objet n'est pas une ellipse") ) (setq cen (cdr (assoc 10 l_ent)) ext (mapcar '+ cen (cdr (assoc 11 l_ent))) dist (* (cdr (assoc 40 l_ent)) (distance cen ext)) larg (getdist "\nSpécifiez la nouvelle largeur pour tous les segments: ") ) (foreach pt '(cen ext) (set pt (trans (eval pt) 0 1)) ) (setvar "PELLIPSE" 1) (setvar "OSMODE" (+ (getvar "OSMODE") 16384)) (command "_ellipse" "_c" cen ext dist) (command "_pedit" (entlast) "_width" larg "") (command "_erase" ent "") (setvar "PELLIPSE" pel) (setvar "OSMODE" (- (getvar "OSMODE") 16384)) (princ) ) Pour l'utiliser (j'explique comme si tu étais un débutant complet, ne t'en offusques pas si ce n'est pas le cas), tu copies le code ci dessus dans le bloc-note, tu l'enregistres sous el2wpl.LSP (par exemple). Puis, dans AutoCAD, dans le dessin courant, tu fais menu Outils -> Charger une application... tu charges ton fichier .LSP et tu tapes el2wpl à la ligne de commande (pour tous les LISP, la commande c'est ce qu'il y a après le c: au début du code). Attention ce LISP ne crééra que des ellipses fermées (la commande ellipse avec PELLIPSE à 1 n'a pas d'option arc) Sinon tu trouveras ici un autre LISP (c-e) pour transformer les cercles en ellipse ou vice-versa, et là un autre (arcedit) qui tranforme un cercle ou une ellipse en arc ou vice-versa. Ces deux derniers LISP (beaucoup mieux aboutis) permettent la sélection de l'objet avant de lancer la commande. [Edité le 22/2/2006 par (gile)]

Quand j'ai démarré ce sujet, je pensais aider, à mon niveau, les plus débutants que moi, avec des astuces abordables par le plus grand nombre, mais, émulation aidant, la barre est rapidement montée bien haut ! Certes, mais la crétion de certains objets graphiques reste plus simple, plus accessible, avec command qu'avec vla-add... ou entmake. Par exemple, pour faire une LWpolyligne dans le SCU courant à partir d'une liste de points définis dans le SCU, il n'y a pas photo ! avec command : (setvar "osmode" (+ (getvar "osmode") 16384)) (command "_pline") (mapcar 'command pts) (command "") (setvar "osmode" (- (getvar "osmode") 16384)) avec entmake : (setq ucszdir (trans '(0 0 1) 1 0 T)) (entmake (append (list '(0 . "LWPOLYLINE") '(100 . "AcDbEntity") '(100 . "AcDbPolyline") '(70 . 0) (cons 90 (length pts)) (cons 38 (- (caddr (car pts)) (caddr (trans '(0 0) 0 1)))) (cons 210 ucszdir) ) (mapcar '(lambda (pt) (cons 10 (trans pt 1 ucszdir))) pts) ) ) avec vla-addLightweightPolyline (setq AcDoc (vla-get-activedocument (vlax-get-acad-object)) ModSp (vla-get-ModelSpace AcDoc) Norm (trans '(0 0 1) 1 0 T) lst (apply 'append (mapcar '(lambda (x) (setq x (trans x 1 Norm)) (list (car x) (cadr x)) ) pts ) ) ) (setq pline (vla-addLightweightPolyline ModSp (vlax-make-variant (vlax-SafeArray-fill (vlax-make-SafeArray vlax-vbDouble (cons 0 (- (length lst) 1) ) ) lst ) ) ) ) (vla-put-Elevation pline (- (caddr (car pts)) (caddr (trans '(0 0) 0 1))) ) Ceci dit l'exemple est choisi avec un peu de mauvaise foi ;) ,je ne cesse de découvrir la puissance et les côtés pratiques du VisualLISP en essayant de "visualiser" mes routines. J'ai un peu essayé aussi, il me semble même que parfois un : (if (not (vl-catch-all-error-p (vl-catch-all-apply ... soit le seul moyen d'obtenir un nil à la place d'une erreur et que la fonction puisse continuer. Merci encore à vous tous pour l'intérêt que vous portez à mes "bidouilles"

J'ai regardé d'un peu plus près et fais quelques tests avec le code de Maximilien. Tout d'abord, BRAVO ! D'un point de vue général : - j'aime beaucoup la manière de gérer à partir d'une liste unique les (setvar ...), (setq ...) et (command ...). - j'aime moins le fait que la liste des variables soit définie "à priori", cela suppose une liste fort longue (celle proposée, ne contient pas toutes les variables suceptibles d'être modidfiées dans tous les LISP que j'utilise) et manque donc, à mon goût, de souplesse. En ce qui concerne la gestion du groupe UNDO, je me permettrais deux petites remarques : - l'option "3" dans (command "_.UNDO" "_CONTROL" "3") me semble curieuse et n'est pas acceptée chez moi, il me semble que les options pour (command "_.UNDO" "_CONTROL" ...) sont : "_ALL", "_NONE" et "_ONE", je remplacerais donc "3" par "_ALL". - mettre CMDECHO à 0 avant de constituer le groupe UNDO fait que ce changement de variable n'est pas inclus dans le goupe UNDO (cmdecho reste à 0 dans le cas d'une seule annulation après execution du LISP). Par rapport à la dernière remarque, il serait possible de metrre CMDECHO à 0 après avoir fait le (command "_.undo" _begin") auquel cas un echo sera renvoyé sur la ligne de commande pour ce (command "_.undo" _begin"). Il existe, depuis v2004 (je crois), une routine dans le fichier ai_utils.lsp qui permet de palier à ce problème : ;;; Set CMDECHO without undo recording (ai_utils.lsp) ;;; ;;; This is useful for LISP defined commands that use UNDO grouping ;;; so that a single undo group is recorded in the undo/redo history ;;; Otherwise, the setting of the CMDECHO value may result in an ;;; additional "Group of Commands" entry in the undo/redo history. ;;; (defun ai_setCmdEcho (newVal / _oldEnvVal) ;; Only do it if the value is different than the current value (if (/= newVal (getvar "CMDECHO")) (progn (setq _oldEnvVal (getenv "acedChangeCmdEchoWithoutUndo")) ;; If not set yet, use 0 for default (if (not _oldEnvVal) (setq _oldEnvVal "0") ) (setenv "acedChangeCmdEchoWithoutUndo" "1") (setvar "cmdecho" newVal) (setenv "acedChangeCmdEchoWithoutUndo" _oldEnvVal) ) ) ) Attention le fichier ai_utils.lsp n'est pas chargé automatiquement par AutoCAD, il faut donc copier la routine dans un fichier .lsp (ou .mnl) chargé pour chaque dessin. De mon côté, je préfère avoir plusieurs routines que j'utilise ou pas suivant les besoins de chaque LISP. J'essaye de les faire le plus possible polyvalentes et compatibles entre elles. Elles sont regoupées dans un fichier Gile_utils.lsp dont le chargement est automatiquement commandé depuis les fichiers .MNL de mes menus personnalisés. Par exemple, j'utilise ai_setCmdEcho notamment dans deux routines qui ouvrent et ferment un groupe UNDO : ;;; GILE_UNDO_BEGIN et GILE_UNDO_END d'après ai_undo_push et ai_undo_pop (acad.mnl) ;;; Utilisation de ai_setCmdEcho (défini dans ai_utils.lsp) (defun GILE_UNDO_BEGIN (/ old_echo) (setq old_echo (getvar "cmdecho") undo_init (getvar "undoctl") ) (ai_setCmdEcho 0) (cond ((and (= 1 (logand undo_init 1)) (/= 2 (logand undo_init 2)) (/= 8 (logand undo_init 8)) ) (command "_.undo" "_begin") ) (T) ) (if (= 4 (logand undo_init 4)) (command "_.undo" "_auto" "_off") ) (ai_setCmdEcho old_echo) ) (defun GILE_UNDO_END (/ old_echo) (setq old_echo (getvar "cmdecho")) (ai_setCmdEcho 0) (cond ((and (= 1 (logand undo_init 1)) (/= 2 (logand undo_init 2)) (/= 8 (logand undo_init 8)) ) (command "_.undo" "_end") ) (T) ) (if (= 4 (logand undo_init 4)) (command "_.undo" "_auto" "_on") ) (ai_setCmdEcho old_echo) ) Ainsi qu'une routine GILE_RESTORE à placer à la fin de la "fonction mère". cette routine polyvalente fonctionne qu'un groupe UNDO est été constitué ou non, que *error* ait été redéfinie ou non, que des variables systéme aient été modifiées ou non avec SAVE&SET_VAR ou que seul CMDECHO ait été modifié avec ai_setCmdEcho : ;;; GILE_RESTORE Fonction polyvalente de restauration de l'environnement initial (defun GILE_RESTORE () (if undo_init (GILE_UNDO_END) ) (if SavedSysVarLst (RESTORE_VAR) ) (if old_echo (ai_setCmdEcho old_echo) ) (if m:err (setq *error* m:err m:err nil ) ) ) Cette dernière routine peut être appelée à la fin de la redéfinition de *error* : ;;; GILE_ERR Redéfinition de *error* ;;; Ferme le groupe "undo", s'il existe, et restaure la valeur initiale des variables. (defun GILE_ERR (msg) (if (or (= msg "Fonction annulée") (= msg "quitter / sortir abandon") ) (princ) (princ (strcat "\nErreur: " msg)) ) (command) (GILE_RESTORE) ) Il me reste maintenant à essayer de m'inspirer de la routine de Maximilien pour améliorer SAVE&SET_VAR et RESTORE_VAR afin qu'elles fonctionnent aussi avec (command ...) et (setq ...) (à suivre ...)

Merci Maximilien, Je vais étudier çà de près.

Extrait de l'aide pour la variable système BLIPMODE

Salut, Les commandes Redessiner, Régénérer ou Régénérer tout, pour effacer les "petites croix". La variable système BLIPMODE à 0 pour ne pas en générer.

Salut Sebdom, Je trouve la remarque quelque peu lapidaire et péremptoire. LUDWIG donne un lien vers un site fort intérressant, les cotes proposées n'y sont pas exactement les mêmes que celles que tu préconises. Je donne aussi un lien vers un fil de discussion (plutôt long) dans lequel les "règles" à observer sont longuement abordées et de manière plus circonspecte. Dans ce même fil sont donnés trois autres liens vers des sites traitant aussi des escaliers (dont celui de Nazemrap membre de CADxp et menuisier si je ne m'abuse). PS : je suis aussi menuisier. [Edité le 17/2/2006 par (gile)]

Il est souvent nécessaire dans un LISP, de changer la valeur de certaines variables système. La méthode habituelle est de sauvegarder la valeur initiale de la variable système dans une variable globale pour pouvoir lui restituer sa valeur initiale à la fin de l'exécution de la routine (ou lors d'une interruption pendant le déroulement du LISP -fonction *error*). Je propose deux petites routines qui simplifient la manoeuvre, ces routines sont déjà apparues dans CADxp assosciées à certains LISP que j'ai publiés, elles sont ici dans une version plus aboutie : SAVE&SET_VAR permet de changer la valeur d'une variable système (comme SETVAR), mais enregistre la valeur initiale de cette variable dans une liste de paires pointées (SavedSysVarLst), si ce n'est déjà fait (seul le premier appel à SAVE&SET_VAR pour une variable donnée est enregistré). RESTORE_VAR restitue leurs valeurs initiales aux variables contenues dans SavedSysVarLst et vide cette liste. ;;; SAVE&SET_VAR & RESTORE_VAR ;;; ;;; SAVE&SET_VAR ;;; Enregistre la valeur initiale de la variable système dans une liste ;;; de paires pointées et lui attribue sa nouvelle valeur (si val est non nil) ;;; ;;; ex: (SAVE&SET_VAR "autosnap" nil) (SAVE&SET_VAR "orthomode" 1) ;;; -> SavedSysVarLst : (("orthomode" . 0) ("autosnap" . 63)) ;;; -> (getvar "orthomode") : 1 ;;; -> (getvar "autosnap") : 55 (63 - 8 : le repérage polaire est désactivé) (defun SAVE&SET_VAR (var val) (cond ((not (getvar var)) (princ (strcat "\nErreur: variable AutoCAD rejetée: " var)) (princ) ) (T (if (not (member (assoc var SavedSysVarLst) SavedSysVarLst) ) (setq SavedSysVarLst (cons (cons var (getvar var)) SavedSysVarLst ) ) ) (if val (setvar var val) ) ) ) ) ;;; RESTORE_VAR ;;; Restaure leurs valeurs initiales aux variables système de "SavedSysVarLst" ;;; ;;; ex: (RESTORE_VAR) ;;; -> (getvar "orthomode") : 0 ;;; -> (getvar "autosnap") : 63 ;;; -> SavedSysVarLst : nil (defun RESTORE_VAR () (foreach pair SavedSysVarLst (if (/= (getvar (car pair)) (cdr pair)) (setvar (car pair) (cdr pair)) ) ) (setq SavedSysVarLst nil) ) Ces routines permettent en outre d'utiliser une redéfinition de la fonction *error* standard qui peut servir quelque soient les variables modifiées par le LISP. ;;; Redéfinition de *error* (defun STD_ERR (msg) (if (or (= msg "Fonction annulée") (= msg "quitter / sortir abandon") ) (princ) (princ (strcat "\nErreur: " msg)) ) (command) (command "_undo" "_end") (RESTORE_VAR) (setq *error* m:err m:err nil ) (princ) )

Salut, Tu peux créer une application (fichier .vlx) qui est une compilation des fichiers .lsp et .dcl : - dans l'éditeur VisualLISP Fichiers -> Créer une application -> Assistant nouvelle application... - tu choisis le mode expert, tu choisis comme emplacement un nouveau dossier dans lequel tu mettras aussi tes images, tu charges tes Lisp et dcl et un fichier .vlx sera créé. - il suffit ensuite d'indiquer dans AutoCAD le chemin de recherche du dossier dans les fichiers de support et de charger le fichier vlx.

Salut, Après avoir mis la variable FILLMODE à 1, tu sélectionnes les polylignes (avec Sélection rapide si tu en as beaucoup) et dans les Propriétés -> Divers -> Génération du type de ligne, tu inverses l'option Activé(e) ou Desactivé(e)

Salut, Un long fil à propos d'escaliers ici NB : la hauteur de marche se mesure du dessus d'une marche au dessus de la suivante (A+D) le giron au milieu de l'emmarchement (largeur de la marche) de l'aplomb d'un nez de marche à l'aplomb du suivant ©. [Edité le 14/2/2006 par (gile)]

As tu essayé dans le menu Outils -> Extraction d'attributs..., même si tu n'as pas mis d'attributs dans ton bloc "Chêne", tu pourras avoir dans un tableau AutoCAD le nom du bloc et le nombre d'occurences.