O
conteúdo desta página está baseado no material
criado
pela professora
Isabel
Harb Manssour.
Antes
de iniciar esta aula, certifique-se que o Eclipse está
configurado corretamente para utilizar a JOGL.
Caso não
esteja, siga as instruções desta
página.
Introdução
Faça
o download do arquivo fontes.zip.
Este arquivo contém as classes que devem ser inseridas no
projeto e
algumas imagens que serão usadas para teste da
aplicação.
Atenção: as imagens deverão
estar na pasta do projeto, junto com as DLLs.
Descrição das Classes
Classe Imagem
Esta classe representa uma
imagem JPG dentro do programa. Possui, entre outros, os
métodos getPixel
e setPixel para permitir o acesso aos pontos da imagem.
Observe o fonte da classe para ver os demais métodos
disponíveis.
Classe Pixel
Classe auxiliar para armazenar um ponto da tela. Possui os métodos getR(), getG() e getB() para permitir a
obtenção da cor de um ponto.
Classe ExemploImagem
Esta classe, que possui apenas o método
construtor, inicialmente cria um objeto (da classe JFrame) que representa a janela do
programa e define os parâmentros necessários ao
funcionamento de uma área OpenGL dentro desta janela.
// Cria janela
JFrame janela = new JFrame("Imagens em
OpenGL");
janela.setBounds(50,100,1000,600);
janela.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
BorderLayout layout = new BorderLayout();
Container caixa=janela.getContentPane();
caixa.setLayout(layout);
// Cria um objeto GLCapabilities para especificar o
número de bits
// por pixel para RGBA
GLCapabilities c = new GLCapabilities();
c.setRedBits(8);
c.setBlueBits(8);
c.setGreenBits(8);
c.setAlphaBits(8);
Após a inicialização da superfície de
OpenGL, a construtora cria objetos da classe Imagem, que é
responsável pela carga de imagens no formato JPG.
Imagem im[] = new Imagem[9];
// Cria os objetos Imagem a partir de arquivos JPEG
im[0] = new Imagem("abbey.jpg");
im[1] = new Imagem("churras.jpg");
im[2] = new Imagem("eye.jpg");
im[3] = new Imagem("flags.jpg");
im[4] = new Imagem("flower.jpg");
im[5] = new Imagem("rocks.jpg");
im[6] = new Imagem("shells.jpg");
im[7] = new Imagem("shells2.jpg");
im[8] = new Imagem("sushi24bit.jpg");
A seguir, a construtora da classe realiza a ligação
entre a janela e um objeto da classe GLCanvas,que representa a área
de desenhos de OpenGL dentro da Janela.
// Cria um canvas, adiciona na janela
// para os eventos Gl, de mouse e teclado
GLCanvas canvas = new GLCanvas(c);
janela.add(canvas,BorderLayout.CENTER);
Por fim, cria-se um objeto da Classe RendererImagem(descrito
a seguir), passado a este um vetor com as imagens recém
carregadas.
Este objeto é informado ao objeto da classe GLCanvas, como sendo
o objeto que irá tratar os eventos de mouse, teclado e de
redesenho da tela.
// Cria o objeto que irá gerenciar os eventos
renderer = new RendererImagem(im);
// Especifica o objeto "ouvinte"
// para os eventos de OpenGL, de mouse e de teclado
canvas.addGLEventListener(renderer);
canvas.addMouseListener(renderer);
canvas.addKeyListener(renderer);
janela.setVisible(true);
canvas.requestFocus();
Classe RendererImagem
Esta classe é responsável pelo gerenciamento dos
eventos de teclado e mouse e pelos procedimentos de redesenho da tela.
Os principais métodos da classe são:
public
void init(GLAutoDrawable drawable): método responsável pela
inicialização de variáveis da OpenGL. Ele é
executado automaticamente quando o objeto da GLCanvas é criado.
Sugere-se colocar neste método das as
inicializações que irão valer desde o
início do programa.
public void
display(GLAutoDrawable drawable): método
responsável pelo redesenho da área OpenGL da janela.
Sugere-se todos os comandos de desenho de OpenGL sejam ativados a
partir deste método,ou de métodos chamados a partir daqui.
public void
reshape(GLAutoDrawable drawable, int x, int y, int width, int height): método chamado quando
a janela for redimensionada.
public void
mouseClicked(MouseEvent e): método chamado
quando um botão do mouse for clicado dentro da janela.
public void
keyPressed(KeyEvent e): método chamado
quando uma tecla for pressiona dentro da janela.
Os demais métodos são mencionados nas atividades
descritas abaixo.
Atividades
Compile
e execute o programa. As teclas F1
e F2
mostram a próxima imagem ou anterior, respectivamente.
Além disso, a
única opção implementada é
a tecla ESC para sair do programa. Ao ser
pressionada qualquer tecla, o programa exibe uma nova imagem ao lado da
original (que por enquanto é igual a ela). As teclas de 1
a 6
devem ser usadas para implementar as tarefas abaixo (cada tecla executa
a tarefa correspondente).
Observe
atentamente o código para entender o seu funcionamento.
Depois realize as tarefas 1 à 7 especificadas ao longo do
código. O único arquivo que deve ser alterado
é o RendererImagem.java,
e a imagem a ser alterada está no atributo nova.
Para facilitar, estas tarefas foram listadas a seguir.
- Tarefa
1: no método ConvertToGrayScale(),
gere uma imagem em tons de cinza usando os métodos getPixel
e setPixel
da classe Imagem.
- Tarefa
2: no método convertToBlackAndWhite(),
implemente o algoritmo para segmentar/transformar as imagens para
P&B
usando limiarização. Se o valor do pixel for
menor que o valor do limiar a cor deve ser preta, caso
contrário deve ser branca.
Implemente esta técnica e varie o valor do limiar para
números pequenos como 10 ou 15 e números grandes
como 100 e 150.
- Tarefa
3: ainda no método convertToBlackAndWhite(),
mude o valor do limiar para um número que represente a
média entre os valores de intensidade máximo e
mínimo encontrados na imagem.
- Tarefa
4: no método highPass
implemente um filtro
passa-alta (realce de bordas). Veja no material sobre processamento de
imagens quais valores devem ser usados.
- Tarefa
5: no método lowPass
implemente um filtro passa-baixa (suavização).
Veja no material sobre processamento de imagens quais valores devem ser
usados.
- Tarefa
6: no método posterize()
gere uma imagem através da técnica de
posterização, que simplesmente reduz a quantidade
de tons diferentes de cada componente de cor. Por exemplo, se quisermos
posterizar para 10 intensidades,
25 tons de cada componente se transformam no tom médio de
cada intervalo (0..25 = 12, 26..50 = 38, ...).
- Tarefa
7: no método sepia()
gere uma imagem em tons de sépia, através do
seguinte algoritmo:
- A imagem deve estar em tons de cinza;
- Faça as sombras (cinzas mais escuros) ficarem ainda mais
escuras (0 <= cinza < 60);
- Faça os cinzas médios ficarem meio amarronzados
(60 <= cinza < 190), reduzindo o azul;
- Faça as partes claras (cinzas claros) ficarem meio
amarelados (190 <= cinza):
aumente vermelho e
verde
ou diminua o azul.
Observações:
- para todas as tarefas experimente alterar as imagens pressionando as
teclas F6 (avança) e F7 (volta);
- analise o método keyPressed
e verifique as teclas que podem ser usadas no programa para testar cada
tarefa que for implementada.