Toutes les lignes en polylignes

[atchoume]

Travaillant dans le bâtiments j'ai beaucoup de dessin d'architecte, le problème, il ne connaisse pas les polylignes pourtant si pratique pour les métré.

 

je pensais créer un programme qui transforme toutes les lignes en polylignes en jouant avec une boucle sur les entités et avec PEDIT. Le probleme c'est qu'avec de gros dessin mon ordinateur a dut. Est ce qu'il existe une autre solution

 

[(gile)]

Salut,

 

Une fois toutes les lignes récupéres avec un (ssget "_X" '((0 . "LINE"))), tu peux faire une liste (l_lst) dont chaque élément est aussi une liste contenant le nom d'entité de la ligne et les coordonnées de ses points de départ et de fin.

 

Ensuite faire une boucle pour tester si un autre élément a une extrémité commune avec le premier élément, et si c'est le cas créer une nouvelle liste (sub_lst) avec les coordonnées du premier élément plus la coordonnée de l'élément trouvé qui n'est pas commune au premier et reboucler avec les nouvelles extrémités de la nouvelle liste jusquà ce qu'il n'y ait plus d'autres ligne jointives.

Cette liste est la liste des sommets d'une polyligne à créer (avec entmake).

 

On suprime les éléments traités de l_lst et on reboucle avec le nouveau premier élément de l_lst.

 

Les lignes qui ne sont jointives à aucune autre peuvent soit être laissées en l'état, soit transformées en polylignes aussi.

 

La méthode peut sembler tortueuse, c'est celle que j'ai employée dans join_3Dpoly dont tu peux t'inspirer.

[bonuscad]

Salut,

 

Je crois que si je devait traiter des dessin volumineux, je m'attacherais dans le code à faire des filtres efficaces, quitte à faire des boucles plus que de raison.

 

En effet je pense que si tes dessins sont bien structurés, il sera par exemple plus efficace de filter tes lignes en tenant compte du calque, éventuellement du type de ligne et/ou de la couleur et j'en passe.

Ceci afin de manipuler des jeux de collections d'entités de taille raisonnable à soumettre à la commande pedit.

En plus tu éviteras des surprises de changement de propriété des lignes de départ lorsqu'elle sont jointes à d'autres (de nature différente) et conservera ainsi une hiérachie claire de tes objets.

 

Une sélection globale ne peut que mettre ta machine à genoux.

 

Voilà pour la philosophie que j'adopterais, pour le code. Je te laisse essayer de le mettre en oeuvre.

Bon courage ;)

[(gile)]

Bonuscad a complètement raison, Join3dPoly fonctionne avec une sélection faite (donc contrôlée) par l'utilisateur et pour créer une seule poly3d.

 

J'ai répondu un peu vite et en utilisant PEDIT, il n'est pas nécessaire de faire tous ces tests sur les extrémités des lignes, PEDIT s'en charge.

 

Pour me faire pardonner de t'avoir égaré sur des chemins forts tortueux, je te propose une ébauche, qui traite les lignes par calque :

 

(defun c:line2pline (/ lay n_lay ss n ent)
 (setq lay (tblnext "LAYER" T))
 (while lay
   (setq n_lay	(cdr (assoc 2 lay))
  ss	(ssget "_X" (list '(0 . "LINE") (cons 8 n_lay)))
   )
   (if	ss
     (repeat (setq n (sslength ss))
(setq ent (ssname ss (setq n (1- n))))
(if (entget ent)
  (if (= 1 (getvar "PEDITACCEPT"))
    (command "_.pedit" ent "_join" ss "" "")
    (command "_.pedit" ent "_yes" "_join" ss "" "")
  )
)
     )
   )
   (setq lay (tblnext "LAYER"))
 )
 (princ)
) 

 

[Edité le 3/6/2006 par (gile)]

[rebcao]

et en utilisant simplement EDITER polyligne avec l'option MULTIPLE ? ça ne marcherait pas ?

 

Christian

[Phane59]

Pas mal la fonction multiple j'y avait jamais fait attention. elle va etre super pratique pour mes métrés. Merci du tuyau :o

[(gile)]

Comme le sujet m'intéressait, j'ai fait une version plus aboutie.

 

À l'intérieur d'une boucle qui fait un premier jeu de sélection en filtrant les lignes par calque, on boucle sur chaque ligne (si elle n'a pas déjà été jointe à une polyligne) pour faire un autre jeu de sélection en filtrant les lignes du calque ayant les mêmes propriétés (couleur, type de ligne, épaisseur de ligne). C'est ce nouveau jeu de sélection qui est passé à PEDIT.

 

;;; L2PL - Gilles Chanteau - 04/06/06
;;; Joint en lwpolyligne toutes les lignes jointives ayant des propriétés
;;; similaires (calque, couleur, type de ligne, épaisseur de ligne)
;;; Les lignes sur les calques vérouillés ou gelés ne sont pas traitées.

;; Redéfinition de *error*

(defun L2PL_ERR	(msg)
 (if (or
(= msg "Fonction annulée")
(= msg "quitter / sortir abandon")
     )
   (princ)
   (princ (strcat "\nErreur: " msg))
 )
 (command "_.undo" "_end")
 (setvar "CMDECHO" old_echo)
 (setq	*error*	m:err
m:err nil
 )
 (princ)
)

;; C:L2PL

(defun c:l2pl (/ old_echo lay ss1 ss2 ss3 n ent lst col lt el)

 (setq	m:err	 *error*
*error*	 p2pl_err
old_echo (getvar "CMDECHO")
 )
 (command "_.undo" "_begin")
 (setvar "CMDECHO" 0)
 ;; boucle sur chaque calque
 (setq lay (tblnext "LAYER" T))
 (while lay
   (if	(zerop (logand 5 (cdr (assoc 70 lay))))
     ;; si le calque n'est ni vérouillé ni gelé
     (progn
(setq
  ss1 (ssget "_X"
	     (list (cons 0 "LINE") (cons 8 (cdr (assoc 2 lay))))
      )
  ss3 (ssadd)
)
(if ss1
  ;; boucle sur chaque ligne (si le calque en contient)
  (repeat (setq n (sslength ss1))
    (setq ent (ssname ss1 (setq n (1- n))))
    (if	(setq l_ent (entget ent))
      ;; si la ligne n'a pas déjà été traitée
      (progn
	(if (not (setq col (cdr (assoc 62 l_ent))))
	  (setq col 256)
	)
	(if (not (setq lt (cdr (assoc 6 l_ent))))
	  (setq lt "BYLAYER")
	)
	(if (not (setq el (cdr (assoc 370 l_ent))))
	  (setq el -1)
	)
	;; sélection de toutes les lignes du calque de mêmes propriétés
	(setq ss2 (ssget "_X"
			 (list (cons 0 "LINE")
			       (cons 8 (cdr (assoc 2 lay)))
			       (cons 62 col)
			       (cons 6 lt)
			       (cons 370 el)
			 )
		  )
	)
	;; création de la polyligne
	(if (= 1 (getvar "PEDITACCEPT"))
	  (command "_.pedit" ent "_join" ss2 "" "")
	  (command "_.pedit" ent "_yes" "_join" ss2 "" "")
	)
	(setq ss2 nil)
	;; si la polyligne créée n'a que 2 sommets
	(if (= 2
	       (length (vl-remove-if-not
			 '(lambda (x) (= (car x) 10))
			 (entget (entlast))
		       )
	       )
	    )
	  (setq lst (cons (entlast) lst))
	)
      )
    )
  )
)
     )
   )
   (setq lay (tblnext "LAYER"))
 )
 ;; les polylignes à 2 sommets sont re-tansformées en lignes
 (mapcar '(lambda (x) (command "_.explode" x)) lst)
 (command "_.undo" "_end")
 (setvar "CMDECHO" old_echo)
 (setq	*error*	m:err
m:err nil
 )
 (princ)
)