Einen Punkt um den Ursprung und um einen anderen Punkt rotieren

In diesem Artikel zeige ich euch, wie man einen Punkt um den Ursprung und um einen anderen Punkt rotiert. Ein Grundverständnis darüber, was ein Vektor und eine Matrix ist, wird vorausgesetzt.

Übersicht:

Einen Punkt um den Ursprung rotieren

Anmerkung: Ich gehe von einer umgekehrten y-Achse aus, wie man sie häufig in Frameworks sieht. Je nach Koordinatensystem muss die Drehmatrix etwas angepasst werden.

Zunächst benötigen wir die Rotationsmatrix. Das Produkt der Rotationsmatrix und der Position eines Punktes als Vektor ergibt einen neuen Vektor. Der x und y Wert dieses Vektors ergibt den neuen, rotierten Punkt:

Die Rotationsmatrix, oder auch Drehmatrix gennant, lautet (hier ist a der Winkel):

( cos a  -sin a )
( sin a   cos a )

Da wir aber ein Koordinatensystem mit getauschter y-Achse verwenden muss die Rotationsmatrix etwas angepasst werden:

( cos a   sin a )
(-sin a   cos a )

Die Rotationsmatrix multiplizieren wir nun mit dem Punkt (als Vektor) den wir rotieren wollen und kommen auf unsere neue Position ( x’ und y’):

( x' ) = ( cos a   sin a ) * ( x )
( y' )   (-sin a   cos a )   ( y )

Lösen wir das ganze auf, kommen wir auf die Formel, die wir auch in unserem Code verwenden werden:

x' = cos a * x + sin a * y
y' =-sin a * x + cos a * y

Hier das ganze als Methode einer Vector Klasse in Java umgesetzt:

public void rotateAroundOrigin(float angleDegrees) {
	// Den Winkel von Grad in Radiant umrechnen
	float angle = (float) ( (Math.PI / 180 ) * angleDegrees );
	// // Die Werte des neuen Punktes berechnen
	float xNew = (float) (  Math.cos(angle) * this.x + Math.sin(angle) * this.y);
	float yNew = (float) ( -Math.sin(angle) * this.x + Math.cos(angle) * this.y);
	// Die neue Position anwenden
	this.x = xNew;
	this.y = yNew;
}

Einen Punkt um einen vorgegeben Punkt rotieren

Das Rotieren eines Punktes um einen anderen, vorgegebenen Punkt funktioniert ähnlich wie das rotieren um den Ursprung. Allerdings sind noch ein paar weitere Schritte notwendig. Bei der Rotation um einen bestimmten Punkt betrachtet man den zu rotierenden Punkt relativ zum Punkt um den dieser rotiert werden soll. Wir projizieren den zu rotierenden Punkt also in das Koordinatensystem des Punktes, um den wir rotieren möchten. Schließlich kehren wir die Projektion wieder um.

Ausgangslage:

Ausgangslage

Nach der Projektion:

Nach der Projektion

Nach der Rotation:

Nach der Rotation

Nach dem umkehren der Projektion:

Nach der Rotation

Die Formel, mit der y-Achsen Korrektur ist also Folgende (xp und yp sind die x und y Werte des Punktes den wir rotieren und xt und yt die Werte des Punktes um den wir rotieren):

( x' ) = ( cos a  sin a ) * ( xp - xt) + ( xt )
( y' )   (-sin a  cos a )   ( yp - yt)   ( yt )

Aufgelöst bekommen wir dann:

x' = ( cos a * (xp - xt) + sin a * (yp - yt)) + xt
y' = (-sin a * (xp - xt) + cos a * (yp - yt)) + yt

Und als Java Methode:

public void rotateAroundPoint(Vector2f targetPoint, float angleDegrees) {
	// Den Winkel von Grad in Radiant umrechnen
	float angle = (float) ( (Math.PI / 180 ) * angleDegrees );
	// // Die Werte des neuen Punktes berechnen
	float xNew = (float) 
			( ( Math.cos(angle) * (this.x - targetPoint.x) + Math.sin(angle) * (this.y - targetPoint.y)) + targetPoint.x );
	float yNew = (float)
			( ( -Math.sin(angle) * (this.x - targetPoint.x) + Math.cos(angle) * (this.y - targetPoint.y)) + targetPoint.y );
	// Die neue Position anwenden
	this.x = xNew;
	this.y = yNew;
}