Graphics2D nützlich für R³?

[Felix]

Hallo zusammen,

ich hab zwar schon mal im Abschnitt Grafikprogrammierung gepostet, aber der Eintrag hat nicht wirklich Früchte getragen (und ich weiß auch nicht wie man ihn wieder löschen kann). Zudem kann ich jetzt mein Problem näher beschreiben.
Ich möchte einen dreidimensionalen Raum darstellen. In diesen will ich dann ein Objekt einfügen, das man verschieben und rotieren kann. Alle Methoden dazu schreib ich selbst (das ist ja die Aufgabe meiner Facharbeit). Das heißt der Raum muss nur Ebenen (bzw. Flächen) und Vektoren darstellen können. So was wie Java 3D ist für mich glaub ich nutzlos, weil a) die Methoden die ich umsetzten will bereits implementiert sind und b) die Einarbeitung angeblich ziemlich schwierig sein soll.
Leider kann ich das Panel (sowas in die Richtung strebt mir vor) auch nicht selbst schreiben, da die Objekte "nach hinten", also je nach x1 Wert, kleiner (bzw. Größer) werden sollen, und ich nicht weiß, wie man so was umsetzt.
Nachdem es allerdings viele Anwendungen gibt, bei denen man Vektoren im R³ darstellen muss, habe ich mir gedacht, dass es vielleicht schon eine vorgefertigte Komponente gibt, die so etwas kann.
Kann mir jemand weiterhelfen?

Gruß
der Felix

 

[Landei]

Man kann Java2D dafür nehmen (und Sun hat mal selbst ein Applet-Beispiel für sowas gebastelt). Aber sobald es etwas anspruchsvoller wird, kommst du um "echtes" 3D nicht herum, also Java3D oder JMonkeyEngine oder so. Ein "Zwischending" wäre die direkte Verwendung von Open-GL, das zwar "3D", aber wirklich ziemlich Low-Level ist. Java-Wrapper für Open-GL sind JOGL und LWJGL.

 

[kowa]

Mit Vektorrechung geht das auch so, ohne Java3D und was so dazugehört. Wenn du dreidimensionale Vektoren hast, musst du die dritte Koordinate "wegrechnen", da man mit Java2D eben nur mit 2 koordinaten zurechtkommen muss. Das kannst du zb mit dieser Rechnung durchführen (gilt für x- und y-Wert):

public static double dim (double wert, double z)
	{
//		BetrachterZ ist der Abstand des Betrachters zum Monitor in Pixeln. Z.B. Bildschirmbreite
		double neuerWert = (wert * betrachterZ) / (z + betrachterZ); //z ist die dritte Koordinate eines Punktes
		return neuerWert;
	}

Hier ist noch eine Seite, in der 3D Animationen mit sehr wenig Code umgesetzt wurde. Da wird auch kein Java3D benutzt. Hab selbst mal so einen Würfel gemacht, die Drehung kann mathematisch etwas komplizierter werden aber für eine Facharbeit macht man sich die Mühe. Geht mit Matrizen gut. 3D-Raum selbst ist nicht schwer.

 

[Felix]

Danke kowa für das geniale Beispiel!

Ich hab jetzt versucht mir selbst ein Koordinatensystem zu erstellen. Leider kapier ich das mit dem Zeichnen der Linien nicht ganz, sie erscheinen nämlich nur manchmal, und meine zu Debugzwecken eingefügte Zeilenausgabe, wird auch nicht ausgegeben... 🙁
Hier ist mal der Code:

import java.awt.*;
import java.util.*;
import javax.swing.*;

public class Koordinatensystem extends JPanel {

	ArrayList Vektors = new ArrayList();

	int nullx, nully;

	public Koordinatensystem() {
		
	}

	@Override 
	public void paint(Graphics g) {
		Dimension size = this.getSize();
		nullx = new Double(size.getWidth() / 2).intValue();
		nully = new Double(size.getHeight() / 2).intValue();
		
		// DEBUG
		System.out.println("paintComponent wird ausgeführt");
		
		/*
		 * Koordinatensystem schreiben
		 */
		paintVektor(g, 0, 0, 0, 100, 0, 0);
		paintVektor(g, 0, 0, 0, 0, 100, 0);
		paintVektor(g, 0, 0, 0, 0, 0, 100);
	}

	private void paintVektor(Graphics g, int x1, int x2, int x3, int y1,
			int y2, int y3) {
		g.drawLine(new Double(nullx + x1 + (x3 * Math.sqrt(0.5)))
				.intValue(), new Double(nully - x2 + (x3 * Math.sqrt(0.5))).intValue(), new Double(nullx
				+ y1 + (y3 * Math.sqrt(0.5))).intValue(),
				new Double(nully - y2 + (y3 * Math.sqrt(0.5)))
						.intValue());
	}
}

Ich zeichne jetzt grade zum ersten mal in ein JPanel, vermutlich ist der Fehler ziemlich einfach zu beheben...

Gruß
der Felix

 

[Ark]

nullx = new Double(size.getWidth() / 2).intValue();
nully = new Double(size.getHeight() / 2).intValue();

Wahrscheinlich wird auch Windows so programmiert, sonst wäre es nicht so langsam. 😀

Irgendwie scheint es immer mehr in Mode zu kommen, den kompliziertesten Weg zu suchen, um ein Problem zu lösen. Erst neulich erklärte jemand, man könnte das Suffix eines Wortes erhalten, indem man zunächst das Wort spiegelt, dann das gleich lange Präfix nimmt und dieses dann wieder spiegelt. *aus Nähkästchen plauder*

Nichts gegen dich, 😉 aber ich glaube, Wirth hat doch recht: "Software wird schneller langsamer als Hardware schneller wird."

Na ja, das Ganze geht wesentlich einfacher:

import java.awt.*;
import java.util.*;
import javax.swing.*;

public class Koordinatensystem extends JPanel {

	private static final double SQRT05 = Math.sqrt(0.5);
	ArrayList Vektors = new ArrayList();

	int nullx, nully;

	public Koordinatensystem() {
		
	}

	@Override 
	public void paintComponent(Graphics g) { // das ist bei Swing eher erwünscht!
		Dimension size = this.getSize();
		nullx = size.width / 2;
		nully = size.height / 2;
		
		// DEBUG
		System.out.println("paintComponent wird ausgeführt");
		
		/*
		 * Koordinatensystem schreiben
		 */
		paintVektor(g, 0, 0, 0, 100, 0, 0);
		paintVektor(g, 0, 0, 0, 0, 100, 0);
		paintVektor(g, 0, 0, 0, 0, 0, 100);
	}

	private void paintVektor(Graphics g, int x1, int x2, int x3, int y1,
			int y2, int y3) {
		g.drawLine(
			nullx + x1 + (int) (x3 * SQRT05),
			nully - x2 + (int) (x3 * SQRT05),
			nullx + y1 + (int) (y3 * SQRT05),
			nully - y2 + (int) (y3 * SQRT05)
		);
	}
}

(Ich hoffe, meine Art der Parameterlistenformatierung ist legitim.)

Die Strukturierung ist wahrscheinlich sowieso etwas verbesserungswürdig. So würde ich z.B. die Methode paintVektor() in der Vektorklasse unterbringen, weil ein Koordinatensystem nicht unbedingt zu wissen hat, wie man einen Vektor visualisiert. Außerdem sollten Membervariablen so private wie möglich sein, Collections sollten typisiert werden usw.

Passiert denn sonst noch etwas, außer dass ungefähr nichts passiert? Möglicherweise stimmt etwas mit deiner Art der Einbettung des Koordinatensystems in einen Container nicht.

Ark

 

[Felix]

danke Ark 😀

Ich setzte das JPanel eigentlich nur in ein JFrame:

public class MainFrame extends JFrame{

	Koordinatensystem koordinatensystem = new Koordinatensystem();
	
	/*
	 * Startpunkt
	 */
	public static void main(String[] args){
		new gui.MainFrame();
	}
	
	/*
	 * Konstruktor
	 */
	public MainFrame(){
		/*
		 * JFrame einrichten
		 */
		this.setTitle("3D Raum");
	    this.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 
		
		this.setSize(500,400);
		this.add(koordinatensystem);
		this.setVisible(true);
	}
}

Zu der paintVektor-Methode: Ich wollte eigentlich auch noch so etwas wie Größenwirkung einbauen (was man am Koordinatensystem einstellen soll), deshalb hab ich die Methode zum Zeichnen (ich muss dann ja die x und y Längen mit einem Faktor versehen, oder halt eben nicht) in das Koordinatensystem gelegt. Aber ich bin mir eh noch nicht ganz im Klaren, wie ich das machen soll, denn wenn ich mein Objekt verschiebe, ändern sich ja alle Vektoren, dh ich müsste alle Vektoren aus der ArrayList löschen und diese dann neu füllen, bevor ich repaint() aufrufe. Das scheint mir aber ein bisschen umständlich zu sein....

Gruß
der Felix

 

[Ark]

this.add(koordinatensystem);

Welche Java-Version verwendest du? Wenn sie <1.5 ist, geraten wir an dieser Stelle wohl sehr schnell in Schwulitäten.

Aber ich bin mir eh noch nicht ganz im Klaren, wie ich das machen soll, denn wenn ich mein Objekt verschiebe, ändern sich ja alle Vektoren, dh ich müsste alle Vektoren aus der ArrayList löschen und diese dann neu füllen, bevor ich repaint() aufrufe. Das scheint mir aber ein bisschen umständlich zu sein....

... und ich denke, das wird sogar zu umständlich sein.

Zeige doch mal die Vektorklasse, wenn sie nicht allzu geheim sein sollte. 😉

Ark

 

[Felix]

Ich benutze Java 1.6. Ich hab mich in "Java ist auch eine Insel" über das Thema Zeichnen eingelesen und dort wird das JFrame ganz ähnlich erstellt.

Die Vektorklasse ist weder geheim, noch (bis jetzt) besonders spannend 🙂 bis jetzt wird sie auch noch nicht verwendet...

public class Vektor {

	double x1, x2, x3;
	
	public Vektor(double x1, double x2, double x3){
		this.x1 = x1;
		this.x2 = x2;
		this.x3 = x3;
	}
	
	public double getX1(){
		return x1;
	}
	
	public double getX2(){
		return x2;
	}
	
	public double getX3(){
		return x3;
	}
}

EDIT: Ich verstehs nicht, wenn ich was ändere und das Programm aus Eclipse raus starte, ohne das File vorher abzuspeichern, werden die Linien angezeigt, wenn ich das JFrame dann aus meiner Arbeitsfläche raus schiebe und wieder zurück sind die Linien weg. Wenn alle Files des Projekts gespeichert sind, und ich starte das Programm aus Eclipse raus, werden auch keine Linien angezeigt... :?

 

[Ark]

Ich denke, es ist besser, wenn du die Komponenten in ein Array packst. Nach Möglichkeit solltest du auch Setter hinzufügen, wenn es möglich und - sehr wahrscheinlich - auch nötig ist. Dazu packst du noch Methoden zum Verschieben (Addieren), Rotieren usw.

So würde ich zumindest vorgehen.

Ich verstehs nicht, wenn ich was ändere und das Programm aus Eclipse raus starte, ohne das File vorher abzuspeichern, werden die Linien angezeigt, wenn ich das JFrame dann aus meiner Arbeitsfläche raus schiebe und wieder zurück sind die Linien weg. Wenn alle Files des Projekts gespeichert sind, und ich starte das Programm aus Eclipse raus, werden auch keine Linien angezeigt... :?

Tritt wirklich kein Fehler (Exception) auf?

Ark

 

[Felix]

Nein, nicht die Spur einer Exception...

EDIT: Arrg, bis jetzt habe ich Suns Java 1.5 vewendet (wusste nicht, dass das bei Eclipse noch als Standart eingestellt war). Jetzt habe ich OpenJDK 1.6 eingestellt, und es funktioniert alles. :shock: Aber warum? Kann ich das nicht so umschreiben, dass es auch mit älteren Java Versionen funktioniert?

 

[kowa]

Kleiner Tipp, wenn du die 3D->2D Umrechnung nicht mit einer konstanten wie im Beispiel oben mit der Wurzel aus 0,5 machst, sondern mit meinem Beispiel, bekommst du realistische Verschiebungen hin. Das heisst zb dass man mehr von der rechten seite eines würfels sieht, wenn man ihn nach links verschiebt usw. Wenn du immer nur eine konstante auf die x und y werte drauf addierst, bleibt die räumliche darstellung gleich. Hab mir grad mal so einen 3D-Würfel gebastelt und es ausprobiert.

 

[Felix]

Meine Idee war ein räumliches Gitter zu schaffen, so das die Koordinaten bei größerem z auch weiter auseinander liegen. Ich hab es aber noch nicht so geschrieben, mal sehen ob es funktioniert...