Rotation d'attributs de blocs, selon les polylignes les plus proches

[Kilian336]

Bonjour,

 

Je cherche un moyen depuis des années d'accélérer le traitement des altitudes sur des plans topos. Je cherche à orienter les attributs d'altitudes de mes blocs points topo, pour les faire s'orienter selon la polyligne sur lequel ils sont insérés, et selon les polylignes les plus proches, s'ils sont isolés.

J'ai fait plusieurs recherches, y compris sur des forums anglophones, mais personnes ne parle d'orientation sur les polylignes les plus proches, ce qui est mon plus gros soucis aujourd'hui.

J'ai Covadis, alors je sais orienter les attributs selon une polyligne, mais je sais le faire un par un, j'aimerais le faire d'un coup pour tous les points où passe une polyligne.

Par contre, je n'ai jamais trouvé de moyen d'orienter ces attributs selon la polyligne la plus proche, c'est la où j'aurais bien besoin d'aide.

J'ai une idée de fonctionnement de lisp mais je ne sais pas si c'est réalisable :

1 - Orienter tous les attributs ALT des blocs (tcpoint.bpt) selon les polylignes par lesquelles passent ces mêmes blocs (c'est à dire que les points d'insertion des blocs (et non des attributs) = un sommet d'une polyligne)

2 - Orienter les attributs des blocs non pris en compte dans l'étape 1 (c'est à dire ceux dont aucune polyligne ne passe) selon la polyligne la plus proche du point d'insertion du bloc (et non de l'attribut)

Avec une autre difficulté qui serait d'orienter tous ces attributs, selon le sens de lecture du plan, c'est à dire par rapport au SCU "vue". Je m'explique : Aujourd'hui, avec mon AutoCAD et mon Covadis, si je travaille sur un plan topo avec un SCU perso orienté différemment du SCU général, selon l'orientation de certaines polylignes, il se peut que l'attribut ALT soit affiché à l'envers (après l'outil Covadis d'orientation des points topos selon polyligne), car ce même outil, travaille toujours selon le SCG, ce qui m'oblige à inverser certaines altis, ce qui peut-être vite redondant. Il faudrait que le lisp que je propose puisse travailler, selon le SCU en cours au moment de lancer la commande, afin de palier à ces altis correctement orientés, mais à l'envers.

 

Petit détail mais qui à son importance pour moi, l'idéal serait que la rotation des blocs et des autres attributs ne changent pas, seul l'attribut ALT serait modifié.

 

Je vous joint un bout du plan topo sur lequel je travaille, pour vous donner une idée, et pour avoir la composition de mon bloc tcpoint (j'ai commencé a dégrossir l'orientation des altis selon les rues)

 

Merci beaucoup pour avance à ceux qui se pencheront sur le sujet, bonne journée !

PlanTopoExemple.dwg

[didier]

Bonjour @Kilian336

Tout ça dépend de l'utilité finale.
Perso, lorsque je dois rendre un plan topo de ce genre, je ne "livre" pas toutes les altitudes sur ma mise en page.
Je change certains attributs, ceux que je veux voir imprimés, de calque et dans ma fenêtre de présentation, je gèle le calque des attributs que je ne veux pas voir.
Bien sûr, ceux qui seront désormais visibles sont tournés pour s'aligner sur la polyligne ou la ligne afférente.
Du coup, j'ai tendance à travailler point par point, car de cette façon, je relis pour contrôle et je choisis bien celui que je veux.

Tout ça pour dire que travailler sur une polyligne complète peut se révéler contre-productif.

On en parle ?

Amicalement

[Kilian336]

Merci de ta réponse, en effet, dans le plan final, je masque énormément d'altitudes (c'est mon calque TopoAltCaché), et je suis d'accord que travailler point par point, permet un contrôle efficace. Cependant, sur des grands plans topos, tourner les altis peut prendre facilement une journée complète, et le contrôle des altis sera fait de toute manière car la sélection des points à afficher / masquer, reste un processus manuel, et l'analyse du MNT et des courbes de niveau me permet aussi d'éviter les erreurs d'altis.

[didier]

Bonjour @Kilian336

Tourner les altis peut prendre facilement une journée complète, FAUX, je fais ça en une heure tout au plus, même un gros fichier.
Si je fais un truc qui traite la totalité de la polyligne, je suis certain que plus de la moitié des points tournés ne seront pas livrés. (donc pourquoi le faire ?)
Et comme il faut faire passer les points non visibles dans un autre calque, il va falloir passer point par point in fine, non ?
C'est bien plus rapide que ce qu'on croit de travailler point par point et que je veux voir livrés.
Le calque que je livre est d'une autre couleur et c'est très visuel.
Je ne cherche pas à prouver une certaine vérité, c'est ma façon de faire et tous mes collègues dans toutes les boites dans lesquelles je suis passé m'ont imité.

Amicalement
 

 

[Kilian336]

Moi ça me prend autant de temps, on ne doit pas avoir le même rendu final. En 1h je peux orienter mes points selon de grand axes, masquer automatiquement ceux qui se chevauchent, mais c'est tout. Je n'ai pas le temps de mettre en avant les points que je souhaiterais, le seuils, les niveaux des regards, des bas / hauts de trottoirs, etc...

Sur un corps de rue de 3000 points, je vois pas comment faire un rendu nickel en 1h !

 

Et sur le fait de passer les points un par un, c'est plus simple de simplement passer un point d'un calque à l'autre, plutôt que de le déplacer, le tourner, puis de le changer de calque. Selon ma façon de travailler, je sais que je gagnerais beaucoup de temps avec ce lisp, sans perdre en qualité.

[didier]

Bonjour @Kilian336

Actuellement j'en suis là.

Mais le sens de construction de la polyligne est important et va poser souci.
Je sélectionne poly par poly, mais si c'est bon, je peux améliorer.

Amicalement

 

 

 

[Kilian336]

Super c'est déjà plus rapide que l'outil Covadis ! Effectivement, le sens de la polyligne influe sur où l'attribut va se positionner, la dessus, je ne pense pas qu'il soit possible de faire quelque chose la dessus, sauf à inverser le sens de la polyligne avant de lancer la commande.

 

Mais sinon ça me paraît bon, penses tu qu'il est possible de faire ce qu'il se passe dans ta vidéo en seulement 1 clic ?

[didier]

Bonjour @Kilian336

Oui, le sens de la polyligne est primordial.
Si je réfléchis, je vais peut-être trouver une soluce, mais tout de suite, ce n'est pas possible.
Pour le choix de multiples polylignes je pense que c'est possible aisément.

Je vais en remettre une couche, mais ma façon de faire point par point est plus efficace, car une fois le point traité c'est bon et je n'y reviens plus jamais.
Le fait de traiter les polylignes va faire la moitié du travail et finalement, il faudra y revenir.

Amicalement

[bonuscad]

Ma proposition!

Cela doit tourner les attributs en fonction de la polyligne, en conservant la lecture suivant le scu courant.

Tu peux sélectionner l'ensemble des blocs TCPOINT, mais comme le traitement peut être un peu long, j'ai mis une barre de progression.

(defun c:test ( / ss dfzz count n progress i ent dxf_ent pt_ins ss_pl ent_pl pt prm a_ref deriv alpha n_ent dxf_next)
  (setq ss (ssget '((0 . "INSERT") (2 . "TCPOINT"))))
  (cond
    (ss
      (if (not dfzz) (setvar "USERR1" 1E-02))
      (initget 4)
      (if (not (setq dfzz (getdist (strcat "\nRayon de recherche? <" (rtos (getvar "USERR1") 2 2) "> : "))))
        (setq dfzz (getvar "USERR1"))
        (setvar "USERR1" dfzz)
      )
      (setq
        count 0
        progress (setq n (sslength ss))
        i 0
      )
      (acet-ui-progress-init "Progression:" progress)
      (repeat n
        (setq
          ent (ssname ss (setq n (1- n)))
          dxf_ent (entget ent)
          pt_ins (cdr (assoc 10 dxf_ent))
          ss_pl (ssget "_C" (trans (mapcar '- pt_ins (list dfzz dfzz 0.0)) 0 1) (trans (mapcar '+ pt_ins (list dfzz dfzz 0.0)) 0 1) '((0 . "LWPOLYLINE")))
        )
        (acet-ui-progress-safe (setq i (1+ i)))
        (cond
          ((and ss_pl (eq (sslength ss_pl) 1))
            (setq
              ent_pl (ssname ss_pl 0)
              pt (vlax-curve-getClosestPointToProjection ent_pl pt_ins '(0 0 1) nil)
              prm (vlax-curve-getParamAtPoint ent_pl pt)
              a_ref (atan (/ (cadr (getvar "ucsxdir")) (car (getvar "ucsxdir"))))
              deriv (vlax-curve-getfirstderiv ent_pl prm)
              alpha (atan (cadr deriv) (car deriv))
              alpha (rem (+ (* 2 pi) alpha) (* 2 pi))
              alpha
              (if (and (> (- alpha a_ref) (* 0.5 pi)) (<= (- alpha a_ref) (* pi 1.5)))
                (+ pi alpha)
                alpha
              )
              n_ent ent
            )
            (while (/= (cdr (assoc 0 (setq dxf_next (entget (entnext n_ent))))) "SEQEND")
              (if (eq (cdr (assoc 2 dxf_next)) "ALT")
                (progn
                  (entmod
                    (subst
                      (cons 50 alpha)
                      (assoc 50 dxf_next)
                      dxf_next
                    )
                  )
                  (setq count (1+ count))
                )
              )
              (setq n_ent (cdar dxf_next))
            )
          )
        )
      )
      (acet-ui-progress)
    )
  )
  (princ (strcat "\n" (itoa count) " Blocs TCPOINT ont leur attribut ALT pivoté sur " (itoa (sslength ss)) "sélectionnés."))
  (prin1)
)

 

[Kilian336]

 

Le 01/10/2024 à 18:47, didier a dit :

Bonjour @Kilian336

Oui, le sens de la polyligne est primordial.
Si je réfléchis, je vais peut-être trouver une soluce, mais tout de suite, ce n'est pas possible.
Pour le choix de multiples polylignes je pense que c'est possible aisément.

Je vais en remettre une couche, mais ma façon de faire point par point est plus efficace, car une fois le point traité c'est bon et je n'y reviens plus jamais.
Le fait de traiter les polylignes va faire la moitié du travail et finalement, il faudra y revenir.

Amicalement

Pas de soucis, merci pour ton aide. Et pour ta méthode, c'est celle aussi que j'ai depuis longtemps, mais je pense qu'elle peut-être amélioré, le lisp en question ne rendra pas le plan tout de suite propre, mais il peut dégrossir pas mal à mon avis, ça vaut le coup d'essayer !

[Kilian336]

Le 02/10/2024 à 17:28, bonuscad a dit :

Ma proposition!

Cela doit tourner les attributs en fonction de la polyligne, en conservant la lecture suivant le scu courant.

Tu peux sélectionner l'ensemble des blocs TCPOINT, mais comme le traitement peut être un peu long, j'ai mis une barre de progression.

(defun c:test ( / ss dfzz count n progress i ent dxf_ent pt_ins ss_pl ent_pl pt prm a_ref deriv alpha n_ent dxf_next)
  (setq ss (ssget '((0 . "INSERT") (2 . "TCPOINT"))))
  (cond
    (ss
      (if (not dfzz) (setvar "USERR1" 1E-02))
      (initget 4)
      (if (not (setq dfzz (getdist (strcat "\nRayon de recherche? <" (rtos (getvar "USERR1") 2 2) "> : "))))
        (setq dfzz (getvar "USERR1"))
        (setvar "USERR1" dfzz)
      )
      (setq
        count 0
        progress (setq n (sslength ss))
        i 0
      )
      (acet-ui-progress-init "Progression:" progress)
      (repeat n
        (setq
          ent (ssname ss (setq n (1- n)))
          dxf_ent (entget ent)
          pt_ins (cdr (assoc 10 dxf_ent))
          ss_pl (ssget "_C" (trans (mapcar '- pt_ins (list dfzz dfzz 0.0)) 0 1) (trans (mapcar '+ pt_ins (list dfzz dfzz 0.0)) 0 1) '((0 . "LWPOLYLINE")))
        )
        (acet-ui-progress-safe (setq i (1+ i)))
        (cond
          ((and ss_pl (eq (sslength ss_pl) 1))
            (setq
              ent_pl (ssname ss_pl 0)
              pt (vlax-curve-getClosestPointToProjection ent_pl pt_ins '(0 0 1) nil)
              prm (vlax-curve-getParamAtPoint ent_pl pt)
              a_ref (atan (/ (cadr (getvar "ucsxdir")) (car (getvar "ucsxdir"))))
              deriv (vlax-curve-getfirstderiv ent_pl prm)
              alpha (atan (cadr deriv) (car deriv))
              alpha (rem (+ (* 2 pi) alpha) (* 2 pi))
              alpha
              (if (and (> (- alpha a_ref) (* 0.5 pi)) (<= (- alpha a_ref) (* pi 1.5)))
                (+ pi alpha)
                alpha
              )
              n_ent ent
            )
            (while (/= (cdr (assoc 0 (setq dxf_next (entget (entnext n_ent))))) "SEQEND")
              (if (eq (cdr (assoc 2 dxf_next)) "ALT")
                (progn
                  (entmod
                    (subst
                      (cons 50 alpha)
                      (assoc 50 dxf_next)
                      dxf_next
                    )
                  )
                  (setq count (1+ count))
                )
              )
              (setq n_ent (cdar dxf_next))
            )
          )
        )
      )
      (acet-ui-progress)
    )
  )
  (princ (strcat "\n" (itoa count) " Blocs TCPOINT ont leur attribut ALT pivoté sur " (itoa (sslength ss)) "sélectionnés.)
  (prin1)
)

 

Merci mais je n'arrive pas à lancer la commande, il m'indique "Commande : ; erreur: structure incorrecte de la chaîne en entrée.

[bonuscad]

@Kilian336

Effectivement il manquait quelques caractères en fin de code, j'ai rectifié le code dans le post concerné, recharge ce code.

Désolé de ce mauvais copié-collé...

[Kilian336]

C'est bon le lisp fonctionne, cependant il ne tourne pas beaucoup d'altitudes, et je ne comprends pas pourquoi. Sur mon plan par exemple, je sélectionne tous mes points topos, je lance la commande, j'indique 3m comme rayon de recherche (c'est bien le rayon de recherche de la polyligne la plus proche ?) et il m'indique que 200 et quelques points ont été traités sur les 2900. En cherchant les points orientés, je remarque qu'ils sont souvent orientés comme un bloc (point 659 par ex alors que le 660 ne s'oriente pas) ou alors il s'agit de points isolés, mais qui ont l'air d'avoir une rotation qui ne correspond pas à une polyligne proche (point 3034 par exemple)

 

J'ai essayé avec des rayons de recherche différent y compris celui par défaut, mais j'obtiens plus ou moins les mêmes résultats, je comprend pas trop.

 

En tout cas merci beaucoup pour ton travail, il y a l'air d'avoir du boulot !

test.dwg

[bonuscad]

Pour info il y a une discussion similaire sur le forum Autodesk et l'utilisateur à soulevé un problème, que je pense avoir résolu.

Je l'adapte à ma proposition faite ici, essaye cette version...

(defun c:test ( / ss dfzz count n progress i ent dxf_ent pt_ins ss_pl tmp j ent_pl pt prm a_ref deriv alpha n_ent dxf_next)
  (setq ss (ssget '((0 . "INSERT") (2 . "TCPOINT"))))
  (cond
    (ss
      (if (zerop (getvar "USERR1")) (setvar "USERR1" 1E-02) (getvar "USERR1"))
      (initget 4)
      (if (not (setq dfzz (getdist (strcat "\nRayon de recherche? <" (rtos (getvar "USERR1") 2 2) "> : "))))
        (setq dfzz (getvar "USERR1"))
        (setvar "USERR1" dfzz)
      )
      (setq
        count 0
        progress (setq n (sslength ss))
        i 0
      )
      (acet-ui-progress-init "Progression:" progress)
      (repeat n
        (setq
          ent (ssname ss (setq n (1- n)))
          dxf_ent (entget ent)
          pt_ins (cdr (assoc 10 dxf_ent))
          ss_pl (ssget "_C" (trans (mapcar '- pt_ins (list dfzz dfzz 0.0)) 0 1) (trans (mapcar '+ pt_ins (list dfzz dfzz 0.0)) 0 1) '((0 . "LWPOLYLINE")))
        )
        (cond
          ((and ss_pl (> (sslength ss_pl) 1))
            (setq tmp (ssadd) l_d nil)
            (repeat (setq j (sslength ss_pl))
              (setq
                ent_pl (ssname ss_pl (setq j (1- j)))
                l_d
                (cons
                  (cons
                    (distance pt_ins (vlax-curve-getClosestPointToProjection ent_pl pt_ins '(0 0 1) nil))
                    ent_pl
                  )
                  l_d
                )
              )
            )
            (ssadd (cdr (assoc (apply 'min (mapcar 'car l_d)) l_d)) tmp)
            (setq ss_pl tmp)
          )
        )
        (acet-ui-progress-safe (setq i (1+ i)))
        (cond
          ((and ss_pl (eq (sslength ss_pl) 1))
            (setq
              ent_pl (ssname ss_pl 0)
              pt (vlax-curve-getClosestPointToProjection ent_pl pt_ins '(0 0 1) nil)
              prm (vlax-curve-getParamAtPoint ent_pl pt)
              a_ref (atan (/ (cadr (getvar "ucsxdir")) (car (getvar "ucsxdir"))))
              deriv (vlax-curve-getfirstderiv ent_pl prm)
              alpha (if deriv (atan (cadr deriv) (car deriv)) 0.0)
              alpha (rem (+ (* 2 pi) alpha) (* 2 pi))
              alpha
              (if (and (> (- alpha a_ref) (* 0.5 pi)) (<= (- alpha a_ref) (* pi 1.5)))
                (+ pi alpha)
                alpha
              )
              n_ent ent
            )
            (while (/= (cdr (assoc 0 (setq dxf_next (entget (entnext n_ent))))) "SEQEND")
              (if (eq (cdr (assoc 2 dxf_next)) "ALT")
                (progn
                  (entmod
                    (subst
                      (cons 50 alpha)
                      (assoc 50 dxf_next)
                      dxf_next
                    )
                  )
                  (setq count (1+ count))
                )
              )
              (setq n_ent (cdar dxf_next))
            )
          )
        )
      )
      (acet-ui-progress)
    )
  )
  (princ (strcat "\n" (itoa count) " Blocs TCPOINT ont leur attribut ALT pivoté sur " (itoa (sslength ss)) " sélectionnés."))
  (prin1)
)