AWT Graphics2D mehrmals aufrufen

[Neve]

Hallo zusammen,

ich zeichne auf der Graphics eines JPanels viele nebeneinander liegende Objekte, was soweit auch funktioniert. Die entsprechenden Parameter werden aus einem Array entnommen, welches dieser Klasse übergeben wurde. Jetzt möchte ich aber von der main-class aus in einer for-Schleife für mehrere (unterschiedliche) Arrays solche Graphic-JPanels erstellen und in das Main-JPanel einfügen. Jedes Array wird korrekt übergeben, jedoch im Endeffekt immer nur das letzte Array mehrmals hintereinander gezeichnet. Wo liegt mein Fehler? Bin noch Anfänger und dankbar für jeden Tip. ???:L

public class Sphere extends JPanel{
		.....	
	public Sphere(int array[]){	
			setPreferredSize(new Dimension(WIDTH,HEIGHT));
			setOpaque(false);		
			this.array = array;			
			startX = 10;	
	}	
	
	private void createSphere(Graphics2D g2d, int i){					
		if (array[i] == 0){	
			diameter = MIN_DIAMETER;
			color1 = WHITE;
			color2 = GRAY;
		}
		else {
			diameter = MIN_DIAMETER + array[i]*FACTOR;
			color1 = BLUE1;
			color2 = BLUE2;
		}
		
		startY = HEIGHT/2-(int)diameter/2;		
		Point2D start = new Point2D.Double(startX, startY);
		Point2D end = new Point2D.Double(startX+diameter/2, startY+diameter/2);		
		Ellipse2D.Double sphere = new Ellipse2D.Double(startX, startY, diameter, diameter);		
		GradientPaint gp = new GradientPaint(start, color1, end, color2);						
		g2d.setPaint(gp);
		g2d.fill(sphere);			
		startX = startX + (int)diameter;		
	}	
	
	protected void paintComponent(Graphics g){
		
		super.paintComponent(g);		
		Graphics2D g2d = (Graphics2D)g;
		RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		g2d.setRenderingHints(renderHints);

		for (int i=0; i < array.length; i++){
			createSphere(g2d, i);		
		}
		
		startX = 10;
		g2d.dispose();
		}		
}

Aufruf in der Main-Class:

	private void start(){	
		quantity = 3;
		
		for (int i=0; i<quantity; i++){
			
			JPanel panel = new JPanel();
			panel.setOpaque(false);
			panel.setLayout(new FlowLayout(FlowLayout.LEFT));
			
			JPanel cat_panel = addCategory(category[i]);
			panel.add(cat_panel);
			
			JPanel vector_panel = addSphericalVector(i);
			panel.add(vector_panel);
			
			this.add(panel);
		}			
	}

	private JPanel addSphericalVector(int row) {

		int tempArray [] = new int[length];				// umkopieren der Matrix-Zeile in ein einzelnes Array
		for (int i=0; i<length; i++){
			tempArray[i] = matrix[row][i];
		}
	
		JPanel panel = new Sphere(tempArray);			
		return panel;
	}

Ist jetzt vielleicht etwas viel Code geworden, aber dann findet man den Fehler bestimmt einfacher...

 

[Marco13]

So beim drüberschauen... sollte eigentlich gehen... erst dachte ich, du verwendest immer denSELBEN array, aber tust du nicht... kannst du ein KSKB machen?

 

[Neve]

Danke für die schnelle Antwort. Hoffe, dass mit einem KSKB das folgende gemeint ist...

package GlobalMode;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class FeatureSequence extends JPanel{
	
	private static JFrame frame;
	private static int quantity, length;
	private static int matrix[][];
	private static int category[];
	private static ImageIcon CatIcon = null;

	
	public FeatureSequence(){
	//public FeatureSequence(int quantity, int[][] matrix, int[] category){
		setTestData();
		setLayout(quantity);
		start();		
	}	

	private void setLayout(int i){		
		this.setBackground(Color.white);
		this.setLayout(new GridLayout(i+8,2));				
	}

	private void start(){
	
		quantity = 3;  //zum Test
		
		for (int i=0; i<quantity; i++){
			
			JPanel panel = new JPanel();
			panel.setOpaque(false);
			panel.setLayout(new FlowLayout(FlowLayout.LEFT));
			
//			JPanel cat_panel = addCategory(category[i]);
//			panel.add(cat_panel);
			
			JPanel vector_panel = addSphericalVector(i);
			panel.add(vector_panel);
			
			this.add(panel);
		}			
	}	
	
	private JPanel addSphericalVector(int row) {

		int tempArray [] = new int[length];				// umkopieren der Matrix-Zeile in ein einzelnes Array
		for (int i=0; i<length; i++){
			tempArray[i] = matrix[row][i];
		}	
		JPanel panel = new Sphere(tempArray);		
		return panel;
	}
	
	
	private void setTestData(){
		
		//Testdaten
		quantity = 3;
		length = 11;
		category = new int[quantity];
		matrix = new int[quantity][length];
	
		category[0] = 6;
		category[1] = 2;
		category[2] = 6;
		
		matrix[0][0] = 0;
		matrix[0][1] = 9;
		matrix[0][2] = 17;
		matrix[0][3] = 11;
		matrix[0][4] = 0;
		matrix[0][5] = 0;
		matrix[0][6] = 10;
		matrix[0][7] = 32;
		matrix[0][8] = 21;
		matrix[0][9] = 0;
		matrix[0][10] = 15;
		
		matrix[1][0] = 3;
		matrix[1][1] = 0;
		matrix[1][2] = 0;
		matrix[1][3] = 4;
		matrix[1][4] = 0;
		matrix[1][5] = 0;
		matrix[1][6] = 10;
		matrix[1][7] = 8;
		matrix[1][8] = 21;
		matrix[1][9] = 0;
		matrix[1][10] = 11;	
		
		matrix[2][0] = 15;
		matrix[2][1] = 7;
		matrix[2][2] = 0;
		matrix[2][3] = 8;
		matrix[2][4] = 20;
		matrix[2][5] = 4;
		matrix[2][6] = 0;
		matrix[2][7] = 9;
		matrix[2][8] = 1;
		matrix[2][9] = 21;
		matrix[2][10] = 16;	
	}	
	
	public static void main (String[] args){
		
		frame = new JFrame("T e s t");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	
		frame.add(new FeatureSequence());
		frame.setPreferredSize(new Dimension(1260, 760));
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}
}

package GlobalMode;


import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import javax.swing.JPanel;



public class Sphere extends JPanel{
		
	private static int WIDTH = 1100;
	private static int HEIGHT = 50;
	private static float MIN_DIAMETER = 7f;
	private static float FACTOR = 1f; 
	private static float diameter;
	
	private static int startX, startY, j;
	private static int array[];
	private static Graphics2D g2dArray[] = new Graphics2D[100];

	private static Color GRAY = Color.gray;
	private static Color WHITE = Color.white;
	private static Color RED1 = new Color(192,80,77);
	private static Color RED2 = new Color(217,149,148);
	private static Color BLUE1 = new Color(149,179,215);
	private static Color BLUE2 = new Color(79,129,189);
	private static Color color1, color2;
	
		
	public Sphere(int array[]){	
			setPreferredSize(new Dimension(WIDTH,HEIGHT));
			setOpaque(false);		
			this.array = array;			
			startX = 10;	
		}
		
	private void createSphere(Graphics2D g2d, int i){
					
		if (array[i] == 0){	
			diameter = MIN_DIAMETER;
			color1 = WHITE;
			color2 = GRAY;
		}
		else {
			diameter = MIN_DIAMETER + array[i]*FACTOR;
			color1 = BLUE1;
			color2 = BLUE2;
		}
		
		startY = HEIGHT/2-(int)diameter/2;
		
		Point2D start = new Point2D.Double(startX, startY);
		Point2D end = new Point2D.Double(startX+diameter/2, startY+diameter/2);
		
		Ellipse2D.Double sphere = new Ellipse2D.Double(startX, startY, diameter, diameter);
		
		GradientPaint gp = new GradientPaint(start, color1, end, color2);						
		g2d.setPaint(gp);
		g2d.fill(sphere);	
		
		startX = startX + (int)diameter;		
	}
	
	
	protected void paintComponent(Graphics g){
		
		super.paintComponent(g);		
		Graphics2D g2d = (Graphics2D)g;

		RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		g2d.setRenderingHints(renderHints);

		for (int i=0; i < array.length; i++){
			createSphere(g2d, i);		
		}
		
		startX = 10;
		g2d.dispose();	
	}		
}

 

[Marco13]

Wah ja, das liegt daran dass in "Sphere" alles static ist. Static heißt, dass diese Variablen zur KLASSE "Sphere" gehören. D.h. wenn man 10 Spheres erstellt, dann haben die immer nur EINEN (gemeinsamen) Array, nämlich eben diesen Array der zur Klasse "Sphere" gehört (weil er static ist).

Wenn man dort nur
[c]private int array[];[/c]
schreibt (ohne static) geht' schonmal.

Die ganzen Farben sind wohl static, und sollten vermutlich sogar final sein:
[c]private static final Color BLUE2...[/c]
(um deutlich zu machen, dass das Konstanten sind, die sich nicht mehr ändern - deswegen schreibt man die auch GROSS ).


Aber ganz allgemein: Man sollte den Gültigkeitsbereich von Variablen so klein wie möglich halten. Also nicht sowas wie

void methode()
{
    int wert;
    for (int i=0; i<10; i++)
    {
        wert = 3*i;
        System.out.println(wert);
    }
}

sondern

void methode()
{
    // int wert; // Nicht hier
    for (int i=0; i<10; i++)
    {
        int wert = 3*i; // sondern hier!
        System.out.println(wert);
    }
}

Und das bedeutet (bezogen auf die Sphere-Klasse) auch, dass man nur die Fields (Variablen) oben in die Klassendefinition schreiben sollte, die "unbedingt benötigt werden" - also genau die, die den Zustand eines Objektes beschreiben. In deinem Fall bräuchte man wohl nur [c]array[/c] und [c]startX[/c] (wobei man startX auch noch "wegkriegen" könnte - man braucht das ja nur als "Hilfsvariable" während des Zeichnens...)


Aber... was auch immer du mit

private static Graphics2D g2dArray[] = new Graphics2D[100];

vorhast: MACH ES NICHT :shock:

 

[Marco13]

Nochmal ein Beispiel: Man braucht eigentlich nur den [c]array[/c]. Könnte man ggf. noch eleganter machen, aber ... eben als Beispiel

class Sphere extends JPanel{

    private static final int WIDTH = 1100;
    private static final int HEIGHT = 50;
    private static final float MIN_DIAMETER = 7f;
    private static final float FACTOR = 1f;

    private static final Color GRAY = Color.gray;
    private static final Color WHITE = Color.white;
    private static final Color RED1 = new Color(192,80,77);
    private static final Color RED2 = new Color(217,149,148);
    private static final Color BLUE1 = new Color(149,179,215);
    private static final Color BLUE2 = new Color(79,129,189);


    private int array[];

    public Sphere(int array[]){
            setPreferredSize(new Dimension(WIDTH,HEIGHT));
            setOpaque(false);
            this.array = array;
    }

    private float createSphere(Graphics2D g2d, int i, float x){
        float diameter = 0;
        Color color1;
        Color color2;

        if (array[i] == 0)
        {
            diameter = MIN_DIAMETER;
            color1 = WHITE;
            color2 = GRAY;
        }
        else {
            diameter = MIN_DIAMETER + array[i]*FACTOR;
            color1 = BLUE1;
            color2 = BLUE2;
        }
        float startY = HEIGHT/2-(int)diameter/2;
        Point2D start = new Point2D.Double(x, startY);
        Point2D end = new Point2D.Double(x+diameter/2, startY+diameter/2);

        Ellipse2D.Double sphere = new Ellipse2D.Double(x, startY, diameter, diameter);

        GradientPaint gp = new GradientPaint(start, color1, end, color2);
        g2d.setPaint(gp);
        g2d.fill(sphere);

        x = x + (int)diameter;
        return x;
    }


    protected void paintComponent(Graphics g){

        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;

        RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHints(renderHints);

        float x = 10;
        for (int i=0; i < array.length; i++)
        {
            x = createSphere(g2d, i, x);
        }
        g2d.dispose();
    }
}

EDIT: Wobei ich ja finde, das Sprites nicht von JPanel erben sollten... aber das nur nebenbei...

 

[Neve]

Danke, danke, danke!!!
Der Code sieht in deinen Augen wahrscheinlich wirklich sehr dilettantisch aus...aber wie gesagt...bin totaler Anfänger.

Mit

private static Graphics2D g2dArray[] = new Graphics2D[100];

habe ich ein println durchgeführt, um zu sehen was passiert...hatte mir aber nicht weitergeholfen und ich habe es dann nicht mehr gelöscht.

Danke auch für die anderen Tips - und das so unglaublich schnell! :applaus: