Poignées superposées

[Fraid]

bonjour,

 

Lorsque l'on ramene une poignées d'une polyligne l'une sur l'autre on ne peux plus prolonger celle ci

 

je suppose que vous l'avez aussi remarquez

 

et ben moi sa m'enerve grave

et cela fait tres longtemps que sa m'agace :(

 

y aurai t'il une astuce pour evité cela

 

merci

 

 

[eturlin]

jJ' ai essayé mais je crois que je n'ai pas compris la question !

[Tramber]

Y a pas d'astuce sinon de rentre dans l'édition des points par PEDIT et ses sous-options.

Modif-sommet (suivant autant de fois qu'il faut) et Déplacer

 

Si j'ai compris la question de travers, il y a toujours la touche CTRL pour choisir l'objet que l'on veut prolonger quand il est superposé à un autre.

 

[Edité le 29/6/2006 par Tramber]

[Fraid]

t'a bien compris

si on fait pedit/modif sommet/suivant/

la croix reste sur le meme point puisque il il y a 2 sommet au meme endroit

 

bref

la meilleur astuce est de ne pas ramener les poignée l'une sur l'autre

voila une discussion pour rien

désolé :P

[Tramber]

Pourtant cette méthode de déplacement permet de séparer les points. Je ne comprends pas pourquoi tu n'y arrives pas.

[Fraid]

si si j'y arrive

 

mais cela me fait perdre quelque seconde

je vais plus vite en coupant la polyligne juste avant et en supprimant le petit bout restant

et la je peux prolonger

 

peut etre qu'il existerai un lisp qui fusionerai les sommets ayant les memes coordonnées?

 

[(gile)]

peut etre qu'il existerai un lisp qui fusionerai les sommets ayant les memes coordonnées?

 

Si ça n'existe pas déjà, et si personne ne l'a fait d'ici là, je te fais ça se soir, avec REMOVE-DOUBLES sur la liste des sommets et un entmake je pense que c'est facile à faire.

[bonuscad]

J'avais déjà monter ce genre de routine, elle travaille sur des polylignes 2D ou 3D, le seul "Hic" est que cette routine supprime les segments d'arcs.

 

Mais gilles va certainement remédier a cette insuffissance et améliorer tout ça ;)

 

Voici déjà ce que j'ai réalisé:

 

(defun c:remove_vertice_overlapped ( / ent dxf_ent typent closed lst e_next nb_vtx lst2 osmd flag)
(while (null (setq ent (entsel "\nChoix de la polyligne: "))))
(setq typent (cdr (assoc 0 (setq dxf_ent (entget (car ent))))))
(cond
	((eq typent "LWPOLYLINE")
		(setq
			closed (boole 1 (cdr (assoc 70 dxf_ent)) 1)
			lst (mapcar '(lambda (x) (trans x (car ent) 1)) (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) dxf_ent)))
		)
	)
	((eq typent "POLYLINE")
		(setq
			closed (boole 1 (cdr (assoc 70 dxf_ent)) 1)
			e_next (entnext (car ent))
		)
		(while (= "VERTEX" (cdr (assoc 0 (setq dxf_next (entget e_next)))))
			(if (zerop (boole 1 116 (cdr (assoc 70 dxf_next))))
				(setq
					lst (cons (trans (cdr (assoc 10 dxf_next)) (car ent) 1) lst)
				)
			)
			(setq e_next (entnext e_next))
		)
		(setq
			lst (reverse lst)
		)
		(print)
	)
	(T (princ "\nN'est pas une Polyligne! "))
)
(cond
	(lst
		(setq nb_vtx (length lst))
		(if (equal (last lst) (car lst)) (setq lst (cdr lst) closed 1))
		(while (car lst)
			(setq
				lst2 (cons (car lst) lst2)
				lst (vl-remove (car lst) lst)
			)
		)
		(setq lst (reverse lst2))
		(cond
			((not (eq nb_vtx (length lst)))
				(setq osmd (getvar "osmode"))
				(setvar "osmode" 0)
				(if (not (equal (cdr (assoc 210 dxf_ent)) '(0.0 0.0 1.0)))
					(progn (command "_.ucs" "_object" ent) (setq flag T))
					(setq flag nil)
				)
				(entdel (car ent))
				(command "_.pline")
				(foreach n lst (command n))
				(if (zerop closed)
					(command "")
					(command "_close")
				)
				(if flag (command "_.ucs" "_previous"))
				(setvar "osmode" osmd)
				(alert "\nLa nouvelle polyligne ne possède plus d'arc.")
			)
			(T (alert "\nPas de sommets en double. Aucun changement!"))
		)
	)
	(T (princ "Doit être une LWPolyligne/Polyligne2D ou 3D."))
)
(prin1)
)

[(gile)]

Voilà, ni REMOVE_DOUBLES ni entmake, mais je me suis régalé à trouver une réponse à ton problème, merci.

 

À la différence du LISP proposé par bonuscad, celui-ci ne traite que les polylignes optimisées (lwpolyline), mais il conserve les arcs.

 

;;; TRUNC_LST 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_lst (expr lst)
 (cond
   ((not (member expr lst)) lst)
   ((equal (car lst) expr) nil)
   (T (cons (car lst) (trunc_lst expr (cdr lst))))
 )
)

;;; SINGLE_VERTICES
;;; Supprime tous les sommets superposées d'une lwpolyligne

(defun c:single_vertices (/ ent e_lst p_lst)
 (while (not
   (setq ent (car (entsel "\nSélectionnez une polyligne: ")))
 )
 )
 (if (= "LWPOLYLINE" (cdr (assoc 0 (setq e_lst (entget ent)))))
   (progn
     (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_lst (assoc 10 (cdr p_lst)) p_lst))
      p_lst (member (assoc 10 (cdr p_lst)) (cdr p_lst))
)
     )
     (entmod e_lst)
   )
   (princ "\nEntité non valide.")
 )
 (princ)
)

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

 

[Edité le 5/7/2006 par (gile)]

[Fraid]

je suis content que tu t'eclate grace a mes questions Gile

 

doucement nous ameliorons autocad en eliminant certain defaults

 

je suis sur le terrain cette semaine j'essairais ton lisp dés que je suis rentrer au bureau

 

je te tient au courant

 

merci

[Fraid]

sa marche impeccable gile

 

du coup je viens de decouvrir que l'on pouvait charger un lisp simplement en le faisant glisser dans le dessin

 

encore merci

 

et a bientot pour de nouvelles aventure ;)

[(gile)]

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.

[bonuscad]

la boucle ne prend pas en compte le (ou les)dernier(s) sommet(s) s'ils ont été superposé(s) sur le premier.

 

Ca, a mon avis, je ne pense pas que ce soit un plus!

Ceci et un choix de l'utilisateur de faire un polyligne fermée sans passer par l'option "clore".

 

Ou alors de passer dans ce cas le bit 70 de 0 à 1 pour obtenir le même résultat, c'est peut être ce que tu veux faire?

Il ne faudra pas oublié de "checker" le dernier arrondi. Je me demande d'ailleurs si ce code 40 peut être affecter pour clore, ou si c'est celui de l'avant dernier segment?

[(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

 

 

[(gile)]

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)]