Processamento Digital de Imagens (DCA0445)

A imagem utilizada como base está sendo mostrada na Figura 1.

Apesar da imagem em questão ser representada em tons de cinza, a solução deste exercício foi pensada para uma imagem genérica e, portanto, optamos por ler a imagem em matrizes de cores utilizando a flag cv2.IMREAD_COLOR.

Extraímos, então, as dimensões da imagem e o número de canais utilizando o atributo shape.

Na sequência, solicitamos ao usuário as coordenadas dos pontos de interesse P1 e P2. A partir das coordenadas fornecidas, percorremos os pixels que compõem o retângulo entre esses dois pontos, invertendo os tons de todos os canais.

Para exibir o resultado, precisou-se utilizar a função cv2_imshow(), a qual é uma versão compatível com o Google Colab de cv2.imshow(). O resultado final tomando-se a Figura 1 como entrada e considerando os pontos P1=(90, 190) e P2=(220, 120) está exposto na Figura 2.

Aplicando como entrada uma imagem colorida, obtivemos o seguinte resultado.

Da mesma forma que o exercício anterior, lemos a imagem e extraímos os seus dados essenciais. Vale ressaltar que para que a troca dos quadrantes seja possível as dimensões da imagem devem ser pares. Adicionamos, portanto, duas condicionais: caso uma das duas dimensões da imagem seja ímpar, descartaremos a última linha e/ou coluna do array.

Em seguida, calculamos a metade das dimensões para uso posterior e criamos um novo array para armazenar a imagem trocada.

Por fim, invertemos os quadrantes da figura selecionando as regiões da imagem de origem e atribuindo-as às suas novas posições utilizando slicing de arrays, como mostra o trecho de código abaixo.

Exibimos, então, o resultado armazenado em img_trocada, obtendo a figura final, como pode ser visto a seguir.

Como a lógica do programa foi pensada para uma imagem genérica, aplicou-se uma figura colorida com dimensões de 814 x 543 pixels, a fim de verificar o seu funcionamento. O resultado é apresentado na Figura 5.

O código completo pode ser encontrado em: trocaregioes.ipynb.

Existe uma limitação de valores em 255 tons de cinza distintos em razão do tipo de variável que está sendo utilizada (unsigned char). A proposta de solução é utilizar uma matriz do tipo int ou float para aumentar as possibilidades de contabilização. Para além disso, poderíamos também adaptar o algoritmo para o sistema RGB, possibilitando a criação de 255³ rótulos, que são diferenciáveis na visão computacional.

Como devemos levar em consideração que podem existir bolhas com mais de um buraco, a imagem a ser utilizada como base para este código é mostrada na Figura 6.

Inicialmente, lê-se o arquivo e as dimensões da imagem. Logo após, percorremos todos os pixels de borda, aplicando um flood fill da cor do fundo (tom 0) sempre que nos depararmos com um pixel branco no percurso.

A variável num_bolhas_borda armazena o número de bolhas que foram excluídas da figura e é incrementada sempre que chamamos a função cv2.floodFill(). A nova imagem, dada por img_aux, é mostrada na Figura 7.

Na sequência, faremos o labeling das bolhas presentes na nova imagem. Para isso, percorremos todos os pixels da figura, procurando novamente por pixels brancos. Ao encontrarmos uma nova bolha, incrementamos a variável num_bolhas e aplicamos o flood fill com o tom correspondente ao valor atual do contador.

Ao fim deste processo, conheceremos a quantidade total de bolhas e cada uma delas estará sendo representada por um tom de cinza diferente, como exposto na Figura 8.

Para realizar a contagem das bolhas com buracos, iniciamos pintando o fundo de branco, aplicando um flood fill no ponto (0,0), de modo que apenas os buracos apresentem tom de cinza 0.

Varremos novamente a figura, dessa vez buscando os pixels pretos e aplicando neles um flood fill com a cor do fundo. Verificamos, então, o pixel antecedente: caso este seja diferente de 220, incrementamos a variável num_bolhas_buracos e pintamos a bolha que contém o buraco em questão com o tom de cinza 220; caso contrário, temos que a bolha já foi contabilizada.

O trecho de código acima garantirá que nenhuma bolha seja contabilizada mais de uma vez e fará com que as bolhas com buracos fiquem destacadas na figura, como vemos abaixo.

Obtemos, enfim, a seguinte saída: A figura tem 7 bolhas com buracos e 14 bolhas sem buracos. O código completo pode ser encontrado em: labeling.ipynb.

Para realizar a captura de imagens através de uma câmera (webcam), utilizamos a função cv2.VideoCapture().

Em segunda instância, definimos o tamanho da tela de exibição como (512 x 480) e o número de tonalidades como 256, podendo apresentar valores de 0 a 255 (o segundo valor de hist_range é exclusive).

O parâmetro bin_w define a largura ocupada por cada tom de cinza no histograma.

Na sequência, convertemos cada frame capturado para escala de cinza e realizamos a equalização com a função cv.equalizeHist(). A partir de agora, os processos ocorrerão em loop para todos os frames coletados em tempo real enquanto não existir uma condição de interrupção do programa.

Após a equalização dos tons de cinza, faremos o cálculo do histograma por meio da função cv2.calcHist() empregando os parâmetros previamente definidos como argumentos. Depois disso, normalizaremos os histogramas gerados com a função cv2.normalize().

Com isso, criamos um conjunto de barras verticais (representação de um trem de pulsos), que partem do eixo horizontal e vão até o ponto do valor calculado, a fim de representar a quantidade de pixels de cada tom de cinza do frame.

Exibimos, então, a captura gerada pela webcam e o seu histograma:

Após a aplicação da equalização com o nosso programa, geramos o seguinte resultado:

Nota-se que, como a captura foi realizada em um ambiente com boa iluminação, o histograma se encontra concentrado em uma região mais clara. Após equalização, percebemos uma distribuiçao mais uniforme das intensidades dos pixels na imagem gerada e um melhor constraste.

Para apreciar melhor os resultados da equalização, vamos introduzir uma imagem com pouco contraste, sendo a captura realizada em local com baixa iluminação. Note que os pixels estão agrupados, predominantemente, no lado mais a esquerda do histograma.

Abaixo visualizamos o resultado da equalização e do novo histograma obtido. Verifica-se uma clara redistribuição dos pixels imagem por todo o histograma.

Apesar de conseguirmos visualizar melhor alguns detalhes da imagem equalizada em comparação com a imagem escura, o ruído está muito presente.

O código completo pode ser encontrado em: equalize.py.

Este programa utiliza as alterações no histograma dos frames do vídeo capturado para detecção de movimentos. Partindo de uma estrutura semelhante ao do algoritmo anterior, calcularemos, para cada frame, o histograma da componente vermelha e o compararemos com o histograma que o antecedeu.

Precisamos, inicialmente, separar os canais da imagem:

Assim, calculamos e normalizamos o histograma atual do canal vermelho.

Para a condição inicial em que não temos um frame anterior para comparação, inicializamos uma variável inicio = True e atribuímos a hist_anterior o histograma atual que está sendo gerado. Terminada esta ação, a variável inicio passa a ser False.

Os histogramas são comparados por meio da função compareHist() e o resultado é inserido na varivável dif, que representa o quanto o histograma do frame atual difere do anterior. Para tal, utilizamos a métrica cv2.HISTCMP_BHATTACHARYYA, a qual retorna valores entre 0.0 e 1.0, em que quanto mais próximo de 0.0, maior é a semelhança entre as imagens.

A partir disso, comparamos o valor encontrado (em %) ao limiar, que foi definido como 3 após alguns testes para alcançar a sensibilidade desejada. Quando este é ultrapassado, uma mensagem de Movimento detectado ! é exibida na imagem.

O resultado pode ser observado abaixo:

O código completo pode ser encontrado em: motiondetector.py.

Inicialmente, adaptamos o código citado no exercício para a linguagem Python. Nele, o usuário pode escolher o efeito (módulo, média, gaussiano, bordas horizontais, bordas verticais, laplaciano e boost) que deseja aplicar às imagens capturadas em tempo real por meio das teclas do teclado.

Nota-se que foram adicionadas duas novas funcionalidades ao programa: o filtro laplaciano do gaussiano e o salvamento em arquivo do frame atual com filtro aplicado.

Para realizar o laplaciano do gaussiano, foi criada uma flag (laplacian_gauss) que retorna True quando o comando (tecla f) é ativado. Dessa forma, primeiramente selecionamos a máscara adequada para aplicar o filtro gaussiano e, em seguida, criamos uma expressão condicional baseada na flag em questão a fim de aplicar o laplaciano em cima da imagem já filtrada previamente.

Quando outras opções de filtro são escolhidas, a variável laplacian_gauss é setada para False e, portanto, nenhum processo adicional é realizado no frame.

Na sequência, verificamos se os valores mostrados devem ser absolutos ou não e transformamos os dados da matriz resultante que representa a imagem final em valores unsigned de 8 bits (0 a 255), para, só então, exibí-la em uma janela, assim como a imagem original.

Para comparar os efeitos do filtro laplaciano e laplaciano do gaussiano, utilizamos como entrada do programa a imagem exposta a seguir.

O comparativo entre os dois resultados é mostrado na Figura 17. Percebe-se que, ao aplicarmos o filtro gaussiano, que realiza um borramento, antes do laplaciano, atenuamos os ruídos da imagem tornando as bordas mais precisas na figura resultante, dando a impressão de uma imagem mais escura.

O código completo pode ser encontrado em: laplgauss.py.

Para este código, inicialmente lemos a imagem de entrada do programa, armazenando-a na variável img1. Em seguida, a img2 é obtida aplicando-se cinco vezes o filtro da média com máscara 5x5 na imagem original, a fim de alcançar um efeito de borramento com intensidade desejável.

Criamos a janela e também as barras de ajuste solicitadas no exercício utilizando a função cv2.createTrackbar(), definindo um slider que inicia em 0 e pode ir até 100. Um dos parâmetros exigidos para esta criação é uma função de callback, a qual será chamada sempre que o usuário interagir com a barra de rolagem.

Ao chamar o callback, a função apresentada acima automaticamente envia como argumento o valor atual da barra que foi ajustada. Por esse motivo, a função on_trackbar() possui um argumento (val), mas este não é utilizado em seu interior, uma vez que optamos por usar a mesma função de callback para todas as três barras. Como alternativa, coletamos a posição atual de todos os sliders localmente, utilizando a função cv2.getTrackbarPos() sempre que há alteração.

Para simular o efeito do tilt-shift, fazemos uma soma ponderada entre a imagem e sua versão borrada por meio da função cv2.addWeighted(). Esse processo pode ser modelado por uma função que define a região de desfoque ao longo do eixo vertical da imagem:

em que \(x\) representa as linhas da imagem, \(l_1\) e \(l_2\) são os limites verticais para a região sem borramento cujo \(\alpha\) assume valor em torno de 0.5 e \(d\) indica a força do decaimento da região normal para a região borrada.

Para evitar o erro de divisão por zero, foi acrescido ao decaimento um valor de 0.001. Além disso, antes de atribuir os novos parâmetros, verificamos se os valores de altura da região sem borramento e o centro determinado são compatíveis para que o tamanho da imagem não seja excedido.

Ao final, exibimos na janela o resultado dessa combinação linear e o armazenamos na variável global img_final, a fim de disponibilizar a imagem atual para ser salva em arquivo pelo comando s.

Para verificar o funcionamento do código, utilizamos a imagem abaixo como entrada do programa.

Ao realizarmos o ajuste das barras (altura: 70; centro: 48; decaimento: 22), chegamos no resultado apresentado na Figura 19.

O código completo pode ser encontrado em: tiltshift.py.

Este caso é uma aplicação do exemplo acima, em que cada quadro do vídeo é processado como realizado anteriormente e alguns quadros são descartados para criar um efeito de stop motion.

O vídeo utilizado para exemplificação está disposto abaixo.

O algoritmo usará os parâmetros de ajuste que são fornecidos pelo usuário através da mudança das barras de rolagem para calcular os valores de \(\alpha\), que é um vetor do tamanho da imagem. Esse efeito, que a princípio é gerado no frame inicial, repercutirá por todos os frames restantes compondo o vídeo final.

Como o mesmo efeito será aplicado para todos os frames do vídeo, uma vez definida a configuração, não será necessário recalcular os parâmetros. Por esse motivo, tratamos o vetor \(\alpha\) como uma variável global que será constantemente atualizada pela função de callback das barras para, enfim, ser utilizada dentro da função tiltshift() repetidas vezes durante a criação do vídeo.

Essa função recebe como argumento o frame original e o frame borrado e retorna a imagem com o efeito do tilt-shift aplicado. O seu algoritmo segue a mesma lógica que o exercício anterior.

Como requisito do programa, a função salvarvideo() grava o resultado do efeito aplicado no vídeo. O objetivo da função cv2.VideoWriter() é, portanto, salvar o vídeo final em arquivo, definindo o nome (video_tiltshift.mp4), extensão, taxa de frames por segundo e as dimensões do vídeo (iguais ao original).

Para criar o efeito de stop motion, uma condição descarta é imposta e a variável taxa determinará esse descarte. Nesse processo, os frames que são múltiplos do valor armazenado em taxa devem ser mantidos, ou seja, a cada 8 frames do vídeo original, extraímos 1 frame para o vídeo final.

Quando o usuário concluir a sua configuração, ele pode pressionar a tecla s para salvar o resultado no arquivo de vídeo video_tiltshift.mp4.

O resultado do efeito tilt-shift no vídeo mostrado previamente pode ser visualizado abaixo.

O código completo pode ser encontrado em: tiltshiftvideo.py.

Neste exercício, resolveremos problemas de distribuição irregular de iluminação em imagens utilizando o filtro homomórfico.

O filtro homomórfico é uma versão modificada do filtro gaussiano e atua sobre as componentes de reflectância e iluminância da imagem, a partir da seguinte equação matemática:

Os parâmetros do filtro (\(\gamma_{H}\), \(\gamma_{L}\), \(D_{0}\) e \(c\)) são ajustados pelo usuário a fim atingir o resultado desejado: reduzir os efeitos causados pela má iluminação na imagem original. O algoritmo implementado segue os passos descritos a seguir.

Primeiramente, realiza-se o padding da imagem e aplica-se a transformada de Fourier, transferindo a análise para o domínio da frequência.

Em seguida, desloca-se o centro do seu espectro, invertendo os quadrantes da imagem (A↔D, B↔C) por meio da função deslocaDFT().

Na sequência, multiplica-se a função na frequência pelo filtro (\(G(u,v) = H(u,v)F(u,v)\)) e retoma-se a configuração original dos quadrantes da imagem invertendo nocamente os quadrantes.

Finalmente, calcula-se a transformada inversa do produto e extrai-se a parte real da imagem no domínio espacial.

Detendo-se ao filtro em si, definimos a função filtro_homomorfico() que implementará o equacionamento matemático. Como comentado anteriormente, o algoritmo usará os parâmetros do filtro, os quais são fornecidos pelo usuário através do controle das barras deslizantes, que variam de 0 a 100.

A variável tmp corresponde à matriz temporária utilizada para criar as componentes real e imaginária do filtro. Com isso, define-se D(u,v) e implemeta-se o filtro, exibindo o resultado em janela. Enfim, cria-se a matriz com as componentes do filtro e combina ambas em uma matriz multicanal complexa.

Para exemplificar, foi gerado um filtro com os seguintes parâmetros: \(\gamma_{H}=89\), \(\gamma_{L}=35\), \(D_{0}=70\) e \(c=96\), obtendo o resultando abaixo. Verifica-se que este facilita a passagem de componentes de frequências mais altas (reflectância) em detrimento das frequências mais baixas (iluminância).

A imagem original utilizada de teste é apresentada na Figura 22. Em seguida, é mostrada a imagem após a realização da filtragem homomórfica.

O código completo pode ser encontrado em: homomorfico.py.

Neste programa, iremos simular a técnica do pontilhismo desenhando digitalmente pequenos círculos na imagem escolhida. Estes círculos serão separados por pequenos intervalos e deslocados de seu centro de forma randômica.

Inicialmente, definiremos a função pontilhismo() para aplicação da técnica desejada. As variáveis STEP, JITTER e RAIO são determinadas de antemão. Detalhando melhor esses parâmetros, temos que STEP define o passo usado para varrer a imagem de referência, JITTER regula o intevalo de separação (espalhamento) dos elementos e RAIO corresponde a distância entre um ponto de cada círculo gerado e seu centro.

xrange e yrange são arrays de índices que armazenam as coordenadas dos pontos em que vão ser colocados os círculos do pontilhismo, preenchidos com valores sequenciais iniciando em 0, além de receberem um ganho igual a STEP e um deslocamento STEP//2.

Após embaralhar aleatoriamente os pontos através da função random.shuffle(), os loops mostrados acima fazem com que as variáveis i e j assumam, a cada iteração, os valores dos arrays xrange e yrange de forma consecutiva.

A imagem que será utilizada para aplicação da técnica de pontilhismo é mostrada abaixo:

Para melhorar a qualidade das imagens que geraremos com a técnica do pontilhismo, podemos utilizar a detecção de bordas de Canny. O algoritmo de Canny é um dos mais rápidos e eficientes algoritmos de detecção de bordas ou descontinuidades. A saída desse algoritmo é uma imagem binária em que todas as bordas são representadas com valor 255 (branco) e os demais pixels com valor 0 (preto).

A trackbar está associada à função on_trackbar_canny(). Nessa função, são gerados círculos a partir dos pixels de borda detectados, de modo a evidenciar os contornos. Com isso, denota-se que o limiar \(T_2\) empregado é determinado pelo usuário a partir da interação com o slider, enquanto o \(T_1\) é obtido considerando a proporção de 3:1.

O processo é repetido quatro vezes e, à medida em que aumentam-se os limiares, são criados círculos menores. Para impedir a repetição excessiva, os círculos são desenhados alternadamente sobre os pontos que compõem as bordas da imagem, evitando os pontos consecutivos.

Após aplicação, os resultados com variação de threshold podem ser observados abaixo:

A seguir, visualizamos outro teste realizado e a imagem aplicada a técnica de pontilhismo, com threshold de 20.

O código completo pode ser encontrado em: cannypontilhism.py.

O k-means é um processo de quantização que visa classificar N observações em K aglomerados. É um processo iterativo em que extrai-se a distância média das amostras em cada aglomerado, redefinindo as posições dos centroides a cada passo. Esse processo acontece até não termos mais mudanças significativas nas posições dos centroides.

No programa em questão, implementaremos o procedimento descrito acima começando com centroides aleatoriamente determinados, devido à escolha do parâmetro KMEANS_RANDOM_CENTERS. Definido na variável criteria, o critério de parada se dá ao atingir o número máximo de 10000 iterações ou o erro \(\epsilon\) de valor 0,0001.

Conforme solicitado, o algoritmo é rodado dez vezes, gerando dez imagens distintas. Como os centros dos agrupamentos são escolhidos, inicialmente, de forma aleatória, esses pontos mudarão a cada rodada, promovendo imagens relativamente diferentes. Isto ocorre devido à natureza não determinística do método k-means, a qual pode levar a diferentes valores de convergência de acordo com os pontos de partida ou, em alguns casos, sequer encontrar uma convergência.

As imagens geradas a partir da Figura 24 foram aglomeradas em um arquivo .gif, a fim de compararmos os resultados obtidos em cada iteração.

O código completo pode ser encontrado em: kmeans.py.

Sabe-se que os seres humanos possuem a capacidade de compreender o conteúdo de uma imagem apenas pela observação e interpretação de símbolos. Assim, podemos facilmente reconhecer um texto contido em uma imagem e fazer a sua leitura.

No dia a dia, frequentemente necessitamos da digitalização dessas informações, principalmente quando lidamos com documentos, fazendo-se necessário processar, extrair o texto e armazená-lo de forma editável. Nesse contexto, é bastante conveniente e torna-se muito mais fácil e rápido fazer determinados trabalhos, pesquisar uma dada informação ou manipular o conteúdo de um relatório, por exemplo, quando fazemos essa conversão de forma automática.

Assim, o algoritmo do Scanner Inteligente foi idealizado com o intuito de extrair automaticamente textos impressos e dados de documentos digitalizados em tempo real. Esse recurso integra os assuntos abordados na disciplina de Processamento Digital de Imagens e faz o reconhecimento óptico de caracteres (OCR), buscando o melhor enquadramento e disposição do conteúdo do documento de interesse e convertendo o texto detectado nas imagens em arquivo de texto (.txt), usando bibliotecas Python.

A descrição detalhada da implementação deste algoritmo, bem como os resultados obtidos, podem ser acessados clicando aqui.

O código completo pode ser encontrado em: scanner.py.