Aller au contenu

challenge 11 \"certainement pour confirmé\"


Messages recommandés

Posté(e)

Voilà, puisque les challenges font progresser tout le monde, en voici un qui me trotte depuis un certain moment:

nous avons des faces 3D qui modelisent un terrain (le terrain naturel) un second qui represente un modelage ou projet.

je voudrais par exemple lorsque je clique a un endroit aléatoire avoir les informations suivantes:

le Z du terrain naturel

le Z du projet

et le delta Z (Z terrain - Z projet).

 

Voila je ne vous demande pas de repondre tout de suite mais donner quelques idées afin que la plupart des personnes qui veulent develloper puissent participer.

Disons que la reponse definitive (si il y a) soit donnée dans une semaine.

 

Merci d'avance de votre participation.

 

@plus

LB

 

 

 

Posté(e)

Salut Lovecraft!

 

Ayant peu de dessins 3D, serai-t-il possible d'avoir un de ces plans?

Je t'envoie mon mail perso en mp.

 

a+!

Tous pour lisp, Lisp pour tous!

Avec Revit, cela ne vas trop vite...

Posté(e)

Salut,

 

Jene pense pas avoir de soucis majeur pour faire ça (les routines nécessaires sont déjà publiées sur le forum) donc je vais laisser chercher les autres.

 

Quelques petites précisions quand même :

 

- Les faces 3d ont elles bien toutes seulement 3 sommets (donc planes) ou peuvent elles avoir plus de sommets (donc peut-être non planes) ? Dans le second cas, il est impossible de définir une direction Z de la face.

- Sous quelle forme doit être exprimé le delta entre les deux direction Z ? Mesure angulaire ?

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

J'ai fais un truc qui semble fonctionner (dans le SCG et en vue de dessus), mais c'est pas un modèle de concision, il m'a fallu sortir une palanquée de routines de ma besace !

 

J'attends un peu pour poster...

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

ah oui ben c'est ce que j'ai fait aussi

 

(defun ilp_perso (pt_a pt_b pt_1 pt_2 pt_3)

 (setq xa (car pt_a))
 (setq ya (cadr pt_a))
 (setq za (caddr pt_a))
 (setq xb (car pt_b))
 (setq yb (cadr pt_b))
 (setq zb (caddr pt_b))
 (setq x1 (car pt_1))
 (setq y1 (cadr pt_1))
 (setq z1 (caddr pt_1))
 (setq x2 (car pt_2))
 (setq y2 (cadr pt_2))
 (setq z2 (caddr pt_2))
 (setq x3 (car pt_3))
 (setq y3 (cadr pt_3))
 (setq z3 (caddr pt_3))
 (setq xn (- (* (- y2 y1) (- z3 z1)) (* (- y3 y1) (- z2 z1))))
 (setq yn (- (* (- z2 z1) (- x3 x1)) (* (- z3 z1) (- x2 x1))))
 (setq zn (- (* (- x2 x1) (- y3 y1)) (* (- x3 x1) (- y2 y1))))

 (setq	s (/ (+ (* xn (- xa x1)) (* yn (- ya y1)) (* zn (- za z1)))
     (+ (* xn (- xb xa)) (* yn (- yb ya)) (* zn (- zb za)))
  )
 )

 (setq x_pt (+ (* s (- xa xb)) xa))
 (setq y_pt (+ (* s (- ya yb)) ya))
 (setq z_pt (+ (* s (- za zb)) za))

 (setq pt (list x_pt y_pt z_pt))

 pt
)

 

le lien pour la tienne ne fonctionne pas ?

 

 

Posté(e)

Super ta routine !

 

Certainement plus rapide que celle que j'utilise qui en appelle d'autres.

Tu dois pouvoir l'améliorer en supprimant les setq inutiles, au lieu de :

 

(setq xa(car pt_a))

(setq ya(cadr pt_a))

(setq za(caddr pt_a))

 

tu peux faire :

 

(setq xa (car pt_a) ya (cadr pt_a) za (caddr pt_a))

 

et à la fin, tu n'as pas besoin de faire :

 

(setq x_pt (+ (* s (- xa xb)) xa))

(setq y_pt (+ (* s (- ya yb)) ya))

(setq z_pt (+ (* s (- za zb)) za))

 

(setq pt (list x_pt y_pt z_pt))

 

pt

 

tu peux directement faire ;

 

(list (+ (* s (- xa xb)) xa) (+ (* s (- ya yb)) ya) (+ (* s (- za zb)) za))

 

C'est le résultat de cette expression (la dernière) qui est retourné par la routine.

 

Je n'avais pas fait de lien c'est avec les routines de calcul vectoriel ici.

 

PS : je viens de regarder le sujet du lien, il date un peu, certaines routines on été améliorées depuis, il faudra que je le remette à jour.

 

[Edité le 5/10/2007 par (gile)]

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

Comme ça n'a pas l'air de se bousculer au portillon, je livre ma réponse en espérant qu'elle servira soit à y apporter des améliorations, soit à débloquer d'autres idées d'algorythmes.

 

J'ai préféré conserver mes routines pour le calcul de l'intersection d'une ligne et d'un plan, malgré que la routine donnée par Lovecraft soit plus rapide (le mode de calcul étant le même). Je trouve plus "lisible" le fait de faire appel à d'autres routines qui, d'autre part, peuvent être utiles ailleurs.

 

La commande est deniv, l'utilisateur choisit un objet sur le calque "terrain naturel" et un objet sur le calque "terrain projet", puis entre dans une boucle où pour chaque point spécifié un message donne le résultat, on sort de la boucle en faisant Espace, Entrée, clic droit ou Echap.

Le dénivelé est positif si le projet est plus haut (remblais) négatif sinon.

 

Ce n'est pas un modèle de concision et il peut certainement être amélioré, mais comme dit plus haut, j'ai utilisé des routines que j'avais déjà.

 

PS : je n'ai pas testé sur un dessin contenant un grand nombre de faces 3D où le traitement devrait être plus long.

 

EDIT : correction d'une erreur de sens dans le dénivelé

 

;; CLOCKWISE-P
;; Retourne T si les points p1 p2 et p3 tournent dans le sens horaire

(defun clockwise-p (p1 p2 p3)
 ()

;; INSIDE_3PTS
;; Evalue si pt est strictement à l'intérieur du triangle p1 p2 p3 (points 2d)

(defun inside_3pts (pt p1 p2 p3)
 (if (clockwise-p p1 p2 pt)
   (and (clockwise-p p2 p3 pt)
 (clockwise-p p3 p1 pt)
   )
   (and (clockwise-p p2 pt p3)
 (clockwise-p p3 pt p1)
 (clockwise-p p1 pt p2)
   )
 )
)

;; VEC1
;; Retourne le vecteur normé (1 unité) de sens  p1 p2

(defun vec1 (p1 p2 / d)
 (if (not (zerop (setq d (distance p1 p2))))
   (mapcar '(lambda (x1 x2) (/ (- x2 x1) d)) p1 p2)
 )
)

;; VXV
;; Retourne le produit scalaire (réel) de deux vecteurs

(defun vxv (v1 v2)
 (apply '+ (mapcar '* v1 v2))
)

;; V^V
;; Retourne le produit vectoriel (vecteur) de deux vecteurs

(defun v^v (v1 v2)
 (list	(- (* (cadr v1) (caddr v2)) (* (caddr v1) (cadr v2)))
(- (* (caddr v1) (car v2)) (* (car v1) (caddr v2)))
(- (* (car v1) (cadr v2)) (* (cadr v1) (car v2)))
 )
)

;; IL3P
;; Retourne le point d'intersection de la droite définie par p1 p2
;; et du plan défini par p3 p4 p5.

(defun il3p (p1 p2 p3 p4 p5 / nor scl)
 (setq nor (v^v (mapcar '- p4 p3) (mapcar '- p5 p3)))
 (if (and
(/= 0 (setq scl (vxv nor (mapcar '- p2 p1))))
(setq scl (/ (vxv nor (mapcar '- p1 org)) scl))
     )
   (mapcar '(lambda (x1 x2) (+ (* scl (- x1 x2)) x1)) p1 p2)
 )
)

;; REMOVE_DOUBLES_F
;; Suprime tous les doublons d'une liste (avec tolérance)

(defun remove_doubles_f	(lst fuzz)
 (if lst
   (cons (car lst)
  (remove_doubles_f
    (vl-remove-if '(lambda (x) (equal x (car lst) fuzz)) lst)
    fuzz
  )
   )
 )
)

;; INTERS-3DFACE-POINT
;; Retourne la liste des points d'intersections de la projectrice verticale
;; de pt avec chaque face 3d de la liste rencontrée
;;
;; Arguments
;; pt : point (coordonnées SCG)
;; ss : jeu de sélection (faces 3d)
;;
;; Algorythme
;; Tant qu'un point n'est pas trouvé sur une face 3d du jeu de sélection,
;; - on constitue la liste des sommets après suppression des doublons (plst)
;; - les sommets et le point spécifiés sont projetés sur le plan XY (p0 p1 p2 p3)
;; - on évalue si p0 est soit confondu avec un sommet soit sur une arrête soit à
;; l'intérieur du triangle p1 p2 p3. Si une de ces condition est vérifiée le
;; point 3d sur la face 3d est calculé et son altitude est retournée.

(defun Inters-3dFace-Point (pt ss / loop n ent plst p0 p1 p2 p3 alt)
 (setq	loop T
n 0
 )
 (while (and loop (setq ent (ssname ss n)))
   (setq plst
   (remove_doubles_f
     (mapcar 'cdr
	     (vl-remove-if-not
	       '(lambda (x) (member (car x) '(10 11 12 13 14)))
	       (entget ent)
	     )
     )
     1e-9
   )
  n (1+ n)
   )
   (mapcar '(lambda (s p) (set s (list (car p) (cadr p))))
    '(p0 p1 p2 p3)
    (cons pt plst)
   )
   (if	(= 3 (length plst))
     (cond
((equal p0 p1 1e-9)
 (setq loop nil
       alt  (caddr (car plst))
 )
)
((equal p0 p2 1e-9)
 (setq loop nil
       alt  (caddr (cadr plst))
 )
)
((equal p0 p3 1e-9)
 (setq loop nil
       alt  (caddr (caddr plst))
 )
)
((equal (vec1 p1 p0) (vec1 p0 p2) 1e-9)
 (setq loop nil
       alt (+ (caddr (car plst))
	       (* (- (caddr (cadr plst)) (caddr (car plst)))
		  (/ (distance p1 p0) (distance p1 p2))
	       )
	    )
 )
)
((equal (vec1 p2 p0) (vec1 p0 p3) 1e-9)
 (setq loop nil
       alt (+ (caddr (cadr plst))
	       (* (- (caddr (caddr plst)) (caddr (cadr plst)))
		  (/ (distance p2 p0) (distance p2 p3))
	       )
	    )
 )
)
((equal (vec1 p1 p0) (vec1 p0 p3) 1e-9)
 (setq loop nil
       alt (+ (caddr (car plst))
	       (* (- (caddr (caddr plst)) (caddr (car plst)))
		  (/ (distance p1 p0) (distance p1 p3))
	       )
	    )
 )
)
((inside_3pts p0 p1 p2 p3)
 (setq loop nil
       alt (caddr
	      (il3p pt
		    (list (car pt) (cadr pt) 1.0)
		    (car plst)
		    (cadr plst)
		    (caddr plst)
	      )
	    )
 )
)
     )
   )
 )
 alt
)

;; DENIV Fonction principale

(defun c:deniv (/ lay1 lay2 pt ss1 ss2 n alt1 alt2)
 (while (not (setq lay1
	     (car
	       (entsel
		 "\nSélectionnez un objet sur le calque du \"terrain naturel\": "
	       )
	     )
      )
 )
 )
 (setq	lay1 (cdr (assoc 8 (entget lay1)))
lay2 lay1
 )
 (while (= lay1 lay2)
   (setq lay2 (car
	 (entsel
	   "\nSélectionnez un objet sur le calque du \"terrain projet\": "
	 )
       )
  lay2 (cdr (assoc 8 (entget lay2)))
   )
 )
 (while (setq pt (getpoint "\nSpécifiez le point: "))
   (if
     (and
(setq ss1
       (ssget
	 "_F"
	 (list pt (list (car pt) (+ (cadr pt) (getvar "VIEWSIZE"))))
	 (list '(0 . "3DFACE") (cons 8 lay1))
       )
)
(setq alt1 (Inters-3dFace-Point (trans pt 1 0) ss1))
(setq ss2
       (ssget
	 "_F"
	 (list pt (list (car pt) (+ (cadr pt) (getvar "VIEWSIZE"))))
	 (list '(0 . "3DFACE") (cons 8 lay2))
       )
)
(setq alt2 (Inters-3dFace-Point (trans pt 1 0) ss2))
     )
      (alert (strcat
	"Altitude naturel :\t"
	(rtos alt1)
	"\nAltitude projet :\t"
	(rtos alt2)
	"\nDénivelé :\t"
	(rtos (- alt2 alt1))
      )
      )
      (alert "Il n'y a pas deux faces 3d à la verticale du point."
      )
   )
 )
 (princ)
) 

[Edité le 7/10/2007 par (gile)][Edité le 7/10/2007 par (gile)]

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

Que dire de cette routine quime rend .......

Je vais mettre la mienne dès que j'ai terminé, mais bon elle est beaucoup moins bien , car pour l'instant j'en suite au stade je selectionne un face3D TN un face3D projet et je clique a l'interieur des deux faces donc cela ne fonctionne que localement..je pense que je ne sais pas faire comme toi gile d'ou l'importance de suivre une p'tite formation ;)

@plus

Posté(e)

Ton challenge présente plusieurs difficultés.

 

Du calcul de coordonnées en 3d (ce qui suppose un peu de calcul vectoriel ou l'utilisation de la calculatrice géométrique), ça, tu as montré que tu sais le faire.

 

Faire un sélection de faces à partir d'un point, chose que je n'ai pas réussi à faire directement (même en style visuel "Réaliste" ou "Conceptuel" on ne sélectionne que la face supérieure).

Il faut donc trouver une astuce pour sélectionner le minimum de faces (y compris celles à la verticale du point) afin que le traitement ne soit pas trop long.

 

Peux tu me dire si ça n'est pas trop long avec un nombre important de facs affichées dans la fenêtre ou, mieux, m'envoyer un fichier du style de ceux que tu utilises contenant deux modélisations de terrain, je le mettrais en téléchargement ici pour que d'autres puissent essayer aussi.

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

pour repondre , non ce n'est vraimant pas ,long voire même immédiat, et pouratnt il y a un nombre important de faces 3D. je vais te joindre un fichier afin que tu puisses constater ainsi que les autres membres.

@plus

PS va falloir que je decortique ta routine pour mieux comprendre comment tu fais en ce qui concerne le jeu de selection.

Posté(e)

Ça ne se bouscule toujours pas.

 

La question est plus large qu'un "challenge" comme ceux fait pécédemment auxquels on répondait par une (ou quelques) routines. Il s'agirait là de répondre avec une petite application.

 

Je vais essayer de débroussailler un peu (de la manière dont j'ai abordé la question) pour essayer de dégager ce qui pourrait relever d'un (ou de plusieurs) "challenge".

 

Pour répondre à la demande, il faudrait :

 

1 - Récupérer des données entrées par l'utilisateur : les 2 calques sur lesquels sont les faces 3d et le point.

 

2 - Sélectionner les faces 3d à la verticale du point.

 

3 - Calculer les points d'intersections entre la verticale du point et les faces 3d qui sont à sa verticale (du moins leurs altitudes).

 

4 - Retourner le résultat.

 

Les points 1 et 4 relèvent plutot de choix personnels (esthétique, pratique, convivialité...) d'interface, dans lequels interviennent assez peu, à mon avis, la rapidité d'exécution du code : les actions faites par l'utilisateur seront toujours plus longue que l'interprétation du code.

 

Le point 2 est plus intéressant d'un point de vue "challenge". Comment faire une sélection qui contienne à coup sur les faces 3d concernées et qui, d'un autre côté, ne contienne pas trop d'entités ce qui aurait pour conséquence d'augmenter considérablement le temps d'exécution (puis qu'il faut retrouver parmi ces objets ceux qui sont effectivement à la verticale du point).

 

Comme on est dans le forum "Débuter en LISP" et que j'ai déjà donné une réponse je vais essayer d'expliquer le choix que j'ai fait, ce qui n'empêche pas de donner d'autres solutions sur ce point.

 

En procédant par élimination, entsel nentsel ou nentselp ne permettent pas de sélectionner une face 3d en affichage filaire 2d si le point est à l'intérieur de celle ci. Il en est de même pour ssget avec un seul point.

Dans toutes les options possibles avec ssget certaines permettent de faire un jeu de sélection sans intervention de l'utilisateur (excepté le point précédemment acquis) :

 

"_X" (toutes les entités du dessin) ou "_A" (toutes les entités sur des calques dégelés) créerait des jeu de sélection très important (dans le dessin fournit par Lovecraft : 1680 faces 3d sur le calque MNT_NIVEAUFINI, 1970 sur MNT_TN_VILLY)

 

"_W" (fenêtre) et "_WP" (fenêtre polygonale) nécessitent que les objets soient entièrement à l'intérieur de la fenêtre, il serait envisageable de faire une fenêtre de sélection correspondant à la fenêtre de dessin active (moins d'entités que précédemment si on est pas en zoom étendu). Si les faces reherchées sont dans la vue courante, elles seront sélectionnées.

 

"_C" (capture), "_CP" (capture polygonale) et "_F" (trajet) permettent de sélectionner à coup sur les faces 3d recherchés si le point spécifié est un des points de la fenêtre ou du trajet et que celui ci croise une des arrêtes des faces recherchées.

 

Mon choix s'est porté sur trajet, plus simple à utiliser. J'ai un premier point pour mon trajet : le point spécifié, j'en construit un autre de manière à être sûr que le trajet sera entièrement contenu dans la fvue affichée. La variable système VIEWSIZE indique la hauteur de la vue en unité de dessin, en ajoutant cette valeur à la coordonnée Y de mon point je suis certain que mon trajet sera entièrement contenu dans la vue. Donc qu'il coupera les arrêtes des faces 3d recherchées (à condition, bien sur, qu'elles soient aussi à l'intérieur de la vue).

De plus, dans le jeu de sélection créé avec l'option trajet les objets sont dans l'ordre dans lequel ils ont été sélectionnés (là partir du premier point du trajet).

La fonction ssget autorisant les filtres de sélection, je fait 2 jeux en filtrant les face 3d sur le premier calque et les faces 3d sur le second, ce qui facilite le traitement par la suite.

 

 

Reste donc, le point 3 : le traitement de ce jeu de sélection pour en ressortir les altitudes des point d'intersection de la verticale du point avec une faces 3d de chacun des calques.

Et là, à mon avis, il y a moyen de "challenger". ;)

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

Le point 2 est plus intéressant d'un point de vue "challenge". Comment faire une sélection qui contienne à coup sur les faces 3d concernées et qui, d'un autre côté, ne contienne pas trop d'entités ce qui aurait pour conséquence d'augmenter considérablement le temps d'exécution (puis qu'il faut retrouver parmi ces objets ceux qui sont effectivement à la verticale du point).

 

Voila ce que je n'arrive pas a faire.

 

Reste donc, le point 3 : le traitement de ce jeu de sélection pour en ressortir les altitudes des point d'intersection de la verticale du point avec une faces 3d de chacun des calques.

 

Voici ce que j'aimerais faire.

 

Gile, j'ai pas eu trop le temps de me repencher sur le sujet. je vais donc regarder ça dans les prochains jours.

PS: "c'est ce que j'aimerai aprendre en formation ;)

Posté(e)

La vache mais il est vachement compliqué ce challenge !!!!

 

Gile, comme toujours, tes précisions sont redoutables d'efficacité !!

Bon bah on va d'abord essayer de comprendre ce qui est demandé avant de se lancer :)

 

A bientot.

Matt.

"Chacun compte pour un, et nul ne compte pour plus d'un."

Posté(e)

Comme (gile) était surpris que je n'ai effectué aucune proposition, voici la mienne. ;)

 

Voila le code fonctionne avec le dessin proposé et dans le SCG, je ne suis pas allé plus loin pour l'instant. (la variable "par" est réglée à 3.5 pour ce dessin)

 

Lors de l'utilisation le Z du curseur (si dans 3dFace) est affiché en dynamique dans la barre d'état des coordonnées.

 

(defun punktinpolylinie	(pointinquestion point_list /)
 (if (equal 0.0
     (pipwinkelsumme pointinquestion point_list)
     0.0001
     )
   nil
   t
 )
)
(defun pipwinkelsumme (pointinquestion		 point_list
	       /	    count	 p1
	       p2	    scheitel	 winkeleins
	       winkelzwei
	      )
 (setq
   winkeleins 0.0
   scheitel   (car point_list)
   count      1
 )
 (while (< 1 (length point_list))
   (setq
     p1	 (car point_list)
     p2	 (cadr point_list)
     point_list (cdr point_list)
     winkelzwei (pipwinkelhilfe pointinquestion p1 p2)
     winkelzwei (if (< 180.0 winkelzwei)
	   (- winkelzwei 360.0)
	   winkelzwei
	 )
     winkeleins (+ winkeleins winkelzwei)
   )
   (setq count (1+ count))
 )
 (setq
   winkelzwei (pipwinkelhilfe pointinquestion p2 scheitel)
   winkelzwei (if (< 180.0 winkelzwei)
	 (- winkelzwei 360.0)
	 winkelzwei
       )
 )
 (+ winkeleins winkelzwei)
)
(defun pipwinkelhilfe (pointinquestion p1 p2 / alpha beta)
 (setq
   beta  (angle pointinquestion p1)
   alpha (angle pointinquestion p2)
   alpha (- alpha beta)
 )
 (if (< alpha 0)
   (setq alpha (+ (* 2 pi) alpha))
 )
 (* (/ (float alpha) pi) 180.0)
)
(defun C:ID-Z_3DFACE (/	    tmp	  cod_rub     par   ps1	  ps2	ps3
	      ps4   js	  n	px    dxf_ent	  lst_pt
	      p1    p2	  p3	xn    yn    zn	  zx	p
	     )
 (princ
   "\n[Click-Gauche]: Identification 3D Actif/Inactif  [Click-Droit]: Quitte la commande "
 )
 (princ "\nID3Dyn [b]<<[/b]INACTIF>>")
 (while (or (= 5 (car (setq tmp (grread t 1 0)))) (= 3 (car tmp)))
   (cond
     ((= 3 (car tmp))
      (if (null cod_rub)
 (progn
   (setq cod_rub T)
   (princ "\nID3Dyn [b]<<[/b]ACTIF>>")
 )
 (progn
   (setq cod_rub nil)
   (princ "\nID3Dyn [b]<<[/b]INACTIF>>")
 )
      )
     )
     ((= 5 (car tmp))
      (cond
 (cod_rub
  (setq
    par	3.5
    ps1	(list (+ (car (cadr tmp)) par)
	      (+ (cadr (cadr tmp)) par)
	)
    ps2	(list (+ (car (cadr tmp)) par)
	      (- (cadr (cadr tmp)) par)
	)
    ps3	(list (- (car (cadr tmp)) par)
	      (- (cadr (cadr tmp)) par)
	)
    ps4	(list (- (car (cadr tmp)) par)
	      (+ (cadr (cadr tmp)) par)
	)
    js	(ssget "_CP" (list ps1 ps2 ps3 ps4) '((0 . "3DFACE")))
    n	-1
    px	(list (car (cadr tmp)) (cadr (cadr tmp)) 0.0)
  )
  (cond
    (js
     (repeat (sslength js)
       (setq
	 dxf_ent (entget (ssname js (setq n (1+ n))))
	 lst_pt
		 (list
		   (cdr (assoc 10 dxf_ent))
		   (cdr (assoc 11 dxf_ent))
		   (cdr (assoc 12 dxf_ent))
		   (cdr (assoc 13 dxf_ent))
		 )
       )
       (if (equal (caddr lst_pt) (cadddr lst_pt))
	 (setq lst_pt (list (car lst_pt)
			    (cadr lst_pt)
			    (caddr lst_pt)
			    (car lst_pt)
		      )
	 )
	 (setq lst_pt (append lst_pt (list (car lst_pt))))
       )
       (if (punktinpolylinie px lst_pt)
	 (progn
	   (setq p1 (car lst_pt)
		 p2 (cadr lst_pt)
		 p3 (caddr lst_pt)
	   )
	   (setq
	     xn	(- (* (- (cadr p2) (cadr p1))
		      (- (caddr p3) (caddr p1))
		   )
		   (* (- (cadr p3) (cadr p1))
		      (- (caddr p2) (caddr p1))
		   )
		)
	     yn	(- (* (- (car p3) (car p1))
		      (- (caddr p2) (caddr p1))
		   )
		   (* (- (car p2) (car p1))
		      (- (caddr p3) (caddr p1))
		   )
		)
	     zn	(- (* (- (car p2) (car p1))
		      (- (cadr p3) (cadr p1))
		   )
		   (* (- (car p3) (car p1))
		      (- (cadr p2) (cadr p1))
		   )
		)
	   )
	   (setq zx (/ (- (+ (* (car p1) xn)
			     (* (cadr p1) yn)
			     (* (caddr p1) zn)
			  )
			  (* (car px) xn)
			  (* (cadr px) yn)
		       )
		       zn
		    )
	   )
	   (setq p (list (car px) (cadr px) zx))
	 )
       )
     )
    )
  )
  (cond
    (p
     (setq p (trans p 1 0))
     (grtext -2
	     (strcat
	       (rtos (car p))
	       ","
	       (rtos (cadr p))
	       ","
	       (rtos (caddr p))
	     )
     )
    )
    (grtext -2 "")
  )
  (setq p nil)
 )
 (T nil)
      )
     )
     (T (princ "\nArrêt anormal de la commande "))
   )
 )
 (grtext -2 "")
 (princ
   "\nMode interrogation point 3D en dynamique terminé. "
 )
 (prin1)
)

Choisissez un travail que vous aimez et vous n'aurez pas à travailler un seul jour de votre vie. - Confucius

Posté(e)

Mister Grread !

 

Sympa l'affichage dynamique (j'ai préféré changer le grtext à -1 et ne laisser affichée que la coordonnée Z).

 

Mais il me semble qu'on est pas sûr de pouvoir dire de l'altitude de quelle maille il s'agit.

 

À suivre ?...

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Posté(e)

de quelle maille il s'agit.

 

Tout à fait :P

 

Alors bien sur, soit on désactive le calque du maillage gênant, soit on améliore le lisp en testant si le point à l'intérieur est vérifié plusieurs fois pour le même jeu de sélection et si oui on calcule le delta z.

Choisissez un travail que vous aimez et vous n'aurez pas à travailler un seul jour de votre vie. - Confucius

  • 8 mois après...

Créer un compte ou se connecter pour commenter

Vous devez être membre afin de pouvoir déposer un commentaire

Créer un compte

Créez un compte sur notre communauté. C’est facile !

Créer un nouveau compte

Se connecter

Vous avez déjà un compte ? Connectez-vous ici.

Connectez-vous maintenant
×
×
  • Créer...

Information importante

Nous avons placé des cookies sur votre appareil pour aider à améliorer ce site. Vous pouvez choisir d’ajuster vos paramètres de cookie, sinon nous supposerons que vous êtes d’accord pour continuer. Politique de confidentialité