Tarea1. Detección de Bordes

Para la tarea 1 se nos pido que realizaramos la detección de bordes en una imagen y binarizarla donde los pondría en color blanco y el resto de la imagen negro.

Para llegar esté objetivo se aplicaria primeramente un mascara de convolución, para la cual realice lo siguiente:

La imagen original es:

 

Obtener una imagen en escala de grises mostrada en lab

	import pygame, sys, os # Importe pygame para la creacion de la ventana
	#from pygame.locals import *
	from sys import argv # Importe para tabajar con argumentos
	import Image #Importe para trabajar con Image (PIL)
	#Convierte la imagen en escala de grises
	def pixel():
	ima = argv[1]
	im = Image.open(ima)
	imagen=im.load()
	ancho, alto = im.size
	for i in range(ancho):
	for j in range(alto):
	(r,g,b)= im.getpixel((i,j))
	pix = (r + g + b)/3
	imagen[i,j]=(pix, pix, pix)
	nueva= 'nueva.png'
	im.save(nueva)
	return nueva
	def main():
	pygame.init() # Inicializa pygame
	screen = pygame.display.set_mode((380, 300)) #Crea la ventana con las dimensiones de la imagen
	pygame.display.set_caption('Escala de Grises') #Se define el nombre de la ventana
	imagen = pixel() # La imagen toma los nuevos valores
	img = pygame.image.load(imagen) # Carga nuestra imagen
	screen = pygame.display.get_surface() # Se utiliza para mostrar la imagen en la ventana
	while True: # Ciclo para las acciones en la ventana
	for event in pygame.event.get():
	if event.type == pygame.QUIT:
	sys.exit()
	screen.blit(img, (0,0)) # muestra la posicion de la imagen en x = 0 y y=0
	pygame.display.update()
	if __name__ == "__main__":
	main()

view raw EGrises.py hosted with ❤ by GitHub

Después de esto aplicar un filtro a la imagen donde se verá que es mas borrosa y asi poder identificar los bordes.

	import sys,pygame
	import Image
	from sys import argv
	from math import*
	import numpy
	import time
	import math
	def main():
	ima,ancho,alto,vecino_n= pixel(argv[1])
	i_filtro = filtros(ima,ancho,alto,vecino_n)
	screen = pygame.display.set_mode((ancho,alto))
	pygame.display.set_caption('Imagenes')
	img = pygame.image.load(i_filtro)
	screen = pygame.display.get_surface()
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	sys.exit(0)
	screen.blit(img,(0,0))
	pygame.display.update()
	def filtros(ima,ancho,alto,vecino_n):
	tiempo1 = time.time()
	imagen = ima.load()
	val_1 = [-1,0,1]
	for i in range(ancho):
	for j in range(alto):
	pm = vecinos(i,j,val_1,vecino_n)
	imagen[i,j] = (pm,pm,pm)
	nueva = 'filtro.png'
	i_filtro = ima.save(nueva)
	tiempo2 = time.time()
	print "Tiempo de procesamiento filtro"
	return nueva
	#def conv(i_filtro, )
	def vecinos(i,j,vec_1,vecino_n):
	pm = 0
	indice = 0
	for x in vec_1:
	for y in vec_1:
	sumav_1 = i+x # sumamos los vecinos
	sumav_2 = j+y # sumamos los vecinos
	try:
	if vecino_n[sumav_1,sumav_2]: #ciclo
	pm += vecino_n[sumav_1,sumav_2]
	indice+=1
	except IndexError:
	pass
	try:
	pm=int(pm/indice)
	return pm
	except ZeroDivisionError:
	return 0
	#Escala de grises
	def pixel(ima):
	ima = Image.open(ima)
	nueva = 'escala_grises.png'
	imagen = ima.load()
	ancho,alto = ima.size
	vecino_n = numpy.empty((ancho, alto))
	for i in range(ancho):
	for j in range(alto):
	(r,g,b) = ima.getpixel((i,j))
	pix = (r+g+b)/3
	imagen[i,j] = (pix,pix,pix)
	vecino_n[i,j] = int(pix)
	i_filtro = ima.copy()
	imagen = ima.save(nueva)
	return i_filtro,ancho,alto,vecino_n
	if __name__ == "__main__":
	main()

view raw filtro.py hosted with ❤ by GitHub

Y finalmente para detectar bordes utilice como base la explicación en clase, aplicando el proceso de convolución, que se basa en una mascara que va reccoriendo cada pixel buscando variaciones y comparandose con los pixeles cercano.

La máscara aplicada la realice utilizando el operador Sobel. Estos operadores calculan las variaciones de intensidad de cada píxel en comparación con otros. 

Para aplicar éstos operadores es necesario multiplicar los valores de cada píxel por cada valor de las matrices pre-establecidas una para dirección en x(filas) y la segunda para dirección en y(columnas) y la magnitud de gradiente.

Código 

	import sys,pygame
	import Image
	#from sys import argv
	from math import*
	#import numpy
	from time import*
	import math
	def main():
	pygame.init() # Inicializa pygame
	screen = pygame.display.set_mode((700, 500))
	pygame.display.set_caption('Imagenes')
	imagen = conv()
	img = pygame.image.load(imagen)
	screen = pygame.display.get_surface()
	while True: # Ciclo para las acciones en la ventana
	for event in pygame.event.get():
	if event.type == pygame.QUIT:
	sys.exit()
	screen.blit(img, (0,0)) # muestra la posicion de la imagen en x = 0 y y=0
	pygame.display.update()
	#Aplicamos la mascara
	def conv():
	tarda = time()
	ima = Image.open("filtro.png")
	imagen = ima.load()
	ancho,alto = ima.size
	mat_x = ([-1,0,1],[-2,0,2],[-1,0,1])
	mat_y = ([1,2,1],[0,0,0],[-1,-2,-1])
	for i in range(ancho):
	for j in range(alto):
	sumx=0.0
	sumy = 0.0
	for m in range(len(mat_x[0])):
	for h in range(len(mat_y[0])):
	try:
	mul_x= mat_x[m][h] * imagen[i+m, j+h][0]
	mul_y= mat_y[m][h] * imagen[i+m, j+h][0]
	except:
	mul_x=0
	mul_y=0
	sumx=mul_x+sumx
	sumy=mul_y+sumy
	valorx = pow(sumx,2)
	valory = pow(sumy,2)
	grad = int(math.sqrt(valorx + valory))
	if grad <= 0:
	grad = 0
	elif grad >= 255:
	grad = 255
	imagen[i,j] = (grad, grad, grad)
	nueva = 'conv.png'
	otra = ima.save(nueva)
	t1 = time()
	t2 = t1 - tarda
	print "Tiempo que tardo el procesamiento = "+str(t2)+" segundos"
	return nueva
	if __name__ == "__main__":
	main()

view raw bordes.py hosted with ❤ by GitHub

Aquí el resultado:

Aquí mi Repositorio