Eclipse Plugin, swt Canvas Polynome zeichnen

7

7mSeni

Grünschnabel
Hallo,

ich bin gerade dabei ein eclipse plugin zu schreiben, in der ich Polynome zeichnen soll.
Dazu benutze ich ein Canvas Objekt als "zeichenfläche". Die Polynome liegen als Coeffizienten vor. Bsp: 5 + 3*x + 2*x^2 = [5, 3, 2]

Wie könnte ich das Polynom nun zeichnen? Eine funktion um die punkte des Polynoms zu berechen haben ich. Ich tue mich nur schwer mit der Umsetzung der Polynome, da ich mich mit grafik programmierung kaum auskenne.

Ich habe gesehen, dass es Klassen für CubicCurve2D gibt, aber die setzen Graphics2D Objekte voraus, Canvas bietet aber nur ein normales Graphics objekt.


Kann mir da jemand helfen, ich bin irgendwie am Ende und habe keine Idee.

Thx,
Gruss
 
Unter help.eclipse.org findest du die API-Doc zu SWT und sonstigem eclipse Krams.

Such mal nach org.eclipse.swt.graphics.GC. Das ist der Graphics-Context in SWT mit welchem du auf deinem Canvas zeichnen kannst.

Dazu implementierst du am Besten einen PaintListener auf deinem Canvas (addPaintListener). Im PaintEvent bekommst du einen gc mitgeliefert. Darauf kannst du dann z.B. drawPolyline verwenden. Einfach deine Koordinaten auf Pixel umrechnen und in ein int-Array packen.
 
Danke erstmal für deinen Tipp. Ich muss mir das später mal genauer anschaun. Aber ich glaube man kann da keine Kurven zeichnen, nur so primitive objekte.

Aber kann man das GC Objekt irgendwie in ein Graphics2D Objekt casten? Ich würde gerne auf die awt Komponenten zugreifen wollen und die Polynome mittels GerneralPath zu zeichnen.

Das codestück macht eigentlich schon genau das was ich brauche, aber ist eben unter swt/canvas nicht nutzbar? Gezeichnet wird ein Polynom: f(x) = x^2

Code: 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.CubicCurve2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import java.awt.geom.QuadCurve2D;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Main extends JPanel {

	public Main() {
	}

	public void paint(Graphics g) {
		Graphics2D g2d = (Graphics2D) g;

		AffineTransform transform = new AffineTransform();
		transform.translate(150, 150);
		transform.scale(1, -1);
		transform.scale(75, 50);
		
		int xStart = -3;
		int yStart = -3;
		
		int xEnd = 4;
		int yEnd = 3;

		g2d.setPaint(Color.lightGray);
		GeneralPath path = new GeneralPath();
		for (int i = xStart; i <= xEnd; i++) {
			path.moveTo(i, yStart);
			path.lineTo(i, yEnd);
		}
		for (int i = yStart; i <= yEnd; i++) {
			path.moveTo(xStart, i);
			path.lineTo(xEnd, i);
		}
		g2d.draw(transform.createTransformedShape(path));

		int steps = 50;
		float dx = 4.0f / steps;
		g2d.setPaint(Color.black);
		path = new GeneralPath();
		path.moveTo(xStart, valueAt(xStart));
		for (float x = xStart + dx; x <= xEnd; x += dx)
			path.lineTo(x, valueAt(x));
		g2d.draw(transform.createTransformedShape(path));

	}

	private float valueAt(float x) {
		return x * x;
	}

	public static void main(String[] args) {
		JFrame frame = new JFrame();
		frame.getContentPane().add(new Main());

		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(600, 600);
		frame.setVisible(true);
	}
}
 
Versuchs mit SWT_AWT... damit kannst du AWT Komponenten in SWT Komponenten zeichnen, (ab Eclipse 3.0, wenn ich's recht im Kopf hab).

Die SWT Composite, die das ganze wrapt muss aber vom Stil SWT.EMBEDDED sein und ich warne die jetzt schon mal vor, dass du dir einige Male die Haare ausreissen wirst, bevor alles so klappt wie's soll :)

Als Beispiel:
Java: 
package org.cookbook.ch09;

import java.awt.event.*;

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.awt.SWT_AWT;

public class SwingAWTClass {

    public static void main(String[] args) {
        final Display display = new Display( );
        final Shell shell = new Shell(display);
        shell.setText("Using Swing and AWT");
        shell.setSize(350, 280);
        
        Composite composite = new Composite(shell, SWT.EMBEDDED);
        composite.setBounds(20, 20, 300, 200);
        composite.setLayout(new RowLayout( ));

        java.awt.Frame frame = SWT_AWT.new_Frame(composite);
        java.awt.Panel panel = new java.awt.Panel( );
        frame.add(panel);

        final javax.swing.JButton button = new javax.swing.JButton("Click Me");
        final javax.swing.JTextField text = new javax.swing.JTextField(20);

        panel.add(button);
        panel.add(text);

        button.addActionListener(new ActionListener( ) {
            public void actionPerformed(ActionEvent event) {
                text.setText("Yep, it works.");
            }
        });
        
        shell.open( );
        while(!shell.isDisposed( )) {
            if (!display.readAndDispatch( )) display.sleep( );
        }
        display.dispose( );
    }
}

Der Code ist von hier weil ich gerade zu faul bin, ein Beispiel zu schreiben ;)

EDIT: Ach ja, die Lösung von zeja ist um Längen schöner, die hier ist nur, falls du dich nicht durchringen kannst, auf den AWT-Code zu verzichten...
 
Zuletzt bearbeitet:
Ok, ich werde es mal versuchen, aber es muss doch eine Möglichkeit geben in swt komplexere grafiken zu zeichnen als nur linien und kreise.

Es muss doch ein gegenstück in SWT zum Graphics2D geben?
 
Was ich nicht wirklich verstehe ist, warum du um einen Graphen zu zeichnen mehr als Punkte und Linien brauchst? Eine grafische Darstellung eines Graphen ist ja nichts weiter als eine Sammlung von Punkten,,,?

Such mal nach org.eclipse.swt.graphics.GC. Das ist der Graphics-Context in SWT mit welchem du auf deinem Canvas zeichnen kannst.

Dazu implementierst du am Besten einen PaintListener auf deinem Canvas (addPaintListener). Im PaintEvent bekommst du einen gc mitgeliefert. Darauf kannst du dann z.B. drawPolyline verwenden. Einfach deine Koordinaten auf Pixel umrechnen und in ein int-Array packen.
Zum Vergrößern anklicken....
 
Zuletzt bearbeitet:
Das Problem ist dass ich eigentlich zwar beliebig viele punkte berechen kann, aber nur wenige punkte brauche für die darstellung.

Will sagen dass ich für einen Punkt ca. 50 oder 70 pixel benutzen will, also eine art skalierung des graphen.

Ich weiss eben nicht wie ich die berechneten punkte in pixel umwandeln soll.

Gruss
 
Umwandeln? - Ein Punkt = eine x- und eine y-Koordinate... ein Pixel = eine x- und eine y-Koordniate...? und wenn du einen fetten Punkt willst, zeichnest du stattdessen einen ausgefüllten Kreis mit Radius von z.B. 20px...

Am einfachsten wäre ja immer noch, wie zeja gesagt hat, gc.drawPolyLine(int[] xy), da übergibst du in einem int[] deine errechneten Punkte und der malt dir zwischen denen deine Linie... da kannst du auch gc.setLineWidth(int width) oder sowas setzten, dann ist die Linie auch dick.

Schau dir das ganze hier mal an, da wird das recht schön erklärt.

Gruss
.bile
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück