(gile)

Merci encore :red: Il est, bien sûr, possible de modifier tout ça (et tu n'aurais aucune difficulté à le faire ;) ). Pour le positionnement (rotation et miroir), si ce n'est pas fait dans le déroulement du LISP il est fort probable que l'utilisateur doive le faire après. L'orientation du bloc (surface développée) est faite arbitrairement par rapport au SCU courant en fonction des premiers sommets traités (selon qu'ils sont confondus ou pas). La face vue dépend du côté qui a été sélectionné sur les objets au moment de la création de la surface réglée, il me semblait donc intéressant de proposer la possibilité d'afficher l'autre face. Pour le renommage, on pourrait éviter de faire un bloc ou le supprimer et le purger à la fin.

Pour éviter une erreur dans le cas d'un sommet unique (cone ou surface réglées sur un point), j'ai modifié la sous routine THIRD_PT dans les LISP.

Salut, Tu pourras trouver une version gratuite à partir d'ici, mais j'ai cru comprendre que la principale différence entre version gratuite et payante c'est justement les possibilités d'exportation sous certains formats.

La modification apportée à xref_purge (version 1.1) pour éviter de purger les xrefs déchargées faisait entrer SPURGE (qui purge les blocs vides) dans une boucle sans fin. Je modifie SPURGE (version 1.3) pour corriger le problème. Pour sergeluc, Je te remercie mais j'avais fait ce nouveau sujet pour éviter les confusions qui avaient cours dans le sujet précédent, il n'est question ici que des xrefs non-référencées (pas des xrefs introuvables). [Edité le 8/7/2006 par (gile)]

Re-re, Je pense que le plus simple est de passer par du vlisp : ((lambda (/ f_m) (while (null (setq f_m (ssget '((-4 . " (0 . "VIEWPORT") (-4 . " (0 . "LWPOLYLINE") (102 . "{ACAD_REACTORS") (-4 . "AND>") (-4 . "OR>") ) ) ) ) ) (setq Index 0 Couleur 1 ) (if f_m (repeat (sslength f_m) (vla-put-color (vlax-ename->vla-object (ssname f_m Index)) Couleur) (setq Index (+ Index 1)) ) ) ) ) [Edité le 8/7/2006 par (gile)]

Re, Extrait de l'aide aux développeurs concernant la fonction entmod :

Salut, Il y a une faute ici : ([surligneur]= null[/surligneur] (assoc 62 (entget (ssname f_m Index))))

Tramber a raison, question poids du fichier et quantité de travail pour le mappage de chaque lame. Je donne quand même le LISP, les slides sont coupés suivant le plan XY du SCU qui se déplace sur l'axe Z, il faut donc bien placer le SCU avant de lancer la commande : ;;; 10/04/05 - Gilles Chanteau - FONCTION TRANCHER ;;; Déplace le SCU courant sur l'axe Z et coupe les solides sélectionnés à l'aide du plan XY ;;; autant de fois que demandé, puis replace le SCU dans sa position initiale. ;;; Demande à l'utilisateur le nombre de tranches à couper, l'épaisseur des tranches ;;; et de choisir les objets ;;; Redéfinition de *error* (defun STD_ERR (msg) (if (or (= msg "Fonction annulée") (= msg "quitter / sortir abandon") ) (princ) (princ (strcat "\nErreur: " msg)) ) (command) (command "_undo" "_end") (command "_u") (setq *error* m:err m:err nil ) (princ) ) ;;; Fonction principale (defun c:trancher (/ echo n epais objets) (setq m:err *error* *error* STD_ERR echo (getvar "cmdecho") ) (initget 7) (setq n (getint "\nEntrez le nombre de tranches: ")) (initget 7) (setq epais (getdist "\nSpécifiez l'épaisseur des tranches: ")) (if (not (setq objets (ssget "_i"))) (progn (sssetfirst nil nil) (setq objets (ssget)) ) ) (command "_undo" "_begin") (princ "Trancher") (setvar "cmdecho" 0) (repeat n (command "_ucs" "_move" "z" epais "_slice" objets "" "xy" "" "_both") ) (command "_ucs" "_move" "z" (* (- n) epais)) (command "_undo" "_end") (setvar "cmdecho" echo) (setq *error* m:err m:err nil ) (princ) )

j'ai un outil en LISP pour "trancher" un solide suivant une épaisseur donnée, je te posterai ça ce soir.

Salut, Si tu veux voir le sujet d'où est extrait l'image proposée.

Si la cotation a été faite avec des cotes associatives, tu peux essayer un COTREGEN qui devrait replacer les cotes sur les objets à partir desquelles elles ont été faites.

Je n'ai pas cherché plus que ça, mais je ne pense pas que cet outil existe. Le seul moyen que je vois est plutôt fastidieux : diviser le parquet en autant de lames et faire un mapping sur chacune des lames. C'est la méthode que j'avais employée pour faire le plaquage du dessus de la table Louis XV

Salut, Je n'avais effectivement pas pensé aux xref déchargées et xref_purge détachait toutes les xrefs non présentes dans le dessin. Le seul moyen que j'ai trouvé pour différencier les xrefs déchargées c'est qu'elles ne "comptent" aucune entité. Donc je modifie xref_purge pour qu'il détache toutes les xrefs non présentes dans le dessin sauf celles qui n'ont aucune entité (ce qui, à priori, ne devrait concerner que les xrefs déchargées). Pour ce concerne le fonctionnement aléatoire sur AutoCAD 2006, je ne suis pas sûr de pouvoir t'aider, je n'ai que la version 2007 et je dois avouer n'avoir pas fais énormément de tests approfondis et être proche de la limite de mes connaissances en VisualLISP. [Edité le 6/7/2006 par (gile)]

Sino, un petit LISP vite fait : (defun c:sel_lay (/ ent) (while (not (setq ent (car (entsel "\nSélectionnez un objet sur le calque cible: ") ) ) ) ) (sssetfirst nil (ssget "_X" (list (cons 8 (cdr (assoc 8 (entget ent))))))) (princ) )

Encore une fois, MERCI Patrick. Très pratique le double clic :D

Dans le même esprit, j'ai ajouté, le traitement des polylignes 2D et 3D. ;;; Clean_poly Supprime tous les sommets superposés des polylignes, optimisées, 2D et 3D ;;; TRUNC Retourne la liste tronquée à partir de la première occurrence ;;; de l'expression (liste complémentaire de celle retournée par MEMBER) (defun trunc (expr lst) (cond ((not (member expr lst)) lst) ((equal (car lst) expr) nil) (T (cons (car lst) (trunc expr (cdr lst)))) ) ) ;;; Fonction principale (defun c:clean_poly (/ ent e_lst p_lst vtx1 vtx2) (while (not (setq ent (car (entsel "\nSélectionnez une polyligne: "))) ) ) (setq e_lst (entget ent)) (cond ((= "LWPOLYLINE" (cdr (assoc 0 e_lst))) (setq p_lst (vl-remove-if-not '(lambda (x) (or (= (car x) 10) (= (car x) 40) (= (car x) 41) (= (car x) 42) ) ) e_lst ) e_lst (vl-remove-if '(lambda (x) (member x p_lst) ) e_lst ) ) (if (= 1 (cdr (assoc 70 e_lst))) (while (equal (car p_lst) (assoc 10 (reverse p_lst))) (setq p_lst (reverse (cdr (member (assoc 10 (reverse p_lst)) (reverse p_lst) ) ) ) ) ) ) (while p_lst (setq e_lst (append e_lst (trunc (assoc 10 (cdr p_lst)) p_lst)) p_lst (member (assoc 10 (cdr p_lst)) (cdr p_lst)) ) ) (entmod e_lst) ) ((and (= "POLYLINE" (cdr (assoc 0 e_lst))) (zerop (logand 240 (cdr (assoc 70 e_lst)))) ) (setq e_lst (cons e_lst nil) vtx1 (entnext ent) vtx2 (entnext vtx1) ) (while (= (cdr (assoc 0 (entget vtx1))) "VERTEX") (if (= (cdr (assoc 0 (entget vtx2))) "SEQEND") (if (or (not (equal (assoc 10 (entget vtx1)) (assoc 10 (last (reverse (cdr (reverse e_lst))))) ) ) (zerop (logand 1 (cdr (assoc 70 (last e_lst))))) ) (setq e_lst (cons (entget vtx1) e_lst)) ) (if (not (equal (assoc 10 (entget vtx1)) (assoc 10 (entget vtx2))) ) (setq e_lst (cons (entget vtx1) e_lst)) ) ) (setq vtx1 vtx2 vtx2 (entnext vtx1) ) ) (setq e_lst (reverse (cons (entget vtx1) e_lst))) (entdel ent) (mapcar 'entmake e_lst) ) (T (princ "\nEntité non valide.")) ) (princ) ) [Edité le 6/7/2006 par (gile)]

Pour Bonuscad, j'ai oublié de préciser : dans le cas d'une polyligne "close" (70 . 1), sinon, la superposition des premier et dernier sommets est conservée. J'en ai profité pour "bétonner" un peu en traitant uniquement la liste des codes 10 40 41 et 42, au cas où la liste entget ne serait pas dans l'ordre "classique". J'édite le code ci-dessus

Je le fais aussi pour moi, et je partage. De même qu'il n'y a toujours pas de réseau hélicoïdal alors que ce type commande est plutôt facile à développer.

Salut, Il me semble qu'il y a deux erreurs, celle qui provoque le lancement de ta routine d'erreur c'est : (vla-put-activeucs (vla-get-activedocument (vlax-get-acad-object)) scu_init) (vla-delete scu_init) J'avais précisé ici (réponse 7 deuxième page) : Ensuite dans ta redéfinition de *error*, tu fais (command "_.undo" "_b") ce qui démarre un nouveau groupe undo au lieu de fermer celui qui est ouvert. Sinon ta gestion des erreurs ne restaure pas le SCU initial par exemple, je disais qu'en règle générale la fin de la routine de gestion d'erreur et de la routine principale sont semblables, tu pourrais par exemple glisser (END_PRG_ERR ) à la fin de ta routine de gestion d'erreur.

Il reste un petit truc à modifier, la boucle ne prend pas en compte le (ou les)dernier(s) sommet(s) s'ils ont été superposé(s) sur le premier. Je répare ça ce soir.

Tout simplement : (vla-delete scu_init) Attention - scu_init = le nom de la variable, pas : "scu_init" le nom du SCU - le SCU ne pas être actif sinon, impossible de le supprimer. [Edité le 4/7/2006 par (gile)]

Ce qui équivaut à nommer le SCU courant, en vlisp : (if (= "" (getvar "UCSNAME")) (setq scu_init (vla-add (vla-get-UserCoordinateSystems (vla-get-ActiveDocument (vlax-get-acad-object)) ) (vlax-3d-point (trans '(0 0 0) 1 0)) (vlax-3d-point (trans '(1 0 0) 1 0)) (vlax-3d-point (trans '(0 1 0) 1 0)) "SCU_init" ) ) (setq scu_init (vla-get-ActiveUCS (vla-get-ActiveDocument (vlax-get-acad-object)) ) ) )

Peut-être est-ce encore une différence en Vlisp entre les versions 2000 et les suivantes, mais je confirme ce que dit Bred, il faut que le SCU courant soit nommé pour que (vla-get-activeucs (vla-get-activedocument (vlax-get-acad-object))) ne retourne pas le message d'erreur indiqué Extrait de l'aide (2007) pour ActiveUCSProperty Quant au lien que tu donnes, il me semble avoir compris qu'il s'agit de l'utilisation de matrices pour faire quelque chose d'équivalent à la fonction TRANS (mais mon anglais est à peine moins mauvais que mes connaissances en calcul matriciel).

Suite à ce message, je modifie Res_hel pour y ajouter un option "Référence" dans la spécification de l'angle décrit ou entre les éléments.

Je crois que j'avais lu un peu vite le message, quand tu parles de "référence", c'est bien pour l'angle de référence, comme dans la commande rotation ? Je modifie Res_hel dans ce sens, merci pour la suggestion. [Edité le 4/7/2006 par (gile)]