Sélection et suppression d\'entité (+copiage)

[cyrkan]

Bonjour bonjour!

 

Pour mon rpojet je compte sélectionner les entité dans un calque et les déplacer!

 

J'ai donc débuter mon code comme suit:

====

 

(defun c:test ()

(setq liste (ssget "X" (list (cons 8 "*test*"))))

(setq nombre (sslength liste))

)

 

====

 

Il y a donc le ssget + X pour tout sélèctionner; je filtre en ne gardant que les calques ayant test dans leur noms.

 

Et ensuite je demande le nombre de calque sélèctionner pour savoir si j'ai réussit a sélectionner le bon nombre de calque!

 

En gros jusque la tout marche! mais aprés je butte sur les commande approprié! je ne trouve pas le code qui me permettrait de déplacer les entité et non juste déplacé des liste ou juste supprimé des liste (j'avait penser a copier supprimé).

 

Je vous remercie pour l'éventuel aide qui pourra mettre donné!

 

EDIT: Euh ... Je me suis surement trompé de parti de forum; un admin pourrait déplacer le sujet ^^ (dans la parti débutant).

J'ai regardé aussi, il y a apparement un sujet qui traite du déplacement de bloc (moi je cherche a déplacer l'intégralité), mais bon j'avous que j'ai pas tout capté (j'ai commencé à chercher une corde et un tabouret avant la fin!!! <acronym class=dict title=)

 

[Edité le 14/4/2008 par cyrkan]

[bseb67]

Salut!

 

Si tu veux déplacer du même vecteur tes objets, tu peux faire ainsi

(defun c:test ()
 (cond
         ((= (setq liste (ssget "X" (list (cons 8 "*test*")))) nil)
                    (alert "Pas d'entités")
         )
         (t
            (setq nombre (sslength liste))
            (command "deplacer" liste "" '(0.0 0.0 0.0) (list dep_x dep_y dep_z))
         )
)

 

Il te faut juste donner les valeurs à dep_x dep_y et dep_z

[cyrkan]

En faite non je ne veux pas "déplacer" dans un sens "x" ou "y" mais les garder au même endroit mais dans un calques que j'aurais choisit.

 

Par exemple j'ai une polyligne dans un calques A Je veut juste qu'elle soit dans un calques B; Mais avec les même propriété qu'elle vait dans le calques A (longueur; couleur; type de ligne)

[bseb67]

Re,

 

Ok, par contre pour la couleur, cela dépend de ton mode de couleur, si tes entités son en couleur

ducalque, il faut que les calques soient de la même couleur.

 

Pour changer de calque, c'est très simple, soit on passe par les données DXF, soit

la commande chprop:

 

(defun testDXF( ancien_calque nouveau_calque / liste e le)
(cond
  	((or (= ancien_calque nil)
	     (/= (type ancien_calque) 'STR))
	 	(alert (strcat "Le paramètre ancien_calque n'est pas bon!"))
	)
	((= (setq liste (ssget "X" (list (cons 8 (strcat "*" ancien_calque "*"))))) nil)
		(alert "Pas d'entités")
	)
	((or (= nouveau_calque nil)
	     (/= (type nouveau_calque) 'STR))
	 	(alert (strcat "Le paramètre nouveau_calque n'est pas bon!"))
	)
	((= (tblsearch "LAYER" nouveau_calque) nil)
	 	(alert (strcat "Le calque " nouveau_calque " n'existe pas!"))
	)
	
	(t
	 	(print (strcat "Il y a " (itoa (setq nombre (sslength liste))) " entités à changer de calque"))
	 
	 	; on boucle tant qu'il y a quelque chose dans liste
	 	(while (/= (setq e (ssname liste 0)) nil)
		  	; on récupère les données DXF
			(setq le (entget e))
		  	; on modifie le calque
		  	(setq le (subst (cons 8 nouveau_calque) (assoc 8 le) le))
		  	; on met à jour
		  	(entmod le)
		  	
		  	; on supprime e de liste
		  	(ssdel e liste)
		) ; while
		
		
	)
) ; cond
) ; testDXF

(defun testCHP( ancien_calque nouveau_calque / liste e le)
(cond
  	((or (= ancien_calque nil)
	     (/= (type ancien_calque) 'STR))
	 	(alert (strcat "Le paramètre ancien_calque n'est pas bon!"))
	)
	((= (setq liste (ssget "X" (list (cons 8 (strcat "*" ancien_calque "*"))))) nil)
		(alert "Pas d'entités")
	)
	((or (= nouveau_calque nil)
	     (/= (type nouveau_calque) 'STR))
	 	(alert (strcat "Le paramètre nouveau_calque n'est pas bon!"))
	)
	((= (tblsearch "LAYER" nouveau_calque) nil)
	 	(alert (strcat "Le calque " nouveau_calque " n'existe pas!"))
	)
	
	(t
	 	(print (strcat "Il y a " (itoa (setq nombre (sslength liste))) " entités à changer de calque"))
	 
	 	; on boucle tant qu'il y a quelque chose dans liste
	 	(while (/= (setq e (ssname liste 0)) nil)
		  	(command "chprop" e "" "calque" nouveau_calque "")
		  	
		  	; on supprime e de liste
		  	(ssdel e liste)
		) ; while
		
		
	)
) ; cond
) ; testCHP

 

J'avais oublié le test des paramètres.

 

[Edité le 15/4/2008 par bseb67]

[cyrkan]

Pfiouuuu! je met 5 ligne de code tu m'en met 50!!! <acronym class=dict title=

 

Je ne peut pas tester tout ca pour le moment!!!!

 

Mais en tout cas je te remerci! et je te tient au courant!

[bseb67]

Re,

 

Tout d'abord il y a deux versions, ensuite tu peux enlever les tests des paramètres,

mais en programmation il faut toujours vérifier que les arguments passés sont ceux attendus.

Sinon gare aux plantages.

 

Mais c'est vrai que lorsque j'ai commencé, je ne faisait pas les tests, au fur et à mesure on se perfectionne mais on devient plus pointilleux ;)

[cyrkan]

RE! En effet il y a deux solutions! (ce n'était pas un reproche le coup des 50 lignes <acronym class=dict title=! :D )

 

Je pense que je vais prendre la seconde qui ce raproche le plus de ce que l'on a appris en cours! et que je pense comprendre plus facilement!

D'ailleur pour ce qui est de comprendre, je ne compte pas pompé ce que tu ma donner sans essayé de comprendre ^^ :cool:

 

Donc j'ai quelque question à te posé!

Question qui vont te paraitre extrèmement bête... mais c'est la vie :P

 

1ere chose que je n'est pas compris:

En cour je suis resté sur du:

(defun c: nomduprog ()

pourquoi ici on passe direct sur du : (defun nomduprog (annonce des variables) bref sans le c: ...

 

2ième chose que je n'est pas compris!

je n'est pas compris la structure de code suivante:

(/= (type ancien_calque) 'STR))

j'avous que le (/=(****) str) m'est complètement inconnu! (surtout le: (/= )

 

Voila je te remerci de me laisser abuser de ta patience!

[(gile)]

Salut,

 

1) la fonction defun, pour DEfine FUNction, permet de définir des fonctions AutoLISP.

Elle requiert au moins 3 arguments :

 

(defun symbole ([arguments...] [/ variables...]) expressions...)

 

- symbole = nom de ma fonction.

Si le nom commence par c: la fonction pourra être appelée par son nom sans le c: directement à la ligne de commande (ou depuis une macro) comme n'importe quelle autre commande prédéfinie. Dans ce cas la fonction n'a pas d'arguments. On parle de commande définie en LISP.

Si le nom de la fonction ne commence pas par c:, on ne peut appeler la fonction qu'au sein d'une expression LISP commençant par une parenthèse. La fonction ainsi définie peut requérir des arguments et est utilisable comme n'importe quelle autre fonction AutoLISP (à ceci près que les arguments requis ne sont jamais optionnels). On parle alors de routine ou sous-routine.

 

- ([arguments...] [/ variables...]) : une liste contenant (ou non) les arguments requis par la fonction et/ou (ou non) les variables locales. Cette liste doit être présente même si elle est vide.

 

- expressions : la (ou les) expression(s) AutoLISP qui determine(nt) l'action de la fonction.

 

Par exemple, la fonction tan, définie ci-dessous, retourne la tangente d'un angle tout comme les fonctions prédéfinies sin et cos retournent le sinus et le cosinus. L'argument requis pour ces trois fonctions est un angle exprimé en radians. Si elle est chargée, la fonction tan s'utilise exactement comme une fonction autoLISP prédéfinie.

 

(defun tan (a) (/ (sin a) (cos a)))

 

 

2) (/= (type ancien_calque) 'STR))

 

La fonction LISP /= (différent de) évalue si les expressions qui lui sont passés comme argument ne sont pas égales. Ces arguments doivent être des nombres ou des chaines de caractères (les symboles "quotée" comme 'STR sont considérés comme des chaînes).

 

Dans ce cas, il est évalué si l'évaluation de l'expression (type ancien_calque) est égale à STR, autrement dit si la variable ancien-calque contient bien une chaîne de caractère.

 

N'hésite pas à consulter l'aide aide Aux développeurs >> AutoLISP Refecence >> AutoLISP Function pour apprendre de nouvelle fonctions, ou si tu as du mal en Anglais, tu peux voir ici

[bseb67]

Salut cyrkan,

 

Je vois que (Gile) a répondu à tes questions, et je n'aurai pas donné autant de détails.

Comme je ne travaille pas le vendredi après-midi, je répond très rarement avant le lundi matin suivant.

 

Si t'a besoin d'aide n'hésite pas à demander, je me suis inscrit sur cadxp l'an dernier afin d'avoir de l'aide dont (Gile) m'a fournit une bonne partie. Et si je peux, aide de mon mieux les autres.

[bonuscad]

Un code qu'on pourrait envisager si l'on aime utiliser les grips.

 

Celui ci lit les codes dxf en dynamique (lorsque vous déplacez le curseur sur une entité)

Cela est affiché dans la barre d'état (là où habituellement se trouve les coordonnées)

Dès que les codes semblent convenir, vous verrouilliez d'un click-droit, il est alors proposé en ligne de commande (manière SSX, pour ceux qui connaissent), de simplifier le filtrage en supprimant les codes principaux proposés.

Les grips sont alors activés, vous voyez bien la sélection, par la palette de propriété, on fait les affectations que l'on désire.

 

(defun data2string (l_dxf / l_dxf lst_pair grp_el typ_el ch1 ch2 ch)
(setq ch "")
(while l_dxf
	(setq lst_pair (car l_dxf))
	(setq grp_el (car lst_pair) typ_el (cdr lst_pair))
	(cond
		((eq (type grp_el) 'INT)
			(setq ch1 (itoa grp_el))
		)
		((eq (type grp_el) 'REAL)
			(setq ch1 (rtos grp_el 2 4))
		)
		((eq (type grp_el) 'STR)
			(setq ch1 (strcat "\"" grp_el "\""))
		)
		(T
			(setq ch1 "")
		)
	)
	(cond
		((eq (type typ_el) 'INT)
			(setq ch2 (itoa typ_el))
		)
		((eq (type typ_el) 'REAL)
			(setq ch2 (rtos typ_el 2 4))
		)
		((eq (type typ_el) 'STR)
			(setq ch2 (strcat "\"" typ_el "\""))
		)
		((eq (type typ_el) 'LIST)
			(setq ch2 (strcat (rtos (car typ_el) 2 4) " " (rtos (cadr typ_el) 2 4) (if (caddr typ_el) (strcat " " (rtos (caddr typ_el) 2 4)) "")))
		)
		(T
			(setq ch2 "")
		)
	)
	(if (eq (type typ_el) 'LIST)
		(setq ch (strcat ch "(" ch1 " " ch2 ") "))
		(setq ch (strcat ch "(" ch1 " . " ch2 ") "))
	)
	(setq l_dxf (cdr l_dxf) ch1 "" ch2 "")
)
(strcat "(" ch ")")
)
(defun c:dyn_filter ( / sv_shmnu oldim key pt_sel l_dxfcod m_filt ent dxf_ent typ_ent msg ss)
(setq
	sv_shmnu (getvar "SHORTCUTMENU")
	oldim (getvar "dimzin")
)
(setvar "dimzin" 0)
(setvar "SHORTCUTMENU" 11)
(while (and (setq key (grread T 4 0)) (not (member key '((2 13) (2 32)))) (/= (car key) 25))
	(setq
		l_dxfcod nil m_filt nil
		pt_sel (osnap (list (caadr key) (cadadr key)) "_near")
	)
	(if pt_sel
		(progn
			(setq ss (ssget "_C" pt_sel pt_sel))
			(if ss (setq ent (ssname ss 0)))
		)
		(setq ent (car (nentselp (list (caadr key) (cadadr key)))))
	)
	(cond
		(ent
			(setq dxf_ent (entget ent))
			(setq l_dxfcod (append '(38 39 48 370 62 6 8 67 0) l_dxfcod))
			(if (member (cdr (assoc 0 dxf_ent)) '("HATCH" "INSERT" "MLINE" "SHAPE"))
				(if (assoc 2 dxf_ent) (setq l_dxfcod (cons 2 l_dxfcod)))
			)
			(foreach n l_dxfcod (if (assoc n dxf_ent) (setq m_filt (cons (assoc n dxf_ent) m_filt))))
			(grtext -2 (data2string m_filt))
		)
		(T (grtext -2 ""))
	)
)
(setq typ_ent (cdr (assoc 0 dxf_ent)) m_filt nil)
(cond
	((eq typ_ent "LWPOLYLINE")
		(setq l_dxfcod (cons 43 l_dxfcod))
	)
	((or (eq typ_ent "POLYLINE") (eq typ_ent "MLINE"))
		(setq l_dxfcod (cons 70 l_dxfcod))
	)
	((or (eq typ_ent "DIMENSION") (eq typ_ent "LEADER"))
		(setq l_dxfcod (cons 3 l_dxfcod))
		(setq l_dxfcod (cons 70 l_dxfcod))
	)
	((or (eq typ_ent "ARC") (eq typ_ent "CIRCLE") (eq typ_ent "ELLIPSE"))
		(setq l_dxfcod (cons 40 l_dxfcod))
	)
	((or (eq typ_ent "TEXT") (eq typ_ent "MTEXT") (eq typ_ent "ATTDEF"))
		(setq l_dxfcod (cons 7 l_dxfcod))
		(setq l_dxfcod (cons 40 l_dxfcod))
	)
)
(foreach n l_dxfcod (if (assoc n dxf_ent) (setq m_filt (cons (assoc n dxf_ent) m_filt))))
(princ (strcat "\n(ssget \"" "_X" "\" " (data2string m_filt) ")"))
(setq msg "")
(initget (foreach n m_filt (setq msg (strcat (itoa (car n)) " " msg))))
(setq msg "")
(setq msg (strcat "\nCode DXF a supprimer? [" (foreach n m_filt (setq msg (strcat (itoa (car n)) "/" msg))) "]"))
(while (setq what (getkword msg))
	(setq m_filt (vl-remove (assoc (atoi what) m_filt) m_filt))
	(princ (strcat "\n(ssget \"" "_X" "\"" (data2string m_filt) ")"))
	(setq msg "")
	(initget (foreach n m_filt (setq msg (strcat (itoa (car n)) " " msg))))
	(setq msg "")
	(setq msg (strcat "\nCode DXF a supprimer? [" (foreach n m_filt (setq msg (strcat (itoa (car n)) "/" msg))) "]"))
)
(if (zerop (getvar "PICKFIRST")) (setvar "PICKFIRST" 1))
(sssetfirst nil nil)
(setq ss (ssget "_X" m_filt))
(sssetfirst nil ss)
(setvar "SHORTCUTMENU" sv_shmnu)
(setvar "dimzin" oldim) 
(prin1)
)

[cyrkan]

euh, je ne vais encore passer pour un boulet.... (c'est la vie!)

 

J'ai voulut tester sur un exemple ton procédé! j'ai donc créer deux calques (ancien_calque et un autre nouveau_calque). J'ai mis dans le calques ancien_calque une ligne, une polyligne et un cercle.

 

Puis j'ai copier coller ton code celui sur la methode du chprop...

 

Et enfin j'ai lancé directement de la ligne de commande,bon ca na pas voulut ce lancé; j'ai donc rajouté le c: c'est a dire: (defun c: testCHP (....)...

Ca na pas marcher non plus! je ne comprend pas.

 

Précision la il ma mis que le nombre d'argument était insuffisant.

(les parenthèses son ok)

 

HELP ;)

 

Merci d'avance pour les précisions!

[Patrick_35]

Salut

 

Un exemple

 

(setq js (ssget))
(command "_.chprop" js "" "_layer" "Nouveau_Calque" "")

 

@+

[(gile)]

Salut,

 

Relis bien la réponse 7, TestCHP est une fonction définie en LISP (sous-routine) qui requiert deux arguments. c:TestCHP ne peut donc pas fonctionner.

 

Il faut soit entrer à la ligne de commande l'expression LISP (avec les noms des calques):

(TestCHP "ancien_calque" "nouveau_calque")

soit intégrer la routine dans une définition de commande qui l'appellera:

 

(defun c:test (/ ancien nouveau)
 (if (and
(setq ancien (getstring "\nNom de l'ancien calque: "))
(setq nouveau (getstring "\nNom du nouveau calque: "))
     )
   (TestCHP ancien nouveau)
 )
 (princ)
) 

[cyrkan]

OK!

 

Cette fois ci c'est la bonne j'ai compris!!!!!!

 

(setq ancien (getstring "\nNom de l'ancien calque: "))

(setq nouveau (getstring "\nNom du nouveau calque: "))

 

ces deux ligne servent à rentrer les deux futurs paramètres utilisé comme variable par la suite!

 

(TestCHP ancien nouveau)

 

lance donc la routine créer au préalable! avec les deux paramètres rentré plus tot!

 

Par contre ici on a comme paramètre ancien et nouveau et non plus ceux énoncé das le code d'avant! ( (defun testCHP( ancien_calque nouveau_calque / liste e le) )

 

Est ce que ancien et nouveau prenne le pas et remplace encien_calque et nouveau_calque?

 

Mais sinon j'ai bien compris le principe cette fois ci!

 

Encore merci!

[(gile)]

ancien, nouveau, ancien_calque, nouveau_calque, mais aussi TestCHP ou getstring sont des données AutoLISP appelées symboles (succession de caractères alphanumériques qui ne sont pas entre guillemets).

À ces symboles peuvent être attribués des fonctions (TestCHP, getstring) ou des valeurs, on parle alors de variables (ancien, nouveau) ou encore, au sein d'une fonction, ils symbolisent les valeurs qui leurs seront attribuées lors de l'exécution de la fonction, on parle alors d'arguments ou paramètres (ancien_calque, nouveau_calque).

 

(setq ancien (getstring "\nNom de l'ancien calque: "))
(setq nouveau (getstring "\nNom du nouveau calque: "))

 

Ces deux expressions permettent d'attribuer aux variables ancien et nouveau des valeurs spécifiées par l'utilisateur (disons "tata" et "toto")

 

(TestCHP ancien nouveau)

Quand cette expression est évaluée, tous les symboles qu'elle contient sont évalués, ce qui revient à dire : évaluer la fonction TestCHP avec "tata" et "toto". Donc ces valeurs remplaceront respectivement ancien_calque et nouveau_calque dans toutes les expressions qui composent la définition de la fonction TestCHP.

[cyrkan]

Merci pour tout!

 

Explication clair et limpide! <acronym class=dict title=