Creare un reticolato in java

[maqotil]

Salve a tutti coloro che si interessano di java 2,non vi nascondo la mia ammirazione se riuscite ad affrontare questo linguaggio ma bando alle ciance....dovrei costruire un pannello con una serie di linee orizzontali e verticali che vadano a formare un reticolato.....non solo ,in ognuno dei quadrati formati dal reticolato devo inserire un cerchio nero......
Mi date qualche idea su come fare?????????????????

[anx721]

Devi ridefinire il metodo paintComponent del JPanel per poterci disegnare sopra; intanto puoi leggerti il tutorial della sun:

http://java.sun.com/docs/books/tutor...ing/index.html

Ma il disegno è fisso? Cioè Potresti creare un'immaine e settarla come sfondo del pannello? Qual è lo scopo di questo reticolato? L'utente deve essere in grado di modificarlo in modo interattivo o no?

[maqotil]

Allora,innanzitutto grazie della risposta,non ci speravo più!!!!
Il reticolato seve a rappresentare i pixel dello schermo,infatti al centro va disegnato un cerchio che deve poter cambiare colore (pixel acceso o meno) mi serve per creare un programma che faccia vedere come si accendono i pixel a schermo per rappresentare una retta o un poligono, con 2 algoritmi particolari,l'interattivià sta nel fatto che l'utente può disegnare una retta e poi devo far partire una specie di animazione (automatica o gestita dall'utente che tramite bottone sceglie di accendere un pixel alla volta)
questo è più o meno una parte del lavoro che devo fare....

[anx721]

Ecco un programmino da cui puoi partire per fare il tuo progetto.

C'è una classe Screen che rappresenta lo schermo e che viene disegnato da uno ScreenPanel.

La classe Screen ha un metodo

drawLine(Pixel p1, Pixel p2)

che disegna, un pixel alla volta, un segmento di retta che congiunge i pixel p1 e p2, utilizzando un algoritmo per il disegno di segmenti di retta. Questo metodo utilizza un altro metodo della classe Screen, ovvero:

Pixel[] getLine(Pixel p1, Pixel p2)

che ritorna l'array di pixel tra p1 e p2. Per provare diversi algoritmi definisci altri metodi della forma

Pixel[] getLineXXX(Pixel p1, Pixel p2)

che ritornano l'array di pixel che rappresentano la linea.

Per disegnare un segmento inseirisci le coordinate del punto iniziale e finale neli appositi campi e clicca sul pulsante 'Disegna'. Tieni conto che l'origine degli assi si trova nell'angolo superiore sinistro.

Il codice nel prossimo post.

[anx721]

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


public class Test extends JFrame implements ActionListener{
	JButton drawButton;
	JButton cancButton;
	Screen screen;
	JTextField x1field;
	JTextField y1field;
	JTextField x2field;
	JTextField y2field;
	
	public Test(){
		super("Screen");
		setSize(600, 400);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setExtendedState(MAXIMIZED_BOTH);
		screen = new Screen(30, 22);
		getContentPane().add(new JScrollPane(new ScreenPanel(screen)), "Center");
		
		JPanel controls = new JPanel();
		controls.setBorder(new EmptyBorder(5, 5, 5, 5));
		
		x1field = new JTextField(3);
		x1field.setText("0");
		y1field = new JTextField(3);
		y1field.setText("0");
		x2field = new JTextField(3);
		x2field.setText("20");
		y2field = new JTextField(3);
		y2field.setText("15");
		
		controls.add(new JLabel(" x1:"));
		controls.add(x1field);
		controls.add(new JLabel(" y1:"));
		controls.add(y1field);
		controls.add(new JLabel("                      "));
		controls.add(new JLabel(" x2:"));
		controls.add(x2field);
		controls.add(new JLabel(" y2:"));
		controls.add(y2field);
		controls.add(new JLabel("                      "));
		
		drawButton = new JButton("Disegna !");
		controls.add(drawButton);
		drawButton.addActionListener(this);
		cancButton = new JButton("Reset !");
		controls.add(cancButton);
		cancButton.addActionListener(this);
		
		getContentPane().add(controls, "South");
		
		setVisible(true);
	}

	
	public void actionPerformed(ActionEvent e){
		Object source = e.getSource();
		if(source == drawButton){
			try{
				int x1 = Integer.parseInt(x1field.getText());
				int y1 = Integer.parseInt(y1field.getText());
				int x2 = Integer.parseInt(x2field.getText());
				int y2 = Integer.parseInt(y2field.getText());
				
				if((x1 < 0) || (x1 > screen.getXSize()) || (y1 < 0) || (y1 >= screen.getYSize()))
					JOptionPane.showMessageDialog(this, "Il pixel p1 non appartiene allo screen", "Errore", JOptionPane.ERROR_MESSAGE);
				if((x2 < 0) || (x2 > screen.getXSize()) || (y2 < 0) || (y2 >= screen.getYSize()))
					JOptionPane.showMessageDialog(this, "Il pixel p2 non appartiene allo screen", "Errore", JOptionPane.ERROR_MESSAGE);

				screen.drawLine(new Pixel(x1, y1), new Pixel(x2, y2));
			}
			catch(NumberFormatException nfe){
				JOptionPane.showMessageDialog(this, "Una delle coordinate inserite non rappresenta un numero intero", "Errore", JOptionPane.ERROR_MESSAGE);
			}
			return;
		}
		
		if(source == cancButton){
			screen.reset();
			return;
		}
	}

	public static void main(String[] argus){
		new Test();
	}
}

class Screen{
	//dimensione orizzontale
	private int hSize;
	//dimensione verticale
	private int vSize;
	//la matrice che rappresenta i pixel
	private int[][] screen;
	//costante che indica un pixel acceso
	public static int ON = 1;
	//costante che indica un pixel spento
	public static int OFF = 0;
	//un 'ascoltatore' a cui notificare l'avvenuta accensione o spenimento
	//di un pixel
	private ScreenListener lis;
	//variabile che vale true se è in corso il disegno di una linea
	//serve per evitare di disenare piu linee contemporaneamente
	private ScreenDrawer drawer;
	
	public Screen(int hSize, int vSize){
		this.hSize = hSize;
		this.vSize = vSize;
		screen = new int[hSize][vSize];
		for(int i = 0; i < hSize; i++)
			for(int j = 0; j < vSize; j++)
				screen[i][j] = OFF;
	}
	
	//accende il pixel di posizione x, y
	public synchronized void turnOn(int x, int y){
		screen[x][y] = ON;
		if(lis != null)
			lis.screenChanged(this);
	}
	
	//spegne il pixel di posizione x, y
	public synchronized void turnOff(int x, int y){
		screen[x][y] = OFF;
		if(lis != null)
			lis.screenChanged(this);
	}
	
	public int getXSize(){
		return hSize;
	}

	public int getYSize(){
		return vSize;
	}
	
	//restituisce true se il pizel (x, y) è acceso
	public synchronized boolean isOn(int x, int y){
		return screen[x][y] == ON;
	}
	
	//Restituisce un array di pixel che rapprsentano la linea
	//tra i punti p1 e p2
	private synchronized Pixel[] getLine(Pixel p1, Pixel p2){
		if((p1 == null) || (p2 == null))
			return null;
		if((p1.x < 0) || (p1.x > hSize) || (p1.y < 0) || (p1.y >= vSize))
			return null;
		if((p2.x < 0) || (p2.x > hSize) || (p2.y < 0) || (p2.y >= vSize))
			return null;
			
		Vector v = new Vector();
		int z1 = p1.x;
		int w1 = p1.y;
		int z2 = p2.x;
		int w2 = p2.y;

		int x, y, dz, dw;
		if(w1 > w2){
			int a = z1;
			int b  = w1;
			z1 = z2;
			w1 = w2;
			z2 = a;
			w2 = b;
		}
		dz = Math.abs(z1 - z2);
		dw = w2  - w1;
		int signZ = 1;
		if (z1 > z2)
			signZ = -1;
		int signW = 1;
		if (w1 > w2)
			signW = -1;
		if (dz == 0)
			for(int i = Math.min(w1, w2); i <= Math.max(w1, w2); i++){
				x = z1;
				y = i;
				v.add(new Pixel(x, y));
			}
		else
			for(int i = 0; i <= dz; i++){
				x = z1 + (signZ * i);
				y = w1 + signW * (i * dw) / dz;
				int b = w1 + signW * ((i + 1) * dw) / dz;
				int a = Math.min(y, b);
				b = Math.max(y, b);
				if (a == b)
					v.add(new Pixel(x, y));
				else
					for(y = a; (y < b)&&(y <= w2); y++)
						v.add(new Pixel(x, y));
			}
	
			Pixel[] pos = new Pixel[v.size()];
			Enumeration e = v.elements();
			Pixel p;
			int i = 0;
			while (e.hasMoreElements()){
				p = ((Pixel)e.nextElement());
				pos[i] = p;
				i++;
			}
		return pos;
	}
	
	//Disegna la linea tra i pizel p1 e p2
	public synchronized void drawLine(Pixel p1, Pixel p2){
		Pixel[] pixels = getLine(p1, p2);
		//Se stavo disenando una linea interrompo il disegno
		if(drawer != null)
			drawer.interrupt();
		reset();
		drawer = new ScreenDrawer(this, pixels);
		drawer.start();
		
	}
	
	//spegne tutti i pixel accesi
	public synchronized void reset(){
		//Se stavo disenando una linea interrompo il disegno
		if(drawer != null)
			drawer.interrupt();
		for(int i = 0; i < hSize; i++)
			for(int j = 0; j < vSize; j++)
				screen[i][j] = OFF;
		if(lis != null)
			lis.screenChanged(this);
	}
	
	//imposta 'ascoltatore' a cui notificare le modifiche avvenute
	public void setScreenListener(ScreenListener lis){
		this.lis = lis;
	}
	
}


//Classe che rappresenta la posizione di un pixel
class Pixel{
	public int x = 0;
	public int y = 0;
	
	public Pixel(int x, int y){
		this.x = x;
		this.y = y;
	}
}

//Un oggeto che disegna sullo screen accendendo uno ad uno i pixel

class ScreenDrawer extends Thread{
	
	//Lo screen su cui disegnare
	private Screen screen;
	//I pixels da accendere
	private Pixel[] pixels;

	
	public ScreenDrawer(Screen screen, Pixel[] pixels){
		this.screen = screen;
		this.pixels = pixels;
	}
	
	public void run(){
		for(int i = 0; i < pixels.length; i++){
			Pixel p = pixels[i];
			screen.turnOn(p.x, p.y);
			try{
				sleep(1000);
			}
			catch(InterruptedException e){
				return;
			}
		}
	}

}

interface ScreenListener{
	public void screenChanged(Screen screen);
}

class ScreenPanel extends JPanel implements ScreenListener{
	//lo screen da disegnare
	Screen screen;
	//dimensione in pizel di una cella dello screen
	int size;
	//dimensione orizzontale dello screen
	int hSize;
	//dimensione verticale dello screen
	int vSize;
	
	public ScreenPanel(Screen screen){
		setLayout(new BorderLayout());
		this.screen = screen;
		screen.setScreenListener(this);
		size = 30;
		hSize = screen.getXSize();
		vSize = screen.getYSize();
		setPreferredSize(new Dimension(size * hSize, size * vSize)); 
	}
	
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		g.setColor(Color.BLACK);
		//Disegno le linee verticali
		for(int i = 0; i <= hSize; i++)
			g.drawLine(i * size, 0, i * size, vSize * size);
		//Disegno le linee orizzontali
		for(int i = 0; i <= vSize; i++)
			g.drawLine(0, i * size, hSize * size, i * size);
		g.setColor(Color.BLUE);
		//Disegno i pizel accesi
		for(int i = 0; i < hSize; i++)
			for(int j = 0; j < vSize; j++)
				if(screen.isOn(i, j))
					//diseno il cerchio
					g.fillOval(i * size + 2, j * size + 2, size - 4, size - 4);
	}
	
	
	//questo metodo viene invocato dallo screen quando lo screen
	//accende o spegne un pixel; il pannello quindi si ridisegna
	//con repaint
	public void screenChanged(Screen screen){
		repaint();
	};
    
}

[maqotil]

sei un grande,lo provo e ti faccio sapere....

[maqotil]

Incredibile,è proprio quello che mi serviva,ora devo solo trovare il modo di inserirlo in un altro JFrame......

[anx721]