Olá, pessoal, estou fazendo um programa para a minha apresentação em monografia e me deparei com o seguinte impasse:
Eu preciso fazer um processamento e esse processamento ser acompanhado pela Thread que irá aparecer para o usuário uma barra de progresso do processamento…
O problema está no seguinte, não estou conseguindo implementar, será que alguém poderia me dar uma sugestão… o que estava pensando está abaixo…
Primeiramente eu vou ter minha classe principal que irá chamar a classe logo abaixo e passar a matrix com os valores dos pontos da imagem, largura e altura…
Este cógigo abaixo foi pego no site do GUJ e foi feita algumas alterações tentando solucionar o problema:
package processamento;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JTextField;
import org.apache.commons.math.complex.Complex;
import org.apache.commons.math.complex.ComplexFormat;
import org.apache.commons.math.complex.ComplexUtils;
/**
* @author smota
*/
public class ClasseGUI extends JFrame implements Observer {
//Nro de iterações para o loop de simulação do processo
public static int TAM_PROCESSO = 10000000;
/**
* @serial A matrix Complexa de retorno.
*/
private Complex[][] matrixComplexa ;
/**
* @serial A matrix Auxiliar de linha.
*/
private Complex[][] matrixAux;
/**
* @serial As variáveis para criação da matrix.
*/
public Complex aux1,aux2,aux3,aux4;
/**
* @serial O objeto imagem passado como parâmetro à classe.
*/
private int[][] image ;
/**
* @serial O objeto homo do filtro homomórfico.
*/
private double[][] homo ;
/**
* @serial A largura e a altura da imagem passado como parâmetro à classe.
*/
private int largura,altura;
/**
* @serial O contador da estrutura for e variável para formação da matrix Complexa.
*/
private int al;
/**
* @serial A constante pi.
*/
private double valorpi;
/**
* @serial As variáveis para contrução de números Complexos.
*/
private double re,im,inter1,inter2;
private Complex[][] retorno;
//Variaveis da interface
private JProgressBar barradeprogresso;
private JButton botaoOK;
private JTextField texto;
private JLabel label;
//Variavel de controle da thread do processo
private Thread processo;
/**
* Executa o processo da aplicação
*/
private Complex[][] executaProcesso() {
if(processo==null) { //Instancia a thread SE não existir uma
processo = new Thread(new classeProcesso(this,image,largura,altura));
processo.start();
retorno=cp.getTransformColuna();
} else {
System.out.println("O processo ainda está em execução");
}
return retorno;
}
/**
* Construtor padrão, instancia e monta objetos da tela
*/
protected ClasseGUI(int[][] imagem, int largura, int altura) {
this.image=imagem;
this.largura=largura;
this.altura=altura;
Container contentPane = getContentPane();
contentPane.setLayout(new BorderLayout());
botaoOK = new JButton("Processar");
//Listener do botao
botaoOK.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
executaProcesso();
}
} );
texto = new JTextField();
label = new JLabel("Programa Exemplo");
label.setHorizontalAlignment(JTextField.CENTER);
barradeprogresso = new JProgressBar();
barradeprogresso.setMaximum(ClasseGUI.TAM_PROCESSO);
contentPane.add(label,BorderLayout.NORTH);
contentPane.add(texto,BorderLayout.CENTER);
contentPane.add(botaoOK,BorderLayout.WEST);
contentPane.add(barradeprogresso,BorderLayout.SOUTH);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
}
/**
* Atualiza a tela
* @see java.util.Observer#update(java.util.Observable, java.lang.Object)
* @param o Objeto que sofreu uma atualização
* @param arg Argumento passado pelo objeto para seus observadores
*/
public void update(Observable o, Object arg) {
if(arg instanceof Integer) {
//Seta o valor do progresso
barradeprogresso.setValue( ((Integer) arg).intValue());
texto.setText( String.valueOf(((Integer) arg).intValue()));
} else if(arg instanceof Boolean) {
if( ((Boolean) arg).booleanValue() ) {
barradeprogresso.setValue(0);
label.setText("Processo finalizado!");
}
}
}
/**
* Instancia e mostra a tela do usuário
* @param args Parâmetros da linha de execução
*/
//public static void main(String[] args) {
// new ClasseGUI().show();
// }
}
A seguinte irá realizar o processamente e deve retornar uma matrix Complexa…
package processamento;
import java.util.Observable;
import java.util.Observer;
import org.apache.commons.math.complex.Complex;
import org.apache.commons.math.complex.ComplexFormat;
import org.apache.commons.math.complex.ComplexUtils;
/**
* @author smota
*/
public class classeProcesso extends Observable implements Runnable {
/**
* @serial A matrix Complexa de retorno.
*/
private Complex[][] matrixComplexa ;
/**
* @serial A matrix Auxiliar de linha.
*/
private Complex[][] matrixAux;
/**
* @serial As variáveis para criação da matrix.
*/
public Complex aux1,aux2,aux3,aux4;
/**
* @serial O objeto imagem passado como parâmetro à classe.
*/
private int[][] imagem ;
/**
* @serial O objeto homo do filtro homomórfico.
*/
private double[][] homo ;
/**
* @serial A largura e a altura da imagem passado como parâmetro à classe.
*/
private int largura,altura;
/**
* @serial O contador da estrutura for e variável para formação da matrix Complexa.
*/
private int al;
/**
* @serial A constante pi.
*/
private double valorpi;
/**
* @serial As variáveis para contrução de números Complexos.
*/
private double re,im,inter1,inter2;
/**
* Construtor que recebe um objeto que irá observa-lo
* @param observador Objeto que irá acompanhar as mudanças deste objeto
*/
public classeProcesso(Observer observador,int[][] imagem, int largura, int altura){
this.imagem=imagem;
this.largura=largura;
this.altura=altura;
//Adiciona o objeto observador a lista de observadores
addObserver(observador);
//...outras inicializações
}
/**
* Ponto de entrada da Thread.
* @see java.lang.Runnable#run()
*/
public void run() {
Complex[][] matrixAux = getTransformLinha();
Complex[][] matrixComplexa = new Complex[largura][altura];
for(int h=0; h<= ClasseGUI.TAM_PROCESSO; h++) {
if((h % 10 == 0)) {
al = 0;
for(int w = 0; w < largura ; w++){
aux2 = Complex.ZERO;
aux3 = Complex.ZERO;
for(int z = 0;z< largura; z++){
re = Math.cos(2* valorpi * (z-1) * al / largura);
im = -Math.sin(2* valorpi * (z-1) * al / largura);
aux1 = new Complex( re , im);
aux1 = aux1.multiply( matrixAux[z][h] );
aux2 = aux2.add( aux1 );
}
al = al+1;
inter1 = aux2.getReal() / largura;
inter2 = aux2.getImaginary() / largura;
aux3 = new Complex( inter1 , inter2 );
matrixComplexa[w][h] = aux3;
notifyObservers(new Integer(h));
setChanged();
}
}
}
//Notifica fim do processo
notifyObservers(new Boolean(true));
setChanged();
}
public double[][] getHomo(){
double[][] homo=new double[largura][altura];
for(int h = 0; h < altura ; h++){
for(int w = 0; w < largura ; w++){
homo[w][h]=Math.log(1+imagem[w][h]);
}
}
return homo;
}
/**
* Este método processa a imagem, convertendo as linhas da imagem na
* matriz complexa.
* @return A matriz da transformada linha.
*/
public Complex[][] getTransformLinha(){
Complex[][] matrixAux = new Complex[largura][altura];
homo=getHomo();
for(int h = 0; h < largura ; h++){
al = 0;
for(int w = 0; w < altura ; w++){
aux2 = Complex.ZERO;
for(int z = 0; z< altura; z++){
re = homo[h][z]*Math.cos(2*valorpi*(z-1)*al/altura);
im = -homo[h][z]*Math.sin(2*valorpi*(z-1)*al/altura);
aux1 = new Complex(re,im);
aux2 = aux2.add(aux1);
}
al = al+1;
inter1= aux2.getReal()/ altura;
inter2 = aux2.getImaginary()/ altura;
aux3 = new Complex( inter1 , inter2 );
matrixAux[h][w] = aux3;
}
}
return matrixAux;
}
public Complex[][] getTransformColuna(){
return matrixComplexa;
}
}
E a primeira retornar para a principal a mesma matrix…
Muito obrigado…