Berechnung, wenn ein Winkel zwischen zwei Winkeln

Also ich mache ein kleines Spiel, wo ich bin, die überprüfen, ob ein Charakter kann "sehen" die anderen, wo die Charakter sehen kann Charakter B, wenn A in einer bestimmten Entfernung von B, und die Richtung in Grad von A ist +/- 45 Grad, der Winkel B ist die Verkleidung.

Derzeit mache ich eine kleine Rechnung, wo ich Kontrolle wenn

(facingAngle - 45) =< angleOfTarget =< (facingAngle + 45)

Dies funktioniert gut, außer wenn wir überqueren die 360-Grad-Linie.

Sagen wir mal facingAngle = 359, angleOfTarget = 5. In dieser situation, das Ziel ist nur 6 Grad vom Zentrum entfernt ist, daher möchte ich meine Funktion true zurück. Leider 5 nicht zwischen 314 und 404.

Mögliche Duplikate von Bestimmen Sie, wenn der Winkel liegt zwischen 2 andere Winkel

InformationsquelleAutor user1641573 | 2012-09-02

math trigonometry

21

Nur versuchen
```
anglediff = (facingAngle - angleOfTarget + 180 + 360) % 360 - 180

if (anglediff <= 45 && anglediff>=-45) ....
```
Der Grund dafür ist, dass der Unterschied in den Winkeln ist facingAngle - angleOfTarget obwohl aufgrund der Verpackung-Effekte, werden Sie vielleicht von 360 Grad.

Hinzufügen 180+360 dann modulo 360 subtrahieren Sie dann 180, effektiv wandelt alles um den Bereich -180 bis 180 Grad (durch addieren oder subtrahieren von 360 Grad).

Dann können Sie die Winkel-Unterschied einfach, ob es innerhalb von -45 bis 45 Grad.
- Zuerst habe ich dache es war nicht die Arbeit in Thema Fall, aber dann habe ich getestet in Python.. Arbeiten!! Also ging ich zurück zu Pascal, um herauszufinden, warum er nicht dort arbeiten, stellt sich heraus, dass mod in Pascal funktioniert nicht mit negativen zahlen...
- Dies scheitert in dem Fall, wo facingAngle ist 0 und angleOfTarget ist 359, zum Beispiel. Es sei denn, ich bin fehlt etwas, erhalten Sie (0 - 359 + 180) % 360 - 180 = -359. Ein absoluter Wert ist erforderlich, um die facingAngle - angleOfTarget Subtraktion.
- Vollständig getestet, in Java (Android). Es funktioniert.
InformationsquelleAutor ronalchn
8

Gibt es eine trigonometrische Lösung, die vermeidet, dass die Umhüllung problem.

Ich nehme an, Sie haben (x, y) - Koordinaten für beide Charaktere P1 und P2. Sie haben bereits angegeben, dass Sie wissen, der Abstand zwischen den beiden, die du vermutlich berechnet sich mit Pythagoras' theorem.

Können Sie die dot product von zwei Vektoren berechnen der Winkel zwischen Ihnen:
```
A . B = |A| . |B| . cos(theta).
```
Wenn Sie A als facingAngle vector-es wird [cos(fA), sin(fA)], und haben Größe |A| 1.

Wenn Sie B als der Vektor zwischen den beiden Zeichen, und Ihre Entfernung vor Sie bekommen:
```
cos(theta) = (cos(fA) * (P2x - P1x) + sin(fA) * (P2y - P1y)) /|B|
```
wo |B| ist die Strecke, die du bereits berechnet.

Brauchen Sie nicht, um tatsächlich die inverse Cosinus zu finden theta, da für eine Reihe von -45 bis +45 brauchen Sie nur für cos(theta) >= 0.70710678 (d.h. 1 /sqrt(2)).

Das mag leicht kompliziert, aber die Chancen sind, dass Sie bereits alle erforderlichen Variablen hanging around in Ihrem Programm sowieso.

InformationsquelleAutor Alnitak
8

Hier ist eine einfache Funktion, die ich online gefunden, und geändert. Es funktioniert einwandfrei, für jeden Winkel (kann auch außerhalb von 0-360). (Diese Funktion ist in c, arbeitet in Xcode.)

Denken Sie daran, es wird überprüft, gegen den UHRZEIGERSINN, von Winkel A bis Winkel B. Es gibt JA (true), wenn der Winkel zwischen 🙂

Zunächst eine einfache Konvertierung Funktion, um alle Winkel 1-360
```
//function to convert angle to 1-360 degrees
 static inline double angle_1to360(double angle){
 angle=((int)angle % 360) + (angle-trunc(angle)); //converts angle to range -360 + 360
 if(angle>0.0)
 return angle;
 else
 return angle + 360.0;
 }
```
Überprüfen Sie, ob der Winkel ist zwischen 🙂
```
//check if angle is between angles
 static inline BOOL angle_is_between_angles(float N,float a,float b) {
 N = angle_1to360(N); //normalize angles to be 1-360 degrees
 a = angle_1to360(a);
 b = angle_1to360(b);

 if (a < b)
 return a <= N && N <= b;
 return a <= N || N <= b;
 }
```
ZB. Um zu überprüfen, ob der Winkel 300 ist zwischen 180 Grad und 10 Grad:
```
BOOL isBetween=angle_is_between_angles( 300, 180,10);
```
//GIBT JA
- Scheint zu funktionieren für Java, wenn trunc() wird ersetzt mit Mathematik.floor().
- Anzumerken, dass Sie Lesen können, eine else zwischen return a <= N && N <= b; und return a <= N || N <= b;
- Wie wäre es, wenn (a = 10, b = 5, N = 355) Wird angle_is_between_angles() gibt true zurück, wenn, die wir verwenden, die als Argumente?
InformationsquelleAutor Stan Tatarnykov
0

Lösung einfach zu handhaben wickeln am unteren Ende (in negative Werte), ist nur hinzuzufügen 360 alle Ihre Werte:
```
(facingAngle + 315) =< (angleOfTarget + 360) =< (facingAngle + 405)
```
So, die Subtraktion von 45 kann niemals negativ, weil es nicht mehr passiert.

Griff Verpackung am oberen Ende müssen Sie noch einmal überprüfen, hinzufügen anderen 360 auf die angleOfTarget Wert:
```
canSee  = (facingAngle + 315 <= angleOfTarget + 360) &&
          (angleOfTarget + 360 <= facingAngle + 405);
canSee |= (facingAngle + 315 <= angleOfTarget + 720) &&
          (angleOfTarget + 720 <= facingAngle + 405);
```
InformationsquelleAutor paxdiablo

Andere Weise mit immer minimale positive Differenz und Vergleich mit Schwellwert:

anglediff = Math.min(Math.abs(facingAngle - angleOfTarget), 360 - Math.abs(angleOfTarget - allowDirection));
if (anglediff <= 45)

InformationsquelleAutor DFE

0

Neuformulierung Alnitak Antwort in einer anderen Weise, eine Lösung, die vermeidet, dass der Winkel wrap bei 360 Grad ist noch einmal das problem in einem anderen Koordinatensystem, wo die Winkel werden immer kleiner. Hier ist der code:
```
def inside_angle(facing, target):
    dot = cos(facing)*cos(target) + sin(facing)*sin(target)
    angle = acos(dot)

    return angle <= pi/4
```
Dies geschieht mithilfe der Vektor-Projektion. Angenommen, die Vektoren |Verkleidung> = [cos(in) sin(in)] und |target> = [cos(Ziel) sin(Ziel)], bei der Projektion das Ziel in der nach-Vektor, der Winkel reicht von null, wenn das Ziel genau auf der gegenüberliegenden Vektor-oder zunehmen, auf beiden Seiten. Auf diese Weise können wir einfach vergleichen Sie es mit pi/4 (45 Grad). Die Formel für den Winkel ist die folgende:
```
cos(angle) = <facing|target> /<target|target> <facing|facing>
```
Das heißt, der Cosinus des Winkels ist das Skalarprodukt zwischen den Vektoren |Verkleidung> und |target> Module unterteilt, die 1 ist in diesem Fall, die wird:
```
angle = acos(<facing|target>)
```
Referenz:
https://en.wikipedia.org/wiki/Vector_projection

InformationsquelleAutor hdante

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.