Strecken-Editor

Steff87 · 5. Apr 2011

Hallo zusammen!
ich hab ein problem. Ich will eine Strecken-Editor bauen. Dieser zeichnet zwar nur Linien und Kreissegmente, aber genau das ist mein Problem. Wenn ich eine "Kurve" zeichene und dann eine Gerade hinzufüge passen diese nicht zusammen. Sie sind verschoben. Ich probier bei diesem Problem schon mind. 2 Wochen die verschiedensten möglichkeiten aus.
Vielleicht habt ihr ja einen Vorschlag.
Hier erst mal die Zeichen Klasse. Ist von JPanel abgeleitet.

Java:

package util;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JPanel;

import trackParts.StdTrackTypes;

@SuppressWarnings("serial")
public class TrackDrawPanel extends JPanel implements MouseListener{
	
	static Integer startCoordinates[] = {410,384}; //x,y
	
	static List<Integer[][]> coordinates;
	static int deg = 90;
	//private static int curDeg=0;
	static int deltaXges=0;
	static int deltaYges=0;
	
	public TrackDrawPanel(){
		coordinates = new ArrayList<Integer[][]>();
		coordinates = new ArrayList<Integer[][]>();
		if(coordinates.size()==0){
			Integer[][]xy = {{startCoordinates[0],startCoordinates[1]},{startCoordinates[0], startCoordinates[1]+(int)StdTrackTypes.getWidth()}};
			coordinates.add(xy);
		}
		this.addMouseListener(this);
	}
	
	/**
	 * Calculates the Y-Coordinate of the end points of a curve
	 * @param deg The extent angle
	 * @param radius The radius of the curve
	 * @return It returns the y-value in pixel
	 */
	static int calcDeltaY(double deg, double radius){
		double alpha = (Math.PI)/180*deg;
		double c = radius;
		double b = radius;
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));
		//System.out.println("a: "+a);
		double hc = a*Math.sin(beta);
		return (int)Math.round(hc);
	}
	
	/**
	 * Calculates the X-Coordinate of the end points of a curve
	 * @param deg The extent angle
	 * @param radius The radius of the curve
	 * @return It returns the x-value in pixel
	 */
	static int calcDeltaX(double deg, double radius){
		double alpha = (Math.PI)/180*deg;
		double c = radius;
		double b = radius;
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));
		System.out.println("beta: "+beta);
		double hc = a*Math.sin(beta);
		int x = (int)Math.round((Math.sqrt(Math.pow(a,2)-Math.pow(hc, 2))));
		return x;
	}
	
	static int angleCalc(boolean x){
		if(deg>=0 && deg<90){
			if(x){
				return -deltaXges;
			}else{
				return deltaYges;
			}
		}else if(deg>=90 && deg<180){
			if(x){
				return -deltaXges;
			}else{
				return deltaYges;
			}
		}else if(deg>=180 && deg<270){
			if(x){
				return -deltaXges;
			}else{
				return deltaYges;
			}
		}else if(deg>=270 && deg<=360){
			if(x){
				return -deltaXges;
			}else{
				return deltaYges;
			}
		}
		return 0;
	}

	/**
	 * This method draws a filled curve.
	 * @param g
	 * @param degree The extent angle. 
	 * @param radius The radius of the cure
	 */
	public static void drawCurve(Graphics g, double degree, double radius){
		if(coordinates.size()==0){
			Integer[][]xy = {{startCoordinates[0],startCoordinates[1]},{startCoordinates[0]+(int)StdTrackTypes.getWidth(), startCoordinates[1]}};
			coordinates.add(xy);
		}
		System.out.println("Vor kurve:");
		System.out.println("X: "+coordinates.get(coordinates.size()-1)[0][0]+" Y: "+coordinates.get(coordinates.size()-1)[0][1]);
		System.out.println("X1: "+coordinates.get(coordinates.size()-1)[1][0]+" Y1: "+coordinates.get(coordinates.size()-1)[1][1]);
		//curDeg=(int)degree;
		Integer[][]xy=null;
		g.fillArc(coordinates.get(coordinates.size()-1)[0][0]-(int)(radius)+angleCalc(true), coordinates.get(coordinates.size()-1)[0][1]-angleCalc(false), 2*(int)(radius), (int) (2*(radius)), deg, (int)degree);
		g.setColor(Color.RED);
		g.fillArc(coordinates.get(coordinates.size()-1)[0][0]-(int)radius+(int)StdTrackTypes.getWidth()+angleCalc(true), coordinates.get(coordinates.size()-1)[0][1]+(int)StdTrackTypes.getWidth()-angleCalc(false), 2*(int)(radius-(int)StdTrackTypes.getWidth()), 2*(int)(radius-(int)StdTrackTypes.getWidth()), deg, (int)degree);
		
		deg =(int)(deg+degree>360?(deg+degree-360):deg+degree);
		
//		int deltaX = calcDeltaX(degree, radius);
//		int deltaY = calcDeltaY(degree, radius);
//		int deltaX1 = calcDeltaX(degree, radius-StdTrackTypes.getWidth());
//		int deltaY1 = calcDeltaY(degree, radius-StdTrackTypes.getWidth());
		
		int deltaX = calcDeltaX(deg-90, radius);
		int deltaY = calcDeltaY(deg-90, radius);
		int deltaX1 = calcDeltaX(deg-90, radius-StdTrackTypes.getWidth());
		int deltaY1 = calcDeltaY(deg-90, radius-StdTrackTypes.getWidth());
		
//		if(deg>=0 && deg<=90){
//			
//		}else if(deg>90 && deg<=180){
//			
//		}else if(deg>180 && deg<=270){
//			
//		}else if(deg>270 && deg<=360){
//			
//		}
		
		
		
	
		if(deg>=0 && deg<=90){
			if(deg>45){
				deltaXges -= deltaX;
				deltaYges -= deltaY;
			}else{
				deltaXges -= deltaY;
				deltaYges -= deltaX;
			}
			xy = new Integer[][]{{coordinates.get(coordinates.size()-1)[0][0]-(deg>45?deltaX:deltaY),coordinates.get(coordinates.size()-1)[0][1]-(deg>45?deltaY:deltaX)},{coordinates.get(coordinates.size()-1)[1][0]-(deg>45?deltaX1:deltaY1),coordinates.get(coordinates.size()-1)[1][1]-(deg>45?deltaY1:deltaX1)}};
		}else if(deg>90 && deg<=180){
			if(deg<135){
				deltaXges -= deltaY;
				deltaYges += deltaX;
			}else{
				deltaXges -= deltaX;
				deltaYges += deltaY;
			}
			xy = new Integer[][]{{coordinates.get(coordinates.size()-1)[0][0]-(deg<135?deltaY:deltaX),coordinates.get(coordinates.size()-1)[0][1]+(deg<135?deltaX:deltaY)},{coordinates.get(coordinates.size()-1)[1][0]-(deg<135?deltaY1:deltaX1),coordinates.get(coordinates.size()-1)[1][1]+(deg<135?deltaX1:deltaY1)}};
		}else if(deg>180 && deg<=270){
			if(deg>225){
				deltaXges += deltaX;
				deltaYges += deltaY;
			}else{
				deltaXges += deltaY;
				deltaYges += deltaX;
			}
			xy = new Integer[][]{{coordinates.get(coordinates.size()-1)[0][0]+(deg>225?deltaX:deltaY),coordinates.get(coordinates.size()-1)[0][1]+(deg>225?deltaY:deltaX)},{coordinates.get(coordinates.size()-1)[1][0]+(deg>225?deltaX1:deltaY1),coordinates.get(coordinates.size()-1)[1][1]+(deg>225?deltaY1:deltaX1)}};
		}else if(deg>=270 && deg<=360){
			if(deg<315){
				deltaXges += deltaX;
				deltaYges -= deltaY;
			}else{
				deltaXges += deltaY;
				deltaYges -= deltaX;
			}
			
			xy = new Integer[][]{{coordinates.get(coordinates.size()-1)[0][0]+(deg<315?deltaX:deltaY),coordinates.get(coordinates.size()-1)[0][1]-(deg<315?deltaY:deltaX)},{coordinates.get(coordinates.size()-1)[1][0]+(deg<315?deltaX1:deltaY1),coordinates.get(coordinates.size()-1)[1][1]-(deg<315?deltaY1:deltaX1)}};
		}
		coordinates.add(xy);
		System.out.println("nach kurve");
		System.out.println("DX: "+deltaX+" DY: "+deltaY+" DX1: "+deltaX1+" DY1: "+deltaY1+" Deg: "+deg);
		System.out.println("X: "+coordinates.get(coordinates.size()-1)[0][0]+" Y: "+coordinates.get(coordinates.size()-1)[0][1]);
		System.out.println("X1: "+coordinates.get(coordinates.size()-1)[1][0]+" Y1: "+coordinates.get(coordinates.size()-1)[1][1]);
	}

	/**
	 * This method draws a straight.
	 * @param g
	 * @param length The length of a straight
	 */
	public static void drawStraight(Graphics g, int length){
		g.setColor(Color.GREEN);
		if(coordinates.size()==0){
			Integer[][]xy = {{startCoordinates[0],startCoordinates[1]},{startCoordinates[0]+(int)StdTrackTypes.getWidth(), startCoordinates[1]}};
			coordinates.add(xy);
		}
		System.out.println("X: "+coordinates.get(coordinates.size()-1)[0][0]+" Y: "+coordinates.get(coordinates.size()-1)[0][1]);
		System.out.println("X1: "+coordinates.get(coordinates.size()-1)[1][0]+" Y1: "+coordinates.get(coordinates.size()-1)[1][1]);
		if(deg==360 || deg == 0){ // Alle horizontale und vertikale Geraden
			g.fillRect(coordinates.get(coordinates.size()-1)[0][0], coordinates.get(coordinates.size()-1)[0][1], (int)StdTrackTypes.getWidth(), -length);
			Integer[][]xy = {{coordinates.get(coordinates.size()-1)[0][0],coordinates.get(coordinates.size()-1)[0][1]-length},{coordinates.get(coordinates.size()-1)[0][0]-(int)StdTrackTypes.getWidth(),coordinates.get(coordinates.size()-1)[0][1]-length}};
			coordinates.add(xy);
		}else if(deg==270){
			g.fillRect(coordinates.get(coordinates.size()-1)[0][0], coordinates.get(coordinates.size()-1)[0][1], length, (int)StdTrackTypes.getWidth());
			Integer[][]xy = {{coordinates.get(coordinates.size()-1)[0][0]+length,coordinates.get(coordinates.size()-1)[0][1]},{coordinates.get(coordinates.size()-1)[0][0]+length,coordinates.get(coordinates.size()-1)[0][1]-((int)StdTrackTypes.getWidth())}};
			coordinates.add(xy);
		}else if(deg == 180){
			g.fillRect(coordinates.get(coordinates.size()-1)[0][0], coordinates.get(coordinates.size()-1)[0][1], (int)StdTrackTypes.getWidth(), length);
			Integer[][]xy = {{coordinates.get(coordinates.size()-1)[0][0],coordinates.get(coordinates.size()-1)[0][1]+length},{coordinates.get(coordinates.size()-1)[0][0]+(int)StdTrackTypes.getWidth(),coordinates.get(coordinates.size()-1)[0][1]+length}};
			coordinates.add(xy);
		}else if(deg == 90){
			g.fillRect(coordinates.get(coordinates.size()-1)[0][0], coordinates.get(coordinates.size()-1)[0][1], -length, (int)StdTrackTypes.getWidth());
			Integer[][]xy = {{coordinates.get(coordinates.size()-1)[0][0]-length,coordinates.get(coordinates.size()-1)[0][1]},{coordinates.get(coordinates.size()-1)[0][0]-length,coordinates.get(coordinates.size()-1)[0][1]+(int)StdTrackTypes.getWidth()}};
			coordinates.add(xy);
		}else{ // Alle anderen Winkel
			int x = (int)(length * Math.cos(Math.PI/180*(deg-90)));
			int y = (int)(length * Math.sin(Math.PI/180*(deg-90)));
			int xpoints[] = null;
			int ypoints[] = null;
			
			// Aufbauschema
			// x1y1-----x4y4
			//  |         |
			// x2y2-----x3y3
			
			if(deg>0 && deg < 90){ //OK
				xpoints = new int[]{coordinates.get(coordinates.size()-1)[0][0],coordinates.get(coordinates.size()-1)[1][0],coordinates.get(coordinates.size()-1)[1][0]-(x<0?-x:x),coordinates.get(coordinates.size()-1)[0][0]-(x<0?-x:x)};
				ypoints = new int []{coordinates.get(coordinates.size()-1)[0][1],coordinates.get(coordinates.size()-1)[1][1],coordinates.get(coordinates.size()-1)[1][1]-(y<0?-y:y),coordinates.get(coordinates.size()-1)[0][1]-(y<0?-y:y)};
			}else if(deg>90 && deg < 180){  //OK
				xpoints = new int[]{coordinates.get(coordinates.size()-1)[0][0],coordinates.get(coordinates.size()-1)[1][0],coordinates.get(coordinates.size()-1)[1][0]-(x<0?-x:x),coordinates.get(coordinates.size()-1)[0][0]-(x<0?-x:x)};
				ypoints = new int []{coordinates.get(coordinates.size()-1)[0][1],coordinates.get(coordinates.size()-1)[1][1],coordinates.get(coordinates.size()-1)[1][1]+(y<0?-y:y),coordinates.get(coordinates.size()-1)[0][1]+(y<0?-y:y)};
			}else if(deg>180 && deg < 270){ //OK
				xpoints = new int[]{coordinates.get(coordinates.size()-1)[0][0],coordinates.get(coordinates.size()-1)[1][0],coordinates.get(coordinates.size()-1)[1][0]+(x<0?-x:x),coordinates.get(coordinates.size()-1)[0][0]+(x<0?-x:x)};
				ypoints = new int []{coordinates.get(coordinates.size()-1)[0][1],coordinates.get(coordinates.size()-1)[1][1],coordinates.get(coordinates.size()-1)[1][1]+(y<0?-y:y),coordinates.get(coordinates.size()-1)[0][1]+(y<0?-y:y)};
			}else if(deg>270 && deg < 360){//OK
				xpoints = new int[]{coordinates.get(coordinates.size()-1)[0][0],coordinates.get(coordinates.size()-1)[1][0],coordinates.get(coordinates.size()-1)[1][0]+(x<0?-x:x),coordinates.get(coordinates.size()-1)[0][0]+(x<0?-x:x)};
				ypoints = new int []{coordinates.get(coordinates.size()-1)[0][1],coordinates.get(coordinates.size()-1)[1][1],coordinates.get(coordinates.size()-1)[1][1]-(y<0?-y:y),coordinates.get(coordinates.size()-1)[0][1]-(y<0?-y:y)};
			}
			
			g.fillPolygon(xpoints, ypoints, 4);
			
			Integer[][]xy = {{xpoints[3],ypoints[3]},{xpoints[2],ypoints[2]}};
			coordinates.add(xy);
		}
			
	}

	
//	protected void paintComponent(Graphics g){
//		super.paintComponent(g);
//		Graphics2D g2d = (Graphics2D)g;
//		//drawCurve(g2d, 30, 20);
//	}
	
	public static void setToZero() {
		deg=90;
		deltaXges=0;
		deltaYges=0;
	}

	
	@Override
	public void mouseClicked(MouseEvent e) {
		System.out.println("XPos: "+e.getX()+" YPos: "+e.getY());
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
}

Und die StdTrackTypes:

Java:

public class StdTrackTypes {
	private static float width = 19.8f; //cm
	
	public static float getWidth(){
		return width;
	}
}

Vielen Dank schon mal für eure Hilfe

SlaterB · 5. Apr 2011

und du meinst, aus 200 Zeilen deltaX-Berechnung kann man irgendetwas erkennen?

aus welchem Grund hast du die Klasse StdTrackTypes gepostet?
einerseits sinnvoll da sie in der anderen Klasse benötigt wird, so ist der Code kompilierbar,
aber er enthält ja quasi nur statische Methoden die nirgendwo aufgerufen werden, man kann das ganze sowieso nicht ausführen,
ein komplettes Testprogramm wäre besser

komisch zu sehen ist allerdings auch genau in dieser Klasse dass dort ein 19.8f-Wert abgelegt ist und dieser an vielen Stellen
auf int gecastet, auf 19 abgerundet wird,
kann dass nicht zu zufällig schon der Grund für Abweichungen sein?

AmunRa · 5. Apr 2011

könntest du auch eine kurze main Methode schreiben in der dein JPanel angewendet wird und wir daher sehen können was genau dein Fehler ist

Steff87 · 5. Apr 2011

@SlaterB:
Ich hab mir gedacht, das ich mal alles notwendige poste. Und nein, durch das weglassen der casts bzw. durchs casten wird das ergebnis auch nicht besser oder schlechter.

Hier ist eine kleine Test klasse:

Java:

package ui;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;

import util.TrackDrawPanel;

@SuppressWarnings("serial")
public class Test extends JFrame implements ActionListener{
	TrackDrawPanel track;
	
	Test(){
		
		setSize(1024,600);
		track = new TrackDrawPanel();
		JScrollPane scrollTrack = new JScrollPane(track, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		JPanel trackParts = new JPanel();
		JSplitPane splitPanel= new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, scrollTrack, trackParts);
		splitPanel.setDividerSize(0);
		splitPanel.setDividerLocation(getSize().width*4/5);
		//System.out.println("width :"+track.getSize().width +" loc: "+splitPanel.getDividerLocation());
		
		trackParts.setSize(300, 600);
		trackParts.setPreferredSize(new Dimension(300, 600));
		
		JButton stdStraight = new JButton("Standardgerade");
		JButton curve1_30Deg = new JButton("Kurve 1/30°");
		stdStraight.addActionListener(this);
		curve1_30Deg.addActionListener(this);
		trackParts.add(stdStraight);
		trackParts.add(curve1_30Deg);
		
		add(splitPanel);
		setVisible(true);
	}
	@Override
	public void actionPerformed(ActionEvent evt) {
		String cmd = evt.getActionCommand();
		if(cmd.equalsIgnoreCase("Standardgerade")){
			TrackDrawPanel.drawStraight(track.getGraphics(), 34);
		}else if(cmd.equalsIgnoreCase("Kurve 1/30°")){
			TrackDrawPanel.drawCurve(track.getGraphics(), 30,40);
		}
		
	}
	
	public static void main(String[] args) {
		new Test();
	}

}

Steff87 · 5. Apr 2011

Wenn jemand ein einfacheren Weg weiß bin ich auch nicht abgeneigt.

SlaterB · 5. Apr 2011

jetzt kann man es gut ausprobieren, schön,
bisschen frech ansonsten immer noch, einfach nur den riesigen Code zu posten, nichtmal zu kommentieren wie man es zu bedienen hat, was genau welche Methode macht, welche Rechenansätze du benutzt usw.,

naja gut, kann man auch halbwegs erkennen, und für mich persönlich immer ein spannendes Thema zur Suche,
allerdings ganz schön aufwendig und dann lernst du ja gar nichts?

ich habe als erstes folgenden Code eingefügt am Ende der drawCurve-Methode:

Java:

        g.setColor(Color.GREEN);
        for (Integer[][] p : coordinates)
        {
            g.drawLine(p[0][0], p[0][1], p[1][0], p[1][1]);
            g.fillArc(p[0][0], p[0][1], 5, 5, 0, 360);
            g.fillArc(p[1][0], p[1][1], 5, 5, 0, 360);
        }

wenn man nur 3x Kurve malt dann sind die ersten berechneten Punkte noch halbwegs in Ordnung,
wobei der zweite schon doppelt so weit vorausspring, der dritte weit dann aber weit nach links ab, siehe Anhang, ist das gewollt?

wenn nicht, einfach genau diese Rechnung nachprüfen, du hast doch die Zahlen auf Papier und musst ja ein Konzept haben was dann rauskommen soll, kannst du die Rechnung nicht nachprüfen?
einige Ausgaben hast du ja schon, in der Richtung weiter,

mit viel Zeit könnte ich das auch, müsste aber erst verstehen was dein Vorgehen ist, gehts nicht selber?

-----

andere Anmerkungen:
- die Methode angleCalc() ist merkwürdig, du unterscheidest die 360 Grad des Winkels in 4 Bereiche, in allen vieren machst du aber dasselbe, Fehler?
wobei du im Code des ersten Postings in Zeile 144 bis 179 eine ähnliche Unterscheidung dann mit anderen Grenzen und anderem Ausgang hast

- ganz allgemein wäre es extrem hilfreich, nicht auf ewig deinen Code immer mehr zu verwurschteln, sondern Struktur reinzubringen!,
ich weiß noch nicht genau, wieso jeder Eintrag in der wichtigen coordinates-Liste aus 2 Punkten besteht, aber das mit einem Integer[][] abzubilden ist ja ein Graus,
erstelle dir eine Klasse mit 4 Attributen x1, y1, x2, y2 oder 2 Punkt-Objekten,

geschätzt tausendmal taucht in deinem Code coordinates.get(coordinates.size() - 1) auf, lege doch eine Variable
Integer[][] last = coordinates.get(coordinates.size() - 1); an (oder besser Typ der neuen Klasse)

anderes könnte man auch noch vereinfachen, aber das stört wohl langsam eher,
bei deinem Berechnungsproblem hilft das auch nicht,

wenn du schon versucht hast selber zu rechnen, und sich sonst keiner findet, dann schaue ich bald intensiver nach,
aber bisschen warten musst du dann noch

Steff87 · 5. Apr 2011

Deine Anmerkungen zum Thema Strukturieren sind schon hilfreich. Ich hab mir auch schon gedacht, dass es sinvoll ist, etwas aufzuräumen, aber mein vorrangiges Ziel war, das ganze zum laufen zu bringen. Strukturiern kann ich ja später noch.
Wegen den fehlenden Komentaren:
Hab in der zwischen zeit welche hinzugefügt.

Steff87 · 5. Apr 2011

Hi!
Ich glaub ich hab meinen Fehler gefunden. Die Berechnung für deltaX und Y waren falsch. Ist zwar immer noch nicht perfekt, sieht aber besser aus.
Hier der verbesserte Code:

Java:

static int calcDeltaX(double deg, double radius){
		double alpha = (Math.PI)/180*deg; // Umwandlung in Radialwert
		double c = radius;				  // Dreiecksseiten
		double b = radius;				  //	
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));						//Berechnung von fehlender Seite
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));		//Berechnung von fehlendem Winkel
		double tmpAlpha = Math.PI-(Math.PI)/180*90-(Math.PI/180*(TrackDrawPanel.deg-90));				//Berechnung von fehlendem Winkel im zweiten Dreieck
		tmpAlpha = Math.PI-tmpAlpha-beta;																//
		int x = (int) Math.round(a*Math.cos(tmpAlpha));													//Entgültige Berechnung von deltaX
		System.out.println("a: "+a+" beta: "+beta+" tmpAlpa: "+tmpAlpha+" x: "+x);
		return x;
}

und

Java:

static int calcDeltaY(double deg, double radius){
		double alpha = (Math.PI)/180*deg; // Umwandlung in Radialwert
		double c = radius;				  // Dreiecksseiten
		double b = radius;				  //	
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));						//Berechnung von fehlender Seite
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));		//Berechnung von fehlendem Winkel
		double tmpAlpha = Math.PI-(Math.PI)/180*90-(Math.PI/180*(TrackDrawPanel.deg-90));				//Berechnung von fehlendem Winkel im zweiten Dreieck
		tmpAlpha = Math.PI-tmpAlpha-beta;																//
		int x = (int) Math.round(a*Math.sin(tmpAlpha));													//Entgültige Berechnung von deltaY
		System.out.println("a: "+a+" beta: "+beta+" tmpAlpa: "+tmpAlpha+" x: "+x);
		return x;

Zusätzlich hab ich noch ein paar anpassungen an der drawCurve gemacht, die ich hier nicht poste

SlaterB · 5. Apr 2011

ist das Thema beendet? ansonsten wäre 'Code nicht posten' kontraproduktiv,

in jede Zeile ein Kommentar a la '// Umwandlung in Radialwert' nützt übrigens niemanden, wenn du das speziell meinetwegen neu eingefügt hast

eher allgemein lange Sätze
'die aktuelle Situation stellt sich wegen soundso aus den beiden Punkten a und b dar,
eine Kurve ist immer 30 Grad, deswegen wird im Dreieck a, b, c der sin gerechnet, daraus ergibt sich neues d=x,y,
bedenken muss man einen Gradbereich von sowieso, dann ist irgendwas negativ deshalb neuen Wert sowieso negieren'

ok, mag sein dass das nicht leicht ist und dasselbe wie der Code rauskommt

Steff87 · 6. Apr 2011

Leider ist das Thema noch nicht beendet. Jetzt hab ich noch weitere Kurven hinzugefügt. Wenn ich die gleiche Kurve in einer Strecke verwende funktioniert es gut, aber wenn ich die anderen dazu nehme werden diese versetzt. Außerdem brauch ich noch die paintComponent() Methode, die mir beim verschieben die Strecke neu zeichnet.
Hier erstmal den gut arbeitenden Code + Test-klasse
TrackDrawPanel:

Java:

package util;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JPanel;

import trackParts.StdTrackTypes;
import trackParts.TrackParts;

@SuppressWarnings("serial")
public class TrackDrawPanel extends JPanel implements MouseListener{
	
	
	//static TrackParts parts;
	
	static Integer startCoordinates[] = {410,384}; //x,y
	
	static List<Point[]> coordinatePoints;
	static List<Integer> partList;
	static int deg = 90;
	static int deltaXges=0;
	static int deltaYges=0;
	
	static int trackSize = Math.round(StdTrackTypes.getWidth());
	
	public TrackDrawPanel(String filePath){
		this();
		// TODO: Konstruktor mit Dateiaufruf schreiben
		System.out.println(filePath);
		FileInputStream leseStrom = null;
		 byte zeichen = 0;
		try {
			leseStrom = new FileInputStream(filePath);
		} catch (FileNotFoundException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	    
		do{
	       try {
			zeichen = (byte)leseStrom.read();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	       System.out.print(zeichen+" ");
	       char text = (char)zeichen;
	     } while (zeichen !=-1);
	     try {
			leseStrom.close();
		} catch (IOException e) {

		}
	}
	
	public TrackDrawPanel(){
		partList = new ArrayList<Integer>();
		coordinatePoints = new ArrayList<Point[]>();
		
		if(coordinatePoints.size()==0){
			Point p[] = {new Point(startCoordinates[0], startCoordinates[1]), new Point(startCoordinates[0],startCoordinates[1]+trackSize)};
			coordinatePoints.add(p);
		}
		
		this.addMouseListener(this);
	}
	
	/**
	 * Calculates the Y-Coordinate of the end points of a curve
	 * @param deg The extent angle
	 * @param radius The radius of the curve
	 * @return It returns the y-value in pixel
	 */
	static int calcDeltaY(double deg, double radius){
		
		double alpha = (Math.PI)/180*deg; // Umwandlung in Radialwert
		double c = radius;				  // Dreiecksseiten
		double b = radius;				  //	
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));						//Berechnung von fehlender Seite
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));		//Berechnung von fehlendem Winkel
		double tmpAlpha = Math.PI-(Math.PI)/180*90-(Math.PI/180*(TrackDrawPanel.deg-90));				//Berechnung von fehlendem Winkel im zweiten Dreieck
		tmpAlpha = Math.PI-tmpAlpha-beta;																//
		int x = (int) Math.round(a*Math.sin(tmpAlpha));													//Entgültige Berechnung von deltaY
//		System.out.println("a: "+a+" beta: "+beta+" tmpAlpa: "+tmpAlpha+" x: "+x);
		return x;
		
	}
	
	/**
	 * Calculates the X-Coordinate of the end points of a curve
	 * @param deg The extent angle
	 * @param radius The radius of the curve
	 * @return It returns the x-value in pixel
	 */
	static int calcDeltaX(double deg, double radius){
		
		double alpha = (Math.PI)/180*deg; // Da die Sinus und Cosinus Funktionen von der Klasse Math nur mit Radialwerten rechnet, wird hier die Gradzahl umgewandelt 
		double c = radius;				  // Zwei der drei Seiten des Dreickes haben die Länge des Übergebenen Radiuses
		double b = radius;				  // Es ist somit immer ein gleichschenkliges Dreieck.
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));						// Hier wird die fehlende Seite des Dreieckes mit dem Cosinussatz, aufgelöst nach dem Winkel, berechnet
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));		// Berechnung von fehlendem Winkel für die Berechnung des nächsten Dreieck
		double tmpAlpha = Math.PI-(Math.PI)/180*90-(Math.PI/180*(TrackDrawPanel.deg-90));				// Berechnung von fehlendem Winkel im zweiten Dreieck zur Berechnung von deltaX
		tmpAlpha = Math.PI-tmpAlpha-beta;																//
		int x = (int) Math.round(a*Math.cos(tmpAlpha));													// Hier wird entgültig das deltaX berechnet
		return x;
	}

	/**
	 * Diese Methode zeichnet eine gefüllte Kurve.
	 * @param g
	 * @param degree Der Winkel der Kurve 
	 * @param radius Der Außenradius der Kurve
	 */
	public static void drawCurve(Graphics g, double degree, double radius, TrackParts part){
		// Current Coordinates
		Point[] curPoints = coordinatePoints.get(coordinatePoints.size()-1);
		Point p[] = null;
		
		partList.add(part.ordinal());
		
		//Zeichnen der Kurve
		g.fillArc(curPoints[0].x-(int)(radius)-deltaXges, curPoints[0].y-deltaYges, 2*(int)(radius), (int) (2*(radius)), deg, (int)degree);
		g.setColor(Color.RED);
		g.fillArc(curPoints[0].x-(int)radius+trackSize-deltaXges, curPoints[0].y+trackSize-deltaYges, 2*(int)(radius-trackSize), 2*(int)(radius-trackSize), deg, (int)degree);
		
		//Berechnung von deltaX und deltaY
		int deltaX = calcDeltaX(degree, radius);
		int deltaY = calcDeltaY(degree, radius);
		int deltaX1 = calcDeltaX(degree, radius-StdTrackTypes.getWidth());
		int deltaY1 = calcDeltaY(degree, radius-StdTrackTypes.getWidth());
		
		System.out.println(curPoints[0].x-(int)(radius)-deltaXges+" detlaX: "+deltaX);
		//Aktueller Gesamtwinkel
		deg =(int)(deg+degree>360?(deg+degree-360):deg+degree);

		deltaXges -= deltaX;
		deltaYges += deltaY;
		
		p = new Point[]{new Point(curPoints[0].x-(deltaX),curPoints[0].y+(deltaY)), new Point(curPoints[1].x-(deltaX1),curPoints[1].y+(deltaY1))};
		coordinatePoints.add(p);
		
		g.setColor(Color.GREEN);
        for (Point[] q : coordinatePoints)
        {
            g.drawLine(q[0].x, q[0].y, q[1].x, q[1].y);
            g.fillArc(q[0].x, q[0].y, 5, 5, 0, 360);
            g.fillArc(q[1].x, q[1].y, 5, 5, 0, 360);
        }
	}

	/**
	 * This method draws a straight.
	 * @param g
	 * @param length The length of a straight
	 */
	public static void drawStraight(Graphics g, int length, TrackParts part){
		partList.add(part.ordinal());
		
		Point[] curPoints = coordinatePoints.get(coordinatePoints.size()-1);

		if(deg==360 || deg == 0){ // Alle horizontale und vertikale Geraden
			g.fillRect(curPoints[0].x, curPoints[0].y, -trackSize, -length);
			Point p[] = {new Point(curPoints[0].x,curPoints[0].y-length), new Point(curPoints[0].x-trackSize,curPoints[0].y-length)};
			coordinatePoints.add(p);

		}else if(deg==270){
			g.fillRect(curPoints[0].x, curPoints[0].y, length, -trackSize);
			Point p[] = {new Point(curPoints[0].x+length,curPoints[0].y), new Point(curPoints[0].x+length,curPoints[0].y-(trackSize))};
			coordinatePoints.add(p);
		}else if(deg == 180){
			g.fillRect(curPoints[0].x, curPoints[0].y, trackSize, length);
			Point p[] = {new Point(curPoints[0].x,curPoints[0].y+length), new Point(curPoints[0].x+trackSize,curPoints[0].y+length)};
			coordinatePoints.add(p);
		}else if(deg == 90){
			g.fillRect(curPoints[0].x, curPoints[0].y, -length, trackSize);
			Point p[] = {new Point(curPoints[0].x-length,curPoints[0].y), new Point(curPoints[0].x-length,curPoints[0].y+trackSize)};
			coordinatePoints.add(p);
		}else{ // Alle anderen Winkel
			int x = (int)(length * Math.cos(Math.PI/180*(deg-90)));
			int y = (int)(length * Math.sin(Math.PI/180*(deg-90)));
			int xpoints[] = null;
			int ypoints[] = null;
			
			// Aufbauschema
			// x1y1-----x4y4
			//  |         |
			// x2y2-----x3y3
			
			if(deg>0 && deg < 90){ //OK
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x-(x<0?-x:x),curPoints[0].x-(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y-(y<0?-y:y),curPoints[0].y-(y<0?-y:y)};
			}else if(deg>90 && deg < 180){  //OK
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x-(x<0?-x:x),curPoints[0].x-(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y+(y<0?-y:y),curPoints[0].y+(y<0?-y:y)};
			}else if(deg>180 && deg < 270){ //OK
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x+(x<0?-x:x),curPoints[0].x+(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y+(y<0?-y:y),curPoints[0].y+(y<0?-y:y)};
			}else if(deg>270 && deg < 360){//OK
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x+(x<0?-x:x),curPoints[0].x+(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y-(y<0?-y:y),curPoints[0].y-(y<0?-y:y)};
			}
			
			g.fillPolygon(xpoints, ypoints, 4);
			Point p[] = {new Point(xpoints[3],ypoints[3]), new Point(xpoints[2],ypoints[2])};
			coordinatePoints.add(p);
		}	
	}

	protected void paintComponent(Graphics g){
	}
	
	public static void setToZero() {
		deg=90;
		deltaXges=0;
		deltaYges=0;
	}
	
	@Override
	public void mouseClicked(MouseEvent e) {
		System.out.println("XPos: "+e.getX()+" YPos: "+e.getY());
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
	
}

enum TrackParst

Java:

public enum TrackParts {
	C1_30, C1_60, C2_30, C3_30, C4_15, STC1_30, STC2_30, STC3_30, STC4_15,
	STD_STRAIGHT, STRAIGHT_1_3, STRAIGHT_1_4, DOUBLELANECHANGE,  LANECHANGE_LEFT, LANECHANGE_RIGHT, BLACKBOX
}

Testklasse

Java:

package ui;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;

import trackParts.TrackParts;
import util.TrackDrawPanel;

@SuppressWarnings("serial")
public class Test extends JFrame implements ActionListener{
	TrackDrawPanel track;
	
	Test(){
		
		setSize(1024,600);
		track = new TrackDrawPanel();
		JScrollPane scrollTrack = new JScrollPane(track, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		JPanel trackParts = new JPanel();
		JSplitPane splitPanel= new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, scrollTrack, trackParts);
		splitPanel.setDividerSize(0);
		splitPanel.setDividerLocation(getSize().width*4/5);
		//System.out.println("width :"+track.getSize().width +" loc: "+splitPanel.getDividerLocation());
		
		trackParts.setSize(300, 600);
		trackParts.setPreferredSize(new Dimension(300, 600));
		
		JButton stdStraight = new JButton("Standardgerade");
		JButton curve1_30Deg = new JButton("Kurve 1/30°");
		JButton curve4_15Deg = new JButton("Kurve 4/15°");
		stdStraight.addActionListener(this);
		curve1_30Deg.addActionListener(this);
		curve4_15Deg.addActionListener(this);
		trackParts.add(stdStraight);
		trackParts.add(curve1_30Deg);
		trackParts.add(curve4_15Deg);
		
		add(splitPanel);
		setVisible(true);
	}
	@Override
	public void actionPerformed(ActionEvent evt) {
		String cmd = evt.getActionCommand();
		if(cmd.equalsIgnoreCase("Standardgerade")){
			TrackDrawPanel.drawStraight(track.getGraphics(), 34, TrackParts.STD_STRAIGHT);
		}else if(cmd.equalsIgnoreCase("Kurve 1/30°")){
			TrackDrawPanel.drawCurve(track.getGraphics(), 30,40, TrackParts.C1_30);
		}else if(cmd.equalsIgnoreCase("Kurve 4/15°")){
			TrackDrawPanel.drawCurve(track.getGraphics(), 15,99, TrackParts.C4_15);
		}
		
	}
	
	public static void main(String[] args) {
		new Test();
	}

}

Danke nochmals

SlaterB · 7. Apr 2011

das Thema hier ganz vergessen, schickes Programm schon bisher,

ich hab mir zu deiner neuen Frage bisher nur die Zeichnung angesehen, siehe Anhang,
beim Wechsel des Kurvenradius vergrößerst du den Radius, allerdings gehts du schnurgerade nach unten,
du musst in die Richtung gehen, die durch die beiden beiden grünen Punkte beschrieben wird, in Länge des Radius,
hilft dir das schon weiter? nur diese Info könntest du ja im Grunde ja auch selber sehen,

wie machst du das bisher bei der 30 Grad-Kurve, woher weißt du da den richtigen Mittelpunkt für den Kreis?
man merkt ich habe weiter noch nicht allzuviel Einblick in den Code

wenn du auch dort in Richtung der beiden grünen Punkte mit kleineren Radius gehst,
dann könntest du beides quasi auf dieselbe Art berechnung, nur mit unterschiedlichen Radius + Winkel,
dieselbe Methode im Code hast du ja anscheinend eh schon, alles zu verdoppeln wäre schlimm

dein Ziel muss wahrscheinlich sein, weniger zusätzliche Variablen wie static deltaXges, deltaYges zu benötigen,
alles muss in der Liste gespeichert werden, für jede neue Berechnung allein die aktuell letzen Informationen ausreichen,
nur zwei Punkte reichen in der Liste vielleicht nicht, du solltest zumindest auch noch den Typ des aktuellen Eintrags speichern,

ok, für die aktuelle Berechnung ist das nicht unbedingt nötig, da weiß man ja den Typ aus dem Buttonklick,
für deine andere größere Frage ist das aber interessant, paintComponent() hast du bisher nicht,
wenn das funktionieren soll dann musst du dort jedesmal die komplette Strecke neu malen, deshalb mehr Infos in der Liste,
wäre überhaupt auch bisschen übersichtlicher, die Berechnung der Punkte (die du übrigens für 15 Grad anscheinend richtig hast) von der Zeichnung zu trennen,
wie paintComponent funktioniert will ich gar nicht groß sagen, bei einem derart riesigen Programm von dir solltest du dir im Internet bisschen was durchlesen, Beispielprogramme suchen

eine Alternative zur Dauerhaftigkeit der Zeichnung wäre, diese auf ein Image-Objekt zu malen
und in paintComponent immer dieses Image anzuzeigen

Steff87 · 7. Apr 2011

Danke schon mal dafür.
Soweit hab ich auch schon gedacht, mehr Informationen in die Liste zu packen. Hab mir daher eine weitere Liste gemacht, die mir den Typ des Streckenteils speichert. Die Berechnung für die Kurven funktioniert, wie du ja gesehen hast, schon gut.

Die Berechnung für die 30 Grad Kurve mach ich mit den Variablen deltaXges und deltaYges. Die Funktion fillArc bekommt ja den linken oberen Punkt des Rechteckes in dem der Kreis gezeichnet wird und zusätzlich die Breite, die Höhe, den Anfangswinkel und den Winkel des Kreissegments. Um den linken oberen Punkt zu berechnen muss ich den bereits gedrifteten weg der Kurven teile herausrechnen und die mach ich mit den Variablen deltaXges und deltaYges.
Bei den anderen Kurven mach ich das genau so, aber irgendwas muss ich noch abziehen, um eine übereinstimmung zu bekommen. aber Was ???:L

Auf den Trick mit dem Bild bin ich noch nicht gekommen, weiß aber nicht, ob es für meine Zwecke geeignet ist. Die Strecke soll auf eine andere Oberfläche übertragen werden und dort dann mit den erlernten Streckendaten eines autonomfahrenden Carrera Fahrzeuges verglichen werden.

Also ich hab mir noch einiges vorgenommen und das ganze soll bis spätestens Mitte August fertig sein.

SlaterB · 7. Apr 2011

also ich denke dann wirklich, wie schon gesagt, es ist die Zeile

Java:

g.fillArc(curPoints[0].x - (int)(radius) - deltaXges, curPoints[0].y - deltaYges, 2 * (int)(radius), (int)(2 * (radius)),
                  deg, (int)degree);

zusammen mit wie auch immer du deltaXges + deltaYges berechnest,
solange der radius gleich bleibt passt das irgendwie zusammen, wenn nun aber plötzlich der radius wechselt,
sind deltaX + Y verkehrt und lassen sich auch nicht so leicht umrechnen, jedenfalls nicht leichter als es gleich richtig zu machen:

ich kann auch nur meinen schon genannten Vorschlag wiederholen, ich hab es ja quasi schon beantwortet:
verzichte auf deltaXges + deltaYges, die, wie ich nun nach 1 Min. im Code sehe allein fürs Zeichnen nötig sind,
und berechne allein aus den beiden aktuellen grünen Punkten den aktuellen Mittelpunkt

das sollte doch wohl möglich sein, berechne den X- und Y-Abstand, bilde so ein rechtwinkliges Dreieck und einen Winkel
(Achtung, Sonderfall: genau waagerecht / genau senkrecht),
verwende als neue lange Seite in einem vergrößerten Rechteck den Radius und rechne damit neuen X/Y-Abstand zu einem der beiden grünen Punkte,
sin/cos in rechtwinkligen Dreieck, asin, acos, tan, atan, Pythagoras, brauch man alles immer wieder, hast du ja auch schon im Code,
bzw. hier reicht auch ein einfacher Dreisatz, damit hast du jedenfalls den Mittelpunkt für die Kreiszeichnung

Steff87 · 7. Apr 2011

Nochmals vielen Dank für deine Hilfe, SlaterB.:toll::applaus:

Hab mir deinen Rat zu Herzen genommen und jetzt Funktionierts einwandfrei
Foglenden Code hab ich in der drawCurve eingesetzt und die jeweiligen parameter in die drawFillArc eingesezt.

Java:

int x = curPoints[0].x-(int)Math.round(radius-radius*Math.sin((Math.PI/180*(deg-90))));
		int y = curPoints[0].y-(int)Math.round((radius-radius*Math.cos(Math.PI/180*(deg-90))));
		int x1 = curPoints[1].x-(int)Math.round((radius-trackSize)-(radius-trackSize)*Math.sin((Math.PI/180*(deg-90))));
		int y1 = curPoints[1].y-(int)Math.round(((radius-trackSize)-(radius-trackSize)*Math.cos(Math.PI/180*(deg-90))));

Vielen herzlichen dank:applaus::applaus::toll:

Jetzt fehlt nur noch die paintComponent. Wird aber auch irgendwie klappen

Crian · 7. Apr 2011

Vielleicht kannst du das ganze ja nochmal anhängen? Falls das hier geht. Ich finde das Projekt recht interessant.

Steff87 · 7. Apr 2011

Kann ich schon machen, will aber noch ein paar Änderungen vornehmen und erweitern. Zumindest sollte die paintComponent Methode funktionieren. Ansonsten Gern

Steff87 · 8. Apr 2011

Wie versprochen, die Sourcen vom einigermaßen funktionierenden Streckeneditor
Viel Spaß damit, und wenn jemdan verbesserungsvorschläge hat, nur her damit.:toll:

Test Klasse:

Java:

package ui;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;

import trackParts.TrackParts;
import util.TrackDrawPanel;

@SuppressWarnings("serial")
public class Test extends JFrame implements ActionListener{
	TrackDrawPanel track;
	
	Test(){
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(1024,600);
		track = new TrackDrawPanel();
		JScrollPane scrollTrack = new JScrollPane(track, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		JPanel trackParts = new JPanel();
		JSplitPane splitPanel= new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, scrollTrack, trackParts);
		splitPanel.setDividerSize(0);
		splitPanel.setDividerLocation(getSize().width*4/5);
		//System.out.println("width :"+track.getSize().width +" loc: "+splitPanel.getDividerLocation());
		
		trackParts.setSize(300, 600);
		trackParts.setPreferredSize(new Dimension(300, 600));
		
		JButton stdStraight = new JButton("Standardgerade");
		JButton curve1_30Deg = new JButton("Kurve 1/30°");
		JButton curve4_15Deg = new JButton("Kurve 4/15°");
		stdStraight.addActionListener(this);
		curve1_30Deg.addActionListener(this);
		curve4_15Deg.addActionListener(this);
		trackParts.add(stdStraight);
		trackParts.add(curve1_30Deg);
		trackParts.add(curve4_15Deg);
		
		add(splitPanel);
		setVisible(true);
	}
	@Override
	public void actionPerformed(ActionEvent evt) {
		String cmd = evt.getActionCommand();
		if(cmd.equalsIgnoreCase("Standardgerade")){
			TrackDrawPanel.drawStraight(track.getGraphics(), 34, TrackParts.STD_STRAIGHT);
		}else if(cmd.equalsIgnoreCase("Kurve 1/30°")){
			TrackDrawPanel.drawCurveLeft(track.getGraphics(), 30,40, TrackParts.C1_30);
		}else if(cmd.equalsIgnoreCase("Kurve 4/15°")){
			TrackDrawPanel.drawCurveLeft(track.getGraphics(), 15,99, TrackParts.C4_15);
		}
		
	}
	
	public static void main(String[] args) {
		new Test();
	}

}

TrackDrawPanel:

Java:

package util;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JPanel;

import trackParts.StdTrackTypes;
import trackParts.TrackParts;
import trackParts.curves.Curve1_30Deg;
import trackParts.curves.Curve1_60Deg;
import trackParts.curves.Curve2_30Deg;
import trackParts.curves.Curve3_30Deg;
import trackParts.curves.Curve4_15Deg;
import trackParts.straights.DoubleLaneChange;
import trackParts.straights.LaneChangeLeft;
import trackParts.straights.LaneChangeRight;
import trackParts.straights.StandardStraight;
import trackParts.straights.Straight_1_3;
import trackParts.straights.Straight_1_4;

@SuppressWarnings("serial")
public class TrackDrawPanel extends JPanel implements MouseListener{
		
	static Integer startCoordinates[] = {410,384}; //x,y
	
	public static List<Point[]> coordinatePoints;
	public static List<String> partList;
	static int deg = 90;
	static Point[] curPoints = null;
	
	static boolean repaint=false;
	
	static int trackSize = Math.round(StdTrackTypes.getWidth());
	
	public TrackDrawPanel(String filePath){
		this();
		readFile(filePath);
	}
	
	public TrackDrawPanel(){
		partList = new ArrayList<String>();
		coordinatePoints = new ArrayList<Point[]>();
		
		if(coordinatePoints.size()==0){
			Point p[] = {new Point(startCoordinates[0], startCoordinates[1]), new Point(startCoordinates[0],startCoordinates[1]+trackSize)};
			coordinatePoints.add(p);
		}
		curPoints = coordinatePoints.get(0);
		this.addMouseListener(this);
	}
	
	void readFile(String filePath){
		FileInputStream leseStrom = null;
		coordinatePoints.remove(0);
		 int zeichen = 0;
		 String str = "";
		 
		try {
			leseStrom = new FileInputStream(filePath);
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		}
	    
		do{
	       try {
			zeichen = leseStrom.read();
			} catch (IOException e) {
				e.printStackTrace();
			}
			str += (char)zeichen;
		
	     } while (zeichen !=-1);
		

		String[] stra = str.split("/");
		String[] parts = stra[0].split(",");
		for(int i =0; i< parts.length; i++){
			if(parts[i]=="-1"){
				continue;
			}
			partList.add(parts[i]);
		}
		Point[] p= {null,null} ;
		int j=0;
		String[] coordinates = stra[1].split(";");
		for(int i=0; i<coordinates.length; i++){
			if(coordinates[i]!=""){
				String[] splitstr = coordinates[i].split(",");
				if(splitstr.length<2)
					continue;
				p[j] = new Point(Integer.parseInt(splitstr[0].substring(1)),Integer.parseInt(splitstr[1].substring(0, splitstr[1].indexOf('>'))));
				j++;
				if(j==2){
					j=0;
					addPoints(p);
					p= new Point[]{null,null};
				}
			}
		}
		//this.repaint();
	     try {
			leseStrom.close();
		} catch (IOException e) {

		}
	}
	void addPoints(Point[]p){
		Point[] q = p;
		coordinatePoints.add(q);
	}
	
	/**
	 * Calculates the Y-Coordinate of the end points of a curve
	 * @param deg The extent angle
	 * @param radius The radius of the curve
	 * @return It returns the y-value in pixel
	 */
	static int calcDeltaY(double deg, double radius){
		
		double alpha = (Math.PI)/180*deg; // Umwandlung in Radialwert
		double c = radius;				  // Dreiecksseiten
		double b = radius;				  //	
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));						//Berechnung von fehlender Seite
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));		//Berechnung von fehlendem Winkel
		double tmpAlpha = Math.PI-(Math.PI)/180*90-(Math.PI/180*(TrackDrawPanel.deg-90));				//Berechnung von fehlendem Winkel im zweiten Dreieck
		tmpAlpha = Math.PI-tmpAlpha-beta;																//
		int x = (int) Math.round(a*Math.sin(tmpAlpha));													//Entgültige Berechnung von deltaY
		return x;
		
	}
	
	/**
	 * Calculates the X-Coordinate of the end points of a curve
	 * @param deg The extent angle
	 * @param radius The radius of the curve
	 * @return It returns the x-value in pixel
	 */
	static int calcDeltaX(double deg, double radius){
		
		double alpha = (Math.PI)/180*deg; // Da die Sinus und Cosinus Funktionen von der Klasse Math nur mit Radialwerten rechnet, wird hier die Gradzahl umgewandelt 
		double c = radius;				  // Zwei der drei Seiten des Dreickes haben die Länge des Übergebenen Radiuses
		double b = radius;				  // Es ist somit immer ein gleichschenkliges Dreieck.
		double a = Math.sqrt(Math.pow(b, 2)+Math.pow(c, 2)- 2*b*c*Math.cos(alpha));						// Hier wird die fehlende Seite des Dreieckes mit dem Cosinussatz, aufgelöst nach dem Winkel, berechnet
		double beta = Math.acos((Math.pow(b, 2) - Math.pow(c, 2) - Math.pow(a, 2)) / (-2 * c * a));		// Berechnung von fehlendem Winkel für die Berechnung des nächsten Dreieck
		double tmpAlpha = Math.PI-(Math.PI)/180*90-(Math.PI/180*(TrackDrawPanel.deg-90));				// Berechnung von fehlendem Winkel im zweiten Dreieck zur Berechnung von deltaX
		tmpAlpha = Math.PI-tmpAlpha-beta;																//
		int x = (int) Math.round(a*Math.cos(tmpAlpha));													// Hier wird entgültig das deltaX berechnet
		return x;
	}
	
	public static void drawCurveRight(Graphics g, double degree, double radius, TrackParts part){
		// Current Coordinates
		g.setColor(Color.BLACK);
		Point p[] = null;
		
		int x = curPoints[1].x+(int)Math.round(radius - radius*Math.sin(Math.PI/180*(90-deg)));
		int y = curPoints[1].y+(int)Math.round( radius*Math.cos(Math.PI/180*(90-deg))+radius);
		int x1 = curPoints[0].x+(int)Math.round((radius+trackSize)-(radius+trackSize)*Math.sin(Math.PI/180*(90-deg)));
		int y1 = curPoints[0].y+(int)Math.round((radius+trackSize)*Math.cos(Math.PI/180*(90-deg))+(radius+trackSize));
				
		//Zeichnen der Kurve
		g.fillArc(x,y, -2*(int)(radius), (int) (-2*(radius)), deg-180, (int)degree);
		g.setColor(Color.WHITE);
		g.fillArc(x1,y1, -2*(int)(radius+trackSize), -2*(int)(radius+trackSize), deg-180, (int)degree);
		
		//Berechnung von deltaX und deltaY
		int deltaX = calcDeltaX(-degree, radius);
		int deltaY = calcDeltaY(-degree, radius);
		int deltaX1 = calcDeltaX(-degree, radius+trackSize);
		int deltaY1 = calcDeltaY(-degree, radius+trackSize);
	
		//Aktueller Gesamtwinkel
		deg =(int)(deg+degree<0?(deg+degree+360):deg+degree);

		if(!repaint){
			partList.add(part.toString()+"r");
			p = new Point[]{new Point(curPoints[0].x-(deltaX1),curPoints[0].y+(deltaY1)),new Point(curPoints[1].x-(deltaX),curPoints[1].y+(deltaY))};
			coordinatePoints.add(p);
			curPoints = coordinatePoints.get(coordinatePoints.size()-1);
		}
		g.setColor(Color.GREEN);
        for (Point[] q : coordinatePoints)
        {
            g.drawLine(q[0].x, q[0].y, q[1].x, q[1].y);
            g.fillArc(q[0].x, q[0].y, 5, 5, 0, 360);
            g.fillArc(q[1].x, q[1].y, 5, 5, 0, 360);
        }
	}
	
	/**
	 * Diese Methode zeichnet eine gefüllte Kurve.
	 * @param g
	 * @param degree Der Winkel der Kurve 
	 * @param radius Der Außenradius der Kurve
	 */
	public static void drawCurveLeft(Graphics g, double degree, double radius, TrackParts part){
		// Current Coordinates
		Point p[] = null;
		g.setColor(Color.BLACK);
		
		int x = curPoints[0].x-(int)Math.round(radius-radius*Math.sin((Math.PI/180*(deg-90))));
		int y = curPoints[0].y-(int)Math.round((radius-radius*Math.cos(Math.PI/180*(deg-90))));
		int x1 = curPoints[1].x-(int)Math.round((radius-trackSize)-(radius-trackSize)*Math.sin((Math.PI/180*(deg-90))));
		int y1 = curPoints[1].y-(int)Math.round(((radius-trackSize)-(radius-trackSize)*Math.cos(Math.PI/180*(deg-90))));
		
		//Zeichnen der Kurve
		g.fillArc(x, y, 2*(int)(radius), (int) (2*(radius)), deg, (int)degree);
		g.setColor(Color.WHITE);
		g.fillArc(x1,y1, 2*(int)(radius-trackSize), 2*(int)(radius-trackSize), deg, (int)degree);
		
		//Berechnung von deltaX und deltaY
		int deltaX = calcDeltaX(degree, radius);
		int deltaY = calcDeltaY(degree, radius);
		int deltaX1 = calcDeltaX(degree, radius-trackSize);
		int deltaY1 = calcDeltaY(degree, radius-trackSize);
		
		//Aktueller Gesamtwinkel
		deg =(int)(deg+degree>360?(deg+degree-360):deg+degree);

		if(!repaint){
			partList.add(part.toString());
			p = new Point[]{new Point(curPoints[0].x-(deltaX),curPoints[0].y+(deltaY)), new Point(curPoints[1].x-(deltaX1),curPoints[1].y+(deltaY1))};
			coordinatePoints.add(p);
			curPoints = coordinatePoints.get(coordinatePoints.size()-1);
		}
		g.setColor(Color.GREEN);
        for (Point[] q : coordinatePoints)
        {
            g.drawLine(q[0].x, q[0].y, q[1].x, q[1].y);
            g.fillArc(q[0].x, q[0].y, 5, 5, 0, 360);
            g.fillArc(q[1].x, q[1].y, 5, 5, 0, 360);
        }
	}

	/**
	 * This method draws a straight.
	 * @param g
	 * @param length The length of a straight
	 */
	public static void drawStraight(Graphics g, int length, TrackParts part){
		
		g.setColor(Color.BLACK);
		Point p[]=null;

		if(deg==360 || deg == 0){ // Alle horizontale und vertikale Geraden
			g.fillRect(curPoints[0].x, curPoints[0].y, -trackSize, -length);
			p = new Point[]{new Point(curPoints[0].x,curPoints[0].y-length), new Point(curPoints[0].x-trackSize,curPoints[0].y-length)};
		}else if(deg==270){
			g.fillRect(curPoints[0].x, curPoints[0].y, length, -trackSize);
			p = new Point[]{new Point(curPoints[0].x+length,curPoints[0].y), new Point(curPoints[0].x+length,curPoints[0].y-(trackSize))};
		}else if(deg == 180){
			g.fillRect(curPoints[0].x, curPoints[0].y, trackSize, length);
			p = new Point[]{new Point(curPoints[0].x,curPoints[0].y+length), new Point(curPoints[0].x+trackSize,curPoints[0].y+length)};
		}else if(deg == 90){
			g.fillRect(curPoints[0].x, curPoints[0].y, -length, trackSize);
			p = new Point[]{new Point(curPoints[0].x-length,curPoints[0].y), new Point(curPoints[0].x-length,curPoints[0].y+trackSize)};
		}else{ // Alle anderen Winkel
			int x = (int)(length * Math.cos(Math.PI/180*(deg-90)));
			int y = (int)(length * Math.sin(Math.PI/180*(deg-90)));
			int xpoints[] = null;
			int ypoints[] = null;
			
			// Aufbauschema
			// x1y1-----x4y4
			//  |         |
			// x2y2-----x3y3
			
			if(deg>0 && deg < 90){ 
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x-(x<0?-x:x),curPoints[0].x-(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y-(y<0?-y:y),curPoints[0].y-(y<0?-y:y)};
			}else if(deg>90 && deg < 180){ 
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x-(x<0?-x:x),curPoints[0].x-(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y+(y<0?-y:y),curPoints[0].y+(y<0?-y:y)};
			}else if(deg>180 && deg < 270){
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x+(x<0?-x:x),curPoints[0].x+(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y+(y<0?-y:y),curPoints[0].y+(y<0?-y:y)};
			}else if(deg>270 && deg < 360){
				xpoints = new int[]{curPoints[0].x,curPoints[1].x,curPoints[1].x+(x<0?-x:x),curPoints[0].x+(x<0?-x:x)};
				ypoints = new int []{curPoints[0].y,curPoints[1].y,curPoints[1].y-(y<0?-y:y),curPoints[0].y-(y<0?-y:y)};
			}
			
			
			
			g.fillPolygon(xpoints, ypoints, 4);
			p = new Point[]{new Point(xpoints[3],ypoints[3]), new Point(xpoints[2],ypoints[2])};
			
		}
		//Keine neuen Einträge in die Listen, wenn das Panel neu gezeichnet wird
		if(!repaint){
			partList.add(part.toString());
			coordinatePoints.add(p);
			curPoints = coordinatePoints.get(coordinatePoints.size()-1);
		}
		
		Point[] t = coordinatePoints.get(coordinatePoints.size()-2);
		
		if(part == TrackParts.DOUBLELANECHANGE){
			g.setColor(Color.YELLOW);
			g.drawLine(curPoints[0].x, curPoints[0].y, t[1].x, t[1].y); //Rechts
			g.setColor(Color.BLUE);
			g.drawLine(curPoints[1].x, curPoints[1].y, t[0].x, t[0].y); //Links
		}else if(part == TrackParts.LANECHANGE_LEFT){
			g.setColor(Color.YELLOW);
			g.drawLine(curPoints[1].x, curPoints[1].y, t[0].x, t[0].y); //Links
		}else if(part == TrackParts.LANECHANGE_RIGHT){
			g.setColor(Color.YELLOW);
			g.drawLine(curPoints[0].x, curPoints[0].y, t[1].x, t[1].y); //Rechts
		}
	}

	public static void drawBlackBox(Graphics g, int length){
		int offset = length/3;
		int xpoints[] = {curPoints[0].x, curPoints[1].x, curPoints[1].x-offset, curPoints[1].x-offset, curPoints[1].x-2*offset, curPoints[1].x-2*offset, curPoints[1].x-length, curPoints[0].x-length};
		int ypoints[] = {curPoints[0].y, curPoints[1].y, curPoints[1].y, curPoints[1].y+10, curPoints[1].y+10, curPoints[1].y, curPoints[1].y, curPoints[0].y};
		g.setColor(Color.BLACK);
		g.fillPolygon(xpoints, ypoints, xpoints.length);
		Point[] p = {new Point(xpoints[7], ypoints[7]), new Point(xpoints[6], ypoints[6])};
		if(!repaint){
			coordinatePoints.add(p);
			partList.add(TrackParts.BLACKBOX.toString());
			curPoints = coordinatePoints.get(coordinatePoints.size()-1);
		}
	}
	
	protected void paintComponent(Graphics g){
		super.paintComponent(g);
		int i=0;
		repaint = true;
		int lastDeg = deg;
		deg = 90;
		
		for(String part: partList){
			curPoints = coordinatePoints.get(i);
			if(part.equals(TrackParts.STD_STRAIGHT.toString())){
				drawStraight(g, (int)StandardStraight.getLength(), TrackParts.STD_STRAIGHT);
			}else if(part.equals(TrackParts.STRAIGHT_1_3.toString())){
				drawStraight(g, (int)Straight_1_3.getLength(), TrackParts.STRAIGHT_1_3);
			}else if(part.equals(TrackParts.STRAIGHT_1_4.toString())){
				drawStraight(g, (int)Straight_1_4.getLength(), TrackParts.STRAIGHT_1_4);
			}else if(part.equals(TrackParts.DOUBLELANECHANGE.toString())){
				drawStraight(g, (int)DoubleLaneChange.getLength(), TrackParts.DOUBLELANECHANGE);
			}else if(part.equals(TrackParts.LANECHANGE_LEFT.toString())){
				drawStraight(g, (int)LaneChangeLeft.getLength(), TrackParts.LANECHANGE_LEFT);
			}else if(part.equals(TrackParts.LANECHANGE_RIGHT.toString())){
				drawStraight(g, (int)LaneChangeRight.getLength(), TrackParts.LANECHANGE_RIGHT);
			}else if(part.equals(TrackParts.BLACKBOX.toString())){
				drawBlackBox(g, Math.round(StandardStraight.getLength()));
			}else if(part.equals(TrackParts.C1_30.toString())){
				drawCurveLeft(g, Curve1_30Deg.getDeg(), Curve1_30Deg.getRadius(), TrackParts.C1_30);
			}else if(part.equals(TrackParts.C1_60.toString())){
				drawCurveLeft(g, Curve1_60Deg.getDeg(), Curve1_60Deg.getRadius(), TrackParts.C1_60);
			}else if(part.equals(TrackParts.C2_30.toString())){
				drawCurveLeft(g, Curve2_30Deg.getDeg(), Curve2_30Deg.getRadius(), TrackParts.C2_30);
			}else if(part.equals(TrackParts.C3_30.toString())){
				drawCurveLeft(g, Curve3_30Deg.getDeg(), Curve3_30Deg.getRadius(), TrackParts.C3_30);
			}else if(part.equals(TrackParts.C4_15.toString())){
				drawCurveLeft(g, Curve4_15Deg.getDeg(), Curve4_15Deg.getRadius(), TrackParts.C4_15);
			}else if(part.equals(TrackParts.STC1_30.toString())){
				drawCurveLeft(g, Curve1_30Deg.getDeg(), Curve1_60Deg.getRadius(), TrackParts.STC1_30);
			}else if(part.equals(TrackParts.STC2_30.toString())){
				drawCurveLeft(g, Curve2_30Deg.getDeg(), Curve2_30Deg.getRadius(), TrackParts.STC2_30);
			}else if(part.equals(TrackParts.STC3_30.toString())){
				drawCurveLeft(g, Curve3_30Deg.getDeg(), Curve3_30Deg.getRadius(), TrackParts.STC3_30);
			}else if(part.equals(TrackParts.STC4_15.toString())){
				drawCurveLeft(g, Curve4_15Deg.getDeg(), Curve4_15Deg.getRadius(), TrackParts.STC4_15);
			}else if(part.equals(TrackParts.C1_30.toString()+"r")){
				drawCurveRight(g, -Curve1_30Deg.getDeg(), -Curve1_30Deg.getRadius(), TrackParts.C1_30);
			}else if(part.equals(TrackParts.C1_60.toString()+"r")){
				drawCurveRight(g, -Curve1_60Deg.getDeg(), -Curve1_60Deg.getRadius(), TrackParts.C1_60);
			}else if(part.equals(TrackParts.C2_30.toString()+"r")){
				drawCurveRight(g, -Curve2_30Deg.getDeg(), -Curve2_30Deg.getRadius(), TrackParts.C2_30);
			}else if(part.equals(TrackParts.C3_30.toString()+"r")){
				drawCurveRight(g, -Curve3_30Deg.getDeg(), -Curve3_30Deg.getRadius(), TrackParts.C3_30);
			}else if(part.equals(TrackParts.C4_15.toString()+"r")){
				drawCurveRight(g, -Curve4_15Deg.getDeg(), -Curve4_15Deg.getRadius(), TrackParts.C4_15);
			}else if(part.equals(TrackParts.STC1_30.toString()+"r")){
				drawCurveRight(g, -Curve1_30Deg.getDeg(), -Curve1_30Deg.getRadius(), TrackParts.STC1_30);
			}else if(part.equals(TrackParts.STC2_30.toString()+"r")){
				drawCurveRight(g, -Curve2_30Deg.getDeg(), -Curve2_30Deg.getRadius(), TrackParts.STC2_30);
			}else if(part.equals(TrackParts.STC3_30.toString()+"r")){
				drawCurveRight(g, -Curve3_30Deg.getDeg(), -Curve3_30Deg.getRadius(), TrackParts.STC3_30);
			}else if(part.equals(TrackParts.STC4_15.toString()+"r")){
				drawCurveRight(g, -Curve4_15Deg.getDeg(), -Curve4_15Deg.getRadius(), TrackParts.STC4_15);
			}
			i++;
		}
		curPoints = coordinatePoints.get(i);
		
		this.setBackground(Color.white);
		deg = lastDeg;
		repaint = false;
	}
	
	@Override
	public void mouseClicked(MouseEvent e) {
		System.out.println("XPos: "+e.getX()+" YPos: "+e.getY());
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
	
}

TrackParts:

Java:

public enum TrackParts {
	C1_30, C1_60, C2_30, C3_30, C4_15, STC1_30, STC2_30, STC3_30, STC4_15,
	STD_STRAIGHT, STRAIGHT_1_3, STRAIGHT_1_4, DOUBLELANECHANGE,  LANECHANGE_LEFT, LANECHANGE_RIGHT, BLACKBOX
}

Die Restlichen fehlenden Klassen kann ja jeder selber schreiben. Sind nicht groß und schwierig.

Crian · 14. Apr 2011

Die Restlichen fehlenden Klassen kann ja jeder selber schreiben. Sind nicht groß und schwierig.

Ich dachte du packst das einfach und hängst es an. Schade, da ist noch so viel rot, das kann ich nicht eben nachschreiben.

SlaterB · 14. Apr 2011

rot sind doch nur Klassennamen in Aufrufen wie
[c]drawStraight(g, (int)Straight_1_3.getLength(), TrackParts.STRAIGHT_1_3);[/c]
das sind alles reichlich sinnlose Klassen wie anfangs schon

Java:

class StdTrackTypes {
    private static float width = 19.8f; //cm
    
    public static float getWidth(){
        return width;
    }
}

also flott entsprechende Klassennamen definieren und irgendwelche Werte zurückgeben,
Winkel von 0-90, Strecken wahrscheinlich auch in diesem niedrigen Bereich,
Ausprobieren ist auch erlaubt..

oder gleich diese Aufrufe durch normale Werte bzw. besser Konstanten ersetzen

Steff87 · 14. Apr 2011

So schwer ist das ganze nicht.
Leider kann ich nicht alles packen und hier anhängen. Ist nämlich Teil eines größeren Projektes. Da kann ich nicht einfach her gehen und die Technologie verraten.

	Titel	Forum	Antworten	Datum
I	JFrame Bild strecken und auf Bildschirmgröße anpassen	AWT, Swing, JavaFX & SWT	2	16. Mai 2016
L	LayoutManager Componenten über verfügbaren Platz strecken	AWT, Swing, JavaFX & SWT	7	29. Nov 2011
	Swing Text in JLabel strecken	AWT, Swing, JavaFX & SWT	2	18. Jun 2010
S	Swing Dynamische JPanels: Vertikales Strecken verhindern	AWT, Swing, JavaFX & SWT	4	7. Jul 2009
B	Icon strecken / zerren	AWT, Swing, JavaFX & SWT	6	30. Dez 2007
L	Schnittpunkt von 2 Strecken ermitteln	AWT, Swing, JavaFX & SWT	4	3. Apr 2007
B	BorderLayout.WEST (JTree strecken in Höhe)	AWT, Swing, JavaFX & SWT	2	19. Apr 2006
	HTML Editor	AWT, Swing, JavaFX & SWT	3	2. Okt 2022
C	HTML Editor Eingabemaske kafenio Ersatz	AWT, Swing, JavaFX & SWT	7	17. Feb 2020
L	JavaFX JavaFX Diagram Editor	AWT, Swing, JavaFX & SWT	3	20. Mrz 2019
L	Editor does not contain a main type	AWT, Swing, JavaFX & SWT	1	6. Dez 2017
K	Java FX: Mathematik Editor	AWT, Swing, JavaFX & SWT	14	13. Jan 2017
K	Html Editor	AWT, Swing, JavaFX & SWT	3	24. Jun 2016
B	Java FX FXML Textarea SceneBuilder als XML Editor	AWT, Swing, JavaFX & SWT	1	14. Mrz 2016
R	Editor Wörter zählen	AWT, Swing, JavaFX & SWT	2	30. Dez 2015
S	JavaFX FXML-Editor mit Java 7?	AWT, Swing, JavaFX & SWT	2	9. Nov 2015
U	WYSIWYG Text-Editor für JFrames	AWT, Swing, JavaFX & SWT	8	28. Feb 2015
I	LookAndFeel HTML Auflösung - Online Editor programmieren	AWT, Swing, JavaFX & SWT	2	17. Nov 2014
	Java JTable - Combobox + Checkbox - Cellrenderer + Editor	AWT, Swing, JavaFX & SWT	3	16. Nov 2014
F	JAVA-EDITOR: Panel in Frame aufnehmen	AWT, Swing, JavaFX & SWT	3	6. Mai 2014
G	Text im textfeld in einem Editor anzeigen	AWT, Swing, JavaFX & SWT	18	6. Mai 2014
T	SelectAll bei JXTreeTable Editor	AWT, Swing, JavaFX & SWT	2	25. Okt 2012
B	Swing Filter für JTable mit Netbeans Editor	AWT, Swing, JavaFX & SWT	2	23. Okt 2012
A	Swing Imagemap-Editor -> XML	AWT, Swing, JavaFX & SWT	8	27. Jun 2012
S	SWT HTML-WYSIWUG-Editor	AWT, Swing, JavaFX & SWT	3	12. Mrz 2012
B	GUI Editor nachträglich anschalten?	AWT, Swing, JavaFX & SWT	4	24. Nov 2011
B	Netbeans Swing/AWT Editor editierbar?	AWT, Swing, JavaFX & SWT	5	7. Nov 2011
X	Frei nutzbarer HTML Editor	AWT, Swing, JavaFX & SWT	13	24. Apr 2011
B	WYSIWYG-HTML-Editor / Validator für JAVA	AWT, Swing, JavaFX & SWT	2	6. Apr 2011
S	Visual Editor mit main Methode	AWT, Swing, JavaFX & SWT	3	29. Jan 2011
	Swing XML editor plugin für eigene anwendung	AWT, Swing, JavaFX & SWT	2	28. Jan 2011
H	variable Höhe einer JTextArea (als Renderer/Editor) als Zelle einer JTable	AWT, Swing, JavaFX & SWT	9	1. Nov 2010
B	Editor programmieren	AWT, Swing, JavaFX & SWT	26	5. Okt 2010
R	JTable - eigener Editor - Mouse events	AWT, Swing, JavaFX & SWT	2	30. Sep 2010
N	Eigener Grafik Editor mit fehlerhafter Anzeige	AWT, Swing, JavaFX & SWT	4	7. Jun 2010
M	Swing jcombobox als jtable-editor: neues Item auswählen	AWT, Swing, JavaFX & SWT	4	10. Mai 2010
J	eclipse/Visual Editor: Auf Felder/Methoden vom Hauptframe zugreifen	AWT, Swing, JavaFX & SWT	4	6. Apr 2010
G	Swing Hex-Editor	AWT, Swing, JavaFX & SWT	19	28. Jan 2010
R	Swing Editor für jTable	AWT, Swing, JavaFX & SWT	6	8. Dez 2009
N	Swing Dynamische JRadioButtons und Visual Editor	AWT, Swing, JavaFX & SWT	4	24. Sep 2009
	Kleiner UML Editor	AWT, Swing, JavaFX & SWT	4	23. Jun 2009
F	Visual Editor Installationsprobleme	AWT, Swing, JavaFX & SWT	12	19. Jun 2009
C	Suche fertigen HTML editor	AWT, Swing, JavaFX & SWT	2	10. Feb 2009
K	Eclipse Visual Editor rendert die Komponenten nicht richtig	AWT, Swing, JavaFX & SWT	2	18. Dez 2008
D	Events bei Tabs in einem Editor	AWT, Swing, JavaFX & SWT	2	12. Aug 2008
V	Visual Editor und nerviges FreeFormComponentsHostDialog	AWT, Swing, JavaFX & SWT	3	12. Jul 2008
K	Tabelle -> Editor -> b-estimmte Tasten	AWT, Swing, JavaFX & SWT	17	13. Jun 2008
N	Kennt jemand einen WYSIWYG Editor für AWT?	AWT, Swing, JavaFX & SWT	4	20. Apr 2008
C	Spielfeld Editor	AWT, Swing, JavaFX & SWT	4	9. Jan 2008
M	Editor-Komponente	AWT, Swing, JavaFX & SWT	3	6. Sep 2007
M	Einfachen UI Editor basteln	AWT, Swing, JavaFX & SWT	2	15. Aug 2007
D	Brauche einfachen HTML Editor	AWT, Swing, JavaFX & SWT	2	29. Jul 2007
O	Editor in JTable mit mouseMoved aufrufen?	AWT, Swing, JavaFX & SWT	2	18. Jun 2007
K	Keine SWT-Komponenten-Gruppe in Palette des Visual Editor	AWT, Swing, JavaFX & SWT	2	16. Jun 2007
R	Editor mit "Gehe zu"-Funktion	AWT, Swing, JavaFX & SWT	4	10. Jun 2007
T	Editor auf Basis JFrame in ein JPanel wandeln - Problem!	AWT, Swing, JavaFX & SWT	5	27. Apr 2007
G	JTable Editor	AWT, Swing, JavaFX & SWT	7	2. Apr 2007
G	Selbstprogrammierter Editor - brauche Hilfe	AWT, Swing, JavaFX & SWT	5	12. Mrz 2007
N	JTable mit Editor?	AWT, Swing, JavaFX & SWT	3	19. Feb 2007
M	Hilfe bei vers. Fonts und Zeilenlänge in eigenem Editor.	AWT, Swing, JavaFX & SWT	3	30. Jan 2007
J	GUI-Editor	AWT, Swing, JavaFX & SWT	18	4. Sep 2006
G	Editor Lade Problem	AWT, Swing, JavaFX & SWT	22	8. Aug 2006
G	Editor wie MS Word	AWT, Swing, JavaFX & SWT	3	2. Jun 2006
H	eigener Editor und JList als PopMenu	AWT, Swing, JavaFX & SWT	6	31. Jan 2006
G	JTable: Zellenhöhe mit neuem CellRenderer & Editor	AWT, Swing, JavaFX & SWT	17	28. Dez 2005
P	Wie richte ich den Visual Editor ein ?	AWT, Swing, JavaFX & SWT	2	16. Dez 2005
C	wysiwyg Editor zum Einbinden in meinem Code	AWT, Swing, JavaFX & SWT	14	11. Dez 2005
S	[JTable] Editor erst nach Doppelklick	AWT, Swing, JavaFX & SWT	5	10. Okt 2005
	JTable: Editor stoppen	AWT, Swing, JavaFX & SWT	8	18. Mai 2005
A	irgendwo ein fertiger WYSIWYG HTML-Editor da?	AWT, Swing, JavaFX & SWT	7	11. Mrz 2005
K	editor fuer swing und awt	AWT, Swing, JavaFX & SWT	7	26. Apr 2004
W	Editor Syntax Farben	AWT, Swing, JavaFX & SWT	2	9. Apr 2004

Strecken-Editor

Aktives Mitglied

SlaterB

Gast

Gesperrter Benutzer

Aktives Mitglied

Aktives Mitglied

SlaterB

Gast

Anhänge

Aktives Mitglied

Aktives Mitglied

Anhänge

SlaterB

Gast

Aktives Mitglied

SlaterB

Gast

Anhänge

Aktives Mitglied

SlaterB

Gast

Aktives Mitglied

Top Contributor

Aktives Mitglied

Aktives Mitglied

Top Contributor

SlaterB

Gast

Aktives Mitglied

Ähnliche Java Themen