Comment créer un point avec... différentes données

[DenisHen]

Bonsoir à tous...

 

Voilà, je tente de faire une fenêtre dans l'EP. J'ai quatre points dans l'EO (Pt1=bas gauche ; Pt2=bas droit ; Pt3=haut droit et Pt4=haut gauche)

 

j'aimerais faire une fenêtre dans l'EP, j'ai les bonnes longeurs et hauteur grace à ces quatre points multipliés par le dixième de l'échelle (j'ai pô compris pourquoi).

 

Sachant que echelle="200.0" (oui, une chaine). J'ai donc écris ça (car je n'ai pas trouver à faire une fenêtre en deux points) :

  ;;Calcul des quatres points de le nouvelles fenêtre*************
 (setq pt1_ep (list (0.1 0.1)))
 (setq pt2_ep (list (0.1 (+ (/ (* (distance pt1 pt2) (atof echelle)) 10) (car pt1_ep)))))
 (setq pt3_ep (list (car pt2_ep) (+ (/ (* (distance pt2 pt3) (atof echelle)) 10) 0.1)))
 (setq pt4_ep (list (car pt1_ep) (cadr pt3_ep)))

 

Mais je crains que ma construction de points (en fait, la création d'une liste de deux données pour chaque point) ne soit pas appropriée.

 

car je fais :

(command "-fenetres" "po" Pt1_ep Pt2_ep Pt3_ep Pt4_ep)

Mais ca ne fonctionne pas... J'obtient :

Définition des points de l'espace papier; erreur: fonction incorrecte: 0.1

En fait, je crois mal créer mes listes de points...

 

J'espère être "claire"...(Maître didier, si tu me lis...Cette ligne est pour toi... ;) )

 

Je cherche toujours à créer une liste d'après plusieurs données (j'attend avec impatience ma formation LISP chez un Maître ! ! !)

[(gile)]

Salut,

 

Dans la console de l'éditeur Visual LISP (ou directement en ligne de commande), teste les expressions suivantes :

(setq pt1_ep (list (0.1 0.1)))

(list (0.1 0.1))

(0.1 0.1)

 

Relis attentivement le chapitre 1.2 de "Introduction à AutoLISP" :

1.2.1 Évaluation des applications de fonction

1.2.2 Données sous forme de listes (quote)

Ainsi que le chapitre 8.1 :

Construction des listes (quote list cons)

 

Pose toi la question : comment interpréter le message d'erreur ?

Les messages d'erreur AutoLISP on en général la forme :

; erreur: :

[didier]

Coucou

 

Tu ne te poses pas les bonnes questions, par contre tu fais des efforts d'explications qui sont appréciés

Tu ne lis pas bien les diverses aides fournies, l'introduction de (gile) ou da-code ni les autres d'ailleurs

Si tu testes dans la console la réponse ne se fait pas attendre

 

Amicalement

 

 

[didier]

Coucou

 

Tu m'as mis le doute ...

J'ai expliqué, du moins il me semble, a minima j'ai mis un exemple qui explique comment faire des points comme tu as besoin ici.

Il faut lire, relire, et quand on a lu on relit

C'est comme les contrôles dans le travail, il faut contrôler, re-contrôler et quand c'est fait on contrôle...

Surtout avec le métier dont tu viens tu devrais être habitué à cette façon de faire

 

C'est ICI

 

 

Amicalement

[DenisHen]

Salut à tous, et un grand merci pour vos réponses.

 

@(gile) : J'ai fais des testes dans la console (ce que je fais de plus en plus souvent), et voici le résultat :

_$ (0.1 0.1)

_$ (list (0.1 0.1))

; erreur: fonction incorrecte: 0.1

_$ (setq pt1_ep (list (0.1 0.1)))

_$ pt1_ep

nil

_$ (list '(0.1 0.1))

((0.1 0.1))

_$ (list (0.1 0.1))

; erreur: fonction incorrecte: 0.1

_$ '(0.1 0.1)

(0.1 0.1)

_$

J'avoue ne pas savoir trop quoi en faire.

 

@didier : J'ai bien lu et relu jusqu'à croire que j'avais compris, mais construire une liste à l'air beaucoup plus compliqué pour un profane (comme moi) que vous semblez le croire, ce n'est que mon avis bien-sur...

 

Mais je vais tout relire encore une fois pour suivre vos conseils...

 

Encore merci à vous...

 

Denis...

[(gile)]

Les fondamentaux

 

Une expression LISP est :

- soit un atome : un nombre (INT, REAL), une chaine STR, un nom d'entité (ENAME), un jeu de sélection (PICKSET), une fonction (SUBR, USUBR, EXRXSUBR), etc.

- soit une liste d'expressions LISP

 

Une liste LISP commence par une parenthèse ouvrante et se termine par une parenthèse fermante.

Entre ces parenthèses elle peut contenir des expressions LISP (CF ci-dessus) séparées par des espaces, ou rien (cas particulier de la liste vide : nil).

 

En règle générale, quand la liste n'est pas vide, la première expression juste derrière la parenthèse ouvrante est une fonction, les expressions suivantes sont les arguments de cette fonction. On appelle ce type de liste une "application de fonction".

La seule exception au cas général ci-dessus est la liste utilisée comme structure de données, autrement dit une collection d'expressions ne devant pas être évaluées (une liste de trois nombres pour représenter un point, par exemple). Dans ce cas, il faut empêcher l'évaluation de la liste, on utilise pour ça la fonction quote ou son abréviation : l'apostrophe (').

 

En résumé, toute parenthèse ouvrante non précédée de la fonction quote (ou d'une apostrophe) est considérée comme le début d'une application de fonction et doit donc être directement suivie d'une expression de type fonction.

[didier]

Coucou

 

Faire des tests signifie "essayer"

Qu'est-ce que ça t'aurais coûté de tester :

(setq pt1 (list 0.1 0.1))
(setq test (list (list 0.1 0.1)))

 

Et de regarder les résultats ? la console est là pour ça.

Tu ne vas pas mettre le feu à ta machine en déclenchant une erreur en AutoLISP, vas-y essaye...

 

Amicalement

[Aleck_Ultimate]

Salut.

 

Dans un cas un peu semblable je n'ai réellement compris à quoi servait QUOTE que mercredi dernier (à force de me casser la gueule sur mon tapis roulant) , ce qui a résolu 75% de mes difficultés sur le code en cours (qui consistait à reprendre les exercices proposés par Didier sur son site avec ENTMAKE à la place de COMMAND).

 

Je crois que c'est le genre de choses qui ne peut s'apprendre que en butant dessus. Comme pour "le feu ça brûle".

 

Cette fonction abrégée en ' est ultra-basique pour des habitués, mais je crois qu'elle mériterait un peu plus de détails sur son aplication. Peut-être en ajoutant deux ou trois lignes à ses exemples sur ton site, Didier ?

 

Maintenant que je me rend compte que je ne suis pas le seul a avoir (longtemps) buté là-dessus, et DenisHen est beaucoup plus avancé que moi, je me dit que c'est peut-être un piège classique chez les autodidactes, cette apostrophe qu'on met ou enlève un peu au hasard jusqu’à ce que ça marche sans forcément comprendre comment.

[didier]

Coucou

Mise à jour sur da-code ICI

Dans l'attente des retours d'information...

Merci d'utiliser le formulaire de contacts pour me répondre, je garde trace des questions et des réponses par ce biais, le MP sur CadXP est volatil

 

Amicalement

[DenisHen]

Salut à tous, et merci pour vos réponses, collégiales...

 

Entre jour férié, congé imposé, jour férié, congé imposé.... Je ne sais plus quel jour on est...

 

Donc, après les balades en VTT le long du canal de Bourgogne, les promenades des chiens dans les bois, re VTT, re balades... Recherche des fleures d'accacia (en beignet, c'est un régal), puis re VTT et tout et tout... Je suis donc de "retour"... J'aimerais progresser dans mon projet perso... Et pour ça, il faut que je m'investisse sur mon temps libre...

 

J'ai donc tenté de faire selon vos conseils (celà dit, Aleck, je n'ai pas le niveau que tu penses ;) . Je ne touche pas encore à (entmake par exemple...)

 

J'ai donc fais plusieurs essais dans la console, voici mes tentatives de compréhension, je vous dévoile tout mon "processus" intellectuel (s'il existe) pour que vous compreniez mieux les méandres syntaxiques auxquels peuvent avoir à faire les novices (comment ça se passe dans le cerveau des profanes et autres débutants comme moi) :

_$ (list (+ 2 3) 1)

(5 1) ==> Bon, là, ça va

_$ (list (cons (+ 2 3) (cons 1))) ==> j'ai compris qu'il manquait une parenthèse après le "3"

; erreur: nombre d'arguments insuffisants

_$ (cons (+ 2 3)) ==> je ne sais pas pourquoi je n'ai pas eu de retour de la console

_$ (setq pt2_ep (list (0.1 (+ (/ (* 600 250) 100) 0.1))))

; erreur: fonction incorrecte: 0.1 ==> je pense qu'il ne fallait pas de parenthèse avant le "0.1"

_$ (setq pt2_ep (list (0.1) (+ (/ (* 600 250) 100) 0.1)))

_$ pt2_ep

nil ==> Rien compris

_$ (setq pt2_ep (list '(0.1) '(+ (/ (* 600 250) 100) 0.1)))

((0.1) (+ (/ (* 600 250) 100) 0.1)) ==> j'ai vu que j'avais interdis l'évaluation avec le '

_$ (setq pt2_ep (list (cons (0.1)) (cons(+ (/ (* 600 250) 100) 0.1))))

; erreur: fonction incorrecte: 0.1 ==> Rien compris

_$ (setq pt2_ep (list 0.1 (cons(+ (/ (* 600 250) 100) 0.1))))

_$ pt2_ep

((0.1) (+ (/ (* 600 250) 100) 0.1)) ==> j'ai vu que j'avais interdis l'évaluation avec le (cons

_$ (setq pt2_ep (list '(0.1) (cons(+ (/ (* 600 250) 100) 0.1))))

; erreur: nombre d'arguments insuffisants ==> Rien compris

_$ (setq pt2_ep (list (cons 0.1) (cons(+ (/ (* 600 250) 100) 0.1))))

_$ pt2_ep

((0.1) (+ (/ (* 600 250) 100) 0.1)) ==> j'ai vu que j'avais interdis l'évaluation avec les (cons

_$ (setq pt2_ep (list 0.1 (+ (/ (* 600 250) 100) 0.1))))

(0.1 1500.1)

; erreur: parenthèse fermante supplémentaire en entrée ==> Petite erreur de parenthèses

_$ (setq pt2_ep (list 0.1 (+ (/ (* 600 250) 100) 0.1)))

(0.1 1500.1) ==> C'est là que je crois comprendre l'immense difficulté des listes avec des parenthèses évaluées ou pas...

_$

Je crois que j'ai fini par comprendre... Mais pas sans "mal"...

 

Mais grâce à quelqu'un d'entre vous (pour ne pas dire tous), Maître (gile), didier, Patrick_35...) On progresse parfois sans le savoir, c'est l’apprentissage "fourbe", "sous-jacent", qu'on ne voit pas, mais qui est bien présent...Et je vous en remercie au nom de tous... ;)

 

Je vais encore passer quelques lignes de code dans la console pour bien mettre en place la compréhension de cette particularité essentielle du langage LISP...

 

Je ne manquerais pas à vous souhaiter un excelent week-end à tous... Profitez-en... (didier, si tu me lis, je pense à l'expatrié et à ces environ 24h/24... Même avec un peu de lecture les soirée... ;) )

 

Bien à vous tous...

 

Denis...