organisation d'un SSGET

[juju_30]

Bonjour,

 

je suis en train de modifier un programme que l'on m'a fourni précédemment, qui permet d'imprimer automatiquement des PDF depuis l'espace objet en sélectionnant une polyligne.

le programme fonctionne bien mais j'aurais aimé organiser ces impressions.

 

je vais essayer d'etre clair:

 

dans ma selection, j'ai bien mes polylignes qui me servent de cadre d'impression avec leur nom d'entité. cependant lorsque "l'impression" se lance, le programme me choisit aléatoirement mes polylignes.

 

j'aurais aimé par exemple que ma selection soit classé en partant d'un X mini et d'un Y maxi à un X mini et un Y mini ("comme si on lisait un livre")

 

si quelqu'un à une base sur laquelle je pourrais travailler, je l'en remercie d'avance.

[juju_30]

petite info en plus:

 

je voulais utiliser, par exemple l'angle superieur gauche de chaque polyligne mais dans ma selection les angles (15-20-25-30) de mes polylignes ne sont jamais au meme endroit.

 

Petite difficulté en plus...

[(gile)]

Salut,

 

Un exemple vite fait qui convertit le jeu de sélection en une liste et trie cette liste par Y décroissant puis, en cas d'égalité des Y par X croissant du premier sommet de chaque polyligne.

 

Je te laisse le soin de l'adapter à ta guise.

 

(if (setq ss (ssget '((0 . "LWPOLYLINE"))))
 (repeat (setq n (sslength ss))
   (setq lst (cons (ssname ss (setq n (1- n))) lst))
 )
)
(setq lst
      (vl-sort
 lst
 (function
   (lambda (pl1 pl2 / pt1 pt2)
     (setq pt1 (cdr (assoc 10 (entget pl1)))
	   pt2 (cdr (assoc 10 (entget pl2)))
     )
     (if (= (cadr pt1) (cadr pt2))
       (< (car pt1) (car pt2))
       (> (cadr pt1) (cadr pt2))
     )
   )
 )
      )
)

[juju_30]

Salut,

 

Un exemple vite fait qui convertit le jeu de sélection en une liste et trie cette liste par Y décroissant puis, en cas d'égalité des Y par X croissant du premier sommet de chaque polyligne.

 

Je te laisse le soin de l'adapter à ta guise.

 

(if (setq ss (ssget '((0 . "LWPOLYLINE"))))
 (repeat (setq n (sslength ss))
   (setq lst (cons (ssname ss (setq n (1- n))) lst))
 )
)
(setq lst
      (vl-sort
 lst
 (function
   (lambda (pl1 pl2 / pt1 pt2)
     (setq pt1 (cdr (assoc 10 (entget pl1)))
	   pt2 (cdr (assoc 10 (entget pl2)))
     )
     (if (= (cadr pt1) (cadr pt2))
       (< (car pt1) (car pt2))
       (> (cadr pt1) (cadr pt2))
     )
   )
 )
      )
)

 

 

Merci je vais voir ce que je peux en faire.

Bonne fin de journée.

[zebulon_]

Bonjour,

 

(defun zoom_ent (e / util obj minpoint maxpoint)
 (setq util (vla-get-utility 
                  (vla-get-activedocument 
                       (vlax-get-acad-object))))                        

 (setq obj (vlax-ename->vla-object e))

 (vla-GetBoundingBox obj 'minpoint 'maxpoint)

 (setq minpoint (trans (vlax-safearray->list minpoint) 0 1))
 (setq maxpoint (trans (vlax-safearray->list maxpoint) 0 1))

 (command "_zoom" "_w" "_non" minpoint "_non" maxpoint)
);defun

 

un bout de code qui permet de faire un zoom sur un objet avec vla-getboundingbox (voir aide de cette fonction). Je pense que c'est préférable que de récupérer juste le premier point de la polyligne, qui n'est pas forcément celui en bas à gauche.

 

J'imagine qu'on peut l'utiliser pour ton cas en récoltant une liste de "minpoint" à partir de la sélection de polylignes. Ensuite, on trie cette liste avec un vl-sort.

 

(setq ptlist '((10 10) (0 0) (20 0) (0 10) (10 0) (20 10) (10 20) (20 20) (0 20)))

(defun PointSort (Dir FunX FunY fuzz pl /)
 (if (= (strcase Dir) "X")
   (vl-sort pl 
     (function
       (lambda (p1 p2)
         (cond
           ((equal (car p1) (car p2) fuzz) ((eval funY) (cadr p1) (cadr p2)))
           (t ((eval funX) (car p1) (car p2)))
         )
       )
     )
   )
   (vl-sort pl 
     (function
       (lambda (p1 p2)
         (cond
           ((equal (cadr p1) (cadr p2) fuzz) ((eval funX) (car p1) (car p2)))
           (t ((eval funY) (cadr p1) (cadr p2)))
         )
       )
     )
   )
 )
)


;; d'abord les x
(print (PointSort "X" '< '< 1e-8 ptlist))  ;; x et y croissants
(print (PointSort "X" '< '> 1e-8 ptlist))  ;; x croissant y décroissant
(print (PointSort "X" '> '< 1e-8 ptlist))  ;; etc...
(print (PointSort "X" '> '> 1e-8 ptlist))

;; d'abord les y
(print (PointSort "Y" '< '< 1e-8 ptlist))
(print (PointSort "Y" '< '> 1e-8 ptlist))
(print (PointSort "Y" '> '< 1e-8 ptlist))
(print (PointSort "Y" '> '> 1e-8 ptlist))  ;; x et y décroissants

(princ)

 

La fonction vl-sort ressemble à ce qu'a écrit (gile), mais je pense qu'il est préférable de rajouter une tolérance quand on compare des coordonnées de points. On a vite fait de trouver que ce n'est pas égal pour un micron de différence. Ensuite, j'ai essayé de faire une fonction un peu plus "tout-terrain"

 

Amicalement

Vincent