Mes redébuts en lisp

[Patrick_35]

Pour DenisH

 

(mapcar '(lambda(a B)(princ (strcat a B))) (list "\nLignList type 3 : \nMatri=" "\nX=" "\nY=") LignList)

 

@+

[La Lozère]

Bon je patauge, je patauge.

(defun c:gpoi ();/ fichier str lst)
(setq fichier (open (getfiled "Fichier .CSV à ouvrir" "" "csv" 8) "r"))
(setq str (read-line fichier))
(print str)
(close fichier)
)

Pourquoi ce bout de code (que j'ai simplifié) marche sur un fichier tout neuf, mais pas sur d'autre. Cela me renvoi:

; erreur: type d'argument incorrect: FILE nil

 

Déjà que c'est compliqué pour moi, mais alors en plus si le fonctionnement est aléatoire :(

[didier]

Coucou

 

NON le fonctionnement n'est pas aléatoire, du moins dans le vrai sens de aléatoire.

 

Cas possible :

Tu es mal sorti d'une boucle et que tu n'as pas pu fermer le fichier "sortie avant close"

Donc tu n'y auras plus accès tant que la session AutoCAD sera ouverte ni en lisp ni dans l'explorer classique (effacement par exemple).

 

Ne mets pas la barre trop haut (sans te manquer de respect)

Commence le lisp avec des entités simples et faciles à comprendre avant de te lancer dans la lecture de fichiers

Surtout si tu te sers du code des autres ce qui n'est pas la bonne méthode.

 

Sans me mettre en avant : j'ai commencé le C# et j'en suis encore à faire des additions en console DOS, tu vois le genre ?

 

Amicalement

[DenisHen]

Salut à tous...

 

Effectivement didier, ne pas mettre la barre trop haute, mais je pense qu'il a juste besoin d'une piqure de rappel...

 

Et à mon niveau (au raz des pâquerettes) si j'y suis parvenu, je ne pense pas que ça lui est inaccessible...

 

Juste une question, est-ce que le Lisp réagit comme le VBA. Un ligne avec close fermerait-elle tous ce qui est ouvert ?

[didier]

Coucou

 

Si tu le dis ! ... je ne me battrais sûrement pas mais j'écris ce que je pense et je donne les conseils que je m'applique en premier.

 

Je ne connais pas assez le VBA pour le comparer au lisp (d'AutoCAD) mais j'ai un énorme doute sur l'existence de similitudes.

 

[La Lozère]

Je suis bien preneur de vos conseils et remarques

Quand à ne pas mettre la barre trop haut je suis d'accord.

Le truc c'est qu'à l'heure actuel, si je monte pas la barre, je peux dire que j'ai atteint mon objectif avec ce code:

;; Met en 3D un profil en travers dessiné
(defun c:gpoi ();/ sel pb zp gis)
(command "_.undo" "_group")
;; Entrée utilisateur
(setq sel (ssget))
(setq pb (getpoint "\nPoint de base du déplacement: "))
 	(setq zp (getpoint pb "\nSpécifier les coordonnées du ZP: "))
(setq gis (getreal "\nSpécifier la valeur du gisement: "))
;
;;Calcul
  (command "_move" sel "" pb zp)
  (command "3DROTATION" sel "" "x" zp "300")
  (command "_rotate" sel "" zp gis)
;
  (command "_.undo" "_end")
 (princ ) 
)

 

Maintenant, les valeurs des arguments zp et gis sont disponible dans un fichier Excel.

pour l'instant hors de question d'aller chercher des données dans un xls. Par contre il m'est très facile de convertir cet .xls en .csv avec un séparateur ";"

Du coup, avec le tuto de (gile) je m'en sort.

Alors j'ai créai un deuxième bout de code pour extraire les données:

(defun c:gpoi ();/ fichier sep pos str lst num_pt xzp yzp zzp gis zp)
(setq fichier (open (getfiled "Fichier .CSV à ouvrir" "" "csv" 8) "r"))
(while
(setq str (read-line fichier))
(defun str2lst (str sep / pos)
(setq sep ";")
 (if (setq pos (vl-string-search sep str)) 
   (cons (substr str 1 pos) 
   (str2lst (substr str (+ (strlen sep) pos 1)) sep) 
   ) 
   (list str) 
 ) 
) 
(setq lst (str2lst str sep))
(setq num_pt(car lst))
(setq xzp (atoi (cadr lst)))
(setq yzp (atoi (caddr lst)))
(setq zzp (atoi (cadddr lst)))
(setq gis (atoi (car (cdr (cdr (cdr (cdr lst)))))))
(setq zp (list xzp yzp zzp))
)
(close fichier)
)

 

A ce point, il me reste à combiner les 2 codes.

 

Les points encore en suspend et à comprendre, c'est pourquoi cette erreur et surtout la partie récursive de ce bout de code. Je comprend l'ensemble des fonctions la composant (vl-string-search, cons, substr, strlen), je comprend le principe de fonctionnement qui consiste à aller chercher des éléments de la chaine d'un point de début à un point de fin, puis de transformer ces éléments en une nouvelle chaine, puis de reconstruire/compléter une liste a partir de cette chaine et bis-répétita jusqu'à ce qu'il n'y ait plus d'éléments dans la chaine initiale. Maintenant c'est comment articuler les choses ensemble que j'ai du mal.

[DenisHen]

je ne me battrais sûrement pas mais j'écris ce que je pense et je donne les conseils que je m'applique en premier.

 

Ce n'était nullement mon intention. De plus, je suis, et ce n'est pas la première fois, d'accord avec toi.

 

C'était juste un petit bout de code qui servirait de base à la compréhension du Lisp, juste un petit rappel...

 

Je ne voulais pas m’immiscer dans les conseils des grands... Je proposais juste mon point de vue de novice, car je comprends très bien La Lozère, on débute tout les deux...

 

Amicalement...

[Patrick_35]

Salut

 

@La Lozère

J'ai vu que tu mettais la fonction de (gile) dans la boucle while.

Normalement, on ne définit qu'une seule fois une fonction.

Tu as plusieurs manières de le faire

1) En local, une fonction dans une fonction

(defun c:gpoi(/ str2lst)
 (defun str2lst (str sep / pos)
   ...
 )
 ...
)

2) En global, si cette fonction est susceptible d'être utilisée par plusieurs lisps, mais attention dans ce cas au nom de la fonction afin que cela ne se mélange pas avec d'autres lisps qui utilisent aussi des fonctions globales. (une fonction qui en remplace une autre --> erreur)

(defun str2lst (str sep / pos)
 ...
)
(defun c:gpoi()
 ...
)

 

Ensuite, ton code fonctionne très bien pour une ligne de texte. Quid pour deux lignes, voir plus ?

Tu ne teste pas si l'utilisateur annule la recherche du fichier csv

(open nil "r") --> Erreur

 

Continue, car pour une reprise, tu avances vite.

 

@+

[La Lozère]

Bonjour Patrick,

Effectivement, je n'avais fait attention à sortir la fonction de (gile) de la boucle. En y réfléchissant, c'est logique.

 

Pour plusieurs ligne je compte sur le while. Pour l'instant, mon deuxième bout de code traite toutes les lignes du fichier, mais ne retient que la dernière ligne car justement je suis dans la boucle while.

La prochaine étape est d'intégrer (en le modifiant) le premier bout de code dans la boucle while du deuxième bout de code. Ainsi je traiterais chaque ligne différemment avec pour chaque ligne une nouvelle valeur de variable pb, et une nouvelle sélection d'objets sel.

 

Ensuite, je m'attaquerais à la gestion d'erreur, comme:

- l'annulation de la recherche du fichier csv

- interruption de la commande en cours d'utilisation,

- etc.

 

Je souhaite également pouvoir laisser à l'utilisateur le choix du mode de saisi des arguments zp et gis en proposant à l'utilisateur une saisie clavier, un clic ou une valeur par défaut issue de la lecture du fichier .csv utilisable par simple validation parla touche "Entrée".

 

Merci pour les encouragements

[La Lozère]

Bonjour,

Bon maintenant que CADXP est de retour, je vais pouvoir poser mes questions ;)

 

La première, pourquoi dans certaines conditions d'ouverture de fichier, pas tout le temps, j'ai ce message après avoir sélectionné mon CSV.

Commande: gpoi

Voulez-vous utiliser un fichier csv? [Oui/Non]: O

Erreur: type d'argument incorrect: FILE nil

 

La deuxième, ans le cas d'une utilisation avec listing, je souhaite poser une question du genre: "Spécifier les coordonnées du ZP:" et "Spécifier la valeur du gisement:" mais avec une proposition de valeurs issus du listing. Genre: "Spécifier les coordonnées du ZP <821493.123,6302456.858,84.556>:" et "Spécifier la valeur du gisement <242.635>:". Ce qui permettrait de n'avoir qu'à valider. Mais je ne sais pas comment faire, et je n'ai rien trouvé.

Merci.

 

Voici mon code:

(defun c:gpoi (/      fichier	    sep	   pos	  str	 lst	num_pt
       xzp    yzp    zzp    gis	   zp	  str2lst	kw
       sel    pb
      )
 (command "_.undo" "_group")
;;;
;;;gestion d'erreur
 (defun *error* (msg)
   (if	(/= msg "Fonction annulée")
     (princ (strcat "\nErreur: " msg))
   )
   (if	fichier
     (close fichier)
   )
   (princ)
 )
;;;
 (initget 1 "Oui Non")
 (setq	kw (getkword
     "\nVoulez-vous utiliser un fichier csv? [Oui/Non]: "
   )
 )
;;;
;;;          Boucle pour OUI
 (if (= "Oui" kw)
   (progn
     (setq
fichier	(open (getfiled "Fichier .CSV à  ouvrir" "" "csv" 8)
	      "r"
	)
     )
;;;
     (while
(setq str (read-line fichier))
 (defun	str2lst	(str sep / pos)
   (setq sep ";")
   (if (setq pos (vl-string-search sep str))
     (cons (substr str 1 pos)
	   (str2lst (substr str (+ (strlen sep) pos 1)) sep)
     )
     (list str)
   )
 )
 (setq lst (str2lst str sep))
 (setq num_pt (car lst))
 (setq xzp (atof (cadr lst)))
 (setq yzp (atof (caddr lst)))
 (setq zzp (atof (cadddr lst)))
 (setq gis (atof (car (cdr (cdr (cdr (cdr lst)))))))
 (setq zp (list xzp yzp zzp))
 (setq sel (ssget))
 (setq pb (getpoint "\nPoint de base du déplacement: "))
;;;
;;;Déplacement
 (command "_move" sel "" pb zp)
 (command "3DROTATION" sel "" "x" zp "300")
 (command "_rotate" sel "" zp gis)
     )
     (close fichier)
   )
 )
;;;
;;;
;;;              Boucle pour NON
 (if (= "Non" kw)
   (progn
;;; Entrée utilisateur
     (setq sel (ssget))
     (setq pb (getpoint "\nPoint de base du déplacement: "))
     (setq zp (getpoint pb "\nSpécifier les coordonnées du ZP: "))
     (setq gis (getreal "\nSpécifier la valeur du gisement: "))
;;;
;;;Déplacement
     (command "_move" sel "" pb zp)
     (command "3DROTATION" sel "" "x" zp "300")
     (command "_rotate" sel "" zp gis)
;;;
   )
 )
 (command "_.undo" "_end")
 (princ)
)

 

PS: Didier, je ne t'ai pas oublié ;)

[didier]

Coucou

 

je ne comprends pas

tu veux sélectionner les valeurs dans le fichier texte ?

si oui, comment ?

[La Lozère]

Non, je ne veux pas sélectionner les valeurs dans le fichier texte.

Dans mon lisp, j'ai 2 options. Soit je rentre les valeurs de ZP et GIS manuellement, soit elles sont issue directement d'un fichier CSV.

D'où la question:

  (initget 1 "Oui Non")
 (setq kw (getkword
            "\nVoulez-vous utiliser un fichier csv? [Oui/Non]: "

 

Ce que je voudrais, c'est qu'en répondant oui à la question, j'ai la possibilité de modifier ces valeurs manuellement, mais en ayant par défaut les valeurs du listing.

 

Sur Covadis, on a un peu ça quand on lance la commande de création de polyligne 3D (commande Covadis) et qu'on choisit l'option "Saisir l'altitude pour chaque point". Si on clic en accrochage objet un point en 3D, il va nous proposer la valeur de ce point 3D, mais on peut aussi la modifier.

Exemple:

http://img4.hostingpics.net/pics/734165Capture.jpg

[(gile)]

Salut,

 

Quatre petites remarques en lisant le code en diagonale :

 

1. sortir la définition (defun str2lst ...) de str2lst de la boucle while (il est inutile de redéfinir la fonction à chaque itération)

 

2. ne pas assigner de valeur à sep dans la définition de str2lst. sep est un argument de la fonction, on assigne sa valeur dans l'appel de fonction :

(setq lst (str2lst str ";"))

3. déclarer localement la fonction *error* pour qu'elle ne soit pas redéfinie dans ce document pour toute la session.

 

4. l'utilisation de (command "_.undo" "_group") au début du code et (command "_.undo" "_end") uniquement à la fin du code n'est pas très sure. Si une erreur (ou une annulation) intervient avant la fin, le groupe undo n'est pas terminé et annuler plusieurs opérations risque de provoquer une erreur fatale.

Il serait prudent d'ajouter (command-s "_.undo" "_end") dans la fonction (locale) *error*.

[(gile)]

Re,

 

Généralement, pour proposer des valeurs par défaut, il faut stocker les valeurs de celles-ci en fonction de leur portée et de leur durée :

• dans des variables globales (dans le dessin, le temps de la session)
  
• dans des dictionnaires (dans le dessin, pérenne)
  
• dans la base de registre (dans tous les dessin, pérenne)
  

Ensuite, on laisse la possibilité à l'utilisateur de faire Entrée au lieu de répondre à l'invite pour l'assignation d'une variable locale. Si l'utilisateur à répondu à l'invite, on modifie la valeur par défaut avec la nouvelle valeur, sinon, on assigne la valeur par défaut à la variable locale.

 

Un petit exemple avec des variables globales pour dessiner un cercle. Une fonction locale est utilisée pour convertir un point (liste de réels) en chaîne pour écrire la valeur par défaut du centre dans l'invite.

 

(defun c:test (/ ptos basePoint radius)

 ;; fonction locale
 ;; convertit un point en une chaîne
 (defun ptos (pt)
   (strcat
     (rtos (car pt))
     ","
     (rtos (cadr pt))
     (if (caddr pt)
       (strcat "," (rtos (caddr pt)))
       ""
     )
   )
 )

 ;; initialisation des variables globales (valeurs par défaut)
 (or *defaultBasePoint* (setq *defaultBasePoint* '(0. 0. 0.)))
 (or *defaultRadius* (setq *defaultRadius* 42.))
 
 (if (setq basePoint
            (getpoint
              (strcat
                "\nCentre <"
                (ptos *defaultBasePoint*)
                ">: "
              )
            )
     )
   (setq *defaultBasePoint* basePoint)
   (setq basePoint *defaultBasePoint*)
 )
 
 (initget 6)
 (if (setq radius
            (getdist
              basePoint
              (strcat
                "\nRayon <"
                (rtos *defaultRadius*)
                ">: "
              )
            )
     )
   (setq *defaultRadius* radius)
   (setq radius *defaultRadius*)
 )

 (command-s "_.circle" "_non" basePoint radius)
 (princ)
)

[La Lozère]

Merci (gile).

Le truc c'est que si je sort la fonction str2lst de la boucle, ça ne marche plus. Il me déplace mes objets de chaque séquences aux coordonnées de la première ligne de mon fichier CSV.

 

Voici le code modifié:

(defun c:gpoi (/      fichier	    sep	   pos	  str	 lst	num_pt
       xzp    yzp    zzp    gis	   zp	  str2lst	kw    *error*
       sel    pb
      )
;;;
;;;gestion d'erreur
 (defun *error* (msg)
   (if	(/= msg "Fonction annulée")
     (princ (strcat "\nErreur: " msg))
   )
   (if	fichier
     (close fichier)
   )
   (princ)
 )
;;; 
(defun	str2lst	(str sep / pos)
   (if (setq pos (vl-string-search sep str))
     (cons (substr str 1 pos)
	   (str2lst (substr str (+ (strlen sep) pos 1)) sep)
     )
     (list str)
   )
)
;;;
 (initget 1 "Oui Non")
 (setq	kw (getkword
     "\nVoulez-vous utiliser un fichier csv? [Oui/Non]: "
   )
 )
;;;
;;;          Boucle pour OUI
 (if (= "Oui" kw)
   (progn
     (setq
fichier	(open (getfiled "Fichier .CSV à  ouvrir" "" "csv" 8)
	      "r"
	)
     )
;;;
(setq str (read-line fichier))
     (while
 (setq lst (str2lst str ";"))
 (setq num_pt (car lst))
 (setq xzp (atof (cadr lst)))
 (setq yzp (atof (caddr lst)))
 (setq zzp (atof (cadddr lst)))
 (setq gis (atof (car (cdr (cdr (cdr (cdr lst)))))))
 (setq zp (list xzp yzp zzp))
 (setq sel (ssget))
 (setq pb (getpoint "\nPoint de base du déplacement: "))
;;;
;;;Déplacement
 (command "_move" sel "" pb zp)
 (command "3DROTATION" sel "" "x" zp "300")
 (command "_rotate" sel "" zp gis)
     )
     (close fichier)
   )
 )
;;;
;;;
;;;              Boucle pour NON
 (if (= "Non" kw)
   (progn
;;; Entrée utilisateur
     (setq sel (ssget))
     (setq pb (getpoint "\nPoint de base du déplacement: "))
     (setq zp (getpoint pb "\nSpécifier les coordonnées du ZP: "))
     (setq gis (getreal "\nSpécifier la valeur du gisement: "))
;;;
;;;Déplacement
     (command "_move" sel "" pb zp)
     (command "3DROTATION" sel "" "x" zp "300")
     (command "_rotate" sel "" zp gis)
;;;
   )
 )
 (princ)
)

[didier]

Coucou

 

Il me déplace mes objets de chaque séquences aux coordonnées de la première ligne de mon fichier CSV.

qu'est-ce que ça peut bien vouloir dire !!!

[La Lozère]

Alors:

1 - Dans le fichier CSV sur chaque ligne il y a des info du numéro de point, les coordonnées du point et le gisement

2- Mon lisp est censé déplacer des objets sélectionnées aux coordonnées du point (et d'autre actions).

3- Pour chaque ligne du CSV, je sélectionne des objets différents, d'où le WHILE et ce jusqu'à la fin du CSV

 

Le truc, c'est qu'en modifiant le code suivant les info de (gile) à savoir sortir str2lst de la boucle, j'ai l'impression que mes variables (coordonnées du point, et autres)ne change pas entre chaque sélection d'objet.

Je sélectionne mes premiers objets, et hop ça part au bon endroit. Suite de la boucle. Je sélectionne mes nouveaux objets, et patatra, ça part au même endroit que précédemment. Alors que les variable aurais du changer et prendre les valeurs de la deuxième ligne.

 

Ca ne faisait pas ça quand str2lst était dans la boucle.

 

Mon CSV en PJ

Classeur1.zip

[didier]

Coucou

 

je ne pense qu'il faille faire comme ça, sans te manquer de respect.

 

il faudrait (avec ma façon de penser) : donner le nom du profil à traiter et ENSUITE aller lire dans le CSV la ligne correspondante et donc en extraire les bonnes données,

PUIS

traiter le profil,

PUIS passer à un autre

 

je ne vois pas trop comment tu as organisé ça dans ton algorithme pour l'instant.

 

Amicalement

[DenisHen]

Salut.

 

Donc, juste histoire de comprendre, tu lance ton LISP qui lit la première ligne du CSV, tu sélectionnes une ou plusieurs entités, tu fais [ENTRER], les entités se déplacent vers les coordonnées de la ligne lu, puis, le LISP lit la ligne suivante et ainsi de suite ?

[(gile)]

Regarde bien ta dernière version.

Tu as sorti plus que la définition de str2lst de la boucle.

Où est passée la condition de sortie du while ?

 

À mon avis, tu devrais séparer les taches :

• d'abord, lire le fichier et stocker chaque ligne dans une liste (boucle while)
  
• ensuite traiter chaque ligne de la liste (boucle foreach)
  

Cette façon permet de tester et de déboguer plus facilement chaque partie séparément et elle est aussi plus sûre : le fichier est simplement lu avant d'être refermé.

 

Tu peux juste faire les deux boucles l'une à la suite de l'autre dans la même fonction (c:gpoi).

Tu peux aussi définir une fonction qui lit un fichier texte et retourne une liste de chaîne et appeler cette fonction.

 

;; readFile
;; Lit la totalité d'un fichier texte.
;; Retourne une liste contenant toutes les lignes.
;;
;; Argument
;; filename : le nom du fichier (chemin complet s'il n'est pas dans les chemins de recherche).

(defun readFile (filename / file line lst)
 (if (setq filename (findfile filename))
   (progn
     (setq file (open filename "r"))
     (while (setq line (read-line file))
       (setq lst (cons line lst))
     )
     (close file)
   )
 )
 (reverse lst)
)

 

et ensuite :

(setq fichier (getfiled "Fichier .CSV à  ouvrir" "" "csv" 8))
(foreach str (readFile fichier)
 (setq lst (str2lst str ";"))
 ...
)

[La Lozère]

(gile) merci pour ton exemple. J'avais en fait tout sous la main, il me manquait juste strcat et

    (setq *defaultRadius* radius)
   (setq radius *defaultRadius*)

 

 

Salut Didier,

Tu ne me manques pas de respect, mais comme pour Autocad, et très souvent pour toutes choses il y a plusieurs façon d'arriver à ces fins. Et dans le cas présent, je n'ai pas la même que toi.

 

Voici comment fonctionne globalement mon lisp:

Au lancement de la commande il me demande si je veux extraire des valeurs d'un fichier ou les saisir manuellement

 

Donc, si la réponse et non:

1- je sélectionne mes objets du profil voulu

2- je sélectionne par clic le point de base

3- je saisi manuellement ou par clic les coordonnées de destination

4- je saisi manuellement le gisement

5- A la validation tout ce met en place

6- Si besoin je relalance la commande

 

Si la réponse est oui (avec la modif faite grâce à (gile):

1- une boite de dialogue s'ouvre afin de sélectionner le CSV dans lequel se trouve les données du type "PT-1;815679.200;6299727.790;78.056;292.310", "PT-2;815659.345;6299725.385;78.256;292.339", etc et autant de ligne que de profils

2- Début de la boucle

3- je sélectionne mes objets du profil voulu

4- je sélectionne, par clic, le point de base

5- Je sélectionne, par clic, manuellement ou je valide la proposition, les coordonnées de destination

6- Je saisie ou je valide la proposition de gisement

7- A la validation tout ce met en place

8- etc... jusqu'à la fin de la boucle, soit la fin des lignes du CSV

9- Fin de la boucle

 

Donc, pour l'instant tout marche. Sauf que quand je sort de la boucle str2lst là, ça bug

[La Lozère]

Donc, juste histoire de comprendre, tu lance ton LISP qui lit la première ligne du CSV, tu sélectionnes une ou plusieurs entités, tu fais [ENTRER], les entités se déplacent vers les coordonnées de la ligne lu, puis, le LISP lit la ligne suivante et ainsi de suite ?

C'est presque çà. Avant le déplacement, je saisi le point de base du déplacement

[La Lozère]

Merci (gile), effectivement j'avais sorti trop de chose de la boucle.... <_<

 

Bon, je pense être arrivé à ce que je voulais avec ce code:

(defun c:PT2dto3D (/      fichier	    sep	   pos	  str	 lst	num_pt
       xzp    yzp    zzp    gis	   zp	  str2lst	kw
       *error*	     *zp*   *gis*  sel	  pb
      )
;;;
;;;gestion d'erreur
 (defun *error* (msg)
   (if	(/= msg "Fonction annulée")
     (princ (strcat "\nErreur: " msg))
   )
   (if	fichier
     (close fichier)
   )
   (princ)
 )
;;; 
 (defun str2lst (str sep / pos)
   (if	(setq pos (vl-string-search sep str))
     (cons (substr str 1 pos)
    (str2lst (substr str (+ (strlen sep) pos 1)) sep)
     )
     (list str)
   )
 )
;;;
 (initget 1 "Oui Non")
 (setq	kw (getkword
     "\nVoulez-vous utiliser un fichier csv? [Oui/Non]: "
   )
 )
;;;
;;;          Boucle pour OUI
 (if (= "Oui" kw)
   (progn
     (setq
fichier	(open (getfiled "Fichier .CSV à  ouvrir" "" "csv" 8)
	      "r"
	)
     )
;;;
     (while
     (setq str (read-line fichier))
  (setq lst (str2lst str ";"))
  (setq num_pt (car lst))
  (setq xzp (atof (cadr lst)))
  (setq yzp (atof (caddr lst)))
  (setq zzp (atof (cadddr lst)))
  (setq gis (atof (car (cdr (cdr (cdr (cdr lst)))))))
  (setq zp (list xzp yzp zzp))
  (setq sel (ssget))
  (setq pb (getpoint "\nPoint de base du déplacement: "))
  (if (setq
       *zp* (getpoint
	      (strcat
		"\nSpécifier les coordonnées du ZP du profil "
		(car lst)
		"\: <"
		(cadr lst)
		"\ "
		(caddr lst)
		"\ "
		(cadddr lst)
		">: "
	      )
	    )
     )
   (setq zp *zp*)
   (setq *zp* zp)
  )
				;
  (if (setq
       *gis* (getreal
	       (strcat
		 "\nSpécifier la valeur du gisement du profil "
		 (car lst)
		 "\: <"
		 (car (cdr (cdr (cdr (cdr lst)))))
		 ">: "
	       )
	     )
     )
   (setq gis *gis*)
   (setq *gis* gis)
  )
;;;
;;;Déplacement
 (command "_move" sel "" pb zp)
 (command "3DROTATION" sel "" "x" zp "300")
 (command "_rotate" sel "" zp gis)
     )
     (close fichier)
   )
 )
;;;
;;;
;;;              Boucle pour NON
 (if (= "Non" kw)
   (progn
;;; Entrée utilisateur
     (setq sel (ssget))
     (setq pb (getpoint "\nPoint de base du déplacement: "))
     (setq zp (getpoint pb "\nSpécifier les coordonnées du ZP: "))
     (setq gis (getreal "\nSpécifier la valeur du gisement: "))
;;;
;;;Déplacement
     (command "_move" sel "" pb zp)
     (command "3DROTATION" sel "" "x" zp "300")
     (command "_rotate" sel "" zp gis)
;;;
   )
 )
 (princ)
)

 

J'ai bien encore une erreur aléatoire:

Commande: PT2dto3D

Voulez-vous utiliser un fichier csv? [Oui/Non]: O

Erreur: type d'argument incorrect: FILE nil

Mais si je ferme Autocad, et que je ré-ouvre mon fichier, ça marche ou pas.... :blink:

J'ai comme l'impression que ça a un rapport avec le fait que j'ai la variable startup à 2

 

Je vous mets en WeTransfert un exemple avec le DWG, le CSV, le LSP

A TELECHARGER

 

C'est forcément améliorable, et je vais regarder ce qu'il est possible de faire. Mais là, pour l'instant, ça fait le boulot.

 

(gile) je vais regarder ce que tu propose comme adaptation, et notamment la boucle foreach.

 

En tout cas gros merci à vous pour mes re-début dans le monde du lisp....

[didier]

Coucou

 

Plutôt qu'aller chercher le gisement dans un fichier tu pourrais cliquer sur le peigne de tabulation et en extraire le gisement qui te servirait à la rotation

Idem pour le point d’insertion en XY, chercher l'intersection de l'axe en plan et du peigne, c'est assez simple à trouver.

Non ?

 

Je ne te rejoins pas sur la complexité de sélection des entités et des entrées utilisateurs,

Tu as de gros risques d'erreurs, mais si ça te va, soit !.

 

Amicalement

[La Lozère]

Oui effectivement, cliquer le peigne serait une idée. A voir, car suivant le sens de description de l'objet ça pourrait tourner à l'envers :(rires forts):

Et pour les XY, également, bonne idée. Encore qu'ici on peut faire un filtre de coordonnées .xy

A tester.... Merci pour les idées