Export d\'attributs excel

[chris_mtp]

Bonjour à tous,

 

Voici un bout de code que j'ai modifié pour faire un export de blocs d'Autocad vers Excel.

 

(defun c:extattributs (/ i nom_fic fic file jeu d nom entit nature long nom_plan coor1 val va1 val2)

(princ "\nEXPORTATION D'ATTRIBUTS")

(setq nom_fic (getstring "\nNom du fichier de sortie : "))
(setq fic (getfiled "Veuillez indiquer le répertoire de destination" nom_fic "xls" 1))
(setq file (open fic "w")) 
(write-line (strcat "X" "\t" "Y" "\t" "Z" "\t" "Bloc" "\t" "Calque") file)
(princ "\nChoisissez les attributs à exporter")
(setq jeu (ssget))
(if jeu 
        (extratt2)
        (progn
        (princ "\nPas de sélection défini - ABONDON")
        (close file)
        )
)
(princ)
)


(defun extratt2()
(setq d 0)
(setq long (sslength jeu))
(while (< d long)
(setq nom (ssname jeu d))
(setq entit (entget nom))
(setq nature (cdr (assoc 0 entit)))
(if (= nature "INSERT")(extat2))
       (setq d (+ d 1))
);fin while

(close file)

(princ (strcat "\n" (itoa long) " objets exportés"))
)


(defun extat2()

(setq nom_plan (cdr (assoc 8 entit)))
(setq nom_bloc (cdr (assoc 2 entit)))
(setq coor1 (cdr (assoc 10 entit)))
(setq val (car coor1))
(setq val1 (cadr coor1))
(setq val2 (caddr coor1))


(write-line (strcat (rtos val 2 5) "\t" (rtos val1 2 5) "\t" (rtos val2 2 5) "\t" nom_bloc "\t" nom_plan) file)
) 

 

Maintenant en fait, je souhaiterais non plus exporter seulement les coordonnées du point d'insertion du bloc avec le nom du bloc et du calque d'appartenace mais aussi la valeur des attributs correspondants.

 

Exemple, si je sélectionne un bloc avec n attributs, je devrais avoir avoir dans mon fichier excel de sortie n colonnes avec comme entête l'étiquette de l'attribut et pour chaque bloc la valeur de l'attribut correspondant.

 

J'ai essayé d'utiliser la fonction eattext mais les paramètrages sont longs à effectuer.

D'autre part, j'utilise la fonction OpenExcel de Gile qui vient de cette discussion,

http://www.cadxp.com/XForum+print-fid-115-tid-23199.html?POSTNUKESID=798cb7ba4c063fc5224ab83c867540d8

pratique pour une manipulation rapide des entités.

 

J'ai essayé de plus de prendre exemple sur des lisps existants comme MAT ou IXL mais en vain.

Merci par avance de votre aide.

 

John.[Edité le 19/7/2009 par chris_mtp][Edité le 19/7/2009 par chris_mtp][Edité le 19/7/2009 par chris_mtp][Edité le 19/7/2009 par chris_mtp]

 

[Edité le 19/7/2009 par chris_mtp]

[(gile)]

Salut,

 

Plusieurs remarques.

 

Tout d'abord, eut égard à ceux qui vont lire ton code pour essayer de t'aider, tu pourrais un peu en soigner la présentation.

Il me semble bien t'avoir déjà parlé de l'éditeur Visual LISP et du formatage du code (retraits qui rendent le code plus facile à lire).

 

Ensuite, je te conseillerais de commencer par finaliser ta routine avant de vouloir lui ajouter des fonctionnalités.

En l'état, elle est curieusement structurée et pas très fiable.

- CMDECHO ne concerne que que les commandes natives (donc les appels à la fonction command) est inutile ici.

- Tu ouvres un fichier dans la routine principale (open) et tu le refermes dans une sous routine qui n'est appelée que si l'utilisateur sélectionne des blocs.

- L'utilisation de OpenExcel me semble inutile. De plus Excel n'est pas refermé (CloseExcel).

[chris_mtp]

Bonjour Gile,

 

Je ne me sers que très rarement de l'editeur Visual Lisp car je ne sais pas très bien m'en servir.

J'ai fait ce code comme j'ai pu et j'ai encore beaucoup de choses à apprendre en lisp mais il marche pour mes beoins donc je ne suis pas trop attardé sur la mise en forme mais c'est vrai que pour le mettre en ligne, j'aurais du faire les quelques modifs que tu m'as signalé avant.

 

Désolé donc pour la mise en forme mais j'y ai remédier.

 

En ce qui concerne ma question, je ne sais pas comment comptabiliser le nombre d'attributs d'un bloc sélectionné puis en extraire les valeurs.

 

Si vous avez des idées ou des exemples, merci par avance.

John.

[(gile)]

Je ne me sers que très rarement de l'editeur Visual Lisp car je ne sais pas très bien m'en servir.

À mon avis, tu grandement tort.

D'abord, c'est en l'utilisant que tu apprendras à t'en servir.

L'utilisation de l'éditeur t'aidera non seulement à écrire et déboguer tes programmes plus facilement, mais aussi à mieux comprendre comment fonctionne le LISP.

 

Il ne s'agit pas d'utiliser toutes les fonctions dès le début, mais déjà, en plus des fonctions commune à tous les éditeurs de texte (Ctrl+N, Ctrl+O, Ctrl+S, etc.), tu peux tester et utiliser :

- la sélection par double clic pour vérifier l'appariement des parenthèses, pour évaluer des expressions et des variables (Ctr+Maj+E), pour accéder directement à l'aide des fonctions (Ctrl+F1).

- la console pour évaluer/tester des expressions

- les fonctions de formatage (Ctrl+Maj+F et Ctrl+Alt+F)

- le chargement de la fenêtre active dans AutoCAD (Ctrl+Alt+E)

 

J'ai fait ce code comme j'ai pu et j'ai encore beaucoup de choses à apprendre en lisp mais il marche pour mes beoins

Je répète qu'il est impératif de fermer (close) un fichier ouvert (open) et ce quelque soit ce qui a pu se passer entre les deux.

[chris_mtp]

Merci Gile pour ces explications mais en ce qui concerne ma question sur la détermination du nombre d'attribut d'un bloc sélectionné,

 

 

[(gile)]

1) Tu insères un bloc avec attributs dans AutoCAD

2) Tu ouvres l'éditeur Visual LISP (VLIDE)

3) Dans la console, tu entres (setq bloc (car (entsel))) et tu valides. Ça devrait te faire basculer automatiquement dans la fenêtre AutoCAD.

4) Tu sélectionnes le bloc avec attributs. Ça devrait te faire re-basculer automatiquement dans l'éditeur où le nom d'entité du bloc est affiché dans la console (c'est le résultat de l'évaluation de l'expression).

5) Dans la console toujours, tu entres : (setq att (entnext bloc)) et tu valides. Le nom d'entité de l'entité (ou sous entité) suivant bloc d'affiche.

6) Tu sélectionnes entnext en double cliquant dessus et tu fais Ctrl+F1. L'aide s'ouvre à la page de la fonction entnext où tu peux voir comment elle fonctionne.

7) Tu entres (entget att), tu valides et tu peux lire la liste DXF du premier attribut.

8) Tu entres (setq att (entnext att)), tu valides et devrait obtenir le nom d'entité de l'entité suivante.

9) Tu entres (entget att), tu valides et tu peux lire la liste dxf de cette entité.

10) Tu répètes l'opération jusqu'à ce que entget retourne un objet SEQEND (0 . "SEQEND") qui marque la fin des sous-entités (attributs).

 

Ceci devrait te permettre de comprendre comment faire une boucle while en testant avec entget et en "incrémentant" avec entnext pour rechercher tous les attributs d'une référence de bloc.

[chris_mtp]

Tu laches rien toi hein avec ton Editeur Lisp mais tu as raison.

Je vais m'y mettre

 

Je reviens vers toi si j'ai des soucis.

Merci.

John

[(gile)]

Tu laches rien toi hein avec ton Editeur Lisp mais tu as raison.

 

Ce ne pas tant pour l'éditeur Visual LISP, mais plutôt pour que tu acquières les moyens de bien comprendre ce qui se passe pendant l'exécution d'une expression ou d'une routine.

 

Je t'ai parfois donné des bouts de code tout fait que tu as plus ou moins heureusement réussi à assembler, mais à voir la manière dont tu t'y prends on peut lire que qu'il te manque certaines bases fondamentales.

 

L'éditeur ne fera pas tout, il faut aussi arriver à se mettre à la place d'une machine (un ordinateur) qui agit de manière très bêtement logique, et envisager tous les cas possibles.

Par exemple, pour ce que tu veux faire là, il faut envisager la cas où l'utilisateur sélections 3 blocs différents : un bloc sans attributs et deux autres dont les attributs sont différents (en nombre et par leurs étiquettes). Comment vas tu gérer les extractions ?

 

C'est en se posant toutes ces questions qu'on peut comprendre que si la commande EXTATTBE demande tant de paramètres c'est parce que sans ces données et critères il ne peut y avoir de traitement "machine".

[chris_mtp]

Bonjour

 

Voici ce que j'ai pu faire;

Certes ce n'est pas un code parfait mais bon ca marche dans les 3 cas que tu m'as conseillé gile

(defun c:extatt
      (/ i file jeu d nom entit nature long coor1 val va1 val2 ent liste att)
 (setq file (open "C:/export_att.txt" "w"))
 (write-line (strcat "Numéro" " " "X" " " "Y" " " "Z") file)
 (princ "\nChoisissez les attributs à exporter")
 (setq jeu (ssget '((0 . "INSERT"))))
 (if jeu
   (progn
     (setq i 1)
     (setq d 0)
     (setq long (sslength jeu))
     (while (< d long)
       (setq nom (ssname jeu d))
       (setq entit (entget nom))
       (setq coor1 (cdr (assoc 10 entit)))
       (setq val (car coor1))
       (setq val1 (cadr coor1))
       (setq val2 (caddr coor1))
       (setq ent nom)
       (if (= (cdr (assoc 0 (entget ent))) "INSERT")
         (if (= (cdr (assoc 66 (entget ent))) 1)
           (progn
             (setq liste nil)
             (while
               (if ent
                 (not (= (cdr (assoc 0 (entget ent))) "SEQEND"))
               )
                (if (= (cdr (assoc 0 (entget ent))) "ATTRIB")
                  (setq
                    liste (append liste (list (cdr (assoc 1 (entget ent)))))
                  )
                )
                (setq ent (entnext ent))
             )
           )
           (setq liste nil)
         )
       )
       (if (= liste nil)
         (write-line (strcat (rtos i 2 0)
                             " "
                             (rtos val 2 4)
                             " "
                             (rtos val1 2 4)
                             " "
                             (rtos val2 2 4)
                     )
                     file
         )
         (progn
           (setq att (lst2strg liste " "))
           (write-line (strcat (rtos i 2 0)
                               " "
                               (rtos val 2 4)
                               " "
                               (rtos val1 2 4)
                               " "
                               (rtos val2 2 4)
                               " "
                               att
                       )
                       file
           )
         )
       )
       (setq i (+ i 1))
       (setq d (+ d 1))
     )
     (close file)
   )
   (progn
     (princ "\nPas de sélection défini")
     (close file)
   )
 )
 (prin1)
)

(defun lst2strg (lst sep)
 (if (cadr lst)
   (strcat (vl-princ-to-string (car lst))
           sep
           (lst2str (cdr lst) sep)
   )
   (vl-princ-to-string (car lst))
 )
)

 

John[Edité le 25/7/2009 par chris_mtp]

[(gile)]

C'est bien, mais...

 

- J'ai du reformaté ton code pour le rendre plus lisible (c'est la dernière fois...)

 

- Tu ne devrais ouvrir le fichier qu'après être sûr d'avoir à y écrire (après les interventions de l'utilisateur) : si au moment de la sélection l'utilisateur fait Echap la routine s'arrête et le fichier n'est pas refermé.

 

- En LISP une tabulation c'est : "\t"

 

- En l'état, "ta" fonction "lst2strg" ne peut fonctionner que si la fonction originale "lsp2str" est chargée.

Je pense qu'il n'est pas très futé de renommer/modifier des fonctions écrites par d'autres si on n'en a pas parfaitement compris le fonctionnement. Je pense aussi qu'il est préférable de laisser les en-têtes (quand il y en a) à la fois par correction pour l'auteur et parce que ce sont parfois les seuls commentaires sur l'usage de la routine.

[chris_mtp]

Pour le reformatage c'est vrai que je ne n'y fais pas gaffe mais ce n'était pas la peine de le modifier.

D'autre part, pour la fonction lst2str j'ai du passer du temps à la comprendre et c'est pour cela que je l'ai modifié et changé de nom pour l'adapter à mes besoins.

 

Mais j'ai pu m'en sortir quand même.

John.