Funktionen Plotter - Klassen/Methoden/Funktionen

[TomFader]

Hi,

ich schreib seit längerem an einem Funktionen Plotter,
jetzt hätte ich ein paar Fragen und auch gern eure Meinung was dass umsetzen der Sachen angeht.

1) Ich habe einen Button der mir einen Thread spawnt der dann meine Funktion zeichnen soll, soweit so gut und der Thread funktioniert ja, leider scheiterts beim zeichnen der Pixel, also gezeichnet wird halt Pixel für Pixel, irgenwie hab ich da was vermurgst oder nen denk fehler. Muss ich mir da ne Methode/Funktion fürs Rechteck schreiben die dass für mich macht damit ich es an anderer Stele verwenden kann?


2) Ich zeichne ja ein Koordinatensystem, soll ich dass als Funktion fürs Rechteck implementieren oder gleich beim initialisieren des Rechtecks zeichnen? Was ist sauberer sinnvoller?


3) Ich hätte gern eine Art Skala auf der Leiste, wie schaff ich es die am geschicktesten auszugeben also k.a. alle 5 Pixel nen 4 pixle breite linie und alle 5 pixel dann ne 8 breite Linie jeweils mit text drüber. Ich dachte da an eine Schleife, gibts vlt. was günstigeres? Weil bei großen Zahlen wird sich ja der Text verlaufen.


4) Ich will dass der User Funktionen der Form x * (x + sin(x)) eingibt und die dann durch mein Tool geparst werden und er gleichzeitig ne Mathematische Formel generiert mit der ich die Funktion berechnen kann, wobei natürlich alle Rechenregeln berücksichtigt werden sollen. Wie geh ich dieses Problem am besten bzw. geschicktesten an?

Ich hätte gemeint ich geh von zB.: rechts nach links und parse halt der Reihe nach die mathematik durch bis ich zu einer Klammer komme die wird übernommen für sin(x) müsst ich dann halt dass äquivalent für den Compiler rein schreiben und dann halt die klammer wieder schließen. ?

package funktion;

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Dimension;
import javax.swing.JTextArea;
import java.awt.Rectangle;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import java.awt.*;
import javax.swing.JTextField;
//import java.awt.GridBagLayout;

/**
 *@Author    	Thomas Jan Rychlik
 *@version		1.0 Beta (private use only)
 *@description  Programm zum anzeigen von mathematischen Funktionen
 *@since		April-1st-2008
 */

public class gui extends JFrame{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public JPanel jPanel = null;
	public JLabel jLabel = null;
	public JTextField jTextField = null;
	public JButton jButton = null;
	public JProgressBar jProgressBar = null;
	public JLabel jLabel1 = null;
	public JLabel jLabel2 = null;
	public JTextArea jTextArea = null;
	public Rechteck AnzeigeRechteck = null;
	/**
	 * This method initializes 
	 * 
	 */
	public gui() {
		super();
		initialize();
	}



	/**
	 * This method initializes this
	 * 
	 */
	private void initialize() {
		this.setSize(new Dimension(500, 400));
		//should be accessed in a static way ???
		JFrame.setDefaultLookAndFeelDecorated(true);
		this.setTitle("Graphische Funktionen Zeichner");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setContentPane(getJPanel());

	}



	/**
	 * This method initializes jPanel	
	 * 	
	 * @return javax.swing.JPanel	
	 */
	private JPanel getJPanel() {
		if (jPanel == null) {
			jLabel2 = new JLabel();
			jLabel2.setBounds(new Rectangle(334, 345, 39, 16));
			jLabel2.setText("Ready");
			jLabel1 = new JLabel();
			jLabel1.setBounds(new Rectangle(284, 345, 47, 16));
			jLabel1.setText("Status:");
			jLabel = new JLabel();
			jLabel.setBounds(new Rectangle(15, 180, 91, 17));
			jLabel.setText("Funktion f(x)= ");
			jPanel = new JPanel();
			jPanel.setLayout(null);
			jPanel.add(jLabel, null);
			jPanel.add(getJTextField(), null);
			jPanel.add(getJButton(), null);
			jPanel.add(getJProgressBar(), null);
			jPanel.add(jLabel1, null);
			jPanel.add(jLabel2, null);
			jPanel.add(getJTextArea(), null);
			Rechteck AnzeigeRechteck = new Rechteck();
			jPanel.add(AnzeigeRechteck);
			AnzeigeRechteck.setBounds(new Rectangle(120, 15, 260, 150));



		}
		return jPanel;
	}



	/**
	 * This method initializes jTextField	
	 * 	
	 * @return javax.swing.JTextField	
	 */
	private JTextField getJTextField() {
		if (jTextField == null) {
			jTextField = new JTextField();
			jTextField.setBounds(new Rectangle(105, 180, 286, 16));
		}
		return jTextField;
	}



	/**
	 * This method initializes jButton	
	 * 	
	 * @return javax.swing.JButton	
	 */
	private JButton getJButton() {
		if (jButton == null) {
			jButton = new JButton();
			jButton.setBounds(new Rectangle(405, 180, 76, 16));
			jButton.setText("Start");
			jButton.addActionListener(new java.awt.event.ActionListener() {
				public void actionPerformed(java.awt.event.ActionEvent e) {
					jButton.setEnabled(false);
					new Thread( new Runnable()
					{
						public void run()
						{
							for ( int i = 1; i <= 100; i++ )
							{
								try { Thread.sleep( 100 ); } catch ( InterruptedException e ) { }
								final int j = i;

								SwingUtilities.invokeLater( new Runnable()
								{
									public void run()
									{
										jProgressBar.setValue(j);
										jLabel2.setText(j + "%");
										//hier will ich dann meine berechnete funktion Pixel für Pixel zeichnen
										AnzeigeRechteck.drawOval(50, 50, 0, 0);
										//g.drawOval(50, 50, 0, 0);
										if (j==100)
										{
											jButton.setEnabled(true);
											jLabel2.setText("");
										}
									}
									
									
								});

							}
							
						}
						
					}).start();

				}
			});


		}
		return jButton;
	}



	/**
	 * This method initializes jProgressBar	
	 * 	
	 * @return javax.swing.JProgressBar	
	 */
	private JProgressBar getJProgressBar() {
		if (jProgressBar == null) {
			jProgressBar = new JProgressBar();
			jProgressBar.setBounds(new Rectangle(375, 345, 106, 16));
		}
		return jProgressBar;
	}



	/**
	 * This method initializes jTextArea	
	 * 	
	 * @return javax.swing.JTextArea	
	 */
	private JTextArea getJTextArea() {
		if (jTextArea == null) {
			jTextArea = new JTextArea();
			jTextArea.setBounds(new Rectangle(15, 210, 466, 121));
			jTextArea.setText("Funktionszeichenlog:");
		}
		return jTextArea;
	}



	public class Rechteck extends JComponent{

		/**
		 * 
		 */
		private static final long serialVersionUID = -3673149918506320972L;
		int x=0, y=0;
		int width=260, height=150;

		public void paintComponent(Graphics g){
			super.paintComponent(g);
			g.setColor(Color.black);
			g.fillRect(x, y, width, height);
			//Farbe setzen
			//Koordinatensystem wird in rot gezeichnet
			g.setColor(Color.red);
			//Zeichnen der Achsen
			g.drawLine(0, 75, 260, 75);
			g.drawLine(130, 0, 130, 150);
			//setzen der Beschriftungen der Achsen
			g.drawString("y", 140, 15);
			g.drawString("x", 250, 70);
			g.drawString("-y", 140, 140);
			g.drawString("-x", 10, 70);
			//pixel zeichnen
			g.drawOval(50, 50, 0, 0);
			//g.drawString("x", 10, 15);			
		}

		public Dimension getPreferredSize(){
			return new Dimension(100, 100);
		}

	}


	
	public static void main(String[] args) {
		gui gui = new gui();
		//createAndShowGUI();
		gui.setVisible(true);//gui.show(); ist deprected seit JDK 1.5



	}
}

[/img]

 

[Gelöschtes Mitglied 5909]

das ist weitaus schwieriger als du dir das vorstellst
schau dir das mal an

http://www.java-forum.org/de/viewtopic.php?t=13378

 

[TomFader]

Ok gut, dass mit dem Parser check ich jetzt, aber hat vlt. noch wer nen Tip wie ich dass ganze dann anzeigen lassen kann, irgenwie hab ich mit dem ganzen Klassen Methoden ramsch scheinbar ein problem

 

[TomFader]

Kann mir vlt. doch noch wer erklären wie ich meinen Thread prozess dazu bringe meine Funktion an zu zeigen? Wäre für jede Idee dankbar.

 

[TomFader]

hmm nächste versuch von mir:

public class Rechteck extends JComponent{

		/**
		 * 
		 */
		private static final long serialVersionUID = -3673149918506320972L;
		int x=0, y=0;
		int width=260, height=150;

		public void paintComponent(Graphics g){
			super.paintComponent(g);
			g.setColor(Color.black);
			g.fillRect(x, y, width, height);
			//Farbe setzen
			//Koordinatensystem wird in rot gezeichnet
			g.setColor(Color.red);
			//Zeichnen der Achsen
			g.drawLine(0, 75, 260, 75);
			g.drawLine(130, 0, 130, 150);
			//setzen der Beschriftungen der Achsen
			g.drawString("y", 140, 15);
			g.drawString("x", 250, 70);
			g.drawString("-y", 140, 140);
			g.drawString("-x", 10, 70);
			//pixel zeichnen
			g.setColor(Color.green);
			g.drawOval(50, 50, 0, 0);
			//g.drawString("x", 10, 15);
			g.paintpixel(30, 40);
		}
		
		
		public void paintpixel(int x, int y){
			Graphics g = new Graphics();
			super.paintComponent(g);
			setColor(Color.blue);
			drawOval(x, y, 0, 0);
			repaint();
		}
		
		public Dimension getPreferredSize(){
			return new Dimension(100, 100);
		}

	}

Ich bin langsam echt am verzweifeln!

 

[Marco13]

hmm nächste versuch von mir:

...
			Graphics g = new Graphics();
			super.paintComponent(g);
			setColor(Color.blue);
			drawOval(x, y, 0, 0);
			repaint();

Ich bin langsam echt am verzweifeln!

Ich auch, wenn ich solchen Code sehe Beschreib' was du machen willst - und zwar präzise (also nicht "Ich will eine Funktion zeichnen. (<-Punkt)"). Was soll "Rechteck" sein oder tun? Und was hat irgendein Thread da verloren?

 

[TomFader]

Dass Rechteck dass ich ausgebe dient mir als Koordinatensystem
Im Endeffekt will ich in diesem System dann meine Funktionen zeichnen, hierzu hab ich schon den passenden Parser geschrieben, es geht jetzt nur darum das Ergebnis dass der Parser anhand der Funktionen berechnet (dass ist dann die x Koordinate) auf eben dieses Rechteck zu klatschen, mittels drawOval(x, y); leider schaff ich es nicht eben dieses drawOval ein zu bauen.

 

[Marco13]

Es gibt - wie immer - (viele) verchiedene Möglichkeiten, das zu machen. Das Zeichnen des Koordinatensystems könnte (wie du es schon machst) von einer Component erledigt werde. Diese Component müßte zusätzlich noch die aktuelle Funktion zeichnen. (Und das ist ja - wenn ich das richtig verstanden habe - das Problem).

Man könnte jetzt sowas machen wie

class Rechteck extends JComponent
{
    private FunktionswertLieferer funktionswertLieferer = ...

    private int yScreen[] = new int[width von dieser component];

    private void aktualisiereFunktionswerte()
    {
        yScreen = new int[width von dieser component];

        for (int xs = 0; xs<maxX; xs++)
        {
            float xf = berechneWeltX(xs);
            float yf = funktionswertLieferer.berechneY(xf);
            int ys = berechneScreenY(yf);
            yScreen[xs] = ys;
       }
    }
 
    public void paintComponent(Graphics g)
    {
         super.paintComponent(g); 
         //Koordinatensystem wird in rot gezeichnet 
         ....

        // Zeichne die vorher berechnete funktion
        for (int xs = 0; xs<maxX; xs++)
        {
            int ys = yScreen[xs];
            g.drawLine(xs,ys,xs,ys);
        }

    }
}

Die Methode "aktualisiereFuntkionswerte" muss dann jedes mal aufgerufen werden, wenn die Funktion oder das lokale Koordinatensystem oder die Größe der Component sich ändern.

 

[Marco13]

BTW: Die Variablennamen sind unfug - jButton, jLabel1, jLabel2, jLabel412334, ... und die Sache mit den Threads ist auch nicht so optimal.... aber da wird sich an der Struktur sowieseo noch einiges ändern........

 

[TomFader]

Ich hätte noch ne Frage, und zwar würd ich gern in einem Thread aus einer double Variable eine Int variable machen.
Es müsste eigentlich mit int x = intValue(Math.sin(j)); gehen, aber leider ist im Thread intValue nicht implementiert? Kann ich da was machen, ausser die Methode implementieren? Ich hätte jetzt keinen Plan wie ich ne Methode schreibe die aus double int macht.

private JButton getJButton() {
		if (jButton == null) {
			jButton = new JButton();
			jButton.setBounds(new Rectangle(405, 180, 76, 16));
			jButton.setText("Start");
			jButton.addActionListener(new java.awt.event.ActionListener() {
				public void actionPerformed(java.awt.event.ActionEvent e) {
					jButton.setEnabled(false);
					new Thread( new Runnable()
					{
						public void run()
						{
							for ( int i = 1; i <= 100; i++ )
							{
								try { Thread.sleep( 100 ); } catch ( InterruptedException e ) { }
								final int j = i;
								
								SwingUtilities.invokeLater( new Runnable()
								{
									public void run()
									{
										 
										jProgressBar.setValue(j);
										//int x;
										//String s = new String("e*(e-pi)*pi");
										
										//x = (parser.parse( s ));
										jTextArea.setText("");

										//x= intValue(parser.parse( s ));
										
										// kann kein intValue in runable finden
										int x = intValue(Math.sin(j));
										//Ich schieß meine Koordinaten aufs Rechteck
										AnzeigeRechteck.addGraphCoords(j, x  );
										jLabel2.setText(j + "%");
										//repainten des jPanel
										jPanel.repaint();								
										if (j==100)
										{
											jButton.setEnabled(true);
											jLabel2.setText("");
										}
									}
									
									
								});

							}
							
						}
						
					}).start();

				}
			});


		}
		return jButton;

 

[TomFader]

BTW: Die Variablennamen sind unfug - jButton, jLabel1, jLabel2, jLabel412334, ... und die Sache mit den Threads ist auch nicht so optimal.... aber da wird sich an der Struktur sowieseo noch einiges ändern........

Zuerst sollte mal das Programm funktionieren, und dann kann man an den Feinheiten arbeiten, denk ich.
Andererseits wäre es für die Zukunft gescheit, sinnvolle aussagekröftige Bezeichnungen usw. zu vergeben.

 

[Marco13]

int i = (int)doubleWert; :roll:

Die Variablen umbennenen zu wollen, sobald du nicht mehr weißt, was sie bedeuten, könnte sich als ungeschickt herausstellen....

EDIT: Aber du hast recht: Die Variablennamen sind im Moment das geringste Problem.

 

[TomFader]

Hehe,

erst einmal dankeschön für die rasche Hilfe,
so nun hab ich folgendes Problem, wenn ich es so wie du gesagt hast mach ( j wird immer ++, also hochgezählt)
sprich:

double s = (Math.sin(j));
int y = (int)s;
AnzeigeRechteck.addGraphCoords(j, y  );

dann bekomm ich folgende Ausgabe:

adding x : 1, y : 0
adding x : 2, y : 0
adding x : 3, y : 0
adding x : 4, y : 0
adding x : 5, y : 0

sprich mein ywert ist immer Null *grml* er zeichnet dass ganze auch ganz hübsch nämlich ne wunderschöne null linie *g*
Kann es sein dass er den Wert immer abrundet? Oder Hast vlt. ne vermutung woran dass liegt?


Übrigens ist eins meiner ersteren größeren Projekte, deswegen auch noch eher unerfahren mit dem ganzen Zeug.

 

[Marco13]

Übrigens ist eins meiner ersteren größeren Projekte, deswegen auch noch eher unerfahren mit dem ganzen Zeug.

Kann es sein, dass das hervorgehobene Wort dort nicht hingehört? :wink:

Egal, was und wie du rechnest: Bei sin(x) wird IMMER ein Wert rauskommen, der zwischen -1 und 1 liegt. Und wenn man einen Wert wie 0.999999 in einen int umwandelt, kommt da eben 0 raus. Selbst wenn 1 rauskommen würde, würde die Linie nicht wie eine Kurve aussehen, sondern eher wie eine ... fisselige, waagerechte Linie.

Mein Nachtrag oben ("Die Variablennamen sind im Moment das geringste Problem.") bezog sich nicht zuletzt darauf. Ich hatte das mit dem "lokalen Koordinatensystem" ja schon erwähnt - und im Code unmißverständlich angedeutet:

        for (int xs = 0; xs<maxX; xs++)
        {
            float xf = berechneWeltX(xs);
            float yf = funktionswertLieferer.berechneY(xf);
            int ys = berechneScreenY(yf);
            yScreen[xs] = ys;
       }

Man hat eine Component mit Pixelkoordinaten 0,0 bis 100,100. Was man plotten will, ist aber eine Funktion von 0,-1 bis PI,1. Wenn die Funktion die Component ausfüllen soll, muss man - wie oben angedeutet - umrechnen zwischen den Screen-Koordinaten (die immer ints sind, und den "Welt"-Koordinaten (die ggf. als double vorliegen).

[/quote]