web-dev-qa-db-fra.com

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

J'ai des données de direction du vent provenant d'une girouette, et les données sont représentées entre 0 et 359 degrés.

Je veux convertir ceci en format texte (rose des vents) avec 16 directions différentes.

En gros, je veux savoir s’il existe un moyen simple et rapide d’adapter la lecture de l’angle à un tableau de 16 cordes afin d’indiquer la direction du vent sans utiliser un grand nombre de déclarations if et de rechercher des plages d’angles.

On peut trouver la direction du vent ici .

merci!

angle
28
zacharoni

MODIFIER :  

Puisqu'il y a un changement d'angle tous les 22,5 degrés, la direction doit changer de main après 11,25 degrés.

Donc:

349-360//0-11 = N
12-33 = NNE
34-56 = NE

L'utilisation des valeurs de 327 à 348 (spectre complet de NNW) n'a pas permis d'obtenir un résultat pour la réponse d'Eudoxos. Après avoir réfléchi, je n'ai pas trouvé le défaut dans sa logique, j'ai donc réécrit la mienne ..

def degToCompass(num):
    val=int((num/22.5)+.5)
    arr=["N","NNE","NE","ENE","E","ESE", "SE", "SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
    print arr[(val % 16)]

>>> degToCompass(0)
N
>>> degToCompass(180)
S
>>> degToCompass(720)
N
>>> degToCompass(11)
N
>>> 12
12
>>> degToCompass(12)
NNE
>>> degToCompass(33)
NNE
>>> degToCompass(34)
NE

PAS :

  1. Divisez l'angle par 22,5 car 360 °/16 directions = 22,5 °/changement de direction. 
  2. Ajoutez 0,5 pour que, lorsque vous tronquez la valeur, vous puissiez rompre le «lien» entre le seuil de modification. 
  3. Tronquez la valeur en utilisant la division entière (il n’ya donc pas d’arrondi). 
  4. Indexez directement dans le tableau et imprimez la valeur (mod 16).
60
steve-gregory

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.

22
Matt Frear

Attention aux arrondis, les angles compris entre 349 et 11 doivent être "N", ajoutez donc le demi-secteur en premier (+ (360/16)/2), puis gérez le dépassement de 360 ​​par% 360, puis divisez par 360/16:

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

J'ai vérifié cela et cela fonctionne très bien et semble exact. 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)];
    }
3
user2675312

Fonction Javascript 100% active 

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) ] ;
}

pas  

  1. Étant donné un angle de 360 ​​degrés
  2. Comme le nord se situe entre -11,25 et 11,25, on soustrait 11,25 pour plus de précision 
  3. Diviser l'angle par 22,5 car 360 °/16 directions = 22,5 °/changement de direction
  4. Math.abs pour aussi négatif est encore au nord 
  5. Sélectionnez le segment de la réponse

J'espère que ça aide

1
Pascal

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];
}
1
Arne Kaas

Je crois qu'il est plus facile de:

  1. Décalage de 11,25
  2. Ajoutez un "N" à la fin de la liste des directions pour gérer le "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)];
1
edom-plc

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 sur toute votre division. 360/16 = 22,5, vous voudriez donc diviser par 22,5 pour obtenir la position.

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

1
Joseph

Ce JavaScript fonctionnera pour tous ceux qui n'ont besoin que de 8 points cardinaux et qui souhaitent des flèches correspondantes.

function getCardinalDirection(angle) {
    const directions = ['↑ N', '↗ NE', '→ E', '↘ SE', '↓ S', '↙ SW', '← W', '↖ NW'];
    return directions[Math.round(angle / 45) % 8];
}
0
Edward Brey

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

La cellule N12 indique les degrés pour lesquels une réponse est nécessaire. La plage N14: O29 recherche le secteur (de A à R):

VENT SECTEUR 0 A 22.5 B 45 C 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

0
John Babin

Si vous êtes arrivé (e) ici et que vous souhaitez uniquement diviser vos diplômes 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)]
0
Enda Molloy

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
0
Hristo markow

J'utilise lourdement R et j'avais besoin d'une solution pour cela. C’est ce que j’ai proposé et qui fonctionne bien pour toutes les combinaisons possibles. 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)])
}
0
azdatasci