Einfache Möglichkeit, Winkel zwischen -179 und 180 Grad zu halten

Gibt es eine einfache Möglichkeit zu konvertieren, die einen Winkel (in Grad) zwischen -179 und 180? Ich bin sicher, ich könnte mit mod (%) und einige if-Anweisungen, aber es wird hässlich:


//Make angle between 0 and 360
angle%=360;

//Make angle between -179 and 180
if (angle>180) angle-=360;

Es scheint nur, wie es sein sollte eine einfache mathematische operation, die nicht beide Aussagen gleichzeitig. Ich kann nur noch zum erstellen einer statischen Methode für die Konvertierung für jetzt.

Kommentar zu dem Problem - Öffnen
IMHO, Das ist nicht hässlich. Das ist ganz sauber und klar. Kommentarautor: C. Ross
Was ist, wenn der Anfangswinkel weniger dann -179? Kommentarautor: Matthew Whited
Nach Rücksprache mit den docs bin ich mit Matthew Whited - Winkel % 360 ergibt sich ein Wert zwischen -359 und +359, nicht 0 und +359. Damit Ihre Lösung scheitert zu normalisieren, erste Werte kleiner dann -179. Kommentarautor: Daniel Brückner
@Daniel: Guter Punkt. Das gegebene Beispiel ist nicht gut genug. Fühlen Sie sich frei, etwas zu deuten, das ist besser. Kommentarautor: User1

InformationsquelleAutor der Frage User1 | 2010-02-23

  1. 14

    Ich bin ein wenig spät zur party, ich weiß, aber...

    Meisten dieser Antworten sind nicht gut, weil Sie versuchen, schlau zu sein und kurz und dann nicht aufpassen Grenzfälle.

    Es ist ein wenig Ausführlicher, aber wenn Sie wollen, damit es funktioniert, einfach in der Logik zu machen, damit es funktioniert. Versuchen Sie nicht, clever zu sein.

    int normalizeAngle(int Winkel) 
{ 
 int newAngle = Winkel; 
 while (newAngle <= -180) newAngle += 360; 
 while (newAngle > 180) newAngle -= 360; 
 zurück newAngle; 
}

    Das funktioniert und ist einigermaßen sauber und einfach, ohne zu versuchen, zu fancy. Beachten Sie, dass nur null oder eins von den while-Schleifen können immer ausgeführt werden.

    InformationsquelleAutor der Antwort Platinum Azure

  2. 64
    //reduce the angle  
angle =  angle % 360; 

//force it to be the positive remainder, so that 0 <= angle < 360  
angle = (angle + 360) % 360;  

//force into the minimum absolute value residue class, so that -180 < angle <= 180  
if (angle > 180)  
    angle -= 360;

    InformationsquelleAutor der Antwort James K Polk

  3. 14

    Versuchen, diese stattdessen! 

    atan2(sin(angle), cos(angle))

    atan2 hat eine Reihe von [-π, π). Dieser nutzt die Tatsache, dass tan θ = sin θ /cos θ, und dass atan2 ist intelligent genug, um zu wissen, welche Quadranten θ ist.

    Da möchte man Grad, werden Sie wollen, konvertieren Sie Ihre Winkel und Bogenmaß: 

    atan2(sin(angle * PI/180.0), cos(angle * PI/180.0)) * 180.0/PI

    Update
    Meine bisherigen Beispiel war auch vollkommen legitim, jedoch beschränkt sich der Bereich um ±90°. atan2's-Reihe ist der gewünschte Wert von -179° bis 180°. Erhalten Sie unten.

    Versuchen Sie dies: 

    asin(sin(angle)))

    Die domain sin ist die echte Linie, die Palette ist [-1, 1]. Die domain asin ist [-1, 1], und der Bereich ist [-PI/2, PI/2]. Da asin ist die inverse von sin Ihre Eingaben nicht geändert (viel, es gibt einige abdriften, denn Sie sind mit floating point-zahlen). So bekommen Sie Ihre eingegebenen Wert zurück, und Sie erhalten die gewünschte Bandbreite als ein Nebeneffekt von der eingeschränkten Reichweite der Arkussinus.

    Da möchte man Grad, werden Sie wollen, konvertieren Sie Ihre Winkel und Bogenmaß: 

    asin(sin(angle * PI/180.0)) * 180.0/PI

    Werden(Vorsicht: Trigonometrische Funktionen sind bazillions mal langsamer als eine einfache dividieren und subtrahieren-Operationen, auch wenn Sie fertig sind, in eine FPU!)

    InformationsquelleAutor der Antwort Seth

  4. 8

    Nicht so schlau, auch, aber nicht wenn.

    Winkel = (Winkel + 179) % 360 - 179;

    Aber ich bin nicht sicher, wie Java-Griffe modulo für negative zahlen. Dies funktioniert nur, wenn -1 modulo 360 entspricht 359.

    UPDATE

    Gerade überprüft die docs a % b ergibt sich ein Wert zwischen -(|b| - 1) und +(|b| - 1) daher der code ist fehlerhaft. Konto für negative Werte, die von der modulo-operator verwenden Sie den folgenden.

    angle = ((angle + 179) % 360 + 360) % 360 - 179;

    Aber ... Nein ... nie ... etwas ähnlich zu deiner ersten Lösung, aber die festen Werte, die kleiner als -179.

    InformationsquelleAutor der Antwort Daniel Brückner

  5. 6

    Dieser funktioniert sowohl negative und Dezimalzahlen und erfordert keine Schleifen, noch trigonometrische Funktionen:

    Winkel= Math.Stock(Winkel /360 + 0.5) * 360

    Das Ergebnis ist in [-180, 180) Intervall. Für (-180, 180] Intervall, können Sie diese stattdessen zu verwenden:

    Winkel= Math.ceil(Winkel /360 - 0.5) * 360

    InformationsquelleAutor der Antwort Astronomino

  6. 3

    Vielleicht nicht hilfreich, aber ich habe immer gerne mit nicht-Grad-Winkel.

    Einem Winkel im Bereich von 0 bis 255 kann in Schranken gehalten werden bitweise Operationen, oder für eine einzelne byte-variable, einfache erlaubt zum überlaufen.

    Einem Winkel Bereich von -128 bis 127 ist nicht ganz so einfach mit dem bitweisen ops, aber wieder, für ein single-byte-variable, Sie können lassen Sie es überlauf.

    Dachte ich, es sei eine gute Idee, viele Jahre zurück für die Spiele, wo Sie sind wahrscheinlich über eine lookup-Tabelle für die Winkel. In diesen Tagen, nicht so gut - die Winkel sind unterschiedlich verwendet, und schwimmen sowieso.

    Immer noch - vielleicht eine Erwähnung Wert.

    InformationsquelleAutor der Antwort Steve314

  7. 3

    Einen kurzen Weg, die Griffe negativen zahlen ist

    double mod = x - Math.floor((x + 179.0) / 360) * 360;

    Cast abschmecken.

    BTW: Es scheint, dass die Winkel zwischen den (180.0, 181.0) sind nicht definiert. Sollte nicht der Bereich (-180, 180] (exklusive, inklusive]

    InformationsquelleAutor der Antwort Peter Lawrey

  8. 3

    Ich weiß, dass Jahre vergangen, aber noch immer.

    Diese Lösung enthält keine Schleifen, kein Abzug, kein modulo (ermöglicht das normalisieren in Bogenmaß Intervall). Funktioniert für alle Eingaben, einschließlich negativer Werte, große Werte, Rand-Fällen.

    double normalizedAngle = angle - (ceil((angle + M_PI)/(2*M_PI))-1)*2*M_PI;  //(-Pi;Pi]:
double normalizedAngle = angle - (ceil((angle + 180)/360)-1)*360;           //(-180;180]:

double normalizedAngle = angle - (floor((angle + M_PI)/(2*M_PI)))*2*M_PI;  //[-Pi;Pi):
double normalizedAngle = angle - (floor((angle + 180)/360))*360;           //[-180;180):

    InformationsquelleAutor der Antwort alexburtnik

  9. 2

    Gut, eine weitere Lösung, diese mit nur einer division und keine Schleifen.

    static double normalizeAngle(double angle)
{
    angle %= 360.0; //[0..360) if angle is positive, (-360..0] if negative
    if (angle > 180.0) //was positive
        return angle - 360.0; //was (180..360) => returning (-180..0)
    if (angle <= -180.0) //was negative
        return angle + 360.0; //was (-360..180] => returning (0..180]
    return angle; //(-180..180]
}

    InformationsquelleAutor der Antwort Vlad

  10. 2

    Hier ist ein integer-Lösung:

    int normalize(int angle)
{
    angle %= 360;
    int fix = angle / 180; //Integer division!!
    return (fix) ? angle - (360 * (fix)) : angle;
}

    Manchmal wird klug macht einfach mehr Spaß, Platin Azure.

    InformationsquelleAutor der Antwort Cory B

  11. 2

    Ich habe eine Formel für die Ausrichtung der kreisförmigen Werte

    halten Winkel zwischen 0 und 359 ist:

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

    aber zu halten zwischen -179 bis 180 Formel kann sein:

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

    dieser wird seine Orientierung shift über -179 halten tatsächlichen Winkel intakt

    generalisierte Formel für die Verschiebung Winkel Orientierung:

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

    InformationsquelleAutor der Antwort Saad Ahmed

  12. 1
    int angle = -394;

//shortest
angle %= 360;
angle = angle < -170 ? angle + 360 : (angle > 180 ? angle - 380 : angle);

//cleanest
angle %= 360;
if (angle < -179) angle += 360;
else if (angle > 180) angle -= 360;

    InformationsquelleAutor der Antwort Matthew Whited

  13. 0

    Wie etwa 

    (angle % 360) - 179

    Dies tatsächlich zurück, andere Ergebnisse erzielen als der naive Ansatz, vorgestellt in der Frage, aber es wird halten Sie den Winkel zwischen den Grenzen angegeben. (Ich nehme an, dass vielleicht dies die falsche Antwort, aber ich lasse es hier im Falle löst es andere Personen mit ähnlichen problem).

    InformationsquelleAutor der Antwort

  14. 0

    Hier ist mein Beitrag. Es scheint zu funktionieren für alle Winkel ohne Rand Probleme. Es ist schnell. Es kann n180[360000359] = -1 fast augenblicklich. Beachten Sie, wie die Sign-Funktion hilft bei der Auswahl der richtigen Logik Weg und ermöglicht den gleichen code in unterschiedlichen Winkeln.

    Ratch

    n180[a_] := 
 If[Abs[Mod[a, If[Sign[a] == 0, 360, Sign[a] 360]]] <= 180, 
  Mod[a, If[Sign[a] == 0, 360, Sign[a] 360]], 
  Mod[a, If[Sign[a] == 0, 360, -Sign[a] 360]]]

    InformationsquelleAutor der Antwort Ratch

  15. -2

    Es besser ist die Verwendung von Bibliothek-Funktionen. Sie behandeln Sonderfälle wie NaN und Ewigkeiten.

    public static double normalizeAngleDegrees(double angle) {
    return Math.toDegrees(Math.atan2(Math.sin(Math.toRadians(angle)), Math.cos(Math.toRadians(angle))));
}

    InformationsquelleAutor der Antwort cohadar

Schreibe einen Kommentar