[Résolu] Dans un GetPoint, ou est le Z ?

[DenisHen]

Bonsoir à tous, car à cette heure là, c'est le début de la soirée...

 

Juste une petite question, je cherche à connaitre juste l'X et l'Y d'un point en 3D

 

En gros, je demande à l'utilisateur de cliquer sur une polyligne 3D le milieu, mais je dois ne retenir que le point "2D", sans le Z... Pour insérer un bloc "à plat".

 

Genre : Insérer un bloc avec l'X et l'Y du milieu d'une polyligne 3D...

 

Je cherche mais n'arrive pas vraiment à séparer les (car, cdr, caddr et cadrdaddrdcadd d'un point... :P

 

Si quelqu'un a une astuce, un conseil ou une idée... Je suis preneur...

 

Aller, encore un efferalgan et au lit... Il est tant... ;)

[DenisHen]

Je pense que je démarre bien :

  (setq Pt_Ins (getpoint "\tInsertion du block : "))
 (setq Pt_Ins_X (car Pt_Ins))
 (setq Pt_Ins_Y (cadr Pt_Ins))

Mais comment réattribuer à Pt_Ins l'X, l'Y et un Z à 0...?

 

Et surtout, comment obtenir l'orientation d'un point obtenu avec une orientation 3D pour l'exploiter de façon 2D...

 

En gros, je clique sur le milieu d'une polyligne 3D et ensuite, sur une de ses extrémité 3D pour insérer un bloc en 2D... j'ai fais déjà ça :

  (setq Pt_Ins (getpoint "\tInsertion du block : "))
 (setq Pt_Dir (getorient Pt_Ins "\tDirection du block : "))

Pour finir par insérer un bloc avec toutes l'altimétrie à zéro...

[Tramber]

(list (car Pt_Ins) (cadr Pt_Ins) 0.0)

Tout simplement

Pour ton second souhait, je ne suis pas trop bien la demande : ton bloc inséré sera dnas la même direction en plan ou en 3D ?

En plan, utilise la fonction angle, là aussi, tout simplement.

En 3D, changer le SCU sera une bonne solution.

[zebulon_]

Je cherche mais n'arrive pas vraiment à séparer les (car, cdr, caddr et cadrdaddrdcadd d'un point...

 

Les 2 fonctions de base sont (car x) et (cdr x). Tout le reste en découle.

 

les équivalences pour les concaténations d'une série de car / cdr

(caar x)        (car (car x))                    
(cadr x)        (car (cdr x))                    
(cdar x)        (cdr (car x))                    
(cddr x)        (cdr (cdr x))                    
(caaar x)       (car (car (car x)))              
(caadr x)       (car (car (cdr x)))              
(cadar x)       (car (cdr (car x)))              
(caddr x)       (car (cdr (cdr x)))              
(cdaar x)       (cdr (car (car x)))              
(cdadr x)       (cdr (car (cdr x)))              
(cddar x)       (cdr (cdr (car x)))              
(cdddr x)       (cdr (cdr (cdr x)))              
(caaaar x)      (car (car (car (car x))))        
(caaadr x)      (car (car (car (cdr x))))        
(caadar x)      (car (car (cdr (car x))))        
(caaddr x)      (car (car (cdr (cdr x))))        
(cadaar x)      (car (cdr (car (car x))))        
(cadadr x)      (car (cdr (car (cdr x))))        
(caddar x)      (car (cdr (cdr (car x))))        
(cadddr x)      (car (cdr (cdr (cdr x))))        
(cdaaar x)      (cdr (car (car (car x))))        
(cdaadr x)      (cdr (car (car (cdr x))))        
(cdadar x)      (cdr (car (cdr (car x))))        
(cdaddr x)      (cdr (car (cdr (cdr x))))        
(cddaar x)      (cdr (cdr (car (car x))))        
(cddadr x)      (cdr (cdr (car (cdr x))))        
(cdddar x)      (cdr (cdr (cdr (car x))))        
(cddddr x)      (cdr (cdr (cdr (cdr x))))        

 

En fait, c'est simple à comprendre : tu enlèves le "c" du début et le "r" de la fin et tu regardes ce qui te reste. Le "a" indique qu'il y a une car et le "d" indique qu'il y a un cdr. La limite, c'est 4 niveaux, ce qui peut permettre de gérer des listes de listes de listes de listes... J'en bégaye ! :)

 

Exemple :

(cddadr x)

tu enlèves le "c" et le "r", il te reste "ddad", d'où :

(cdr (cdr (car (cdr x)))

 

Amicalement

Vincent

[didier]

Coucou

 

Toujours réfractaire à l'aide fournie par le logiciel !!!

C'est pas grave car je vais t'aider sans doute, comment ?

 

Je me suis mis en tête de relancer mon site Web qui a planté il y a quelques années et que javais remisé dans un coin de ma tronche en pertes et profits.

Je te mets en pièce jointe un PDF extrait des mes explications qui seront sur le site.

Je dois retravailler des centaines pages pour les mettre en HTML, je ne sais pas encore donner de date de disponibilité car je peaufine et je mets la barre assez haut (pour mes petites possibilités) et comme je me contente du maximum ça prend du temps.

 

Amicalement

pages 52-56.pdf

[DenisHen]

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

 

J'ai aussi trouvé dans l'aide (tu vois didier que je m'y rend de temps en temps ;) ) la commande nth qui m'a l'air plus facile d'utilisation, à mes yeux...

 

Merci encore à tous...

 

Denis...

[zebulon_]

Bonjour,

 

la commande nth qui m'a l'air plus facile d'utilisation, à mes yeux...

lorsque les éléments de la liste sont des atomes, la fonction nth est sans doute plus facile à utiliser pour piocher le nième élément d'une liste, d'autant plus qu'avec (caar liste), (cadr liste), etc... on est limité à une profondeur de 4 niveaux.

Mais lorsque les éléments de la liste sont des listes, la notation concaténée de car et de cdr me semble plus directe, ou dans d'autres cas comme dans l'exemple ci-dessous

;; Intersections  -  Lee Mac
;; Returns a list of all points of intersection between two objects
;; for the given intersection mode.
;; ob1,ob2 - [vla] VLA-Objects
;;     mod - [int] acextendoption enum of intersectwith method

(defun LM:intersections ( ob1 ob2 mod / lst rtn )
   (setq lst (vlax-invoke ob1 'intersectwith ob2 mod))
   (repeat (/ (length lst) 3)
       (setq rtn (cons (list (car lst) (cadr lst) (caddr lst)) rtn)
             lst (cdddr lst)
       )
   )
   (reverse rtn)
)

qui utilise la fonction (cdddr liste) qui permet d'enlever les 3 premiers éléments d'une liste et qui n'a pas d'équivalent avec nth.

 

Amicalement

Vincent

[didier]

Coucou

 

Faîtes gaffe à ce que vous écrivez !

Un jour ou l'autre quelqu'un va le lire et le répéter puisqu’il l'a vu écrit sur un site où les gens ont de la crédibilité, c'est comme quelque chose qui passe à la radio et que tout le monde répète, même si le journaliste qui a le pouvoir du micro s'est lamentablement vautré dans la compréhension de ce qu'il raconte!.

la tournure de phrase il me semble que ....... à vérifier est le minimum lorsqu'on est pas certain de ce qu'on écrit.

Ce coup de gueule est libérateur car sur le net on en lit des conneries, récemment j'ai lu sur un site de formateurs (eh oui !) qu'avec la version LT on pouvait toujours utiliser le LT Extender pour faire tourner des routines Lisp, vous le croyez ça ?

Allez je ferme ma grande bouche et je m'explique :

 

Pour ce qui est de la fonction NTH, il est faux de dire que si c'est des atomes c'est plus simple, ça n'a rien à voir la seule vraie limitation de cette commande est de connaitre le longueur de la liste car sinon on risque de recevoir une erreur

 

Pour ce qui est des fonctions car et consorts, il est faux de dire qu'on est limité à quatre niveaux.

 

Cela dit pour extraire les coordonnées d'un point exprimé sous forme de triplet les fonctions car, cadr et caddr sont les plus aisées à utiliser.

 

Lorsque je serai sur le point de lancer mon site, j'espère être clair dans mes explications (et être lu) car je donnerai des exemples (vérifiés) de tout ce que je donnerai comme explication.

 

Amicalement

 

[zebulon_]

Je ne pense pas avoir écrit tellement de conneries.

 

Et si c'est le cas, je ne suis pas le seul :

ça n'a rien à voir la seule vraie limitation de cette commande NTH est de connaitre le longueur de la liste car sinon on risque de recevoir une erreur

 

If n is greater than the highest element number of lst, nth returns nil.

 

Donc nth renvoie nil et non une erreur. Fait gaffe à ce que tu écris ! Un jour quelqu'un va te lire etc...

 

Ensuite, la concaténation de car et cdr est limitée à 4 niveaux. Ce qui veut dire qu'on peut écrire (cadddr liste) à la place de (car (cdr (cdr (cdr liste)))), mais que (caddddr liste) n'existe pas et là, il faut écrire (car (cdr (cdr (cdr (cdr liste))))). Enfin, il me semble. A vérifier sur vos versions.

 

Ensuite, nth renvoie le nième élément d'une liste, quelle que soit la liste. Si le nième élément de liste est une liste, alors nth renvoie une liste. Ce que je voulais dire est que, si on a une liste du genre

'("a" ("b" "c") "d" "e")

et qu'on veut récupérer le "b", c'est plus court en faisant (car (car (cdr liste)), ou plus simplement (caadr liste). Avec nth, il faut faire 2 étapes.

 

Après, chacun fait comme il veut, du moment que ça fonctionne.

 

Amicalement

Vincent

[(gile)]

Salut,

 

car et cdr sont, avec cons, des fonctions essentielles de tous les langages LISP qui reflètent précisément ce que sont les listes chaînées, structure de données fondamentale du LISP.

 

La fonction nth évoque plus la façon dont on accède aux données dans un tableau indexé ; ce qui n'est pas du tout le cas.

Dans un tableau indexé, l'indice est l'adresse même de la cellule, donc l'accès est direct (complexité O(1)) ; alors qu'avec une liste chaînée l'accès se fait séquentiellement depuis le premier élément (complexité O(n)).

 

Autrement dit, pour définir une fonction nth en LISP est obligé de passer par car et cdr que ce soit de manière récursive :

(defun nieme (n l)
 (if (zerop n)
   (car l)
   (nieme (1- n) (cdr l))
 )
)

ou itérative :

(defun nieme (n l)
 (repeat n (setq l (cdr l)))
 (car l)
)

 

On peut trouver plus lisible l'utilisation de nth, mais comprendre les imbrications de car et cdr, c'est commencer à entrevoir la nature récursive des listes chaînées et du LISP.

[didier]

Coucou

 

Il n'est pas question de faire un bras de fer avec vous, zebulon_ ou qui que ce soit d'autre

Je lâche l'affaire pour ne pas passer pour un troll.

[zebulon_]

Bonsoir,

 

Si j’ai mal parlé, montre ce que j’ai dit de mal ? Mais si j’ai bien parlé, pourquoi me frappes-tu ?

 

Amicalement

Qui que ce soit

[bonuscad]

la commande nth qui m'a l'air plus facile d'utilisation, à mes yeux...

 

Je rejoins zebulon_, pour mar part je préfère largement les (car) et les (cdr) et tout ses mixtes.

 

Pourquoi ?

 

Déjà je pense que l'accés à la donnée est plus rapide qu'avec (nth) même si à l'utilisation cela ne se percoit pas.

C'est vraiment la fonction de base du lisp en amont tu n'a rien d'autre. (nth) peut être simulé avec l'écriture d'une fonction. Si tu arrive à faire une fonction (car) et (cdr), je veux la démonstration!

 

(nth) est surtout interessant si l'on a conjointement la liste des index et qu'on la manipule.

 

Et puis ELEMENT IMPORTANT (nth) ne gère pas la paire pointée.

 

Pour cette dernière, tu as le 1er élément avec (car) et le deuxième avec (cdr), avec (nth), impossible !

 

Essayes (nth 1 '(1 . 2)) -> ; erreur: liste incorrecte: 2

alors que (cdr '(1 . 2)) -> 2

[zebulon_]

Bonjour Bonuscad,

 

ce n'est pas ce qui m'est reproché et je pense que Didier est également d'accord avec toi sur l'utilisation des car et consorts. Il me corrigera le cas échéant.

 

Il me reproche ceci :

Pour ce qui est de la fonction NTH, il est faux de dire que si c'est des atomes c'est plus simple

 

et

Pour ce qui est des fonctions car et consorts, il est faux de dire qu'on est limité à quatre niveaux.

 

Je me permets donc d'éclaircir mon propos :

avec car et consorts, on arrive à piocher le premier élément d'une liste avec car, le second avec cadr, le troisième avec caddr et le quatrième avec cadddr. Mais après le quatrième niveau on se retrouve coincé parce que caddddr n'existe pas. Et l'aide est claire à ce sujet

AutoLISP accepte des concaténations de car et de cdr, jusqu'à une profondeur de 4 niveaux

Donc, si on veut récupérer le 5ème (ou plus) élément d'une liste, le nth devient plus simple.

 

Lorsque j'ai dit, "quand c'est des atomes c'est plus simple avec nth", j'aurais dû dire le contraire. Quand on a des listes de listes, c'est plus simple à gérer avec car, cdr et compagnie. Ce que j'ai illustré par cet exemple :

Commande: (caadr '("a" ("b" "c") "d" "e"))

"b"

 

Et il y a des choses qu'on ne peut pas reproduire avec nth, ce sont les fonctions cdr, cddr, cdddr etc... qui renvoient une liste.

 

Pour conclure, je pense qu'on peut se passer de nth dans 99% des cas, comme le plus souvent quand on traite une liste, on utilise 3 outils de base qui sont l'adjonction en tête, la tête et la queue. En lisp cons, car et cdr, comme l'a rappelé (gile). Lorsque j'ai appris à programmer avec Turbo Pascal dans les années 1985, ces fonctions n'existaient pas et il fallait s'écrire ses propres fonctions de gestion de liste à partir de pointeurs. Heureusement, comme la liste est l'ADN du lisp, on dispose de tout cela directement.

 

Il n'est pas question de faire un bras de fer avec vous, zebulon_ ou qui que ce soit d'autre

Je lâche l'affaire pour ne pas passer pour un troll.

Il n'est pas question, en effet de faire un bras de fer, il est question d'être clair dans ses propos. Si je ne l'ai pas été suffisamment, je vous demande de m'excuser. De là à dire que ce que j'ai écrit est faux, c'est un peu disproportionné.

 

Amicalement

Vincent

[bonuscad]

Quand je disais que je te rejoins, c'était sur ceci:

la notation concaténée de car et de cdr me semble plus directe

 

Par contre ceci

Mais après le quatrième niveau on se retrouve coincé

Est a interpréter avec un seul appel, car on n'est pas vraiment coincé.

 

(cadr (cddddr (cddddr '(1 2 3 4 5 6 7 8 9 10))))

retourne 10, (nth) dans ce cas peut simplifié l'appel (et c'est ce pourquoi il a été certainement conçu)

 

Pour mois les notions de (car) (cdr) et (cons) me semble essentielles pour une compréhension du lisp.

J'ai appuyé sur la notion de paire pointée (qui elle ne présente pas d'aborescence, voir fin de page, donc un accés direct à la donnée), car (nth) se révèle inadapté à ce type de liste.

 

En résumé l'utilisation de car et cdr sont essentielle à bon apprentissage du lisp, si l'on ne comprends pas bien cette base, on ne progressera que très lentement.

 

Après au lecteur d'avoir l'oeil critique pour interpréter les réponses, car nul n'est parfait dans ses explications (même ceux qui manie bien la langue, peuvent fourcher)

[zebulon_]

Mais après le quatrième niveau on se retrouve coincé

 

Coincé est un mot qui n'est pas approprié. Désolé, mais il faut m'excuser car le français n'est pas ma langue maternelle.

 

On n'est pas "coincé" puisqu'on peut toujours faire autant de (car (cdr (cdr ... liste))) qu'on veut. Ce que je voulais dire, c'est qu'on n'a plus en magasin de fonction unique qui fait le boulot, sauf nth.

 

Merci pour la précision

Amicalement

Vincent