bonuscad

C'est vrai que cela devrait être paramètrable. Malgré le choix "Détails" lors de l'ouverture d'un fichier (j'aime bien pouvoir classer par date et non par le nom). Ce dernier paramètrage n'est jamais gardé, on revient toujours en mode "icone" Si quelqu'un savait quelles clés du registre bidouiller (car je pense que c'est là que sa ce passe) pour fixer ce paramètrage, je suis preneur... :) Merci d'avance

Il te faut placer AVANT un appel à (command ".......) (command "_.UNDO" "_Begin") et APRES le dernier appel à (command "....") (command "_.UNDO" "_End") Si tu veut être sûr (en étant perfectionniste) que tout se déroule bien, il te faut surveiller la variable 'UNDOCTL" (lecture seule), et suivant sa valeur, utiliser la commande "_.UNDO" "_Control" "...... Au cas où l'utilsateut aurait par fixer par exemple la commande Annuler à 1 seule opération., ou même aucune. (situation peu probable) En faisant comme ceci le résultat de ta routine pourra être annuler en une seule opération, même si plusieur appel à (command) ont été fait.

Salut Miamar, J'ai planché un peu sur ce ce genre de fonction (un peu similiaire à la fonction EXTRIM des ExpressTools) Voici le code qu'il en résulte: Est-ce une bonne approche?, je n'en sais rien ! Si tu veux t'en inspirer et le modifier..... (defun c:plsel ( / ) (while (null (setq ent (entsel "\nChoix de la Polyligne: ")))) (setq typent (cdr (assoc 0 (setq dxf_ent (entget (car ent)))))) (cond ((or (eq typent "LWPOLYLINE") (eq typent "POLYLINE")) (vl-load-com) (setq obj_vlax (vlax-ename->vla-object (car ent)) param_start (vlax-curve-getStartParam obj_vlax) param_end (vlax-curve-getEndParam obj_vlax) perim_obj (vlax-curve-getDistAtParam obj_vlax (+ param_start param_end)) pt_start (vlax-curve-getStartPoint obj_vlax) pt_end (vlax-curve-getEndPoint obj_vlax) ) (initget 6) (setq res_track (getdist (cadr ent) (strcat "\nDistance de résolution<" (rtos (/ perim_obj 100.0)) ">: ")) last_e (entlast) old_osmd (getvar "osmode") old_pdmd (getvar "pdmode") ) (if (not res_track) (setq res_track (/ perim_obj 100.0))) (setq l_pt (list pt_start) lg 0.0) (while (< (+ lg res_track) perim_obj) (setq l_pt (cons (vlax-curve-getPointAtDist obj_vlax (setq lg (+ lg res_track))) l_pt)) ) (setq l_pt (cons pt_end l_pt)) (command "_.erase" (ssget "_WP" l_pt) "") (setq n (float (length l_pt))) (command "_.pline" (mapcar 'command l_pt)) (setq e_tmp (entlast)) (command "_.offset" (/ res_track 2.0) e_tmp (list (/ (apply '+ (mapcar 'car l_pt)) n) (/ (apply '+ (mapcar 'cadr l_pt)) n)) "" ) (setq l_fence (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) (entget (entlast))))) (entdel (entlast)) (entdel e_tmp) (command "_.trim" ent "" (ssget "_F" l_fence) "") ) ) (prin1) )

Bonjour, Pour le marquage au sol, j'ai bien une routine Lisp qui permet de faire cela facilement. Elle utilise la commande POLYLIGNE en la redéfinissant et génére automatiquement un fichier .LIN correspondant au dessin. (Ce fichier sera généré avec le facteur d'échelle du type de ligne en cours du dessin). La défintion s'appuie sur les normes de marquage au sol rattaché au type de classement des voies. (espacement et largeur du marquage) (defun sgnerr (ch / ) (cond ((eq ch "Function cancelled") nil) ((eq ch "quit / exit abort") nil) ((eq ch "console break") nil) (T (princ ch)) ) (setq *error* olderr) (setvar "cmdecho" oldcmd) (princ) ) (defun c:hzoff ( / oldcmd) (setq oldcmd (getvar "cmdecho")) (setvar "cmdecho" 0) (setvar "plinewid" 0.0) (setvar "celtype" "BYLAYER") (command "_.redefine" "polylign") (command "_.redefine" "_pline") (prompt "\nCommande POLYLIGN redéfinie en standard") (setvar "cmdecho" oldcmd) (prin1) ) (defun c:hzon ( / oldcmd) (setq oldcmd (getvar "cmdecho")) (setvar "cmdecho" 0) (command "_.undefine" "polylign") (command "_.undefine" "_pline") (prompt "\nCommande POLYLIGN redéfinie en mode signalisation horizontale") (setvar "cmdecho" oldcmd) (prin1) ) (defun c:polylign () (c:_pline) ) (defun c:_pline ( / oldcmd entry wid_pl mod_tl) (setq oldcmd (getvar "cmdecho")) (setq olderr *error* *error* sgnerr) (setvar "cmdecho" 0) (while (not wid_pl) (setq entry (getstring (strcat "\nDonner le type de U à tracer ou largeur de en cm [2U/3U/5U/50/25/15/10] <" (getvar "users1") "> : " ) ) ) (if (= entry "") (setq entry (getvar "users1")) ) (cond ((or (= entry "2U")(= entry "2u")) (setq wid_pl (* 2.0 (getvar "userr1"))) (setvar "users1" "2U") ) ((or (= entry "3U")(= entry "3u")) (setq wid_pl (* 3.0 (getvar "userr1"))) (setvar "users1" "3U") ) ((or (= entry "5U")(= entry "5u")) (setq wid_pl (* 5.0 (getvar "userr1"))) (setvar "users1" "5U") ) ((or (eq (atof entry) 50) (eq (atof entry) 25) (eq (atof entry) 15) (eq (atof entry) 10) ) (setq wid_pl (* 0.01 (atof entry))) (setvar "users1" (rtos (atof entry) 2 0)) ) (T (prompt "\nLa valeur doit être 2U, 3U, 5U, 50cm, 25cm, 15cm ou 10cm") (setq wid_pl nil) ) ) ) (setvar "plinewid" wid_pl) (if (= (getvar "users2") "") (setvar "users2" "CONTINU")) (initget "T1 TP1 T2 TP2 T3 TP3 Continu") (setq mod_tl (getkword (strcat "\nType de modulation [T1/TP1/T2/TP2/T3/TP3/Continu] <" (getvar "users2") ">: " ) ) ) (if (not mod_tl) (setq mod_tl (getvar "users2")) ) (cond ((eq mod_tl "T1") (setvar "celtype" "T1") ) ((eq mod_tl "TP1") (setvar "celtype" "T-PRIM1") ) ((eq mod_tl "T2") (setvar "celtype" "T2") ) ((eq mod_tl "TP2") (setvar "celtype" "T-PRIM2") ) ((eq mod_tl "T3") (setvar "celtype" "T3") ) ((eq mod_tl "TP3") (setvar "celtype" "T-PRIM3") ) ((eq mod_tl "Continu") (setvar "celtype" "CONTINUOUS") ) ) (setvar "users2" mod_tl) (alert (strcat "\n - Utilisez la commande HZOFF" "\npour activer la commande POLYLIGN standard." "\n - Utilisez la commande HZON" "\npour activer la commande POLYLIGN modifiée." ) ) (setq *error* olderr) (setvar "cmdecho" 1) (command "_.PLINE") (prin1) ) (defun c:signhz ( / oldcmd oldexp maj fac_tl val_tl nam_tl nam_fic fil_out val_u entry) (setq val_u nil) (setq oldcmd (getvar "cmdecho") oldexp (getvar "expert")) (setq olderr *error* *error* sgnerr) (setvar "cmdecho" 0) (setvar "expert" 3) (if (tblsearch "LTYPE" "T1") (setq maj T) (setq maj nil)) (setq fac_tl (getvar "ltscale")) (setq val_tl '( (3.0 -10.0) (1.5 -5.0) (3.0 -3.5) (0.5 -0.5) (3.0 -1.33) (20.0 -6.0) ) ) (setq nam_tl '( "*T1,longitudinale axial" "*T-PRIM1,longitudinale axial" "*T2,longitudinale de rive" "*T-PRIM2,transversale" "*T3,longitudinale axial" "*T-PRIM3,longitudinale de rive" ) ) (if (zerop (getvar "dwgtitled")) (setq nam_fic (strcat (getvar "dwgprefix") (getvar "dwgname") ".LIN")) (setq nam_fic (strcat (getvar "dwgname") ".LIN")) ) (setq fil_out (open nam_fic "w")) (while val_tl (write-line (car nam_tl) fil_out) (write-line (strcat "A," (rtos (/ (caar val_tl) fac_tl) 2 4) "," (rtos (/ (cadar val_tl) fac_tl) 2 4) ) fil_out ) (setq nam_tl (cdr nam_tl) val_tl (cdr val_tl)) ) (close fil_out) (command "'_.LINETYPE" "_LOAD" "*" nam_fic "") (prompt (strcat "\nLes types de lignes T1 T'1 T2 T'2 T3 et T'3 sont définies et chargées" "\npour un facteur d'échelle de : " (rtos fac_tl 2 2) ) ) (while (not val_u) (initget 6) (setq entry (getreal "\nDonner la valeur de U en centimètres [7.5/6/5/3] <6>: ")) (cond ((or (eq entry 7.5) (eq entry 6) (eq entry 5) (eq entry 3) ) (setq val_u entry) ) ((not entry) (setq val_u 6.0) ) (T (prompt "\nLa valeur de U doit être de 7.5cm, 6cm, 5cm ou 3cm") (setq val_u nil) ) ) ) (setq val_u (* 0.01 val_u)) (setvar "userr1" val_u) (setvar "fillmode" 1) (setvar "plinegen" 1) (command "_.undefine" "polylign") (command "_.undefine" "_pline") (if maj (progn (prompt "\nMise à jour des entitées avec la nouvelle définition par un REGEN") (command "_.regenall") ) (prompt (strcat "\nSi vous voulez changez l'échelle du type de ligne, ou la valeur de U" "\nrelancez la commande SIGNHZ" "\nNB: Les polylignes tracées auparavant garderont l'ancienne valeur de U." ) ) ) (setvar "expert" oldexp) (setvar "cmdecho" oldcmd) (setq *error* olderr) (prin1) )

As tu essayer le fichier de Patrick (The WebMaster) ici: http://www.cadxp.com/Downloads+index-req-viewsdownload-sid-4.html

Dans certaine condition ça à l'air possible (liè a "MIRRTEXT") J'ai vu ça ici: http://www.ma-info.com/info/astuces/astuces.htm

Ben Sylvain me fait mentir. :( Cet utililitaire gratuit "Terrain.arx" bien qu'imparfait, est tout à fait honorable dans le résultat (qu'il faut cependant retoucher) En effet j'ai l'impression que les courbes sont dessinées dans un espèce de "BoundingBox" incluant le maillage , ce qui donne une représentation des courbes en dehors du maillage assez surprenante. Malgré cela cet utilitaire est interessant, et débroussaille une bonne partie du boulot.

Peut être dans la table des symboles accessible par la fonction (tblnext "VIEW" T) "T" pour obtenir la 1ere vue dans la table . (tblnext "VIEW") pour obtenir les suivantes. Je doute qu'une vue non enregistrée soit accessible par là (pas testé)

Bonjour, Je n'ai pas de solution miracle, mais une méthode qui pourra peut être te rendre service. Tout d'abord, il faudrait faire un maillage de ton semis de points. J'ai développer un utilitaire pour ceci (voir les discussions relatant ceci: faire une recherche sur le site avec TRIANGULATION ou MAILLAGE ou MNT) Mon application s'appelle trinod.lsp ou trinod pour XP.lsp (disponible dans la zone téléchargement) Une fois le maillage effectué en 3DFACE (de préference), tu peut executer la petite routine suivante (qui seras peut être a ajuster) (defun c:niveau_z ( / center_view pos_cible pos_camera niv_z) (command "_.ucs" "_world") (command "_.plan" "_world") (command "_.zoom" "_all") (command "_.zoom" "_extents") (setq center_view (getvar "viewctr")) (setq pos_cible center_view pos_camera (list (car center_view) (cadr center_view) 1000.0)) (setq niv_z (getreal "\nEntrez le z: ")) (command "_.dview" "" "_points" pos_cible pos_camera "_clip" "_back" niv_z "_clip" "_front" niv_z "") (setvar "osmode" (+ 16384 (rem (getvar "osmode") 16384))) ) Celle ci va te faire apparaitre un pointillé représentant les arrêtes de 3Dface interceptés De là une connaissance de ton fond de plan te seras necessaire pour interpreter le passage de ta Polyligne ou Spline qui representera ta courbe au Z fourni dans la routine. Tu vas travailler en "Aveugle" et tu ne pourras pas t'accrocher à ces point affichés, à toi de passer aux mieux par ces points virtuels. Une fois tracé cette coube, utilise la commande "REPERE" (pour réaffiché ton dessin) et change le Z (celui fourni dans la routine) de ta courbe tracée pour l'avoir en 3D si tu le désire. Voilà pour la méthode que je peux te proposer, j'espère que tu seras à l'aise. Ce n'est pas du rapide, mais je n'ai pas mieux et cela m'étonnerais que tu trouve mieux (en FREE) car cela demanderait un développement complexe. Bruno V. [Edité le 5/1/2005 par bonuscad]

Je vous présente déjà tout mes voeux pour 2005. Récemment il y avait eu une discussion sur les pentes en pourcentage. J'ai donc amélioré des routines que j'avais déjà réalisé pour que celle-ci puissent fonctionner DANS le plan XY et AVEC le plan XY. En voici le résultat: (defun errlsp (ch) (cond ((eq ch "Function cancelled") nil) ((eq ch "quit / exit abort") nil) ((eq ch "console break") nil) (T (princ ch)) ) (setvar "cmdecho" v1) (setvar "orthomode" v2) (setvar "osmode" v3) (setvar "blipmode" v4) (setvar "snapang" v5) (setq *error* olderr) (princ) ) (defun C:PENTE ( / v1 v2 v3 v4 v5 d_pc flag p_o p_f dlt_x d olderr) (setq v1 (getvar "cmdecho") v2 (getvar "orthomode") v3 (getvar "osmode") v4 (getvar "blipmode") v5 (getvar "snapang") ) (setvar "cmdecho" 0) (setvar "orthomode" 0) (setvar "blipmode" 0) (setq olderr *error* *error* errlsp) (initget 1) (setq d_pc (getreal "\nEntrer la valeur de la pente (rampe) en % ?: ")) (initget 8) (setq p_o (getpoint "\nPoint de départ : ")) (if (eq p_o ()) (setq p_o (getvar "lastpoint"))) (initget "Dans Avec _In With") (if (eq (getkword "\nPente [Dans/Avec] le plan XY : ") "With") (setq flag T) (progn (setvar "snapang" (atan (/ d_pc 100.0))) (setvar "orthomode" 1) (setq flag nil) ) ) (initget 41) (setq p_f (getpoint p_o "\nPoint final : ")) (setvar "osmode" (+ 16384 (rem (getvar "osmode") 16384))) (if flag (progn (setq dlt_x (sqrt (+ (* (- (car p_o) (car p_f)) (- (car p_o) (car p_f))) (* (- (cadr p_o) (cadr p_f)) (- (cadr p_o) (cadr p_f)))))) (setq d (* dlt_x (/ (sin (atan (/ d_pc 100.0))) (cos (atan (/ d_pc 100.0)))))) (setq p_f (list (car p_f) (cadr p_f) (+ (caddr p_o) d))) (command "_.line" p_o p_f "") ) (progn (setq dlt_x (- (car p_f) (car p_o))) (setq d (/ dlt_x (cos (atan (/ d_pc 100.0))))) (command "_.line" p_o (polar p_o (atan (/ d_pc 100.0)) d) "") ) ) (setvar "cmdecho" v1) (setvar "orthomode" v2) (setvar "osmode" v3) (setvar "blipmode" v4) (setvar "snapang" v5) (setq *error* olderr) (prin1) ) Et la deuxième: (defun C:ID-PENTE ( / blp pt_o pt_f e_last dxf_o dev dev_z) (setvar "cmdecho" 0) (setq blp (getvar "blipmode")) (setvar "blipmode" 0) (initget 8) (setq pt_o (getpoint "\nSpécifiez le point de départ: ")) (if (null pt_o) (setq pt_o (getvar "lastpoint"))) (cond (pt_o (initget 41) (setq pt_f (getpoint pt_o "\nChoix du point final: ")) (cond (pt_f (command "_.ray" pt_o pt_f "") (setq e_last (entlast) dxf_o (trans (cdr (assoc 11 (entget e_last))) 0 1 T) ) (if (zerop (car dxf_o)) (setq dev "infini") (setq dev (rtos (* (/ (cadr dxf_o) (car dxf_o)) 100.0) 2 4)) ) (if (= (caddr dxf_o) 1.0) (setq dev_z "infini") (if (zerop (caddr dxf_o)) (setq dev_z (rtos 0.0 2 4)) (setq dev_z (rtos (* (sqrt (/ 1.0 (- (/ 1.0 (* (caddr dxf_o) (caddr dxf_o))) 1.0))) 100.0) 2 4)) ) ) (entdel e_last) (prompt (strcat "\nPente dans le plan XY = " dev " % - Pente avec le plan XY = " dev_z " %")) (alert (strcat "Pente dans le plan XY = " dev " % - Pente avec le plan XY = " dev_z " %")) ) ) ) ) (setvar "blipmode" blp) (setvar "cmdecho" 1) (prin1) ) Bruno V.

En reprenant le lisp de Serge et en incluant un parcours des calques. C'est pas tout à fait ton souhait, mais presque (ssget "X") , sélection automatique par calque. Tu peut essayer d'alméliorer encore un peu. (defun c:pedit2 ( / fuzz hasLineOrArc i layer n objet oldPeditaccept peditaccept repere ss curr_layer next_layer name_layer) (setvar "cmdecho" 0) (setq fuzz 0.0) (setq curr_layer (getvar "clayer") next_layer (tblnext "LAYER" T) ) (if (setq next_layer (tblnext "LAYER")) (setq name_layer (cdr (assoc 2 next_layer))) (setq name_layer "0") ) (while (/= curr_layer name_layer) (if (/= curr_layer name_layer) (progn (setq ss (ssget "_X" (list (cons 0 "*polyline,arc,line") (cons 8 name_layer)))) (setq hasLineOrArc nil) (setq i 0 n (if ss (sslength ss) 0)) (while (< i n) (setq objet (ssname ss i)) (if (member (strcase (cdr (assoc 0 (entget objet))) t) '("arc" "line")) (setq hasLineOrArc t i (1+ n)) ) (setq i (1+ i)) ) (cond ((not ss) nil) ((> (substr (getvar "acadver") 1 4) "16.1") (setq oldPeditaccept (getvar "peditaccept")) (setvar peditaccept 1) (command "_.pedit" "_multiple" ss "" "_join" fuzz "") ) (hasLineOrArc (command "_.pedit" "_multiple" ss "" "_yes" "_join" fuzz "") ) (t (command "_.pedit" "_multiple" ss "" "_join" fuzz "") ) ) ) ) (setq next_layer (tblnext "LAYER")) (if (null next_layer) (setq next_layer (tblnext "LAYER" T)) ) (setq name_layer (cdr(assoc 2 next_layer))) ) (setvar "cmdecho" 0) (princ) ) (princ "\nTapez PEDIT2 pour joindre des objets d'un même calque.") (princ)

Il me semble avoir vu sur un autre forum, que cela pouvait être du à une indexation des fichiers DWG par XP pour une recherche rapide. Je crois qu'il fallait invalider cette option (par la base de registre, je ne me souviens plus) Si ça rapelle quelque chose à l'un de vous ......

De souvenir il me semble qu'il existait MODEMACRO (un truc comme ça) en version 10 sous DOS. Je ne sais plus si c'était fourni en standard avec AutoCAD ou avec l'extension Unitab III (qui était payant) Malheuresement je n'ai plus de lecteur 5' 1/4 pour lire la disquette et reprendre ce Lisp. (a moins que je retrouve peut être une version sur un format 3'1/2) ;)

Fais un copier-coller des lignes suivantes sur la ligne de commande (dans un nouveau dessin de préférence) (entmake '( (0 . "MTEXT") (100 . "AcDbEntity") (67 . 0) (410 . "Model") (8 . "0") (100 . "AcDbMText") (10 -8.74531 195.697 0.0) (40 . 7.48668) (41 . 597.653) (71 . 1) (72 . 5) (1 . "\\A2;{\\fArial Black|b0|i0|c0|p34;Quel est le \\L\\C1;meilleur\\l\\C7; site \\H0.7x;\\S^Francophone ;\\H1.429x;sur la \\H1.336x;\\C5;CAO\\C7;\\~?}") (7 . "Standard") (210 0.0 0.0 1.0) (11 0.965926 0.258819 0.0) (42 . 321.983) (43 . 15.5821) (50 . 0.261799) (73 . 1) (44 . 1.0) )) (entmake '( (0 . "MTEXT") (100 . "AcDbEntity") (67 . 0) (410 . "Model") (8 . "0") (100 . "AcDbMText") (10 31.6593 152.115 0.0) (40 . 14.9734) (41 . 597.653) (71 . 1) (72 . 5) (1 . "{\\fArial Black|b0|i0|c0|p34;\\C3;c'est CADxp\\H0.5x; bien sûr!}") (7 . "Standard") (210 0.0 0.0 1.0) (11 0.965926 0.258819 0.0) (42 . 197.937) (43 . 19.355) (50 . 0.261799) (73 . 1) (44 . 1.0) )) (entmake '( (0 . "MTEXT") (100 . "AcDbEntity") (67 . 0) (410 . "Model") (8 . "0") (100 . "AcDbMText") (10 21.6638 115.854 0.0) (40 . 7.5) (41 . 572.462) (71 . 1) (72 . 5) (1 . "{\\fTimes New Roman|b1|i0|c0|p18;\\C6;Bonne fête à tous} {\\fCourier New|b1|i0|c0|p49;et que le père Noël n'oublie notre Webmaster Patrick} {\\fCourier New|b1|i1|c0|p49;\\H1.344x;\\C40;\\U+20AC\\~\\H0.7442x;\\U+20AC\\~\\H0.6563x;\\U+20AC}") (7 . "Standard") (210 0.0 0.0 1.0) (11 1.0 0.0 0.0) (42 . 534.124) (43 . 12.9756) (50 . 0.0) (73 . 1) (44 . 1.0) )) Exécutes la routine et tu comprendras (je pense!) son action NB: je donne le DCL traduit en français /// StripMtext[3].DCL Steve Doman sdoman@yahoo.com stripmtext : dialog { label = "StripMtext v3.0"; spacer_1; : toggle { label = "Sauvegarder la configuration"; key = "save"; fixed_width = true; } spacer_1; : boxed_row { label = "Sélection des formats à supprimer"; : column { : toggle { label = "Position sur la ligne"; key = "A"; fixed_width = true; } : toggle { label = "Couleur"; key = "C"; fixed_width = true; } : toggle { label = "Fonte"; key = "F"; fixed_width = true; } : toggle { label = "Hauteur"; key = "H"; fixed_width = true; } : toggle { label = "Souligné"; key = "L"; fixed_width = true; } : toggle { label = "Surligné"; key = "O"; fixed_width = true; } } : column { : toggle { label = "Retour à la ligne"; key = "P"; fixed_width = true; } : toggle { label = "Italique"; key = "Q"; fixed_width = true; } : toggle { label = "Empilement"; key = "S"; fixed_width = true; } : toggle { label = "Facteur de compression"; key = "T"; fixed_width = true; } : toggle { label = "Largeur"; key = "W"; fixed_width = true; } : toggle { label = "Espace insécable"; key = "~"; fixed_width = true; width = 1; } } : column { : button { key = "selectall"; label = "Tout sélectionner"; } : button { key = "clearall"; label = "Tout désélectionner"; } : spacer { height = 4.0; } } } : column { errtile; ok_cancel; } }

Je te le fait pas dire, le problème majeure n'est pas de récuperer les entités, mais surtout le classement de celles-ci par rapport à leur positionnement entre elles (savoir si telle entité avec un XYZ et un alpha de rotation doit aller avec une autre entité positionnée a tel XYZ et alpha) en plus si des attributs doivent si ajouter je te dis pas la prise de tête. Bien que je pense que ce ne soit pas irréalisable, cela demanderait un temps de traitement très long (surtout en Lisp). Cela me fait penser un peu a un programme de triangulation (maillage de point 3D), je n'en ai jamais vu d'efficace en lisp. A mon avis tu peux tirer un trait sur ce genre de souhait. (bien que l'idée était bonne) ;)

En complément, ne remplace pas la réponse de Tramber ;) Si tu manipules de gros Xrefs, il peut être interessant de se pencher conjointement sur la variable INDEXCTL et XLOADCTL La variable indexctl est à fixer dans les fichiers qui te serviront souvent comme Xref et pas dans le dessin récepteur. Quand à xloadctl il est défini dans la base de registre et ne se change que si on le redéfini. Personnellement j'utilise indexctl à 3 et xloadctl à 2. Pour les chargement de gros xrefs cela peut améliorer grandement le temps de chargement et le partage de ceux-ci (si ceux-ci sont partagée entre différents utilisateurs) Voir l'aide si je n'ais pas été assez explicite. Bruno V

L'avantage, est la conservation de l'usage du double-click sur un bloc avec attributs pour éditer ceux-ci. Donc pour l'avoir disponible a chaque ouverture voir la discussion à: http://www.cadxp.com/sujetXForum-2209.htm Il y a eu certainement d'autre fils à ce sujet, fait une recherche. @+

Voici le lien du thème identique http://www.cadxp.com/sujetXForum-106.htm ;)

En attendant quelque chose de plus "catholique", tu peux faire ceci (tester sous 2002): Commande: nondef Entrez le nom de la commande: _eattedit Commande: (defun c:eattedit ()(command "ddatte")) C:EATTEDIT Et voici ce que tu obtiendras: Commande: _.eattedit ddatte Sélectionnez la référence de bloc:

Salut, Je trouve que pour débuter en LISP, ta demande est nettement pour un utilisateur très averti en Lisp. Néanmoins je te livre quelques lignes qui te permettrons de faire des groupes sans Noms (ils n'apparaitrons pas dans la boite de dialogue de la commande "Groupe" ) Il te faut savoir quand même qu'un groupe est DECOMPOSABLE ou simplement inactivable à l'aide des touches [CTRL+SHIFT+A] (command "_.-INSERT" (nth 1 (nth 2 public_style_cote)) p1 (nth 2 (nth 2 public_style_cote)) "" a5 ) (setq PRIVE_FLECHE (entlast)) (command "_.line" p1 p3 "") (setq PRIVE_LIGNE (entlast)) (if (null (dictsearch (namedobjdict) "LIGNE_FLECHE")) (setq xname (entmakex '((0 . "DICTIONARY") (100 . "AcDbDictionary"))) newdict (dictadd (namedobjdict) "LIGNE_FLECHE" xname) ) (setq newdict (cdar (dictsearch (namedobjdict) "LIGNE_FLECHE"))) ) (setq xname (entmakex (append '( (0 . "GROUP") (100 . "AcDbGroup") (300 . "Fleche & Ligne") (70 . 0) (71 . 1) ) (list (cons 340 prive_fleche) (cons 340 prive_ligne) ) ) ) ) (if (not (assoc 3 (dictsearch (namedobjdict) "LIGNE_FLECHE"))) (dictadd newdict "RECORD_1" xname) (dictadd newdict (strcat "RECORD_" (itoa (1+ (atoi (substr (cdr (assoc 3 (dictsearch (namedobjdict) "LIGNE_FLECHE"))) 8))))) xname) )

Je répond à la 1ere question, Tout en conservant ton profil en long avec un rapport de 1/1, tu peux le déformer en vue avec les quelques lignes suivantes. Avantage : l'interrogation d'un point sera juste malgré la déformation. (defun c:DeformPL ( / echll) (command "_.ucs" "_world") (initget 8) (setq echll (getpoint "\nEchelle du profil en long <1000,100>: ")) (if (eq echll ()) (setq echll '(1000 100))) (setvar "ucsfollow" 0) (command "_.ucs" "_y" (angtos (atan (/ (sqrt (- (* (car echll) (car echll)) (* (cadr echll) (cadr echll)) ) ) (cadr echll) ) ) 0 4 ) ) (command "_.ucs" "_save" "SCU_AXE-LONG") (command "_.plan" "_current") (command "_.ucs" "_previous") (prin1) ) Tu peux encore paufiner le code

Le Diesel n'est pas mon fort, :casstet: Je te livre ce que j'ai pu faire, mais il y a un problème , j'ai l'impression que la fin de la ligne est évalué avec un temps de retard. (la fois suivante, je ne comprends pas pourquoi) Mais bon c'est un début de piste: *^C^C_.area;_o;\_id;\_.setvar;userr1;$M=$(rtos,$(index,0,$(getvar,lastpoint)),2,2);_.setvar;userr2;$M=$(rtos,$(index,1,$(getvar,lastpoint)),2,2);_.-mtext;@;_h;0.5;_j;_mc;\$M=$(rtos,$(/,$(getvar,area),1),2,0) ;$M=$(rtos,$(/,$(getvar,perimeter),1),2,0)ml;;_.rectangle;@;$M=$(getvar,userr1),$(getvar,userr2);

La conversion de polyligne ou l'applatissement de celle-ci, vaste programme :( Je te propose plusieurs fonctions avec différentes approches. Il est possible de trouver mieux, ou encore d'autres approches ailleurs, faire des recherches sur d'autes forums ou sites. Tu trouveras peut être ton bonheur dans l'une des 3. ;) (defun c:spl3Dto2D ( / flag_erase old_osmd e l_dxf l_som 2d_lsom ) (setvar "cmdecho" 0) (initget "Général Courant _Wolrd Current") (if (eq (getkword "\nProjection 2D dans SCU [Général/Courant]: ") "Wolrd") (command "_.ucs" "_world") ) (initget "Oui Non _Yes No") (if (eq (getkword "\nEffacer la spline3D [Oui/Non] ") "No") (progn (princ "\nBien Chef, on conserve") (setq flag_erase T)) (setq flag_erase nil) ) (setq old_osmd (getvar "osmode")) (setq js (ssget "_X" '((0 . "SPLINE") (67 . 0) (410 . "Model")))) (cond (js (command "_.undo" "_begin") (setvar "osmode" 0) (repeat (setq n (sslength js)) (setq l_dxf (entget (setq e (ssname js (setq n (1- n)))))) (setq l_som (mapcar '(lambda (x) (trans x e 0)) (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) l_dxf)))) (setq 2d_lsom (mapcar '(lambda (x) (trans (list (car x) (cadr x) 0.0) 0 1)) l_som)) (command "_.pline" (foreach n 2d_lsom (command n)) ) (command "_.pedit" (entlast) "_spline" "") (if (not flag_erase) (entdel e) ) ) (setvar "osmode" old_osmd) (command "_.undo" "_end") ) (T (princ "\nAucune Spline trouvée") ) ) (setvar "cmdecho" 1) (prin1) ) (defun C:S-E2PL ( / ent typent dxf_ent obj_vlax param_start param_end perim_obj pt_start pt_end res_track flag_ucs last_e old_osmd old_pdmd l_pt) (while (null (setq ent (entsel "\nChoix de la Spline ou Ellipse à convertir en polyligne: ")))) (setq typent (cdr (assoc 0 (setq dxf_ent (entget (car ent)))))) (cond ((or (eq typent "SPLINE") (eq typent "ELLIPSE")) (vl-load-com) (setq obj_vlax (vlax-ename->vla-object (car ent)) param_start (vlax-curve-getStartParam obj_vlax) param_end (vlax-curve-getEndParam obj_vlax) perim_obj (vlax-curve-getDistAtParam obj_vlax (+ param_start param_end)) pt_start (vlax-curve-getStartPoint obj_vlax) pt_end (vlax-curve-getEndPoint obj_vlax) ) (initget 6) (setq res_track (getdist (cadr ent) (strcat "\nDistance de résolution<" (rtos (/ perim_obj 100.0)) ">: ")) last_e (entlast) old_osmd (getvar "osmode") old_pdmd (getvar "pdmode") ) (if (not res_track) (setq res_track (/ perim_obj 100.0))) (initget "Oui Non _Yes No") (if (eq (getkword "\nVoulez vous faire une projection sur le SCU courant? [Oui/Non]: ") "Yes") (setq flag_ucs nil) (progn (command "_.ucs" "_entity" (car ent)) (setq flag_ucs T) ) ) (cond ((and (eq typent "SPLINE") (not (zerop (boole 1 1 (cdr (assoc 70 dxf_ent)))))) (setq l_pt '("_close")) ) ((and (eq typent "ELLIPSE") (zerop (cdr (assoc 41 dxf_ent))) (eq (cdr (assoc 42 dxf_ent)) (* 2 pi))) (setq l_pt '("_close")) ) (T (setq l_pt (cons (trans pt_end 0 1) '(""))) ) ) (setvar "osmode" 0) (setvar "pdmode" 1) (setvar "cmdecho" 0) (command "_.measure" (car ent) res_track) (while (and (= (cdr (assoc 0 (setq dxf_ent (entget (entlast))))) "POINT") (not (equal (entlast) last_e)) ) (setq l_pt (cons (trans (cdr (assoc 10 dxf_ent)) 0 1) l_pt)) (entdel (entlast)) ) (command "_.pline" (mapcar 'command (cons (trans pt_start 0 1) l_pt))) (if flag_ucs (command "_.ucs" "_previous")) (initget "Oui Non _Yes No") (if (not (eq (getkword "\nEffacer l'entité source [Oui/Non] : ") "No")) (entdel (car ent)) ) (setvar "osmode" old_osmd) (setvar "pdmode" old_pdmd) (setvar "cmdecho" 1) ) (T (princ "\nN'est pas une Spline ou Ellipse!")) ) (prin1) ) (princ "\nS-E2PL.LSP chargé. Tapez S-E2PL pour convertir SPLINE ou ELLIPSE en POLYLIGNE.") (prin1) (defun c:PL3Dto2D ( / js flag_ps flag_ucs old_osmd lay_cur n ent l_dxf lay_nam s_dxf 2d_lsom flag_cl flag_sp nw_pt) (setq js (ssget "_X" '((0 . "POLYLINE") (-4 . "&=") (70 . 8) (410 . "Model")))) (cond (js (setvar "cmdecho" 0) (command "_.undo" "_begin") (if (zerop (getvar "tilemode")) (progn (setq flag_ps T) (setvar "tilemode" 1) ) (setq flag_ps nil) ) (if (zerop (getvar "worlducs")) (progn (setq flag_ucs T) (command "_.ucs" "_world") ) (setq flag_ucs nil) ) (setq old_osmd (getvar "osmode") lay_cur (getvar "clayer")) (repeat (setq n (sslength js)) (setq l_dxf (entget (setq ent (ssname js (setq n (1- n))))) lay_nam (cdr (assoc 8 l_dxf)) s_dxf (entget (entnext (cdar l_dxf))) 2d_lsom nil ) (if (zerop (boole 1 1 (cdr (assoc 70 l_dxf)))) (setq flag_cl nil) (setq flag_cl T) ) (if (zerop (boole 1 4 (cdr (assoc 70 l_dxf)))) (setq flag_sp nil) (setq flag_sp T) ) (while (/= (cdr (assoc 0 s_dxf)) "SEQEND") (if (zerop (boole 1 207 (cdr (assoc 70 s_dxf)))) (setq nw_pt (cdr (assoc 10 s_dxf)) 2d_lsom (cons (list (car nw_pt) (cadr nw_pt) 0.0) 2d_lsom) ) ) (setq s_dxf (entget (entnext (cdar s_dxf)))) ) (setvar "clayer" lay_nam) (command "_.pline" (foreach n 2d_lsom (command n)) ) (cond ((and flag_cl flag_sp) (command "_.pedit" (entlast) "_close" "_spline" "") ) (flag_cl (command "_.pedit" (entlast) "_close" "") ) (flag_sp (command "_.pedit" (entlast) "_spline" "") ) ) (entdel ent) (setvar "osmode" old_osmd) ) (if flag_ucs (command "_.ucs" "_previous")) (if flag_ps (setvar "tilemode" 0)) (setvar "clayer" lay_cur) (command "_.undo" "_end") (princ (strcat "\n" (itoa (sslength js)) " 3Dpoly(s) ont leurs Z à zéro et sont converties en 2Dpoly ou LWPOLYLINE.")) ) (T (princ "\nAucune 3Dpoly trouvée") ) ) (setvar "cmdecho" 1) (prin1) ) A essayer ! résultats non garantis Bruno V.

Voici un exemple pas trop long, qui fonctionne un peu à la façon des Express (par pointage) Tu peux améliorer le filtre pour y rajouter d'autres options (couleur, type de ligne, etc..) Cela peut être fait dans une boucle avec (getkword) et construire ainsi la liste de filtre pour affiner ta sélection. Mais déjà pour débuter simplement ;) je te laisse décortiquer (defun c:typ2calq ( / model_ent js vers_calqu ent n) (while (null (setq model_ent (entsel "\nChoix d'une entité type: ")))) (setq model_ent (entget (car model_ent))) (setq js (ssget "_X" (list (assoc 0 model_ent)))) (cond (js (while (null (setq vers_calqu (entsel "\nChoix de l'entité pour calque de destination: ")))) (setq vers_calqu (assoc 8 (entget (car vers_calqu))) n 0) (repeat (sslength js) (setq ent (entget (ssname js n))) (entmod (subst vers_calqu (assoc 8 ent) ent)) (setq n (1+ n)) ) (princ (strcat "\n" (itoa n) " entité(s) " (cdr (assoc 0 model_ent)) " sont sur le calque " (cdr vers_calqu))) ) ) (prin1) )

Patrick_35 a déjà donné la réponse a propos des scripts. En multi-session tu ne pourras faire cela. Par contre ceci peut fonctionner ^C^C'FILEDIA;0;SDI;1;_.new;"gabarit.dwt"; NB: La macro ne fonctionneras que SI 1 seul dessin est ouvert