Boucle d\'extraction attribut fixe dans bloc imbriqués

[Bred]

... mais. .... ça à l'air de trés bien fonctionner !!!! :D :D :D

je vais le tester plus en profondeur, et essayer de comprendre ta manière de faire, et je te tiens au courant....

 

dans tous les cas, un immense merci !!! :)

[bonuscad]

De rien!

 

Je me suis appuyé sur un code que j'avais donné ici classé sans suite :(

[Bred]

Salut,

J'ai testé la proposition de Bonuscad et elle fonctionne.... mais je n'arrive décidement pas à la modifier pour mon besoin :

Je voudrais avoir la possibilité de faire faire une "sortie" d'attribut fixe d'une selection "simple"

((setq sel (ssget '((0 . "INSERT")))))

et non pas de la totalité du plan....

 

Je bute donc toujours sur mon problème de "boucle"... (comme écrit dans le premier message...)

 

... merci d'avance pour votre aide ...

 

 

[(gile)]

Salut,

 

Je n'ai pas tout suivi, mais tu peux esayer ça.

 

J'ai un peu modifié la routine xplore de Bonuscad qui attaquait la boucle sur la deuxième entité du bloc (setq ent (entnext (cdar l))) pour que la première soit aussi traitée.

 

;;; la routine de Bonuscad modifiée
(defun xplore (ent / l)
 (while ent
   (setq l (entget ent))
   (if	(eq (cdr (assoc 0 l)) "INSERT")
     (xplore
(cdr (assoc -2 (tblsearch "BLOCK" (cdr (assoc 2 l)))))
)
   )
   (if	(eq (cdr (assoc 0 l)) "ATTDEF")
     (print (strcat "Etiquette = "
	     (cdr (assoc 2 l))
	     " ; Valeur = "
	     (cdr (assoc 1 l))
     )
     )
   )
   (setq ent (entnext ent))
 )
)

;;; Pour traiter les blocs d'un jeu de sélection
(if (setq sel (ssget '((0 . "INSERT"))))
 (repeat (setq n (sslength sel))
   (setq bloc (tblsearch
	 "BLOCK"
	 (cdr (assoc 2 (entget (ssname sel (setq n (1- n))))))
       )
   )
   (if	(      (progn
(print (strcat "Bloc : " (cdr (assoc 2 bloc))))
(xplore (cdr (assoc -2 bloc)))
     )
   )
 )
)

[Bred]

Salut (gile) ....

pfff... tu m'écoeures !!!!

c'est ça... tu as fait ce que je cherchais à faire en adaptation de bonuscad....

merci... (à Bonuscad aussi - encore !!!)

j'ai vraiment du mal avec certaines "logique lispienne".... ça va venir ....

 

Par contre, j'abuse : pourrais-tu m'expliquer - si c'est possible - d'après mon premier lisp comment lui faire comptabiliser les blocs imbriqués à "X" niveaux.... je préssent que c'est une boucle, mais je n'arrive pas à la mettre en place....

ce lisp fonctionne pour les blocs "simple", mais pas pour les "imbriqués"....

(je sais que le programmes que tu me proposes modifiés ci-dessus fait la même chose, mais cela me permettrait de comprendre en partant d'un lisp "à mon niveau"...)

 

je le recopie pour simplifier la lecture (les blocs ont chacun 4 attibuts fixes Att1/Att2/Att3 et Att4):

 

 (defun c:aaa ()

(setq list-att-1bloc nil)
(setq list-att nil)

(setq sel (ssget '((0 . "INSERT"))))

(setq index 0)
(repeat (sslength sel)

(setq Nom_ent (ssname sel index))
(setq bloc (tblsearch "BLOCK" (cdr (assoc 2 (entget Nom_ent)))))
(setq Nom_ent (cdr (assoc -2 bloc)))
(setq ent (entget Nom_ent))

(while Nom_ent
(if (/= (cdr (assoc 0 (entget Nom_ent))) "ATTDEF")

(setq Nom_ent (entnext Nom_ent))

(progn ; (setq list-att-1bloc nil)
(setq ent (entget Nom_ent))
(setq list-att-1bloc (append
(list
(list
(cdr (assoc 2 ent))(cdr (assoc 1 ent)))) list-att-1bloc))
(setq Nom_ent (entnext Nom_ent))
)
)
)

(setq list-att (append (list (list (cadr (assoc "Att1" list-att-1bloc))
(cadr (assoc "Att2" list-att-1bloc))
(cadr (assoc "Att3" list-att-1bloc))
(cadr (assoc "Att4" list-att-1bloc)))) list-att))
(setq index (1+ index))
)

;;; liste final tout attributs
(setq list-att (append (list (list "Att1" "Att2" "Att3" "Att4")) list-att))
)

[(gile)]

Pour récupérer les blocs imbriqués quelque soit leur niveau d'imbrication, il faut explorer toutes les entités du bloc et tant que dans ces entités on trouve un bloc explorer les entités de ce bloc et ainsi de suite jusqu'à avoir fait le tour de toutes les entités de tous les blocs.

 

Je ne vois que deux façon de faire :

 

soit avec une liste contenant au départ le ou les blocs à traiter qu'on parcourt tant qu'elle contient des éléments. On traite le premier, s'il contient dans ses entité un (ou des) bloc(s), on le (ou les) rajoute à la fin de la liste et on supprime ce premier élément de la liste, puis on traite le second et ainsi de suite jusqu'à ce que la liste soit vide.

 

soit on se sert d'une routine récursive, comme la routine de Bonuscad xplore. C'est peut-être un peu moins facile à comprendre mais à mon goût beaucoup plus élégant. Une fonction récursive est une fonction qui s'appelle elle même dans sa propre définition, chaque appel à la fonction s'ajoute au précédent provoquant un "empilement" et est évalué ensuite lors du "dépilement".

Fais une recherche dans les forums avec "récurs" j'en ai parlé ailleurs (Bonuscad aussi) et je donne quelque exemples simples avec une fois l'utilisation de la fonction (trace ...) et de la fenêtre de suivi de l'éditeur VisualLISP pour voir l'empilement et le dépilement.

 

Bonne nuit ...

 

un lien vers un message qui contient d'autres liens.

 

ou encoreici,, par exemple, la fonction TRUNC est définie de manière récursive.

 

[Edité le 6/8/2006 par (gile)]

[Bred]

merci (gile), je vais m'y "coller" !....

[Bred]

Pour info, comme il faut que j'écrive tout, et que ça pourrais être utile à d'autre, j'ai mis des commentaires à la routine de bonucad modifié par (gile)

 

 ;;; la routine de Bonuscad modifiée
(defun xplore (ent / l) ; routine d'exploration d'entité et de "sous-entité"
 
 (while ent ; tant que j'ai "ent"
   
   (setq l (entget ent)) ; l = entié de ent
   
   (if (eq (cdr (assoc 0 l)) "INSERT") ; si entité 0 de l = "	insert"
     
     (xplore ; routine explore
(cdr (assoc -2 (tblsearch "BLOCK" (cdr (assoc 2 l))))) ; "explore" sous-bloc dans "l"
)
     )
   
   (if (eq (cdr (assoc 0 l)) "ATTDEF") ; si entité 0 de l = "ATTDEF"
     
     (print (strcat "Etiquette = " (cdr (assoc 2 l)) ; écrire Etiquette = entité 2 de l
	     " ; Valeur = " (cdr (assoc 1 l)))) ; écrire Valeur = entité 1 de l
     )
   (setq ent (entnext ent)) ; ent = prochaine entité dans "ent"
   )
)


;;; Pour traiter les blocs d'un jeu de sélection
(defun c:dec ()
 
 (if (setq sel (ssget '((0 . "INSERT")))) ; selection de blocs
   
   (repeat (setq n (sslength sel)) ; répéter nombre d'élément dans sel (=n)
     
     (setq bloc (tblsearch "BLOCK" (cdr (assoc 2 (entget (ssname sel (setq n (1- n))))))))
     ; "bloc" = chercher "BLOCK" dans entité du (1- n) élément de sel
     
     (if (< (cdr (assoc 70 bloc)) 4) ; si entité 70 de bloc < 4 (bloc n'est PAS une Xref)

(progn
  (print (strcat "Bloc : " (cdr (assoc 2 bloc)))) ; écrire "bloc : nom de bloc	  
  (xplore (cdr (assoc -2 bloc))) ; puis "xplore" sous blocs dans bloc
	  );fin de progn
) ; fin de if
     ) ; fin de repeat
   ) ; fin de if
 )
 ) 

 

[Edité le 6/8/2006 par Bred]

[(gile)]

Si ça t'intéresse, Un petit topo sur la récursivité ici.

[Bred]

... tu rigoles j'epères (gile) !!! il est déjà copié et archivé pour étude, ton "petit topo sur la récursivité" ....

je ne t'ai pas remercié dans ton post pour ne pas le poluer avec des choses "inutiles", donc je te remercie ici de tes explications.... et si j'ai des problèmes et questions je t'en ferait part dans ce post...

(d'ailleurs ton post est tellement bien et utile, qu'il pourrait être la première pierre d'un nouveau sous-forum lisp : "cours et astuces de programation lisp" .... je te laisse le proposer à Patrick si tu penses que c'est utile ...)

merci encore

[(gile)]

Je viens de voir une très jolie routine de Tim Willey, en vlisp, avec une sous-routine de forme récursive ici.

[quent1]

Bonjour,

Je me permets de relancer ce sujet car j’ai essayé d’utiliser et de modifier le Lisp de Bonusad modifié par Giles.

 

Je ne suis un débutant, mais j’ai commencé à le modifier pour qu’il réponde à ce que je veux en faire

Ce programme de base ne faisait que lister l’ensemble des objets présent dans le dessin en fouillant bien toutes les couches. Pour ma part, j’ai besoin de compter un ensemble de blocs présent à plusieurs niveaux dans des blocs. La modification que j’y ai apporté fonctionne bien et permet de stocker le nombre total de ces blocs dans une variable « compteur ».

Mais… mon problème est que certain des blocs que je veux compter sont intégrés dans des blocs dynamiques qui possèdent un paramètre de visibilité. En ne spécifiant rien, le programme compte les blocs présent dans les blocs dynamique, mais même ceux qui ne sont pas affichés à l’écran… j’ai donc essayé des variantes, en jouant avec le code 60 qui est celui de la visibilité, sans grand succès… Tous ce que j’ai réussi à faire c’est compter tous les blocs cachés mais pas ceux à l’écran (exactement l’inverse de ce que je veux faire !) avec une condition sur le code 60 = 1, ce que j’ai trouvé assez normal, mais en mettant la condition sur 60=0 pour compter les blocs visibles, le programme ne me compte pas les blocs qui sont affichés…

 

J'ai mis le programme en pièce jointe

 

Je ne sais pas si j’ai été très clair ? Auriez-vous des pistes pour m’aider ?

 

Merci d’avance

 

Quent1

Extraction de blocs imbriqués f.LSP