Punkt auf Kreis berechnen

Also ich glaube ich habe die Geschichte doch noch nicht so verstanden, wie ich dachte.

Bei der 2D Berechnung bestimme ich die Rotationsmatrix, bzw. die neue Position für das Ziel, um den Standort (in einen Kreis) drumherum.

Theoretisch wäre das doch nun auch für das hoch und runterschauen möglich.
Bisher habe ich es ermöglicht am gleichen Standort nach links oder rechts zu schauen, wenn ich jetzt nach oben oder unten schauen möchte, muss ich doch eine Rotationsmatrix für Y und Z bestimmen, oder ?

Also die Rotationsmatrize müsste dann so aussehen:

//  direction = Richtungsvektor, welcher die Form [x, y, z] besitzt

rotationsMatrixYZ[0] = (cos(VerschiebungsfaktorY) * directionXY[1]) + (-sin(VerschiebungsfaktorY) * directionXY[2])
rotationsMatrixYZ[1] = (sin(VerschiebungsfaktorY) * directionXY[1]) + ( cos(VerschiebungsfaktorY) * directionXY[2])

So brauch ich mir doch nicht erneut die Arbeit machen eine weitere Formel zu errechnen, wenn sich die Kopfbewegung von links nach rechts um einen VerschiebuungsfaktorX berechnet und die Kopfbewegung von oben nach unten um einen VerschiebuungsfaktorY berechnet.

Oder entstehen so Fehler ?
Bzw. ist das nicht korrekt ?

Was das Post davor angeht:
Die Richtungsmatrizen bilden sich wie auf der Seite des genannten Links.
X und Y-Richtungsmatrizen enthalten hierbei als Winkel die Verschiebung in X Richtung, bei der Z-Richtungsmatrix die Verschiebung in Y Richtung.

DirectionMatrixX[0] = [1, 0, 0]
DirectionMatrixX[1] = [0, cos(VerschiebungX), -sin(VerschiebungX)]
DirectionMatrixX[2] = [0, sin(VerschiebungX),  cos(VerschiebungX)]

DirectionMatrixY[0] = [cos(VerschiebungX), 0, -sin(VerschiebungX)]
DirectionMatrixY[1] = [0, 1, 0]
DirectionMatrixY[2] = [sin(VerschiebungX), 0,  cos(VerschiebungX)]

DirectionMatrixZ[0] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[1] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[2] = [0, 0, 1]

Richtungsvektor

Direction[0] = TargetX - EyeX;
//das nochmal für Y und Z

Rotationsvektor

RotationX[0] = DirectionMatrixX * Direction
//das nochmal für Y und Z

Anpassung der eigentlich Koordianten

TargetX = RotationX[0] + RotationY[0] + RotationZ[0] + MittelpunktX
//das nochmal für Y und Z

Ich hoffe jetzt ist es lesbarer

SeppJ

Maab schrieb:

Also ich glaube ich habe die Geschichte doch noch nicht so verstanden, wie ich dachte.

Bei der 2D Berechnung bestimme ich die Rotationsmatrix, bzw. die neue Position für das Ziel, um den Standort (in einen Kreis) drumherum.

Theoretisch wäre das doch nun auch für das hoch und runterschauen möglich.
Bisher habe ich es ermöglicht am gleichen Standort nach links oder rechts zu schauen, wenn ich jetzt nach oben oder unten schauen möchte, muss ich doch eine Rotationsmatrix für Y und Z bestimmen, oder ?

Ja, kann man so machen.

Also die Rotationsmatrize müsste dann so aussehen:

//  direction = Richtungsvektor, welcher die Form [x, y, z] besitzt

rotationsMatrixYZ[0] = (cos(VerschiebungsfaktorY) * directionXY[1]) + (-sin(VerschiebungsfaktorY) * directionXY[2])
rotationsMatrixYZ[1] = (sin(VerschiebungsfaktorY) * directionXY[1]) + ( cos(VerschiebungsfaktorY) * directionXY[2])

Verstehe nicht, warum du jetzt auf einmal mit 2D Matrizen kommst. Was willst du in diesem Zusammenhang damit sagen?

So brauch ich mir doch nicht erneut die Arbeit machen eine weitere Formel zu errechnen, wenn sich die Kopfbewegung von links nach rechts um einen VerschiebuungsfaktorX berechnet und die Kopfbewegung von oben nach unten um einen VerschiebuungsfaktorY berechnet.

Oder entstehen so Fehler ?
Bzw. ist das nicht korrekt ?

Das kommt ganz darauf an, wie die Bewegung genau aussehen soll. Eine mögliche Fehlerquelle die bei dieser Art des Vorgehens auftauchen kann, ist, dass es einen Unterschied macht, in welcher Reihenfolge die Rotationen um verschiedene Achsen durchgeführt werden.

Was das Post davor angeht:
Die Richtungsmatrizen bilden sich wie auf der Seite des genannten Links.
X und Y-Richtungsmatrizen enthalten hierbei als Winkel die Verschiebung in X Richtung, bei der Z-Richtungsmatrix die Verschiebung in Y Richtung.
DirectionMatrixX[0] = [1, 0, 0]
DirectionMatrixX[1] = [0, cos(VerschiebungX), -sin(VerschiebungX)]
DirectionMatrixX[2] = [0, sin(VerschiebungX),  cos(VerschiebungX)]
	
DirectionMatrixY[0] = [cos(VerschiebungX), 0, -sin(VerschiebungX)]
DirectionMatrixY[1] = [0, 1, 0]
DirectionMatrixY[2] = [sin(VerschiebungX), 0,  cos(VerschiebungX)]

DirectionMatrixZ[0] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[1] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[2] = [0, 0, 1]

Die sehen soweit richtig aus.

Richtungsvektor

Direction[0] = TargetX - EyeX;
//das nochmal für Y und Z

ok.

Rotationsvektor

RotationX[0] = DirectionMatrixX * Direction
//das nochmal für Y und Z

Schreib das mal bitte ganz aus, damit man sehen kann, ob du Matrixmultiplikation richtig beherrscht.

Anpassung der eigentlich Koordianten

TargetX = RotationX[0] + RotationY[0] + RotationZ[0] + MittelpunktX
//das nochmal für Y und Z

Nein, siehe vorheriger Post von mir. Diese Formel deutet sehr darauf hin, dass du vorher schon Quatsch gemacht hast. Ich schreib nochmal richtig hin, wie man mehrere Drehungen durchführen kann:

Sei Mittelpunkt $\vec{m}$, darum zu drehender Punkte $\vec{t}$. Dann ist der zu drehende Richtungsvektor $\vec{d}=\vec{t}-\vec{m}$. Gegeben eine Rotationsmatrix $\hat{X}(\alpha)$ um die x-Achse um einem Winkel $\alpha$ und entsprechend Rotationsmatrizen $\hat{Y}(\beta)$ und $\hat{Z}(\gamma)$ um y und z. Angenommen man möchte diese nacheinander auf $\vec{d}$ anwenden (siehe oben, warum das möglicherweise Probleme macht). Dazu rechnet man: \begin{equation*} \vec{d}_{neu}= \hat{Z}(\gamma) \cdot \hat{Y}(\beta) \cdot \hat{X}(\alpha) \cdot \vec{d}\end{equation*} Der Punkt $\cdot$ bedeutet dabei jeweils eine Matrixmultiplikation, je nach Zusammenhand zwischen 3x3 Matrizen bzw. 3x3 Matrix und 3d-Vektor. Die Klammerung der Rechnung ist dabei egal, die Reihenfolge der Matrizen beeinflusst jedoch das Ergebnis. Der transformierte t-Vektor ist dann $\vec{t}_{neu}=\vec{m}+\vec{d}_{neu}$

Also wie soll das nun genau aussehen:
Hier erstmal ein Bild

Was passiert da nun:
Links erstmal eine 3D-Darstellung der Umgebung.
Der Kreis signalisiert eigentlich nur, den Radius des Zielpunktes, d.h. auf dem der Zielpunkt sich bewegt.

Standort ist der Standort, also die Position, der Kamera
Ziel ist jeweils der Zielpunkt (Bei der Grafik sieht es so aus, als würde der Punkt im Kreis liegen, der liegt jedoch auf dem Kreis, also egal wo ich ihn nun gezeichnet hätte, er hätte immer den gleichen Abstand zum Mittelpunkt).

Oben rechts siehst du die Draufsicht.
Hier wird der Zielpunkt auf dem Kreis verschoben, wenn die Maus nach links oder rechts bewegt wird.
Der daraus entstehende Faktor, von neuer und alter Position der Maus, entspicht den Verschiebungswinkel!

Diese Draufsicht kannst du dir vorstellen wie du selbst siehst, d.h. du kannst deinen Kopf nach links uns rechts bewegen ohne deine eigetnliche Position (die deines Körpers) zu verädern. Kurz gesagt du schaust dich um _OHNE_ den Kopf zu knicken d.h. die Z-Höhe ist die selbe!

Die Position des alten Ziels und des neuen Ziels ist jeweils immer auf dem Kreis, d.h. die Länge beider Vektoren ist gleich.

Darunter siehst du die Rotation für die Z-Achse, diese soll das nicken deines Kopfes realisieren, d.h. du darfst nun auch nach oben und nach unten gucken, ohne deinen Körper zu bewegen.

Der Faktor entsteht bei der Verschiebung der Maus, wenn du sie nach oben oder nach unten bewegst.

Das ist eigentlich alles.
Ersteres funktioniert mit den angegeben Berechnungen im 2D Bereich.
Jedoch weiss ich nicht, wie ich das Kopf nicken implementieren soll, weil ich ja dann eine weitere Matrix rausbekomme.

// Zu deine Post

Die Matrixmultiplikation ist Zeile * Spalte.
In diesem genannten Fall heißt dass ich Multipliziere alle Faktoren der ersten Zeile der Matrix mit der erten Spalte des Vektors (dieser hat ja nur einen), anschließend Summiere ich die Multiplikationsergebnisse auf und komme auf die erste Dimension des Ergebnisvektors.

D.h. grob

EV[0] = M[0][0] * V[0] + M[0][1] * V[1] + M[0][2] * V[2]
EV[1] = M[1][0] * V[0] + M[1][1] * V[1] + M[1][2] * V[2]
EV[2] = M[2][0] * V[0] + M[2][1] * V[1] + M[2][2] * V[2]

Somit habe ich den Ergebnisvektor, der ja nun x,y und z enthält.

In unseren Fall heißt das:
RotationX[0] = DirectionMatrixX[0][0] * Direction[0] + DirectionMatrixX[0][1]...
RotationX[1] = DirectionMatrixX[1][0] * Direction[0] + DirectionMatrixX[1][1]...
RotationX[2] = DirectionMatrixX[2][0] * Direction[0] + DirectionMatrixX[2][1]...

RotationY[0] = DirectionMatrixY[0][0] * Direction[0] + DirectionMatrixY[0][1]...
RotationY[1] = DirectionMatrixY[1][0] * Direction[0] + DirectionMatrixY[1][1]...
RotationY[2] = DirectionMatrixY[2][0] * Direction[0] + DirectionMatrixY[2][1]...

RotationZ[0] = DirectionMatrixZ[0][0] * Direction[0] + DirectionMatrixZ[0][1]...
RotationZ[1] = DirectionMatrixZ[1][0] * Direction[0] + DirectionMatrixZ[1][1]...
RotationZ[2] = DirectionMatrixZ[2][0] * Direction[0] + DirectionMatrixZ[2][1]...

Dann habe ich drei Rotationsmatrizen!
Und hier hängt es dann irgendwie bei mir, jedenfalls was das R3 angeht.

So hatte ich es mir gedacht.

Was du mir jetzt geschrieben hast, bringt wieder etwas Licht ins Dunkle, jedoch kann ich das heute nicht mehr anwenden, da ich nicht mehr auf Arbeit bin, sondern werde das morgen tun.

Aber nochmal eine Frage zu deiner Erklärung:
Wenn ich den Punkt jetzt bei Mausbewegung von links nach rechts und umgekehrt wie im Bild besprochen um den Mittelpunkt rotieren lassen möchte, dann muss ich doch aus den genannten Rotationsmatrizen nur die MatrixX und MatrixY nutzen, oder ?

D.h. bei den beiden Matrizen wäre der Winkel (d.h. der Bewegungsfaktor der Maus) doch der selbe, damit ich mich mehrmals um meine eigene Achse drehen kann, oder ?

Mir fehlt irgendwie noch der letzte Funken der das Eis bricht, ich bin irgendwie kurz davor, aber so richtig habe ich die Brücke noch nicht entdeckt.

Liebe Grüße und danke für deine Nerven!

Maab.

Guten Morgen,

also soweit funktioniert das mit der Bewegung von links nach rechts, wie ich das möchte, der Radius bleibt auch der selbe.

Was nun noch nicht funktioniert ist die Bewegung von oben nach unten.
Da rotiert er, bei der Mausbewegung im Kreis, nicht über sich selbst drüber.
Schwer zu beschreiben, aber laut meinem Bild müsste die Kamera an der gleichen Position immer nach oben oder unten rotieren, dass macht sie in diesem Fall nicht.

Kann es sein, dass ich für die Bewegung von links nach rechts und umgekehrt, zwei Richtungsmatrizen brauche und für die Bewegung von oben nach unten und umgekehrt, ebenfalls zwei ?

Grüße,
Maab.

SeppJ

Maab schrieb:

Guten Morgen,

also soweit funktioniert das mit der Bewegung von links nach rechts, wie ich das möchte, der Radius bleibt auch der selbe.

Was nun noch nicht funktioniert ist die Bewegung von oben nach unten.
Da rotiert er, bei der Mausbewegung im Kreis, nicht über sich selbst drüber.
Schwer zu beschreiben, aber laut meinem Bild müsste die Kamera an der gleichen Position immer nach oben oder unten rotieren, dass macht sie in diesem Fall nicht.

Kann es sein, dass ich für die Bewegung von links nach rechts und umgekehrt, zwei Richtungsmatrizen brauche und für die Bewegung von oben nach unten und umgekehrt, ebenfalls zwei ?

Grüße,
Maab.

Ich bin mir nicht ganz sicher was du beschreibst, vermute aber mal, dass du Probleme mit den richtigen Drehachsen hast. Schnapp dir mal eine Kugel, markiere einen Punkt auf der Oberfläche und mal dir ein Koordinatensystem hin. Dann machst du genau die Sachen, die du dir von deinem Programm wünscht und achtest dabei darauf, um welche Achsen du deine Kugel drehst.

SeppJ schrieb:

Ich bin mir nicht ganz sicher was du beschreibst, vermute aber mal, dass du Probleme mit den richtigen Drehachsen hast. Schnapp dir mal eine Kugel, markiere einen Punkt auf der Oberfläche und mal dir ein Koordinatensystem hin. Dann machst du genau die Sachen, die du dir von deinem Programm wünscht und achtest dabei darauf, um welche Achsen du deine Kugel drehst.

Also so richtig weiss ich jetzt eigentlich auch nicht mehr, wie ich das erklären soll.

Eigentlich ist es einfach erklärt wenn ich sage: "Wie als würde man einen Egoshooter spielen und sich umgucken!".

D.h. Umschauen tut man sich ja, indem man sich nicht bewegt sondern nur seinen Kopf.
Hierbei funktiniert das umschauen von rechts nach links und links nach rechts, aber das umschauen von oben nach unten und unten nach oben nicht.

Beim hochschauen zieht die Sicht nach links oder rechts, nicht gerade hoch.
Ich weiss nicht recht, was ich da falsch gemacht habe.

Ich werde evtl. gleich mal versuchen das per Hand zu berechnen, wobei ich denke, dass mir das wahrscheinlich mehr Arbeit macht als es mir wirklich nützt.

Grüße,
Maab.

SeppJ

Das hört sich so an, als würdest du das 'Kopfnicken' durch Drehen um eine bestimmte Koordinatenachse versuchen. Realistischer als Drehachse wäre doch wohl eine Achse die orthogonal zu Blickrichtung in der Bewegungsebene liegt.

Okay also ich habe es nochmal etwas eindeutiger gemacht.

Schau mal HIER

Die Rotation um die Z-Achse (Rotationskreis = Dunkelgrau) simuliert das nach links und rechts schauen im Raum. Hier bei rotiert der Punkt (grün auf der Z-Achse) auf dieser Achse.
D.h. die Kamera schaut (Koordinatenursprung = Kamerastandort) in Richtung dieses Punktes.

Da existiert jedoch noch ein Punkt (rot) mitten im Raum der das nach oben und unten sehen simuliert.

Hierbei kann ich diesen Punkt um keiner der Achsen rotieren lassen, da die Rotation (Winkel = gelb) nicht korrekt sein würde.
D.h der Punkt (rot) soll für die auf und Auf- und Abewegung auf diesen Rotationskreis (türkis) hin und her fahren.

Ich habe die ganze Geschichte jetzt nur für diesen einen Quadranten gezeichnet, jedoch soll die Rotation in den anderen Quadranten (wenn man den Rotationskreis vervollständigt) weitergeführt werden können.

Also dazu finde ich im Netz auch irgendwie gar nichts, zumal ich auch nicht weiss unter was man da nun genau suchen sollte.

Grüße,
Maab.

SeppJ

Dann lag ich mit meinem letzten Beitrag richtig, dort steht auch schon die Lösung. Deine Rotationsachse steht orthogonal zu der Verbindung zwischen dem Ursprung und dem roten Punkt und sie liegt in der XY-Ebene. Oder anders ausgedrückt:
Rotationsachse = Kreuzprodukt(Ortsvektor roter Punkt, Z-Achse)

SeppJ schrieb:

Dann lag ich mit meinem letzten Beitrag richtig, dort steht auch schon die Lösung. Deine Rotationsachse steht orthogonal zu der Verbindung zwischen dem Ursprung und dem roten Punkt und sie liegt in der XY-Ebene. Oder anders ausgedrückt:
Rotationsachse = Kreuzprodukt(Ortsvektor roter Punkt, Z-Achse)

Was bedeutet hier "Z-Achse" ?
Die Koordinaten des Punktes auf der Z-Achse ?

Grüße,
Maab.