[Résolu] Lisp modifications d'attributs et hachures

[Glead]

Bonjour,

 

je viens vous demander un peu d'aide, j'ai pas mal cherché sur le net et sur le forum la réponse a mes questions mais j'ai rien trouvé de concluent... J'ai aussi lu quelques documents pour débuter en Lisp mais c'est loin d'être suffisant pour pouvoir commencer a taper mon code.

 

J'aimerais crée un code qui

 

1 - Isoler un calque (contenant uniquement des textes)

1.1 - Règle l'inclinaison automatiquement des textes avec une valeur donnée (380g)

 

2 - Isoler un calque (contenant uniquement des polylignes fermées)

2.1 - Sélectionner tout les objets du calque

2.2 - Affecter une hachures donnée à chaque polyligne

 

J'ai trouvé se bout de Lisp sur le site de Gile qui permet une sélection par calque

;; Sélection par calque
(defun c:ssl (/ ss ent)
 (and
   (or
     (and
(setq ss (cadr (ssgetfirst)))
(= 1 (sslength ss))
(setq ent (ssname ss 0))
     )
     (and
(sssetfirst nil nil)
(setq ent (car (entsel)))
     )
   )
   (sssetfirst nil (ssget "_X" (list (assoc 8 (entget ent)))))
 )
 (princ)
)

 

C'est bien le ssname qui correspond au nom du claque voulu ?

 

Merci d'avance pour votre aide !

 

Je reste très proche du sujet, si vous avez besoin de précision n'hésitez pas!

[Tramber]

1 - apriori ne sert à rien

2 - idem

1.1 - selectionner tous les textes (d'un calque ou plusieurs ou aucun en particulier) et facile. En changer l'inclinaison aussi.

2.1 - mouais. Dis nous ce que tu veux selectionner une fois pour toute en termes de calques parce que ca n'est pas clair. En terme d'objets c'est compris.

2.2 - il faudra penser à filtrer les polylignes fermées et aussi à gérer les erreurs en fabrication de hachures. Indiquer si celles-ci seront sur le calque de la poly, etc.

 

Bref, il faudrait demander deux lisps séparément et un peu plus clairement en terme de selection pour apprendre.

Modifié le 22 février 2016 par Tramber
Déplacement du sujet

[Glead]

En faite je dois mettre en forme un export de plan de cadastre pour qu'il soit aux normes et comme c'est quelque chose que je dois faire quotidiennement pour plusieurs fichiers j'aurais aimé automatiser cette routine.

 

J'ai donc deux calques nommés 01139 et 01219 qui contiennent uniquement du texte que je dois incliner à 380g

 

J'ai 5 calques nommés 01232, 01321, 01211, 01251, 01252 composé uniquement de polylignes fermées auquel je dois intégrer des hachures qui sont différentes pour chaque calque

 

Manuellement se n'est pas compliqué mais ça prend vite du temps

 

Est-ce que c'est un peu plus clair ?

 

Merci de ton aide

 

EDIT : Par contre j'ai vu personne faire le même type de transformation de mise en page avec du Lisp, je me demande donc si c'est bien de ça dont j'ai besoin ?

 

(setq sel1 (ssget '((-4 . "<OR")(8 . "01139")(8 . "01219")(-4 . "OR>"))))

[Glead]

Rebonjour,

 

Je viens juste chercher quelques précisions pour pas trop me perdre dans l'écriture de mon code...

 

Pour crée les hachures des polylignes du calques 01323 par exemple :

 

1 Isolement du calque 01323

2 Sélection des polylignes

3 Lancer l'outil hachure (par contre comment faire pour paramétrer les variables de l'outil pour ne pas devoir tout redéfinir à chaque utilisation ?)

4 Application des hachures aux polylignes

5 Libérer le calque 01323

 

Si quelqu'un peut m'éclairer ?

 

Cordialement

[DenisHen]

Bonjour Glead,

 

Petite question, les hachures sont dans le même calque que les polylignes fermées ?

 

Si oui, ce sera difficile de sélectionner la polyligne puisqu'elle sera créée après, donc, dessus. Il faudra donc prévoir un "OrdreTrace".

 

Si non, quel sera le nom de ce calque ?

 

Et quelle type de hachures ? Des "Solides" ?

 

En tous cas :

 

1. sélectionner toutes tes lwpolyline du calque concerné avec un ssget,

2. fouiller l'ensemble de la sélection avec un while,

3. créer le calque contenant les hachures s'il n'existe pas,

4. créer la hachure avec un command,

5. sortir du while.

 

Peut-être un foreach pour faire les 5 calques différents.

 

Denis...

[Glead]

Les hachures doivent si possible rester dans le même calque que les polylignes, au besoin on peut en crée un nouveau !

 

Si oui, ce sera difficile de sélectionner la polyligne puisqu'elle sera créée après, donc, dessus. Il faudra donc prévoir un "OrdreTrace".

 

Et quelle type de hachures ? Des "Solides" ?

 

Denis...

 

Les polylignes existent déjà dans le calque, mais même si elles sont recrées et qu'elles viennent dessus la hachure c'est exactement se qu'il me faut.

 

Les hachures sont soit le motif "SOLID" soit des motifs de l'onglet "personnalisées"

 

Merci de ton aide :)

[Glead]

Bug... Désolé

[DenisHen]

Voici un petit LiSP que je viens de t'écrire...

 

Tu peut le modifier selon tes besoins...

 

(defun c:TestHach ()
 (setq n 0)
 (if (setq Select
            (ssget "_X" '((0 . "LWPOLYLINE") (8 . "01323")))
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent)
           n    (1+ n)
     ) ;_ Fin de setq
     (if (not (tblsearch "layer" "01323_Hach"))
       (command "-calque" "n" "01323_Hach" "")
       (setvar "clayer" "01323_Hach")
     ) ;_ Fin de if
     (command "_-hatch" "s" ent "" "")
   ) ;_ Fin de while
 ) ;_ Fin de if
 (if (setq Select (ssget "_X" '((0 . "HATCH")))) ;_ Fin de setq
   (command "ordretrace" Select "" "ar" "")
 ) ;_ Fin de if

 (princ)
)

 

Tu peut aussi faire un foreach pour boucler sur une liste de calque...

 

Denis...

[Glead]

Voici un petit LiSP que je viens de t'écrire...

 

Tu peut le modifier selon tes besoins...

 

(defun c:TestHach ()
 (setq n 0)
 (if (setq Select
            (ssget "_X" '((0 . "LWPOLYLINE") (8 . "01323")))
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent)
           n    (1+ n)
     ) ;_ Fin de setq
     (if (not (tblsearch "layer" "01323_Hach"))
       (command "-calque" "n" "01323_Hach" "")
       (setvar "clayer" "01323_Hach")
     ) ;_ Fin de if
     (command "_-hatch" "s" ent "" "")
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ Select)
 (princ)
)

 

Tu peut aussi faire un foreach pour boucler sur une liste de calque...

 

Denis...

 

Wouaw !! Sa marche parfaitement ! Merci beaucoup !!

 

(command "_-hatch" "P" "VIGNE" "1" "0" "s" ent "" "")

 

Voilà la variante pour choisir le motif de la hachure

 

Je m'attaque au foreach maintenant

[DenisHen]

Content d'avoir rendu service...

 

Pour les hachures "Vigne", remplace la ligne

(command "_-hatch" "s" ent "" "")

par la ligne

(command "_-hatch" "p" "vigne" 1.00 0.00 "s" ent "" "")

Sachant que 1.00 est la taille et que 0.00 est la rotation.

 

Voilà...

[-Olivier-]

Bonjour Glead,

 

Avec ceci :

(command "_-hatch" "P" "nom_du_motif" "" "" "s" ent "" "")

 

Pour la sélection, j'aurai ajouté un filtre sur le bit 70 pour ne sélectionner que les polylignes fermées.

 

(ssget "_X" '((0 . "LWPOLYLINE") (8 . "01323") (70 . 1)))

 

Olivier

[DenisHen]

Glead : tu peut ajouter

(if (setq Select (ssget "_X" '((0 . "HATCH")))) ;_ Fin de setq
   (command "ordretrace" Select "" "ar" "")
 ) ;_ Fin de if

après le "_ Fin de if" pour passer les hachures en arrière plan

 

Olivier : effectivement, tu as raison...

[Glead]

Merci pour vos réponses !

 

Pour la fonction foreach le principe c'est bien de crée une liste générale (dans mon cas la sélection de toutes les ploylignes de tout les calques à éditer) puis avant de lancer chacune des fonctions de création de hachures filtrer la liste général ?

 

Ne peut-on pas lancer les sélections et la création des hachures pour chaque calque les un après les autres dans le même fichier ?

[Tramber]

(command "-hachures" "p" "ANGLE" 1.0 0 ""); pour configurer la prochaine intervention
(setq sel(ssget "X"(list(cons 0 "LWPOLYLINE")(cons 8 "01323")(cons 70 1))))
(setq cont 0)
(repeat(sslength sel)
 (setq entite(ssname sel cont))
 (command "-hachures" "S" entite  "" "")
 (setq cont(1+ cont))
 )

 

Le temps que je boive mon café et cherche un peu à taper ma contribution toute simple vous avez fait plein de messages !

[Tramber]

Ne peut-on pas lancer les sélections et la création des hachures pour chaque calque les un après les autres dans le même fichier ?

(command "-hachures" "p" "ANGLE" 1.0 0 ""); pour configurer le style de la prochaine intervention

(defun mafonc(calq /)
 (setvar "CLAYER" calq)
 (setq sel(ssget "X"(list(cons 0 "LWPOLYLINE")(cons 8 calq)(cons 70 1))))
 (setq cont 0)
 (repeat(sslength sel)
   (setq entite(ssname sel cont))
   (command "-hachures" "S" entite  "" "")
   (setq cont(1+ cont))
   ))

(mafonc "0123")
(mafonc "0124")
(mafonc "0125")
(mafonc "0126")

Pourrait fonctionner.

Sans vérifier les calques toutefois ici. Je file, j'ai du boulot.

[Glead]

(command "-hachures" "p" "ANGLE" 1.0 0 ""); pour configurer le style de la prochaine intervention

(defun mafonc(calq /)
 (setvar "CLAYER" calq)
 (setq sel(ssget "X"(list(cons 0 "LWPOLYLINE")(cons 8 calq)(cons 70 1))))
 (setq cont 0)
 (repeat(sslength sel)
   (setq entite(ssname sel cont))
   (command "-hachures" "S" entite  "" "")
   (setq cont(1+ cont))
   ))

(mafonc "0123")
(mafonc "0124")
(mafonc "0125")
(mafonc "0126")

Pourrait fonctionner.

Sans vérifier les calques toutefois ici. Je file, j'ai du boulot.

 

Merci à toi !

 

Il y a quand même un problème avec ton Lisp pour mon application, j'ai pas les mêmes paramètres de hachures dans tout les calques et comme j'ai pu comprendre ici il reprend la même commande hachure pour les différents calques.

 

Par contre ton approches est très intéressante !

 

En tout cas vos réponses mon bien motivé a approfondir le sujet :D

[DenisHen]

(defun mafonc(calq /)
 (setvar "CLAYER" calq)
 (setq sel(ssget "X"(list(cons 0 "LWPOLYLINE")(cons 8 calq)(cons 70 1))))
 (setq cont 0)
 (repeat(sslength sel)
   (setq entite(ssname sel cont))
   (command "-hachures" "S" entite  "" "")
   (setq cont(1+ cont))
   ))
(defun c:HachPolyCalq ()
(command "-hachures" "p" "ANGLE" 1.0 0 "")
(mafonc "0123")
(command "-hachures" "p" "Vigne" 1.0 0 "")
(mafonc "0124")
(command "-hachures" "p" "Vigne" 1.0 100 "")
(mafonc "0125")
(command "-hachures" "p" "ANGLE" 1.0 100 "")
(mafonc "0126")
)

 

En gros, tu défini le type de hachure pour les prochaines commandes "hachures".

 

Je ne l'ai pas testé mais je pense que ça devrait fonctionner...

 

Bon, je file aussi, pour la même raison...

[Glead]

Il me reste à apprendre... Je teste ça de suite !

[bonuscad]

Bonjour,

 

Je vais donner un autre exemple (qui sera à adapter...)

 

Que fait celui-ci?

Il hachure chaque polyligne fermée, mais pour chaque polyligne il va chercher le segment le plus grand afin de régler l'angle des hachures par rapport à celui-ci.

Par exemple si tu règle comme il faut pour le motif "vigne", tu pourras obtenir a ce que la hachure s'aligne sur le plus grand côté de la parcelle, ce qui donne un meilleur rendu final que d'avoir les hachures toutes dans le même sens.

 

(defun c:multi_hatch-45 ( / js n model_hatch scale_hatch ang_hatch ent dxf_ent lst_pt lst_d where alpha)
 (setq js (ssget '((0 . "LWPOLYLINE") (-4 . "<AND") (-4 . "&") (70 . 1) (-4 . "AND>"))))
 (cond
   (js
     (setq
       n -1
       model_hatch (getvar "HPNAME")
       scale_hatch (getvar "HPSCALE")
       ang_hatch (getvar "HPANG")
     )
     (setvar "HPNAME" "ANSI31")
     (setvar "HPSCALE" (* (getvar "HPSCALE") (getvar "DIMSCALE")))
     (repeat (sslength js)
       (setq
         ent (ssname js (setq n (1+ n)))
         dxf_ent (entget ent)
         lst_pt (mapcar '(lambda (x) (trans x ent 0)) (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) dxf_ent)))
         lst_d (mapcar 'distance lst_pt (cons (last lst_pt) lst_pt))
         where (- (length lst_pt) (length (member (apply 'max lst_d) lst_d)))
         alpha (angle (if (zerop where) (last lst_pt) (nth (1- where) lst_pt)) (nth where lst_pt))
       )
       (setvar "HPANG" (angle (trans '(0 0 0) 0 1) (trans (polar '(0 0 0) alpha scale_hatch) 0 1)))
       (command "_.HATCH" "" "" "" ent "")
     )
     (setvar "HPNAME" model_hatch)
     (setvar "HPSCALE" scale_hatch)
     (setvar "HPANG" ang_hatch)
   )
   (T (princ "\nAucune LWPOLYLINE fermée trouvé !"))
 )
 (princ)
)

[Glead]

Wouaw, je parle à des passionnés ici !

 

Beau boulot Bonuscad, par contre c'est très vite trop compliqué pour moi... Je vais rester sur des fonctions les plus basiques possible pour pouvoir éditer le code selon mes besoins et apprendre au passage.

 

Je touilles toutes vos réponses et je posterais mon LISP final pour se qui en aurait besoin et si vous avez des remarques.

[Glead]

Voilà se que je voulais faire pour incrémenter plusieurs calques :

 

(defun c:HACH500 ()
 (setq n 0)
 (if (setq Select
            (ssget "_X" '((0 . "LWPOLYLINE") (8 . "01211")(70 . 1)))
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent)
           n    (1+ n)
     ) ;_ Fin de setq
     (if (not (tblsearch "layer" "01211_Hach"))
       (command "-calque" "n" "01211_Hach" "")
       (setvar "clayer" "01211_Hach")
     ) ;_ Fin de if
     (command "_-hatch" "P" "SOLID" "s" ent "" "")
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ Select)
 (princ)
)
(setq n 0)
 (if (setq Select
            (ssget "_X" '((0 . "LWPOLYLINE") (8 . "01321")(70 . 1)))
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent)
           n    (1+ m)
     ) ;_ Fin de setq
     (if (not (tblsearch "layer" "01321_Hach"))
       (command "-calque" "n" "01321_Hach" "")
       (setvar "clayer" "01321_Hach")
     ) ;_ Fin de if
     (command "_-hatch" "P" "SOLID" "s" ent "" "")
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ Select)
 (princ)
)

 

Mais malheureusement il refuse de lire la deuxième partie... Il génère les hachures du calque 01211 et s'arrête sur un message qui ressemble à ça : <Selection set: 276a>

 

Désolé de vous embêter...

[DenisHen]

Salut Glead.

 

A la fin de ton premier (princ), il faut supprimer la parenthèse fermante à la ligne suivante (ligne 19)...

 

Personnellement, j'utiliserais ça :

defun c:Hach500 ()
 (command "-hachures" "p" "SOLID" 1.0 0 "") ;Type de hachure pour le calque qui suit
 (mafonc "01211")
 (command "-hachures" "p" "SOLID" 1.0 0 "")
 (mafonc "01232")
 (command "-hachures" "p" "SOLID" 1.0 0 "")
 (mafonc "01321")
 (command "-hachures" "p" "SOLID" 1.0 0 "")
 (mafonc "01251")
 (command "-hachures" "p" "SOLID" 1.0 0 "")
 (mafonc "01252")
) ;_ Fin de defun
(defun mafonc (calq /)
 (setvar "CLAYER" calq)
 (setq sel (ssget "X" (list (cons 0 "LWPOLYLINE") (cons 8 calq) (cons 70 1))))
 (setq cont 0)
 (repeat (sslength sel)
   (setq entite (ssname sel cont))
   (if (not (tblsearch "layer" (strcat Calq "_Hach")))
     (command "-calque" "n" (strcat Calq "_Hach") "")
     (setvar "clayer" (strcat Calq "_Hach"))
   ) ;_ Fin de if
   (command "-hachures" "S" entite "" "")
   (setq cont (1+ cont))
 ) ;_ Fin de repeat
) ;_ Fin de defun

[Tramber]

Les gars, une astuce, Etablir (dans la commande -calques), rend un calque courant tout en le créant s'il n'existe pas.

Pas besoin de tblsearch.

J'aurais dû y penser moi-même :P

[DenisHen]

Remarque judicieuse, et c'est ce que je faisais avant. En plus, cette option (établir) créé le calque s'il n'existe pas et le rend actif dans tout les cas.

 

Je ne l'avais pas vu, mais il y a un (setvar "CLAYER" calq) au début de la boucle... Totalement inutile...

 

La routine corrigée :

(defun c:Hach500 ()
 (command "-hachures" "p" "SOLID" 1.0 0 "") ;Type de hachure pour le calque qui suit
 (mafonc "01211")
 (command "-hachures" "p" "SOLID" 1.0 0 "")
 (mafonc "01232")
 (command "-hachures" "p" "SOLID" 1.0 100 "")
 (mafonc "01321")
 (command "-hachures" "p" "SOLID" 1.0 100 "")
 (mafonc "01251")
 (command "-hachures" "p" "SOLID" 1.0 100 "")
 (mafonc "01252")
) ;_ Fin de defun
(defun mafonc (calq /)
 (setq old_clayer (getvar "clayer"))
 (setq sel (ssget "X" (list (cons 0 "LWPOLYLINE") (cons 8 calq) (cons 70 1))))
 (setq cont 0)
 (repeat (sslength sel)
   (setq entite (ssname sel cont))
   (if (not (tblsearch "layer" (strcat Calq "_Hach")))
     (command "-calque" "n" (strcat Calq "_Hach") "")
     (setvar "clayer" (strcat Calq "_Hach"))
   ) ;_ Fin de if
   (command "-hachures" "S" entite "" "")
   (setq cont (1+ cont))
 ) ;_ Fin de repeat
 (setvar "clayer" old_clayer)
) ;_ Fin de defun

 

Mais le tblsearch est aussi intéressant pour d'autre "recherche"... C'est une façon d'apprentissage que j'ai reçu (ici notamment), et donc, que je transmet...

[Tramber]

Je ne l'avais pas vu, mais il y a un (setvar "CLAYER" calq) au début de la boucle... Totalement inutile...

Tu dois te tromper. J'en ai mis un en début de fonction, pas dans la boucle.

C'est parce que je ne pensais ni à tblsearch ni à Etablir.