Trait d\'axe

[fauxsuisse]

Bonjour tout le monde.

 

J'ai une petite question bête, voila j'ai des double ligne tracés sur mon plan mais maintenant j'aimerai tracé une ligne à l'axe de ces doubles lignes mais voilà l'idéal c'est que le trait commence à une certaine longueur avant le point d'insertion en gros je voudrait par exemple tracé un trait qui fait 20cm de long mais que graphiquement il fasse 22cm donc 1cm avant et 1 cm après.

:exclam:

[lili2006]

Bonjour à toutes et tous,

 

Avec la commande diviser et le bloc "ligne" qui va bien ?

[didier]

coucou

 

qui fait 20cm de long mais que graphiquement il fasse 22cm

 

???

 

une petite clarification, s'il te plaît :exclam:

 

amicalement

[bryce]

Bonjour,

 

Commandes "Décaler", puis "Modifier la longueur" avec l'option DIfférence ?

Ou un lisp pour automatiser...

[norrin76]

accroch' objet mileu entre deux points aussi...tellement d'option en fait...je vois pas le soucis meme droite bissectrice puis ajuster sans prolongement...etc etc...

[fauxsuisse]

Salut Didier,

 

Effectivement je pensais aussi que mon explication n'était pas forcément très claire.

En somme quand on trace un trait celui ci commence à partir du point donné et fini au second point mais moi ce que j'aimerai c'est que mon trait commence par exemple 1 cm avant le point et fini de même 1cm après.

En fait j'ai tracé des chemins de câbles que sont des multilignes avec des blocs pour les angles etc. maintenant j'aimerai tracé l'axe de ces éléments, actuellement j'utilise la fonction "xline" droite qui fonctionne très bien mais au bout d'un moment il y a un peu beaucoup de trait qui traverse tout l'écran et ne s'y retrouve plus.

Ce qui m'intéresserais c'est d'avoir une xline mais qui ne ferait pas tout l'écran.

A l'époque j'avais un ancien programme ou l'on pouvait créer un type de trait qui justement permettait de commencer à une distance avant le point d'insertion et se terminer un peu plus long après le second point. :casstet:

 

Voilà j'espère que j'étais un peu plus claire

[Carboleum]

En somme quand on trace un trait celui ci commence à partir du point donné et fini au second point mais moi ce que j'aimerai c'est que mon trait commence par exemple 1 cm avant le point et fini de même 1cm après.

 

la commande lengthen est ton amie

[bryce]

Bonjour,

 

Je te propose une macro qui permet d'automatiser un peu le dessin de tes axes :

 

*^C^C$m=$(if,$(=,$(getvar,userr1),0),modemacro;"Longueur de dépassement : ";userr1;\modemacro;.;)_line;_m2p;\$m=$(if,0,)_m2p;\;_lengthen;_de;"$m=$(getvar,userr1)";"""$m=$(getvar,lastpoint)""";"""""$m=$(getvar,lastpoint)""""";;

 

La longueur de dépassement des axes est stockée dans la variable USERR1.

Si celle-ci est à 0 (c'est le cas par défaut), la macro demande une valeur lors de la première utilisation.

 

Voici une petite vidéo montrant l'utilisation de la macro :

 

Le lisp permettrait de faire quelque chose de beaucoup plus sophistiqué, mais l'avantage de la macro est qu'elle fonctionnera aussi sur LT.

[fauxsuisse]

Salut Bryce :P

C'est exactement ce que je voulais et ton exemple vidéo est justement l'utilisation que j'en fais.

 

Juste un petit détail, est-il possible de supprimer le principe de devoir choisir le milieu de deux points à chaque fois car mes multiligne sont toujours fermée donc l'accrochage au milieu est plus rapide, si non c'est parfait.

Merci :P

[bryce]

Oui, voici la même macro mais en ne choisissant qu'un point pour chaque extrémité de l'axe, et en utilisant les accrochages actifs :

 

*^C^C$m=$(if,$(=,$(getvar,userr1),0),modemacro;"Longueur de dépassement : ";userr1;\modemacro;.;)_line;\$m=$(if,0,)\;_lengthen;_de;"$m=$(getvar,userr1)";"""$m=$(getvar,lastpoint)""";"""""$m=$(getvar,lastpoint)""""";;

 

Et la même, mais en forçant l'accrochage milieu :

 

*^C^C$m=$(if,$(=,$(getvar,userr1),0),modemacro;"Longueur de dépassement : ";userr1;\modemacro;.;)_line;_mid;\$m=$(if,0,)_mid;\;_lengthen;_de;"$m=$(getvar,userr1)";"""$m=$(getvar,lastpoint)""";"""""$m=$(getvar,lastpoint)""""";;

[fauxsuisse]

Merci Bryce c'est vraiment parfait.

T'as bien compris ce que je cherchais et je vais gagner beaucoup de temps avec tes macros.

 

Merci encore et bon dimanche. :P :P :P

[Joutof]

Bonjour,

 

Je relance un peux ce vieux sujet.

En fait je cherche quelque chose de ressemblant :

J'ai un dessin autocad 2D (Autovad 2011).

Dessus j'ai des tubes et gaines (généré par un autre logiciel).

Je l'insère en xref. Ensuite je fait un fichier d'habillage.

Je voudrais savoir s'il existait une commande ou un lisp pour faire automatiquement les traits d'axe.

On clique sur une ligne puis sur l'autre et hop le trait d'axe apparait au milieu.

Vu que j'ai aussi des coudes il faudrait que la lisp soit compatible avec les arcs de cercle.

 

Quelqu'un voit commlent faire ça ?

[kallain]

Salut,

 

Dans ton cas, il faudrait chercher du côté des routines

du genre moyenne entre 2 polylignes que tu dois pouvoir trouver sur ce site.

[Joutof]

Oui effectivement j'avais bien 2-3 astuces à ce sujet mais le soucis c'est que ce n'est pas des polylignes, c'est des lignes et qui plus est en xref (donc pas sélectionnable).

Il n'est pas concevable pour nous de travailler directement sur l'xref puisque qu'elle est 100% régénérée assez souvent par l'autre logiciel, ce qui aurrait comme concéquence de supprimer le travail.

[bonuscad]

Je peut te proposer ceci, à condition que l'xref soit attaché au point 0,0,0 sans facteur d'échelle et l'angle d'insertion à zéro (autrement il faudrait approfondir le code)

Cela devrait fonctionner avec des LIGNE,ARC et POLYLIGNE allégées (pour peu qu'elles aient le même nombres de sommets)

(defun sel_obj (msg / ent dxf_ent)
 (while (not ent)
   (setq ent (nentsel msg))
   (cond
     (ent
       (setq dxf_ent (entget (car ent)))
       (if (member (cdr (assoc 0 dxf_ent)) '("LINE" "ARC" "LWPOLYLINE"))
         dxf_ent
         (progn
           (setq ent nil)
           (princ "\nL'objet ne convient pas! Attend une LIGNE, ARC ou POLYLIGNE.")
         )
       )
     )
     (T
       (princ "\nAucun objet sélectionné!")
     )
   )
 )
)
(defun c:axe_tuy ( / fst_ob snd_obj dxf_obj n e_valid tmp_obj lst1 lst2 nw_lst l_vtx l_blg lremov)
 (setq
   fst_obj (sel_obj "\nSélectionner le 1er objet: ")
   snd_obj (sel_obj "\nSélectionner le 2ème objet: ")
 )
 (cond
   ((eq (cdr (assoc 0 fst_obj)) (cdr (assoc 0 snd_obj)))
     (setq dxf_obj fst_obj n 1 e_valid T tmp_obj snd_obj)
     (repeat 2
       (set (read (strcat "lst" (itoa n)))
         (cond
           ((eq (cdr (assoc 0 dxf_obj)) "LINE")
             (list (cons (cdr (assoc 10 dxf_obj)) 0.0) (cons (cdr (assoc 11 dxf_obj)) 0.0))
           )
           ((eq (cdr (assoc 0 dxf_obj)) "ARC")
             (list (cons (cdr (assoc 10 dxf_obj)) (cdr (assoc 40 dxf_obj))) (cons (list (cdr (assoc 50 dxf_obj)) (cdr (assoc 51 dxf_obj))) 0.0))
           )
           ((eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE")
             (mapcar 'cons
               (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) dxf_obj))
               (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 42)) dxf_obj))
             )
           )
         )
       )
       (setq dxf_obj snd_obj n (1+ n))
     )
     (While e_valid
       (setq nw_lst
         (mapcar 'cons
           (mapcar
             '(lambda (x y)
               (list
                 (* (+ (caar x) (caar y)) 0.5)
                 (* (+ (cadar x) (cadar y)) 0.5)
               )
             )
             lst1 lst2
           )
           (mapcar
             '(lambda (x y)
               (* (+ (cdr x) (cdr y)) 0.5)
             )
             lst1 lst2
           )
         )
       )
       (cond
         ((eq (cdr (assoc 0 dxf_obj)) "LINE")
           (setq
             dxf_obj (subst (cons 10 (caar nw_lst)) (assoc 10 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 11 (caadr nw_lst)) (assoc 11 dxf_obj) dxf_obj)
           )
         )
         ((eq (cdr (assoc 0 dxf_obj)) "ARC")
           (setq
             dxf_obj (subst (cons 10 (caar nw_lst)) (assoc 10 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 40 (cdar nw_lst)) (assoc 40 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 50 (caaadr nw_lst)) (assoc 50 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 51 (car (cdaadr nw_lst))) (assoc 51 dxf_obj) dxf_obj)
           )
         )
         ((eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE")
           (setq l_vtx (mapcar 'car nw_lst) l_blg (mapcar 'cdr nw_lst) dxf_obj nil)
           (while tmp_obj
             (cond
               ((eq (caar tmp_obj) 10)
                 (setq dxf_obj (cons (cons 10 (car l_vtx)) dxf_obj) l_vtx (cdr l_vtx))
               )
               ((eq (caar tmp_obj) 42)
                 (setq dxf_obj (cons (cons 42 (car l_blg)) dxf_obj) l_blg (cdr l_blg))
               )
               (T
                 (setq dxf_obj (cons (car tmp_obj) dxf_obj))
               )
             )
             (setq tmp_obj (cdr tmp_obj))
           )
           (setq dxf_obj (reverse dxf_obj))
         )
       )
       (setq lremov nil)
       (foreach n dxf_obj (if (member (car n) '(5 330 -1)) (setq lremov (cons (car n) lremov))))
       (foreach m lremov
         (setq dxf_obj (vl-remove (assoc m dxf_obj) dxf_obj))
       )
       (entmake (subst (cons 8 (getvar "CLAYER")) (assoc 8 dxf_obj) dxf_obj))
       (cond
         ((not (eq (cdr (assoc 0 dxf_obj)) "ARC"))
           (initget "Dessine Autre _Draw Other")
           (if (eq (getkword "\nChoisir la solution [Dessine/Autre]? <Dessine>: ") "Other")
             (progn
               (setq lst2 (reverse lst2) e_valid T)
               (if (eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE")
                 (setq
                   lst2 (mapcar 'cons (mapcar 'car lst2) (mapcar '- (mapcar 'cdr (append (cdr lst2) (list (car lst2))))))
                   tmp_obj snd_obj
                 )
               )
               (entdel (entlast))
             )
             (setq e_valid nil)
           )
         )
         (T (setq e_valid nil))
       )
     )
   )
   (T
     (princ "\nLes objet sont de nature différente")
   )
 )
 (prin1)
)

Modifié le 29 mai 2013 par bonuscad

[Joutof]

Merci,

 

Je viens d'essayer le lisp mais j'obtient une erreur :

; erreur: nombre d'arguments insuffisants

 

J'ai changé le début du code pour lancer le lisp avec la commande "tax" :

(defun c:tax (msg / ent dxf_ent)

Ai-je fait une boulette ??

[-Olivier-]

Bonjour Joutof,

 

Ai-je fait une boulette ??

OUI ! :D

 

La commande principale est plus loin c:axe_tuy. C'est ce nom qu'il te faut changer.

La partie que tu as modifié ne commence pas par c: . C'est donc une fonction intermédiaire appelée par la fonction principale. Si tu changes son nom, elle pourra plus être utilisée par la commande principale, d'où l'erreur.

 

Olivier

[Joutof]

Oups, éffectivement... C'était bien ça.

Du coup ça fonctionne très bien pour les arcs qu'il soit sur une xref ou direct dans le dessin. Ca fonctionne aussi très bien pour 2 lignes directement sur le dessin, par contre pour 2 lignes sur l'xref, il me dessine un point (une ligne de longueur 0 pour être exacte).

Il n'arrive pas à dessiner un trait d'axe de la bonne longueur.

Vu que j'y connais pas grand chose en lisp, est-ce quelquechose de facile à modifier ?

[bonuscad]

Il n'arrive pas à dessiner un trait d'axe de la bonne longueur.

 

Ce qu'il peut se passer, c'est que les lignes (ou polylignes) n'aient pas le même sens de parcours (Cela ne s'applique pas aux Arcs, qui eux sont toujours dans le sens trigo); cela crée donc un effet papillon pour le résultat qui est faux.

 

Pour palier à ce problème, j'ai modifié le code précédent pour pouvoir dessiner l'autre solution si la première ne convient pas.

[Joutof]

Ca marche niquel !! Merci !!

Ca me sauve la vie :D

Je vais juste être un peux chian, mais plutot que de proposer la possibilité il serait pas plus "transparent" de tester la longeur de la ligne créer et si elle vaut 0 choisir automatiquement l'autre solution ?

 

Si c'est pas possible, c'est pas grave, c'est niquel comme ça !!

[bonuscad]

plutot que de proposer la possibilité il serait pas plus "transparent" de tester la longeur de la ligne créer et si elle vaut 0 choisir automatiquement l'autre solution ?

 

Ça te donne zéro car tes lignes sont horizontale ou verticale et de même longueur, mais si tu sort de ce cas précis, ce n'est plus le cas!

En plus je te rappelle qu'il peut traiter les polylignes (avec arc) et avoir une longueur de 0.0 est peu probable.

 

Pour rappel, le code peut traiter des arêtes non parallèles et de longueur différente (réduction de diamètre, même dissymétrique), mais il est mieux d'avoir une cohérence entre celles-ci pour que le résultat soit valable car le code ne vérifie pas cette cohérence. (Ça compliquerai beaucoup le code pour faire cela)

 

Pour résumer: c'est un traceur de médiane de segments.

[Joutof]

Ok ! Merci encore pour ce lisp bien pratique.

[Joutof]

Bon c'est encore moi...

Maintenant que les traits d'axe fonctionnent niquel, je me suis dit qu'il était peut être possible de faire la même chose avec les cercles ?

Alors j'ai déjà lu un post la dessus, mais comme mes cercles sont sur une xref et pas toujours fermés, je ne peut pas les sélectionner.

Actuellement j'utilise un bloc construit à l'échelle 1:1 que je déforme en fonction du Ø de mon cercle.

Ca marche pas mal mais pas très pratique...

[bonuscad]

je me suis dit qu'il était peut être possible de faire la même chose avec les cercles ?

 

La version proposée traitant les arcs, il ne m'est pas compliqué de rajouter les cercles.

 

Alors voilà!

 

(defun sel_obj_median (msg / ent dxf_ent)
 (while (not ent)
   (setq ent (nentsel msg))
   (cond
     (ent
       (setq dxf_ent (entget (car ent)))
       (if (member (cdr (assoc 0 dxf_ent)) '("LINE" "ARC" "CIRCLE" "LWPOLYLINE"))
         dxf_ent
         (progn
           (setq ent nil)
           (princ "\nL'objet ne convient pas! Attend une LIGNE, ARC,CERCLE ou POLYLIGNE.")
         )
       )
     )
     (T
       (princ "\nAucun objet sélectionné!")
     )
   )
 )
)
(defun c:vertex_median ( / fst_ob snd_obj dxf_obj n e_valid tmp_obj lst1 lst2 nw_lst l_vtx l_blg lremov)
 (setq
   fst_obj (sel_obj_median "\nSélectionner le 1er objet: ")
   snd_obj (sel_obj_median "\nSélectionner le 2ème objet: ")
 )
 (cond
   ((eq (cdr (assoc 0 fst_obj)) (cdr (assoc 0 snd_obj)))
     (setq dxf_obj fst_obj n 1 e_valid T tmp_obj snd_obj)
     (repeat 2
       (set (read (strcat "lst" (itoa n)))
         (cond
           ((eq (cdr (assoc 0 dxf_obj)) "LINE")
             (list (cons (cdr (assoc 10 dxf_obj)) 0.0) (cons (cdr (assoc 11 dxf_obj)) 0.0))
           )
           ((eq (cdr (assoc 0 dxf_obj)) "ARC")
             (list (cons (cdr (assoc 10 dxf_obj)) (cdr (assoc 40 dxf_obj))) (cons (list (cdr (assoc 50 dxf_obj)) (cdr (assoc 51 dxf_obj))) 0.0))
           )
           ((eq (cdr (assoc 0 dxf_obj)) "CIRCLE")
             (list (cons (cdr (assoc 10 dxf_obj)) (cdr (assoc 40 dxf_obj))))
           )
           ((eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE")
             (mapcar 'cons
               (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) dxf_obj))
               (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 42)) dxf_obj))
             )
           )
         )
       )
       (setq dxf_obj snd_obj n (1+ n))
     )
     (if (not (eq (length lst1) (length lst2))) (progn (setq e_valid nil) (princ "\nPas de cohérence dans le nombre de sommets.")))
     (While e_valid
       (setq nw_lst
         (mapcar 'cons
           (mapcar
             '(lambda (x y)
               (list
                 (* (+ (caar x) (caar y)) 0.5)
                 (* (+ (cadar x) (cadar y)) 0.5)
               )
             )
             lst1 lst2
           )
           (mapcar
             '(lambda (x y)
               (* (+ (cdr x) (cdr y)) 0.5)
             )
             lst1 lst2
           )
         )
       )
       (cond
         ((eq (cdr (assoc 0 dxf_obj)) "LINE")
           (setq
             dxf_obj (subst (cons 10 (caar nw_lst)) (assoc 10 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 11 (caadr nw_lst)) (assoc 11 dxf_obj) dxf_obj)
           )
         )
         ((eq (cdr (assoc 0 dxf_obj)) "ARC")
           (setq
             dxf_obj (subst (cons 10 (caar nw_lst)) (assoc 10 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 40 (cdar nw_lst)) (assoc 40 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 50 (caaadr nw_lst)) (assoc 50 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 51 (car (cdaadr nw_lst))) (assoc 51 dxf_obj) dxf_obj)
           )
         )
         ((eq (cdr (assoc 0 dxf_obj)) "CIRCLE")
           (setq
             dxf_obj (subst (cons 10 (caar nw_lst)) (assoc 10 dxf_obj) dxf_obj)
             dxf_obj (subst (cons 40 (cdar nw_lst)) (assoc 40 dxf_obj) dxf_obj)
           )
         )
         ((eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE")
           (setq l_vtx (mapcar 'car nw_lst) l_blg (mapcar 'cdr nw_lst) dxf_obj nil)
           (while tmp_obj
             (cond
               ((eq (caar tmp_obj) 10)
                 (setq dxf_obj (cons (cons 10 (car l_vtx)) dxf_obj) l_vtx (cdr l_vtx))
               )
               ((eq (caar tmp_obj) 42)
                 (setq dxf_obj (cons (cons 42 (car l_blg)) dxf_obj) l_blg (cdr l_blg))
               )
               (T
                 (setq dxf_obj (cons (car tmp_obj) dxf_obj))
               )
             )
             (setq tmp_obj (cdr tmp_obj))
           )
           (setq dxf_obj (reverse dxf_obj))
         )
       )
       (setq lremov nil)
       (foreach n dxf_obj (if (member (car n) '(5 330 -1)) (setq lremov (cons (car n) lremov))))
       (foreach m lremov
         (setq dxf_obj (vl-remove (assoc m dxf_obj) dxf_obj))
       )
       (entmake (subst (cons 8 (getvar "CLAYER")) (assoc 8 dxf_obj) dxf_obj))
       (cond
         ((not (member (cdr (assoc 0 dxf_obj)) '("ARC" "CIRCLE")))
           (initget "Accepter Voir _Accept See")
           (if (eq (getkword "\nChoisir la solution affichée, [Accepter/Voir] la suivante? <Accepter>: ") "See")
             (progn
               (setq lst2 (reverse lst2) e_valid T)
               (if (eq (cdr (assoc 0 dxf_obj)) "LWPOLYLINE")
                 (setq
                   lst2 (mapcar 'cons (mapcar 'car lst2) (mapcar '- (mapcar 'cdr (append (cdr lst2) (list (car lst2))))))
                   tmp_obj snd_obj
                 )
               )
               (entdel (entlast))
             )
             (setq e_valid nil)
           )
         )
         (T (setq e_valid nil))
       )
     )
   )
   (T
     (princ "\nLes objet sont de nature différente")
   )
 )
 (prin1)
)

[Joutof]

Que d'efficacité et de rapidité ;)

Par contre je crois bien que je me suis mal exprimé, je parlais plutot de ceci :

http://leconmath.tableau-noir.net/images/symetrie-cercle.jpg

 

Du coup je sais pas si c'est applicable au même lisp ?