Comment highliter une entité imbriquée ?

krunch · le 26 septembre 2012

Bonjour à tous

Voilà la question est dans le titre, et c'est pour utiliser avec nentselp.

J'ai essayé vla-highlight au lieu de redraw 3, entupd et redraw sur la référence .. ça ne marche pas.

J'ai trouvé ce post sur le même sujet mais la réponse laisse perplexe .. apparemment il y aurait un moyen ?

(gile) · le 27 septembre 2012

Salut,

À ma connaissance, ce n'est possible directement en LISP. Le seul artefact que j'imagine est de créer une copie de l'entité sélectionnée depuis la définition du bloc, de la mettre en surbrillance et de la transformer (vla-TransformBy) en utilisant la matrice de transformation du bloc pour qu'elle se superpose exactement avec l'entité sélectionnée.

C'est possible (et relativement facile) avec dotNET pour toues les "sous entités" : composants de blocs, segments de polylignes "lourdes" (2d, 3d, maillages) arrêtes et faces des solides 3d...

VDH-Bruno · le 27 septembre 2012

Bonjour,

Effectivement ce n’est pas directement possible en lisp comme vient de le rappeler (gile)

J'ai trouvé ce post sur le même sujet mais la réponse laisse perplexe .. apparemment il y aurait un moyen ?

Dans le post que tu cites, il y en lien de James Allen vers cette autre discution

http://forums.autodesk.com/t5/Visual-LISP-AutoLISP-and-General/Highlight-Nested-Lisp-Net-Interop/m-p/2464441

Dans laquelle il offre à la communauté la possibilité de charger un fichier HighlightNested.zip contenant une dll ainsi que le fichier source cs (C#)

Visiblement cette dll écrite en .NET permet de définir une nouvelle fonction lisp, nenthl qui prendrait en argument la valeur de retour de la fonction lisp native nentsel, exemple :

(nenthl (nentsel))

Cette nouvelle fonction accessible après un chargement préalable de la dll, permettrais de mettre en surbrillance une sous-entité comme celle appartenant à un bloc.

Voilà pour la solution proposée dans le post auquel tu fais référence, je n’ai personnellement pas testé la dll et je ne suis pas compétent pour apprécier la qualité du fichier sources.

Sinon pour ce qui est de définir des extensions de fonction en .NET (ou en ARX, d’ailleurs il me semble avoir lu que vlisp avait été écrit dans ce dernier) cela ce fait, d’ailleurs sur ce forum (gile) nous a déjà proposé une bibliothèque de fonction LISP définies sur le même principe.

http://cadxp.com/index.php?/topic/34242-extension-pour-autolisp/page__p__185472__fromsearch__1#entry185472

Cordialement,

krunch · le 27 septembre 2012

Oui j'ai vu le lien de James Allen vers le dll. Mais comme auparavant il avait l'air de dire que c'était "possible mais compliqué" en Lisp je cherchais une confirmation ..

La solution de substitution de (gile) me semble en effet réalisable (avec CopyObjects je suppose), bien qu'un peu compliquée.

En fait j'ai déjà intégré des .dll de (gile) postés sur ce forum ..

Mais de façon générale je suis un peu réticent à cette solution : n'étant pas du tout compétent (ne sachant pas ce qu'il y a dedans ..), et apparemment il y a parfois des problèmes de compatibilité (?).

Peut être à tort, je ne sais pas, mais s'il y a un moyen de rester en Lisp j'ai tendance à préférer.

Merci pour vos réponses.

(gile) · le 27 septembre 2012

J'ai jeté un coup d’œil au code de James Allen, il ne devrait pas y avoir de problème jusqu'à la version 2012 mais il ne fonctionnera pas avec la 2013 (et les futures).

Je suis entièrement d'accord pour privilégier les solutions entièrement en LISP, mais étant donné que AutoLISP / Visual LISP est plus limité que .NET ou, a fortiori, ObjectARX, il y a des fois où c'est incontournable.

Il y a certes des problèmes de compatibilité avec les versions utilisées, mais elles sont moins fréquentes avec les bibliothèques .NET qu'avec ObjectARX (ceux qui utilisent DosLib savent bien qu'il y a systématiquement une nouvelle version à chaque nouvelle version majeure -tous les 3 ans).

VDH-Bruno · le 27 septembre 2012

Re,

J'ai jeté un coup d’œil au code de James Allen, il ne devrait pas y avoir de problème jusqu'à la version 2012 mais il ne fonctionnera pas avec la 2013 (et les futures).

Merci à (gile) pour son coup d’œil averti, car la fonction a l’air séduisante et confortable d’utilisation, je n’exclut pas d’y recourir un jour :) ,(de plus il y a le source).

La solution de substitution de (gile) me semble en effet réalisable (avec CopyObjects je suppose), bien qu'un peu compliquée.

Je comprends que tu puisse préférer cette voie, comme toi je préfère utiliser ce que je maitrise. Je rappellerai toute fois que c’est une superposition d’entité qui est proposé plus qu’une réelle substitution, pour simuler la substitution il faudrait en plus aller jouer avec le code dxf 60 (visibilité) de la sous entité du bloc , et sans teste préalable je ne saurai dire de tête si ça n’amène pas plus de soucis que cela en résoudraient…

A+

(gile) · le 27 septembre 2012

Je rappellerai toute fois que c’est une superposition d’entité qui est proposé plus qu’une réelle substitution, pour simuler la substitution il faudrait en plus aller jouer avec le code dxf 60 (visibilité) de la sous entité du bloc , et sans teste préalable je ne saurai dire de tête si ça n’amène pas plus de soucis que cela en résoudraient…

J'ai utilisé cette méthode dans AddVtx&DelVtx pour mettre en surbrillance des segments de lwpolyligne (il ne s'agit pas là de sous entité), la superposition marche bien pour les segments droits, moins bien pour les arcs...

Pour ce qui est de jouer avec la visibilité des composants de bloc ça agira sur toutes les références du bloc...

VDH-Bruno · le 27 septembre 2012

Pour ce qui est de jouer avec la visibilité des composants de bloc ça agira sur toutes les références du bloc...

Merci (gile) pour le retour et la confirmation.

A+

krunch · le 27 septembre 2012

Ok merci pour la confirmation

Il y a certes des problèmes de compatibilité avec les versions utilisées, mais elles sont moins fréquentes avec les bibliothèques .NET qu'avec ObjectARX

C'est bien sûr une question de limite du Lisp, mais un ignorant du C# ne sait même pas quelle bibliothèque est utilisée...

Le C# a l'air d'ouvrir beaucoup de possibilités en étant plus près de la source, mais affreusement compliqué par ailleurs .. (et puis vous faîtes en 30 lignes ce qu'on fait en 1 avec le Lisp)

Je rappellerai toute fois que c’est une superposition d’entité qui est proposé plus qu’une réelle substitution, pour simuler la substitution il faudrait en plus aller jouer avec le code dxf 60 (visibilité) de la sous entité du bloc

Je vais donc essayer ça.

A priori la copie de l'entité est placée dessus, et même highlitée elle cache l'originale...

Merci encore

(gile) · le 27 septembre 2012

Oups !...

C'est dans PolySegments.lsp et non dans AddVtx&DelVtx.lsp que j'avais utilisé cette méthode.

krunch · le 27 septembre 2012

Bon j'ai fini par arriver à quelque chose mais ça a été intense..

Pour le moment je vois juste 2 défauts :

- avec les cercles la superposition n'est pas parfaite comme disait (gile) : le highlight est un peu brouillon

- avec les MText des tableaux quand ils sont recadrés (remis à la ligne) par une cellule : le MText sort sur 1 ligne

Il faut aussi bloquer les XRefs (mon post précédent) sinon "Erreur Automation Objet absent de la base de données"

2 trucs remarqués au passage :

- pour comparer des objets ename on peut utiliser eq mais pour des objets vla il faut utiliser equal

- (redraw ename 3) marche mieux que (vla-highlight vla 1) notamment avec les attributs

(defun c:go (/ acdoc out grr cod obj rol dum mat)

   (defun *ERROR* (msg)
       (if rol (High rol nil))
       (print msg)
   )
   
   (defun High (rol on)
       (if on
           (redraw rol 3)
           (if dum
               (progn
                   (vla-delete dum)
                   (setq dum nil)
               )
               (redraw rol 4)
           )
       )
   )
   
   (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object)))

   (while (not out)
       (setq grr (grread t 15 2)
             cod (car grr))
       (cond
           
           ; Enter/Espace/Clic-droit
           ((or (= cod 25) (member grr '((2 13)(2 32))))
            	(*ERROR* "sortie")
               (setq out T)
           )
           
           ; Rollover
           ((= cod 5)
            	(if (setq obj (nentselp (cadr grr)))
                   (setq mat (caddr obj)
                         obj (car obj)))
            	
            	(or (eq obj rol)
                   (progn
                       (if rol (High rol nil))
                       (if obj
                           (if mat
                               (progn
                                   (setq dum (vla-CopyObjects acdoc
                                                              (vlax-make-variant(vlax-safearray-fill(vlax-make-safearray vlax-vbobject '(0 . 0)) (list (vlax-ename->vla-object obj))))
                                                              (vla-get-ModelSpace acdoc))
                                         dum (car (vlax-safearray->list (vlax-variant-value dum))))
                                   (vla-TransformBy dum (vlax-tmatrix mat))
                                   (setq obj (vlax-vla-object->ename dum))
               		)
                   	    )
           		)
                       (setq rol obj)
                       (if rol (High rol T))
                   )
               )
           )            
       )
   )

   (princ)
)

(gile) · le 27 septembre 2012

Bravo !

juste un truc, je pense qu'il est préférable de déclarer la fonction *error* localement.

krunch · le 27 septembre 2012

Je reviens sur ma remarque sur les tableaux : en fait nentselp ne détecte pas le texte normal à l'intérieur des tableaux :(

juste un truc, je pense qu'il est préférable de déclarer la fonction *error* localement.

Je n'ai jamais su s'il fallait déclarer les fonctions locales. Il faut le faire pour toutes ou juste pour *error* ?

(gile) · le 27 septembre 2012

Je n'ai jamais su s'il fallait déclarer les fonctions locales. Il faut le faire pour toutes ou juste pour *error* ?

En LISP, comme dans la plupart des langages fonctionnels, les fonctions sont des "objets de première classe" au même titre que les variables. Il en va donc comme pour les variables en ce qui concerne leur "portée".

Si tu ne déclares pas localement une fonction imbriquée c'est comme si tu définissais cette fonction à l'extérieur de la fonction parent, elle est accessible pour toutes les autres fonctions à partir du moment où la fonction parent est exécutée.

Une petite séquence pour illustrer ça :

(defun foo () (print "foo")) ; la fonction foo est globale

(defun toto () (foo) (princ)) ; toto exécute foo
(toto) ; -> "foo"

(defun tata () (defun foo () (print "tata")) (foo) (princ)) ; tata redéfinit foo sans la déclarer
(tata) ; -> "tata"
(toto) ; -> "tata" foo a été redéfinie globalement

(defun titi (/ foo) (defun foo () (print "titi")) (foo) (princ)) ; titi redéfinit foo en la déclarant
(titi) ; -> "titi" résultat de la définition locale de foo
(tata) ; -> "tata" résultat de la définition globale de foo
(toto) ; -> "tata" résultat de la définition globale de foo

Quand il s'agit d'une fonction globale comme *error* qui définie par AutoCAD pour chaque document, ne pas la déclarer revient donc à la redéfinir globalement pour toutes les fonctions LISP qui seront exécutée ensuite dans la session de ce document.

À mon avis et pour résumer, il faut toujours déclarer localement *error*, et imbriquer et déclarer localement les fonction dont on craint qu'elle puisse entrer en conflit avec d'autres de même nom.

krunch · le 27 septembre 2012

Merci pour ces précisions, je n'avais pas remarqué que les fonctions locales restaient accessibles si non déclarées.

krunch · le 27 septembre 2012

Nouvelle version :

- filtre les objets des Xrefs avec nouveau test (dans ce cas il highlighte la Xref)

- corrige les cercles/arcs baveux : il suffit d'updater la refbloc

- intègre les objets 'old style' que j'avais oubliés

Ne détecte pas le texte normal contenu dans les tableaux ..

; Boucle grread avec highlight des entités survolées
; et substitution de celles imbriquées dans les références de blocs

(defun c:go (/ *ERROR* High acdoc out grr cod obj rol dum mat ctx)

   (defun *ERROR* (msg)
       (if rol (High rol nil))
       (print msg)
   )
   
   (defun High (rol on)
       (if on
           (redraw rol 3)
           (if dum
               (progn
                   (entdel dum)
                   (setq dum nil)
               )
               (redraw rol 4)
           )
       )
   )
   
   (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object)))
   (while (not out)
       (setq grr (grread t 15 2)
             cod (car grr))
       (cond
           
           ; Enter/Espace/Clic-droit
           ((or (= cod 25) (member grr '((2 13)(2 32))))
            	(*ERROR* "sortie")
               (setq out T)
           )
           
           ; Rollover
           ((= cod 5)
            	(setq obj (nentselp (cadr grr))
                     mat (caddr obj)
                     ctx (cadddr obj)
               )
            	
            	(if (and ctx (vl-some '(lambda(u) (< 3 (cdr (assoc 70 (tblsearch "BLOCK" (cdr (assoc 2 (entget u)))))))) ctx))
                   (setq obj (last ctx)
                         ctx nil)
                   (if (and (setq obj (car obj)) (= (cdr (assoc 0 (entget obj))) "VERTEX"))
                       (setq obj (cdr(assoc 330 (entget obj))))
                   )
            	)
            	
            	(or (eq obj rol)
                   (progn
                       (if rol (High rol nil))
                       (if obj
                           (if ctx
                               (progn
                                   (entupd (last ctx))
                                   (setq dum (vla-CopyObjects acdoc
                                                              (vlax-make-variant (vlax-safearray-fill (vlax-make-safearray vlax-vbobject '(0 . 0)) (list (vlax-ename->vla-object obj))))
                                                              (vla-get-ModelSpace acdoc))
                                         dum (car (vlax-safearray->list (vlax-variant-value dum))))
                                   (vla-TransformBy dum (vlax-tmatrix mat))
                                   (setq dum (vlax-vla-object->ename dum))
                                   (setq obj dum)
               		)
                   	    )
           		)
                       (setq rol obj)
                       (if rol (High rol T))
                   )
               )
           )            
       )
   )

   (princ)
)

krunch · le 5 octobre 2012

Je lâche pas l'affaire ..

Il y avait des erreurs avec les ATTRIB imbriquées dans des blocs (on ne peut pas copier un Attrib dans l'espace Objet) et avec les TEXT/MTEXT Annotatifs imbriqués.

Alors j'ai ajouté une fonction pour ces entités, qui refabrique un TEXT/MTEXT à partir d'un ATTRIB ou d'un TEXT/MTEXT.

C'est un peu poussive mais ça marche correctement y compris avec les comportements annotatifs.

Ici les entités imbriquées sont highlitées en rouge ..

; Boucle grread avec Highlight des entités survolées :
; - Highlight des entités de l'espace Objet
; - Highlight après refabrication dans l'espace courant des Attribs/Text/MText imbriqués dans un bloc
; - Highlight après copie dans l'espace courant des autres entités imbriquées dans un bloc ; les entités de XRef renvoient la Référence de bloc

(defun c:go (/ *ERROR* High acdoc out grr cod obj rol dum mat ctx)

   (defun *ERROR* (msg)
       (if rol (High rol nil))
       (print msg)
   )
   
   (defun High (rol on)
       (if on
           (redraw rol 3)
           (if dum
               (progn
                   (entdel dum)
                   (setq dum nil)
               )
               (redraw rol 4)
           )
       )
   )

   ; Refabrique un TEXT/MTEXT dans l'espace Objet à partir d'un ATTRIB ou d'un TEXT/MTEXT
   (defun Make_TextObject (get / att ort mlt new)

       (setq get (entget obj)
             att (= (cdr (assoc 0 get)) "ATTRIB")
             ort (or (Get_MatchOrient obj) (and att (Get_MatchOrient (cdr (assoc 330 (entget (tblobjname "block" (cdr (assoc 2 (entget (cdr (assoc 330 get))))))))))))
             mlt (if att (cdr (member '(101 . "Embedded Object") get))
                     	  (= (cdr (assoc 0 get)) "MTEXT")
                 )
             new (append (if att
                             '(-1 0 100 102 330 360 5 51 2 280 67 74 70)
                             '(-1 0 100 102 330 360 5)
                 	  )
                         (if ort
                             '(210 50 11)
                         )
                 )
             new (append (if mlt
                             '((0 . "MTEXT")(100 . "AcDbEntity")(100 . "AcDbMText"))
                             '((0 . "TEXT")(100 . "AcDbEntity")(100 . "AcDbText"))
                         )
                         (if att
                             (if mlt
                                 (list (cons 8 (cdr (assoc 8 get))))
                                 (append (list (cons 73 (cdr (assoc 74 get))))
                                         (if (and ort (member (cdr (assoc 72 get)) '(3 5)))
                                             (list (cons 11 (mapcar '+ (list (distance (cdr (assoc 10 get)) (cdr (assoc 11 get))) 0 0) (cdr (assoc 10 get)))))
                                         )
                                 )
                             )
                         )
                         (vl-remove-if '(lambda(u) (member (car u) new)) (if (and att mlt) mlt get))
                 )
             
             new (vlax-ename->vla-object (entmakex new))
       )
       
       (and ort
            (not mlt)
            (vla-move new (vla-get-Insertionpoint new) (vla-get-Insertionpoint (vlax-ename->vla-object (cdr (assoc -1 get)))))
       )
       
       new
   )

   
   (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object)))
   (while (not out)
       (setq grr (grread t 15 2)
             cod (car grr))
       (cond
           
           ; Enter/Espace/Clic-droit
           ((or (= cod 25) (member grr '((2 13)(2 32))))
            	(*ERROR* "sortie")
               (setq out T)
           )
           
           ; Rollover
           ((= cod 5)
            	(setq obj (nentselp (cadr grr))
                     mat (caddr obj)
                     ctx (cadddr obj)
               )
            	
            	(if (and ctx (vl-some '(lambda(u) (< 3 (cdr (assoc 70 (tblsearch "BLOCK" (cdr (assoc 2 (entget u)))))))) ctx))
                   (setq obj (last ctx)
                         ctx nil)
                   (if (and (setq obj (car obj)) (= (cdr (assoc 0 (entget obj))) "VERTEX"))
                       (setq obj (cdr (assoc 330 (entget obj))))
                   )
            	)
            	
            	(or (eq obj rol)
                   (progn
                       (if rol (High rol nil))
                       (if obj
                           (if ctx
                               (progn
                                   (entupd (last ctx))

                                   (setq dum (if (member (cdr (assoc 0 (entget obj))) '("ATTRIB" "TEXT" "MTEXT"))
                                                 (Make_TextObject (entget obj))
                                                 (progn
                                                     (setq dum (vla-CopyObjects acdoc
                                                                                (vlax-make-variant (vlax-safearray-fill (vlax-make-safearray vlax-vbobject '(0 . 0)) (list (vlax-ename->vla-object obj))))
                                                                                (vla-get-ModelSpace acdoc)))
                                                     (car (vlax-safearray->list (vlax-variant-value dum)))
                                                 )
                                   ))
                                   
                                   (vlax-put dum 'color 1)                                    
                                   
                                   (vla-TransformBy dum (vlax-tmatrix mat))
                                   
                                   (setq dum (vlax-vla-object->ename dum)
                                         obj dum)
               		)
                   	    )
           		)
                       (setq rol obj)
                       (if rol (High rol T))
                   )
               )
           )            
       )
   )
   (defun Get_MatchOrient (obj)
       (if (= 1 (cdr (assoc 1070 (reverse (cadr (assoc -3 (entget obj '("AcadAnnotative"))))))))
           (assoc -3 (entget obj '("AcadAnnoPO")))
   )
)
   (princ)
)

Connexion

Comment highliter une entité imbriquée ?

Messages recommandés

krunch

(gile)

VDH-Bruno

krunch

(gile)

VDH-Bruno

(gile)

VDH-Bruno

krunch

(gile)

krunch

(gile)

krunch

(gile)

krunch

krunch

krunch

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante