# 3D Point rotieren lassen



## Developer_X (14. Jan 2010)

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 (14. Jan 2010)

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 (14. Jan 2010)

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 (14. Jan 2010)

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 (14. Jan 2010)

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


----------



## Developer_X (14. Jan 2010)

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 (14. Jan 2010)

Spacerat hat gesagt.:


> 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 (14. Jan 2010)

Developer_X hat gesagt.:


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


Und warum dann nicht so?





Marco13 hat gesagt.:


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


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


----------



## Soulfly (15. Jan 2010)

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 (15. Jan 2010)

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 (15. Jan 2010)

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 (15. Jan 2010)

Drehmatrix ? Wikipedia


----------



## Developer_X (15. Jan 2010)

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 (15. Jan 2010)

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


----------



## Developer_X (15. Jan 2010)

das will ich ja gerade


----------



## Marco13 (15. Jan 2010)

*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 (16. Jan 2010)

Ja das Ergebnis stimmt total.

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


----------



## Developer_X (16. Jan 2010)

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);
```


----------

