3D Point rotieren lassen

[Developer_X]

Hi.
Ich habe mal eine Frage:
Wie lautet die Formel um einen 3D Punkt um einen anderen rotieren zu lassen?

Kann mir jemand bitte die Formeln sagen, für die rotation um die X,Y, und Z Achsen,
mit folgendem inhalt:

• 3D Punkt Coordinaten
• RotationsPunkt Coordinaten
• Rotations Winkel

Danke Developer_X

 

[Marco13]

Eine Rotation um einen bestimmten Punkt ist die Hintereinanderausführung von
- Verschiebung des Rotationszentrums in den Ursprung
- Rotation wie auf Rotation matrix - Wikipedia, the free encyclopedia beschrieben
- Verschiebung des Rotationszentruns zurück zur ursprünglichen Position

 

[Developer_X]

Ich habe ne Klasse Point3D geschrieben.

Point3D a = new Point3D(0,0,1-5);

Point3D rot_Point = new Point3D(0,0,0);

double new_x,new_y,new_z;
// rotiere mit den ganzen codes aber nur new_x und new_z sollen verändert werden durch die rotation

a = new Point3D(new_x,new_y,new_z);

Muss das denn unbedingt mit Matrixen passieren?
Ich meine bei der Rotation um die Y Axe zum Beispiel, rotiert im grunde genommen immer nur x und z, also die coordinaten verändern sich. Vorher, beim x-Shooter, wo ihr mir geholfen habt, da hattet ihr auch so ne art formel, die könnte man hier auch einbauen. ich will eine simple rotation.

Kannste mir helfen?

Developer_X

 

[Spacerat]

Es sollten matritzen sein, weil alles andere iwie keinen Sinn macht. Würdest du dich nicht ständig an den Klassen Point oder Vector festbeissen, hättest du mit Sicherheit schon eine Klasse Matrix fertig. In dieser die Methoden [c]rotate()[/c], [c]rotX()[/c], [c]rotY()[/c], [c]rotZ()[/c] und [c]transform()[/c] o.ä.

 

[Marco13]

Man könnte ja auch https://vecmath.dev.java.net/ verwenden, aber ... gut... :bahnhof:

 

[Developer_X]

Ich hatte da mehr an sowas gedacht:

	Point3D a = new Point3D(-1,-1,0);
	
	//,... in der Methode math
	
	rot++;
	double pointX=(-1*Math.cos(Math.toRadians(rot)+Math.toRadians(90))); 
	double pointY=(-1*Math.sin(Math.toRadians(rot)+Math.toRadians(90)));
		
	a = new Point3D(pointX,pointY,a.z);

Developer_X

 

[Developer_X]

Es sollten matritzen sein, weil alles andere iwie keinen Sinn macht. Würdest du dich nicht ständig an den Klassen Point oder Vector festbeissen, hättest du mit Sicherheit schon eine Klasse Matrix fertig. In dieser die Methoden [c]rotate()[/c], [c]rotX()[/c], [c]rotY()[/c], [c]rotZ()[/c] und [c]transform()[/c] o.ä.

Ich trau mich nicht mit Matrix zu arbeiten, da ich keine Ahnung habe, wie ich das machen soll.

 

[Spacerat]

Ich trau mich nicht mit Matrix zu arbeiten, da ich keine Ahnung habe, wie ich das machen soll.

Und warum dann nicht so?

Man könnte ja auch https://vecmath.dev.java.net/ verwenden...

Kennst du doch von Java3D... lässt sich auch in JOGL verwenden.

 

[Soulfly]

Wenn deine Rechnung nimmst und dann einmal Matrizenrechnung dir anlernst, was du solltest, dann wirst du merken, dass das was du da machst nichts anderes als eine manuelle Matrizentransformation für die Rotation um die Z Achse ist. Nichts anderes ist das, wobei deines noch falsch ist.

x = x * cos(rot) - y * sin(rot)
y = x * sin(rot) + y * con(rot)

Guck die Matrizen und Vektoren an sonst wird das nichts!

Greetz,

 

[Developer_X]

Wie ich sehe, habe ich keine Chance mehr, ohne Vectoren und Matrizen zu arbeiten, mir bleibt wohl nichts anderes mehr übrig, ich muss endlich Trigonometrie und Matrizen Rechnung lernen, dann habe ich keine Probleme mehr.

Danke für eure Hilfen, Developer-X

 

[Developer_X]

Wenn ich euch aber noch einmal belästigen dürfte :
Es gibt ja 3 Möglichkeiten zu rotieren.
Könnt ihr mir noch einmal helfen?

x = x * cos(rot) - y * sin(rot)
y = x * sin(rot) + y * con(rot)
z = z

Ist für mich Z-Achsen-Rotation.

Wie gehen die anderen beiden?
X-Achsen-Rotation
und
Y-Achsen-Rotation

Danke, Developer_X

 

[Illuvatar]

Drehmatrix ? Wikipedia

 

[Developer_X]

Sagen wir es mal so, bei mir dreht das Programm durch

				points[a][b] = new Point3D(-(x/2*1)+a*1 +gr.x,this.y[a][b]+gr.y,-(z/2*1)+b*1 +gr.z);
			
			//	Rotate around the Z-Axis
				x = points[a][b].x * Math.cos(Math.toRadians(gr.rot_z+90)) - points[a][b].y * Math.sin(Math.toRadians(gr.rot_z+90));
				y = points[a][b].x * Math.sin(Math.toRadians(gr.rot_z+90)) + points[a][b].y * Math.cos(Math.toRadians(gr.rot_z+90));
				z = points[a][b].z;
				
				points[a][b] = new Point3D(x,y,z);
			
			//	Rotate around the Y-Axis
				x = points[a][b].x * Math.cos(Math.toRadians(gr.rot_y+90)) - points[a][b].z * Math.sin(Math.toRadians(gr.rot_y+90));
				y = points[a][b].y;
				z = points[a][b].x * Math.sin(Math.toRadians(gr.rot_y+90)) + points[a][b].z * Math.cos(Math.toRadians(gr.rot_y+90));

				points[a][b] = new Point3D(x,y,z);
				
			//	Rotate around the X-Axis
				x = points[a][b].x;
				y = points[a][b].x * Math.sin(Math.toRadians(gr.rot_x+90)) + points[a][b].z * Math.cos(Math.toRadians(gr.rot_x+90));
				z = points[a][b].x * Math.cos(Math.toRadians(gr.rot_x+90)) - points[a][b].z * Math.sin(Math.toRadians(gr.rot_x+90));

				points[a][b] = new Point3D(x,y,z);

Man erkennt so gut wie nichts mehr.
Das ganze Rotiert nicht so wie es soll,

Developer_X

 

[Soulfly]

Dann mach dir mal Gedanken um den Drehpunkt, so alleine drehst du um (0,0,0).

 

[Developer_X]

das will ich ja gerade

 

[Marco13]

*seufz*...

Dass man sowas eher als

double angle = Math.toRadians(gr.rot_z+90);
double ca = Math.cos(angle);
double sa = Math.sin(angle);
x = points[a][b].x * ca - points[a][b].y * sa;
y = points[a][b].x * sa + points[a][b].y * ca;

schreiben sollte... :noe: und so eine Zeile wie

points[a][b] = new Point3D(-(x/2*1)+a*1 +gr.x,this.y[a][b]+gr.y,-(z/2*1)+b*1 +gr.z);

will ich mal nicht kommentieren.

Mach' dir einen Punkt, von dem du weißt, wo er liegt. (1,0,0) wäre da ein Kandidat. Drehe den dann um 45° um die z-Achse (und NUR um die). Und schau dann, ob das Ergebnis stimmt.

 

[Developer_X]

Ja das Ergebnis stimmt total.

Aber ich würde gerne wissen, wie die anderen beiden Rotationen in Java aussehen.

 

[Developer_X]

Ok, ich habs jetzt rausbekommen, die Lösung lautet:

				points[a][b] = new Point3D(-(x/2*1)+a*1 +gr.x,this.y[a][b]+gr.y,-(z/2*1)+b*1 +gr.z);
			
			//	Rotate around Y-Axis
				double angle = Math.toRadians(gr.rot_y);
				double ca = Math.cos(angle);
				double sa = Math.sin(angle);
				double x = points[a][b].x * ca - points[a][b].z * sa;
				double z = points[a][b].x * sa + points[a][b].z * ca;
				points[a][b] = new Point3D(x,points[a][b].y,z);
				
			//	Rotate around Z-Axis
				angle = Math.toRadians(gr.rot_z);
				ca = Math.cos(angle);
				sa = Math.sin(angle);
				x = points[a][b].x * ca - points[a][b].y * sa;
				double y = points[a][b].x * sa + points[a][b].y * ca;
				points[a][b] = new Point3D(x,y,points[a][b].z);
				
			//	Rotate around X-Axis
				angle = Math.toRadians(gr.rot_x);
				ca = Math.cos(angle);
				sa = Math.sin(angle);
				y = points[a][b].y * ca - points[a][b].z * sa;
				z = points[a][b].y * sa + points[a][b].z * ca;
				points[a][b] = new Point3D(points[a][b].x,y,z);