Detalhes

Categoria: Aprenda Java fazendo applets

Atualização: Sexta, 10 Abril 2009 16:02

Autor: vovó Vicki

Acessos: 7679

O processamento digital de imagens é um campo muito extenso, que exige conhecimentos bastante especializados. Para que possamos começar a trabalhar com imagens não precisamos ser especialistas no assunto. Algumas noções básicas, porém, são necessárias. Antes de iniciar este projeto, vá até Entendendo Imagens e Cores para fazer alguns testes com cores e leia também O que são threads e como domá-los.

Os pontos principais deste tutorial são:

1. Criar a estrutura básica de um applet
2. Tratar parâmetros
3. Substituir métodos
4. Criar e gerenciar threads
5. Trabalhar com cores
6. Gerar uma barra de efeito colorido

O código Java

Inserção em documento HTML

O applet funcionando

Compilando seu código Java com qualquer compilador disponível (por exemplo, o javac.exe do kit desenvolvedor) será gerado um arquivo de bytecodes com o mesmo nome da classe, ou seja, barraCor.class.

Crie um documento HTML e insira seu applet como mencionado acima. Veja alguns exemplos:

Configuração 1: tempo = 250 e hsi = "h"

Configuração 2: tempo = 250 e hsi = "s"

Configuração 3: tempo = 250 e hsi = "i"

Configuração 4: sequência de 4 applets, de tamanhos diferentes, tempo = 250 e hsi = "h"

Explicações que podem ser úteis

Para poder criar applets com efeitos gráficos interessantes é necessário conhecer e dominar imagens. Neste applet "brincamos" um pouco com o matiz, a saturação e a intensidade das cores. É o nosso primeiro contato com o modelo HSI.

A declaração da classe

Precisamos apenas dos pacotes java.applet.* e java.awt.* para implementar este applet. A novidade na declaração da classe barraCor está em implements Runnable. Isto cria uma interface Runnable, o que quer dizer que nosso applet vai conter um método run que irá gerenciar seu comportamento. Para isto ser possível, precisamos também criar um ou mais threads adicionais, que são as linhas de execução. Não deixe de ler "O que são threads e como domá-los" antes de prosseguir.

Como precisamos de um thread para controlar o comportamento do nosso applet, declaramos as variáveis Thread linha = null; e boolean vivo = true;

O método init()

No método init() verificamos a existência de parâmetros e, caso existam, atribuímos à variável int tempo o valor do parâmetro tempo (tempo de espera entre a troca de cores) e à variável String tipo o valor do parâmetro hsi (tipo de troca de cor).

O método start()

No método start() criamos a linha de execução, a Thread linha. A esta altura já sabemos que o método start() é executado toda vez que a página que contém nosso applet se tornar ativa no browser. Portanto, se a linha de execução não existir (if (linha == null)), criamos uma nova (linha = new Thread(this) - "this" significa "este applet") e a tornamos ativa com linha.start(). A seguir, atribuímos à variável vivo o valor true (vivo = true;), a qual indica que o thread se encontra no estado ativo (executando).

O método run()

Se o applet implementa a interface Runnable e já possui um thread adicional, a presença de um método run() é obrigatória, porém o método run() só atua se o thread de execução estiver ativo ( while(vivo) ), e vivo só é verdadeiro se a página que contém o applet estiver ativa. Caso o usuário mude de página, o thread é desativado pela Java, assim como todos os procedimentos a ele associados. Não sobra "lixo" e os recursos da máquina do usuário são liberados. É claro que a variável vivo precisa indicar esta nova situação. Como sabemos que o método stop() é chamado quando o thread "morre", é neste ponto que atualizamos a variável (veja o o método stop).

A primeira coisa que o método run() faz é solicitar uma nova pintura de tela através de repaint(). O método repaint() aciona os métodos update() e paint(). Com a tela atualizada, fazemos nossa linha de execução "dormir" durante o período indicado pela variável tempo, ou seja, Thread.sleep(tempo). Caso o thread não possa "dormir" porque a execução é interrompida, a Java gera um estado de exceção que pode ser "capturado" e resolvido. Por isto usamos try { ... } seguido de catch(InterruptedExecution _ex) { }. E o que fazemos com este estado de exceção? Nada, ou seja, { } indica para a JVM (Java Virtual Machine) para eliminar o alerta de exceção e continuar seu processamento normalmente.

A seguir testamos se a variável tipo é igual a "h", "s" ou "i". Caso seja igual a "h" ou a "H" (if(tipo.equalsIgnoreCase("h"))), então soma-se 0.05 ao valor de hue (hue += 0.05F), aumentando-o em 5%. Se, depois de incrementado, o valor de hue for maior que 1, seu valor volta a ser 0 (zero). Hue significa matiz e expressa a cor básica predominante de uma imagem. Seu valor varia de 0 a 1 (0% a 100%). 0% é vermelho, 8% é laranja, 17% é amarelo, 33% é verde, 50% é azul turqueza, 67% é azul, 84% é magenta, etc. Por isto o primeiro applet parece um arco-iris: alterna todas as cores do matiz. Veja o tutorial Entendendo imagens e cores que fica bem mais fácil de entender.

Se tipo for igual a "s" ou "S" (if(tipo.equalsIgnoreCase("s"))), então somamos 0.05 ao valor de satu (satu += 0.05F), aumentando a saturação em 5%. Se depois de incrementado o valor de satu for maior que 1, atribuímos a essa variável o valor 0. A saturação indica o quanto a cor básica predominante (o matiz) é "diluído" por luz branca.

Caso tipo seja igual a "i" ou "I" (if(tipo.equalsIgnoreCase("i"))), somamos 0.05 ao valor de inten (inten += 0.05F), aumentando a intensidade em 5%. Também tornamos inten igual a zero se ultrapassar o valor de 1. A intensidade indica a quantidade de luz refletida pela imagem, ou seja: muita luz, a imagem está clara; pouca luz, a imagem está escura.

Neste ponto, as variáveis que controlam o modelo de cores do nosso applet estão atualizadas. Terminada a rotina do método run(), se o thread ainda estiver vivo, começa tudo de novo. O método é repetido e chama repaint() com os novos valores de hue, satu ou inten.

O método upgrade()

O método update(Graphics g) nada mais faz do que chamar o método paint(). Não há necessidade de implementar código por que não precisamos refazer o fundo da nossa imagem, principal função do update.

O método paint()

O método paint(Graphics g), apesar de pequeno, é o coração do nosso applet.

Inicialmente, atribuímos à interface gráfica Graphics g uma nova cor através do método setColor(). Este método exige como parâmetro um objeto Color, o qual definirá a cor que será utilizada para desenhar na tela do applet. O objeto da classe Color também possui seus métodos, entre eles um que utiliza o nosso desejado modelo de cores HSI: é o método getHSBColor(). Este, por sua vez, exige como parâmetros o matiz, a saturação e a intensidade (ou brilho, por isso HSB). O valor de retorno deste método é um objeto Color, então... g.setColor(Color.getHSBColor(hue, satu, inten)) torna ativa a cor que desejamos, ou seja, qualquer pintura efetuada após esta linha será na cor indicada.

Dissecando esta linha de comando - poderíamos tê-la dividido em duas, por exemplo:

Uma vez definida a cor desejada, solicitamos que seja desenhado um retângulo preenchido a partir das coordenadas x = 0 e y = 0 até as coordenadas x = largura do applet e y = altura do applet. Temos então: g.fillRect(0, 0, d.width, d.height).

A cada novo valor de hue, a cor do retângulo será diferente (applet 1). A cada novo valor da saturação, a cor do retângulo será mais "aguada", mais misturada com branco (applet 2) e a cada novo valor da intensidade, a cor do retângulo será mais clara (applet 3).

O método stop()

Quando o usuário abandona a página onde reside nosso applet (ou por motivos outros), o método stop() é invocado. No nosso caso, sua única e importantíssima missão é "desligar" nossa linha de execução e deixar que a Java faça a faxina (liberando variáveis, threads ocultos, etc) antes de "matar" o thread que nós ativamos... ou seja, não sobra lixo e os recursos da máquina são liberados. Basta dizer que a variável vivo é falsa que o método run() será interrompido e deixando que a Java assuma o comando.

Lição de casa

Modifique e amplie o código deste applet. Sugestões:

1. Passe a cor básica (hue) inicial como parâmetro.
2. Passe um parâmetro para indicar o valor do incremento de hue, satu e/ou inten.
3. Configure seu applet em diversos tamanhos. Por exemplo, um applet de 20 x 20 funciona como um marcador (bullet) interessante.

Finalmentes

Se o "coração" do nosso applet é o método paint(), pode-se dizer que o "cérebro" é o método run(). Aliás, na maioria dos applets que lidam com transformação de imagem, o run() é vital e contém o algoritmo principal.

O código fonte, a classe compilada e o texto deste tutorial podem ser baixados na seção de downloads em tutoriais/java.

Bons estudos e sucesso!

vó Vicki