Comment Exporter des xy ?

[willy95]

Bonjour à tous,

je suis toujours en train de me poser des problèmes un peu trop difficiles pour mon petit niveau mais je veux vraiment y arriver, et pour cela je me prend la tete tout les jours, mais la je bloque encore une fois, en deux mots voici mon probleme :

 

Je souhaite selectionner plusieurs objets (ligne, arc, spline, polyligne, etc...)

Récuperer toutes les coordonnées XY des sommets des objets et les ecrirent dans un fichier txt.

 

Je pense utilisé Ssget pour selectioner les objets mais je ne sais pas comment récupérer les coordonnées de cette nouvelle variable

 

 

Je pense utilisé getfiled pour la création du fichier :

 (setq file (getfiled "Créer un fichier" "" "txt" 1) 

Mais j'ai un peu de mal pour la mise en forme dans le fichier:

je souhaiterai faire :

Numéro incrémenté:X=000.000,Y=000.000

 

Alors si vous pouvez me guider j'en serai ravi...

 

Merci d'avance

[(gile)]

Salut,

 

Pour écrire dans un fichier, regarde les fonctions open, write-line et close .

Pour écrire une ligne dans le fichier, l'argument passé à write-line doit être de type STR (chaîne de caractères), regarde les fonctions strcat et rtos

 

La fonction ssget retourne un jeu de sélection (une collection d'entités), il faut donc parcourir ce jeu de sélection pour traiter chaque entité.

Pour ce faire tu peux utiliser une boucle while avec un indice incrémenté passé comme argument de la fonction ssname.

 

Pour récupérer les propriété des entités, on accède à leurs données DXF avec le fonction entget.

 

Suivant le type d'entité, les coordonnées sont contenues dans le (ou les) groupe(s) DXF 10 et 11. Il faut donc envisager un traitement différent suivant le type d'entité :

- code de groupe 10 pour le centre des arcs et cercles

- codes de groupe 10 et 11 pour les lignes

- codes de groupe 10 pour les polylignes (une entrée par sommet)

- code de groupe 10 pour les points de contrôle ou 11 pour les points de lissage des splines.

 

Ton code pourrait avoir la forme suivante :

- acquisition du jeu de sélection (ssget ...)

- acquisition d'un chemin de fichier (getfiled ...)

- ouverture du fichier en écriture (open ...)

- initialisation du compteur

- traitement de chaque entité dans une boucle (while ...)

--- récupérer les données DXF de l'entité (entget ...)

--- lire le type d'entité (cdr (assoc 0 ...))

--- traitement différent suivant le type (cond ...)

--- écriture de la (ou des) ligne(s) dans le fichier (write-line ...)

--- incrémentation de l'indice (1+ ...)

- fermeture du fichier quand la boucle est finie (close ...)

 

Pour les entités ayant plusieurs sommets (polylignes splines), tu peux utiliser une sous routine qui retourne toutes les entrées d'un même code de groupe (quelques exemples ici) et traiter cette liste avec foreach.

[willy95]

MERCI Gile pour toute cette structure de conception, je vais plancher sur tout ca :yltype: ,

Je vous cache pas que je vais avoir du mal :calim: ,

 

Mais comme on dit plus c'est dur plus c'est bon (signe)... :cool:

[bonuscad]

Salut,

 

Ta demande rejoint cette réponse .

 

Dans cette réponse tu trouveras un lien sur ma page, ou la routine proposée fait ce que tu désirerais, à savoir:

 

Je souhaite selectionner plusieurs objets (ligne, arc, spline, polyligne, etc...)

Récuperer toutes les coordonnées XY des sommets des objets et les ecrirent dans un fichier txt.

 

Bien que le fichier généré soit du type .SCV, tu peux facilement le renommer en .TXT car le contenu est en ASCII. (ou modifié le lisp pour avoir l'extension voulu est aussi aisé.)

[willy95]

Merci mais j'arrive que pour les polylignes, pas les arcs, lignes, splines.

et je souhaite une selection de plusieurs objets par capture fenetre.

 

 

[bonuscad]

Merci mais j'arrive que pour les polylignes, pas les arcs, lignes, splines.

 

Si tu peux le faire, mais en plusieurs passes en rajoutant les données au fichier.

Après rien ne t'empêche de modifier le lisp dans sa partie de sélection. A l'origine le code est monté pour filtrer le même type d'objet que celui sélectionné en modèle. Tu peux "shunter" cette partie... et construire la sélection propre à tes besoins.

 

Essayes de faire les modifications et repostes les si tu as du mal à les faire fonctionner.

[willy95]

Merci mais j'ai beaucoup trop de mal a tout comprendre il y a beaucoup trop de chose qui sont pour moi très difficile, je suis un petit joueur a coté,

j'ai essayé de suprimé des parties (les filtres) mais hélas plus rien ne fonctionne, en plus rien que la selection de plusieurs objets par rapport a votre

choix unique d'un type d'objet est une étape vraiment incomprensible pour moi. :(

Je vais me battre avec toute la nuit si il faut, mais si vous avez un peu de temps ou meme de pitié pour moi,

n'hésitez pas à m'ecrire quelques lignes que je décortiquerai volontier et avec un grand intéret certains. :cool:

 

 

[bonuscad]

MERCI Gile pour toute cette structure de conception, je vais plancher sur tout ca

 

Vu la réponse, je pensais que tu te sentais de décortiquer un bout code déjà construit.

 

Mais bon..., pour toi la version allégée (supprimer des lignes m'a pris 30s). Plus de filtrage, or mis le type d'entités pouvant être traitées

 

(defun l-coor2l-pt (lst flag /)
 (if lst
   (cons (list	(car lst)
	(cadr lst)
	(if flag
	  (caddr lst)
	  0.0
	)
  )
  (l-coor2l-pt
    (if	flag
      (cdddr lst)
      (cddr lst)
    )
    flag
  )
   )
 )
)
(defun c:ptdef2csv (/	    js	    n	    file_name	    cle
	    f_open  key_sep str_sep oldim   ename   l_pt
	    l_pr    nbs
	   )
 (princ
   "\nChoix des objets dont les points de définition sont à récuperer: "
 )
 (while
   (null
     (setq js
     (ssget
       (list
	 '(0 . "*LINE,POINT,ARC,CIRCLE,SPLINE,ELLIPSE,INSERT")
	 (cons 67
	       (if (eq (getvar "CVPORT") 1)
		 1
		 0
	       )
	 )
	 (cons 410
	       (if (eq (getvar "CVPORT") 1)
		 (getvar "CTAB")
		 "Model"
	       )
	 )
       )
     )
     )
   )
    (princ
      "\nCe n'est pas un objet valable pour cette fonction!"
    )
 )
 (vl-load-com)
 (setq	file_name
 (getfiled "Nom du fichier a créer ?: "
	   (strcat (substr (getvar "dwgname")
			   1
			   (- (strlen (getvar "dwgname")) 3)
		   )
		   "csv"
	   )
	   "csv"
	   37
 )
 )
 (if (null file_name)
   (exit)
 )
 (if (findfile file_name)
   (progn
     (prompt "\nFichier éxiste déjà!")
     (initget "Ajoute Remplace annUler _Add Replace Undo")
     (setq cle
     (getkword
       "\nDonnées dans fichier? [Ajouter/Remplacer/annUler] : "
     )
     )
     (cond
((eq cle "Add")
 (setq cle "a")
)
((or (eq cle "Replace") (eq cle ()))
 (setq cle "w")
)
(T (exit))
     )
     (setq f_open (open file_name cle))
   )
   (setq f_open (open file_name "w"))
 )
 (initget
   "Espace Virgule Point-virgule Tabulation _SPace Comma SEmicolon Tabulation"
 )
 (setq	key_sep
 (getkword
   "\nSéparateur [Espace/Virgule/Point-virgule/Tabulation]? : "
 )
 )
 (cond
   ((eq key_sep "SPpace") (setq str_sep " "))
   ((eq key_sep "Comma") (setq str_sep ","))
   ((eq key_sep "Tabulation") (setq str_sep "\t"))
   (T (setq str_sep ";"))
 )
 (setq	oldim (getvar "dimzin")
n     -1
 )
 (setvar "dimzin" 0)
 (write-line
   (strcat "Matricule"	    str_sep	    "Type Entité"
    str_sep	    "Coordonée X"   str_sep
    "Coordonée Y"   str_sep	    "Coordonée Z"
   )
   f_open
 )
 (repeat (sslength js)
   (setq ename	(vlax-ename->vla-object (ssname js (setq n (1+ n))))
  l_pt	nil
   )
   (setq l_pr (list 'StartPoint      'EndPoint	       'Center
	     'InsertionPoint  'Coordinates     'FitPoints
	    )
  nbs  0
   )
   (foreach n l_pr
     (if (vlax-property-available-p ename n)
(setq l_pt
       (if (eq n 'Coordinates)
	 (progn
	   (append
	     (if (eq (vla-get-ObjectName ename) "AcDbPolyline")
	       (l-coor2l-pt (vlax-get ename n) nil)
	       (l-coor2l-pt (vlax-get ename n) T)
	     )
	     l_pt
	   )
	 )
	 (cons (vlax-get ename n) l_pt)
       )
)
     )
   )
   (foreach n l_pt
     (write-line
(strcat
  (itoa (setq nbs (1+ nbs)))
  str_sep
  (vla-get-ObjectName ename)
  str_sep
  (rtos (car n) 2 3)
  str_sep
  (rtos (cadr n) 2 3)
  str_sep
  (rtos (caddr n) 2 3)
)
f_open
     )
   )
   (write-line "" f_open)
 )
 (close f_open)
 (setvar "dimzin" oldim)
 (prin1)
)

[willy95]

Déja pour commencer je remercie beaucoup BonusCad pour cette réactivité et cette gentillesse envers moi, :hallucine:

j'ai l'air d'un rigolo a coté mais j'espere un jour pouvoir renvoyé l'appareil,

pour le moment j'ai de quoi lire et testé pendant quelques heures pour arrivé a comprendre ce code.

J'aimerai bien pouvoir numéroté tous les points a la suite et ne pas faire aparaitre les

noms des objets et pour finir marqué X= pour les x, genre : 1:X=123.234,Y=408.875,Z=12.34

en fait ce super code est trop complet pour moi, je souhaite "juste" récupéré des points avec xyz au final.

Encore Merci pour toute cette aide.

[(gile)]

Salut,

 

Voilà un exemple commenté qui suit à peu près le pseudo code donné plus haut.

 

(defun c:Coords2File (/ selset filename file ind ent dxflst typ pt)

 ;; sélection des entités
 (if (setq selset (ssget '((0 . "ARC,CIRCLE,LINE,LWPOLYLINE,SPLINE"))))

   ;; création du fichier
   (if	(setq filename (getfiled "Créer un fichier texte" "" "txt" 1))
     (progn
(setq file (open filename "w")	; ouverture en écriture
      ind  0			; initialisation de l'indice
)

;; boucle tant qu'il y a des entités dans le jeu de sélection
(while (setq ent (ssname selset ind))
  (setq	dxflst (entget ent)	; liste des données DXF
	typ    (cdr (assoc 0 dxflst)) ; type d'entité
	ind    (1+ ind)		; incrémentation de l'indice
  )

  ;; traitement suivant le type d'entité
  (cond
    ((= typ "ARC")
     (write-line (strcat (itoa ind) " Arc") file)
				; indice et type d'entité
     (setq pt (cdr (assoc 10 dxflst))) ; centre de l'arc
     (write-line
       (strcat "X=" (rtos (car pt)) " Y=" (rtos (cadr pt)))
       file
     )
    )
    ((= typ "CIRCLE")
     (write-line (strcat (itoa ind) " Cercle") file)
     (setq pt (cdr (assoc 10 dxflst)))
     (write-line
       (strcat "X=" (rtos (car pt)) " Y=" (rtos (cadr pt)))
       file
     )
    )
    ((= typ "LINE")
     (write-line (strcat (itoa ind) " Ligne") file)
     (setq pt (cdr (assoc 10 dxflst)))
     (write-line
       (strcat "X=" (rtos (car pt)) " Y=" (rtos (cadr pt)))
       file
     )
     (setq pt (cdr (assoc 11 dxflst)))
     (write-line
       (strcat "X=" (rtos (car pt)) " Y=" (rtos (cadr pt)))
       file
     )
    )
    ((= typ "LWPOLYLINE")
     (write-line (strcat (itoa ind) " Polyligne") file)
     ;; pour tous les sommets de la polyligne
     (foreach p	(massoc 10 dxflst)
       (write-line
	 (strcat "X=" (rtos (cadr p)) " Y=" (rtos (caddr p)))
	 file
       )
     )
    )
    ((= typ "SPLINE")
     (write-line (strcat (itoa ind) " Spline") file)
     ;; pour tous les points de lissage de la spline
     (foreach p	(massoc 11 dxflst)
       (write-line
	 (strcat "X=" (rtos (cadr p)) " Y=" (rtos (caddr p)))
	 file
       )
     )
    )
  ) ;_ fin de cond
) ;_ fin de while
(close file)			; fermeture du fichier
     ) ;_ fin de progn
   ) ;_ fin de if
 ) ;_ fin de if
 (princ)
)

;; MASSOC
;; Retourne la liste de toutes les entrées du code spécifié d'une liste d'association
;;
;; Arguments
;; code : le code de groupe pour les entrées
;; lst : la liste d'association

(defun massoc (code lst / ret)
 (foreach n lst
   (if	(= (car n) code)
     (setq ret (cons n ret))
   )
 )
 (reverse ret)
)

[willy95]

Encore MERCI

Pour pouvoir numéroté les points :

 

1:X=00.00,Y=00

2:X=

3:X=

 

il faut intégré ce genre de ligne ?

 

 (setq pts (cdr pts)
cnt (1+ cnt) 

 

 

 

et comment faire pour obtenir 3 point sur les arcs:

1er point debut

2ème point milieu de la courbe sur l'arc

3ème point fin de l'arc

j'ai pas besoin du centre

 

et peu etre le meme probleme pur les splines,

faut il creer des points a des distances défini ?

 

je souhaite en fait pouvoir créer un maximun de points a partir des objets et pouvoir les

redessiné grace et seulement aux points.

 

Est ce vraiment possible ?

 

[willy95]

En fait comme pour l'incrementation de l'indice du type c'est :

 (itoa ind) 

 

et je créer un indice de point

 (itoa npt) 

 

mais je n'arrive pas a insérer correctement :

 npt (1+ npt) 

Ou dois_je l'insérer ?

 

 

[willy95]

En fait j'ai réussi pour les lignes mais je comprends pas pour les polylignes ?

 

 ((= typ "LINE")
 (setq pt (cdr (assoc 10 dxflst))
 [b]   npt    (1+ npt)[/b] )
 (write-line
  (strcat (itoa npt) ":X=" (rtos (car pt)) ",Y=" (rtos (cadr pt)))
    file )
    (setq pt (cdr (assoc 11 dxflst))
   [b]   npt    (1+ npt)[/b]       )
    (write-line (strcat (itoa npt) 
":X=" (rtos (car pt)) ",Y=" (rtos (cadr pt)))
file    )    )

 

La structure pour les polylignes est différente :

(foreach p (massoc 10 dxflst)

[willy95]

Cool a part le probleme avec les arcs :

et comment faire pour obtenir 3 point sur les arcs:

1er point debut

2ème point milieu de la courbe sur l'arc

3ème point fin de l'arc

j'ai pas besoin du centre

 

 

Le code a l'air de fonctionné comme je le voulais mais...

(car il y a un mais)

 

je voudrai le testé sur autocad et si quelqu'un pouvait m'ecrire une ligne

pour insérer un simple point a l'aide du fichier de coordonnée créer.

Je serai rassuré.

 

Le Fichier donne : 1:X=100.00,Y=200,00

[(gile)]

Salut,

 

Pour les arcs, la fonction polar est ton amie :

 

(setq cen   (cdr (assoc 10 dxflst))	; centre
     rad   (cdr (assoc 40 dxflst))	; rayon
     ang1  (cdr (assoc 50 dxflst))	; angle départ
     ang2  (cdr (assoc 51 dxflst))	; angle fin
     start (polar cen ang1 rad)
     mid   (polar cen (/ (+ ang1 ang2) 2.0) rad)
     end   (polar cen ang2 rad)
)

 

Pour la lecture du fichier, tu n'as pas choisi un format qui facilite la chose (bonuscad proposait d'utiliser un fichier CSV qui aurait été plus facile à lire)

 

Pour chaque ligne du fichier (setq line (read-line file)), si tu veux récupérer le point sous forme d'une liste de réels : (200.00 100.00)

 

(setq pos (vl-string-position (ascii "=") line 0 T))
(setq point (list
      (atof (substr line
		    (+ 2 (vl-string-position (ascii "=") str))
		    (- (strlen str) pos 1)
	    )
      )
      (atof (substr line (+ 2 pos)))
    )
)

 

Si tu veux utiliser les points avec la fonction command, tu peux aussi l'utiliser sous forme de chaîne : "200.00,100.00"

 

(setq point (vl-string-subst
      ""
      "Y="
      (substr line (+ 2 (vl-string-position (ascii "=") str)))
    )
)

[willy95]

Voila ma nouvelle amie que j'adore:

 

 (setq cen   (cdr (assoc 10 dxflst)))	; centre
(setq rad   (cdr (assoc 40 dxflst)))	; rayon
(setq ang1  (cdr (assoc 50 dxflst)))	; angle départ
(setq ang2  (cdr (assoc 51 dxflst)))	; angle fin
(setq start (polar cen ang1 rad)npt (1+ npt))
(write-line (strcat (itoa npt) ":X=" (rtos (car start)) 
",Y=" (rtos (cadr start)))file)	
(setq mid (polar cen (/ (+ ang1 ang2) 2.0) rad)npt (1+ npt))
(write-line (strcat (itoa npt) ":X=" (rtos (car mid))
",Y=" (rtos (cadr mid)))file)
(setq end (polar cen ang2 rad)npt (1+ npt))
(write-line (strcat (itoa npt) ":X=" (rtos (car end)) 
",Y=" (rtos (cadr end)))file) )

 

Et tout fonctionne parfaitement et

j'ai meme compris chaque etape parfaitement.

 

Mais j'ai toujours le probleme avec les polylignes qui utilise Foreach:

 (foreach p (massoc 10 dxflst)  

pour insérer mon numéro de point avec npt (1+ npt) et (itoa npt)

J'ai essayé dans tous les sens mais sans résultat comment dois-je faire ?

 

Et Encore MERCI BEAUCOUP pour tous ce temps passé à me faire

comprendre un language qui me rends tellement heureux quand

sa fonctionne exactement comme je le souhaite..

 

[(gile)]

En fait j'ai réussi pour les lignes mais je comprends pas pour les polylignes ?

 

L'expression (massoc 10 dxflst) retourne une liste de sous listes du type ((10 x1 y1) (10 x2 y2) ... (10 xn yn))

La fonction foreach permet de parcourir cette liste et de traiter chaque élément (p)

 

((= typ "LWPOLYLINE")
 (foreach p (massoc 10 dxflst)
   (setq npt (1+ npt))
   (write-line
     (strcat (itoa npt)
      ":X="
      (rtos (cadr p))
      ",Y="
      (rtos (caddr p))
     )
     file
   )
 )
)

[willy95]

Merci

 

j'avais quelques instant pensé a cette solution mais

je suis passé a coté maintenant que vous me l'avez

mis devant les yeux cela me parait tellement

evident que j'ai l'air d'etre vraiment tres stupide.

 

Merci

 

je vais me battre maintenant pour testé le résultat

comme precedement conseillé.

l'import des points exporté

 

[willy95]

Merci Gile j'ai pu testé grace a ton code Instopo

 

http:// http://www.cadxp.com/modules.php?op=modload&name=XForum&file=viewthread&tid=22459#pid97395

 

Tous est parfait et Encore Merci

 

[willy95]

En fait apres tous ces changements qui me plaisent

j'aimerai pouvoir numéroté les entités dans une liste indépendante:

Ligne 1, Ligne 2

Polyligne 1; polyligne 2 etc...

 

- traitement de chaque entité dans une boucle (while ...)

 

J'ai essayé de doublé le while mais sans succès, est ce possible ?

Et si oui comment ?

 

 
indA  0	; initialisation de l'indice pour Arc
indC  0	; initialisation de l'indice pour Cercle
indL  0	; initialisation de l'indice pour Ligne
indPO 0	; initialisation de l'indice pour Polyligne
indSP 0	; initialisation de l'indice pour Spline

;; boucle tant qu'il y a des entités dans le jeu de sélection
(while (setq ent (ssname selset ind))
(setq	dxflst (entget ent)            ; liste des données DXF
typ    (cdr (assoc 0 dxflst))   ; type d'entité
ind    (1+ ind)	      ; incrémentation de l'indice
)

(while (setq ent (ssname selset indL))
(setq	dxflst (entget ent)            ; liste des données DXF
typ    (cdr (assoc 0 dxflst))   ; type d'entité
indL    (1+ indL)	      ; incrémentation de l'indice
)

 

dans ce Genre La ?

 

Merci

 

 

[(gile)]

Salut,

 

C'est dans le cond qu'il faut incrémenter tes indices suivant le type d'entité.

 

[willy95]

Après avoir essayé de comprendre cette fonction "Cond"

j'ai beaucoup de mal a pouvoir l'adapté a mon cas.

 

Une piste serait très aprécié...

 

;)

[(gile)]

Salut,

 

Ton cas est bien un cas typique pour l'utilisation de cond.

Tu dois traiter un jeu de sélection qui peut contenir indifféremment des arcs, des lignes, des polylignes ou des splines.

Pour traiter ce jeu de sélection, il faut boucler sur chaque entité qu'il contient (avec while ou repeat).

Pour chacune de ces entités, il faut déterminer son type -(cdr (assoc 0 ...))- puisque le traitement sera différent selon le type.

Il faut donc ensuite, pour chaque entité, tester si c'est un arc ou si c'est une ligne ou si c'est une polyligne ou si c'est une spline.

C'est à ça que sert la fonction cond.

 

cond accepte un nombre indéterminé de listes comme arguments.

Dans chacune de ces listes, le premier élément est une expression de test.

Ces expressions sont évaluées dans l'ordre jusqu'à ce qu'il y en ait une qui retourne un résultat différent de nil.

Ce sont alors les expressions suivantes dans la "liste/argument" qui sont évaluées.

 

Autrement dit l'utiliation de cond permet d'éviter une cascade de "else if" (sinon si...) imbriqués, les deux exemples suivants sont équivalents.

 

avec cond

(defun c:test-cond (/ ent typ)
 (while (setq ent (car (entsel)))
   (setq typ (cdr (assoc 0 (entget ent))))
   (cond
     ((= typ "ARC")			; expression test
      (alert "Arc")
      (redraw ent 3)
     )
     ((= typ "LINE")			; expression test
      (alert "Ligne")
      (redraw ent 3)
     )
     ((= typ "LWPOLYLINE")		; expression test
      (alert "Polyligne")
      (redraw ent 3)
     )
     ((= typ "SPLINE")			; expression test
      (alert "Spline")
      (redraw ent 3)
     )
     (T (alert "Entité non valide"))
   )
 )
 (command "_.regen")
 (princ)
)

 

avec if

(defun c:test-if (/ ent typ)
 (while (setq ent (car (entsel)))
   (setq typ (cdr (assoc 0 (entget ent))))
   (if	(= typ "ARC")			; expression test
     (progn
(alert "Arc")
(redraw ent 3)
     )
     (if (= typ "LINE")		; expression test
(progn
  (alert "Ligne")
  (redraw ent 3)
)
(if (= typ "LWPOLYLINE")	; expression test
  (progn
    (alert "Polyligne")
    (redraw ent 3)
  )
  (if (= typ "SPLINE")		; expression test
    (progn
      (alert "Spline")
      (redraw ent 3)
    )
    (alert "Entité non valide")
  )
)
     )
   )
 )
 (command "_.regen")
 (princ)
)

[willy95]

MERCI pour ce cours magistral que je garde précieusement. :)

 

J'ai pu intégré cette nouvelle fonction avec le résultat que je souhaitais :

 

 ((= typ "LINE")
(setq ent (ssname selset indL)
indL (1+ indL))

 

Je continu à faire évolué ce code que je mettrai

à disposition pour ceux que sa intéresse (si il y en a ?)

 

 

 

 

[willy95]

Et voila mon nouveau blocage :

J'ai réussi avec les lignes car il y avait seulement

2 poinrs comme ceci :

 (itoa (- npt 2)

 

mais la avec un nombre de points différent,

quelle astuce existe-il pour appliqué a itoa

la première valeur de npt ?

 

 
((= typ "SPLINE")
(setq ent (ssname selset indSP)
indSP (1+ indSP))
(foreach p (massoc 11 dxflst)
(setq npt (1+ npt))
(write-line (strcat (itoa npt) ":X=" (rtos (cadr p)) 
",Y=" (rtos (caddr p))
(strcat model)) file))
(write-line (strcat "Abod." (itoa indSP) ":MD=EPA_313") file)
(write-line (strcat "Abod." (itoa indSP) "&D0:") file)
(write-line (strcat "Abod." (itoa indSP) "&L0:*"  [b] (itoa (- npt 2))[/b] ) file)
file))

 

Merci d'avance pour cette réponse qui me manque...