Funktion zeichnen

[Ocean-Driver]

Nabend,


Ich wollte eine Funktion bestehend aus X -und Y-Punkten zeichnen.

Um dies möglichst genau zu machen wollte ich mit Double-Werten arbeiten, aber da ein Bildschirm ja nur aus ganzen Pixeln besteht.. Wie kann ich die Funktion genau zeichnen?

Es reicht im Bereich +/-10 - An Punkten kann ich belibieg viele erzeugen, aber viele machen ja nicht sein, bei ganzen Pixeln?

Wie krieg ich das hin?


Wenn ich meinetwegen solche Arrays hätte:

double xPoints = {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0}
double yPoints = {0.5,1.0,1.9,2.1,2.1,2.9,3.8,4,9,6.1,7.0}

und wollte diese Zeichnen.

Dazu hab ich mir folgende Klasse angelegt:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package draw;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.Toolkit;
import java.awt.image.ImageObserver;
import java.text.AttributedCharacterIterator;
import javax.swing.JFrame;

/**
 *
 * @author Ocean-Driver
 */
public class FunctionDraw extends JFrame{
    
    int[] xPoints;
    int[] yPoints;
        
    public FunctionDraw(double[] x, double[] y)
    {
        
        setSize(Toolkit.getDefaultToolkit().getScreenSize());
        
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        
            xPoints = new int[x.length];
            yPoints = new int[y.length];
            
        for(int i=0; i < x.length; i++)
        {
        xPoints[i] = (int) (x[i] / super.getSize().width);
        yPoints[i] = (int) (x[i] / super.getSize().height);
        }
            
            
        
    }
    
    
    public void paint()
    {
        new Graphics() {

            @Override
            public Graphics create() {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void translate(int x, int y) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public Color getColor() {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void setColor(Color c) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void setPaintMode() {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void setXORMode(Color c1) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public Font getFont() {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void setFont(Font font) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public FontMetrics getFontMetrics(Font f) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public Rectangle getClipBounds() {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void clipRect(int x, int y, int width, int height) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void setClip(int x, int y, int width, int height) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public Shape getClip() {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void setClip(Shape clip) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void copyArea(int x, int y, int width, int height, int dx, int dy) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawLine(int x1, int y1, int x2, int y2) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void fillRect(int x, int y, int width, int height) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void clearRect(int x, int y, int width, int height) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawOval(int x, int y, int width, int height) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void fillOval(int x, int y, int width, int height) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawString(String str, int x, int y) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void drawString(AttributedCharacterIterator iterator, int x, int y) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void dispose() {
                throw new UnsupportedOperationException("Not supported yet.");
            }
        }.drawPolyline(xPoints, yPoints, WIDTH);
    }
    

}

Von dieser Klasse erzeuge ich ein objekt, mache es sichtbar, und rufe dann die paint-methode auf.

Meine Punkte sehen meist so aus. Wie muss ich diese noch zurechtstuzen um die Funktion zu zeichnen?


Formel: x * 0.5
X-Punkt: 0.14974999999999453 Y-Punkt: 0.07487499999999726
X-Punkt: 0.14979999999999452 Y-Punkt: 0.07489999999999726
X-Punkt: 0.14984999999999452 Y-Punkt: 0.07492499999999726
X-Punkt: 0.1498999999999945 Y-Punkt: 0.07494999999999725


Hier mal der Sourcecode zum erzeugen der Punkte.

String a = "x * 0.5";
        
        
        double[] xPoints = new double[1000];
        double[] yPoints = new double[1000];
        
        xPoints[0] = 0.1;
        yPoints[0] = 0.05;
        
        for(int i=1; i < xPoints.length; i++)
        {
            xPoints[i] = xPoints[i-1] + 0.00005;
            yPoints[i] = MathParser.getInstance().ParseFunction(a.replaceAll("x",String.valueOf(xPoints[i])));
            
            System.out.print("X-Punkt: " + xPoints[i]);
            System.out.println(" Y-Punkt: " + yPoints[i]);
        }

 

[LordLuzifer]

Ohne unfreundlich wirken zu wollen: hast du irgendeine Ahnung vom Zeichnen mit Java2D?
Ich habe bisher noch niemals jemanden gesehen, der sich ein Graphics-Objekt instanziert ... und funktionieren wird das garantiert nicht ...
Also: erstmal zeichnen lernen!
Die Javainsel kann dir das erklären oder auch ein anderes Buch, außerdem haben wir hier schöne Tutorials.
Dann kannst du das Ganze nochmal probieren, zudem es nicht sonderlich schwer ist.

 

[Ocean-Driver]

Hi,


Ok, danke ich hab mich mal eingelesen.

Also ich hab mir jetzt mein eigenes DrawPanel gebaut:

package draw;
import java.awt.Graphics;
import javax.swing.JPanel;


public class FunctionDraw extends JPanel{
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawString("HALLO MAJA!", WIDTH / 2, WIDTH / 2);
        System.out.println("PaintComponent aufgerufen!");   
    }
    
}

Davon hab ich ein Objekt erzeugt und das einem JDialog hinzugefügt. Allerdings wird beim varrieren des Fensters die Methode paintComponent(); nicht aufgerufen, ebenfalls nicht, wenn ich direkt repaint(); aufrufe!

            FunktionZeichnen.add(FDraw);
            FunktionZeichnen.setTitle("Funktion zeichnen");
            FunktionZeichnen.setSize(1680/2,1050/2);
            FunktionZeichnen.setVisible(true);
            //FunktionZeichnen.setResizable(false);
            
            FunktionZeichnen.repaint();

Was mache ich falsch?


Danke für die Hilfe.

 

[Marco13]

Oooommmmm ..... Ooommmmm..... Meine Kristallkugel sagt mir .... Ooooommmm.... Du hast einen ... ooommmm... 21 Zoll Widescreen-LCD-Bildschirm! :wink:

Wie auch immer: Welches Layout verwendest du dann für deinen "FunktionZeichnen"?

FunktionZeichnen.setLayout(new GridLayout(1,1));
FunktionZeichnen.add(FDraw);

!?

 

[Ocean-Driver]

22 Zoll

Wenn man den Wald voll lauter Bäumen nicht sieht - thx hatte kein Layout. Habs GribLayout eingestellt.

Wie gehe ich denn am besten wegen der Koordinaten vor? Verschieb ich den Ursprung in die Mitte des Bildschirms?

Oder wie kann ich die Punkte der Funktion am besten in die richtigen ins umwandeln?




//Edit: Ich hab das Koordinatensystem soweit jetzt gezeichnet, aber die Y-Achse ist falsch herum?!
wie kann ich das umbauen?



Hier mal meine Klasse:

public class FunctionDraw extends JPanel{
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.translate(super.getSize().width / 2, super.getSize().height / 2);

        g.drawLine(-400,0,400,0); // X-Achse
        g.drawLine(0,-280,0,280);  // Y-Achse
        
        g.drawString(" X: 150| Y: 150 (1. Quadrant)", 150,150);
        g.drawString(" X:-150| Y: 150 (2. Quadrant)",-150,150);
        g.drawString(" X:-150| Y: -150(3. Quadrant)",-150,-150);
        g.drawString(" X: 150| Y: -150(4. Quadrant)",150,-150);

        g.drawString("Nullpunkt", 0,0);
        }
    
}

Hier mal nen Screenshot:

Wie kann ich die Y-Achse umdrehen?

 

[Quaxli]

Wie kann ich die Y-Achse umdrehen?

y *= -1;

?

 

[Quaxli]

Hier noch mal ein Beispiel:

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

public class FunctionDraw extends JPanel {

	private static final long	serialVersionUID	= 1L;
	JFrame frame;
	
	public static void main(String[] args) {
		new FunctionDraw();
	}
	
	public FunctionDraw() {
		frame = new JFrame("test");
    frame.setLocation(100,100);
    frame.setSize(100,100);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.add(this);   
    
    frame.setVisible(true);
	}

	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.translate(super.getSize().width / 2, super.getSize().height / 2);

		g.drawLine(-50, 0, 50, 0); // X-Achse
		g.drawLine(0, -50, 0, 50); // Y-Achse

		g.setColor(Color.RED);
		for(int x=-50;x<50;x++){
      int y = 2*x + 10;
      y *= -1;
			g.fillRect(x, y, 2, 2);
		}
		
		
		
	}

}

 

[Ocean-Driver]

schon, aber ist es normal in swing das negative y-werte oberhalb von positiven liegen?


Außerdem weiß ich nicht wie ich die Punkte von einer Funktion am besten zeichnen soll?Wenn ich die Punkte nah nebeneinander lege, ist das Bild extrem klein! Kann ich irgendwie das Bild vergrößern.

Das Ziel ist es, eine Funktion so wie in GeoGebra zeichnen zu können.

 

[lohr]

Du könntest dir zuerst alle Punkte ausrechnen, diese in einem Array oder Liste speichern, dort nach MIN und MAX suchen.

Dann erst das Koordinatenfeld dementsprechend zeichnen und die Kurven (aneinandergereihte Punkte) auch zeichnen.

Jop Y-Werte gehen von oben nach unten.

 

[Gast]

lohr: Warum wurde das so gewählt? Ich mein, in der Mathematik ist der Bereich der Y-Achse, der über der X-Achse liegt doch positiv!

Ich habe bereits einige Punkte in zwei Arrays (einmal X, einmal Y)

Doch, das sind ja double-Werte, da die Koordinaten einer Funktion ja ziemlich Krum sind. Runden = ist ja ziemlich ungenau von 1,5 auf 2 zu runden. Ich hab die Daten mal mit 100 mal genommen und dann umgewandelt.. dann sind die graphen zwar entsprechend groß, aber nicht gerade richtig.

 

[Ocean-Driver]

Ok, der Gast war ich.

Um mal einen Vergleich zu geben, hier einmal die Funktion in Geogebra:

die Funktion, wenn ich sie zeichnen lasse:

Dann erst das Koordinatenfeld dementsprechend zeichnen und die Kurven (aneinandergereihte Punkte) auch zeichnen.

Wie kann ich die größe des Koordinatenfeldes denn überhaupt bestimmen?

 

[Marco13]

Vielleicht hilft das Wort "Dreisatz"?

// Das Intervall, das dargestellt werden soll:
double xMinWorld = ...
double xMaxWorld = ...
double dxWorld = xMaxWorld-xMinWorld;

// Der Platz auf dem Bildschirm
int xMinScreen = 0;
int xMaxScreen = panel.getWidth();
int dxScreen = xMaxScreen-xMinScreen;

for (alle x-Werte xWorld)
{
    double xRelWorld = (xWorld - xMinWorld) / dxWorld; // Wert zwischen 0.0 und 1.0
    int xScreen = xMinScreen + (int)(xRelWorld * dxScreen); // Wert zwischen 0 und panel.getWidth();
    ....
}