Raccords multiples

[nG! Hebus]

Salut,

 

Choses promises, choses dues, je viens vous ennuyer avec ce bout de code...

je n'arrive pas à trouver comment lui dire de segmenter les commandes... Je voudrais d'abord effectuer la première command puis passer à la suivante "p" de fois... Mais je vois pas comment (PS : y'a des choses à redire à ce bout de code, j'en suis conscient et je prend toutes les critiques constitutivement :P )

 

;; Ce programme permet d'effectuer rapidement des raccords multiplent avec un décalage d'une valeur définie
;;Entrées utilisateur, donnée du premier rayon et du décalage entre les polys !

(defun c:mult_r ()
      (if 								;début de la commande "if"
(initget 7) 						;Verrouillage utilisateur pour "a"
	(setq a (getpoint "n\Définir le premier rayon : "))	;Entrée "a" pour le premier rayon
(initget 7)						;Vérrouillage utilisateur pour "b"
	(setq b (getpoint "n\Décalage du rayon : "))		;Entrée "b" pour les rayons suivants
(initget 7)
	(setq p (getpoint "n\Nombre de décalage : "))		;Ajoute l'argument "p" décalage
      	(getcname "raccord" "r" "a" "raccord")				;Sélection de l'argument pour le premier rayon
(getcname "raccord" "r" "+ a b" "raccord")			;Sélection de l'argument pour les rayons suivants
(princ)								
)
(princ)

[(gile)]

Salut,

 

Pour les entrées utilisateurs, utilise la fonction correspondant au type de valeur que tu veux obtenir (getpoint, c'est pour obtenir un point, getcname, ce n'est pas pour une entrée utilisateur, c'est pour avoir le nom global ou local d'une commande).

 

Pour les entrées utilisateur, c'est chapitre 7 de Introduction à AutoLISP ou >>ici pour da-code (le site de didier).

[(gile)]

Et n'hésite pas à aller voir dans l'aide (sélection de le fonction puis Ctrl+F1) et à faire des tests avec de simples expressions depuis la console de l'éditeur Visual LISP ou depuis la commande

[(gile)]

Encore un truc, vas-y progressivement.

Fais d'abord une première routine pour faire les raccords que tu essayes d'aboutir, et seulement ensuite tu ajoutes d'abord un seul décalage et quand ça marche, tu passes aux décalages multiples.

En faisant ainsi tu évites de te retrouver submergé par trop de choses à résoudre d'un seul coup.

[nG! Hebus]

Salut Gile,

 

Alors effectivement pour le moment je n'arrive pas à allez rechercher la valeur "a"...

je veux bien un exemple, car j'arrive pas à trouver comment allez la rechercher...

 

(defun c:mult_r ()
      	(initget 7) 						;Verrouillage utilisateur pour "a"
	(setq a (getpoint "\Définir le premier rayon : "))		;Entrée "a" pour le premier rayon
      	(command "raccord" "r" "a" "raccord" )				;Sélection de l'argument pour le premier rayon
 	(setq ent (entsel "\nCliquez sur la premiere MPL :" ))		;Sélection à l'écran de la pre PL
(princ)							
)
(princ)

 

j'ai beaucoup de mal à visualisé les termes et ce à quoi ils servent sans exemple... Je me perd dans l'intro au LISP et sur le site de didier... Je ne suis pas habitué au terme lié à AutoLISP et du coup c'est quasi impossible de s'y retrouver... Est ce que quelqu'un a des petits LISP d'exemple de fonctions simples :

 

-Créer une ligne : (ça j'ai trouvé !)

-Créer un volume 3D : (ça j'ai trouvé aussi :) ! )

-Demander une entrée à l'utilisateur et la ré-exploiter (pas trouvé...)

-Demander plusieurs entrée et les ré-exploiter (pas trouvé...)

-Faire des calculs à travers des fonctions simples (sélection à l'écran) et tracer les éléments qui en découlent (j'ai trouvé)

-Entrer dans un bloc pour aller chercher une valeur (j'ai trouvé pour aller la chercher mais pas pour l'exploiter...)

[(gile)]

Les fonctions getxxx (excepté getcname) sont utilisée pour récupérer des entrées utilisateur.

Toutes permettent d'entrer une valeur au clavier et la plupart de le faire aussi à l'écran avec la souris.

Suivant le type de données, on choisis l'une ou l'autre et le type de valeur de retour correspond à la fonction utilisée

Au clavier ou à la souris

getpoint invite l'utilisateur à spécifier un point et retourne un point (liste de 3 nombres) ou nil.

getcorner invite l'utilisateur à spécifier un point et retourne un point (liste de 3 nombres) ou nil.

getdist invite l'utilisateur à spécifier une distance et retourne un nombre réel ou nil.

getangle invite l'utilisateur à spécifier un angle et retourne un nombre réel ou nil.

getorient invite l'utilisateur à spécifier une orientation et retourne un nombre réel ou nil.

Au clavier uniquement

getint invite l'utilisateur à spécifier un nombre entier et retourne un nombre entier ou nil.

getreal invite l'utilisateur à spécifier un nombre réel et retourne un nombre réel ou nil.

getstring invite l'utilisateur à spécifier une chaîne de caractères et retourne une chaîne de caractères ou "".

getkword invite l'utilisateur à spécifier un mot clé (option) et retourne une chaîne de caractères ou nil.

 

Un petit exemple fait à partir du tien pour montrer comment on récupère des entrées utilisateur pour les passer à une commande :

 

(defun c:mult_r (/ rayon ent) ; <- déclaration locale des variables
 
 ;; force l'utilisateur à spécifier un nombre strictement positif
 (initget 7)
 
 ;; invite l'utilisateur à spécifier une distance
 (setq rayon (getdist "\nDéfinir le premier rayon : "))
 
 ;; invite l'utilisateur à sélectionner une entité
 (setq ent (entsel "\nCliquez sur la premiere MPL :"))
 
 ;; lance la commande raccord
 ;; et lui passe les entrées utilisateurs récupérées ci-dessus
 (command "_fillet" "_r" rayon "_p" (car ent))
 
 (princ) ; sortie silencieuse
)

[nG! Hebus]

Salut Gile,

 

Et merci de prendre du temps pour éclaircir les points noirs :)

 

Donc en fait le seul soucis que j'avais ici (entre guillemet) c'est que la variable utilisateur a/rayon je l'avais mise entre "a"... Du coup je vois pourquoi il n'appelait pas la variable mais il cherchait dans la (command) une entité appelé "a" correspondant à une cible de la commande réelle autocad...

 

 

NOTA pour moi (histoire de voir si j'ai compris) :

-> avec les "" -> appel une valeur autocad (cherche une valeur : exemple pour un cercle [3P 2P Ttr] :)

-> sans les "" ->Retourne une variable définie (utilisateur et/ou valeur calculée, : exemple :(setq X(entsel "\ntexte affiché")) )

 

 

HORS NOTA :

Et quand tu met "car" -> cela permet d'appliqué à ta variable (ent) la valeur du "_fillet" donné plus tôt par (rayon) c'est ça?

 

 

PS : Et la tu te dit que ça va être plus dur que tu le croyais, alors imagine de mon coté comment je me retrouve comme un con à me battre entre variable/argument...

[(gile)]

Salut Gile,

 

Et merci de prendre du temps pour éclaircir les points noirs :)

 

Donc en fait le seul soucis que j'avais ici (entre guillemet) c'est que la variable utilisateur a/rayon je l'avais mise entre "a"... Du coup je vois pourquoi il n'appelait pas la variable mais il cherchait dans la (command) une entité appelé "a" correspondant à une cible de la commande réelle autocad...

 

 

NOTA pour moi (histoire de voir si j'ai compris) :

-> avec les "" -> appel une valeur autocad (cherche une valeur : exemple pour un cercle [3P 2P Ttr] :)

-> sans les "" ->Retourne une variable définie (utilisateur et/ou valeur calculée, : exemple :(setq X(entsel "\ntexte affiché")) )

 

 

Justement parlons "guillemets.

En LISP un mot sans guillemets et sans espaces comme a ou rayon ou c:mult_r est un symbole (type SYM) comme le sont tontes les fonctions prédéfinies. On utilise des symboles pour les noms de variable et de fonction.

Un symbole contient une valeur et il est évalué sauf s'il est "quoté" avec la fonction quote ou son raccourci l'apostrophe (').

 

Un mot entre guillemets comme "a" ou "_fillet" ou "Ceci est un exemple" est une chaîne de caractères (type STR). Un chaîne de caractère (comme un nombre entier ou réel) n'est pas évaluée, c'est une expression dite autoévaluante.

 

La fonction command accepte que les entrées (options ou paramètres) soient de type chaîne ou du type LISP correspondant à la valeur attendue.

On peut passer à command une chaîne correspondant à ce qu'on entrerait au clavier :

(command "_point" "10,5")

tout comme on peut lui passer un point LISP (une liste de 2 ou 3 nombres)

(command "_point" '(10 5))

tout comme on peut lui passer une variable qui contient un point (la variable est alors évaluée

(setq pt '(10 5))
(command "_point" pt)

 

HORS NOTA :

Et quand tu met "car" -> cela permet d'appliqué à ta variable (ent) la valeur du "_fillet" donné plus tôt par (rayon) c'est ça?

Il est fondamental de comprendre que toute expression LISP renvoie une valeur et que quand on appelle une fonction celle-ci renvoie une valeur qu'il est impératif de connaitre le type de cette avant d'essayer de s'en servir.

La fonction getpoint renvoie un "point" (liste de 3 nombres) ou nil.

La fonction getdist renvoie un nombre réel ou nil.

La fonction entsel renvoie une liste contenant un nom d'entité (type ENAME) et le point cliqué (ou nil).

Donc quand tu fais (tu peux essayer depuis la ligne de commande ou la console Visual LISP) :

(setq ent (entsel "\nCliquez sur la premiere MPL :"))

ent contient une liste du genre:

( (124.054 -13.8985 0.0)) ou nil si l'utilisateur a fait Entrée ou cliqué dans le vide.

Dans notre cas, pour la suite du programme, ce qui nous intéresse c'est le nom d'entité, autrement dit le premier élément de cette liste.

La fonction car (fonction fondamentale de tous les langages LISP avec cdr et cons), la fonction car, donc, renvoie le premier élément de la liste qui lui est passée en argument :

(car ent)

renvoie le premier élément de ent soit le nom d'entité de l'entité sélectionnée.

 

Plutôt que d'essayer de deviner ce que fait une fonction (surtout avec le peu de connaissances que tu as encore) n'hésite pas à consulter la documentation et à faire des tests dans la console ou à la ligne de commande, c'est un énorme avantage des langages interprétés comme AutoLISP que de pouvoir évaluer directement aussi bien une simple expression ou une variable qu'un gros programme.

[nG! Hebus]

Salut c'est encore moi !

 

J'en suis la :

 

;; Ce programme permet d'effectuer rapidement des raccords multiplent avec un décalage d'une valeur définie
;;Entrées utilisateur, donnée du premier rayon et du décalage entre les polys, ainsi que la quantité de décalage !

(defun c:mult_r ()
      	(initget 7) 						;Verrouillage utilisateur pour "a"
	(setq a (getpoint "\Définir le premier rayon : "))		;Entrée "a" pour le premier rayon
	(setq b (getpoint "\Décalage entre les fils : "))		;Entrée "b" pour le décalage à appliquer
      	(command "raccord" "r" a nil "raccord" )				;Sélection de l'argument pour le premier rayon

JUSQUE LA TOUT VA BIEN, MAIS ENSUITE...


        (command "raccord" "r" + a b nil "raccord" )			;Sélection de l'argument pour la fonction suivante supérieure
(command "raccord" "r" - a b nil "raccord" )			;Sélection de l'arugment pour la fonction suivante inférieure
(princ)
)
(princ)

 

 

Mais je n'arrive pas à lui faire lire les (command ) suivantes... La première il me la prend (si tu retire les lignes du dessous tout marche bien (enfin comme je le souhaite, car finalement dans ton code tu sélectionne une POLYLIGNE et je souhaite que ça fonctionne peu importe le type "ligne" ou polyligne)

 

J'ai un autre truc bizare aussi, si je ne met pas le "nil" il me demande un deuxiéme point?! (getpoint ) n'attend pas une distance?

 

Et du coup je met un screen du but à atteindre :) (enfin ce que je souhaite que "mon" LISP fasse à la fin )

 

 

PS : Oui dans ce cas la c'est des PL, mais on a des gens en interne pas...comment dire sans être méchant :o ...

 

 

Du coup je vais voir mais je pense que l'étape suivante sera une multi-sélection, avec une vérification de points (extrémités de chaque PL) puis en fonction de leur position un raccord + b ou - b , mais la j'y suis pas encore (je suis en train de regarder les exercices de Didier pour m'en inspirer )