de liste a selection set

le 12 octobre 2007

comment je peux passer les element de cette liste a un set de selection ?? pour affectuer une commande "_union" sur tous ses elements??

!ff_lst

 (  )

merci ;-)

[Edité le 12/10/2007 par ingoenius]

Matt666 · le 12 octobre 2007

Houlà c'est pas clair !!!

Euh la liste est composée de quoi ?

Si elle est composée d'enames (noms d'entités) :

il faut créer un nouveau jeu de sélection, et le remplir avec un foreach

(setq sset (ssadd)) 
(foreach pt (length lst)
(ssadd pt sset)
)

ou alors un mapcar

(setq sset (ssadd))
(mapcar '(lambda (x) (ssadd x sset)) lst)

A bientot.

matt.

[Edité le 12/10/2007 par Matt666]

le 12 octobre 2007

genial merci ici 3 routines que j'ai pu faire grace avos aides

ar cree des region a partir de trait arc etc qui ce entrecoupent

rp transforme une region en polyligne

++ addition des objet poliyigne fermees comme on peut faire avec _union sur les regions

 
;Creato da Ingoenius Oct 2007
; ---------AUTOREGION ou AUTOPOLYLIGNE-------------------------------------------------------------

;automatizza il comando _boundary per creare una poliligne
;si chiama utoregion ma é settato per creare una polilinea
;se si vuole creare un region bisogna mettere R al posto di P  nella linea di codice 

(defun c:ar ()				
(setq OBJ (ssgetfirst ))		;qui vede se qualcosa é selezionato 
(setq OB1 (cadr OBJ))			;estrai la selezione  
(if (= OB1 nil)				;se nulla é selezionato
 (alert  "\nSelectionner les Objects " )
)
(command "_boundary"  "O" "C" "N" OB1 ""  "O" "P" "" pause "" "");;qui se é P crea una polilinea se é R crea una regione 
(setq REG (entlast))
(command "_change" REG "" "pr"  "_co" "bylayer" "" )
(command "_erase" OB1 "" "")  
)



(defun c:rp ()				;trasforma una regione in polilinea
(setq OBJ (ssgetfirst ))		;qui vede se qualcosa é selezionato 
(setq OB1 (cadr OBJ))			;estrai la selezione  
(if (= OB1 nil)				;se nulla é selezionato
 (alert  "\nSelectionner les Objects " )
)

(command "_boundary"  "O" "C" "N" OB1 ""  "O" "P" "" pause "" "");;qui se é P crea una polilinea se é R crea una regione 
(setq REG (entlast))
(command "_change" REG "" "pr"  "_co" "bylayer" "" )  
(command "_erase" OB1 "" "")
)




(defun c:++ ()				;convertire in region e aaggiungere gli oggetti come union boleana
(setq OBJ (ssgetfirst ))		;qui vede se qualcosa é selezionato
(setq OB1 (cadr OBJ))			;estrai la selezione  tutti gli oggetti 
(setq ff_lst (list nil)) 
;(command "_region" OBJ "")
(if (= OB1 nil)				;se nulla é selezionato
(alert  "\nSelectionner les Objects " )
)

(setq n 0 )
(repeat (sslength OB1)
      (setq ent (ssname OB1 n))
 	(command "_region" ent "")
(setq CRE (list(entlast)))
 	(setq n (+ 1 n))
 	(setq ff_lst(append  ff_lst CRE ))
)
(setq ff_lst (cdr ff_lst))	;lista finale

(setq sset (ssadd))
(mapcar '(lambda (x) (ssadd x sset)) ff_lst)

(command "_union" sset "")
(setq REG (entlast))

(command "_boundary"  "O" "C" "N" REG ""  "O" "P" "" pause "" "");;qui se é P crea una polilinea se é R crea una regione 
(setq REG1 (entlast))
(command "_change" REG1 "" "pr"  "_co" "bylayer" "" )  
(command "_erase" REG "" "")

)

Matt666 · le 12 octobre 2007

Ah oui ok c'est pas mal !!

Petites corrections pour tes 2premiers lisp, si ça ne te dérange pas...

(defun C:AR (/ sel )
    (setq cmdecho (getvar "cmdecho"))
    (setvar "cmdecho" 0)
    (if (setq sel (ssget))
         (progn
              (princ "\nSpécifier le point de contour : ")
              (command 
                   "_UNDO" "D"
                   "_BOUNDARY" "O" "C" "N" sel "" "O" "P" "" pause ""
                   "_CHANGE" (entlast) "" "PR" "_co" "bylayer" ""
                   "_ERASE" sel ""
              )
              (princ "\nContour créé.")
         )
         (princ "\nAucune sélection.")
    )
    (command "_UNDO" "F")
    (setvar "cmdecho" cmdecho)
    (princ)
)

(defun C:RG2CT (/ ent)
    (setq cmdecho (getvar "cmdecho"))
    (setvar "cmdecho" 0)
    (if (ssget "i")
         (if (eq (sslength (ssget "i")) 1) (setq ent (ssname (ssget "i") 0)))
         (setq ent (car (entsel "\nSélectionner la région à convertir : ")))
    )
    (cond
         ((and     ent
                       (eq "REGION" (cdr (assoc 0 (entget ent))))
              )
              (princ "\nSpécifier le point de contour : ")
              (command 
                   "_UNDO" "D"
                   "_BOUNDARY" "O" "C" "N" ent "" "O" "P" "" pause ""
                   "_CHANGE" (entlast) "" "PR" "_co" "bylayer" ""
                   "_ERASE" ent ""
              )
              (redraw)
              (princ "\nConversion effectuée.")
         )
    )
    (command "_UNDO" "F")
    (setvar "cmdecho" cmdecho)
    (princ)
)

Ton 2ème lisp ne peut comporter qu'une seule entité dans la sélection...Il faut aussi vérifier que c'est bien une région.

Pour le 3ème, je n'ai pas trop le temps de regarder, mais je verrai ça bientot !

A bientot, et bravo pour tes lisps :)

EDIT : Suite à la demande de ingoenius, les entités sélectionnées au début sont intégrés à la routine.

[Edité le 15/10/2007 par Matt666]

le 14 octobre 2007

merci , ca me derange pas de tout ;-) au contraire , si ca vous semble que ces lisp soyent utiles ,pour tous le monde tant mieux

seule chose, j'ai teste tes correction, et je remarque que ce fonctionne seulement dans le sense command et ensuite selection , (dans mes lisp meme s'ils sont moins precis et concis) je voulait que dans le cas une selection d'objet est active alors le lisp utilise celle ci c'est possible avec ta version?

merci pour le corrections ;-)

[Edité le 15/10/2007 par ingoenius]

Matt666 · le 15 octobre 2007

Ta dernière routine s'avère assez complexe... Le fait de joindre deux polylignes qui se touchent et de supprimer le tronc commun est assez ardu ! Surtout lorsqu'on sélectionne plusieurs polyilgnes.. Mais ça devrait se faire...

A beitnto !

Matt.

Matt666 · le 15 octobre 2007

Bon bah voilà, c'est fait !! Dis moi ce que tu en penses, moi je l'aime bien cette petite routine !!

Elle utilise le pline2points de gile, pour pouvoir assurer la sélection d'objets dans une polyligne avec des arcs...

Cette routine permet de fusionner deux polylignes fermées qui se touchent... Elle est assez pratique !

Biing !

(defun c:UNPL (/ lst lst2 cmdecho sel cn elts js sset sset2 entl )
    (setq cmdecho (getvar "cmdecho"))
    (setvar "cmdecho" 0)
    (if (setq sel (ssget '((0 . "LWPOLYLINE"))))
         (progn
              (command "_UNDO" "D")
              (repeat (setq cn (sslength sel))
                   (setq lst (cons (ssname sel (setq cn (1- cn))) lst))
              )
              (while (< 1 (length lst))
                   (setq ELTS (cons (car lst) 0))
                   (foreach pt lst
                        (if (and  (setq JS (ssget "cp" (pline2points pt) '((0 . "LWPOLYLINE"))))
                                  (> (sslength (ssdel pt JS)) (cdr ELTS))
                             )
                             (setq ELTS (cons pt (sslength JS)))
                        )
                   )
                   (if (> (cdr ELTS) 0)
                        (progn
                             (setq sset (ssadd))
                             (repeat (setq cn (sslength (setq JS (ssget "cp" (pline2points (car ELTS)) '((0 . "LWPOLYLINE"))))))
                                  (if (member (ssname JS (setq cn (1- cn))) lst)
                                       (ssadd (ssname JS CN) sset)
                                  )
                             )
                             (setq sset2 (ssadd) entl (entlast))
                             (command "_region" sset "")
                             (while (setq entl (entnext entl))
                                  (ssadd entl sset2)
                             )
                             (command "_union" sset2 "")
                             (setq ENT (entlast))
                             (command "_.explode" ent)
                             (setq ss (ssget "_p") lst2 nil)
                             (repeat (setq cn (sslength ss))
                                  (setq lst2 (cons (ssname ss (setq cn (1- cn))) lst2))
                             )
                             (if (vl-every '(lambda (x) (member (cdr (assoc 0 (entget x))) '("LINE" "ARC"))) lst2)
                                  (command "_.pedit" (ssname ss 0) "_yes" "_join" ss "" "")
                             )
                             ;(command "_erase" sset2 "")
                             (redraw)
                             (repeat (setq cn (sslength sset))
                                  (setq lst (vl-remove (ssname sset (setq cn (1- cn))) lst))
                             )
                        )
                        (setq lst (vl-remove pt lst))
                   )
              )
              (command "_UNDO" "F")
              (princ "\nFusion réussie.")
    ))
    (setvar "cmdecho" cmdecho)
    (princ)
)

;; Pline2Points by Mister GILE en personne !!!
;; Retourne une liste de points (coordonnées SCU courant) situés sur une polyligne
;; Les polyarcs sont divisés en fonction de leur courbure.
(defun Pline2Points (pline / bulge2arc elst elv norm dlst blst prec ang n
    plst)
    
    ;; bulge2arcdata
    ;; Retourne la liste des données d'un "polyarc"
    ;; (centre, rayon, angle de départ, angle total)
    (defun bulge2arcdata (bulg start end / ang cen rad)
         (setq ang (* 2 (atan bulg)))
         (setq rad (/ (distance start end) (* 2 (sin ang)))
              cen (polar start
                   (+ (angle start end)
                        (- (/ pi 2) ang)
                   )
                   rad
              )
         )
         (list cen rad (angle cen start) (* ang 2))
    )
    
    (setq elst (entget pline)
         elv (cdr (assoc 38 elst))
         norm (cdr (assoc 210 elst))
         dlst (vl-remove-if-not '(lambda (x) (or (= (car x) 10) (= (car x) 42))) elst)
    )
    (if (= 1 (logand 1 (cdr (assoc 70 elst))))
         (setq dlst (append dlst (list (assoc 10 elst))))
    )
    (while (caddr dlst)
         (setq plst (cons (cdar dlst) plst))
         (if (/= 0.0 (cdadr dlst))
              (progn
                   (setq blst (bulge2arcdata (cdadr dlst) (cdar dlst) (cdaddr dlst))
                        prec (1+ (fix (* 25 (sqrt (abs (cdadr dlst))))))
                        ang (/ (cadddr blst) prec)
                        n 0
                   )
                   (repeat (1- prec)
                        (setq plst 
                             (cons 
                                  (polar (car blst)
                                       (if (minusp (cdadr dlst))
                                            (+ pi (caddr blst) (* ang (setq n (1+ n))))
                                            (+ (caddr blst) (* ang (setq n (1+ n))))
                                       )
                                       (cadr blst)
                                  )
                                  plst
                             )
                        )
                   )
              )
         )
         (setq dlst (cddr dlst))
    )
    (mapcar '(lambda (x)
              (trans (list (car x) (cadr x) elv) norm 1)
         )
         (reverse (cons (cdar dlst) plst))
    )
)

UNPL = union polyligne...

A bientot.

Matt.

EDIT : Suite aux lisps de GILE, changement du programme.

[Edité le 17/10/2007 par Matt666]

le 16 octobre 2007

merci pour les aide, mais......

j'ai pas compris pourquoi ta troisieme routine elle est aussi longue?

car la mienne "++ " est deja fonctionelle?

en fait moi je triche un peu ,

car je transforme d'abord les polylignes selectionnee en regions,

en suite je fait un addittion booleenne de ces region

et pour finir je retransforme en polyligne

pourquoi c'est pas correct d'agir de cette facon? ;-)

Matt666 · le 16 octobre 2007

car la mienne "++ " est deja fonctionelle?

Essaie de sélectionner plusieurs polylignes, et qui ne se touchent pas forcément... Tu verras que ta routine s'arrête aux premières polylignes qui se touchent.

car je transforme d'abord les polylignes selectionnee en regions,

Ma routine ne fonctionne pas tout à fait de la même façon...

1- Jeu de sélection de polylignes exclusivement

2- Utilise pline2points de Gile pour rechercher toutes les polylignes qui se touchent. S'il n'en trouve, il arrête la commande.

3- Transforme en région, unie et repasse en polyligne les entités qui passent cette étape.

Voilà !

pourquoi c'est pas correct d'agir de cette facon?

Parce que s'il ne trouve pas de polylignes qui se touchent, ils les changent quand même en région...

Et ça c'est dommage.

En plus il prend des polylignes par deux uniquement. Dans ma routine si 4 polylignes se touchent, il prend la polyligne qui a le plus de polyligne qui la touchent et unie celles-ci..

Voilà !

A+...

le 17 octobre 2007

OK j'ai compris merci pour les explications,

j'avais l'idee mais pas assez de connaissance de code,

maintenat il faut que l' on ajoute une autre fonction (beaucoup plus difficile)

immagine d'avoir ta poliligne ferme devant toi,

tu dessines une ligne ou poliligne ouverte qui la traverse de part a part,

et tu te retrouves avec 2 polilignes fermees (comme si ta ligne ou polyligne ouverte etait un couteaut)

une espece de Kut 2d sur les poliyignes ou regions fermes

si t'interesse de relever le defi.........;-)

Bonne journée et

merci ancore pour les aides

le 17 octobre 2007

Vu que c'est utile J'ai rajoute une autre fonction (a ma facon)

PS je nomme mes lisp avec peut de caracteres ex ++ -- ar , seulement parce que je les integre sistematiquement en autoload , de cette facon je peut a tout moment lancer rapidement ces commandes

la fonction "--"

demande de selectionner l'objet 1

ensuite demande un selection de 1 ou plusiurs object, et il effectue une substraction de

Obj 1 - Objs 2 = polyligne

(defun c:-- ()				;convertire in region e aaggiungere gli oggetti come union boleana

(setq OB_1  (entsel "Selection Objet 1: "));object 1
;(print  "\nPremier contour cree " )
 
(command "_region"  OB_1 "");trasforma in regione
(setq OB_A1 (entlast));qui nomina

(setq OB_2  (ssget));selections autres objetcs
(setq ff_lst (list nil)) ;creo lista vuota 

(setq n 0 )
(repeat (sslength OB_2)
       (setq ent (ssname OB_2 n))
 	(command "_region" ent "")
(setq CRE (list(entlast)))
 	(setq n (+ 1 n))
 	(setq ff_lst(append  ff_lst CRE ))
)
 
(setq ff_lst (cdr ff_lst))	;lista finale  
(setq sset (ssadd));crea il set di selezione prendendo gli elementi della lista 
(mapcar '(lambda (x) (ssadd x sset)) ff_lst)

(command "_union" sset "")
(setq OB_A2 (entlast));questa é l'oggetto 2
 
(command "_subtract"   OB_A1 "" OB_A2  ""  )
(setq OB_3 (entlast));questa é l'oggetto 3 finale

(command "_boundary"  "O" "C" "N" OB_3 ""  "O" "P" "" pause "" "");;qui se é P crea una polilinea se é R crea una regione 
(setq REG1 (entlast))
(command "_change" REG1 "" "pr"  "_co" "bylayer" "" )  
(command "_erase" OB_3 "" "")
 
;(print  "\nOperation reussie polyligne crée " )
)

(gile) · le 17 octobre 2007

Salut,

Je n'ai pas lu en détail tous les messages, mais pour transformer des régions en polylignes, j'avais fait R2PL et pour fusionner des polylignes Fusion.

Vous pouvez peut-être vous en inspirer.

[Edité le 17/10/2007 par (gile)]

Matt666 · le 17 octobre 2007

Raaah c'est une bonne idée de décomposer la région pour la transformer en pline !! Je change les routines !!

Merci Gile...

Matt666 · le 19 octobre 2007

Salut !

ingoenius, voici un exemple de ce qu'on peut faire pour ta petite routine "Kut 2d" avec deux points, qui symboliseraient une lame de couteau...

;;; Divise une polyligne en deux, suivant les points saisis.
(defun c:POLK ( / cmdecho entl pt1 pt2 sel)
    (setq cmdecho (getvar "cmdecho"))
    (setvar "cmdecho" 0)
    (setq entl (entlast))
    (cond
         ((and  
                   (setq pt1 (getpoint "\nPremier point sur la polyligne à diviser : "))
                   (setq pt2 (getpoint pt1 "\nDeuxième point sur la polyligne à diviser : "))
                   (eq (ssname (setq sel (ssget pt1)) 0) (ssname (ssget pt2) 0))
                   (eq (cdr (assoc 0 (entget (ssname sel 0)))) "LWPOLYLINE")
              )
              (command "_UNDO" "d")
              (command "_break" pt1 pt1 "_break" pt2 pt2)
              (command "pedit" (ssname sel 0) "f" "")
              (if (/= entl (entlast))
                   (command "pedit" (entlast) "f" "")
              )
              (command "_undo" "F")
         )
    )
    (setvar "cmdecho" cmdecho)
    (princ)
)

A bientot.

Matt.

le 19 octobre 2007

merci matt ,

je vais etudier ton code pour apporter mes petites modif

Connexion

de liste a selection set

Messages recommandés

Invité ingoenius

Matt666

Invité ingoenius

Matt666

Invité ingoenius

Matt666

Matt666

Invité ingoenius

Matt666

Invité ingoenius

Invité ingoenius

(gile)

Matt666

Matt666

Invité ingoenius

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante