ssget et réseau

[zebulon_]

Bonjour,

 

comment peut-on filtrer les entités de type RESEAU avec ssget ?

 

Dans les faits, ces entités sont des blocs :

 

((-1 . <Nom d'entité: 1fb31a22bb0>) (0 . "INSERT") (5 . "2EB") (102 . "{ACAD_REACTORS") (330 . <Nom d'entité: 1fb31a22c90>) (102 . "}") (330 . <Nom d'entité: 1fb42d209f0>) (100 . "AcDbEntity") (67 . 0) (410 . "Model") (8 . "HA6") (100 . "AcDbBlockReference") (2 . "*U8") (10 1891.54 -151.707 0.0) (41 . 1.0) (42 . 1.0) (43 . 1.0) (50 . 0.0) (70 . 0) (71 . 0) (44 . 0.0) (45 . 0.0) (210 0.0 0.0 1.0))

 

C'est un bloc anonyme, mais je ne vois pas ce qui est spécifique à un RESEAU d'où ma question.

 

Amicalement

Vincent

[Luna]

Salut,

 

J'ai travaillé sur ce sujet :3

Je n'ai pas de solution pour filtrer les réseaux directement dans l'expression du (ssget) malheureusement, cependant tu peux les filtrer en post-sélection (donc perte de temps en fonction du nombre d'objets dans le jeu de sélection) via leur propriété "ClassName" :3

 

Pour ma part j'ai ceci pour filtrer les réseaux :

(if (setq jsel (ssget '((0 . "INSERT"))))
   (repeat (setq i (sslength jsel))
       (setq name (ssname jsel (setq i (1- i))))
       (if (wcmatch (getpropertyvalue name "ClassName") "AcDbAssociative*Array")
           (ssdel name jsel)
       )
   )
)

Après bien sûr si tu ne traites pas des blocs dynamiques, tu peux filtrer directement dans le (ssget) en excluant les nom de blocs "`*U" de la sélection car un réseau est un bloc dynamique anonyme :3

 

Bisous (de loin),

Luna

[zebulon_]

Bonjour,

 

il me semblait bien que cela n'allait pas être simple.

 

En effet il est plus simple d'exclure le réseau que le contraire si on est sûr de ne pas traiter de blocs dynamiques. Mais c'est justement ce contraire que je voudrais faire.

 

Merci pour la solution

 

Amicalement

Vincent

[zebulon_]

en fait, dans mon esprit "filtrer", ça ne veut pas forcément dire exclure de la sélection, ça veut simplement dire donner des critères de sélection. Ces critères peuvent inclure ou exclure.

 

Quand on filtre, on peut garder ce qui reste dans le filet ou ce qui s'en échappe. Un not judicieusement placé devrait arranger mon affaire !

 

Amicalement

Vincent

[zebulon_]

comme je ne veux sélectionner que les réseaux rectangulaires, ça donne ceci :

 

(if (setq jsel (ssget '((0 . "INSERT"))))
   (repeat (setq i (sslength jsel))
       (setq name (ssname jsel (setq i (1- i))))
       (if (/= (getpropertyvalue name "ClassName") "AcDbAssociativeRectangularArray")
           (ssdel name jsel)
       )
   )
)

 

Amicalement

Vincent

[Luna]

Oui bien sûr, le filtre est dans les deux sens, il s'agit là d'un simple exemple, à adapter au besoin :3

 

comme je ne veux sélectionner que les réseaux rectangulaires, ça donne ceci :

Je te suggère dans ce cas de ne conserver que les blocs dynamiques (inutile de s'embêter avec les blocs standards dans le jeu de sélection) avec le filtre (2 . "`*U*")

Attention, ne pas oublier le ` (= back fix, quote inversée, apostrophe inversée, accent grave, AltGr+7...) devant l'astérisque autrement ça ne fonctionnera pas de la manière escomptée ;3

 

Si besoin, voici un programme me permettant de récupérer quelques données sur les réseaux (désolé, je n'ai pas de commentaires pour faciliter la compréhension :S ) :

; Permet de récupérer les propriétés essentielles et succintes d'un réseau :
;--- La fonction (Array-Def) possède 1 argument
;--- name correspond au nom d'entité du réseau étudié

;--- Renvoie une liste de paires pointées constituées comme suit, sinon nil :
;	("AxesAngle" . 0.0) 		-> l'angle, en radian, entre les axes X et Y du réseau (par défaut : 90°)
;	("RowSpacing" . 0.0) 		-> la distance entre chaque rangée (suivant l'axe Y du SCO)
;	("Rows" . 1)			-> le nombre de rangées
;	("ColumnSpacing" . 0.0) 	-> la distance entre chaque colonne (suivant l'axe X du SCO)
;	("Columns" . 1)			-> le nombre de colonnes
;	("LevelSpacing" . 0.0)	 	-> la distance entre chaque niveau (suivant l'axe Z du SCO)
;	("Levels" . 1)			-> le nombre de niveaux
;	(90 . 1)			-> le nombre d'objets source
;	(330 . <Nom d'entité: 483f218b>)-> la liste des entités sources (pouvant être modifiées/étudiées)
(defun Array-Def (name / i ent Array-properties Array-definition ent-lst lst)

(if (and (= (cdr (assoc 0 (entget name))) "INSERT")
	 (wcmatch (getpropertyvalue name "Classname") "AcDbAssociative*Array")
    )
	(progn
		(setq Array-properties (entget (cdr (assoc 330 (entget (cdr (assoc 330 (entget name)))))))
		      Array-definition (tblsearch "BLOCK" (cdr (assoc 2 (entget (cdr (assoc -2 (tblsearch "BLOCK" (cdr (assoc 2 (entget name))))))))))
		      ent (cdr (assoc -2 Array-definition))
		      lst (list (cons "AxesAngle" (cdr (assoc 40 (member '(1 . "AxesAngle") Array-properties))))
				(cons "RowSpacing" (cdr (assoc 40 (member '(1 . "ItemSpacing") Array-properties))))
				(cons "Rows" (cdr (assoc 90 (cdddr (member '(1 . "Items") Array-properties)))))
				(cons "ColumnSpacing" (cdr (assoc 40 (member '(1 . "RowSpacing") Array-properties))))
				(cons "Columns" (cdr (assoc 90 (cdddr (member '(1 . "Rows") Array-properties)))))
				(cons "LevelSpacing" (cdr (assoc 40 (member '(1 . "LevelSpacing") Array-properties))))
				(cons "Levels" (cdr (assoc 90 (cdddr (member '(1 . "Levels") Array-properties)))))
			  )
		)
		(while ent
			(setq ent-lst (cons ent ent-lst)
			      ent (entnext ent)
			)
		)
		(setq lst (append lst (list (cons 90 (length ent-lst)) (cons 330 ent-lst))))
	)
)
lst

)

; Permet de compter les objets présents dans les réseaux sélectionnés sans avoir à les exploser :

(defun c:ARRAYCOUNT (/ jsel i n name lst Array ent r c l s ent-list o-list)

(if (or (setq jsel (ssget "_I" '((0 . "INSERT") (2 . "`*U*"))))
	(setq jsel (ssget '((0 . "INSERT") (2 . "`*U*"))))
    )
	(progn
		(repeat (setq n 0 i (sslength jsel))
			(setq name (ssname jsel (setq i (1- i))))
			(if (wcmatch (getpropertyvalue name "Classname") "AcDbAssociative*Array")
				(progn
					(setq lst (cons (cons (setq n (1+ n)) (setq Array (Array-Def name))) lst)
					      r (cdr (assoc "Rows" Array))
					      c (cdr (assoc "Columns" Array))
					      l (cdr (assoc "Levels" Array))
					      s (cdr (assoc 90 Array))
					      o-list (cons (list r c l s) o-list)
					      ent-list (mapcar '(lambda (ent)
									(cond
										((and (= (cdr (assoc 0 (entget ent))) "INSERT")
										      (not (wcmatch (getpropertyvalue ent "Classname") "AcDbAssociative*Array"))
										 )
											(cons (getpropertyvalue ent "BlockTableRecord/Name") (cdr (assoc 8 (entget ent))))
										)
										(t
											(cons (cdr (assoc 0 (entget ent))) (cdr (assoc 8 (entget ent))))
										)
									)
								)
								(cdr (assoc 330 Array))
							)
					)
					(prompt (strcat "\n||==================================================||"
							"\nRéseau n°"
							(itoa n)
							(cond ((wcmatch (getpropertyvalue name "Classname") "AcDbAssociativeRectangularArray") " (Rectangulaire)")
							      ((wcmatch (getpropertyvalue name "Classname") "AcDbAssociativePolarArray") " (Polaire)")
							      ((wcmatch (getpropertyvalue name "Classname") "AcDbAssociativePathArray") " (Trajectoire)")
							      (t "")
							)
							" :"
							"\n     Nombre d'objets total = "
							(itoa (* r c l)) " u"
							"\n     Nombre de rangées = "
							(itoa r) " u"
							" (Espacement = "
							(rtos (cdr (assoc "RowSpacing" Array)) 2 2)
							" m)"
							"\n     Nombre de colonnes = "
							(itoa c) " u"
							" (Espacement = "
							(rtos (cdr (assoc "ColumnSpacing" Array)) 2 2)
							" m)"
							"\n     Nombre de niveaux = "
							(itoa l) " u"
							" (Espacement = "
							(rtos (cdr (assoc "LevelSpacing" Array)) 2 2)
							" m)"
							"\n     Nombre d'objets source = "
							(itoa s) " u"
							"\n  Composition de la source du réseau :"
							(apply 'strcat (mapcar '(lambda (x) (strcat "\n     "
												    (if (not (= 0 (setq ent (- (length ent-list) (length (setq ent-list (vl-remove (car ent-list) ent-list)))))))
													(strcat (itoa ent)
														" \""
														(car x)
														"\" sur le calque \""
														(cdr x)
														"\"."
													)
												    	""
												   )
											    )
										)
									        ent-list
									)
							)
						)
					)
				)
				(ssdel name jsel)
			)
		)
		(prompt (strcat "\n||==================================================||"
				"\nSynthèse des "
				(itoa n)
				" réseaux sélectionnés :"
				"\n     Nombre d'objets total = "
				(itoa (apply '+ (mapcar '(lambda (x) (apply '* (cdr (reverse x)))) o-list))) " u"
				"\n     Nombre d'objets global (avec sources) = "
				(itoa (apply '+ (mapcar '(lambda (x) (apply '* x)) o-list))) " u"
				"\nSe référer au détail de chaque réseau pour la répartition des objets et des objets sources."
			)
		)
	)
)
(princ)		 

)

 

En espérant que cela puisse t'aider, ou même d'autres personnes :3

Bisous (de loin),

Luna

[Aleck_Ultimate]

Salut.

 

Attention, ne pas oublier le ` (= back fix, quote inversée, apostrophe inversée, accent grave, AltGr+7...) devant l'astérisque autrement ça ne fonctionnera pas de la manière escomptée ;3

Juste pour être sûr, ce back fix, c'est quoi son utilité ? C'est la même fonction que l'anti-slash \ qui annule la fonction d'un caractère spécial pour lui rendre son usage de texte affiché ?

[Luna]

Vouih il permet de lire le caractère suivant de manière littérale : Wildcard Characters

Wildcard Description

# (pound) : Matches any numeric digit.

@ (at) : Matches any alphabetic character.

. (period) : Matches any nonalphanumeric character.

* (asterisk) or % (percent) : Matches any string, including the null string. It can be used at the beginning, middle, or end of a string.

? (question mark) : Matches any single character.

~ (tilde) : Matches anything but the next pattern.

[ ] (brackets) : Matches any one of the characters enclosed.

[~ ] (tilde and brackets) : Matches any character not enclosed.

- (hyphen) : Specifies a range for a single character when inside brackets.

' (reverse quote) : Escape character; reads the next character literally.

, (comma) : Enters a set when used between items.

 

En revanche, il ne me semble pas que le back-slash annule la fonction d'un caractère spécial... Il sert de caractère marqueur pour AutoCAD qui permet de créer des fonctions secondaires pour un simple caractère. En clair c'est plutôt l'inverse, il permet de créer des caractères spéciaux à partir de caractères simples.

 

Bisous (de loin),

Luna

[Aleck_Ultimate]

Bon, je parle beaucoup trop mal anglais pour suivre.

 

Moi je me base sur l'Evan(gile) selon Chanteau, chapitre 11 page 22 :

 

* Les caractères de contrôle sont soit des caractères non imprimables (saut de ligne, retour chariot, Echap…) soit des

caractères qui pourraient rendre l'interprétation du code caduque : des guillemets à l'intérieur d'une chaîne. Pour pouvoir

écrire ces caractère dans une chaîne on les fait précéder du "caractère d'échappement" : la barre oblique inversée ou

anti-slash (\). Ce caractère devra donc, lui aussi, être précédé d'un caractère d'échappement.

Caractères de contrôle :

\\ : anti-slash

\" : guillemet

\n : saut de ligne

\r : retour chariot

\e : Echap

\nnn : caractère dont le code octal est nnn

Je ne comprend pas cette dissonance entre les deux discours, surtout que vous parlez de la même chose ???

[zebulon_]

Merci pour ce rajout bien utile.

 

Par contre, plus je regarde ces entités de type réseau, moins je les apprécie, surtout parce qu'ils sont anonymes. Quand on les sélectionne, c'est difficile de savoir de quoi il s'agit, puisque c'est un bloc dont le nom n'est pas fixe, contrairement à un bloc standard. Un bloc non anonyme, lorsqu'on le sélectionne, on arrive à savoir rapidement de quoi il s'agit puisque son nom nous apprend beaucoup à son sujet. Pour un bloc anonyme, c'est beaucoup plus délicat de savoir à partir de quoi il a été construit.

 

Maintenant, je sais sélectionner des réseaux, mais comment faire pour savoir si c'est un réseau qui représente ce que je veux traiter ou un autre ?

 

En d'autres termes, comment fait-on pour savoir à partir de quoi ce réseau a été créé ?

 

Amicalement

Vincent

[Luna]

Vincent :

En d'autres termes, comment fait-on pour savoir à partir de quoi ce réseau a été créé ?

C'est justement pour cela que j'ai posté ce code, à vrai dire, ce n'est pas très clair sans les commentaires mais je récupère les entités sources (les entités ayant été utilisées pour la création du réseau) via la liste avec les noms d'entités. Mais pour être plus claire, retourne sur un sujet que tu as justement ouvert et auquel (gile) a répondu à cette question (avec les commentaires) : arrayrect et arrayedit

Pour plus de détails, il s'agit de la variable Array-Definition qui récupère la définition du bloc anonyme à l'origine du réseau et donc après c'est comme pour une définition de bloc, il faut créer une boucle pour récupérer toutes les entités (entnext) associées au code DXF -2 de cette définition :3

En fait, (gile) m'a simplement fait remarqué que même si le réseau est un bloc anonyme, la table des blocs contient tout de même une définition de bloc pour le réseau que l'on peut retrouver via le code DXF 2 du réseau (et après c'est un chemin un peu particulier pour retrouver cette définition de bloc originelle) :3

(setq Array-definition (tblsearch "BLOCK" (cdr (assoc 2 (entget (cdr (assoc -2 (tblsearch "BLOCK" (cdr (assoc 2 (entget name)))))))))))

 

Après, en soit, les blocs aussi sont embêtants à leur manière ! Les blocs dynamiques par exemple ne peuvent pas être directement filtrés par leur nom car il est anonymisé (donc différent du nom de la définition) ou les blocs standards possédant des attributs (faire un (entmake) de ces blocs demande une petite gymnastique bien particulière !==" )... Bref, tout est compliqué quand on débute, mais c'est justement en se posant des questions,en fouillant toujours plus profond et en visant toujours plus haut que l'on arrive finalement à réaliser des choses qui nous paraissaient impossible auparavant ! <3

Et puis, sans oublier que, plus on développe de programmes différents (par nous-mêmes), et plus notre bibliothèque de routines LISP grandit avec des fonctions de plus en plus complexes, généralisées et sans erreurs ;3

 

Alek

Je ne comprend pas cette dissonance entre les deux discours, surtout que vous parlez de la même chose ???

Justement, ce n'est pas du tout la même chose !! Les caractères n, ", r, e sont des caractères imprimables lorsqu'ils sont utilisés dans des strings (le mot français est trop long à écrire :3). Mais si on ajoute un \ devant ces caractères, alors là on obtient des caractères supplémentaires (et non imprimable pour la plupart). L'utilisation du back-slash permet d'ajouter des caractères spéciaux à un string qui ne peuvent pas être interprété par AutoCAD autrement (exemple, si tu veux imprimer des guillemets, ne pas mettre de \ devant mettra fin à ton string car c'est leur but premier : commencer ou mettre fin à un élément de type 'STR).

 

Le quote inversé quand à lui est utilisable pour les outils de recherches relatives, donc ce ne sont pas de simples strings. Notamment les fonctions (wcmatch), (ssget), ou même dans la palette des calques pour les filtres de propriétés sur le nom !

Ici, ce sont des caractères spéciaux (et donc n'ayant pas pour fonction première d'être lu de manière littérale) qui, à l'aide de la quote inversée, perde leur propriété première pour devenir des caractères imprimables.

Par exemple, le caractère * permet de remplacer un string (vide ou non) de longueur inconnu en début, milieu ou fin de chaîne. Or les blocs dynamiques possèdent un * dans leur nom donc on ajoute une quote inversée pour supprimer la fonction première de * est ainsi pouvoir rechercher littéralement ce caractère précis (et donc pas le remplacement d'une chaîne)...

 

En espérant ne pas t'avoir trop perdu...sumimasen..

 

Bisous,

Luna

[zebulon_]

on va fouiller de ce côté. Je pense que je vais trouver mon bonheur

 

Amicalement

Vincent

[zebulon_]

si le réseau a été fabriqué à partir d'un bloc nommé, on arrive à retrouver ce nom de bloc dans NestedBlock et cela permet de savoir de quoi il s'agit.

 

par contre, si le réseau a été fabriqué à partir d’éléments non nommés comme des polylignes, lignes, cercles, etc alors le réseau reste parfaitement anonyme.

 

Cela ne donne pas vraiment d'élément qui permettrait de savoir de quoi il s'agit.

 

Alors, soit je mets ces réseaux sur un calque particulier à la construction et ça me permet de savoir rapidement de quoi il s'agit, soit je lui colle une xdata avec le même effet sans que cela augmente de façon substantielle la liste des calques.

 

Quand j'ai sélectionné un réseau quelconque, je regarde ce que j'ai inscrit dans la xdata et je sais directement de quoi il s'agit. En gros, par ce biais je donne un nom fixe à mes réseaux similaires ce qui me permet de les filtrer facilement et de savoir quoi en faire. Pour autant qu'on puisse coller un xdata à un bloc anonyme. Il n'y a a priori pas de raison, mais je n'ai pas encore essayé.

 

Amicalement

Vincent

[zebulon_]

on peut coller une xdata à un bloc anonyme.

 

Je pense que je vais utiliser ce moyen pour nommer les réseaux. Chaque nom m'indiquera rapidement avec quel élément de base le réseau a été créé et, par voie de conséquence, je saurai les gérer (sélectionner, modifier, etc) sans me demander si je n'ai pas sélectionné un réseau créé par quelqu'un d'autre ou par moi, mais à d'autres fins.

 

Du coup mes réseaux sont nommés et je vais m'y retrouver !

 

Amicalement

Vincent

[Luna]

tout dépend du but final de ton programme :3

 

Je n'ai pas encore eu le temps de me plonger dans les XDatas et dictionnaires donc je ne pourrais pas vraiment t'aider sur ce point mais de ce que j'ai pu en voir, ce n'est pas forcément simple et il faut penser à les mettre à jour si ton objet est modifié.

Je sais que les ExpressTools ont une commande pour ajouter et modifier des XDatas donc si on peut accéder à son code, ça pourrait être intéressant de voir son fonctionnement (c'est XDATA et XDLIST je crois) :3

 

Que cherches-tu à faire exactement avec ces réseaux (si ce n'est pas indiscret) ? Parce que de manière générale les objets sont souvent rangés sur des calques nommés, ils peuvent également avoir des couleurs forcées donc en fonction de l'application de ton programme (un programme général ou plutôt restreint) tu devrais pouvoir te débrouiller sans la gestion des XDatas. Car cela peut aussi poser problème dans le cas où un réseau n'en possède pas, ou bien que les données ne sont pas à jour, bref les risques d'erreurs sont grands surtout si on ne pense pas aux pires scénarios catastrophes ^^"

 

Bisous,

Luna

[VDH-Bruno]

on peut coller une xdata à un bloc anonyme.

 

Je pense que je vais utiliser ce moyen pour nommer les réseaux. Chaque nom m'indiquera rapidement avec quel élément de base le réseau a été créé et, par voie de conséquence, je saurai les gérer (sélectionner, modifier, etc) sans me demander si je n'ai pas sélectionné un réseau créé par quelqu'un d'autre ou par moi, mais à d'autres fins.

 

Du coup mes réseaux sont nommés et je vais m'y retrouver !

 

Amicalement

Vincent

 

Bonjour Zebulon,

 

J'ai parcouru le fil de cette discutions en diagonale, bien que je ne programme plus, je pense que c'est la voie la plus directe pour identifier tes réseaux, de mémoire j'avais exploré cette voie pour retrouver les miens, en créant un nom d'application spécifique attaché à mon entité à la création, pour ajouter ce code -3 à mon filtre pour les sélectionner directement par la suite au moyen de la fonction ssget.

 

A titre d'exemple sur ce forum, dans le code lisp pagine, c'est cette façon de faire qui a été utilisé dans le filtre de sélection ssget (discussion ou tu étais participant)

https://cadxp.com/topic/38099-pagination-automatique/page__view__findpost__p__210208

 

Ci cela peut t'inspirer, bonne continuation à toi dans l'amélioration de tes routines de ferraillage ;)

 

Amicalement Bruno

[zebulon_]

J'ai l'habitude de manipuler les data. De ce côté pas de souci.

 

En fait le réseau sert à représenter des fers à béton en section, dans ce cas ce sont des cercles, ou en plan et en élévation, dans ce cas ce sont des segments en polylignes épaisses. Le réseau est sur le calque qui correspond au diamètre nominal de l'acier, par exemple "HA32". J'ai fait l'outil pour créer le réseau et c'est cet outil qui liera la xdata. Maintenant je veux faire l'outil qui me permettra de modifier le réseau : changer de diamètre et/ou changer l'aspect. Le diamètre nominal m'est donné par le calque et l'aspect me sera donné par la xdata. L'outil de modification changera, le cas échéant, le calque et/ou la xdata liés au réseau pour que l'ensemble reste cohérent.

Amicalement Vincent

[zebulon_]

 

L'ensemble des lisp. Je suis en train de modifier les outils qui correspondent aux aciers en section pour qu'une série d'aciers soit formée d'un seul réseau et non plus de n blocs ou segments.

L'objectif est d'en faciliter la manipulation et la modification.

Amicalement

Vincent

[zebulon_]

Les xdata me servent déjà pour inscrire le numéro du repère dans la polyligne qui décrit le façonnage. Ce qui permet de faire le lien entre le repère et la géométrie de l'acier lors de la génération de la nomenclature.

 

D'où ma grande expérience des xdata !

 

Amicalement

Vincent

[Luna]

Ok je comprend mieux maintenant :3

 

Je ne pensais pas que les réseaux avaient un intérêt pour les plans de ferraillage étant donné que les espacements ne sont pas constant la plupart du temps (ça dépend du ferraillage aussi ^^") donc en effet s'il s'agit de réseaux créés via un programme, il est préférable de créer des XDatas car c'est le plus simple (ça évite de devoir parcourir tous les réseaux à chaque passage pour vérifier les données internes, beaucoup trop long à l'exécution !)

 

Bon courage pour ton programme en tout cas

Bisous,

Luna

[Luna]

Ah et bien au moins je saurais à qui m'adresser lorsque j'aurais un peu de temps pour faire un programme de nomenclature élec' avec gestions des XDatas ^^"

 

Bisous,

Luna

[zebulon_]

De la même manière, compte tenu que les polylignes qui décrivent les aciers ne sont pas nommés, puisque les polylignes ne le sont pas, ce sont les xdata qui permettent au ssget de retrouver "mes" petits par le moyen décrit par Bruno ci-dessus. C'est un acier s'il possède le nom spécifique de mon application. Je vais transposer le même principe à "mes" réseaux.

Amicalement

Vincent

[zebulon_]

les xdata permettent de rajouter des données non graphiques à des entités graphiques, c'est ce qui en fait la puissance. Cela vaut le coup de s'y plonger quand on a acquis un peu d'expérience en programmation.

 

la bibliothèque qui me permet de gérer les xdata plus facilement :

 

;;;1000 chaine
;;;1001 application
;;;1002 accolades
;;;1003 plan
;;;1004 binaire
;;;1005 handle
;;;1010 point
;;;1011 position
;;;1012 deplacement
;;;1013 orientation
;;;1040 real
;;;1041 distance
;;;1042 echelle
;;;1070 entier
;;;1071 entier long


(defun n_remove (n lst / l nlst I)
 (setq I 0)
 (foreach l lst
   (if (/= I n)
     (setq nlst (cons (nth I lst) nlst))
   )
   (setq I (+ I 1))
 )
 (reverse nlst)
)


(defun n_modify (n val lst / l nlst I)
 (setq I 0)
 (foreach l lst
   (if (/= I n)
     (setq nlst (cons (nth I lst) nlst))
     (setq nlst (cons val nlst))
   )
   (setq I (+ I 1))
 )
 (reverse nlst)
)


;----------------------------------------------------------------------------
;
;      trouve, sur une entité l'information correspondant à "cle"
;
;  entrées :  cle   : clef d'accés
;             e     : nom d'entité
;             appli : application
;
;  retourne : valeur recherchée ou nil si la clef n'a pas été trouvée.
;----------------------------------------------------------------------------
(defun x_trouvinfo (cle e appli / xType xData l p)
 (if (= (type e) 'ENAME)
   (setq e (vlax-ename->vla-object e))
 )
 (vla-getxdata e appli 'xType 'xData)
 (if (and xType xData)
   (progn
     (setq l (mapcar 'vlax-variant-value (vlax-safearray->list xData)))
     (if (setq p (vl-position cle l))
       (nth (+ p 1) l)
     )
   )
 )
)


;------------------------------------------------------------------------------
;                       lit une liste en xdata
;  entrées : e    : nom d'entité
;            appli: application
;
;  retourne : liste XDATA correspondant à l'application
;------------------------------------------------------------------------------
(defun x_read (e appli / xType xData lstType lstData RES)
 (if (= (type e) 'ENAME)
   (setq e (vlax-ename->vla-object e))
 )
 (vla-getxdata e appli 'xType 'xData)
 (if (and xType xData)
   (progn
     (setq lstType (vlax-safearray->list xType))
     (setq lstData (mapcar 'vlax-variant-value (vlax-safearray->list xData)))
     (setq RES (list lstType lstData))
   )
 )
 RES
)

;------------------------------------------------------------------------------
;              place une liste en xdata sur une entité en préservant les
;                      xdata des autres applications
;  entrées : l    : liste XDATA correspondant à l'application
;            appli: application
;            e    : nom d'entité
;
;  retourne : sans intéret
;------------------------------------------------------------------------------
(defun x_write (l e appli / lstType lstData xType xData)
 (if (= (type e) 'ENAME)
   (setq e (vlax-ename->vla-object e))
 )
 (if l
   (progn
     (setq lstType (car l))
     (setq lstData (cadr l))
   )
   (progn
     (setq lstType (list 1001))
     (setq lstData (list appli))
   )
 )
 (if (= (strcase (car lstData)) (strcase appli))
   (progn
     (setq xType (vlax-make-safearray vlax-vbInteger (cons 0 (- (length lstType) 1))))
     (setq xData (vlax-make-safearray vlax-vbVariant (cons 0 (- (length lstData) 1))))
     (vlax-safearray-fill xType lstType)
     (vlax-safearray-fill xData lstData)
     (vla-setxdata e xType xData)
   )
   (princ (strcat (car lstData) " et " appli " ne correspondent pas"))
 )
)


;------------------------------------------------------------------------------
;                       place  une valeur en général
;  entrées : cle  : cle d'accés
;            val  : valeur à stocker
;            code : code XDATA (>1000)
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putgen (cle val code l appli / lstType lstData)
 (if l
   (progn
     (setq lstType (car l))
     (setq lstData (cadr l))
   )
   (progn
     (setq lstType (list 1001))
     (setq lstData (list appli))
   )
 )
 (if (not (vl-position cle lstData))
   (progn
     (setq lstType (append lstType (list 1002 1000 code 1002)))
     (setq lstData (append lstData (list "{" cle val "}")))
     (list lstType lstData)
   )
   l
 )
)


;------------------------------------------------------------------------------
;                       modifie  une valeur en général
;  entrées : cle  : cle d'accés
;            val  : nouvelle valeur à stocker
;            code : code XDATA (>1000)
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_modgen (cle val code l appli / lstType lstData)
 (if l
   (progn
     (setq lstType (car l))
     (setq lstData (cadr l))
     (if (= (strcase (car lstData)) (strcase appli))
       (progn
         (if (setq p (vl-position cle lstData))
           (progn
             (setq lstType (n_modify (+ p 1) code lstType ))
             (setq lstData (n_modify (+ p 1) val lstData ))
           )
         )
         (list lstType lstData)
       )
       l
     )
   )
 )
)


;------------------------------------------------------------------------------
;                       enleve la valeur annoncée par cle
;  entrées : cle  : cle d'accés
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_otegen (cle l appli / lstType lstData p)
 (if l
   (progn
     (setq lstType (car l))
     (setq lstData (cadr l))
     (if (= (strcase (car lstData)) (strcase appli))
       (progn
         (if (setq p (vl-position cle lstData))
           (progn
             (repeat 4
               (setq lstType (n_remove (- p 1) lstType))
               (setq lstData (n_remove (- p 1) lstData))
             )
             (list lstType lstData)
           )
           l
         )
       )
       l
     ) 
   )
 )
)

;------------------------------------------------------------------------------
;                       lit une valeur en général
;  entrées : cle  : cle d'accés
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : valeur recherchée ou nil si non trouvée
;------------------------------------------------------------------------------
(defun x_litgen (cle l appli / lstData p)
 (if l
   (progn
     (setq lstData (cadr l))
     (if (and (= (strcase (car lstData)) (strcase appli)) (setq p (vl-position cle lstData)))
       (nth (+ P 1) lstDATA)  
     )
   )
 )
)


;------------------------------------------------------------------------------
;                       place - modifie un entier
;  entrées : cle  : cle d'accés
;            val  : valeur à stocker
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putint (cle val l appli)
  (x_putgen cle (fix val) 1070 l appli)
)
(defun x_modint (cle val l appli)
  (x_modgen cle (fix val) 1070 l appli)
)

;------------------------------------------------------------------------------
;                       place - modifie un reel
;  entrées : cle  : cle d'accés
;            val  : valeur à stocker
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putrel (cle val l appli)
  (x_putgen cle (float val) 1040 l appli)
)

(defun x_modrel (cle val l appli)
  (x_modgen cle (float val) 1040 l appli)
)

;------------------------------------------------------------------------------
;                       place - modifie un 3Dpoint
;  entrées : cle  : cle d'accés
;            pt   : valeur à stocker
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putpoint (cle pt l appli)
  (x_putgen cle pt 1010 l appli)
)
(defun x_modpoint (cle pt l appli)
  (x_modgen cle pt 1010 l appli)
)

;------------------------------------------------------------------------------
;                       place - modifie un coefficient d'échelle
;  entrées : cle  : cle d'accés
;            coef : valeur à stocker
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putech (cle coef l appli)
  (x_putgen cle coef 1042 l appli)
)
(defun x_modech (cle coef l appli)
  (x_modgen cle coef 1042 l appli)
)


;------------------------------------------------------------------------------
;                       place - modifie un handent
;  entrées : cle  : cle d'accés
;            hand : maintien à stocker
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_puthan (cle hand l appli)
  (x_putgen cle hand 1005 l appli)
)
(defun x_modhan (cle hand l appli)
  (x_modgen cle hand 1005 l appli)
)


;------------------------------------------------------------------------------
;                       place et modifie un calque
;  entrées : cle     : cle d'accés
;            calque  : calque à stocker
;            l       : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli   : application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putlay (cle calque l appli)
  (x_putgen cle calque 1003 l appli)
)
(defun x_modlay (cle calque l appli)
  (x_modgen cle calque 1003 l appli)
)


;------------------------------------------------------------------------------
;                       place et modifie une chaine
;  entrées : cle  : cle d'accés
;            ch   : chaine à stocker
;            l    : liste '((xType1 xType2 ...) (xData1 xData2...))
;            appli: application
;
;  retourne : liste XDATA modifiée
;------------------------------------------------------------------------------
(defun x_putstr (cle ch l appli)
  (x_putgen cle ch 1000 l appli)
)
(defun x_modstr (cle ch l appli)
  (x_modgen cle ch 1000 l appli)
)

; Fin XdataFer

 

amicalement

Vincent

[zebulon_]

par exemple, je veux rajouter des données à un élément graphique "vierge" de xdata.

 

je commence par compiler les différentes clés et leurs valeurs correspondantes dans une chaine de caractères :

 

(setq EXDATA (x_putstr "fac" "HNSPI" nil "MONAPPLI"))
(setq EXDATA (x_putstr "nbp" "5" EXDATA "MONAPPLI"))
(setq EXDATA (x_putstr "pas" "0.200" EXDATA "MONAPPLI"))

 

puis après j'enregistre cette chaine dans l'entité graphique E en spécifiant mon nom d'application

 

(x_write EXDATA E "MONAPPLI")

 

Si l'élément graphique possède déjà des xdata de mon application, il faut bien sûr d'abord lire les xdata existants, les modifier et les réécrire.

 

(setq xdata1 (x_read E "MONAPPLI"))
(setq xdata1 (x_putstr "rep" "5" xdata1 "MONAPPLI"))
(x_write xdata1 E "MONAPPLI")

 

et le ssget devient assez rapide, compte tenu que je ne veux sélectionner que des entités qui ont quelque chose à voir avec "MONAPPLI"

 

(ssget '((-3 ("MONAPPLI")))

 

Amicalement

Vincent

[Luna]

0w0

 

Arigato !! j'aurais de quoi travailler :3 à vrai dire, je connaissais déjà le principe des XDatas et leur intérêt mais je n'ai pour le moment jamais eut le temps d'explorer très loin et donc ma bibliothèque n'est pas très...garnie ^^"

Avec tout ça, je pourrais avoir quelques exemples et je devrais enfin pouvoir étudier le langage Visual LISP qui peut être une bonne alternative en fonction des cas :3

 

Par contre, on s'égare un peu du sujet, mais merci beaucoup en tout cas <3

 

Bisous,

Luna