So ordnen Sie atan2 () den Graden 0-360 zu

atan2(y, x) hat diese Diskontinuität bei 180 °, wo sie im Uhrzeigersinn auf -180 ° ..0 ° umschaltet.

Wie ordne ich den Wertebereich 0 ° ..360 ° zu?

Hier ist mein Code:

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

Ich Berechnung der Richtung eines streichBerührungsEreignis angesichts der startPointund endPointbeide XY Punkt structs. Der Code ist für das iPhone, aber jede Sprache, die atan2f()dies unterstützt , reicht aus.

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

Lösung mit Modulo

Eine einfache Lösung, die alle Fälle erfasst.

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

Erläuterung

Positiv: 1 bis 180

Wenn Sie eine positive Zahl zwischen 1 und 180 mal 360 modifizieren, erhalten Sie genau die gleiche Zahl, die Sie eingegeben haben. Mod hier stellt nur sicher, dass diese positiven Zahlen als der gleiche Wert zurückgegeben werden.

Negativ: -180 bis -1

Wenn Sie hier mod verwenden, werden Werte im Bereich von 180 bis 359 Grad zurückgegeben.

Sonderfälle: 0 und 360

Die Verwendung von mod bedeutet, dass 0 zurückgegeben wird, was dies zu einer sicheren Lösung von 0-359 Grad macht.

Fügen Sie einfach 360 ° hinzu, wenn die Antwort von atan2 weniger als 0 ° beträgt.

Oder wenn Sie keine Verzweigung mögen, negieren Sie einfach die beiden Parameter und fügen Sie der Antwort 180 ° hinzu.

(Wenn Sie dem Rückgabewert 180 ° hinzufügen, liegt er gut im Bereich von 0 bis 360, dreht aber den Winkel um. Wenn Sie beide Eingabeparameter negieren, wird er zurückgedreht.)

@erikkallen ist nah aber nicht ganz richtig.

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

Dies sollte in C ++ funktionieren: (Je nachdem, wie fmod implementiert ist, kann es schneller oder langsamer sein als der bedingte Ausdruck)

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

Alternativ können Sie dies tun:

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

da (x, y) und (-x, -y) sich in den Winkeln um 180 Grad unterscheiden.

Ich habe 2 Lösungen, die für alle Kombinationen von positivem und negativem x und y zu funktionieren scheinen.

1) Missbrauch atan2 ()

Gemäß den Dokumenten nimmt atan2 die Parameter y und x in dieser Reihenfolge. Wenn Sie sie jedoch umkehren, können Sie Folgendes tun:

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

2) Verwenden Sie atan2 () korrekt und konvertieren Sie anschließend

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

@Jason S: Ihre "fmod" -Variante funktioniert bei einer standardkonformen Implementierung nicht. Der C-Standard ist explizit und klar (7.12.10.1, "die fmod-Funktionen"):

Wenn y ungleich Null ist, hat das Ergebnis das gleiche Vorzeichen wie x

so,

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

ist eigentlich nur eine ausführliche Umschreibung von:

atan2(y,x)/M_PI*180

Ihr dritter Vorschlag ist jedoch genau richtig.

Das mache ich normalerweise:

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;

Ich habe eine Formel zum Ausrichten des Winkels in 0 bis 360 erstellt

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

Eine alternative Lösung besteht darin, die Funktion mod () zu verwenden, die wie folgt definiert ist:

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

Dann wird mit der folgenden Funktion der Winkel zwischen den Punkten ini (x, y) und end (x, y) erhalten. Der Winkel wird in Grad ausgedrückt, die auf [0, 360] Grad normiert sind. und Nord mit 360 Grad.

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

Die Geosphäre des R-Pakets berechnet die PeilungRumb, eine konstante Peilungslinie bei gegebenem Ursprungspunkt und Ost / Nord. Die Ost- und Nordrichtung muss in einer Matrix oder einem Vektor liegen. Der Ursprungspunkt für eine Windrose ist 0,0. Der folgende Code scheint das Problem leicht zu beheben:

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 ° wird (-1 + 360) = 359 °
-179 ° wird (-179 + 360) = 181 °

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

Dies gibt den Grad von 0 ° -360 ° gegen den Uhrzeigersinn zurück, 0 ° ist um 3 Uhr.

Eine Formel für den Wertebereich von 0 bis 360 Grad.

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

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

Hier ist etwas Javascript. Geben Sie einfach x- und y-Werte ein.

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