Polyligne fermée ou pas.

[DenisHen]

Bonjour à tous.

 

Je suis en train de faire un petit lisp qui me hachurera toutes les polylignes (des LWPOLYLINE) fermées d'un calque.

 

Mais pour ce faire, je cherche à savoir si chaque polyligne est fermée.

 

Si quelqu'un a une astuce, un conseil... Je suis preneur...

 

Denis...

[sbosarl]

bonjour,

pour moi ce serais la paire en dxf (70 ..) qu il faudrait exploiter

(70 0) pour ouvert et (70 1)pour fermé

[(gile)]

Salut,

 

Pour savoir si une polyligne est fermée au sens où sa propriété "Fermé" (Closed) est vraie, tu peux, comme le dit sbosarl, vérifier dans les codes DXF que le groupe 70 a bien le bit 1, mais attention, if faut faire un comparaison bit à bit avec l'opérateur logique AND parce que le groupe 70 des polylignes ne contient pas uniquement ce bit mais aussi le bit 128 qui concerne la "génération de type de ligne". Donc (70 . 1) ou (70 . 129) = fermé et (70 . 0) ou (70 . 128) = ouvert.

(defun IsClosed (pline)
 (= 1 (logand 1 (cdr (assoc 70 (entget pline)))))
)

 

Tu peux aussi, plus simplement, utiliser getpropertyvalue avec la propriété "Closed" : 1 = fermé, 0 = ouvert :

(defun IsClosed (pline)
 (= 1 (getpropertyvalue pline "Closed"))
)

 

Ou encore, si tu utilises Visual LISP (vlaPline est de type vla-object) :

(defun IsClosed (vlaPline)
 (= (vla-get-Closed vlaPline) :vlax-true)
)

 

Mais s'il s'agit de tester si une polyligne est hachurable, il faudrait aussi considérer les polylignes "ouvertes" dont le dernier sommet est superposé au premier.

Là encore, on peut utiliser les trois méthodes :

(defun IsOverlapped (pline / elst)
 (setq elst (entget pline))
 (equal (assoc 10 elst) (assoc 10 (reverse elst)))
)

 

(defun IsOverlapped (pline)
 (equal
   (getpropertyvalue pline "Vertices" 0 "Position")
   (getpropertyvalue pline "Vertices" (fix (getpropertyvalue pline "EndParam")) "Position")
 )
)

 

(defun IsOverlapped (vlaPline / coords sdrooc)
 (setq coords (vlax-get vlaPline 'Coordinates)
       sdrooc (reverse coords)
       )
 (equal (list (car coords) (cadr coords)) (list (cadr sdrooc) (car sdrooc))
)

[DenisHen]

Bonjour à vous, et merci pour vos réponses.

 

A priori, les polylignes sont bien fermées ou ouvertes, puisque mes fichiers sont issus du cadastre.

 

Encore merci à vous...

[DenisHen]

Re.

 

Ben voilà, j'ai écris ça qui ne fonctionne pas :

(defun c:CadHachBati (/ n Select ent)
 (command "-calque" "e" "NANCAY_CADASTRE_BATI_HACH" "")
 (if (setq Select (ssget "_X" (list (cons 0 "LWPOLYLINE") (cons 8 "NANCAY_CADASTRE_BATI"))))
   (while (setq ent (ssname Select n))
     (if (= 1 (getpropertyvalue ent "Closed"))
       (progn (command "_hatch" ent "") ;
              (princ "\nHachure")
       ) ;_ Fin de progn
     ) ;_ Fin de if
     (setq n (1+ n))
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ)
) ;_ Fin de defun

AutoCAD me répond :

Commande: CADHACHBATI ; erreur: type d'argument incorrect: numberp: nil

 

Je pense qu'il me faudrait une formation chaque lundi... ;)

[DenisHen]

J'ai modifier mon lisp en ajoutant un (setq n 0) au début... Et maintenant, j'ai cette réponse là de la part d'AutoCAD :

Commande: CADHACHBATI *Incorrect*

; erreur: Fonction annulée

[(gile)]

Pour localiser une erreur, aide toi des fonctions de débogage de l'éditeur Visual LISP (section 4.5 de Introduction à AutoLISP)

 

Sinon, tu peux filtrer directement les polylignes fermées depuis ton filtre de sélection :

(setq Select (ssget "_X" (list (cons 0 "LWPOLYLINE") (cons 8 "NANCAY_CADASTRE_BATI") (cons -4 "&") (cons 70 1))))

[DenisHen]

Merci (gile), effectivement, c'est mieux.

 

Mais je pense que mon problème est dans l'écriture du (command "_hatch" elst) ou (command "_hatch" elst ""). C'est ça qui déconne, et je n'arrive pas à savoir pourquoi...?

(defun c:CadHachBati (/ n Select ent)
 (setq n 0)
 (command "-calque" "e" "NANCAY_CADASTRE_BATI_HACH" "")
 (if (setq Select (ssget "_X"
                         (list (cons 0 "LWPOLYLINE")
                               (cons 8 "NANCAY_CADASTRE_BATI")
                               (cons -4 "&")
                               (cons 70 1)
                         ) ;_ Fin de list
                  ) ;_ Fin de ssget
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent))
     (command "_hatch" elst)
     (setq n (1+ n))
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ)
) ;_ Fin de defun

[(gile)]

Quand tu utilises la fonction command pour appeler les commandes natives, tu peux faire des tests en ligne de commande pour voir les arguments (options de la commande) qu'il faut passer à la commande.

 

Essaye d'abord :

(command "_hatch")

et regarde les invites en ligne commande

Tu pourras ainsi compléter ton expression LISP au fur et à mesure...

[DenisHen]

Merci pour ton aide (gile)...

 

Je ne connaissais pas cette astuce, j'ignorais que (command "_hatch") réagissait différemment que _hatch...

 

J'ai donc suivi ton conseil, et curieusement, ça déconne toujours. Voici mon nouveau code :

(defun c:CadHachBati (/ n Select ent Obj Calq)
 (setq n 0)
 (setq Obj (entget (car (entsel "Clique une entité du calque à traiter :"))))
 (setq Calq (cdr (assoc 8 Obj)))
 (princ "\nCalq=")
 (princ Calq)
 (setq NouvCalq (strcat Calq "_HACH"))
 (command "-calque" "e" NouvCalq "")
 (if (setq Select (ssget "_X"
                         (list (cons 0 "LWPOLYLINE")
                               (cons 8 Calq)
                               (cons -4 "&")
                               (cons 70 1)
                         ) ;_ Fin de list
                  ) ;_ Fin de ssget
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent))
     (command "_hatch" "_s" elst) ; ou (command "_hatch" "_s" elst "")
     (setq n (1+ n))
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ)
) ;_ Fin de defun

 

J'ai ajouté une sélection d'entité pour le rendre plus "universel"...

[(gile)]

Tu peux regarder le petit screencast que j'ai posté ici.

[DenisHen]

Merci (gile) pour ton aide...

 

Super ton screencast. J'ai bien fais tout pareil, mais rien n'y fait, j'ai essayé (command "_hatch" "solid" elst "") et (command "_hatch" "ansi31" 1 100 ent "") qui fonctionnent tous les deux en ligne de commande... Mais rien n'y fait...

 

Je tourne en rond... Ne serait-ce pas le elst qui poserait problème ?

(defun c:CadHachBati (/ n Select ent Obj Calq)
 (setq n 0)
 (setq Obj (entget (car (entsel "Clique une entité du calque à traiter :"))))
 (setq Calq (cdr (assoc 8 Obj)))
 (princ "\nCalq=")
 (princ Calq)
 (setq NouvCalq (strcat Calq "_HACH"))
 (command "-calque" "e" NouvCalq "")
 (if (setq Select (ssget "_X"
                         (list (cons 0 "LWPOLYLINE")
                               (cons 8 Calq)
                               (cons -4 "&")
                               (cons 70 1)
                         ) ;_ Fin de list
                  ) ;_ Fin de ssget
     ) ;_ Fin de setq
   (while (setq ent (ssname Select n))
     (setq elst (entget ent))
     (command "_hatch" "solide" elst "")
     (setq n (1+ n))
   ) ;_ Fin de while
 ) ;_ Fin de if
 (princ)
) ;_ Fin de defun

[(gile)]

Quand on répond à l'invite de commande "choix des objets: " dans une expression LISP (command ...), on doit passer un nom d'entité (type ENAME) ou un jeu de sélection (type PICKSET).

 

Quand tu fais :

(command "_hatch" "solide" elst "")

quel est le type de elst ?

 

Met un point d'arrêt devant cette expression, relance ton LISP et, quand l'évaluation s'arr^te au point d'arrêt, entre les expressions suivantes dans la console :

(type Select)

(type ent)

(type elst)

[DenisHen]

M'en doutais... C'était bien ça, seul ent est un ENAME... Donc, j'ai maintenant :

(command "_hatch" "solid" ent "")

Un grand merci à toi, Ô maître (gile)... ;)