3D Cube aus Vektoren

[stulleman]

Hallo zusammen!

Ich habe heute mit einem kleinen Projekt angefangen, in dem ich eine einfach Animation eines 3D Cubes machen will.
Da ich heute erst mit Vektoren in der Schule angefangen habe :toll: , wollte ich erst mal grundsätzlich fragen ob mein Vorgehen richtig ist.

Ich habe eine Vector-List mit 8 Vektoren drin: A (2,-2,-2), B (2, 2,-2), C (-2,2,-2), D (-2,-2,-2), E (2,-2,2), F (2, 2,2), G (-2,2,2), H (-2,-2,2)

Weiterhin habe ich mir eine Methode geschrieben, die diese Vektoren um eine bestimmte Achse dreht:

/**
	 * 
	 * @param vectorList
	 * @param angle
	 * @return
	 */
	public static Vector<Vector3D> rotateVectorX(Vector<Vector3D> vectorList, double angle) {
		Vector<Vector3D> newVectorList = new Vector<Vector3D>();
		angle = Math.toRadians(angle);
		
		for(int i = 0; i < vectorList.size(); i++) {
			Vector3D currentVec = vectorList.get(i);
			
			double newX1 = currentVec.getX1();
			double newX2 = (Math.cos(angle) * currentVec.getX2()) - (Math.sin(angle) * currentVec.getX2());
			double newX3 = (Math.sin(angle) * currentVec.getX3()) + (Math.cos(angle) * currentVec.getX3());
			
			newVectorList.add(new Vector3D(newX1, newX2, newX3, currentVec.getName()));
		}

		return newVectorList;
	}

	/**
	 * 
	 * @param vectorList
	 * @param angle
	 * @return
	 */
	public static Vector<Vector3D> rotateVectorY(Vector<Vector3D> vectorList, double angle) {
		Vector<Vector3D> newVectorList = new Vector<Vector3D>();
		angle = Math.toRadians(angle);
		
		for(int i = 0; i < vectorList.size(); i++) {
			Vector3D currentVec = vectorList.get(i);
			
			double newX1 = (Math.cos(angle) * currentVec.getX1()) + (Math.sin(angle) * currentVec.getX1());
			double newX2 = currentVec.getX2();
			double newX3 = (-Math.sin(angle) * currentVec.getX3()) + (Math.cos(angle) * currentVec.getX3());
			
			newVectorList.add(new Vector3D(newX1, newX2, newX3, currentVec.getName()));
		}

		return newVectorList;
	}
	
	/**
	 * 
	 * @param vectorList
	 * @param angle
	 * @return
	 */
	public static Vector<Vector3D> rotateVectorZ(Vector<Vector3D> vectorList, double angle) {
		Vector<Vector3D> newVectorList = new Vector<Vector3D>();
		angle = Math.toRadians(angle);
		
		for(int i = 0; i < vectorList.size(); i++) {
			Vector3D currentVec = vectorList.get(i);
			
			double newX1 = (Math.cos(angle) * currentVec.getX1()) - (Math.sin(angle) * currentVec.getX1());
			double newX2 = (Math.sin(angle) * currentVec.getX2()) + (Math.cos(angle) * currentVec.getX2());
			double newX3 = currentVec.getX3();

			newVectorList.add(new Vector3D(newX1, newX2, newX3, currentVec.getName()));
		}

		return newVectorList;
	}

Das ist was ich bis jetzt habe, doch hier kommen schon ein paar Probleme auf.
Wenn ich den Cube jetzt um 90° drehe, sind die Ergebnisse, meines Erachtens richtig. Mit 45° wiederum nicht. Seht ihr einen Fehler im Code?

Ergebnisse sind übrigens:

90°:
A: (-1.9999999999999998|-2.0|-2.0)
B: (-1.9999999999999998|2.0|-2.0)
C: (1.9999999999999998|2.0|-2.0)
D: (1.9999999999999998|-2.0|-2.0)
E: (-1.9999999999999998|-2.0|2.0)
F: (-1.9999999999999998|2.0|2.0)
G: (1.9999999999999998|2.0|2.0)
H: (1.9999999999999998|-2.0|2.0)

45°:
A: (2.220446049250313E-16|-2.82842712474619|-2.0)
B: (2.220446049250313E-16|2.82842712474619|-2.0)
C: (-2.220446049250313E-16|2.82842712474619|-2.0)
D: (-2.220446049250313E-16|-2.82842712474619|-2.0)
E: (2.220446049250313E-16|-2.82842712474619|2.0)
F: (2.220446049250313E-16|2.82842712474619|2.0)
G: (-2.220446049250313E-16|2.82842712474619|2.0)
H: (-2.220446049250313E-16|-2.82842712474619|2.0)

Und am einfachsten ist es das ganze dann nicht perspektivisch, sonder orthogonal anzuzeigen oder? Und dann von vorne, sodass die x1-Achse so zu sagen nicht beachtet werden muss?

Ich hoffe ich liege nicht zu sehr daneben ???:L

 

[SlaterB]

warum hast du dickes 3D und drehst dann um eine der Achsen?
na mag dir später helfen, im Moment ist das dann aber doch eine 'normalere' Drehung im 2D-Raum..

> double newX2 = (Math.sin(angle) * currentVec.getX2()) + (Math.cos(angle) * currentVec.getX2());

jede Koordinate ist nur ein Faktor des bisherigen, das kann ja kaum funktionieren,
stelle dir einen Vector (1, 0) vor, der auf einer der Achsen liegt, in die zweite Dimension, x2 meinetwegen, 0 aufweist,
dieses x2 bleibt bei 0, egal mit was du mulitiplizierst und addierst, nix zu machen
also falsch, durch fast alle Drehungen muss doch etwas 'Höhe' gewonnen werden in die zweite Dimension

lerne erst einmal wie man mathematisch einen Vector in 2D dreht, sowas hier anscheinend
Vektor um einen gewissen Winkel drehen

bzw. aufgeräumter
Drehmatrix ? Wikipedia
wenn dir Drehmatrix etwas sagt

oder noch weitere Suchen nach schöner präsentierten Ergebnissen

 

[stulleman]

Erstmal danke für deine Antwort!
Ich habe meine Code jetzt verbessert, sodass er richtige Ergebnisse ausgibt, bin mir aber nicht sicher ob du das meintest

Hier ist jetzt die verbesserte Methode um um die Z-Achse zu drehen.

         /**
	 * 
	 * @param vectorList
	 * @param angle
	 * @return
	 */
	public static Vector<Vector3D> rotateVectorZ(Vector<Vector3D> vectorList, double angle) {
		Vector<Vector3D> newVectorList = new Vector<Vector3D>();
		angle = Math.toRadians(angle);
		
		for(int i = 0; i < vectorList.size(); i++) {
			Vector3D currentVec = vectorList.get(i);
			
			double newX1 = (Math.cos(angle) * currentVec.getX1()) - (Math.sin(angle) * currentVec.getX2());
			double newX2 = (Math.sin(angle) * currentVec.getX1()) + (Math.cos(angle) * currentVec.getX2());
			double newX3 = currentVec.getX3();

			newVectorList.add(new Vector3D(newX1, newX2, newX3, currentVec.getName()));
		}

		return newVectorList;
	}

Die Berechnungen klappen also, jetzt bräuchte ich doch eigentlich nur noch eine gute Idee wie ich das auf den Bildschirm bringe oder nicht?
Ich kenne mich mit Java 2D aus, also brauche ich keine Hilfe in der Richtung, sondern eher die Idee wie ich eine 3. Dimension darstellen kann? Oder ratet ihr mir eher dazu zuerst die Variante von vorne zu programmieren?

Danke nochmal!

EDIT: Diese Seite hat mir übrigens sehr geholfen, falls es jemanden interessiert :rtfm:

 

[SlaterB]

es ist mir herzlich gleich, wie du das darstellst, zu einer bestimmten Form werde ich dir also bestimmt nicht raten,

nähere Kenntnisse zu Java3D und was es noch fertiges gibt, habe ich auch nicht

ich selber würde, das könnte man wiederum als Rat bezeichnen , schon aus Interesse alles mit Java 2D selber malen,
eine Ebene ist der Bildschirm, die dritte in die Tiefe versetzt,
wie genau würde ich ausprobieren, mit anderen Bildern vergleichen, 45 Grad kann man ja als erste Näherung versuchen,
alle Punkte nach gewissen Formeln versetzen usw.

 

[stulleman]

Ja genau das war auch mein Ziel, alles mit Java2D zu machen.
An deinen Vorschlag hatte ich auch schon gedacht, dachte nur es gibt eine "Standard" Methode das zu machen.
Ich wüsste gerne wie es Java3D macht, letztendlich benutzt das ja auch nur normale 2D Linien
Vielleicht hat ja jemand anderes Ahnung von Java3D?

Gruß Max

 

[Spacerat]

3D in Java2D darstellen? Such' dir mal das WireFrame-Demo des Standard-JDKs von Sun. Dieses sollte im Demo-Verzeichnis der entsprechenden JDK-Installation nebst Quelltext zu finden sein.

 

[Marco13]

Auch wenn in Computer Graphics: Principles and Practice in C (Addison-Wesley Systems Programming Series): Amazon.de: James D. Foley, Andries VanDam, Steven K. Feiner: Englische Bücher alles steht, was du dazu wissen musst, würde ich das wohl nicht direkt empfehlen...

 

[stulleman]

Wenn man sich das jetzt mal anguckt (nicht der Sourcecode), ist es doch letztendlich nichts anderes als ein Koordinatensystem wo man die Z und X Achse sieht und wenn etwas auf der Y Achse nach hinten oder vorne verschoben ist, dann wird es dementsprechend zuerst oder zuletzt gezeichnet.
Oder habe ich einen Denkfehler?

EDIT: Oder besser gesagt, man sieht die x3 = Z und die x2 = y Achse, und wenn etwas auf der x1 = x Achse verschoben wird.

 

[Spacerat]

Wenn man sich das jetzt mal anguckt (nicht der Sourcecode), ist es doch letztendlich nichts anderes als ein Koordinatensystem wo man die Z und X Achse sieht und wenn etwas auf der Y Achse nach hinten oder vorne verschoben ist, dann wird es dementsprechend zuerst oder zuletzt gezeichnet.
Oder habe ich einen Denkfehler?

EDIT: Oder besser gesagt, man sieht die x3 = Z und die x2 = y Achse, und wenn etwas auf der x1 = x Achse verschoben wird.

Das Ganze heisst 2D-Projektion...
Ich sagte ja bereits, sieh's dir an. Bis dahin wusste ich selbst allerdings noch nicht, dass man das WireFrame-Demo nebst Quelltext auch öffentlich im Netz findet.

 

[stulleman]

Da ich deinem Kommentar entnehme das die Idee die richtige ist, werde ich versuchen alles zu schreiben ohne irgendwo ab zugucken
Ich danke euch erst einmal für die Hilfe, ich habe bestimmt später noch mal eine Frage

 

[Marco13]

Wie immer ist es nicht so einfach, wie es aussieht. Natürlich ist das, was man dort sieht (und das, was man mit minimalem Aufwand nachbauen kann) nur der spezielle Fall, dass man z=0 setzt und damit alles auf die Bildschirmebene plattgedrückt wird. Wenn man es von "vorne" (also entlang der z-Achse) betrachtet. Aber... was macht man, wenn man das ganze von links, rechts, oben oder unten sehen will? Dann ist nichts mehr mit "ich setze einfach alle z-Werte auf 0". Und NEIN, es ist auch nicht damit getan, dann alle x- oder y-Werte auf 0 zu setzen : Spätestens, wenn man das ganze aus einer beliebigen Richtung betrachten können will (also z.B. irgendwie schräg oben) muss man sich mit Projektionsmatrizen rumärgern (und eigentlich noch mit viel, viel mehr, wie z.B. clipping).
Bis dahin war das ja auch nur eine Orthographische Parallelprojektion, und speziell Wireframes sehen damit meistens sch... nicht so schön aus, weil man vorne und hinten nicht erkennt. Schöner wären die mit einer perspektivischen Verzerrung, und die kann man in eine Projektionsmatrix relativ leicht einbauen, aber die irgendwie anders "von Hand" zu machen ist nicht praktikabel.

 

[stulleman]

Okay, da es wirklich nichts bringt das ganze orthogonal zeichnen zu lassen, habe ich mir direkt die Projektionsmatrix angeguckt.
Ich habe mir einfach mal das durchgelesen und habe ehrlich gesagt fast nichts verstanden.
So wie ich es verstanden habe muss ich als erstes P ausrechnen : P = KR[I|-C] (Was bedeutet der Strich neben dem I?)
Danach rechne ich dann einfach x = PX ? Und x sind dann meine zweidimensionalen Punkte?

 

[Spacerat]

Der Strich bedeutet wohl "Vector I" (EDIT: Eindeutig ein Vector. Um genau zu sein eine 3*3 Einheitsmatrix).
Ich hab' mir den online-Quellcode nun noch mal ansehen müssen und siehe da, ein entscheidender Teil fehlt (Matrix3D Auszug):

	/**
	 * Transform nvert points from v into tv. v contains the input coordinates
	 * in floating point. Three successive entries in the array constitute a
	 * point. tv ends up holding the transformed points as integers; three
	 * successive entries per point
	 */
	void transform(float v[], int tv[], int nvert) {
		float lxx = xx, lxy = xy, lxz = xz, lxo = xo;
		float lyx = yx, lyy = yy, lyz = yz, lyo = yo;
		float lzx = zx, lzy = zy, lzz = zz, lzo = zo;
		for (int i = nvert * 3; (i -= 3) >= 0;) {
			float x = v[i];
			float y = v[i + 1];
			float z = v[i + 2];
			tv[i] = (int) (x * lxx + y * lxy + z * lxz + lxo);
			tv[i + 1] = (int) (x * lyx + y * lyy + z * lyz + lyo);
			tv[i + 2] = (int) (x * lzx + y * lzy + z * lzz + lzo);
		}
	}

Damit werden 3D-Vertices in 2D-Points der zugrunde liegenden Projektionsmatrix transformiert. Die letzte Achse des tv-Arrays (tv[i + 2]) ist für die Darstellung in der Ebene nicht wichtig. Sie wird in der Demo für die Tiefendarstellung in Graustufen verwendet.

 

[stulleman]

Ja ich wollte nur sicher gehen ob das die Bezeichnung für eine Einheitsmatrix ist
Trotzdem verstehe ich leider nicht was du mir jetzt mit dem Codeausschnitt sagen willst?
Ich bräuchte eigentlich so etwas wie eine Schritt für Schritt Anleitung wie ich von mehreren 3D Punkten zu mehreren 2D Punkten in Abhängigkeit von einer Kamera komme.
Vielleicht kennt ja einer ein gutes Tutorial?

 

[Spacerat]

Trotzdem verstehe ich leider nicht was du mir jetzt mit dem Codeausschnitt sagen willst?
Ich bräuchte eigentlich so etwas wie eine Schritt für Schritt Anleitung wie ich von mehreren 3D Punkten zu mehreren 2D Punkten in Abhängigkeit von einer Kamera komme.
Vielleicht kennt ja einer ein gutes Tutorial?

Tja... mehr Schritt für Schritt geht kaum. Mein Code ist sozusagen der Schlüssel zu deinem Anliegen.
Die Kamera ist die oben verwendete Matrix (Elemente xx, xy, xz usw), also die Projektionsmatrix. In dem übergebenen Float-Array befinden sich "nvert" 3D-Vertices (3 Floats = 1 Punkt im Raum). Diese Punkte werden in der For-Schleife in 2D-Punkte gewandelt und so auf eine Ebene projeziert.
Wie gesagt, Zeile 17 könntest du theoretisch weglassen und das Target-Array um die Anzahl der Punkte kürzen, damit 2 Elemente pro Zielpunkt übrig bleiben. Im Grossen und Ganzen reduziert sich das Gerechne nun mehr auf folgendes:

point.x = vertex.x * matrix.xx + vertex.y * matrix.xy + vertex.z * matrix.xz + matrix.xo
point.y = vertex.x * matrix.yx + vertex.y * matrix.yy + vertex.z * matrix.yz + matrix.yo

 

[Marco13]

Ja, sich das aus dem Wikipedia-Artikel herzuleiten fände ich auch schwer (bzw. sehr mühsam). Hm... vielleicht liegt das daran, dass es schwer und mühsam IST? :reflect: ? Wie auch immer, es gibt auch noch "fokussiertere" Seiten. Das von Wikipedia ist sehr allgemein, und listet auch Aspekte auf, die praktisch (und speziell für dich im konkreten Fall) kaum relevant sind. Vielleicht hilft schon eins der ersten Websuchergebnisse zu "opengl projection matrix", nämlich OpenGL Projection Matrix : Dort steht eine Herleitung (deren mathematischer Teil auch wieder mühsam nachzuvollziehen ist, aber) die recht zielgerichtet auf die übliche perspektivische OpenGL-Projektionsmatrix

hinausläuft.

 

[stulleman]

Das heißt dein Code müsste mir meine 3D Koordinaten in 2D Koordinaten umrechnen, sodass ich mein Objekt perspektivisch zeichnen kann?
Dann verstehe ich leider nicht wie die Kamera aus mehr als 3 Koordinaten bestehen kann?
Und allgemein was die

xx, xy, xz, xo,
yx, yy, yz, yo,
zx, zy, zz, zo

Variablen beinhalten sollten? Die werden im Code ja nicht initialisiert.
Ich sehe in dem Code oben irgendwie die Koordinaten der Kamera nicht. (Auch so was wie focal length nicht...)

Ich hoffe du kannst mir nochmal helfen

 

[Spacerat]

Diese "komischen" Werte stellen eine vereinfachte 3D-Matrix dar (der Teil, der bei dem Online-Wireframe-Demo fehlt). Das vordere 3*3-Feld (xx bis zz) ist der Rotations- und Scale-Anteil, also Lage und Grösse des Objektes und die hinteren 3 Werte (xo, yo und zo) ist der Objekt-Kamera-Vektor, also die Position des Objektes relativ zur Kamera. Ganz nebenbei bemerkt, fehlt bei dieser Matrix noch eine Zeile, diese ist aber für die Darstellung von 3D-Objekten scheinbar nicht wichtig, ich selbst bin beim Thema Matritzen jedenfalls noch nie auf die Bedeutung dieser Werte (ox = 0, oy = 0, oz = 0 und oo = 1) gestossen. Vllt. kann einer der zahlreichen Studenten in diesem Forum mehr darüber sagen.
Evtl. ist es hilfreich, wenn du dir das Wireframe-Demo mal in Eclipse oder ähnliches lädst und dir dessen Ausführung mal Schritt für Schritt (Haltepunkte und Debug) ansiehst.

 

[Marco13]

Ganz nebenbei bemerkt, fehlt bei dieser Matrix noch eine Zeile, diese ist aber für die Darstellung von 3D-Objekten scheinbar nicht wichtig, ich selbst bin beim Thema Matritzen jedenfalls noch nie auf die Bedeutung dieser Werte (ox = 0, oy = 0, oz = 0 und oo = 1) gestossen. Vllt. kann einer der zahlreichen Studenten in diesem Forum mehr darüber sagen.

Die Studenten-Begründung steht irgendwo in Homogene Koordinaten ? Wikipedia ... ansonsten würde ich noch grob nach Fundiertheit sortiert sagen, dass quadratische Matrizen was feines sind, 4 für Computer eine tolle Zahl ist, die Vektoren auch 4 Zeilen haben und ja auch wieder ein 4-zeiliger Vektor rauskommen soll, und man spätestens bei der oben geposteten Projektionsmatrix die 4. Zeile braucht, weil sie eben nicht (0,0,0,1) sondern (0,0,-1,0) ist...

Evtl. ist es hilfreich, wenn du dir das Wireframe-Demo mal in Eclipse oder ähnliches lädst und dir dessen Ausführung mal Schritt für Schritt (Haltepunkte und Debug) ansiehst.

Das würde ich nur bedingt empfehlen.... Das ist eine weitgehend unkommentierte, schwer nachvollziehbare, sehr spezifische mini-Demo, mit einigen etwas "unkonventionellen" Teilen (bzw. Teilen, die einem das Verständnis am Anfang vielleicht erschweren) ...
(Bin kürzlich (heute ) über Tutorial 3 : Matrices | opengl-tutorial.org gestolpert, das sieht ganz vernünftig aus, aber es gibt sicher noch andere, bessere...)

 

[stulleman]

Danke Marco13, das hat mir schon ein bisschen weiter geholfen, nur wird in diesem Tutorial gerade nicht die Mathematik dahinter besprochen, sondern es wird alles von OpenGl berechnet.

Ich weiß nicht ob ich zu blind oder zu dumm bin, aber irgendwie muss es doch eine "Vorlage" für eine Projektionsmatrix geben oder? Zum Beispiel habe ich so was gefunden, kann damit aber dennoch nicht viel anfangen.

E  0  A  0
    0  F  B  0
    0  0  C  D
    0  0  -1 0
    
    A = (right+left)/(right-left)
    B = (top+bottom)/(top-bottom)
    C = -(far+near)/(far-near)
    D = -2*far*near/(far-near)
    E = 2*near/(right-left)
    F = 2*near/(top-bottom)

Was ich bis jetzt verstanden habe ist:

1. Man hat einen Punkt im Raum A(5,5,5)
2. Man macht eine homogene Koordinate daraus? A(5,5,5,1)
3. Man erstellt eine Projektionsmatrix. (Ich weiß nicht wie)
4. Man erstellt eine Kameramatrix. (Weiß wieder nicht wie, da alles immer in Funktionen erstellt wird)
5. Man erstellt eine Modellmatrix. (Das selbe)
6. Man multipliziert die Matrizen.
7. Man multipliziert A mit dem Ergebnis aus 6 und das Ergebnis ist der 2D Punkt.

Ist das erst mal richtig? Das ist echt frustrierend...

 

[Marco13]

Joa, das sieht so weit richtig aus. Die gepostete Matrix entspricht soweit ich das sehe genau der, die ich als Bild eingefügt hatte. Was meinst du damit "wie" man die erstellt? Ein float[16] oder meinetwegen float[4][4] (oder ein Interface) und dort fügt man diese Werte ein. Die Kamera- und Modelview-Matrix sind dann die Matrizen, die nicht mehr mit der Perspektivischen Verzerrung, sondern nur noch mit der Orientierung und Position im Raum (von Kamera und Modell) zu tun haben.
Zugegeben: Ich habe das auch noch nicht auf dieser Ebene ausprogrammiert. Früher natürlich auch mal einen Drahtgitterwürfel, aber auch nur mit z=0 plattgedrückt, und dann eher auf solche Dinge wie den Bresenham und Polygonfüllen geschaut, bevor ich gemerkt habe, dass OpenGL eher was für mich ist - aber auch da ist zumindest noch wichtig, zu wissen, was diese Matrizen bewirken und wie man sie verwendet.
BTW: Der 2D-Punkt muss dann ggf. noch von Viewplane in Bildschirmkoordinaten umgerechnet werden, aber das ist nur eine Skalierung