Como mapear atan2 () para graus 0-360

atan2(y, x) tem essa descontinuidade em 180 ° onde muda para -180 ° ..0 ° no sentido horário.

Como mapeio a faixa de valores para 0 ° ..360 °?

aqui está meu código:

CGSize deltaPoint = CGSizeMake(endPoint.x - startPoint.x, endPoint.y - startPoint.y);
float swipeBearing = atan2f(deltaPoint.height, deltaPoint.width);

Estou calculando a direção de um evento de toque de deslizar considerando as duas estruturas de ponto XY startPointe e endPoint. O código é para o iPhone, mas qualquer idioma que suporte serve atan2f().

(x > 0 ? x : (2*PI + x)) * 360 / (2*PI)

Solução usando Módulo

Uma solução simples que abrange todos os casos.

degrees = (degrees + 360) % 360;  // +360 for implementations where mod returns negative numbers

Explicação

Positivo: 1 a 180

Se você modificar qualquer número positivo entre 1 e 180 por 360, obterá exatamente o mesmo número inserido. O modo aqui apenas garante que esses números positivos sejam retornados com o mesmo valor.

Negativo: -180 a -1

Usar o mod aqui retornará valores na faixa de 180 e 359 graus.

Casos especiais: 0 e 360

Usar mod significa que 0 é retornado, tornando esta uma solução segura de 0-359 graus.

Basta adicionar 360 ° se a resposta de atan2 for menor que 0 °.

Ou se você não gosta de ramificação, apenas negue os dois parâmetros e adicione 180 ° à resposta.

(Adicionar 180 ° ao valor de retorno o coloca perfeitamente na faixa de 0-360, mas inverte o ângulo. Negar os dois parâmetros de entrada o inverte.)

@erikkallen está perto, mas não muito bem.

theta_rad = atan2(y,x);
theta_deg = (theta_rad/M_PI*180) + (theta_rad > 0 ? 0 : 360);

Isso deve funcionar em C ++: (dependendo de como o fmod é implementado, pode ser mais rápido ou mais lento do que a expressão condicional)

theta_deg = fmod(atan2(y,x)/M_PI*180,360);

Alternativamente, você pode fazer isso:

theta_deg = atan2(-y,-x)/M_PI*180 + 180;

uma vez que (x, y) e (-x, -y) diferem em ângulos em 180 graus.

Tenho 2 soluções que parecem funcionar para todas as combinações de xe y positivo e negativo.

1) Abuso atan2 ()

De acordo com os documentos, atan2 usa os parâmetros y e x nessa ordem. No entanto, se você os inverter, poderá fazer o seguinte:

double radians = std::atan2(x, y);
double degrees = radians * 180 / M_PI;
if (radians < 0)
{
    degrees += 360; 
}

2) Use atan2 () corretamente e converta depois

double degrees = std::atan2(y, x) * 180 / M_PI;
if (degrees > 90)
{
    degrees = 450 - degrees;
}
else
{
    degrees = 90 - degrees;
}

@Jason S: sua variante "fmod" não funcionará em uma implementação compatível com os padrões. O padrão C é explícito e claro (7.12.10.1, "as funções fmod"):

se y for diferente de zero, o resultado terá o mesmo sinal de x

portanto,

fmod(atan2(y,x)/M_PI*180,360)

é na verdade apenas uma reescrita detalhada de:

atan2(y,x)/M_PI*180

Sua terceira sugestão, no entanto, está correta.

Isso é o que eu normalmente faço:

float rads = atan2(y, x);
if (y < 0) rads = M_PI*2.f + rads;
float degrees = rads*180.f/M_PI;

angle = Math.atan2(x,y)*180/Math.PI;

Eu fiz uma fórmula para orientar o ângulo de 0 a 360

angle + Math.ceil( -angle / 360 ) * 360;

Uma solução alternativa é usar a função mod () definida como:

function mod(a, b) {return a - Math.floor (a / b) * b;}

Então, com a seguinte função, o ângulo entre os pontos ini (x, y) e final (x, y) é obtido. O ângulo é expresso em graus normalizados para [0, 360] graus. e Norte referenciando 360 graus.

    function angleInDegrees(ini, end) {
        var radian = Math.atan2((end.y - ini.y), (end.x - ini.x));//radian [-PI,PI]
        return mod(radian * 180 / Math.PI + 90, 360);
    }

A geosfera dos pacotes R calculará o rolamentoRhumb, que é uma linha de rolamento constante dado um ponto de origem e leste / norte. O leste e o norte devem estar em uma matriz ou vetor. O ponto de origem de uma rosa dos ventos é 0,0. O código a seguir parece resolver prontamente o problema:

windE<-wind$uasE
windN<-wind$vasN
wind_matrix<-cbind(windE, windN)
wind$wind_dir<-bearingRhumb(c(0,0), wind_matrix)
wind$wind_dir<-round(wind$wind_dir, 0)

theta_rad = Math.Atan2(y,x);
if(theta_rad < 0)
  theta_rad = theta_rad + 2 * Math.PI;    //if neg., add 2 PI to it
theta_deg = (theta_rad/M_PI*180) ;        //convert from radian to degree

//or
theta_rad = Math.Atan2(y,x);
theta_rad = (theta_rad < 0) ? theta_rad + 2 * Math.PI : theta_rad;
theta_deg = (theta_rad/M_PI*180) ;

-1 grau torna-se (-1 + 360) = 359 graus
-179 graus torna-se (-179 + 360) = 181 graus

double degree = fmodf((atan2(x, y) * (180.0 / M_PI)) + 360, 360);

Isso retornará o grau de 0 ° -360 ° no sentido anti-horário, 0 ° está nas 3 horas.

Uma fórmula para ter o intervalo de valores de 0 a 360 graus.

f (x, y) = 180-90 * (1 + sinal (x)) * (1-sinal (y ^ 2)) - 45 * (2 + sinal (x)) * sinal (y)

     -(180/pi())*sign(x*y)*atan((abs(x)-abs(y))/(abs(x)+abs(y)))

Aqui está um pouco de javascript. Basta inserir os valores xey.

var angle = (Math.atan2(x,y) * (180/Math.PI) + 360) % 360;