punkte verschwinden beim neuzeichnen neuer punkte

[JohannV]

hallo an alle, ich hab da ein problemm.
und zwar:
ich will einzelne punkte auf den bildschirm darstellen, diese sollen gleich nach der eingabe auftauchen.
diese tauchen zwar auf, verschwinden jedoch gleich nach der eingabe des nächsten punktes.
zuerst dachte ich, dass die logik der punkte falsch ist, dem ist aber nicht so. die punkte sind da, die rechnungen im hintergrund funktionieren auch.

hab zwar schon einige beiträge angeschaut, doch nix passendes gefunden.
kann mir einer helfen?
besten dank schonmal

hier der code meines panels

public class Graph extends JPanel
{
	Knoten[] knoten;
	StabElement[] stab;
	int anzahlKnoten;
	int anzahlStaebe;
	public Graph(Knoten[] k)
	{
	this.knoten=k;	
	}
	public Graph()
	{
		this.anzahlKnoten=0;
		this.anzahlStaebe=0;
	}

	public Graph(Knoten[] k, StabElement[] s)
	{
		knoten=k;
		stab=s;
		anzahlKnoten=k.length;
		anzahlStaebe=s.length;
	}

	public void paintComponent(Graphics g)
	{
		super.paintComponent(g);
		Graphics2D g2=(Graphics2D)g;
		g2.translate(200, 300);
		try
		{
			g2.setColor(new Color(123,255,200));
			for(int i=0; i<anzahlKnoten; i++)
			{
				System.out.println("in klasse knoten:"+i);
				g2.fillOval((int)knoten[i].getXKoord(), (int)knoten[i].getYKoord(), 10, 10);
			}
		}
		catch(Exception e)
		{
			System.out.println("Fehler im Graph");
		}
	}
	public void setKnoten(Knoten[] knoten)
	{
		this.knoten = knoten;
		this.anzahlKnoten=knoten.length;
	}
	public void setStab(StabElement[] stab)
	{
		this.stab = stab;
		this.anzahlStaebe=stab.length;
	}

}

 

[Ebenius]

diese tauchen zwar auf, verschwinden jedoch gleich nach der eingabe des nächsten punktes.

Poste mal eben noch den Code der die Punkte hinzufügt!

Ebenius

 

[Johannv]

gleich gibts anschiss :bahnhof:

bei zeile 138 bis 186

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;


public class Start2DFEM extends JApplet implements ActionListener
{
	public JLabel test=new JLabel("tswerwerwrwt");
	
	public JButton erzeugeKnoten;
	public JButton loescheKnoten;
	public JButton erzeugeStab;
	public JButton loescheStab;
	public JButton erzeugeKraft;
	public JButton loescheKraft;
	public JButton erzeugeLager;
	public JButton loescheLager;
	public JButton berechne;
	public Graph graph;
	public Vector vKnoten;
	
	//eingabe panel
	JPanel eingabePanel=new JPanel();
	public JLabel lxkoord=new JLabel("X-Koordinate");
	public JLabel lykoord=new JLabel("Y-Koordinate");
	public JTextField tfxeingabe=new JTextField();
	public JTextField tfyeingabe=new JTextField();
	public JButton fertikEK=new JButton("Knoten Erzeugen");
	public Knoten knotenTemp=new Knoten();
	
	
	//knoten löschen
	public JLabel kNr=new JLabel("Knotennummer");
	public JButton  fertigLK=new JButton("Knoten Löschen");
	public JTextField tfKnotenNummer=new JTextField();
	
	
	//gibt jeweils die nächste nummer(id)eines knotens
	public int knotenID=1;
	//gibt die tatsächliche anzahl der knoten
	int anzahlKnoten=0;
	int anzahlStaebe=0;
	Knoten[] knoten;
	Knoten[] knotenHilf;
	
	StabElement[] stab;
	
	public void init()
	{

		this.setSize(900, 500);
		
		this.getContentPane().setBackground(new Color(50,100,130));
		this.setLayout(new BorderLayout(5,5));
		this.add("West",funktionsPanel());

		//initialisierung
		graph=new Graph();
		fertikEK.addActionListener(this);
		fertigLK.addActionListener(this);
		tfxeingabe.addActionListener(this);
		tfyeingabe.addActionListener(this);
		knoten=new Knoten[1];
		stab=new StabElement[1];
		vKnoten =new Vector(1,1);
		
	
		this.add("Center",graph);
		this.add("South",eingabePanel);
	}
	public JPanel funktionsPanel()
	{
		JPanel panel=new JPanel();
		
		panel.setLayout(new GridLayout(9,1,0,3));
		

		
		erzeugeKnoten=new JButton("Erzeuge Knoten");
		loescheKnoten=new JButton("Lösche Knoten");
		erzeugeStab=new JButton("Erzeuge Stabelement");
		loescheStab=new JButton("Lösche Stabelement");
		erzeugeLager=new JButton("Erzeuge Lager");
		loescheLager=new JButton("Lösche Lager");
		erzeugeKraft=new JButton("Erzeuge Kraft");
		loescheKraft=new JButton("Lösche Kraft");
		berechne=new JButton("Berechnung Starten");
		
		erzeugeKnoten.addActionListener(this);
		loescheKnoten.addActionListener(this);
		erzeugeStab.addActionListener(this);
		loescheStab.addActionListener(this);
		erzeugeLager.addActionListener(this);
		loescheLager.addActionListener(this);
		erzeugeKraft.addActionListener(this);
		loescheKraft.addActionListener(this);
		berechne.addActionListener(this);
		
		panel.add(erzeugeKnoten);
		panel.add(loescheKnoten);
		panel.add(erzeugeStab);
		panel.add(loescheStab);
		panel.add(erzeugeLager);
		panel.add(loescheLager);
		panel.add(erzeugeKraft);
		panel.add(loescheKraft);
		panel.add(berechne);
		
		return panel;
	}
	@Override
	public void actionPerformed(ActionEvent event)
	{
		String cmd=event.getActionCommand();

		if(cmd.equals("Erzeuge Knoten"))
		{
			eingabeKnoten(eingabePanel);

			this.validateTree();
		}
		if(cmd.equals("Lösche Knoten"))
		{

			loescheKnoten(eingabePanel);
			this.validateTree();
		}
		if(cmd.equals("Knoten Erzeugen"))
		{
			//kontrolle auf korrekte eingabe
			try 
			{
				knotenTemp.setXKoord(Double.parseDouble(tfxeingabe.getText()));
				knotenTemp.setYKoord(Double.parseDouble(tfyeingabe.getText()));
				
				//freimachen des textfeldes
				tfxeingabe.setText("");
				tfyeingabe.setText("");
				
				//zuweisung der ID
				knotenTemp.setKnotenNummer(knotenID);

				//
				vKnoten.addElement(knotenTemp);
				
				//schieben aller knotenin den knoten Array
				int lauf=vKnoten.size();//anzahl der schleifen durchlaufe und der größe des knoten arrays
				knoten=new Knoten[lauf];
				for(int i=0; i<lauf;i++)
				{
					knoten[i]=(Knoten)vKnoten.elementAt(i);
				}
				
				
				//erhöhung der knotenID für den nächsten knoten
				knotenID=knotenID+1;
				
				//erhöhung der Anzahl der tatsächlich vorhandenen knoten
				anzahlKnoten=anzahlKnoten+1;
				
				


			}
			catch(Exception e)
			{
				System.out.println("Fehlerhafte Knoteneingabe");

			}
			System.out.println("anz knoten:"+vKnoten.size()+"  länge des vektors knoten[]:"+knoten.length);
			
			graph.setKnoten(knoten);
			graph.repaint();
			
			
		}
		if(cmd.equals("Knoten Löschen"))
		{
			
		}
		
	}
	private void eingabeKnoten(JPanel panel)
	{
		panel.removeAll();
		panel.setLayout(new GridLayout(3,2,5,5));

		panel.add(lxkoord);
		panel.add(tfxeingabe);
		panel.add(lykoord);
		panel.add(tfyeingabe);
		panel.add(fertikEK);
	}
	private void loescheKnoten(JPanel panel)
	{
		panel.removeAll();
		panel.setLayout(new GridLayout(1,3,5,5));
		panel.add(kNr);
		panel.add(tfKnotenNummer);
		panel.add(fertigLK);
	}

	
		


}

 

[Ebenius]

Ach ich hab's nicht ausprobiert. In's Blaue geraten: Hilft es, wenn Du in paintComponent(...) am Ende das da sagst?:

finally {
  g.translate(-200,-300);
}

 

[Landei]

Yo, schließe mich meinem Vorredner an:
Entweder solche Änderungen (Transformationen, Rendering Hints...) wieder zurücksetzen, oder mit tempG = g.createGraphics eine Kopie beschaffen, in selbige malen und am Ende mit tempG.dispose wieder freigeben.

 

[JohannV]

guten morgen.

mit translate hat das nix zu tuhn.
den anderen vorschlag verstehe ich nicht ganz.

wo und wie mache ich mir ein tempG=g.getGraphics();

 

[Ebenius]

Ganz sicher muss man die Translation am Ende der paintComponent()-Methode wieder rückgängig machen. Haste's probiert?

EDIT: Wenn Du den anderen Vorschlag nicht verstehst, dann glaube ich nicht, dass Du Dir sicher sein solltest, dass es mit translate nix zu tun hat!

 

[Guest]

das mit translate hat ich ausprobiert, wenn ich das garnicht im code aufnehme hab ich auch das punk springen!

programme schreib ich nicht jeden tag, ich hatte gehofft hier konkrete hilfe zu finden.

vorschlag 2 hatte ich mir so vorgestelllt.

	public void paintComponent(Graphics g)
	{
		super.paintComponent(g);
		Graphics2D g2=(Graphics2D)g;
		//g2.translate(200, 300);
		Graphics2D tempG=(Graphics2D)g2.create();
		tempG.clearRect(0, 0, 500, 600);
			/**g2.setColor(new Color(255,0,255));
			for(int j =0;j<anzahlStaebe;j++)
			{
				g2.drawLine((int)stab[j].getKnoten1().getXKoord(),(int)stab[j].getKnoten1().getYKoord(),(int) stab[j].getKnoten2().getXKoord(),(int)stab[j].getKnoten2().getYKoord());
			}
			*/
			g2.setColor(new Color(123,255,200));
			for(int i=0; i<anzahlKnoten; i++)
			{
				System.out.println("in klasse knoten:"+i);
				tempG.fillOval((int)knoten[i].getXKoord(), (int)knoten[i].getYKoord(), 10, 10);
			}
			
		tempG.dispose();
		g=tempG;

				

	}

 

[Ebenius]

Okay. Wenn rücktranslaieren nix bringt, dann liegt's wahrscheinlich nicht an paintComponent(). Poste mal bitte noch StabElement und Knoten.

Ebenius

 

[johannV]

public class StabElement
{
	
	//erster knoten des stabes
	private Knoten knoten1;
	//zweiter knoten des stabes
	private Knoten knoten2;
	//ungestreckte/ungestauchte laenge des stabes
	private double ausgangsLaenge;
	//laenge des stabes nach der krafteinwirkung
	private double endLaenge;
	//querschnitt des stabes;
	private double querschnitt;
	//emodul des stabes
	private double eModul;
	//winkel des stabes im raum vom knoten 1 zu 2
	private double winkel;
	//steifigkeitsmatrix des zugstadbes
	private Matrix Kab;
	//transformationsmatritze
	private Matrix T;
	//inzidenzmatritze
	private Matrix A;
	//anzahl der gesammten knoten
	private int anzahlDerKnotenGlobal;
	//stabkoordinaten
	private double[] stabKoord;
	
	

	//
	
	
	public double[] getStabKoordinaten()
	{
		stabKoord=new double[4];
		stabKoord[0]=knoten1.getXKoord();
		stabKoord[1]=knoten1.getYKoord();
		stabKoord[2]=knoten2.getXKoord();
		stabKoord[3]=knoten2.getYKoord();
		
		return stabKoord;
	}
	public int getAnzahlDerKnotenGlobal()
	{
		return anzahlDerKnotenGlobal;
	}
	public Matrix getA()
	{
		return A;
	}
	public void ermittleInzidenzMatritzeA()
	{
		
		double[][] hilf=new double[4][anzahlDerKnotenGlobal*2];
		
		//Ux1 lokal geht auf die position knotenNummer1*2-1
		//Uy1 lokal geht auf die position knotenNummer1*2
		//die -1 ist erforderlich da der array schon sein erstes element bei 0 hat
		hilf[0][knoten1.getKnotenNummer()*2-2]=1;
		hilf[1][knoten1.getKnotenNummer()*2-1]=1;
		hilf[2][knoten2.getKnotenNummer()*2-2]=1;
		hilf[3][knoten2.getKnotenNummer()*2-1]=1;
		
		A=new Matrix(hilf);
		
	}
	public StabElement(Knoten k1, Knoten k2, double q, double e, int aKG)
	{
		knoten1=k1;
		knoten2=k2;
		querschnitt=q;
		eModul=e;
		anzahlDerKnotenGlobal=aKG;
		
		winkelErmittlung();
		ermittleStablaenge();
		kabInReferenzlage();
		ermittleTransformationsMatritze();
		ermittleInzidenzMatritzeA();
	}
	public StabElement()
	{
	
	}
	public Knoten getKnoten1()
	{
		return knoten1;
	}
	public void setKnoten1(Knoten knoten1)
	{
		this.knoten1 = knoten1;
	}
	public Knoten getKnoten2()
	{
		return knoten2;
	}
	public void setKnoten2(Knoten knoten2)
	{
		this.knoten2 = knoten2;
	}
	public double getAusgangsLaenge()
	{
		return ausgangsLaenge;
	}
	public void setAusgangsLaenge(double ausgangsLaenge)
	{
		this.ausgangsLaenge = ausgangsLaenge;
	}
	public double getEndLaenge()
	{
		return endLaenge;
	}
	public void setEndLaenge(double endLaenge)
	{
		this.endLaenge = endLaenge;
	}
	public double getQuerschnitt()
	{
		return querschnitt;
	}
	public void setQuerschnitt(double querschnitt)
	{
		this.querschnitt = querschnitt;
	}
	public double getEModul()
	{
		return eModul;
	}
	public void setEModul(double modul)
	{
		eModul = modul;
	}
	public double getWinkel()
	{
		return winkel;
	}
	public void setWinkel(double winkel)
	{
		this.winkel = winkel;
	}
	public Matrix getKab()
	{
		return Kab;
	}
	public Matrix getT()
	{
		return T;
	}
	public Matrix getTransponierteT()
	{
		return T.transpose();
	}
	public Matrix getSteifigkeitsMatrixInEinbaulage()
	{
		return T.transpose().times(Kab).times(T);
	}
	public void kabInReferenzlage()
	{
		//steifigkeitsmatrix
		double[][] werte1={{1,-1},{-1,1}};
		Kab=new Matrix(werte1);
		Kab.malWert(eModul*querschnitt/ausgangsLaenge);
	}
	public void ermittleTransformationsMatritze()
	{
		//transformationsmatrix
		//vorab mus der winkel ermittelt werden
		double[][] werte2={{Math.cos(winkel),Math.sin(winkel),0,0},{0,0,Math.cos(winkel),Math.sin(winkel)}};
		T=new Matrix(werte2);

	}
	protected void ermittleStablaenge()
	{
		double dx=knoten1.getXKoord()-knoten2.getXKoord();
		double dy=knoten1.getYKoord()-knoten2.getYKoord();
		ausgangsLaenge=Math.hypot(dx, dy);
	}
	protected void winkelErmittlung()
	{
		//berechnung des winkels Alpha
		double alpha=Math.atan((knoten2.getYKoord()-knoten1.getYKoord())/(knoten2.getXKoord()-knoten1.getXKoord()));
		
		
		//abfrage ob quadrant I oder IV
		if(knoten1.getXKoord() < knoten2.getXKoord())
		{
			winkel=alpha;
		}
		else
		{
			winkel=alpha+Math.PI;
		}
	}
	
	
}

public class Knoten
{

	//koordimate in x richtung
	private double xKoord;
	//koordinate in y richtung
	private double yKoord;
	//verschiebung in x richtung
	private double xVerschiebung;
	//verschiebung in y richtung
	private double yVerschiebung;
	//knoten koordinaten
	private double[] knotenKoord;
	
	//absolute nummer des knotens
	private int knotenNummer;

	public Knoten(double x, double y,int num)
	{
		xKoord=x;
		yKoord=y;
		knotenNummer=num;
	}
	public Knoten()
	{
		xKoord=Double.NaN;
		yKoord=Double.NaN;
		xVerschiebung=Double.NaN;
		yVerschiebung=Double.NaN;
		knotenNummer=0;		
	}
	public Knoten(double x, double y, double dx, double dy,int num)
	{
		xKoord=x;
		yKoord=y;
		xVerschiebung=dx;
		yVerschiebung=dy;
		knotenNummer=num;
		
	}
	
	public double getXKoord()
	{
		return xKoord;
	}

	public void setXKoord(double koord)
	{
		xKoord = koord;
	}

	public double getYKoord()
	{
		return yKoord;
	}

	public void setYKoord(double koord)
	{
		yKoord = koord;
	}

	public double getXVerschiebung()
	{
		return xVerschiebung;
	}

	public void setXVerschiebung(double verschiebung)
	{
		xVerschiebung = verschiebung;
	}

	public double getYVerschiebung()
	{
		return yVerschiebung;
	}

	public void setYVerschiebung(double verschiebung)
	{
		yVerschiebung = verschiebung;
	}

	public int getKnotenNummer()
	{
		return knotenNummer;
	}

	public void setKnotenNummer(int knotenNummer)
	{
		this.knotenNummer = knotenNummer;
	}
	public double[] getKnotenKoord()
	{
		knotenKoord[0]=this.getXKoord();
		knotenKoord[1]=this.getYKoord();
		return knotenKoord;
	}
	public void show()
	{
		System.out.println("Knotennummer:"+this.getKnotenNummer()+
						   "\nX Koordinate:"+this.getXKoord()+
						   "\nY Koordinate:"+this.getYKoord());
	}
}

/*************************************************************************
 *  Compilation:  javac Matrix.java
 *  Execution:    java Matrix
 *
 *  A bare-bones immutable data type for M-by-N matrices.
 *
 *************************************************************************/

final public class Matrix {
    private final int M;             // number of rows reihe
    private final int N;             // number of columns spalte
    private final double[][] data;   // M-by-N array

    // create M-by-N matrix of 0's
    public Matrix(int M, int N) {
        this.M = M;
        this.N = N;
        data = new double[M][N];
    }

    // create matrix based on 2d array
    public Matrix(double[][] data) {
        M = data.length;
        N = data[0].length;
        this.data = new double[M][N];
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                    this.data[i][j] = data[i][j];
    }

    // copy constructor
    public Matrix(Matrix A) { this(A.data); }
    public void insertValue(double w, int row, int column)
    {
    	this.data[row][column]=w;
    }

    // create and return a random M-by-N matrix with values between 0 and 1
    public static Matrix random(int M, int N) {
        Matrix A = new Matrix(M, N);
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                A.data[i][j] = Math.random();
        return A;
    }

    // create and return the N-by-N identity matrix
    public static Matrix identity(int N) {
        Matrix I = new Matrix(N, N);
        for (int i = 0; i < N; i++)
            I.data[i][i] = 1;
        return I;
    }

    // swap rows i and j
    private void swap(int i, int j) {
        double[] temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    // create and return the transpose of the invoking matrix
    //transponieren einer matrix
    public Matrix transpose() {
        Matrix A = new Matrix(N, M);
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                A.data[j][i] = this.data[i][j];
        return A;
    }

    // return C = A + B
    public Matrix plus(Matrix B) {
        Matrix A = this;
        if (B.M != A.M || B.N != A.N) throw new RuntimeException("Illegal matrix dimensions.");
        Matrix C = new Matrix(M, N);
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                C.data[i][j] = A.data[i][j] + B.data[i][j];
        return C;
    }


    // return C = A - B
    public Matrix minus(Matrix B) {
        Matrix A = this;
        if (B.M != A.M || B.N != A.N) throw new RuntimeException("Illegal matrix dimensions.");
        Matrix C = new Matrix(M, N);
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                C.data[i][j] = A.data[i][j] - B.data[i][j];
        return C;
    }

    // does A = B exactly?
    public boolean eq(Matrix B) {
        Matrix A = this;
        if (B.M != A.M || B.N != A.N) throw new RuntimeException("Illegal matrix dimensions.");
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                if (A.data[i][j] != B.data[i][j]) return false;
        return true;
    }

    // return C = A * B
    public Matrix times(Matrix B) {
        Matrix A = this;
        if (A.N != B.M) throw new RuntimeException("Illegal matrix dimensions.");
        Matrix C = new Matrix(A.M, B.N);
        for (int i = 0; i < C.M; i++)
            for (int j = 0; j < C.N; j++)
                for (int k = 0; k < A.N; k++)
                    C.data[i][j] += (A.data[i][k] * B.data[k][j]);
        return C;
    }


    // return x = A^-1 b, assuming A is square and has full rank
    public Matrix solve(Matrix rhs) {
        if (M != N || rhs.M != N || rhs.N != 1)
            throw new RuntimeException("Illegal matrix dimensions.");

        // create copies of the data
        Matrix A = new Matrix(this);
        Matrix b = new Matrix(rhs);

        // Gaussian elimination with partial pivoting
        for (int i = 0; i < N; i++) {

            // find pivot row and swap
            int max = i;
            for (int j = i + 1; j < N; j++)
                if (Math.abs(A.data[j][i]) > Math.abs(A.data[max][i]))
                    max = j;
            A.swap(i, max);
            b.swap(i, max);

            // singular
            if (A.data[i][i] == 0.0) throw new RuntimeException("Matrix is singular.");

            // pivot within b
            for (int j = i + 1; j < N; j++)
                b.data[j][0] -= b.data[i][0] * A.data[j][i] / A.data[i][i];

            // pivot within A
            for (int j = i + 1; j < N; j++) {
                double m = A.data[j][i] / A.data[i][i];
                for (int k = i+1; k < N; k++) {
                    A.data[j][k] -= A.data[i][k] * m;
                }
                A.data[j][i] = 0.0;
            }
        }

        // back substitution
        Matrix x = new Matrix(N, 1);
        for (int j = N - 1; j >= 0; j--) {
            double t = 0.0;
            for (int k = j + 1; k < N; k++)
                t += A.data[j][k] * x.data[k][0];
            x.data[j][0] = (b.data[j][0] - t) / A.data[j][j];
        }
        return x;
   
    }
    //multipliziere die matrix mit einem wert
    public void malWert(double wert)
    {
        for (int i = 0; i < M; i++)
            for (int j = 0; j < N; j++)
                    this.data[i][j] = this.data[i][j]*wert;
    		
    }

    // print matrix to standard output
    public void show() {
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) 
                System.out.printf("%9.4f \t", data[i][j]);
            System.out.println();
        }
    }
	public double[][] getData()
	{
		return data;
	}
}

 

[Ebenius]

Das Problem befindet sich in Start2DFEM.actionPerformed(...)

knotenTemp.setXKoord(Double.parseDouble(tfxeingabe.getText()));
knotenTemp.setYKoord(Double.parseDouble(tfyeingabe.getText()));

// freimachen des textfeldes
tfxeingabe.setText("");
tfyeingabe.setText("");

// zuweisung der ID
knotenTemp.setKnotenNummer(knotenID);

// 
vKnoten.addElement(knotenTemp);

Du schreibst immer wieder in die selbe Instanz "knotenTemp". Beim zweiten mal veränderst Du also die Werte in "knotenTemp" und fügst sie wieder dem vector hinzu. Dann hast Du also zweimal den Knoten im Vector, mit den neuen Koordinaten.

Klar? Hoffe es hilft, Ebenius

 

[JohannV]

:applaus: :applaus: :applaus: :applaus: :applaus: :applaus:

das war der fehler.

ich danke dir!
hier der code:

			vKnoten.addElement(new Knoten(Double.parseDouble(tfxeingabe.getText()),
											  Double.parseDouble(tfyeingabe.getText()),
											  knotenID));