bonuscad

Suite aux remarques de gilles, j'ai modifié la routine pour éviter de pouvoir saisir le point de départ sur la tangente. J'ai corrigé certaines abbérations de construction que j'ai remarqué et j'ai essayé surtout d'étendre la commande à des objets situé sur un SCU non parrallèle, pour peu que celui soit courant. A priori cela fonctionne bien avec des segments droit, mais avec des arcs je me heurte toujours a une erreur renvoyé par (vlax-safearray->list (vlax-variant-value (vla-IntersectWith si mes 2 objets sont des cercles dans un scu non parrallèle. Est ce une limitation de vla-intersectwith exemple (trans (vlax-safearray->list (vlax-variant-value (vla-IntersectWith (vlax-ename->vla-object (car (entsel))) (vlax-ename->vla-object (car (entsel))) 1 ) ) ) 0 1 ) de 2 cercles dans un scu non parrallèle me retourne qu'UNE SEULE intersection.... :mad:

Bizarre j'ai essayé la routine que tu as posté, et elle a fonctionné sans problème. J'ai même restauré tes vue que tu as posté :exclam: sauf que pour celle ci j'ai viré les codes 360 et 330 qui été "bouffé" pas postage. D'ailleurs je me demande si ce n'est pas cela qui pose problème. A mon souvenir le code 330 est généralement associé a un NOM d'entité (peut être aussi le 360, à voir). Dans ce cas, je comprend que l'import se fasse mal car il lui sera impossible de retrouver CETTE entité dans un autre dessin. Lors de mon test rapide, je n'ai pas retouvé ces codes dans le fichier TXT crée sur mon PC. Suggestion: enlève ces code du TXT et refait un essai pour voir si ça vient bien de là.

Si tu veux utiliser que cette routine, il te faut les fichiers suivants: Lambert.lsp Lambert.dcl Quad.pat ou Quadiso.pat (je ne sais plus!, mais cela n'a guère d'importance, ce sont les même) Repquad.pat ou Repquadiso.pat (idem) Ces fichiers doivent être IMPERATIVEMEMT placés dans un dossier de recherche pour que la boite de dialogue et les modèles de hachure puissent être trouvé par la routine. Et normalement cela devrait fonctionner.... Ha oui j'oubliait le fichier NordLamb.dwg, celui là tu peux le refaire à ton gout (en respectant l'échelle initiale) [Edité le 30/5/2006 par bonuscad]

Tu me rassures Mais non !!! , ça prouve simplement que ma logique est mal transcrite et incompréhensible. Ce qui parrait évident pour nous, ne l'ait pas forcément pour les autres. Je paufinerais pour éviter ce cas. Merci encore

Bien qu'elle ne m'apporte rien de plus sous ma version ("style de tracé du bloc" grisé). Je confirme quand même qu'elle fonctionne toujours, du moins pour les tests rapides que j'ai pu faire. Rassuré? ;)

Merci gile, j'ai essayé ta proposition, elle fonctionne que sur les arcs ou cercle, mais ne fait pas du tout ce que je veux. Pour être clair, le but premier est de fournir un point de départ un rayon et le programme regarde si la solution est possible pour terminer l'arc tangent à l'objet sélectionné en commencant par le point et de rayyon donné.. Si cela est possible les 4 solutions sont proposé: droite - gauche, arc simple et arc complémentaire (pour les 2 cotés) L'arc simple et complémentaire font en fait le cercle entier à l'écran, il faut supprimer manuellement la solution que l'on ne veut pas retenir. Ceci me sert juste à savoir ou est le point de départ par rapport à une ligne (à droite ou à gauche) pour savoir si je dois ajouter ou retrancher PI/2. Le cas = 0 est si le point de départ est sur la ligne cas peu probable car on cherche a y être tangent. J'espère que tu avais mal compris le but, ce qui pourrait expliquer l'echec de la routine car elle fonctionne bien chez moi, il faut dire que j'ai compris la logique de la commande puisque que je l'ai créé ;) Essayais tu de démmarrer avec un point qui se trouvait sur l'objet de tangence?

"Pack & Go" fait maintenant double emploi avec "ETransmit". Il est possible qu'il ne soit plus présent dans 2006 Donc as tu ta réponse ?

Merci pour le "retour". Si je crois me souvenir tu es sous 2007. Je l'ai conçu sous une 2005-2002. Donc il est fort possible que sous 2007 ça plante. Les fonction vlax, si elles sont perfommante, ont l'énorme désavantage de présenter des incompatibilté entre version :mad: Je ne puis malheuresement corrigé ce problème pour l'instant :(

J'ai essayer de créer une option de constuction d'arc comme définni dans le titre du post. Les objet acceptés pour la tangence sont des lignes, arcs, cercles et des polylignes optimisées arrondies ou pas. La routine fonctionne (normalement) dans des SCU paralèlles au SCG ET dans des SCU non parrallèle si celui ci est courrant (un problème persiste dans ce cas avec les arcs.) Il reste certainement des imperfections ou des cas non prévus, mais la perfection devient complexe à mettre en oeuvre. Je pense qu'elle pourra répondre aux besoins les plus courants. (vl-load-com) (defun near_vertex_arr (obj / dxf_obj e_next obj_vlax pt_sel par pt_first pt_snd i bulge) (setq dxf_obj (entget (car obj))) (setq obj_vlax (vlax-ename->vla-object (car obj)) pt_sel (osnap (cadr obj) "_near") ) (if (null pt_sel) (progn (while (null (setq e_next (entsel "\nDétermination du segment imprécise, resélectionnez: ")))) (setq pt_sel (osnap (cadr e_next) "_near")) ) ) (setq pt_sel (vlax-curve-getClosestPointTo obj_vlax (trans pt_sel 1 0)) par (vlax-curve-getParamAtPoint obj_vlax pt_sel) pt_first (trans (vlax-curve-getPointAtParam obj_vlax (fix par)) 0 1) pt_snd (trans (vlax-curve-getPointAtParam obj_vlax (1+ (fix par))) 0 1) i 0 ) (while (or (/= (caar dxf_obj) 42) (if (< i (fix par)) (setq i (1+ i)))) (setq bulge (cdadr dxf_obj) dxf_obj (cdr dxf_obj)) ) (list pt_first pt_snd bulge) ) (defun c:arc_pt_rad_tg ( / z_dir pt_start rad e_cir ent dxf_ent p_10 p_11 straight l_2pt id_rad v1 v2 det_or dir test obj_line obj_cir lst_int pc1 pc2 pt_end1 pt_end2 ss1 ss2 key) (setq z_dir (trans '(0 0 1) 1 0 T) dxf_ent nil) (while (null dxf_ent) (while (null (setq ent (entsel "\nSélectionner l'objet pour la tangence de l'arc: ")))) (setq dxf_ent (entget (car ent))) (if (or (not (member (cdr (assoc 0 dxf_ent)) '("LINE" "ARC" "CIRCLE" "LWPOLYLINE"))) (not (equal (cdr (assoc 210 dxf_ent)) z_dir 1E-8))) (progn (setq dxf_ent nil) (princ "\nN'est pas une ligne,arc, cercle ou lwpolyligne, ou non parrallèle au SCU courant!")) ) ) (cond ((eq (cdr (assoc 0 dxf_ent)) "LINE") (setq p_10 (cdr (assoc 10 dxf_ent))) (setq p_11 (cdr (assoc 11 dxf_ent))) (setq straight T) ) ((eq (cdr (assoc 0 dxf_ent)) "LWPOLYLINE") (setq l_2pt (near_vertex_arr ent)) (if (zerop (caddr l_2pt)) (setq p_10 (trans (car l_2pt) 1 0) p_11 (trans (cadr l_2pt) 1 0) straight T ) (setq id_rad (/ (distance (car l_2pt) (cadr l_2pt)) (sin (* 2.0 (atan (caddr l_2pt)))) 2.0) p_10 (trans (polar (car l_2pt) (- (angle (car l_2pt) (cadr l_2pt)) (- (* 2 (atan (caddr l_2pt))) (/ pi 2))) id_rad ) 1 0) straight nil ) ) ) (T (setq p_10 (trans (cdr (assoc 10 dxf_ent)) (car ent) 0) id_rad (cdr (assoc 40 dxf_ent)) straight nil) ) ) (while (null pt_start) (initget 9) (setq pt_start (trans (getpoint "\nPoint de départ de l'arc: ") 1 0)) (if (assoc 38 dxf_ent) (if (not (equal (+ (caddr (trans (list 0 0 0) 0 1)) (cdr (assoc 38 dxf_ent))) 0.0 1E-8)) (setq pt_start (list (car pt_start) (cadr pt_start) (cdr (assoc 38 dxf_ent)))) ) ) (cond (straight (setq v1 (mapcar '- p_10 p_11) v2 (mapcar '- p_10 pt_start) det_or (apply '(lambda (x1 y1 z1 x2 y2 z2) (- (* x1 y2) (* y1 x2))) (append v1 v2)) ) (if (equal det_or 0.0 1E-8) (progn (princ "\nLe point de départ ne peut appartenir à la tangente") (setq pt_start nil) ) ) ) (T (if (equal (polar (trans p_10 0 1) (angle (trans p_10 0 1) (trans pt_start 0 1)) id_rad) (trans pt_start 0 1) 1E-8) (progn (princ "\nLe point de départ ne peut appartenir à la tangente") (setq pt_start nil) ) ) ) ) ) (initget 67) (setq rad (getdist (trans pt_start 0 1) "\nRayon de l'arc: ")) (entmake (list (cons 0 "CIRCLE") (cons 100 "AcDbEntity") (cons 60 1) (cons 100 "AcDbCircle") (cons 10 (trans pt_start 0 z_dir)) (cons 40 rad) (cons 210 z_dir) ) ) (setq e_cir (entlast) dxf_ent nil) (cond (straight (cond ((> det_or 0.0) (setq dir (+ (angle (trans p_10 0 1) (trans p_11 0 1)) (/ pi 2)))) ((< det_or 0.0) (setq dir (- (angle (trans p_10 0 1) (trans p_11 0 1)) (/ pi 2)))) ) (entmake (list (cons 0 "LINE") (cons 100 "AcDbEntity") (cons 60 1) (cons 100 "AcDbLine") (cons 10 (trans (polar (trans p_10 0 1) dir rad) 1 0)) (cons 11 (trans (polar (trans p_11 0 1) dir rad) 1 0)) (cons 210 z_dir) ) ) (if (inters (trans pt_start 0 1) (polar (trans pt_start 0 1) (+ dir pi) (* 2.0 rad)) (trans p_10 0 1) (trans p_11 0 1) T) (setq test T) (setq test nil) ) ) (T (if (>= (distance (trans p_10 0 1) (trans pt_start 0 1)) (abs id_rad)) (setq id_rad (+ (abs id_rad) rad) det_or T) (setq id_rad (- (abs id_rad) rad) det_or nil) ) (entmake (list (cons 0 "CIRCLE") (cons 100 "AcDbEntity") (cons 60 1) (cons 100 "AcDbCircle") (cons 10 (trans p_10 0 z_dir)) (cons 40 (abs id_rad)) (cons 210 z_dir) ) ) (if (or (> (distance (trans p_10 0 1) (trans pt_start 0 1)) (+ (abs id_rad) rad)) (< (distance (trans p_10 0 1) (trans pt_start 0 1)) (- (abs id_rad) rad)) (< (distance (trans p_10 0 1) (trans pt_start 0 1)) (- rad (abs id_rad))) ) (setq test nil) (setq test T) ) ) ) (cond (test (setq obj_line (vlax-ename->vla-object (entlast))) (setq obj_cir (vlax-ename->vla-object e_cir)) (setq lst_int (vlax-variant-value (vla-IntersectWith obj_line obj_cir 1))) (entdel (entlast)) (entdel e_cir) (cond ((> (vlax-safearray-get-u-bound lst_int 1) 0) (setq lst_int (vlax-safearray->list lst_int)) (setq pc1 (trans (list (nth 0 lst_int) (nth 1 lst_int) (nth 2 lst_int)) 0 1)) (if (> (length lst_int) 3) (setq pc2 (trans (list (nth 3 lst_int) (nth 4 lst_int) (nth 5 lst_int)) 0 1)) (setq pc2 pc1) ) (if straight (setq pt_end1 (inters pc1 (polar pc1 dir rad) (trans p_10 0 1) (trans p_11 0 1) nil) pt_end2 (inters pc2 (polar pc2 dir rad) (trans p_10 0 1) (trans p_11 0 1) nil) ) (if det_or (setq pt_end1 (polar pc1 (angle pc1 (trans p_10 0 1)) rad) pt_end2 (polar pc2 (angle pc2 (trans p_10 0 1)) rad) ) (setq pt_end1 (polar pc1 (angle (trans p_10 0 1) pc1) rad) pt_end2 (polar pc2 (angle (trans p_10 0 1) pc2) rad) ) ) ) (setvar "CMDECHO" 0) (setq old_osmd (getvar "osmode")) (setvar "osmode" 0) (if (zerop (getvar "PICKFIRST")) (setvar "PICKFIRST" 1)) (command "_.arc" "_ce" pc1 (trans pt_start 0 1) pt_end1) (setq ss1 (ssget "_L")) (command "_.arc" "_ce" pc1 pt_end1 (trans pt_start 0 1)) (ssadd (entlast) ss1) (command "_.arc" "_ce" pc2 (trans pt_start 0 1) pt_end2) (setq ss2 (ssget "_L")) (command "_.arc" "_ce" pc2 pt_end2 (trans pt_start 0 1)) (ssadd (entlast) ss2) (setvar "osmode" old_osmd) (if (and ss1 ss2 (= 0 (getvar "CMDACTIVE"))) (progn (sssetfirst nil ss2) (princ "\n pour choix; < Entrée > /[Espace]/Click+droit pour finir!.") (while (and (not (member (setq key (grread T 4 2)) '((2 13) (2 32)))) (/= (car key) 25)) (cond ((eq (car key) 5) (if (< (distance pc1 (cadr key)) (distance pc2 (cadr key))) (sssetfirst nil ss1) (sssetfirst nil ss2) ) ) ) ) ) ) (command "_.erase") (setvar "CMDECHO" 1) (princ "\n*Cercle coupé aux points obligés* by me!!\n") ) (T (princ "\nDes intersections valides n'ont pu être trouvées!")) ) ) (T (entdel (entlast)) (entdel e_cir) (princ "\nPas d'intersection!") ) ) (prin1) ) [Edité le 30/5/2006 par bonuscad] [Edité le 5/6/2006 par bonuscad]

En modifiant ceci, cela à l'air de fonctionner, à vérifier! (set_tile "unt" (getvar "INSUNITS")) en (set_tile "unt" (itoa (getvar "INSUNITS"))) Bizzare que tu n'ais pas eu ce problème! :exclam: PS: tu as une fonction et une variable de même nom: EDIT_BL [Edité le 25/5/2006 par bonuscad]

Toujours pas! Ceci avant l'ouverture de la boite de dialogue, je vois juste un flash rapide d'essai d'ouverture. NB: Je suppose que le DCL, lui ne change pas entre chaque version? (Je l'ai quand même recopié pour faire l'essai)

Ouin ...... :( Qu'est que tu as fait gile?, sous 2002 ou 2005, j'ai systématiquement une erreur au lancement Erreur: type d'argument incorrect: fixnump: nil A priori cela vient des unités, j'ai essayé de changer (setq unt nil) en (setq unt 1) car cela bloquait sur (itoa unt) , comme ceci la boite de dialogue s'ouvre, mais cela plante plus loin lors de la validation de la boite Je te laisse regarder ;)

Généralement j'utilise simplement les grips pour faire cela, ça fonctionne très bien, le seul hic et si on a beaucoup de sommet à étirer, c'est la sélection de ceux-ci qui est fastidieuse. :mad:

Pour moi c'est l'inverse, je passe moins de temps maintenant (avec un bémol) qu'avant pour produire les dossiers que sous le format papier. Hé oui je dématérialise, le hic qu'il reste et qu'il faut que je produise une multiplicité de format numérique (PDF WORD EXCEL DWG DWF DXF) pour pouvoir contenter la majorité des demandeurs avec les problèmes de versions et tout ce qui suit. Généralement j'essaye de produire en version la plus anciennne possible pour qu'il n'y ait pas de surprises, mais tout ça prend du temps quand même :casstet: et au final il arrive encore souvent que le demandeur réclame un dossier papier :mad: Mais bon c'est les débuts, j'espère que tout ça va s'harmoniser, car pour l'instant cela me fait plus de boulot

En lisp, une liste à 2 éléments s'appelle une "paire pointée", d'où l'explication de la présence du point entre les 2 éléments. Pour la construire, 2 possibilités: la plus courante avec "cons" (cons 0 "LINE") -> (0 . "LINE") ou avec "quote" ou " ' " (quote (0 . "LINE")) ou '((0 . "LINE")) -> (0 . "LINE") Ici l'usage de la variable avec le nom "calque" peut être utilisé, ce qu'il faudrait éviter est plutot un (defun c:calque (.....)) c'est à dire une définition de fonction qui pourrait remplacer la commande "calque". Par contre, par exemple un (defun list (.....)) est déconseillé car (list) est déjà une fonction Autolisp. Pour les variables, il faut plutot éviter un truc du genre (setq T nil) ou (setq pi (sqrt 2))

Pour le "Fun" et si ça peut te donner des idées, un exemple de ce qu'on peut faire ausssi pour avoir un contour un peu "spécial" hachuré. (defun make_line (flag p10 p11 / ) (entmake (list (cons 0 "LINE") (cons 100 "AcDbEntity") (cons 67 (if (eq (getvar "CVPORT") 2) 0 1)) (cons 410 (getvar "CTAB")) (cons 8 (getvar "CLAYER")) (cons 60 flag) (cons 62 (if (eq (getvar "CECOLOR") "BYLAYER") 256 (getvar "CECOLOR"))) (cons 6 (getvar "CELTYPE")) (cons 370 (getvar "CELWEIGHT")) (cons 100 "AcDbLine") (cons 39 (getvar "THICKNESS")) (cons 10 p10) (cons 11 p11) (cons 210 (list 0.0 0.0 1.0)) ) ) ) (defun c:bound_hatch ( / pt1 pt2 pt_o mod js) (setvar "cmdecho" 0) (initget 9) (setq pt1 (getpoint "\nPoint de départ: ") pt_o pt1 mod 0 js (ssadd)) (initget 9 "Invisible Clore") (while (not (equal pt2 pt_o)) (setq pt2 (getpoint pt1 "\nPoint suivant ou segment [invisible/Clore]: ")) (if (listp pt2) (progn (make_line mod (trans pt1 1 0) (trans pt2 1 0)) (setq mod 0 pt1 pt2 js (ssadd (entlast) js)) ) (if (eq pt2 "Invisible") (setq mod 1) (progn (make_line mod (trans pt1 1 0) (trans pt_o 1 0)) (setq pt2 pt_o js (ssadd (entlast) js)) ) ) ) (initget 9 "Invisible Clore") ) (cond ((> (sslength js) 2) (command "_.-bhatch" "_select" js "" "") ) (T (princ "\nIl faut 3 segments pour hachurer cette zone.")) ) (setvar "cmdecho" 1) (prin1) ) [Edité le 24/5/2006 par bonuscad]

Oui, tu as raison, le changement de police permet de placer plus de caractères sur la ligne de commande, mais lors de la validation, celle ci est formatée en 80 colonnes. Dès fois je joue avec le format des unités de longueur et angulaire pour avoir un affichage correct de l'écran texte et une présentation plus lisible. C'est vrai qu'il est dommage d'être confronté à ce genre de problème avec les versions actuelles :casstet:

Merci pour l'info ;)

Signifie que l'argument sousmis n'est pas une liste. Je ne sais comment est ta variable ncalque, donc je pense plutôt à cette ligne (list (cons 8 ncalque)), ou ailleurs dans le reste de ton code non posté. J'ai trouvé: (length) requiert une liste! Tu doit employer (sslength) pour avoir le nombres d'éléments dans un jeu de sélection. [Edité le 23/5/2006 par bonuscad]

Vérifie que ta variable DRAGMODE soit à 2

Et en allant dans les options, onglet affichage. :exclam: Si tu choisis une autre police. Moi par exemple j'utilise la police "Fixedsys" en standard et de taille 7 et il me semble que la ligne de commande ainsi définie, contient beaucoup plus de caractères.

Sans savoir si ça peut répondre à ton souhait, le code suivant serait peut être une source de départ? Je l'avais créer pour un besoin précis et il avait fonctionné pour ce que je voulais obtenir, donc à voir et peut être à creuser d'avatantage. Si je me souviens bien c'est pour obtenir un chemin relatif au dossier en cours et non fixe (ça fais un moment que je ne l'ai pas utilisé) (defun c:relatif_xref ( / cmd bl ch rc n tot) (setq cmd (getvar "cmdecho") tot 0 ch (getvar "dwgprefix") bl (tblnext "block" t) ) (setvar "cmdecho" 0) (command "_.undo" "_group") (princ "\nTravail en cours...")(princ) (while bl (if (= (logand (cdr (assoc 70 bl)) 4) 4) (progn (setq rc (cdr (assoc 1 bl)) n (vl-string-mismatch rc (getvar "dwgprefix") 0 0 T) ) (cond ((and (not (zerop n)) (> n 2)) (setq rc (strcat ".." (substr rc n)))) (T (setq rc "")) ) (if (findfile rc) (progn (command "_.-xref" "_path" (cdr (assoc 2 bl)) rc) (setq tot (1+ tot)) ) ) ) ) (setq bl (tblnext "block")) ) (command "_.undo" "_end") (setvar "cmdecho" cmd) (princ (strcat "\nModification de " (itoa tot) " chemin(s)")) (princ) )

Un bloc avec seulement des attributs invisibles peut être une bonne solution (comme ça il sera plus difficile de le supprimer par inavertance et de pouvoir le purger) On peut aussi se tourner vers les XDATA attachés un point (par exemple) mis sur le calque defpoint (comme ça, il n'est pas imprimé). Ceci pour conserver les infos (elles suivent le DWG durant sa vie).

Disons que c'est simplement une convention adopté par tous depuis longtemps. Avant la venu de l'informatique, on travaillait comme ceci sur papier, (donc en 2D) L'echelle en Z est devenu (logiquement) l'échelle en Y (sens de la hauteur sur le papier). Vu que cela est reconnu par tous les professionnels qui lisent les plans, cela ne pose aucun problème. Dans le même ordre, il y a eu un moment le sens de lecture des profils en travers, qui a posé plus de problème. Certain disaient qu'on devait les représenter face au sens du projet, et d'autres qu'on devait les représenter dos au projet, ce qui avait pour effet d'inverser les cotés droite et gauche.:casstet: Maintenant l'informatique à trancher, on regarde face au projet :P Oui, mais admise depuis par tous

C'est le cas quand l'objet source était une polyligne simple donc la routine suivante devrait fonctionner dans ce cas précis. (Ajuster le cas échant la variable PEDITACCEPT) ((lambda ( / ) (command "_point" (getvar "lastpoint")) (setq e_mark (entlast)) (while (null (setq ent_sel (entsel "\nChoix de la région: ")))) (cond ((eq (cdr (assoc 0 (entget (car ent_sel)))) "REGION") (command "_.explode" ent_sel) (setq js (ssadd)) (setq e_next (cdar (entget e_mark))) (while e_next (setq js (ssadd e_next js)) (setq e_next (entnext (cdar (entget e_next)))) ) (command "_.pedit" (cadr ent_sel) "_yes" "_join" js "" "") ) ) (entdel e_mark) (prin1) ))