VDH-Bruno

Bonjour, Je cherche à sauvegarder dans un XDATA d'une entité le HANDLE d'une autre entité. Ceci est il réalisable ? En lisp cela est réalisable, je suppose que cela l’est également en .net, pour étayer mon affirmation et surtout faute de pouvoir écrire en .net, voici un petit exemple Lisp. En attendant mieux d’un autre cadxpien(ne)… ;; La fonction demande de sélectionner 2 objets et ;; enregistre le handle de chaque objet comme donnée étendu ;; de l'autre objet (defun c:SVG-HANDLE (/ e1 e2) (if (and (setq e1 (car (entsel "\nChoix du 1er objet:"))) (setq e2 (car (entsel "\nChoix du 2ème objet:"))) ) (progn (princ (strcat "\Leurs Handle sont respectivement " (cdr (assoc 5 (setq e1 (entget e1)))) " & " (cdr (assoc 5 (setq e2 (entget e2)))) " !!!" ) ) (regapp "svghandle") (entmod (cons (list -3 (list "svghandle" '(1002 . "{") (cons 1005 (cdr (assoc 5 e1))) '(1002 . "}"))) e2) ) (entmod (cons (list -3 (list "svghandle" '(1002 . "{") (cons 1005 (cdr (assoc 5 e2))) '(1002 . "}"))) e1) ) ) ) (princ) ) Pour vérifier ;; Pour récupére la valeur de l'handle contenu dans les données étendues (defun c:getXhandle () (cdr (assoc 1005 (cdr (assoc "svghandle" (cdr (assoc -3 (entget (car (entsel)) '("*")))))))) )

Bonjour Arcasdk, Bien que n’étant pas un grand spécialiste de la question je vais essayer de t’éclairer dans la mesure de mes moyens. Les Xdata ou données étendues permettent d’attacher des données à des entités, données utilisée par Autodesk ou des applications spécifiques. Sous AutoCAD on trouve par exemple des Xdata attaché aux fenêtres de l’EP (VIEWPORT) ou aux hachures (HATCH), les données étendues sont accessible avec la fonction entget, elles suivent les données de définitions de l’entité et sont précédées d’un code de groupe -3 et d’un nom d’applications (pour AutoCAD le nom d’application est "ACAD"). Pour que la fonction entget retourne les données étendues d’une entité, il faut spécifier son nom d’application, syntaxe (entget ename [applist]) Exemple d’une cotation dont on a modifié le paramètre d’échelle linéaire Nota une astuce pour retourner les données étendues d’une entité quelques soit le nom d’application remplace "ACAD" par "*" : (entget (car (entsel)) '("*")) L’argument applist se conforment au motif de filtrage utilisé par la fonction wcmatch. Pour ce qui est du code 1040 je te renvoie un peu à la réponse de Carboleum, il suffit de faire varier l’echelle linéaire de ta cotation est de rechercher dans la liste dxf des données étendue, le code dxf qui varie… Pour sélectionner des entités en fonction de leur données étendues il suffit de spécifié leur nom d’applications exemple : ;; Sélectionne les cotations ayant des données étendues (ssget '((0 . "DIMENSION") (-3 ("ACAD")))) Ou ;; Sélectionne toutes les entitées ayant des données étendues (ssget "X" '((-3 ("*")))) Pour en savoir plus sur le sujet, il y a le forum qui est très riche sur la question, a voir également les fonctions XDLIST & XDATA des outils Express (il y a je crois une version amélioré par (gile) sur le forum). Il existe également une description des codes donnée dans le Manuel d’utilisation DXF rubrique Données étendues dans les Concepts DXF avancés http://exchange.autodesk.com/autocadmep/fra/online-help/browse#WS1a9193826455f5ff18cb41610ec0a2e719-7943.htm Et la rubrique Extended Data – xdata que l’on trouve dans l’aide AutoLISP Developer's Guide > Using the AutoLISP Language > Using AutoLISP to Manipulate AutoCAD Objects > Extended Data – xdata. http://docs.autodesk.com/ACD/2011/ENU/filesALG/WS73099cc142f4875516d84be10ebc87a53f-7a08.htm Non pas du tout d’ailleurs je viens de m’apercevoir que ma ligne de code n’était pas si fiable, car il peut y avoir plusieurs code 1040 notamment si la taille des flèches a été modifié, pour bien faire il me semble qu’il faudrait également faire une vérification sur la valeur du code 1070 qui précède… Du coup je comprends mieux maintenant la remarque de Bryce Cordialement Bruno

Bonjour, Un équivalent en AutoLisp à la ligne de code donné par Bryce (cdr (assoc 1040 (cdadr (assoc -3 (entget (car (entsel)) '("ACAD")))))) Sur ce principe un code à tester qui devrai répondre à ton besoin ;; Sélectionne les cotations en fonction de leur échelle linéaire (defun c:selCotEchLin (/ eref echlin i ss e) (cond ((and (setq eref (car (entsel "\nPointez une cotation en référence pour l'échelle linéaire :"))) (setq eref (entget eref '("ACAD"))) (= "DIMENSION" (cdr (assoc 0 eref))) ) (setq echlin (cdr (assoc 1040 (cdadr (assoc -3 eref))))) (sssetfirst nil (repeat (setq i (sslength (setq ss (ssget "X" '((0 . "DIMENSION")))))) (if (equal echlin (cdr (assoc 1040 (cdadr (assoc -3 (entget (setq e (ssname ss (setq i (1- i)))) '("ACAD")))))) 1.0e-9 ) ss (ssdel e ss) ) ) ) ) ) (princ) ) A+

Bonjour, Juste une petite intervention pour donner à ceux qui ne l’auraient pas sur leurs postes les variables/fonctions associées utilisé dans le code de (gile)... ;;; GetItem (gile) ;;; Retourne le vla-object de l'item s'il est présent dans la collection ;;; ;;; Arguments ;;; col : la collection (vla-object) ;;; name : le nom de l'objet (string) ou son indice (entier) ;;; ;;; Retour : le vla-object ou nil (defun GetItem (col name / obj) (vl-catch-all-apply (function (lambda () (setq obj (vla-item col name))))) obj) Et (or *layers* (setq *layers* (vla-get-layers (vla-get-activeDocument (vlax-get-acad-object))))) Car personnellement j’apprécie beaucoup les fonctions réversibles (au moins pendant la durée de la session active) et je trouve toujours très plaisant cette utilisation de defun-q pour permettre la redéfinition de fonction et éviter ainsi l’emploi d’une variable global supplémentaire. Sinon le passage d’argument peut également se définir dans une fonction.. (defun c:deverrouille () (LayerUnLockAll T) (princ)) (defun c:verrouille () (LayerUnLockAll nil) (princ)) A+

Re, Très surprenant !!!! Pour le fun en réutilisant une fonction déjà publié sur le forum et celle donné précédemment http://cadxp.com/index.php?/topic/31620-quelques-fonctions-de-liste/ ;; --------------------------------------------------------------- ;; ar-1:n => Arrangement à Répétition de 1 à n (Version itérative) ;; --------------------------------------------------------------- ;; Argument: Une liste de symboles (d'éléments) ;; Retourne: Tous les arrangements de 1 à n ;; Exemple : ;; (ar-1:n '(A B C) 2) ;; => ((A) (B) (C) (A A) (A B) (A C) (B A) (B B) (B C) (C A) (C B) (C C)) (defun ar-1:n (l n / lst res) (setq lst '(nil)) (repeat n (setq res (append res (setq lst (apply 'append (mapcar '(lambda (x) (mapcar '(lambda (y) (cons x y)) lst)) l))))))) Un code qui devrait te retourner une liste de tous les raccourcis clavier de 1 à 2 caractères encore disponible sur ton poste, (vl-remove-if 'namesymbolp (mapcar '(lambda (x) (read (apply 'strcat x))) (ar-1:n '("A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z") 2))) A titre d’exemple voilà ce que cela donne sur mon ordinateur et encore c’est seulement avec les caractères alphabétiques… ps : Je te déconseille de tester la fonction avec des combinaisons de plus de 4 ou 5 caractères car bonjour l’explosion combinatoire ;-) A+

Bonjour, Une fonction qu’il m’arrive d’utiliser quand j’ai un doute sur la disponibilité ou pas d’un nom de fonction avant utilisation.. ;; VDH-Bruno le: 09/10/2011 ;; Fonction Prédicat - Test l'existance d'un nom symbol - ;; Exemple: ;; (namesymbolp 'ef) --> T (symbol définie) ;; (namesymbolp 'attin) --> T (symbol définie) ;; (namesymbolp 'azerty) --> nil (symbol non définie) (defun namesymbolp (name / fich lst line) (or (type (eval name)) (member (strcat "C:" (vl-princ-to-string name)) (atoms-family 1)) (getcname (vl-princ-to-string name)) (member (vl-princ-to-string name) (cond ((setq fich (findfile "acad.pgp")) (setq fich (open fich "r")) (while (setq line (read-line fich)) (if (not (or (= (substr line 1 1) ";") (= (substr line 1 1) ""))) (setq lst (cons (substr line 1 (vl-string-search "," line)) lst)))) (close fich) lst)))))

Re, Pour ceux qui préfèrent avoir comme points de base la moyenne de tous les points d’insertion des textes, plutôt que le point d’insertion de la première entité sélectionné vous pouvez substituer ces lignes de codes : (setq inc_ang (/ (* 2 pi) nb_text) pt_or (cdr (assoc 10 (entget (ssname js_mt 0)))) nb nb_text) Par ces dernières : ;; calcul le centre de gravité des points d'insertions des textes sélectionnés (setq inc_ang (/ (* 2 pi) nb_text) pt_or (mapcar '(lambda (x) (/ x (float (length pt_or)))) (apply 'mapcar (cons '+ (repeat (setq nb nb_text) (setq pt_or (cons (cdr (assoc 10 (entget (ssname js_mt (setq nb (1- nb)))))) pt_or)))))) nd nb_text) (Ps : Au cas où vous relanceriez la commande une seconde fois sur la même sélection, ou sur des sélections de textes non superposés)

Bonjour bonuscad, Je viens de tester, c’est visuellement très réussi comme routine, bravo j’aime beaucoup :)

Re, Ouais à la relecture c’est très moyen ce que j’ai écrit <_< , car ce n’est pas moins aisé avec or, en l’écrivant comme ceci… (or (setq AiResa (getreal "\nArase inférieure <Calcul>: ")) (setq AiResa (calcul))) A+

Bonjour, Si tu veux récupérer aisément la valeur de ta fonction calcul dans ta variable, tu peux privilégier l’usage de cond à or, qui te renverra la valeur de ton test alors que or est une fonction boléenne qui renvoie nil ou T. (initget "Calcul") (setq AiResa (cond ((getreal "\nArase inférieure <Calcul>: ")) ((calcul)) ) ) Sinon un exemple avec une séquence de code (un peu gadget) bricolé/adapté rapidement à ta demande, Il utilise une variable global, dans ta session de dessin au premier appel il te propose par défaut ton option, par la suite il te propose en option par défaut la dernière valeur renseignée ou calculée. (defun c:test () ;; Routine à écrire (provisoirement la fonction retourne 4.0) (defun calcul () (+ 2 2.)) (initget "Calcul") (setq *AiResa* ((lambda (x) (cond ((numberp x) x) ((or (= x "Calcul") (not *AiResa*)) (calcul)) (*AiResa*) ) ) (getreal (strcat "\nArase inférieure ou [Calcul] <" (if (numberp *AiResa*) (rtos *AiResa* 2 3) "C" ) ">: " ) ) ) ) ) Cordialement,

Re, Je vois que tu bloques toujours sur le même problème à savoir la précision à l’affichage et les arrondies, nous en avons déjà discuté dans ce postil me semble... Je ne sais pas trop ce que je peux ajouter de plus. Peut-être que quelqu’un d’autre saura mieux se faire comprendre que moi... En tentant une dernière explication si tu entre au clavier une distance, tu as vraiment la distance à la précision saisie. Maintenant si tu récupère la distance entre 2 points, il se peut suivant la précision de ton dessin que la distance réelle ne soit pas tout à fait égale à 12.1 même si à l’affichage (ou en mesurant) cela semble être le cas. Il n’y a donc rien de surprenant aux résultats que tu donnes, à toi d’intégrer cela dans tes routines, à la saisie au moyen d’une fonction round (cf lien précèdent) ou dans tes tests de comparaisons au moyen de la fonction equal A+

Bonjour, Comme la demande est assez similaire à la précédente, je t’invite à relire ma réponse précédente que je vais compléter … Donc en partant du postulat que tu as réussi à construire un jeu de sélection contenant toutes les entités créer par ta commande réseau. Tu souhaites compléter ce jeu de sélection par toutes les entités créer par la commande miroir, pour cela tu peux procéder comme précédemment en utilisant un "marqueur" dans la base de donnée ou alors pour compléter ton arsenal de fonction utilise sslength et ssname, ce qui te retournera respectivement le nombre d’éléments de ton jeu de sélection et le nom d’entité à l’indice spécifié. Donc pour récupérer le nom de la dernière entité ajouté à ton jeu de sélection : (setq e (ssname ss (1- (sslength ss)))) Puis pour compléter ton jeu de sélection avec toutes les entités nouvellement créé par ta commande miroir (ou autre): (while (setq e (entnext e)) (ssadd e ss) ) Maintenant tu peux passer ss en argument à la commande copier ou déplacer. A+

Bonjour, Non non pas qu’à toi, j’ai le même menu déroulant que Patrick avec l’installe de cette version de Microsoft Visual C# 2010 Express (lien : http://msdn.microsoft.com/fr-fr/gg699326 ) (Ps : Je ne programme pas en .net, la communauté francophone semblant un peu plus active, curieux j’ai installé Visual Studio et disons que vos discussions commence à éveiller mon intérêt…). A+

Bonjour, Etudie plus particulièrement les fonctions entlast, entnext et ssadd Rapidement l’idée général pour ce que tu souhaite faire : En 1 : Après avoir inséré ton bloc, récupère avec entlast le nom de l’entité dessin que tu viens de créer, puis crée ensuite un jeu de sélection vide dans lequel tu stockera cette entitée (tu viens en quelque sorte d’obtenir un marqueur dans ta base de données) Le code en lisp : (setq e (entlast)); récupère le nom de la dernière entité (setq ss (ssadd)); Crée un jeu de sélection vide (ssadd e ss); place l'entité dans le jeu de sélection En 2 : Tu crées ton réseau comme tu le faisais précédemment, puis avec la fonction entnext et une itération tu liste toutes les entités nouvellement créé, que tu ajoutes à ton jeu de sélection, comme ceci… (while (setq e (entnext e)) (ssadd e ss) ) En 3 : Dans ta ligne de command miroir au lieu de donné "d" en paramètre tu passe ss (ton jeu de sélection de toutes les entités créer précédemment..) A+ et bonne continuation ----------------------- Edit : Visiblement je viens de faire de l’écho au message de Patrick_35 qui a été plus rapide..

Bonjour, Avec les réacteurs d’évenement, Il faut exclusivement travailler avec ActiveX (pas de entget, entmode, command …) Regarde dans l’aide c’est assez explicite ici : http://translate.google.fr/translate?sl=en&tl=fr&js=n&prev=_t&hl=fr&ie=UTF-8&layout=2&eotf=1&u=http%3A%2F%2Fdocs.autodesk.com%2FACD%2F2011%2FENU%2FfilesALG%2FWS73099cc142f4875516d84be10ebc87a53f-7c2f.htm Et la : http://translate.google.fr/translate?sl=en&tl=fr&js=n&prev=_t&hl=fr&ie=UTF-8&layout=2&eotf=1&u=http%3A%2F%2Fdocs.autodesk.com%2FACD%2F2011%2FENU%2FfilesALG%2FWS73099cc142f4875516d84be10ebc87a53f-7c2f.htm Donc je ne pense pas que l’on puisse parler de bug mais plutôt de limitation ;) A+

Bonjour et bienvenu Remi83600, Rapidement en reprenant ton code et en adaptant légèrement la syntaxe pour utiliser foreach plutôt que repeat… (command "_pline" "_none" (car Lidessin) "la" 0.5 0.5) (foreach pt (cdr Lidessin) (command "_none" pt)) (command "") A+ (Ps : Il est également possible de paramétrer l’épaisseur de ta polyligne au moyen de la variable PLINEWID et des fonctions Lisp getvar & setvar)

Oui Patrick_35 c’est juste je t’en remercie, effectivement j’ai été peu rigoureux sur ce coup d’ailleurs en lisant également Byce je m’aperçois que j’aurais pu soigner un peu plus ma sélection, au passage je conseil à Arcasdk de s’en inspirer pour gagner en efficacité dans sa macro. Et pour être complet je remercie également (gile) pour les explications concernant le calcul de la valeur de TrueColor que je ne connaissais pas. A+

Bonjour, En suivant les explications donnée par (gile) : Pour réaliser la macro que tu veux faire c.a.d. n’avoir que les couleurs de l’index de définit (pour les entités de dessin dont la couleur n’est pas celle du calque), il suffit de supprimer les codes DXF 420 et 430 de la définition de l’entité si ils sont présent, comme ceci par exemple : (entmod (vl-remove-if '(lambda (x) (or (= (car x) 420) (= (car x) 430))) (entget (car (entsel))))) Pour généraliser à l’ensemble du dessin, tu peux utiliser la fonction ssmap expliqué dans ce sujet: (defun ssmap (fun ss / n) (if (= 'PICKSET (type ss)) ; si ss est bien un jeu de sélection, (repeat (setq n (sslength ss)) ; répéter autant de fois qu'il y a d'entité, (apply fun (list (ssname ss (setq n (1- n))))); appliquer la fonction a chaque entité ) ) ) Et donc rapidement ta macro pourrait ressembler à cela : (defun c:index () (ssmap '(lambda (x) (entmod (vl-remove-if '(lambda (x) (or (= (car x) 420) (= (car x) 430))) (entget x) ) ) ) (ssget "_X") ) (princ) ) A tester en espérant avoir répondu à ton besoin A+

Bonjour Guiux et bienvenu, Suit ce lien liste-de-points-polyligne te devrais trouver ton bonheur A+

Bonjour, Ma version à tester, écrite un peu à la volé mais en théorie elle devrait plutôt bien fonctionner… ;; 27-04-2012 VDH-Bruno ;; My Z=0, Affecte toute la base de données du dessin EO, EP, Bloc ect... (defun c:z=0 () (vl-load-com) (vlax-map-collection (vla-get-Blocks (vla-get-ActiveDocument (vlax-get-acad-object))) '(lambda (block) (vlax-map-collection block '(lambda (obj) (cond ((vlax-method-applicable-p obj 'Move) (vla-Move obj (vlax-3d-point '(0 0 0)) (vlax-3d-point '(0 0 1e99))) (vla-Move obj (vlax-3d-point '(0 0 0)) (vlax-3d-point '(0 0 -1e99))) ) ) ) ) ) ) (princ) ) A+

Re, Pour l’exemple la solution évoqué précédemment avec (vl-remove-if-not 'vl-consp lst) et des fonctions mutuellement récursives histoire d’optimiser encore un peu le traitement dans certain cas en économisant des appels à la fonction member… ;; Variante avec récursion mutuelle (defun recMember (ele lst / f1 f2) (defun f1 (lst) (cond ((member ele lst)) ((f2 (vl-remove-if-not 'vl-consp lst))) ) ) (defun f2 (lst) (cond ((null lst) nil) ((f1 (car lst))) ((f2 (cdr lst))) ) ) (f1 lst) ) A+

Oui C’est assez astucieux cela permet d’aller directement explorer la première sous liste qui suit et avancer un peu plus vite dans le traitement (ou balayage de la liste). D’ailleurs si on veut aller dans cette direction, on peut je pense tenter un (vl-remove-if-not 'vl-consp lst) avec une récursion mutuelle à voir, si j’ai 2 minutes je poserai un exemple mais là je suis trop vraiment charrette... A+

Salut, Coiffé au poteau par (gile) :angry: , je donne tout de même ma variante.. :D ;; Fonction member à toute les profondeurs ;; Arguments: ;; x un élement ;; l une liste ou tree ;; Retourne la liste restante si x est présent dans l, sinon nil ;; Exemple: ;; (super-member 'E '(B C (D (E C A) (F)))) -> (E C A) ;; (super-member 'Z '(B C (D (E C A) (F)))) -> nil (defun super-member (x l) (cond ((null l) nil) ((equal x (car l)) l) ((super-member x (if (listp (car l)) (car l)))) ((super-member x (cdr l))) ) ) A+ ------------------------------ Edit --------------------------------------- Corrigé code, remplacé : ((listp (car l)) (super-member x (car l))) par ((super-member x (if (listp (car l)) (car l))))

Salut, Pour nettoyer (cad supprimé les nil de la liste retourné) l’astuce consiste à appliquer un append sur ta valeur en retour du type (apply ‘append … L’emploie d’une variable comme tu le fais pour essayer de filtrer les nil est plus commun à une construction de code de type foreach.. Pour voir d'autre façon de faire, tu peux suivre ce lien massoc, tu trouveras différentes solutions (foreach, while, vl-remove-if-not, append + mapcar, repeat, récursive…) pour traiter ton cas, qu'il suffira d’adapter légérement le traitement. Sinon pour faire comme ceux que je considère ici comme mes mentors, voici ma version: (defun c:test (/ CheckList) (defun CheckList (key alst) (if (setq alst (member (assoc key alst) alst)) (cons (list (nth 2 (car alst)) (nth 1 (car alst))) (CheckList key (cdr alst)) ) ) ) (CheckList (strcase (getstring T "\nTapper le string : ") T) '(("fdffg" "FDFFG" "1234" "4569" "22") ("fdifg" "FDIFG" "1224" "4569" "22") ("mdffg" "MDFFG" "1434" "4569" "22") ("adffg" "ADFFG" "1234" "4169" "22") ) ) ) A+

Bonjour Fraid, Je ne suis pas sûr de bien saisir l’énoncer du problème.. De plus les résultats que tu donnes ne correspondent pas tout à fait la réalité.. Tu peux développer un peu plus ce que tu souhaiterais obtenir.. A+