Objet graphique TRACE = Au secours !!!

[lecrabe]

Bonjour à tous

 

Je viens de tomber (Croyez moi, ça fait mal)

sur un dessin AutoCAD contenant des objets graphiques TRACE !!!

 

Cela fait au moins 15 ans que je n'ai pas vu de DWG

avec cet horrible objet graphique datant de l'époque d'AutoCAD R1.x

 

Il s'agit de l'ancètre de la polyligne épaisse,

en effet une TRACE est en fait une ligne avec une épaisseur.

 

SVP quelqu'un aurait il un programme Lisp

pour convertir TOUTEs les TRACEs de mon DWG

en N Polylignes 2D épaisses (en récupérént l'information d'épaisseur de la trace) ???

 

En fait il y a 4 points X/Y car c'est en fait la description d'un rectangle

avec une épaisseur de N unités graphiques !!!

 

Il faut donc recalculer les 2 points sur l'axe central afin de reconstruire une

polyligne 2D dont l'épaisseur = XX.XX

 

(entget (car (entsel)) '("*"))

 

donne une horreur:

 

((-1 . ) (0 . "TRACE") (330 .

d'entité: 40070cf0>) (5 . "3E8") (100 . "AcDbEntity") (67 . 0) (410 . "Model")

(8 . "0") (100 . "AcDbTrace") (10 338881.0 90502.0 0.0) (11 338883.0 90500.7

0.0) (12 339309.0 91022.6 0.0) (13 339311.0 91021.3 0.0) (39 . 0.0) (210 0.0

0.0 1.0))

 

Merci d'avance, Le Decapode

 

 

[Edité le 28/2/2006 par lecrabe]

[Eric]

Bonjour Lecrabe

 

Aves la commande flatten (des express) si tu répond yes à la question remove hidden lines tes traces deviennent des polylignes

 

Mais le résultat n'est peut être pas celui que tu souhaites

 

Enfin tu verras bien ;)

[Eric]

Sinon j'ai trouvé ce lisp qui fonctionne très bien :

 

http://discussion.autodesk.com/thread.jspa?messageID=1211968

 

 

[lecrabe]

 

Bonjour Eric

 

Je te remercie pour ce Lisp provenant des Newsgroup

mais il ne correspond pas "complètement" à mon souci

car en fait il demande de sélectionner N traces JOINTIVES

pour les transformer une SEULE BELLE polyligne.

 

Ce que je désire c'est sélectionner N traces

pour les transformer en N Polylignes 2D épaisses.

 

Merci quand même pour ton aide ! :) :D :cool:

 

Le Decapode "traçant"

 

[mdsv31]

Logiquement tu devrais y arriver avec le list si tu enleve c'est trois lignes

 

"_Join" sl ""

"_Width" (distance (cdr (assoc 12 ed))

(cdr (assoc 13 ed))) "")

 

@+

MDSV31

[lecrabe]

 

Bonjour MDSV31 (& Eric)

 

Désolé mais j'essaye desupprimer qq lignes ...

 

Mais ça marche po !!! :o

 

J'ai un gros problème de parenthèses ! :(

 

Le Decapode "Ras la Trace"

 

PS: Pour Eric, FLATTEN donne en fait un résultat MARRANT :casstet:

des polylignes (Rectangle) avec 4 sommets si la trace est Non Ortho

et une polyligne (Triangle) avec 3 sommets si la Trace est Ortho !!!

 

[(gile)]

Salut,

 

 

Voici un LISP qui semble marcher (il est tard, je n'ai pas mis de commentaires, peut-être demain ...) :

 

 

Version commentée

 

 

;;; tr2pl Transforme toutes les traces du dessin en autant de segments de lwpolyligne

(defun c:tr2pl (/ ss e_lst ang)

 ;; Sélection de tous les objets "trace" 
 (setq ss (ssget "_X" '((0 . "TRACE"))))

 ;; Si la sélection n'est pas vide,
 (if ss

   ;; pour chaque objet,
   (repeat (setq n (sslength ss))
     (apply '(lambda (x)
	(setq e_lst (entget x))

	;; calcul de l'angle à l'extrémité
	(setq      ang   (- (angle (cdr (assoc 10 e_lst)) (cdr (assoc 12 e_lst)))
		       (angle (cdr (assoc 10 e_lst)) (cdr (assoc 11 e_lst)))
		    )
	)
	(if (minusp ang)
	  (setq ang (+ ang (* pi 2)))
	)

	;; création de la polyligne
	(entmake
	  (list	'(0 . "LWPOLYLINE")
		'(100 . "AcDbEntity")
		'(100 . "AcDbPolyline")
		'(90 . 2)  ; nombre de sommets
		'(70 . 0)  ; ouverte
		(cons 8 (cdr (assoc 8 e_lst)))
		;; sommet de départ
		(cons 10
		      (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2))
			      (cdr (assoc 10 e_lst))
			      (cdr (assoc 11 e_lst))
		      )
		)
		;; sommet de fin
		(cons 10
		      (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2))
			      (cdr (assoc 12 e_lst))
			      (cdr (assoc 13 e_lst))
		      )
		)
		;; largeur
		(cons 43
		      (* (sin ang)
			 (distance (cdr (assoc 10 e_lst))
				   (cdr (assoc 11 e_lst))
			 )
		      )
		)
		(cons 210 (cdr (assoc 210 e_lst)))
		(cons 39 (cdr (assoc 39 e_lst)))
	  )  ; fin de list
	)  ; fin de entmake
	
	;; suppression de la trace
	(entdel x)
      )  ; fin de lambda
     (list (ssname ss (setq n (1- n))))
     )  ; fin de apply
   )  ; fin de repeat
 )  ; fin de if
 (princ)
)  ; fin de defun 

 

 

PS : en l'état, le LISP ne crée que des segments de polyligne (1 trace -> 1poly), je n'aurais ni le temps ni les moyens avant ce soir (après le boulot) de modifier le code pour qu'il joigne les segments en une unique poly quand les objets sources était jointifs.[Edité le 1/3/2006 par (gile)]

 

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

[mikL44]

Ton lisp (gile) marche impeccable :D

[(gile)]

Merci Boris,

 

Bonne nuit ...

[(gile)]

Voilà la nouvelle version, elle joint les traces jointives en une polyligne unique et conserve les largeurs même si les traces ont été étirés à l'aide de leur poignées.

 

 

Les traces :

 

 

http://img128.imageshack.us/img128/2815/trace17ka.png

 

 

Tranformées en polylignes :

 

 

http://img397.imageshack.us/img397/6868/trace21qt.png

 

 

La baguette magique :

 

 

Nouvelle version (05/03/06) possibilité de choisir entre générer une polyligne unique ou une polyligne par trace pour les traces jointives et de même largeur.

 

 

;;; Trace2poly Transforme les traces sélectionnées (ou Toutes) en lwpolylignes
;;; L'utilsateur choisit si les traces jointives génèrent une seule polyligne ou des segments.
;;; Les largeurs sont conservées.

(defun c:trace2poly (/	     dxf     mid     dep_w   end_w   ss
	     opt     n	     cnt_t   cnt_p   tr_lst  sub_lst
	     pt_lst  prec
	    )

;;; ************************ SOUS ROUTINES ************************ ;;;

 ;; DXF retourne la valeur dxf de l'entité pour le code spécifié
 (defun dxf (code ent)
   (cdr (assoc code (entget ent)))
 )

 ;; MID Retourne le milieu de deux points
 (defun mid (pt1 pt2)
   (mapcar '(lambda (x1 x2) (/ (+ x1 x2) 2)) pt1 pt2)
 )

 ;; DEP_W Largeur de départ d'une trace
 (defun dep_w (tr / ang)
   (setq ang (- (angle (dxf 10 tr) (dxf 12 tr))
	 (angle (dxf 10 tr) (dxf 11 tr))
      )
   )
   (if	(minusp ang)
     (setq ang (+ (* 2 pi) ang))
   )
   (abs (* (sin ang) (distance (dxf 10 tr) (dxf 11 tr))))
 )

 ;; END_W Largeur de fin d'une trace
 (defun end_w (tr / ang)
   (setq ang (- (angle (dxf 12 tr) (dxf 10 tr))
	 (angle (dxf 12 tr) (dxf 13 tr))
      )
   )
   (if	(minusp ang)
     (setq ang (+ (* 2 pi) ang))
   )
   (abs (* (sin ang) (distance (dxf 12 tr) (dxf 13 tr))))
 )

;;; ************************ FONCTION PRINCIPALE ************************ ;;;

 ;; Sélection des objets
 (prompt
   "\nSélectionnez les traces à transformer < Toutes >: "
 )
 (if (not (setq ss (ssget '((0 . "TRACE")))))
   (setq ss (ssget "_X" '((0 . "TRACE"))))
 )
 ;; Si la sélection existe
 (if ss
   (progn

     ;; Choix du type d'objet à créer
     (initget "Oui Non")
     (setq opt
     (getkword
       "\nJoindre les segments ? [Oui/Non] < O >: "
     )
     )
     (if (not opt)
(setq opt "Oui")
     )

     ;; Création d'une liste (tr_lst) contenant toutes les traces du dessin
     (setq n	  (sslength ss)
    cnt_t n
    cnt_p 0
     )
     (repeat n
(setq n	     (1- n)
      tr_lst (cons (ssname ss n) tr_lst)
)
     ) ;_ Fin de repeat

     ;; Tant que tr_lst n'est pas vide
     (while tr_lst

;; Si option "Oui"
(if (= opt "Oui")
  (progn

    ;; Mise en tête de liste d'une trace non jointive à son extrémité
    (while
      (vl-member-if
	'(lambda (x)
	   (and	(equal (dxf 12 (car tr_lst)) (dxf 10 x) 1e-009)
		(equal (dxf 13 (car tr_lst)) (dxf 11 x) 1e-009)
	   )
	 )
	(cdr tr_lst)
      ) ;_ Fin de vl-member-if
       (setq
	 tr_lst
	  (reverse (cons (car tr_lst) (reverse (cdr tr_lst))))
       )
    ) ;_ Fin de while

    ;; Création d'une liste des traces jointives (sub_lst)
    (setq sub_lst (cons (car tr_lst) sub_lst)
	  tr_lst  (cdr tr_lst)
    )

    ;; Tant qu'il existe une trace jointive à la première de sub_lst
    (while (setq prec
		  (car
		    (vl-member-if
		      '(lambda (x)
			 (and (equal (dxf 10 (car sub_lst))
				     (dxf 12 x)
				     1e-009
			      )
			      (equal (dxf 11 (car sub_lst))
				     (dxf 13 x)
				     1e-009
			      )
			 )
		       )
		      tr_lst
		    ) ;_ Fin de vl-member-if
		  )
	   ) ;_ Fin de setq

      ;; Cette trace est ajoutée à sub_lst et supprimée de tr_lst
      (setq sub_lst (cons prec sub_lst)
	    tr_lst  (vl-remove prec tr_lst)
      )
    ) ;_ Fin de while
  ) ;_ Fin de progn

  ;; Si option "Non"
  (setq	sub_lst	(cons (car tr_lst) sub_lst)
	tr_lst	(cdr tr_lst)
  )
) ;_ Fin de if

;; Création de la liste des sommets de la polyligne et des
;; largeurs aux sommets
(setq pt_lst
       (apply 'append
	      (mapcar '(lambda (x)
			 (list
			   (cons 10 (mid (dxf 10 x) (dxf 11 x)))
			   (cons 40 (dep_w x))
			   (cons 41 (end_w x))
			 )
		       )
		      sub_lst
	      ) ;_ Fin de mapcar
       ) ;_ Fin de apply
) ;_ Fin de setq
(setq
  pt_lst (append pt_lst
		 (list (cons 10
			     (mid (dxf 12 (last sub_lst))
				  (dxf 13 (last sub_lst))
			     )
		       )
		 )
	 ) ;_ Fin de append
) ;_ Fin de setq

;; Création de la polyligne
(entmake (append
	   (list '(0 . "LWPOLYLINE")
		 '(100 . "AcDbEntity")
		 '(100 . "AcDbPolyline")
		 '(70 . 0)
		 (cons 90 (/ (+ 2 (length pt_lst)) 3))
		 (cons 8 (dxf 8 (car sub_lst)))
		 (cons 210 (dxf 210 (car sub_lst)))
		 (cons 39 (dxf 39 (car sub_lst)))
	   )
	   pt_lst
	 )
) ;_ Fin de entmake

;; Suppresion des traces traitées
(mapcar 'entdel sub_lst)
(setq sub_lst nil
      cnt_p   (1+ cnt_p)

)
     ) ;_ Fin de while
     (prompt (strcat "\n\t"
	      (itoa cnt_t)
	      " traces ont été transformées en "
	      (itoa cnt_p)
	      " polylignes."
      )
     )
   ) ;_ Fin de progn
   (prompt "\nLe dessin ne contient pas de trace.")
 ) ;_ Fin de if
 (princ)
) ;_ Fin de defun

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

 

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

[lecrabe]

 

Bonjour (gile) et autres valeureux membres

 

Merci beaucoup pour votre aide :) :D :cool:

 

Le Decapode "traçant"

 

PS: Comment peut on ENCORE en 2006 fournir un DWG (Reseau AEP/ASS) avec

des TRACEs et non pas des POLYLIGNEs (ou à la rigueur des LIGNEs) !!! :o :( :mad:

 

C'est fou :casstet:

 

[(gile)]

C'est moi qui te remercie, lecrabe, tu m'as fait découvrir une entité AutoCAD dont je ne soupçonnais pas l'existence, même si son intérêt semble fort désuet ;) .

 

 

J'ai modifié le dernier LISP pour plus de polyvalence. L'utilisateur peut maintenant choisir entre sélectionner certaines trace ou toutes celles du dessin et de générer, pour les traces jointives et de même largeur, soit une polyligne unique soit une succession de segments.

[Tramber]

Dans le genre, tu connais MAINLEV ?

 

A part ça, je parcourais le message et j'ai commencé à chercher les SOLIDEs (les éléments 2D, pas 3D) dans la table DXF.

 

Amusant, c'est la même que pour TRACE, sauf que l'une est gérée dans les SCO l'autre non si l'on lit !

 

Que de similitudes : les 2 sont pleins en fausse 3D avec épaisseur.

 

L'histoire a fait de SOLIDE l'objet qui aurait du être inventé avant ! De sorte, TRACE n'aurait été qu'une commande qui génère des SOLIDEs ;)

 

PS : peut-être les anciens me diront que SOLIDE est bien une commande aussi ancienne que TRACE !?

[(gile)]

Dans le genre, tu connais MAINLEV ?

 

 

Oui, je connais MAINLEV, mais je dessine encore plus mal avec une souris qu'avec un crayon :cool:

 

 

Le fait que TRACE soit géré dans le SCO comme les lwpolylignes m'a facilité la vie pour les LISP ci-dessus, ils fonctionnent même si les traces ont été dessinée dans des SCU différents, sans faire aucun trans :)

[(gile)]

Amusant, c'est la même que pour TRACE, sauf que l'une est gérée dans les SCO l'autre non si l'on lit !

 

S'il n'est pas précisé dans la table DXF que les sommets des SOLIDE sont définis dans le SCO, ce doit être un oubli. un (entget(car(entsel))) sur un SOLIDE créé dans un SCU pivoté montre que c'est bien le cas.

[CDL]

PS : peut-être les anciens me diront que SOLIDE est bien une commande aussi ancienne que TRACE !?

 

Dans mon manuel AutoCAD 2.5 elles sont toutes les deux reférencées

A noter la variables TRACEWID mémorise la dernieré épaissseur stokées pour TRACE

 

Précision du manuel pour les mieux lotis qui posséde ADE-3, il peuvent utiliser la commande POLYLIGNE. :cool:

 

le module ADE-3 (on dirait déja une idée de séparer les riches et les pauvres utilisateurs)permetait de donner un élévation aux entitées

INCROYABLE, de la 3D !

:D

le vieux CDL va se coucher !

[lecrabe]

 

Hello le Brestois

 

Eh oui à une certaine époque, AutoCAD existait en 3 versions ou modules :

 

AutoCAD Base = 4000 Fht

AutoCAD ADE2 = 26 000 Fht

AutoCAD ADE3 = 31 000 Fht

 

Ces prix sont approximatifs et datent de l'époque AutoCAD 2.5/2.6/9.0 :)

 

Pour plus de précision, il faudra que je replonge

dans mes OOPS Magazines (que j'ai gardés précieusement) :P ;)

 

Le Decapode "préhistorique"