(gile)

Salut, Si j'ai bien compris la demande, Res_hel le fait, pour un réseau polaire tu spécifies 0.0 pour le décalge en hauteur, bien sûr. Aussi en téléchargement.

Salut, Tu trouveras ai_setCmdEcho ici. Si ti utitlises _undo pour la restauration de l'environnement initial, je pense qu'il vaut mieux faire : (command "_.undo" "_begin") ou (command "_.undo" "_group") -c'est la même chose- au début du LISP et (command "_.undo" "_end") (command "_u") dans la routine de redéfinition de *error*, pour fermer le groupe et annuler tout ce qui a été fait depuis son ouverture (ce qui devrait ausssi marcher pour les SCU).

Je viens justement de retrouver un message dans lequel je décris avec mauvaise foi mais réalisme, la manière de créer une polyligne avec (command ...) (entmake ...) et (vla-add ...). Le sujet dans lequel se trouve ce message, fait tout à fait écho à celui ci. Personnellement, si j'utilise de plus en plus le VisualLISP, je continue à utiliser les (command ...) comme dans SurfDev où les (command ... pause ...) permettent de rendre la main à l'utilisateur dans l'environnement habituel. J'aime beaucoup aussi les (entmake ...) (entmod ...) qui permettent parfois des codes très élégants quand il s'agit de manipuler des listes (comme dans le petit dernier dont je suis, je dois l'avouer, assez fier). Je viens de voir les dernières réponses. Tu parfaitement raison (et parfaitement compris !), il y a en fait une autre raison, j'utilise beaucoup de sous-routines (dont save&set_var) qui sont chargées automatiquement dans mon profil utilsateur, mais quand je publie dans CADxp ou que je fais une routine pour quelqu'un d'autre, j'écris souvent les LISP sans les utiliser pour ne pas trop encombrer le code. [Edité le 4/7/2006 par (gile)]

Bonsoir, Un des avantages des commandes vla- est, comme le dit Patrick_35, l'absence d'echo sur la ligne de commande. Le (command "_.undo" "_begin") ou "_group" ou "_mark" doit être fait avant de désactiver CMDECHO pour que le changement de variable soit inclus dans le groupe undo, donc l'écho de la commande apparaît à la ligne de commande. Il existe une alternative aux fonction vla- pour palier à ce "problème" (qui n'est qu'esthétique, mais j'y suis sensible) depuis les versions 2004, c'est le LISP ai_setCmdEcho qui en jouant avec une variable d'environnement (acedChangeCmdEchoWithoutUndo) permet de desactiver CMDECHO sans que ceci ne soit pris en compte par _undo. Ce LISP est dans le fichier ai_utils.lsp qui n'est pas chargé automatiquement. J'en ai déjà parlé, tu peux faire une recherche dans les forum avec ai_setCmdEcho. Sinon, je comprends ta démarche et j'ai moi aussi essayé de trouver une méthode "universelle" de gestion des erreurs, et ce faisant j'ai beaucoup appris, mais j'ai remarqué que souvent il faut faire différemment. Par exemple dans le LISP cité plus haut (SurfDev) je n'utilise pas Save&Set_var parce que je voulais restaurer l'accochage aux objets avant la fin de la routine pour l'insertion du bloc.

Je dirais exactement comme Bred, ça m'est arrivé pas plus tard que samedi avec mon portable, j'ai retrouvé ma fenêtre CUI qui était restée sur mon deuxième écran à la maison.

Voilà, ni REMOVE_DOUBLES ni entmake, mais je me suis régalé à trouver une réponse à ton problème, merci. À la différence du LISP proposé par bonuscad, celui-ci ne traite que les polylignes optimisées (lwpolyline), mais il conserve les arcs. ;;; TRUNC_LST Retourne la liste tronquée à partir de la première occurrence ;;; de l'expression (liste complémentaire de celle retournée par MEMBER) (defun trunc_lst (expr lst) (cond ((not (member expr lst)) lst) ((equal (car lst) expr) nil) (T (cons (car lst) (trunc_lst expr (cdr lst)))) ) ) ;;; SINGLE_VERTICES ;;; Supprime tous les sommets superposées d'une lwpolyligne (defun c:single_vertices (/ ent e_lst p_lst) (while (not (setq ent (car (entsel "\nSélectionnez une polyligne: "))) ) ) (if (= "LWPOLYLINE" (cdr (assoc 0 (setq e_lst (entget ent))))) (progn (setq p_lst (vl-remove-if-not '(lambda (x) (or (= (car x) 10) (= (car x) 40) (= (car x) 41) (= (car x) 42) ) ) e_lst ) e_lst (vl-remove-if '(lambda (x) (member x p_lst) ) e_lst ) ) (if (= 1 (cdr (assoc 70 e_lst))) (while (equal (car p_lst) (assoc 10 (reverse p_lst))) (setq p_lst (reverse (cdr (member (assoc 10 (reverse p_lst)) (reverse p_lst))))) ) ) (while p_lst (setq e_lst (append e_lst (trunc_lst (assoc 10 (cdr p_lst)) p_lst)) p_lst (member (assoc 10 (cdr p_lst)) (cdr p_lst)) ) ) (entmod e_lst) ) (princ "\nEntité non valide.") ) (princ) )[Edité le 3/7/2006 par (gile)] [Edité le 5/7/2006 par (gile)]

Si ça n'existe pas déjà, et si personne ne l'a fait d'ici là, je te fais ça se soir, avec REMOVE-DOUBLES sur la liste des sommets et un entmake je pense que c'est facile à faire.

Dans le même esprit, une routine pour obtenir un entier "aléatoire" entre 1 et l'entier spécifié est donnée ici.

Tous ça est très bien, bravo ! Utiliser une liste plutôt que 3 variables est trés "lispien" et, à mon goût, bien plus élégant, je suis content (et un peu fier aussi) que tu anticipes les suggestions que j'aurais pu te faire. Une autre façon de faire, quand on groupe toutes les actions (setvar et command) à l'intérieur d'un même groupe d'annulation, est de fermer le groupe dans la routine de redéfinition de *error* : (command "_.undo" "_end") puis d'annuler le groupe de commande : (command "_u") ou (command "_.undo" 1) C'est la méthode utilisée ici.

Je confirme ce que dit Boris, il semble bien que les coupes avec "raccourcissement" aient un problème à la fois à l'affichage et dans les blocs 2D générés. Un solide d'une complexité toute relative :cool: http://img460.imageshack.us/img460/6766/coupe11dx.png Un plan de coupe sans "raccourcissement" : http://img460.imageshack.us/img460/2871/coupe25bw.png Le même avec un raccoucissement à droite : http://img473.imageshack.us/img473/5871/coupe34gh.png Le même encore mais la partie racccourcie est déplacée au dessus du plan : http://img449.imageshack.us/img449/6364/coupe47xc.png

Voici un premier jet pour répondre à la suggestion de Tramber. J'ajouterais aux objections faites ci-dessus que la précision dépendant du nombre de sommets, si un grand nombre de sommets N ne fait qu'allonger le temps de calcul, l'augmentation de sommets M augmente d'autant le nombre de blocs créés. ;;; MSURFDEV -Gilles Chanteau- 08/07/06 ;;; Crée, pour chaque rangée M d'un maillage 3D ouvert ou fermé, un bloc (region) ;;; représentant le développé de la rangée. ;;; La précision du développé augmente avec le nombre de mailles N (SURFTAB1) ;;; Après positionnement du bloc (insertion et rotation), il est proposé à ;;; l'utilisateur d'exécuter un miroir pour afficher l'autre face du développé. ;;; Par défaut, le bloc est nommé SurfDev_1, SurfDev_2, en fonction de l'existence de ;;; blocs du même nom dans le dessin. Il est proposé à l'utilisateur de le renommer. ;;; SQR retourne le carré du nombre (defun sqr (num) (if (numberp num) (* num num) ) ) ;;; ACOS Retourne l'arc cosinus du nombre (defun acos (num) (if (<= -1 num 1) (atan (sqrt (- 1 (sqr num))) num) ) ) ;;; THIRD_PT Retourne le point qui est à dist1 de pt1 et dist2 de pt2 (defun third_pt (pt1 pt2 dist1 dist2 /) (cond ((zerop dist1) pt1) ((zerop dist2) pt2) (T (polar pt1 (+ (angle pt1 pt2) (acos (/ (+ (sqr (distance pt1 pt2)) (sqr dist1) (- (sqr dist2))) (* 2 (distance pt1 pt2) dist1) ) ) ) dist1 ) ) ) ) ;;; Index_name Crée un nom indexé dont l'indice n'est pas présent dans la table spécifiée (defun index_name (tbl prfx / nom compt) (setq nom (strcat prfx "1") compt 1 ) (while (tblsearch tbl nom) (setq compt (1+ compt) nom (strcat prfx (itoa compt)) ) ) nom ) ;;; Liste des sommets d'une polyligne 3D (defun 3dpoly_pts (ent / pt pts) (while (setq pt (cdr (assoc 10 (entget (entnext ent))))) (setq ent (entnext ent) pts (cons pt pts) ) ) pts ) ;;; Redéfinition de *error* (defun SurfDev_err (msg) (if (= msg "Fonction annulée") (princ) (princ (strcat "\nErreur: " msg)) ) (command "_undo" "_end") (command "_u") (setq *error* m:err m:err nil ) (princ) ) ;;; Fonction principale (defun c:MSurfDev (/ osm cmd del obj lst n lst1 lst2 rslt1 rslt2 n1 n2 ss ind new) (setq m:err *error* *error* SurfDev_err ) (setq osm (getvar "OSMODE") cmd (getvar "CMDECHO") del (getvar "DELOBJ") ) (while (not (setq obj (car (entsel "\Sélectionnez la surface à développer: ")) ) ) ) (if (and (= (cdr (assoc 0 (entget obj))) "POLYLINE") (zerop (logand (cdr (assoc 70 (entget obj))) 206)) ) (progn (setq lst (3dpoly_pts obj) nb_M (cdr (assoc 71 (entget obj))) nb_N (cdr (assoc 72 (entget obj))) ) (command "_undo" "_begin") (setvar "CMDECHO" 0) (setvar "OSMODE" 0) (setvar "DELOBJ" 1) (while (< 1 nb_M) (foreach n '(lst1 lst2 rslt1 rslt2) (set n nil) ) (setq n 0 n0 (/ (length lst) nb_M) n1 0 n2 0 ) (repeat n0 (setq lst1 (cons (nth n lst) lst1) n (1+ n) ) ) (repeat n0 (setq lst2 (cons (nth n lst) lst2) n (1+ n) ) ) (if (equal (car lst1) (car lst2) 1e-9) (setq rslt1 (cons '(0 0 0) rslt1) rslt2 (cons '(0 0 0) rslt2) rslt1 (cons (polar '(0 0 0) (angle (car lst1) (cadr lst1)) (distance (car lst1) (cadr lst1)) ) rslt1 ) rslt2 (cons (third_pt (car rslt1) '(0 0 0) (distance (cadr lst1) (cadr lst2)) (distance (car lst2) (cadr lst2)) ) rslt2 ) lst1 (cdr lst1) lst2 (cdr lst2) ) (setq rslt1 (cons '(0 0 0) rslt1) rslt2 (cons (polar '(0 0 0) (angle (car lst1) (car lst2)) (distance (car lst1) (car lst2)) ) rslt2 ) ) ) (repeat (1- (length lst1)) (setq rslt1 (cons (third_pt (car rslt1) (car rslt2) (distance (nth n1 lst1) (nth (setq n1 (1+ n1)) lst1) ) (distance (nth n2 lst2) (nth n1 lst1)) ) rslt1 ) ) (if (equal (nth n1 lst1) (nth (1+ n2) lst2) 1e-9) (setq rslt2 (cons (car rslt1) rslt2) n2 (1+ n2) ) (setq rslt2 (cons (third_pt (car rslt1) (car rslt2) (distance (nth n1 lst1) (nth (1+ n2) lst2)) (distance (nth n2 lst2) (nth (setq n2 (1+ n2)) lst2) ) ) rslt2 ) ) ) ) (setq ss (ssadd)) (foreach l (list rslt1 rslt2) (if (not (vl-every '(lambda (pt) (equal pt (car l) 1e-9)) l) ) (progn (command "_.spline") (mapcar 'command l) (command "" "" "") (ssadd (entlast) ss) ) ) ) (foreach fun (list 'car 'last) (if (not (equal (apply fun (list rslt1)) (apply fun (list rslt2)) 1e-9 ) ) (progn (command "_.line" (apply fun (list rslt1)) (apply fun (list rslt2)) "" ) (ssadd (entlast) ss) ) ) ) (command "_.region" ss "") (command "_.chprop" (entlast) "" "_layer" "0" "") (setq ind (index_name "BLOCK" "SurfDev_")) (command "_.block" ind '(0 0 0) (entlast) "") (setvar "OSMODE" osm) (command "_.insert" ind "_scale" 1) (princ "\nSpécifiez le point d'insertion: ") (command pause) (princ (strcat "\nSpécifiez l'angle de rotation <" (angtos 0) ">: " ) ) (command pause) (setq bloc (entlast)) (initget "Oui Non") (if (= "Oui" (getkword "\nEffectuer un miroir ? [Oui/Non] < Non >: ") ) (progn (command "_mirror" bloc "" (setq pt (cdr (assoc 10 (entget bloc)))) "_non" (polar pt 0.0 1) "_yes" "_.explode" bloc "_.block" ind "_yes" pt "_previous" "" ) (command "_.insert" ind "_scale" 1) (princ "\nSpécifiez le point d'insertion: ") (command pause) (princ (strcat "\nSpécifiez l'angle de rotation <" (angtos 0) ">: " ) ) (command pause) ) ) (initget "Oui Non") (if (= "Oui" (getkword (strcat "\nRenommer le bloc \"" ind "\" ? [Oui/Non] < Non >: " ) ) ) (progn (initget 1) (setq new (getstring "\Entrez le nouveau nom: ")) (command "_.rename" "_block" ind new) ) ) (repeat n0 (setq lst (cdr lst)) ) (setq nb_M (1- nb_M)) ) (command "_.undo" "_end") (setvar "CMDECHO" cmd) (setvar "DELOBJ" del) ) (princ "\nL'objet sélectionné n'est pas une surface développable." ) ) (setq *error* m:err m:err nil ) (princ) ) [Edité le 8/7/2006 par (gile)]

C'est bien ce qu'il m'avait semblé comprendre, ce que tu propose est, il me semble, tout à fait réalisable, mais je me demande si çà a une réelle utilité. Dans le cas dudit bateau par exemple, s'il avait été fait en un seul maillage (_edgesurf), d'abord ce ne seait plus la même carène (une coque en forme et plus une coque à bouchains vifs) et les arrêtes générées par les développés de chaque rangées M ne correspondraient pas aux bouchains. Il existe sûrement d'autres situations où le problème ne se pose pas de a même façon, je vais regarder ce que je peux faire.

Salut et bienvenue autocadbeginer, Si, comme le dit autospeed, tes objets sont bien en "DUCALQUE", cela peut venir de l'échelle globale des types de ligne. Tu peux modifier ce facteur d'échelle à partir de la boite de dialogue "Gestionnaire des types de ligne" (Menu Format -> Types de ligne) ou en modifiant la valeur de la variable système LTSCALE. Pour les présentations, la variable système PSLTSCALE à 1 (ce qui correspond à cocher la case "Utiliser les unités de l'espace papier pour une mise à l'échelle" dans la boite de dialogue citée plus haut) permet de conserver l'échelle de type de ligne de l'espace paier dans toutes les fenêtres quelques soient leurs échelles respectives. Les modifications de LTSCALE ne sont visibles qu'après une régénération. Pour que l'épaisseur des types de ligne apparaissent à l'écran, il faut que le bouton EL de la barre d'état soit enfoncé (variable système LWDISPLAY). Tu peux aussi trouver ici un petit LISP de bonuscad pour voir immédiatement les effets des changements de facteur d'échelle, ou encore un autre ici.

Merci Tramber, Il me semblait bien que le message était passé inaperçu. Le choix du "pur AutoLISP" est essentiellement du à l'utilisation des (command ... pause ...). Je ne comprends pas bien ce que tu veux dire par "un séparateur dans le sens M", il me semble que s'il y a plus de 2 sommets M la surface n'est plus développable, non ?

Je suis étonné que çà n'intéresse personne. :exclam: Deux petits exemples d'utilisation possible. Une trémie : http://img112.imageshack.us/img112/5441/developptrmie6iz.png Un bateau : http://img301.imageshack.us/img301/5519/dveloppbateau9vq.png

Salut, Je remarque deux petites "erreurs" - Dans la fonction REDEF_ERROR il ne faut pas faire de (progn ...). C'est : si annuler ou quitter, alors pas de message, sinon (dans les autres cas d'erreurs) le message est délivré. (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) ;_ pas de message (princ (strcat "\nErreur: " msg)) ;_le message est délivré ) (END_PRG_ERR) ) - L'idée de récupérer le SCU avec les variables est excellente (pas de SCU nommé) mais incomplète. Pour faire un SCU 3 points fiable il faut aussi récupérer UCSYDIR. (defun TRAIT_SCU_ACTIF () (setq orig (getvar "ucsorg") dirx (getvar "ucsxdir") diry (getvar "ucsydir")) ) Et au moment du SCU 3 points il est préférable que les accrochages aux objets soient désactivés. On peut aussi utiliser l'accrochage temporaire "_NON" ou "AUC" (pour aucun) avant de spécifier chacun des points. En utilisant la fonction (trans ...), il n'est pas nécessaire de passer par un SCG puis un SCU origine : (defun SET_SCU_SAVE () (command "_.ucs" "_3" "_non" (trans orig 0 1) "_non" (trans dirx 0 1) "_non" (trans diry 0 1) ) ) Sinon, pour la forme, çà fait pas mal de variables définies (orig, dirx, diry, Sauv_EXerror, SavedSysVarLst) qu'il serait préférable de déclarer dans la fonction principale : (defun c: mon_programme (/ orig dirx diry Sauv_EXerror SavedSysVarLst) ...) ou de remettre à nil dans la fonction END_PRG_ERR. Cette fonction, d'ailleurs, pourrait être appelée à la fin de REDEF_ERROR (voir plus haut). Dernière chose, si tu utilises SAVE&SET_VAR, je ne vois pas l'intérêt de faire TRAIT_VAR_TYPE, j'avais fais cette routine justement pour ne pas avoir à faire de liste de variables prédéfinie. Dans ce sujet la question est un peu approfondie.

Salut, Je n'ai pas trouvé la variable (si elle existe) mais en VisualLISP, tu peux faire : (vla-get-Count (vla-get-Documents (vlax-get-acad-object))) NOTA : sur les versions antérieures à 2004, il faut faire (vl-load-com) pour charger les fonctions ActiveX avant d'utiliser les fonction vla-... vlax-...

Je suis un bien piètre testeur, j'avais laissé passer un appel à la fonction GETVAL qui n'était pas définie parmi les sous-routines ci-dessus, comme elle fait partie des routines chargées automatiquement dans mon profil utilisateur, je n'avais pas eu de message d'erreur. L'erreur dans le LISP ci-dessus est réparé.

Je ne suis pas tout à fait d'accord, SOLVIEW et SOLDRAW (même si leur utilisation est fastidieuse, surtout quand on pas l'habitude) présententes des avantages par rapport à la génération de coupes depuis PLANDECOUPE : Traits cachés et hachures sur des calques différents, positionnement précis des vues les unes par rapport aux autres ... Certes dans Inventor tout celà est automatisé (il doit être possible d'automatiser aussi ces commandes dans AutoCAD) mais cequi fait la différence d'AutoCAD par rapport à nombre d'autre logiciel, c'est justement le nombre de possibilités offertes pour faire la même chose et son immense capacité à être personnalisable. Pour terminer sur la comparaison entre différents logiciels, je dirais que même Paint fait des choses qu'AutoCAD ne fait pas ! [Edité le 30/6/2006 par (gile)]

Ce ne sont pas les messages, mais les erreurs (les vraies ou annuler, quitter) qui déclenchent l'exécution de la fonction *error*. Cette fonction *error* dans sa version prédéfinie délivre un message du type : "; erreur: type d'argument incorrect : numberp NIL" ou "; erreur: Fonction annulée" Elle pourrait avoir été définie en LISP comme ceci : (defun *error* (msg) (princ (strcat "; erreur: " msg)) (princ) ) Quand on fait le mic mac autour des messages d'erreur, c'est uniquement pour ne pas avoir à la ligne de commande ce type de message : *Annuler* ; erreur: Fonction annulée mais seulement : *Annuler* Sinon tu as bien compris, on remplace, pendant le temps de l'exécution de la routine, la fonction *error* originelle (après l'avoir sauvegardée dans une autre variable) par celle qu'on a redéfinie : (setq Sauv_EXerror *error* *error* Gestion_erreur) et à la fin de la routine et de la fonction Gestion_erreur on restaure la fonction originelle : (setq *errror* Sauv_EXerror Sauv_EXerror nil) D'une manière générale la fin de la routine principale et la fin de la routine de gestion d'erreur sont identiques en ce qui concerne toute la restauration de l'environnement (groupe annuler, variables systèmes, fonction *error* ...)

Pour le message, ce qui se fait, c'est de faire un (princ) en cas dannulation ou de (quit) et de laisser délivrer le message d'erreur AutoCAD dans les autres cas : (if (or (= msg "Fonction annulée") (= msg "quitter / sortir abandon") ) (princ) (princ (strcat "\nErreur: " msg)) ) C'est ensuite, et dans tous les cas que l'on restaure l'environnement (variables, SCU, groupe "_undo" ...) Pour le SCU comme pour toutes les variables en lecture seule, il faut passer par un (command ...) par exemple après avoir sauvé le SCU initial dans un SCU nommé : (command "_ucs" "_save" "scu_init") On peut changer le SCU dans la routine et à la fin de la routine et de la fonction de gestion des erreurs, on fait : (command "_ucs" "_restore" "scu_init") (command "scu" "_del" "scu_init")

Je désactive aussi la saisie dynamique, mais j'apprécie la possibilité de pouvoir rappeler les dernières commandes via le menu contextuel (INPUTHISTORYMODE à 2) qui est arrivée en même temps si je me souviens bien.

La méthode est bonne, il ne faut pas oublier de restaurer les variables à la fin du LISP (s'il n'y a eu ni erreur ni annulations), et je suis sûr que tu sauras l'amèliorer. J'utilise une méthode semblable, que j'ai améliorée/épurée au fil du temps, la liste des variables n'est pas établie au début du LISP mais se constitue au fur et à mesure de la modification des variables en utilisant SAVE&SET_VAR au lieu de setvar. Chaque élément de la liste (SavedSysVarLst) est une liste composée du symbole 'setvar, du nom de la variable et de la valeur initiale. Voici la dernière version : ex: (SAVE&SET_VAR "autosnap" nil) (SAVE&SET_VAR "orthomode" 1) La liste SavedSysVarLst : ((setvar "orthomode" 0) (setvar "autosnap" 63)) après quoi, (getvar "orthomode") retourne 1 (getvar "autosnap") retourne 55 (63 - 8 : le repérage polaire est désactivé) ;;; SAVE&SET_VAR ;;; Enregistre la valeur initiale de la variable système dans une liste ;;; et lui attribue sa nouvelle valeur (si val est non nil) (defun SAVE&SET_VAR (var val) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst) ) (if val (setvar var val) ) ) ) ) Pour restaurer les valeurs initiales à la fin du LISP ou de la fonction de gestion d'erreur il suffit d'évaluer tous les éléments de la liste en faisant : (mapcar 'eval SavedSysVarLst) [Edité le 29/6/2006 par (gile)] [Edité le 29/6/2006 par (gile)]

Salut et bienvenue, Tu double cliques sur la cote en question, dans la boite dialogue "Editer annotation" tu retapes la valeur de la cote puis Alt+0177 pour avoir ± http://img424.imageshack.us/img424/8190/intellidesk6mn.png

Salut Esbe, Pour le problème d'affichage, tu peux peut-être essayer d'éditer le message N°23, il doit y avoir un bbcode mal fermé.