Ein computergeneriertes Kunstbild

rewy · 6. Okt 2009

Hallo zusammen
Ich muss hier eine Aufgabe bewältigen. Das Grafikfenster konnte ich erstellen, jedoch mit dem restlichen Teil habe ich mühe.

Das Fenster hat eine Abmessung von 500 Pixeln in der Breite und 700 Pixeln in der Höhe. Soweit kam ich noch^^

Das Gitter soll so gezeichnet werden, dass horizontal wie vertikal 10 Linien sichtbar sind. Innhab dieses Gitters sollen 13 Felder, welche zufallsmässig ausgewählt werden, mit einer zufälligen Farbe ausgefüllt werden. Es ist darauf zu achten, dass genau 13 Felder bemalt sind.

Die Farbe jedes Feldes soll zufällig aus einer Auswahl von 6 definierten Farben ausgewählt werden. Die RGB-Werte dieser 6 Farben soll aber auch zufällig bestimmt werden.

Kann mir bitte jemand helfen diese Aufgabe zu bewältigen. Habe auch schon gegoogelt, jedoch keine exakte Erklärung oder Beschreibung gefunden die mir weiterhelfen konnte.

greez reto

arthur177 · 6. Okt 2009

Benutzt du Swing um die Fenster aufzubauen?
Poste doch mal dein Quellcode soweit wie du es hast.

Wegen deinen Linien könnte ich vorschlagen, dass du einfach ein GridLayout in dein Fenster setzt. Dieses soll dann 11 Spalten (columns) und 11 Reihen (rows) haben. Jedes Feld des Gridlayouts bekommt dann ein Border (Die Linie von deinen Feldern) und die Farbe generierst du per zufall etwa so:

Java:

int rot = (int) (Math.random() * 255);
int gruen = (int) (Math.random() * 255);
int blau = (int) (Math.random() * 255);

Color start = new Color(rot,blau,gruen);

und setzt diese Farbe in die einzelnen Felder

rewy · 6. Okt 2009

Java:

import java.awt.*;	
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;

public class GrafikBeispiel
	extends Frame
{
	//klassen-Konstanten
	//******************
	final int W_WIDTH = 500;
	final int W_HEIGHT = 700;
	
	//***************************************************************************
	//* Main																	*
	//***************************************************************************
	// Hier beginnt die Ausführung des Programmes								*
	//***************************************************************************
	public static void main (String[] args)
	{
		//Ein Objekt unserer Klasse wird erzeugt. Damit läuft auch paint ab
		GrafikBeispiel wnd;
		wnd	= new GrafikBeispiel();
		
	}
	
	//***************************************************************************
	//* Constructor																	*
	//***************************************************************************
	// Dieser Code wird ausgeführt, wenn ein neues Objekt erzeugt wird								*
	//***************************************************************************
	public GrafikBeispiel()
	{
		super ("GrafikBeispiel"); //Titel des Fenster definieren
		//Folgender Aufruf kommt aus der Datei WindowClosingAdapter.java
		addWindowListener(new WindowClosingAdapter (true)); //Damit das Fenster schliessbar ist
		setSize(W_WIDTH, W_HEIGHT); //definieren der Grösse des Fensters
		setVisible (true); // Fenster sichtbar machen
		
	}
	
	//***************************************************************************
	//* Paint																	*
	//***************************************************************************
	// Diese Methode wird aufgerufen, wenn das Fenster dargestellt wird, also	*
	//auch das erste Mal wenn der Constructor abläuft							*
	//***************************************************************************

}

oke und wie und wo genau definiere ich jetzt das mit columns und rows.^^

arthur177 · 6. Okt 2009

Schau dir das mal an:

Java:

import java.awt.*;

import javax.swing.*;

@SuppressWarnings("serial")
public class GrafikBeispiel extends Frame
{
    //klassen-Konstanten
    //******************
    private final int W_WIDTH = 500;
    private final int W_HEIGHT = 700;
    
    private JPanel panelGrid;
    private int rows=11; // Anzahl der Reihen
    private int cols=11; // Anzahl der Spalten
    private JPanel kaestchen[];
    
    // Farben
    private int rot, gruen, blau;
    
    //***************************************************************************
    //* Main                                                                    *
    //***************************************************************************
    // Hier beginnt die Ausführung des Programmes                               *
    //***************************************************************************
    public static void main (String[] args)
    {
        //Ein Objekt unserer Klasse wird erzeugt. Damit läuft auch paint ab
        GrafikBeispiel wnd;
        wnd = new GrafikBeispiel();
        
    }
    
    //***************************************************************************
    //* Constructor                                                                 *
    //***************************************************************************
    // Dieser Code wird ausgeführt, wenn ein neues Objekt erzeugt wird                              *
    //***************************************************************************
    public GrafikBeispiel()
    {
        super ("GrafikBeispiel"); //Titel des Fenster definieren
        //Folgender Aufruf kommt aus der Datei WindowClosingAdapter.java
//        addWindowListener(new WindowClosingAdapter (true)); //Damit das Fenster schliessbar ist
        setSize(W_WIDTH, W_HEIGHT); //definieren der Grösse des Fensters
        
        
        // Erzeugt ein Gridlayout das die verschiedenen Kästchen enthällt
        panelGrid = new JPanel(new GridLayout(rows, cols));
        add(panelGrid);
        kaestchen = new JPanel[rows*cols]; // Setzt das Array solang wie es insgesammt kästchen geben soll
        for (int i = 0; i < kaestchen.length; i++) 
        {
			kaestchen[i] = new JPanel();
			// Hier muss noch die Farbe ergänzt werden die zufällig bestimmt werden soll ->(rot, gruen, blau)
			rot = 33; blau = 44; gruen = 11; // Nur Beispielswerte
			kaestchen[i].setBackground(new Color(rot, gruen, blau)); 
			kaestchen[i].setBorder(BorderFactory.createLineBorder(Color.black));
			panelGrid.add(kaestchen[i]);
		}
        
        setVisible (true); // Fenster sichtbar machen
        
    }
    
    //***************************************************************************
    //* Paint                                                                   *
    //***************************************************************************
    // Diese Methode wird aufgerufen, wenn das Fenster dargestellt wird, also   *
    //auch das erste Mal wenn der Constructor abläuft                           *
    //***************************************************************************
 
}

rewy · 6. Okt 2009

super, vielen dank^^
was ich nicht genau begreife warum setzt du rot=33, gruen=11........
verstehe die Logik nicht ganz dahinter?

rewy · 6. Okt 2009

ah oke alles klar

arthur177 · 6. Okt 2009

rewy hat gesagt.:
super, vielen dank^^
was ich nicht genau begreife warum setzt du rot=33, gruen=11........
verstehe die Logik nicht ganz dahinter?

Das sind ja nur Beispielwerte. Musst es noch durch zufallswerte ergänzen. siehe oben. Habe doch das extra kommentiert

rewy · 6. Okt 2009

ja habe es gesehen^^ alles klar, danke

Landei · 6. Okt 2009

Sehr künstlerisch!

Java:

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

public class Art {

    public static void main(String... args) {
        JOptionPane.showMessageDialog(null, new JComponent() {
            private final Random rnd = new Random();
            private java.util.List<Integer> ints = new ArrayList<Integer>();
            {
                setPreferredSize(new Dimension(501, 701));
                for (int i = 0; i < 100; i++) {  ints.add(i);  }
                Collections.shuffle(ints);
            }

            @Override
            public void paintComponent(Graphics g) {
                g.setColor(Color.white);
                g.fillRect(0, 0, getWidth(), getHeight());
                int w = getWidth() / 10;
                int h = getHeight() / 10;
                for (int i = 0; i < 13; i++) {
                    int x = ints.get(i) / 10;
                    int y = ints.get(i) % 10;
                    g.setColor(new Color(rnd.nextInt(256), rnd.nextInt(256), rnd.nextInt(256)));
                    g.fillRect(x * w, y * h, w, h);
                }
                g.setColor(Color.black);
                for (int x = 0; x < 10; x++) {
                    for (int y = 0; y < 10; y++) {
                        g.drawRect(x * w, y * h, w, h);
                    }
                }

            }
        }, "Art", JOptionPane.PLAIN_MESSAGE);
    }
}

rewy · 6. Okt 2009

oke irgendwie schaffe ich es nicht das nur 13 Felder bemalt werden. Habe jetzt schon 1 Stunde lang probiert es zu lösen. geht irgendwie nicht. Die von Landei konnte ich noch nicht entziffern^^

Java:

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

public class GrafikBeispiel extends Frame
{
    //klassen-Konstanten
    //******************
    private final int W_WIDTH = 500;
    private final int W_HEIGHT = 700;
    
    private JPanel panelGrid;
    private int rows=11; // Anzahl der Reihen
    private int cols=11; // Anzahl der Spalten
    private JPanel kaestchen[];
    
    // Farben
    private int red, green, blue;
    
    //***************************************************************************
    //* Main                                                                    *
    //***************************************************************************
    // Hier beginnt die Ausführung des Programmes                               *
    //***************************************************************************
    public static void main (String[] args)
    {
        //Ein Objekt unserer Klasse wird erzeugt. Damit läuft auch paint ab
        GrafikBeispiel wnd;
        wnd = new GrafikBeispiel();
        
    }
    
    //***************************************************************************
    //* Constructor                                                                 *
    //***************************************************************************
    // Dieser Code wird ausgeführt, wenn ein neues Objekt erzeugt wird                              *
    //***************************************************************************
    public GrafikBeispiel()
    {
        super ("GrafikBeispiel"); //Titel des Fenster definieren
        //Folgender Aufruf kommt aus der Datei WindowClosingAdapter.java
        addWindowListener(new WindowClosingAdapter (true)); //Damit das Fenster schliessbar ist
        setSize(W_WIDTH, W_HEIGHT); //definieren der Grösse des Fensters
        
        
        // Erzeugt ein Gridlayout das die verschiedenen Kästchen enthällt
        panelGrid = new JPanel(new GridLayout(rows, cols));
        add(panelGrid);
        kaestchen = new JPanel[rows*cols]; // Setzt das Array solang wie es insgesammt kästchen geben soll
       

	for (int i = 0; i < kaestchen.length; i++) 
        {
		kaestchen[i] = new JPanel();
            
		// Hier muss noch die Farbe ergänzt werden die zufällig bestimmt werden soll ->(rot, gruen, blau)
		int red = (int) (Math.random() * 255);
		int green = (int) (Math.random() * 255);
		int blue = (int) (Math.random() * 255);
	
		Color start = new Color(red, green, blue);
		
	
		kaestchen[i].setBackground(new Color(red, green, blue)); 
		kaestchen[i].setBorder(BorderFactory.createLineBorder(Color.blue));
		panelGrid.add(kaestchen[i]);
		
		
        }	setVisible (true); // Fenster sichtbar machen
        
	
	

    }
 
}

Landei · 7. Okt 2009

Irgendwie sowas:

Code:

for(int i = 0; i < 13; i++) {
   x = zufall(0..9)
   y = zufall(0..9)
   farbe = zufall
   male das Viereck an Position x,y
}

In meinem Code ist das etwas versteckt, indem ich eine Liste mit 100 Einträgen erzeuge, durchmischen lassen, und aus den ersten 13 Werten die Koordinaten berechne - ist aber im Prinzip dasselbe, nur kürzer.

Mein Programm ist kein Beispiel für guten Stil, sondern sollte möglichst kurz sein. Versuche lieber, deine Version zum Laufen zu bekommen.

Quaxli · 7. Okt 2009

Hier mal noch ein 2. Codebeispiel. Ich habe es nicht kommentiert, damit Du auch was zu tun hast

Ich habe dabei mal diese Vermischung von AWT und SWING rausgenommen (tut man nicht) und nur Swing-Komponenten verwendet. Außerdem habe ich mal berücksichtigt, daß es 6 verschieden Zufallsfarben sein sollen.

Was das u. a. Beispiel nicht macht: Es ist möglich, daß 2 Rechtecke übereinander gezeichnet werden, da keine Prüfung eingbaut ist, ob eine Rechteck doppelt besetzt wird.

Java:

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

public class GrafikBeispiel extends JPanel {
	// klassen-Konstanten
	// ******************
	private final int	W_WIDTH		= 500;
	private final int	W_HEIGHT	= 700;
	Color[]						colors;
	Rectangle[]       rectangles;

	public static void main(String[] args) {
		new GrafikBeispiel();
	}

	public GrafikBeispiel()    {
		
		    setPreferredSize(new Dimension(W_WIDTH, W_HEIGHT));
		
        JFrame frame = new JFrame("Grafikbeispiel");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(this);
        frame.pack();
        
        createColors();
        createRectangles();
        
        
        frame.setVisible(true);
  }
	
	private void createColors(){
		colors = new Color[6];
		
		for(int i=0;i<colors.length;i++){
			int red   = (int)(Math.random()*256);
			int green = (int)(Math.random()*256);
			int blue  = (int)(Math.random()*256);
			colors[i] = new Color(red,green,blue);
		}
		
	}
	
	private void createRectangles(){
		rectangles = new Rectangle[13];
		
		for(int i = 0;i<rectangles.length;i++){
			int maxx = W_WIDTH/(W_WIDTH/10);
			int maxy = W_HEIGHT/(W_HEIGHT/10);
		  int rx = (int)(Math.random()*maxx);	
		  int ry = (int)(Math.random()*maxy);
		  rectangles[i] = new Rectangle(rx*(W_WIDTH/10),ry*(W_HEIGHT/10),W_WIDTH/10,W_HEIGHT/10);
		}
		
	}
	
	
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		
		g.setColor(Color.RED);
		for(int i=(W_WIDTH/10);i<W_WIDTH;i=i+(W_WIDTH/10)){
			g.drawLine(i, 0, i, W_HEIGHT);
		}
		for(int i=(W_HEIGHT/10);i<W_HEIGHT;i=i+(W_HEIGHT/10)){
			g.drawLine(0, i, W_WIDTH,i);
		}		
		for(int i=0;i<rectangles.length;i++){
			int cr = (int)(Math.random()*colors.length);
			g.setColor(colors[cr]);
			g.fillRect(rectangles[i].x,rectangles[i].y,rectangles[i].width,rectangles[i].height);
			System.out.println(rectangles[i].x + "/" + rectangles[i].y); 
		}
		
		
	}
}

rewy · 7. Okt 2009

oke vielen Dank.....funktioniert jetzt einwandfrei und kann es sogar nachvollziehen^^ supi

Ein computergeneriertes Kunstbild

rewy

Mitglied

arthur177

Mitglied

rewy

Mitglied

arthur177

Mitglied

rewy

Mitglied

rewy

Mitglied

arthur177

Mitglied

rewy

Mitglied

Landei

Top Contributor

rewy

Mitglied

Landei

Top Contributor

Quaxli

Top Contributor

rewy

Mitglied

Aktuelle Jobs

Neue Themen