Zoom ou Selection sur Objet avec le Handle

[lecrabe]

 

Hello

 

J'ai un probleme : j'utilise une fonction qui me plante "grave" en m'indiquant le(s) codes de maintien (Handle) des objets qui pose(nt) probleme !

 

SVP pourrais je avoir une routine qui en donnant 1 (ou plusieurs codes séparés par une virgule) code handle / maintien (1-8 caractères en hexadecimal) me permette :

- soit de sélectionner le(s) objet(s)

- soit de zoomer sur l'Etendue du/des objet(s)

 

Merci d'avance de votre aide,

Le Decapode "qui farfouille en Hexa"

 

[lecrabe]

 

ReHello

 

Serait il possible d'avoir dans le meme esprit une routine qui permette de sélectionner / zoomer l'objet qui utilise le PREMIER code handle/maintien disponible et aussi l'objet qui utilise le DERNIER code handle/maintien ?

 

N'oublions pas qu'il peut y avoir des trous (suite à des effacements par exemple) dans la numérotation des handles qui croissent toujours !

 

Et si en plus, on pouvait faire Suivant / Precedent (comme dans PEDIT), ce serait le pied !

pour se déplacer dans les objets graphiques par le code de maintien / handle ...

 

Qq exemples :

ACAD 2006 : 1er objet dessiné, maintien = 39D

ACAD 2008 : 1er objet, maintien = 171

ACAD 2009 : 1er objet, maintien = 1e0

 

Tout depend "un peu" de ce qui est dessiné dans le DWG/DWT de départ !

 

Le Decapode "qui se maintient"

 

 

[bseb67]

Si j'ai bien compris:

tu veux une fonction de ce type

(faire_selection "DE1R,45FE,...") => pour renvoyer une sélection comme ssget mais qu'avec les entités existantes contenues dans la chaine.

 

et une pour le zoom. Pour celle-ci, une fois celle du ssget de faite, c'est simple,

il suffit de faire (command "_zoom" "_o" select) où select est la sélection générée dans la première

fonction.

 

Je veux bien faire un truc, mais le temps de la faire, je que quelqu'un d'autre aura poser une solution. ;)

 

Bon, je m'y mets.

[lecrabe]

 

Hello

 

Oui quand c sélectionné, c assez facile de zoomer dessus !

 

Le Decapode

 

[bseb67]

Voilà mon premier jet:

 

;---------------------------------------;
; nom: faire_selection                  ;
; role: renvoie une sélection d'entités ;
;       définie par une suite de handels;
;       stockés dans chaine avec une ",";
;       comme séparateur                ;
; param: chaine => chaine de caractères ;
;                  contenant une suite  ;
;                  de handels           ;
; retour: une sélection                 ;
;         (qui peut être vide)          ;
;         nil si erreur                 ;
; date: 17/12/2008                      ;
; BLAES Sébastien                       ;
;---------------------------------------;
(defun faire_selection( chaine / res sep ch_tmp pos_sep hand)
 	(setq res nil
      sep ",")

 	(cond
  	; on test si chaine est bien une string
  	((/= (type chaine) 'STR)
	)
	(t
	 	(setq ch_tmp chaine
		      res (ssadd))
	 
	 	(while (/= ch_tmp "")
		  	(cond
			  	; on test pour enlever le séparateur
			  	((= (substr ch_tmp 1 1) sep)
				 	(setq ch_tmp (substr ch_tmp 2))
				)
				; sinon on cherche la position du séparateur
				((= (setq pos_sep (vl-string-search sep ch_tmp)) nil)
				 	; il n'y a plus pas de séparateur, donc il reste le dernier handel
				 	(if (/= (handent ch_tmp) nil)
					  	(setq res (ssadd (handent ch_tmp) res))
					) ; if

				 	(setq ch_tmp "")
				)
				(t
				 	; on extrait le handel
				 	(setq hand (substr ch_tmp 1 pos_sep)
					      ch_tmp (substr ch_tmp (1+ pos_sep)))

				 	(if (/= (handent hand) nil)
					  	(setq res (ssadd (handent hand) res))
					) ; if
				)
			) ; cond
		) ; while
	)
) ; cond

 	res
) ; faire_selection

 

PS: par contre c'est toujours nul que la mise en forme saute avec la tabulations

[Patrick_35]

Bonjour

 

(gile) à fait une routine ZoomObject qu'il suffit de compléter.

Je sens bseb67 bien partit pour cela ;)

 

@+

[bseb67]

ZoomObject de (Gile) prend en argument une liste d'objets vl.

Je vais faire la une variante de ma fonction, mais demain, là j'ai encore un fichier

à traité puis direct à la maison :D

[(gile)]

Salut,

 

Voilà pour la première demande, pour la seconde, ça pourrait faire l'objet d'un "challenge".

 

;; ZH (gile)
;; Sélectionne les objets présents dans l'espace courant d'après leurs "handle"
(defun c:zh (/ space ss obj hlst olst kw i l)
 (vl-load-com)
 (or *acdoc* (setq *acdoc* (vla-get-ActiveDocument (vlax-get-acad-object))))
 (setq space (vla-get-Block (vla-get-ActiveLayout *acdoc*))
       ss    (ssadd)
 )
 (sssetfirst)
 (initget 1)
 (setq hlst (getstring "\nEntrez les handles à sélectionner séparés par des virgules: ")
       hlst (str2lst hlst ",")
 )
 (foreach h hlst
   (if
     (and
       (not (vl-catch-all-error-p
              (setq obj (vl-catch-all-apply
                          'vla-HandleToObject
                          (list *acdoc* h)
                        )
              )
            )
       )
       (equal (vla-ObjectIdToObject *acdoc* (vla-get-OwnerId obj))
              space
       )
     )
      (progn
        (setq olst (cons obj olst))
        (ssadd (vlax-vla-object->ename obj) ss)
      )
   )
 )
 (if ss
   (progn
     (sssetfirst)
     (sssetfirst nil ss)
     (setq i -1
           l (length olst)
     )
     (while
       (or
         (initget "Suivant Précédent Tous")
         (setq kw (getkword "Zoom sur [suivant/Précédent/Tous] <S>: "))
         (setq kw "Suivant")
       )
        (if (= kw "Suivant")
          (setq i (rem (1+ i) l))
          (setq i (if (minusp (1- i))
                    (1- l)
                    (1- i)
                  )
          )
        )
        (if (= kw "Tous")
          (ZoomObject olst)
          (ZoomObject (list (nth i olst)))
        )
     )
   )
 )
 (princ)
)

;; ZoomObject Effectue un zoom sur les objets contenus dans la liste
;;
;; Argument
;; objlst : une liste de vla-object
;;
;; Variables
;; dir : normale du plan de la vue courante
;; ang : angle de la vue courante
;; 3x3 : matrice de transformation du SCG vers la vue courante (dimension 3)
;; 4x4 : matrice de transformation du SCG vers la vue courante (dimension 4)
;; ptlst : liste des points minimum et maximum des bounding-boxes des objets sélectionnés (SCG)
(defun ZoomObject (objlst / dir ang 3x3 4x4 ptlst)
 (vl-load-com)
 (setq dir (trans '(0 0 1) 2 0 T)
       ang (- (getvar "viewtwist"))
       3x3 (mxm (mapcar '(lambda (x) (trans x 0 dir))
                        '((1 0 0) (0 1 0) (0 0 1))
                )
                (list (list (cos ang) (- (sin ang)) 0)
                      (list (sin ang) (cos ang) 0)
                      '(0 0 1)
                )
           )
       4x4 (append
             (mapcar
               '(lambda (v o)
                  (append v (list o))
                )
               3x3
               '(0 0 0)
             )
             (list '(0 0 0 1))
           )
 )
 (foreach obj objlst
   (vla-TransformBy obj (vlax-tmatrix (trp 4x4)))
   (vla-getBoundingBox obj 'minpt 'maxpt)
   (vla-TransformBy obj (vlax-tmatrix 4x4))
   (setq ptlst (cons (vlax-safearray->list minpt)
                     (cons (vlax-safearray->list maxpt) ptlst)
               )
   )
 )
 (vla-ZoomWindow
   (vlax-get-acad-object)
   (vlax-3d-point (mxv 3x3 (apply 'mapcar (cons 'min ptlst))))
   (vlax-3d-point (mxv 3x3 (apply 'mapcar (cons 'max ptlst))))
 )
)

;; str2lst
;; Transforme un chaine avec séparateur en liste de chaines
;;
;; Arguments
;; str : la chaine à transformer en liste
;; sep : le séparateur
(defun str2lst (str sep / pos)
 (if (setq pos (vl-string-search sep str))
   (cons (substr str 1 pos)
         (str2lst (substr str (+ (strlen sep) pos 1)) sep)
   )
   (list str)
 )
)

;; transpose une matrice -Doug Wilson-
(defun trp (m)
 (apply 'mapcar (cons 'list m))
)

;; Applique une matrice de transformation à un vecteur -Vladimir Nesterovsky-
(defun mxv (m v)
 (mapcar '(lambda (r) (apply '+ (mapcar '* r v))) m)
)

;; Multiplie (combine) deux matrices -Vladimir Nesterovsky-
(defun mxm (m q)
 (mapcar '(lambda (r) (mxv (trp q) r)) m)
)

[lecrabe]

 

Hello Gilles

 

Il manque la fonction MXM ! :o

 

Le Decapode

 

[lecrabe]

 

ReHello

 

Ca marche SUPER BIEN Gilles !!! :) :D :cool:

 

Voici les fonctions à ajouter en fin de routine (Voir ci-dessus)

 

 

;; transpose une matrice Doug Wilson

 

(defun trp (m)

(apply 'mapcar (cons 'list m))

)

 

;; Apply a transformation matrix to a vector by Vladimir Nesterovsky

 

(defun mxv (m v)

(mapcar '(lambda ® (apply '+ (mapcar '* r v))) m)

)

 

;; Multiply two matrices by Vladimir Nesterovsky

 

(defun mxm (m q)

(mapcar '(lambda ® (mxv (trp q) r)) m)

)

 

 

Je les ai reprise dans le zoomobject ORGINAL de Gilles :D

 

Le Decapode

 

[(gile)]

lecrabe,

 

merci pour le retour, j'ai ajouté les routines manquantes.

 

bseb67,

 

Désolé de t'avoir doublé, j'ai écris le code pendant que tu postait le tien et je l'ai posté avant d'avoir lu ta réponse.