Normalisieren Sie die Ausrichtung zwischen 0 und 360

Arbeite ich an einem einfachen drehen routine, die normalisiert Objekte eine rotation zwischen 0 und 360 Grad. Mein C# code scheint zu funktionieren, aber ich bin nicht ganz glücklich mit ihm. Kann das jemand verbessern, der auf den code unten, so dass es ein bisschen mehr robust?

public void Rotate(int degrees)
    {
        this.orientation += degrees;

        if (this.orientation < 0)
        {
            while (this.orientation < 0)
            {
                this.orientation += 360;
            }
        }
        else if (this.orientation >= 360)
        {
            while (this.orientation >= 360)
            {
                this.orientation -= 360;
            }
        }
    }

InformationsquelleAutor der Frage JuniorDeveloper | 2009-10-27

angle c#rotation

Verwenden modulo-Arithmetik:

this.orientation += degrees;

this.orientation = this.orientation % 360;

if (this.orientation < 0)
{
    this.orientation += 360;
}

InformationsquelleAutor der Antwort tvanfosson

Dies ist eine, die normalisiert zu jedem Bereich.
Nützlich für die Normalisierung zwischen [-180,180], [0,180] oder [0,360].

( in C++)

//Normalisiert beliebiger Anzahl in einem beliebigen Bereich 
//durch die übernahme den Bereich umschließt, wenn unter min oder über max 
Doppel-Normalisierung( const double-Wert, const double start, const double Ende ) 
{ 
const double Breite = end - start ; //
const double offsetValue = Wert - start ; //Wert relativ zu 0 

return ( offsetValue - ( floor( offsetValue /Breite ) * Breite ) ) + start ; 
//+ start reset zurück zum start mit der original-Palette 
}

Für ints

//Normalisiert beliebiger Anzahl in einem beliebigen Bereich 
//durch die übernahme den Bereich umschließt, wenn unter min oder über max 
int normalisieren( const int value, const int start, const int end ) 
{ 
const int Breite = end - start ; //
const int offsetValue = Wert - start ; //Wert relativ zu 0 

return ( offsetValue - ( ( offsetValue /Breite ) * Breite ) ) + start ; 
//+ start reset zurück zum start mit der original-Palette 
}

Also im Grunde das gleiche, aber ohne den Boden.
Die version, die ich persönlich benutze ist ein generischer, dass ein Werk für alle numerischen Typen und es verwendet auch eine neue Etage, die nichts tut, im Falle der integralen Typen.

InformationsquelleAutor der Antwort QBziZ

18

Kann dies vereinfacht werden zu den folgenden.
```
public void Rotate (int degrees) {
    this.orientation = (this.orientation + degrees) % 360;
    if (this.orientation < 0) this.orientation += 360;
}
```
C# folgt den gleichen Regeln wie C und C++ und i % 360 geben Sie einen Wert zwischen -359 und 359 für jede beliebige ganze Zahl, dann die zweite Zeile ist um sicherzustellen, dass es in den Bereich 0 bis 359 inclusive.

Wenn Sie wollte sein schiefes, man könnte Sie unten eine Zeile:
```
    this.orientation = (this.orientation + (degrees % 360) + 360) % 360;
```
würde halten Sie es positiv, unter allen Bedingungen, aber das ist ein böse hack für das speichern einer Zeile code, so würde ich es nicht tun, aber ich wird erklären.

Vom degrees % 360 erhalten Sie eine Zahl zwischen -359 und 359. Hinzufügen 360 wird, ändern Sie die Auswahl, um zwischen 1 und 719. Wenn orientation ist schon positiv, das hinzufügen dieser Garantie ist es immer noch, und der Letzte % 360 bringen es zurück zu dem Bereich 0 durch 359.

An einer nackten mindestenskönnte man den code vereinfachen, da die ifs und whiles kombiniert werden können. Zum Beispiel, das Ergebnis der Bedingungen, die in diesen beiden Zeilen:
```
if (this.orientation < 0)
while (this.orientation < 0)
```
ist immer das gleiche, daher müssen Sie nicht die umliegenden if.

So, dass Sie tun könnten:
```
public void Rotate (int degrees) {
    this.orientation += degrees;
    while (this.orientation <   0) this.orientation += 360;
    while (this.orientation > 359) this.orientation -= 360;
}
```
aber ich würde noch gehen für die Modul-version, da es vermeidet loops. Dies wird wichtig, wenn ein Benutzer 360,000,000,000 für die rotation (und Sie wird dies tun, glauben Sie mir) und dann müssen Sie nehmen ein frühes Mittagessen, während Ihr code schleift Weg 🙂

InformationsquelleAutor der Antwort paxdiablo
7

Ich irgendwie schnell verspottet Sie diese in AS3, aber sollte funktionieren (Sie müssen möglicherweise += auf den Winkel)
```
private Number clampAngle(Number angle)
{
    return (angle % 360) + (angle < 0 ? 360 : 0);
}
```
InformationsquelleAutor der Antwort enzuguri
7

Formel für die re-orienting kreisförmigen Werte ich.e zu halten Winkel zwischen 0 und 359 ist:
```
angle + Math.ceil( -angle / 360 ) * 360
```
generalisierte Formel für die Verschiebung Winkel Orientierung:
```
angle + Math.ceil( (-angle+shift) / 360 ) * 360
```
in dem Wert der Verschiebung darstellen circular-shift-e.g ich möchte Werte in -179 bis 180, dann kann es wie folgt dargestellt werden:
angle + Math.ceil( (-Winkel-179) /360 ) * 360

InformationsquelleAutor der Antwort Saad Ahmed
2

Ich lieber vermeiden, Schleifen, Bedingungen, beliebigen offsets (3600), und Math.____() Aufrufe:
```
var degrees = -123;
degrees = (degrees % 360 + 360) % 360;
//degrees: 237
```
InformationsquelleAutor der Antwort Ronnie Overby
0

Fügen Sie ein beliebiges Vielfaches von 360 Grad, zwischen denen Ihre möglichen Eingabewerte werden könnte (um es über null), und nehmen Sie die restlichen mit %, wie dies
```
angle = 382;
normalized_angle = (angle+3600) %360;
//result = 22
```
Obigen Fall nehmen können input-Winkel nach unten zu -3600. Sie können eine beliebige Zahl (Vielfaches von 360) wahnsinnig hoch ist, dass der input-Wert positiv.

In der Regel während einer animation, Ihre vorherigen frame/step-Wert würde wahrscheinlich bereits normalisiert durch den vorherigen Schritt, so werden Sie gut zu gehen, indem Sie nur 360:
```
normalized_angle = (angle+360) %360;
```
InformationsquelleAutor der Antwort sergio

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.