Este código faz a Correlação em uma imagem com uma máscara simples de pesos 1 e tamanho 3×3. É possível ver que a imagem resultante da convolução teve um leve “borramento”.
O tempo de execução do algoritmo para aplicar a máscara simples foi de 2.331 segundos. Com a imagem “percorrendo” a máscara, o tempo foi de 0.00454 segundos. Desta última forma, há maneiras implícitas de executar um for para percorrer algumas linhas e colunas da imagem, o que ajuda a tornar o processo muito mais rápido.
# -*- coding: utf-8 -*-
"""
@author: Rafael Zottesso
"""
# Apenas para contagem de tempo
import timeit
# Outros imports necessários
import numpy as np
import cv2
# Cria uma função para fazer a correlação simples, movendo a máscara sobre a imagem
def correlacao_comum(img, img_corr, mascara):
# Percorre cada pixel da imagem
for x in range(img.shape[0]):
for y in range(img.shape[1]):
# Usa o try porque algumas coordenadas não existem, assim não apresenta o erro. As bordas não estão sendo consideradas.
try:
# Cálculo da máscara coluna a coluna: multuplica o peso que está na máscara pela intensidade do pixel
### Máscara simples, primeira coluna ##
m = img[x-1][y+1] * mascara[0][0]
m += img[x-1][y] * mascara[1][0]
m += img[x-1][y-1] * mascara[2][0]
# Segunda coluna
m += img[x][y+1] * mascara[0][1]
m += img[x][y] * mascara[1][1]
m += img[x][y-1] * mascara[2][1]
# Terceira coluna
m += img[x+1][y+1] * mascara[0][2]
m += img[x+1][y] * mascara[1][2]
m += img[x+1][y-1] * mascara[2][2]
# Faz a média dos valores e guarda como intensidade do pixel
img_corr[x][y] = m/9
# Quando a coordenada não existir, passe para o próximo pixel
except:
continue
return img_corr
# Função com a imagem percorrendo a máscara (contrário da outra)
def correlacao_rapida(img, img_corr, mascara):
# criando uma nova imagem = tamanho da imagem + bordas da mascara
img_corr_rap = np.zeros(np.array(img.shape) + np.array(mascara.shape) - 1)
# Percorre a máscara
for x in range(mascara.shape[0]):
for y in range(mascara.shape[1]):
# Copia os valores para a imagem nova, que é maior para armazenar o cálculo
img_corr_rap[x:x+img.shape[0], y:y+img.shape[1]] += img * mascara[x,y]
return img_corr_rap.astype('uint8')
# imread ( nome da imagem, [1=cor, 0=grayscape, -1=alpha])
# Cada coluna da imagem é armazenada em um subvetor, onde cada coluna é uma posição
img = cv2.imread('./Imagens/original.jpg', 0)
# Abre a imagem novamente para comparar com a original
img_corr = cv2.imread('./Imagens/original.jpg', 0)
# Cria uma máscara simples com o mesmo peso
mascara = np.array([ [1,1,1], [1,1,1], [1,1,1] ])
################### Comum ################
# Verifica o horário inicial da convolução
time_start = timeit.default_timer()
# Executa a função de correlação
img_corr_comum = correlacao_comum(img, img_corr, mascara)
# Verifica o tempo final da convolução
time_end = timeit.default_timer()
# Apresenta a duração do processo de convolução
time = time_end - time_start
print 'Tempo de processamento Comum:', time, 'segundos'
################ Rápida #######################
# Verifica o horário inicial da convolução
time_start = timeit.default_timer()
# Executa a função de correlação
img_corr_rapida = correlacao_rapida(img, img_corr, mascara)
# Verifica o tempo final da convolução
time_end = timeit.default_timer()
# Apresenta a duração do processo de convolução
time = time_end - time_start
print 'Tempo de processamento Rápida:', time, 'segundos'
# Mostrar imagem
# nome da janela, matriz
cv2.imshow('Original',img)
cv2.imshow('Correlação Másc. Simples',img_corr_comum)
cv2.imwrite('./Imagens/original_corr.jpg', img_corr_comum)
# Funções para funcionamento correto ao mostrar a imagem numa janela
cv2.waitKey(0)
cv2.destroyAllWindows()
Imagens resultantes
# Imagem original
# Após a convolução com a máscara imples
