faire passer les hachures en second plans dans un bloc

[philsogood]

Hello,

Tout est dans le titre

Je suis en train de recréer mes bibliothèques d'accessoires de tuyauterie en 2D et pour se faire je dois faire passer en arrière plan tous les hachures que ces blocs contiennent

Quelqu'un pourrait-il me donner un coup de main svp, mes connaissances du lisp ne sont pas assez étendues pour ce type d'application?

Phil

[Dinosor]

Ciao,

 

Si je comprend bien, l'idée c'est de passer ces hachures en arrière-plan sans ouvrir les blocs ? Car tu parles de lisp...

[philsogood]

tou a fait...

j'ai plusieurs ventaines de blocs ou j'ai tracer des hachures, positionnes sur ces blocs, problème : en assemblent les hachures aux blocs, les hachures passent devant!!

Je souhaiterai trouver un lisp pour contrer ce phénomène et faire apsser les hachures en arrière plan

Phil

PS

(2013 toujours sous cellophane !)

, tu vas ouvrir la boite pour l'arrivée de la 2014, ou la 2014 subira le même sort que la 2013?

[Dinosor]

Re,

 

Pour le lisp, je ne vais pas pouvoir t'aider là, désolé. :(

Pour la version j'attend effectvement la 2014, j'ai encore reçu dernièrement la Building Design Suite en deux exemplaires, mais toujours pas ouverts ... Je pense que j'installerai la 2014 sur mon deuxième poste (le poste Lumion), mais à la base je reste encore sous cette version 2011 en 32 bits. Ceci toujours pour une question de compatibilité avec ma Summasketch... :D Dinosaure pas pour rien... hi,hi...

 

J'espère que tu va trouver un bon lisp pour ce que tu demandes !

 

Bonne. B)

[Dinosor]

Il faudrait peut-être s'inspirer du lisp nommé PAT, de Patrick. Celui-ci, semble t'il, permet de changer un attribut d'un bloc dans plusieurs fichiers, sans avoir à les ouvrir. Les "lispeurs" ont peut-être une parade pour affecter les hachures et les mettre en arrière-plan plutôt que de modifier un attribut ? :huh:

[Patrick_35]

Salut

 

Essaye ceci pour voir

(defun c:drw(/ blo doc ent)
 (setq doc (vla-get-activedocument (vlax-get-acad-object)))
 (vla-startundomark doc)
 (vlax-for blo (vla-get-blocks doc)
   (and (eq (vla-get-islayout blo) :vlax-false)
     (vlax-for ent blo
(or (eq (vla-get-objectname ent) "AcDbHatch")
  (progn
    (vla-copy ent)
    (vla-delete ent)
  )
)
     )
   )
 )
 (vla-endundomark doc)
 (princ)
)

 

@+

[lecrabe]

Hello P35

 

Je viens de faire un test rapide sur MAP 2013 32 bits sous Win XP Pro

Ta routine DRW marche nickel-chrome ! MERCI !!

 

Je suis impressionne et etant un gros Nul en Lisp/VLisp

serait il possible que tu nous expliques en quoi un simple

(vla-copy ent) + (vla-delete ent)

peut mettre les hachures en arriere plan les objets contenus dans "ent" ???

 

SVP serait il possible d'avoir une routine comparable qui mettrait en arriere plan

les objets "Nettoyer" (WipeOut en fait)

 

Encore Merci pour ton travail passe, present et futur, lecrabe

[(gile)]

Salut,

 

Le LISP de Patrick_35 ne met pas les hachures en arrière, il met mes autres entités en avant (en fait, une copie de ces entités). ;)

[lecrabe]

Hello Gilles

 

Ah OUI Excellent la ruse !

 

lecrabe

[VDH-Bruno]

Bonsoir,

 

Je suis impressionne et etant un gros Nul en Lisp/VLisp

serait il possible que tu nous expliques en quoi un simple

(vla-copy ent) + (vla-delete ent)

peut mettre les hachures en arriere plan les objets contenus dans "ent" ???

J’espère que Patrick_35 ne m’en voudrat pas si je réponds à sa place, en fait si on veut être puriste ce n’est pas les hachures qui passe en arrière plan, mais plutôt les autres objets qui passent en avant plan en modifiant leurs ordres de création dans la base de données du dessin .

 

En fait le (vla-copy ent) + (vla-delete ent), recrée toutes les entités dans les définitions de bloc qui ne sont pas des hachures en effaçant leurs définitions d’origine…Ce qui les rendent postérieurs aux hachures et les positionnes en avant plan.

 

 

SVP serait il possible d'avoir une routine comparable qui mettrait en arriere plan

les objets "Nettoyer" (WipeOut en fait)

 

Sur le même principe, il suffit dans le code de remplacer l’expression :

(eq (vla-get-objectname ent) "AcDbHatch")

par:

(eq (vla-get-objectname ent) "AcDbWipeout")

Et cela devrait fonctionner..

 

(defun c:drw-AcDbWipeout ()
 (vlax-for blo	(vla-get-blocks (vla-get-activedocument (vlax-get-acad-object)))
   (and (eq (vla-get-islayout blo) :vlax-false)
 (vlax-for ent blo
   (or (eq (vla-get-objectname ent) "AcDbWipeout")
       (progn (vla-copy ent) (vla-delete ent))
   )
 )
   )
 )
 (princ)
)

 

A+

 

EDIT: Visiblement j'ai fait de l'écho à (gile)...

[Patrick_35]

Hello

 

J’espère que Patrick_35 ne m’en voudrat pas si je réponds à sa place

Que nenni

 

ce n’est pas les hachures qui passe en arrière plan, mais plutôt les autres objets qui passent en avant plan en modifiant leurs ordres de création dans la base de données du dessin .

 

En fait le (vla-copy ent) + (vla-delete ent), recrée toutes les entités dans les définitions de bloc qui ne sont pas des hachures en effaçant leurs définitions d’origine…Ce qui les rendent postérieurs aux hachures et les positionnes en avant plan.

C'est exactement cela :D

 

Juste une précision

Si on souhaite que les hachures + les wipeouts en arrière plan, on remplace

 

(eq (vla-get-objectname ent) "AcDbHatch")

Ou/et

(eq (vla-get-objectname ent) "AcDbWipeout")

par

(member (vla-get-objectname ent) '("AcDbHatch" "AcDbWipeout"))

 

@+

[philsogood]

Hello

Merci Patrick ton lisp marche super bien... dommage qu'il soit en V-lisp car il m'est cimpréhensible (je n'ai que quelques bases en lisp)

Super Résultat (et 5h de galère de gagner!)!

Phil

[Patrick_35]

dommage qu'il soit en V-lisp car il m'est cimpréhensible (je n'ai que quelques bases en lisp)

 

Oui, mais dans ce besoin précis, on peut voir ce que peut apporter de plus le vlisp

 

Juste un synopsis pour faire la comparaison de ce qui est possible en Autolisp et vlisp

 

En Autolisp

1) Parcourir la liste des calques pour les déverrouiller et mémoriser ceux qui le sont

2) Parcourir la table des blocs

a) Pointer sur la dernière entité créée (entlast)

b) Insérer un bloc en le décomposant (command -.insert *+nom ...)

c) Créer un jeu de sélection/liste depuis mon pointeur pour récuperer les objets décomposés (entnext (entlast))

d) Copier les objets du jeu de sélection tout en enlevant les hachures (command "_.copy"...)

f) Effacer les objets du jeu de sélection tout en enlevant les hachures (command "_.erase"...)

g) Créer un jeu de sélection/liste depuis mon pointeur des objets copiés + hachures ignorées auparavant (entnext (entlast))

h) Créer le bloc (entmake ...)

3) Verrouiller les calques qui l'étaient

 

En Vlisp

1) Parcourir la table des blocs

a) Parcourir le bloc

b) Copier l'objet du bloc

c) Effacer l'objet du bloc

 

C'est bien plus simple ;)

 

@+

[philsogood]

Encore un langage à apprendre...

Phil :mellow:

[VDH-Bruno]

Encore un langage à apprendre...

Phil :mellow:

 

Non pas forcément, du moment que tu ne sors n’y d’AutoCAD et n’y du document actif, je n’ai pas en tête d’exemple de codes Vlisp qui ne puissent être codé en AutoLISP classique.

 

Les méthodes et propriétés Visual Lisp peuvent être vu comme des bibliothèques de fonctions prédéfinies qui permettent comme dans ce cas un code plus directe…

 

Pour l’exemple un équivalent LISP un peu moins partisan que le cheminement proposé précédemment ;) :

 

(defun c:drwHatch (/ blk e lsthatch lstent dxf)
 (while (setq blk (tblnext "BLOCK" (null blk)))
   (if (wcmatch (setq blk (cdr (assoc 2 blk))) "~'**")
     (progn (setq blk      (entget (tblobjname "BLOCK" blk))
                  e        (cdr (assoc -2 blk))
                  lsthatch nil
                  lstent   nil
            )
            (while e
              (if (= "HATCH" (cdr (assoc 0 (setq dxf (entget e)))))
                (setq lsthatch (cons dxf lsthatch))
                (setq lstent (cons dxf lstent))
              )
              (setq e (entnext e))
            )
            (and lsthatch
                 (entmake blk)
                 (mapcar 'entmake (append (reverse lsthatch) (reverse lstent)))
                 (entmake '((0 . "ENDBLK")))
            )
     )
   )
 )
 (princ)
)

 

A+

Modifié le 12 février 2013 par VDH-Bruno

[philsogood]

Merci Bruno pour cette version pur lisp q'il me reste à potasser!

Phil

[Nico19]

Bonjour à tous,

 

Merci pour ces programmes, mais je viens de me rendre compte (un peu tard :( ) que lors de l'utilisation du lisp drw-AcDbWipeout avec Autocad 2011 sur ma bibliothèque composée de blocs contenant entre autres des paramètres d'étirement, de rotation et d'inversion, ces paramètres ne fonctionnent plus correctement. Pour être plus précis, il ne fonctionne plus que sur le "nettoyer" en lui même (ce qui est balot...).

Quelqu'un aurait-il une solution ?

 

Nicolas

 

Edit : En fait, il semblerait que ce soit les actions liées aux paramètres qui fonctionnent mal, car le paramètre d'alignement, qui n'appelle pas d'action, fonctionne à merveille...

[Chloé17]

Bonjour,

 

Je relance le sujet

J'ai chargé le lisp indiqué en début de post par Patrick

En lançant la commande DRW, voilà ce que j'ai comme message :

 

Commande: DRW

; erreur: Erreur Automation Objet effacé

 

Mon idée est de mettre les hachures de plusieurs blocs (une 50aine) à sélectionner (ou de tous les blocs du dessin) en arrière plan

 

(Version Autocad dans ma signature)

 

Merci,

Chloé

[Fraid]

Bonjour, et bienvenu sur Cadxp :D

 

A tu vérifié si les objets sont dans un calque verrouillé?

[Chloé17]

Bonjour,

 

Non, les objets ne sont pas sur un calque verrouillé, je n'ai même pas pu sélectionner d'objet, c'est directement au lancement de la commande que j'ai ce message.

[(gile)]

Salut,

 

Le LISP de (feu) Patrick_35 traite toutes les hachures contenues dans des blocs sans demander de sélection.

 

Je propose deux commandes :

- H2B qui place toutes les hachures de tous les blocs en arrière plan (comme la routine de Patrick_35) ;

- SH2B qui place les hachures des blocs sélectionnés en arrière plan.

Les deux commandes utilise l'ordre de tracé (au lieu de copier/effacer) les routines sont extraites des bibliothèques AutomationHelpers et Sortents en bas de cette page.

 

(vl-load-com)
(or *acad* (setq *acad* (vlax-get-acad-object)))
(or *acdoc* (setq *acdoc* (vla-get-ActiveDocument *acad*)))
(or *blocks* (setq *blocks* (vla-get-Blocks *acdoc*)))

;; gc:GetItem
;; Retourne le vla-object de l'item s'il est présent dans la collection (ou nil)
;;
;; Arguments
;; col : la collection (vla-object)
;; name : le nom de l'objet (string) ou son indice (entier)

(defun gc:GetItem (col name / obj)
 (vl-catch-all-apply
   (function (lambda () (setq obj (vla-Item col name))))
 )
 obj
)

;; gc:GetObject
;; Retourne un objet (Custom Object) du dictionnaire d'après son nom (ou nil)
;; Arguments
;; dict : le dictionnaire (vla-object)
;; name : le nom de l'objet (string)

(defun gc:GetObject (dict name / obj)
 (vl-catch-all-apply
   (function (lambda () (setq obj (vla-GetObject dict name))))
 )
 obj
)

;; gc:GetSortentsTable
;; Retourne la table d'ordre de tracé du block record (bloc ou espace)
;;
;; Argument
;; block : le block record
;; 
;; Fonctions requises :
;; - gc:GetObject (gc_AutomationHelpers.lsp))
(defun gc:GetSortentsTable (block / sort)
 (cond
   ((gc:GetObject (vla-GetExtensionDictionary block) "ACAD_SORTENTS"))
   ((vla-AddObject (vla-GetExtensionDictionary block) "ACAD_SORTENTS" "AcDbSortentsTable"))
 )
)

;; gc:MoveToBottom
;; Place les objets en arrière (draworder)
;;
;; Argument
;; blk : le block record auquel appartiennent les objets
;; olst : liste des objets à placer en arrière (vla-objects)
(defun gc:MoveToBottom (blk olst)
 (vlax-invoke (gc:GetSortentsTable blk) 'MoveToBottom olst)
)

;; gc:MoveHatchtoBottom
;; Place les hachures en arrière (draworder)
;;
;; Argument
;; blk : le block record auquel appartiennent les objets
(defun gc:MoveHatchtoBottom (blk / lst)
 (vlax-for obj	blk
   (if	(= (vla-get-ObjectName obj) "AcDbHatch")
     (setq lst (cons obj lst))
   )
   (if	lst
     (gc:MoveToBottom blk lst)
   )
 )
)

;; Commande H2B
;; Place toutes les hachures dans tous les blocs à l'arrière plan
(defun c:H2B ()
 (vlax-for blk	*blocks*
   (if	(= (vla-get-IsLayout blk) :vlax-false)
     (gc:MoveHatchtoBottom blk)
   )
 )
 (vla-Regen *acdoc* acAllViewports)
 (princ)
)

;; Commande SH2B
;; Place les hachures des les blocs sélectionnés à l'arrière plan
(defun c:SH2B (/ ss br blk)
 (if (ssget '((0 . "INSERT")))
   (progn
     (vlax-for	br (setq ss (vla-get-ActiveSelectionSet *acdoc*))
(if (setq blk (vla-Item *blocks* (vla-get-Name br)))
  (gc:MoveHatchtoBottom blk)
)
     )
     (vla-Delete ss)
     (vla-Regen *acdoc* acActiveViewport)
   )
 )
 (princ)
)

[lecrabe]

Hello Gilles

 

Est ce que tu utilises la MEME Technique que notre regrette Patrick_35 ?

- ReCreation de toutes les entites NON Hatch

- Suppression des anciennes

- Comme cela, on est SUR d'avoir les Hachures EN DESSOUS !

 

LA SANTE, Bye, lecrabe "triste"

Automne 2020, la retraite

[(gile)]

Non, j'utilise l'ordre de tracé (object AcDbSortentsTable stocké dans le dictionnaire d'extension des espaces et définition de blocs).

[Chloé17]

Le LISP de (feu) Patrick_35

 

Ooh je suis désolée d'apprendre cela…

 

Je propose deux commandes :

 

 

Merci pour ces commandes

Alors,H2B me met le même message que pour le LISP de Patrick, et SH2B ne rapport pas d'erreur, me propose de faire une sélection, ce sont bien des blocs qui sont sélectionnés, mais une fois validé et régénéré, les blocs n'ont pas changé…

 

Chloé

[Fraid]

Bonjour,

 

Je vois que tu possède Covadis,

Le problème vient peut etre de la.

Je ne suis pas un spécialiste de ce dernier, fait une recherche dans ce sens

Je sait qu'il existe une commande du genre CONVERTCOVADIS pour convertir les objets.