A teoria

Inverter uma imagem é fazer com os valores dos pixels invertam seus valores, na escala em que estão. Em imagens tons de cinza de 8-bits os valores dos pixels vão de 0 a 255. A inversão faz com que os pixels que têm valor 0, passem a valer 255, os que tem valor 1 passem a valer 254, e assim por diante. Normalmente representa-se esta operação por uma fórmula simples:

pixel_resultado = valor_máximo – pixel

No caso de imagens RGB (ou muiti-canais em geral), inverte-se cada canal como está descrito acima, e no caso de imagens binárias o zero vira um e o um vira zero.

Inversão de imagens RBG, cinza e binária.

A imagem dos grilos é do Thiago Gama Oliveira.

Na JAI

A JAI tem a operação “invert”, que à primeira vista parece resolver isso tudo… mas não é bem assim. Em imagens binárias, o “invert” não modifica os pixels, modifica o mapa de cores. Isto significa que os píxels continuam tendo os mesmos valores que os originais, mas a aparência deles (a cor exibida no monitor) muda.

Na documentação da JAI isto quase não aparece, ou é citado rapidamente como um recurso de otimização. E não seria mesmo algo ruim se todos os usuários estivessem interessados somente no visual da imagem. Mas quando precisa-se dos valores dos pixels para cálculos posteriores a coisa complica.

Procurando por uma solução achei este registro de bug de 2006 lá na JAI, com tudo explicado, inclusive exemplo, e uma tentativa de solução que deveria funcionar, mas não funciona. O registro está lá, mas não foi resolvido ainda – e pela idade acho que não vai ser resolvido nunca.

Em resumo, a JAI inverte a tabela de cores, e não os pixels. Mas ao usar a imagem invertida para outras operações ela desconsidera a tabela de cores! Assim, inverter a imagem e depois somar com outra tem o mesmo resultado de somar as duas sem inverter antes. A operação “not”, que é um tipo de inversão específica para imagens binárias, tem o mesmo problema.

Conclusão: a JAI não inverte imagens binárias corretamente.

Depois de algumas semanas de pesquisa, e daquela conhecida frustração de achar que era eu que não sabia usar os métodos corretamente, resolvi partir para uma implementação independente da inversão. Não ficou otimizada, nem eu me dei ao trabalho de implementá-la estendendo a JAI, como manda o figurino, mas funciona.

Na verdade usei alguns artifícios dos quais não me orgulho, mas fiz porque não encontrei alternativas mais elegantes – provavelmente vou encontrar, a aí publico o código novamente. Mas por hora incluí a minha classe aqui para quem quiser utilizar (com licença GPL).

BinaryInvert.java
Obs: O arquivo está “zipado” porque .java aparentemente é uma ameaça de segurança para o meu provedor.

Bom, se alguém olhar e achar que tem uma foma beeeeem mais fácil de fazer isso, não pense que vai me ofender – por favor me diga! Na verdade estou torcendo para que isto aconteça…

Até mais!

A JAI

Java Advanced Imaging é o nome da biblioteca da sun para processamento de imagens. O tutorial mais completo que connheço é este (mas repare que é de 1999…). Também não existe um livro para quem precisa entender ele a fundo, então as minhas principais ferramentas de estudo foram:

• A documentação da API
• O código

É, algumas vezes só olhando o código, mesmo…

Também tive a ajuda de colegas que aprenderam antes de mim, e de um tutorial em português organizado por eles, que estamos organizando para distribuir.

OK, now codding:

Depois de baixar a biblioteca, configurar o IDE, e iniciar um projeto, vem aquela sensação de “papel em branco”. O que resolve isso é uma classe main que abre a imagem e mostra a imagem (ou salva). Depois disso pronto é só achar o método que você precisa usar e colocar no meio…

Código para abrir a imagem (comece com este):


PlanarImage imagem = JAI.create("fileload", "caminho e nome do arquivo");


Para mostrar a imagem:

DisplayJAI display = new DisplayJAI(imagem); //altere o nome da variável se o resultado da sua operação tiver outro nome
//cria o frame do swing onde a imagem será exibida
JFrame frame = new JFrame("Imagem X");
//cria o scroll para efetuar as rolagens caso a imagem seja muito grande
JScrollPane scroll = new JScrollPane();
//adiciona o display dentro do scroll
scroll.setViewportView(display);
//adiciona o scroll dentro do frama
frame.add(scroll);
//define a operação padrão para o botão fechar do frame
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 400); //define o tamanho do frame
frame.setVisible(true); //manda o frame ser exibido


Entre estes dois trechos de código, coloque a operação JAI de sua preferência… isso funcionou como ponto de partida para mim.

Livros! (Update, dia 11/03/2010)

Foi só falar que não tinha, que pipocaram links de livros de vários lugares. Como alguns foram por email, outros por comentários, vou listar eles aqui:

• Building Imaging Applications Java Technology
• Java Media APIs: Cross Platform Visualization
• Digital Image Processing: Practical Introduction
• Digital Image Processing: Algorithmic Introduction

Muito Obrigada pelas contribuições!

Estou estudando a JAI agora, por isso espero ter mais posts sobre ela em breve. Interessou? Assine o RSS.