Conversion de la direction du vent en angles en mots de texte

Voici une implémentation javascript de la réponse de steve-gregory, qui fonctionne pour moi.

function degToCompass(num) {
    var val = Math.floor((num / 22.5) + 0.5);
    var arr = ["N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"];
    return arr[(val % 16)];
}

Voir sa réponse pour une explication de la logique.

Attention aux arrondis, angles entre 349...11 devrait être "N", donc ajouter d'abord la moitié du secteur (+(360/16) / 2), puis gérer le débordement sur 360 par %360, puis diviser par 360/16:

["N","NNW",...,"NNE"][((d+(360/16)/2)%360)/(360/16)]

J'ai vérifié cela et cela fonctionne très bien et semble précis. Source: http://www.themethodology.net/2013/12/how-to-convert-degrees-to-cardinal.html par Adrian Stevens

    public static string DegreesToCardinal(double degrees)
    {
        string[] caridnals = { "N", "NE", "E", "SE", "S", "SW", "W", "NW", "N" };
        return caridnals[(int)Math.Round(((double)degrees % 360) / 45)];
    }

    public static string DegreesToCardinalDetailed(double degrees)
    {
        degrees *= 10;

        string[] caridnals = { "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW", "N" };
        return caridnals[(int)Math.Round(((double)degrees % 3600) / 225)];
    }

L'inverse:

function getDir($b)
{

   $dirs = array('N'=>0, 'NNE'=>22.5,"NE"=>45,"ENE"=>67.5, 'E'=>90,'ESE'=>112.5, 'SE'=>135,'SSE'=>157.5, 'S'=>180,'SSW'=>202.5, 'SW'=>225,'WSW'=>247.5, 'W'=>270,'WNW'=>292.5,'NW'=>315,'NNW'=>237.5, 'N'=>0,'North'=>0,'East'=>90,'West'=>270,'South'=>180);
   return $dirs[$b];
}

Je ferais probablement juste une simple division des degrés pour obtenir une position dans un tableau ou une valeur enum ou quelque chose qui vous donnerait le texte dont vous avez besoin. Juste arrondir à la baisse sur l'ensemble de votre division. 360/16 = 22,5, donc vous voudriez diviser par 22,5 pour obtenir la position.

Chaîne [] a = [N, NNW, NW, WNW,...,NNE]

Je crois qu'il est plus facile de:

1. déplacez la direction de 11,25
2. Ajouter un "N" à la fin de la liste orientation pour gérer plus de 360',

DirTable = ["N","NNE","NE","ENE","E","ESE", "SE","SSE","S","SSW","SW","WSW", "W","WNW","NW","NNW",**"N"**]; 

wind_direction= DirTable[Math.floor((d+11.25)/22.5)];

Fonction Javascript 100% de travail

function degToCompass(num) { 
    while( num < 0 ) num += 360 ;
    while( num >= 360 ) num -= 360 ; 
    val= Math.round( (num -11.25 ) / 22.5 ) ;
    arr=["N","NNE","NE","ENE","E","ESE", "SE", 
          "SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"] ;
    return arr[ Math.abs(val) ] ;
}

Les Étapes

1. étant donné un angle de 360 degrés
2. puisque le nord est compris entre -11.25 et 11,25, nous soustrayons 11,25 pour la précision
3. divisez l'angle par 22.5 car 360deg / 16 directions = 22.5 deg/changement de direction
4. Mathématiques.abs Pour comme négatif est encore au nord
5. sélectionnez le segment de arr à partir de la réponse

J'espère que ça aide

Cela fonctionne bien

#!/usr/bin/env python

def wind_deg_to_str1(deg):
        if   deg >=  11.25 and deg <  33.75: return 'NNE'
        elif deg >=  33.75 and deg <  56.25: return 'NE'
        elif deg >=  56.25 and deg <  78.75: return 'ENE'
        elif deg >=  78.75 and deg < 101.25: return 'E'
        elif deg >= 101.25 and deg < 123.75: return 'ESE'
        elif deg >= 123.75 and deg < 146.25: return 'SE'
        elif deg >= 146.25 and deg < 168.75: return 'SSE'
        elif deg >= 168.75 and deg < 191.25: return 'S'
        elif deg >= 191.25 and deg < 213.75: return 'SSW'
        elif deg >= 213.75 and deg < 236.25: return 'SW'
        elif deg >= 236.25 and deg < 258.75: return 'WSW'
        elif deg >= 258.75 and deg < 281.25: return 'W'
        elif deg >= 281.25 and deg < 303.75: return 'WNW'
        elif deg >= 303.75 and deg < 326.25: return 'NW'
        elif deg >= 326.25 and deg < 348.75: return 'NNW'
        else: return 'N'

def wind_deg_to_str2(deg):
        arr = ['NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW', 'N']
        return arr[int(abs((deg - 11.25) % 360)/ 22.5)]

i = 0
while i < 360:
        s1 = wind_deg_to_str1(i)
        s2 = wind_deg_to_str2(i)
        print '%5.1f deg -> func1(%-3s), func2(%-3s), same:%s' % (i, s1, s2, ('ok' if s1 == s2 else 'different'))
        i += 0.5

Utilisé dans Excel: VLOOKUP(MROUND (N12, 22.5), N14: O29, 2, FALSE)

La cellule N12 est la direction vers en degrés pour laquelle une réponse est nécessaire. La gamme N14: O29 regarde le secteur(A à R):

SECTEUR ÉOLIEN 0 Un 22,5 B 45 C De 67,5 D 90 E 112,5 F 135 G 157,5 H 180 J 202,5 K 225 L 247.5 M 270 N 292.5 P 315 Q 337,5 R

Si vous êtes arrivé ici et ne sont intéressés à briser vos degrés dans l'une des 8 directions.

function degToCompass(num){
    const val =  Math.floor((num / 45) + 0.5);
    const arr = ["N","NE","E", "SE","S","SW","W","NW"];
    return arr[(val % 8)]

J'utilise beaucoup R et j'avais besoin d'une solution pour cela. C'est ce que je suis venu avec et fonctionne bien pour toutes les combinaisons possibles que je l'ai nourri:

degToCardinal <- function(degrees) {
  val <- as.integer((degrees / 22.5) + 0.5)
  arr <- c("N","NNE","NE","ENE","E","ESE", "SE", "SSE","S","SSW","SW","WSW","W","WNW","NW","NNW")
  return(arr[((val+1) %% 16)])
}