Copier valeurs d\'attributs

[Oli35]

Bonjour à tous !

 

Je suis à la recherche d'une routine qui permettrait de copier la valeur d'un attribut de bloc et de l'affecter à un attribut d'un autre bloc.

 

Je m'explique : covadis crée, dans le cadre de projets VRD, des blocs avec attributs, qui spécifient la cote altimétrique (1 attribut "ALT") et d'autres infos (d'autres attributs). Nous intégrons la valeur de l'altitude dans un bloc "maison"... en saisissant "à la main" les valeurs des altitudes... Lorsque l'on a 150 blocs à renseigner, c'est un peu frustrant... d'autant plus que l'on risque l'erreur de frappe... (CTRL C CTRL V c'est bien mais fatiguant...).

 

D'avance merci...

[Patrick_35]

Un de mes "vieux" lisp

 

@+

 

;;;=================================================================
;;;
;;; CAT.LSP V1.10
;;;
;;; Copier des attributs
;;;
;;; Copyright (C) Patrick_35
;;;
;;;=================================================================

(defun c:cat(/ chemin cmd fichier nom_bloc s)
 
 ;;;---------------------------------------------------------------
 ;;;
 ;;; Gestion des erreurs
 ;;;
 ;;;---------------------------------------------------------------

 (defun *errcat* (msg)
   (if (/= msg "Function cancelled")
     (if (= msg "quit / exit abort")
       (princ)
       (princ (strcat "\nErreur : " msg))
     )
     (princ)
   )
   (setq *error* s)
   (setvar "cmdecho" cmd)
   (princ)
 )

 ;;;---------------------------------------------------------------
 ;;;
 ;;; Routine principale
 ;;;
 ;;;---------------------------------------------------------------

 (defun changer_texte_attributs(/ a b c n p r s ttt u v)

   ;;;-------------------------------------------------------------
   ;;;
   ;;; Changement de texte de l'entité
   ;;;
   ;;;-------------------------------------------------------------

   (setq p (getvar "pickadd"))
   (setvar "pickadd" 0)
   (princ "\nSélectionner le Bloc de Référence.")
   (setq s (ssget))
   (setvar "pickadd" 1)
   (if (/= s nil)
     (progn
       (setq r (entget (ssname s 0)))
       (if (= (cdr (assoc 0 r)) "INSERT")
         (progn
           (if (= (cdr (assoc 66 r)) 1)
             (progn
               (princ "\nSélection des Blocs à Mofifier.")
               (setq s (ssget))
               (setvar "pickadd" p)
               (if (/= s nil)
                 (progn
                   (setq n 0)
                   (setq u 0)
                   (while (/= (ssname s n) nil)
                     (setq a r)
                     (setq v 0)
                     (setq b (entget (ssname s n)))
                     (if (= (cdr (assoc 0 b)) "INSERT")
                       (setq ttt 1)
                     )
                     (if (and (/= (cdr (assoc -1 a)) (cdr (assoc -1 b))) (= (cdr (assoc 2 a)) (cdr (assoc 2 b))))
                       (progn
                         (while (and (/= (cdr (assoc 0 a)) "SEQEND") (/= (cdr (assoc 0 b)) "SEQEND"))
                           (setq c (subst (assoc 1 a) (assoc 1 b) b))
                           (entmod c)
                           (setq a (entget (entnext (cdr (assoc -1 a)))))
                           (setq b (entget (entnext (cdr (assoc -1 b)))))
                           (setq v 1)
                         )
                         (if (/= v 0)
                           (progn
                             (entupd (cdr (assoc -1 (entget (ssname s n)))))
                             (setq u (1+ u))
                           )
                         )
                       )
                     )
                     (setq n (1+ n))
                   )
                   (if (and (= ttt 1) (= u 0))
                     (alert "Pas de blocs correspondant au bloc de référence.")
                   )
                   (if (= ttt nil)
                     (alert "Pas de blocs sélectionnés.")
                   )
                   (if (/= u 0)
                     (princ (strcat "\n" (itoa u) " blocs modifiés..."))
                   )
                 )
               )
             )
             (alert "Bloc sans Attributs")
           )
         )
         (alert "Pas de Bloc Sélectionné...")
       )
     )
     (princ "\nAucune Sélection...")
   )
 )

 ;;;---------------------------------------------------------------
 ;;;
 ;;; Routine de lancement
 ;;;
 ;;;---------------------------------------------------------------

 (setq s *error*)
 (setq *error* *errcat*)
 (setq cmd (getvar "cmdecho"))
 (setvar "cmdecho" 0)
 (command "_.undo" "_group")
 (changer_texte_attributs)
 (command "_.undo" "_end")
 (setq *error* s)
 (setvar "cmdecho" cmd)
 (princ)
)

(setq nom_lisp "CAT")
(if (/= app nil)
 (if (= (strcase (substr app (1+ (- (strlen app) (strlen nom_lisp))) (strlen nom_lisp))) nom_lisp)
   (princ (strcat "..." nom_lisp " chargé."))
   (princ (strcat "\n" nom_lisp ".LSP Chargé.....Tapez " nom_lisp " pour l'éxecuter.")))
 (princ (strcat "\n" nom_lisp ".LSP Chargé......Tapez " nom_lisp " pour l'éxecuter.")))
(setq nom_lisp nil)
(princ)

[didier]

Bonjour Oli35,

Bonjour Patrick_35,

c'est le même département ?

 

La première question que je veux te poser c'est :

Est ce que ton bloc référence et ton bloc qui va réceptionner les attributs

ont le même nombre d'attributs dans leurs définitions ?

 

si oui,

comment choisis t'on l'ordre des attributs qu'on copie ?

c'est à dire le premier va avec le premier, le deuxième avec le deuxième etc..

 

si non,

faut il créer une nouvelle définition d'attribut avec l'étiquette de la copie ?

 

en sachant ça, on pourra te répondre.

 

amicalement

 

[Oli35]

Merci Patrick_35 (mon "35" à moi c'est effectivement l'Ille et Vilaine, pour Patrick je suppose aussi...)

 

Pour répondre à Didier, le bloc créé par covadis a 3 attributs (ALT, MAT, COD). Le bloc de "réception" (COTE_PROJ) n'a qu'un attribut, COTE, qui doit "récupérer" la valeur de ALT. Je pense que le meilleur "mode opératoire" serait que je copie ce bloc aux endroits désirés sur le plan, avec par ex une valeur à 00.00 (pour que je me rende compte des cotes non renseignées), puis que j'affecte les valeurs de ALT, une par une (pour déceler une anomalie éventuelle), à mes valeurs de COTE.

 

Voilà j'espère que c'est assez clair...

 

Je n'ai pas encore essayé la routine de Patrick.

 

En tout cas merci d'avoir répondu si rapidement !

 

A+

 

[Oli35]

re-bonjour !

 

J'ai essayé ta routine, Patrick, mais ça ne fonctionne que lorsque les blocs sont identiques... De plus, une variable a dû être modifiée, car je ne peux plus faire de sélection multiple, à moins d'appuyer sur "MAJ"...

 

Aïe

 

Merci

 

A +

[Patrick_35]

Salut,

Exact, ça ne le fait que pour des blocs identiques. C'était volontaire à l'époque, et le revoici sans ce "blocage"

Pour ta sélection, mets la variable pickadd à 1

 

@+

;;;=================================================================
;;;
;;; CAT.LSP V1.20
;;;
;;; Copier des attributs
;;;
;;; Copyright (C) Patrick DEWEVRE
;;;
;;;=================================================================

(defun c:cat(/ chemin cmd fichier nom_bloc s p)
 
 ;;;---------------------------------------------------------------
 ;;;
 ;;; Gestion des erreurs
 ;;;
 ;;;---------------------------------------------------------------

 (defun *errcat* (msg)
   (if (/= msg "Function cancelled")
     (if (= msg "quit / exit abort")
       (princ)
       (princ (strcat "\nErreur : " msg))
     )
     (princ)
   )
   (setq *error* s)
   (setvar "pickadd" p)
   (setvar "cmdecho" cmd)
   (princ)
 )

 ;;;---------------------------------------------------------------
 ;;;
 ;;; Routine principale
 ;;;
 ;;;---------------------------------------------------------------

 (defun changer_texte_attributs(/ a b c n r s ttt u v)

   ;;;-------------------------------------------------------------
   ;;;
   ;;; Changement de texte de l'entité
   ;;;
   ;;;-------------------------------------------------------------

   (princ "\nSélectionner le Bloc de Référence.")
   (setvar "pickadd" 0)
   (setq s (ssget '((0 . "INSERT"))))
   (setvar "pickadd" 1)
   (if s
     (progn
       (setq r (entget (ssname s 0)))
       (if (= (cdr (assoc 66 r)) 1)
         (progn
           (princ "\nSélection des Blocs à Mofifier.")
           (if (setq s (ssget '((0 . "INSERT"))))
             (progn
               (setq n 0 u 0)
               (while (/= (ssname s n) nil)
                 (setq a r v 0 b (entget (ssname s n)))
                 (if (= (cdr (assoc 0 b)) "INSERT")
                   (setq ttt 1)
                 )
                 (while (and (/= (cdr (assoc 0 a)) "SEQEND") (/= (cdr (assoc 0 b)) "SEQEND"))
                   (setq c (subst (assoc 1 a) (assoc 1 b) b))
                   (entmod c)
                   (setq a (entget (entnext (cdr (assoc -1 a))))
                         b (entget (entnext (cdr (assoc -1 b))))
                         v 1)
                 )
                 (if (/= v 0)
                   (progn
                     (entupd (cdr (assoc -1 (entget (ssname s n)))))
                     (setq u (1+ u))
                   )
                 )
                 (setq n (1+ n))
               )
               (if (and (= ttt 1) (= u 0))
                 (alert "Pas de blocs correspondant au bloc de référence.")
               )
               (if (= ttt nil)
                 (alert "Pas de blocs sélectionnés.")
               )
               (if (/= u 0)
                 (princ (strcat "\n" (itoa u) " blocs modifiés..."))
               )
             )
           )
         )
         (alert "Bloc sans Attributs")
       )
     )
     (princ "\nAucune Sélection...")
   )
 )

 ;;;---------------------------------------------------------------
 ;;;
 ;;; Routine de lancement
 ;;;
 ;;;---------------------------------------------------------------

 (setq s *error*)
 (setq *error* *errcat*)
 (setq cmd (getvar "cmdecho"))
 (setvar "cmdecho" 0)
 (command "_.undo" "_group")
 (setq p (getvar "pickadd"))
 (changer_texte_attributs)
 (setvar "pickadd" p)
 (command "_.undo" "_end")
 (setq *error* s)
 (setvar "cmdecho" cmd)
 (princ)
)

(setq nom_lisp "CAT")
(if (/= app nil)
 (if (= (strcase (substr app (1+ (- (strlen app) (strlen nom_lisp))) (strlen nom_lisp))) nom_lisp)
   (princ (strcat "..." nom_lisp " chargé."))
   (princ (strcat "\n" nom_lisp ".LSP Chargé.....Tapez " nom_lisp " pour l'éxecuter.")))
 (princ (strcat "\n" nom_lisp ".LSP Chargé......Tapez " nom_lisp " pour l'éxecuter.")))
(setq nom_lisp nil)
(princ)

[Oli35]

Salut !

 

Promis dès que je m'achète un micro personnel je me mets au lisp ! désolé Patrick, en fait cette fois c'est OK pour le changement de bloc, sauf que l'attribut sélectionné par défaut n'est pas le bon (il prend "MAT" au lieu de "ALT"...)...

 

Sinon c'était cool ! Merci !

 

P.S. : Attends il me vient une idée : si je crée dans le bloc de destination un deuxième attribut "invisible" qui récupérerait la valeur de "MAT", est-ce que ma valeur "COTE" serait correctement réaffectée ? Je vais essayer en tout cas... à moins que vous n'ayez une idée moins scabreuse...

 

A+

 

[Oli35]

OK, avec mon attribut "caché" ça marche !!!

 

Cool !

 

Merci beaucoup ! (joie, joie)

 

A+

[didier]

Bonjour,

c'est bien ce qu'il me semblait pour le côté breton,

c'est bien ce qu'il me semblait aussi pour le renseignement du bloc,

 

voilà ce que je te propose,

plutôt que piquer la valeur dans un TCPOINT et la copier dans ton bloc perso,

il sera plus simple de bien positionner ton bloc perso en 3D,

pour ce faire il suffit de temporairement mettre les TCPOINTS en 3D,

je pense que tu sais faire,

ensuite tu lances la routine qui suit, et la valeur du point d'insertion en Z,

va devenir la valeur de l'attribut unique du bloc "cote_proj".

je l'ai appelé ainsi, mais tu es libre de le renommer dans mon filtre.

(defun c:cote-proj()

(setq n 0)

(setq zp nil)

(setq jeu (ssget "x"

'((-4 . "

(0 . "INSERT")

(2 . "cote_proj")

(-4 . "AND>")

)

)

)

(setq lon (sslength jeu))

(repeat lon

(setq ent (ssname jeu n))

(setq zp (rtos (caddr (cdr (assoc 10 (entget ent)))) 2 3))

(setq ent2 (entnext ent))

(setq ent3 (entget ent2))

(setq za (cdr (assoc 1 ent3)))

(setq zp1 (cons 1 zp)

za1 (cons 1 za)

)

(setq z3 (subst zp1 za1 ent3))

(entmod z3)

(entupd ent)

(setq n (+ 1 n))

)

(alert (strcat "Nombre de Blocs renseignés : " (itoa n)))

)

)

 

amicalement

 

 

 

 

 

[Oli35]

merci Didier !

 

Mmmh je crois qu'il y a un petit truc qui ne marche pas...

 

J'ai "corrigé" (enfin je crois) la première erreur annoncée (parenthèse)... en revanche, la "synthax error", je ne maîtrise pas...

 

Désolé...

 

A+

[didier]

bonsoir,

 

si tu es plus précis dans tes explications,

je pourrai t'aider,

 

dis moi le nom de ton bloc,

le nombre d'attributs,

enfin tout ce qui est necessaire à la compréhension de ton souci.

 

amicalement

[Patrick_35]

Salut Didier

 

Le souci pour copier des attributs n'est pas la copie en elle-même, mais de savoir quel attribut vais-je copier et à quel endroit. Pour faire au plus simple et passe-partout, le lisp que je propose recopie le premier attribut du bloc de référence vers le premier attribut du bloc de destination, le second avec le second, etc.... Si le premier bloc à plus d’attributs que celui de destination, ça ne prendra en compte que nombre maximal des attributs de destination (et inversement). Maintenant, s’il faut faire une copie du second attribut du bloc de référence vers le premier attribut du bloc de destination, là c’est vraiment du spécifique et Didier a raison de demander un peu plus de précisions.

 

Kenavo

 

@+

[didier]

hello,

 

c'est pour ça que j'ai proposé une solution alternative,

car, son souci est mal expliqué,

il ne veut pas spécialement Copier des valeurs attributaires

en fait il veut renseigner

son nouveau bloc avec un renseignement

qui est en rapport avec l'alltitude de ce même bloc,

le fait de copier les valeurs dans le bloc initaial est complètement facultatif.

 

mais c'est le lot des répondeurs

qui n'ont que les questions

pas toujours précises pour réfléchir.

 

je me fait toujours expliquer plusieurs fois avant de programmer pour mes potes,

et en discutant, on élague et on découvre la vraie demande,

souvent à des lieues de la question initiale.

 

Oli35 va nous renseigner, et il aura une jolie petite routine CadXpienne

amicalement

[Patrick_35]

le fait de copier les valeurs dans le bloc initaial est complètement facultatif

Je ne suis pas du même avis, le bloc initial est celui qui contient les éléments de base, et à la limite, il suffit de remettre dans l'ordre souhaité pour faire la copie

 

@+

 

[Edité le 6/7/2005 par Patrick_35]

[didier]

hello,

je te prie de m'excuser Patrick_35,

je me suis sans doute mal exprimé.

 

Ce que je veux dire, en l'occurence, c'est que

dans l'exemple d'OLI35, il pose un bloc à un endroit précis,

en fait c'est l'altitude d'insertion de ce bloc qu'il veut passer en attribut,

or, il se trouve que cette altitude se trouve dans un bloc voisin,

 

Ce que je lui suggère, c'est d'insérer son bloc en 3D, ensuite,

il suffit de lancer ce que j'ai proposé pour que la valeur Z du point d'insertion

du bloc se retrouve en attribut.

 

Effectivement, si le besoin de copier des valeurs d'attributs est réel,

ta routine fonctionne à merveille,

mon discours est plus un mode opératoire qu'une discussion sur le Lisp.

 

les points dont parle OLI35, DOIVENT être insérés avant,

si ce n'est pas le cas, il faut les insérer et ensuite recopier les attributs :mad:

 

c'est à ce sujet que je disais qu'il était "facultatif" de copier les attributs.

 

mais on disute et OLI35 nous a oublié ou quoi ?

 

 

 

amicalement

 

[Oli35]

Bonjour !

 

Non je ne vous ai pas oubliés, je n'étais pas là...

 

OK je suis d'accord avec toi Didier, mes blocs cote_proj doivent contenir la valeur z du bloc tcpoint situé à proximité... En revanche, je ne désire pas que mes blocs aient le même point d'insertion que le bloc tcpoint (c'est une des raisons pour lesquelles je n'utilise pas les blocs tcpoint). La routine de Patrick fonctionne effectivement très bien, bloc à bloc.

 

Merci à vous deux...

[Patrick_35]

je te prie de m'excuser Patrick_35,

Je t'en prie Didier, pas entre nous, j'ai l'impression d'être le grand méchant loup ;)

je me suis sans doute mal exprimé.

Non, j'ai peut-être moi aussi mal compris. J'ai l'impression à te lire, que c’est plus un sujet métier qu'autre chose, mais Oli35 à l'air d'être satisfait, donc...

 

@+

 

[didier]

coucou

 

t'inqiète pas, tout baigne, ;)

 

effectivement il me semble que c'est "métier"

c'est pas du "généraliste"

 

amicalement