# Vectorspiegelung



## Alexander (4. Aug 2010)

Hallo,

ich habe zwei (zufällige) dreideminsionale Vektoren d und n.
Nun möchte ich d an n spiegeln. Ich habe vergebens versucht das hinzukriegen ;(
Weiß mir da jemand Hilfe?


----------



## SlaterB (4. Aug 2010)

poste doch alternativ wenigstens Hilfen, z.B. deinen bisherigen Code, 
hast du eine Vektor-Klasse, eine main-Methode zumindest mit erstellten Test-Vektoren usw.?

und erkläre mathematisch, was es bedeutet, einen Vektor zu spiegeln, führe textuell eine Beispiel-Rechnung durch 
(im Programm sind dann idealerweise auch genau diese Vektoren schon testweise vorhanden)

wenn man sieht, was zu rechnen ist, dann müsste man dir helfen können, das in Java-Befehle umzusetzen,
oder weißt du schon ohne Java nicht, worum es geht?


----------



## Marco13 (4. Aug 2010)

Wenn es wirklich nur Vektoren sind, sollte das nicht so schwer sein: Winkel zwischen beiden ausrechnen, Kreuzprodukt zwischen beiden Bilden, und d um die Kreuzprodukt-Achse um 2*Winkel rotieren.


----------



## Alexander (4. Aug 2010)

Die Länge von Vector n ist irrelevant, dies bildet lediglich die Achse der Spiegelung dar.
Der Vector d wird daran gespiegelt. Beispiele:
n = {1, 1, 0}
d = {2, 1, 0}
g = {1, 2, 0}

n = {1, 2, 0}
d = {3, 1, 0}
g = {-1, 3, 0}

Sind nun recht primitive Beispiele und auch nur 2D, aber hoffe ihr habt die Idee.

Marco, jetzt müsste man das nur noch in Java-Befehle umwandeln 
Wie kann man einen Vektor denn rotieren?


----------



## Alexander (4. Aug 2010)

Und müsste man dann nicht nur den Winkel zwischen den beiden Vektoren bestimmen und dann den Vektor d um das doppelte davon rotieren? Warum das Kreuzprodukt bilden?


----------



## Marco13 (4. Aug 2010)

Alexander hat gesagt.:


> Und müsste man dann nicht nur den Winkel zwischen den beiden Vektoren bestimmen und dann den Vektor d um das doppelte davon rotieren?



Und um welche Achse?



> Warum das Kreuzprodukt bilden?



Ah... :reflect:


----------



## ProgX (4. Aug 2010)

Ich versteh nicht ganz das Problem!
Wenn du einen Vektor spiegeln möchtest, musst du theoretisch doch nur alle Wert mit (-1) multiplizieren!


----------



## Michael... (4. Aug 2010)

Braucht man zum Spiegeln im dreidimensionalen Raum nicht eine Ebene? Oder wie soll man sich das Vorstellen einen Vektor an einer Geraden in 3D zu spiegeln?


----------



## Ruzmanz (4. Aug 2010)

> Wenn du einen Vektor spiegeln möchtest, musst du theoretisch doch nur alle Wert mit (-1) multiplizieren!



Nein, dann hättest du den Ursprung als Spiegelpunkt. D.h. du kannst zwar Vektoren am Ursprung spiegeln, aber er will einen anderen Punkt/Grade/Ebene benutzten.

@Alexander deine Hilfestellungen sind ziemlich irreführend und eher wenig hilfreich, da sie falsch sind. Es wäre hilfreicher, wenn du uns verraten würdest, ob es sich um Punkte/Graden/Ebenen handelt. Denn so wie ich das sehe ist dein "n" ein Richtungsvektor, welche den Ursprung als Ortvektor hat ... das geht aus deinem Beispiel nicht hervor. Und d ist ein Punkt?. Es könnte genau so gut eine Ebene und eine Grade sein?

Eine Alternative zu den Lösungsvorschlägen wäre z.B. eine Lotgrade zu erstellen (Punkt/Ebene oder Punkt/Grade(mit Hilfsebene)) und so durch die Distanz den Spiegelpunkt zu berrechnen. Oder bei Punkt/Punkt mit einer einger Graden.


----------



## Pulma (4. Aug 2010)

Eventuell hilft das hier weiter:
www.mario-konrad.ch/file.php?id=10016


----------



## Alexander (4. Aug 2010)

Ich will einen Vektor an einer anderen Spiegeln. Mir hilft es, es so zu veranschaulichen, dass sich ein Punkt and einer Geraden spiegelt, aber praktisch sind es zwei Vektoren..


```
// Load variables
double[] dir1 = dir;
double[] dir2 = canvas.agents.get(a).getDir();
double[] pos2 = canvas.agents.get(a).getPos();
double kn1[] = { pos1[0] - pos2[0], pos1[1] - pos2[1], pos1[2] - pos2[2] };

// Normalize values to calculate direction
canvas.normalize(dir1, 1);
canvas.normalize(kn1, 100);
// Calculating direction
dir1[0] *= -1;
dir1[1] *= -1;
dir1[2] *= -1;
double ta1 = Math.sqrt(Math.pow(dir1[0] - kn1[0], 2) + Math.pow(dir1[1] - kn1[1], 2) + Math.pow(dir1[2] - kn1[2], 2));
double tb1 = Math.sqrt(Math.pow(dir1[0], 2) + Math.pow(dir1[1], 2) + Math.pow(dir1[2], 2));
double tc1 = Math.sqrt(Math.pow(kn1[0], 2) + Math.pow(kn1[1], 2) + Math.pow(kn1[2], 2));
double alpha1;
if (tb1 == 0 || tc1 == 0) // Direction/Speed = 0
	alpha1 = 0;
else
	alpha1 = Math.acos((tb1 * tb1 + tc1 * tc1 - ta1 * ta1) / 2 / tb1 / tc1) * 180 / Math.PI;
double t2b1 = tb1*Math.sin(90-alpha1);
canvas.normalize(kn1, t2b1);
dir1[0] = 2*kn1[0]-dir1[0];
dir1[1] = 2*kn1[1]-dir1[1];
dir1[2] = 2*kn1[2]-dir1[2];

canvas.normalize(dir1, 1);
dir = dir1;
```


```
public void normalize(double v[], double lenght) {
		double d = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
		if (d == 0.0) {
			System.out.println("Dividing by zero :O");
			return;
		}
		v[0] *= lenght/d;
		v[1] *= lenght/d;
		v[2] *= lenght/d;
	}
```

Das hab ich nun gemacht.. Was haltet ihr davon?
Errechnet den Winkel (alpha) der beiden Vektoren und errechnet den Mittelpunkt zwischen Erstem Vektor und Ziel um dann an das Ziel zu kommen..

Es scheint nicht zu funktionieren, hoffe aber die Idee stimmt..
Findet wer den Fehler oder weiß wer wie sowas besser geht?
Hoffe damit ist klar was ich versuche zu erreichen..


----------



## Alexander (4. Aug 2010)

```
public void spiegel(double dir[], double kn[]) { // spiegelt dir an kn (kn wird normalisiert, dir nicht)
		canvas.normalize(kn, 100); // Damit sich kn und dir nicht zu 0 ausgleichen.. Länge ist ja eh egal
		dir[0] *= -1;
		dir[1] *= -1;
		dir[2] *= -1;
		double ta = Math.sqrt(Math.pow(dir[0] - kn[0], 2) + Math.pow(dir[1] - kn[1], 2) + Math.pow(dir[2] - kn[2], 2));
		double tb = Math.sqrt(Math.pow(dir[0], 2) + Math.pow(dir[1], 2) + Math.pow(dir[2], 2));
		double tc = Math.sqrt(Math.pow(kn[0], 2) + Math.pow(kn[1], 2) + Math.pow(kn[2], 2));
		double winkel;
		if (tb == 0 || tc == 0) // Direction/Speed = 0
			winkel = 0;
		else
			winkel = Math.acos((tb * tb + tc * tc - ta * ta) / 2 / tb / tc) * 180 / Math.PI;
		double t2b = tb*Math.sin((90-winkel)/180*Math.PI);
		canvas.normalize(kn, t2b);
		dir[0] = 2*kn[0]-dir[0];
		dir[1] = 2*kn[1]-dir[1];
		dir[2] = 2*kn[2]-dir[2];
	}
```

Ich hatte beim:
double t2b = tb*Math.sin((90-winkel)/180*Math.PI);
vergessen /180*PI zu rechnen... scheiß radiantweise 
Das funktioniert jetzt auch 

Danke an alle!

Hat jemand Verbesserungsvorschläge zu diesem code? damits kürzer/schneller geht?
Ansonsten hab ich hierzu keine fragen mehr


----------

