(angtof \"360\") & (angtos (* 2 pi))

[(gile)]

(angtof "360") retourne 0.0 et (angtos (* 2 pi)) retourne "0.0"

 

Voici donc deux petites routines aux fontionnements proches de ANGTOS et ANGTOF, mais qui permettent de convertir les angles supérieurs ou égaux à 360 degrés, 400 grades ou 2 pi radians, sans les arrondir à 2 k pi près.

 

STR2ANG accepte les chaines numériques (dans ce cas, convertit en fonction de la valeur courante de AUNITS) comme les chaines du type "150g" "22d30'" (dans ce cas, convertit depuis l'unité spécifiée)

 

Modifié le 20/01/06

 

;;; STR2ANG Convertit une chaine de caractères représentant un angle
;;; en sa valeur en radians (nombre réel)
;;; (STR2ANG "540" 0) ou (STR2ANG "600g" nil) retournent 9.42478 soit 3*pi radians

(defun STR2ANG (str unt / ang)
 (if (= (type str) 'STR)
   (progn
     (if (not unt)
(setq unt (getvar "AUNITS"))
     )
     (cond
((numberp (read str))
 (setq ang (float (read str)))
 (cond
   ((or (= unt 0) (= unt 1) (= unt 4))
    (* (/ ang 180) pi)
   )
   ((= unt 2)
    (* (/ ang 200) pi)
   )
   ((= unt 3)
    ang
   )
 )
)
((and (= unt 4) (angtof str))
 (if (= (getvar "ANGDIR") 1)
   (- (getvar "angbase") (angtof str))
   (- (angtof str) (getvar "angbase"))
 )
)
((angtof str)
 (if (not (member "geomcal.arx" (arx)))
   (arxload "geomcal")
 )
 (* (/ (cal str) 180) pi)
)
     )
   )
   (princ "\n; erreur: type d'argument incorrect: stringp nil")
 )
)

 

ANG2STR convertit un angle en radians en une chaine du type "525.00g" "540d0'" en fonction des variables AUNITS et AUPREC courantes (les unités géodésiques ne permettent pas d'utiliser des angles supérieurs ou egaux à 360°).

ANG2STR ne prend pas en compte la valeur de ANGBASE (contrairement à ANGTOS), (ANG2STR (getangle)) retourne donc directement l'angle spécifié quelque soit la valeur de ANGBASE.

 

;;; ANG2STR Convertit une valeur d'angle en radians en chaine de caractère
;;; représentant l'angle dans l'unité spécifiée
;;; (ANG2STR (* 3 pi) 2 2) -> "600.00g"
;;; (ANG2STR (* 3 pi) nil nil) -> "540.00" pour AUNITS=0 et AUPREC=2

(defun ang2str (ang unt prec / d m s)
 (if (numberp ang)
   (progn
     (if (not unt)
(setq unt (getvar "AUNITS"))
     )
     (if (not prec)
(setq prec (getvar "AUPREC"))
     )
     (cond
((= unt 0)
 (rtos (* (/ ang pi) 180) 2 prec)
)
((= unt 1)
 (setq d (* (/ ang pi) 180)
       m (* 60 (- d (setq d (fix d))))
       s (* 60 (- m (setq m (fix m))))
 )
 (if (equal (abs s) 60 1e-009)
   (progn
     (setq s 0.0)
     (if (minusp m)
       (setq m (1- m))
       (setq m (1+ m))
     )
   )
 )
 (if (= (abs m) 60)
   (progn
     (setq m 0)
     (if (minusp m)
       (setq d (1- d))
       (setq d (1+ d))
     )
   )
 )
 (strcat (itoa d)
	 "d"
	 (if (		   (strcat (itoa m) "'")
	   ""
	 )
	 (if (		   (if (		     (strcat (itoa (fix s)) "\"")
	     (strcat (rtos s 2 (- prec 4)) "\"")
	   )
	   ""
	 )
 )
)
((= unt 2)
 (strcat (rtos (* (/ ang pi) 200) 2 prec) "g")
)
((= unt 3)
 (strcat (rtos ang 2 prec) "r")
)
((= unt 4)
 (if (= (getvar "ANGDIR") 1)
   (setq ang (- ang))
 )
 (angtos (+ (getvar "ANGBASE") ang) 4 prec)
)
     )
   )
   (princ "\n; erreur: type d'argument incorrect: numberp: nil")
 )
) 

[Edité le 15/1/2006 par (gile)][Edité le 16/1/2006 par (gile)][Edité le 20/1/2006 par (gile)]

 

[Edité le 21/1/2006 par (gile)]

[(gile)]

J'ai modifié les deux routines pour qu'elles fonctionnent aussi avec les unités géodésiques.

 

Certes ce type d'unité ne permet pas de spécifier des angles supérieurs à un tour.

 

Mais, pensant que ces deux routines pouvaient offrir une alternative intéressante à ANGTOF et ANGTOS (vu leur comportement par rapport à ANGDIR et ANGBASE), j'ai voulu qu'elles fonctionnent avec tous les types d'unités angulaires.

[bonuscad]

Excuse moi (Gile), mais je n'ai pas trop compris où tu voulais en venir!

 

pour les problèmes de ANGBASE et ANGDIR je passe soit par (getangle): tiens compte des variables précédente, ou par (getorient): ignore celles-ci.

 

 

 

[(gile)]

Au départ c'était pour pouvoir spécifier des angles supérieurs à 360° (pour le réseau hélicoïdal), et çà m'arrangeait de ne pas tenir compte de ANGDIR et ANGBASE, ensuite j'ai voulu que çà marche pour toutes les unités angulaires, même les unités géodésiques pour lesquelles on ne peut spécifier d'angles supérieurs à un tour complet.

[(gile)]

Deux petits exemples pour essayer de préciser "où je voulais en venir".

 

À la ligne de commande :

 

(while (not ang)
 (setq ang ([b]STR2ANG[/b] (getstring "\nEntrez un angle: ")))
)
(princ ([b]ANG2STR[/b] ang))

 

Ou pour une edit_box d'une boite de dialogue :

 

(action_tile
 "ang_box"
 (strcat
   "(if (angtof $value)"
   "(progn (setq ang ([b]STR2ANG[/b] $value))"
   "(set_tile \"ang_box\" ([b]ANG2STR[/b] ang)))"
   "(progn (alert \"Entrée non valide\")"
   "(mode_tile \"ang_box\" 2)))"
  )
) 

 

Mais il est fort probable que ces routines n'aient d'autre utilité que celle qui m'a motivé.

 

PS : J'ai rajouté un controle dans STR2ANG pour que la routine retourne nil dans tous les cas d'entrée non valide.

[(gile)]

Encore une petite amélioration aux deux routines.

 

Comme avec ANGTOS et ANGTOF :

 

- on peut spécifier le type d'unité pour STR2ANG (ou nil -> type courant)

- on peut spécifier le type d'unité et/ou la précision pour ANG2STR (ou nil -> type courant)

 

Les routines ont maintenant un comportement très similaire à ANGTOS et ANGTOF, tout en gardant leurs spécificités :

- non prise en compte des variables ANGDIR et ANGBASE

- pris en compte des angles supérieurs ou égaux à un tour (sauf avec les unités géodésiques, bien sûr)