Laboratorio de Visión Computacional:

Tarea 1:

En esta entrada se nos pidio que a una imagen le aplicaramos lo de escala de grises, después el umbral y por último filtro.

La imagen a aplicarle lo anterior sera la misma para los tres para poder ver las diferencias:

Escala de Grises 

Para la conversión a escala de grises:

1. Recorremos la imagen pixel por pixel
2. Por cada pixel sacamos su r,g,b ((r,g,b) = image.getpixel((i,j)))
3. Sacamos un promedio(escala = (r+g+b)/3)
4. Ese promedio se asigna al r,g y b del pixel (pixeles[i,j]=(escala,escala,escala))

La imagen que nos arroja es la siguiente

	import sys,pygame #Importar para la creacion de la vetana
	import Image #Importar para trabajar con imagene (PIL)
	from sys import argv #Importar para trabajar con argumentos de terminal
	#def main: se crea la ventana y se carga la imagen ya en escala de grises
	def main(image):
	ancho,altura,new_image=escala_grises(image) #Llama a funcion escala de grises
	ventana = pygame.display.set_mode((ancho,altura)) #Crea una ventana cn las dimensiones de la imagen
	pygame.display.set_caption('Imagen') #Definimos el nombre d ela ventana
	imagen = pygame.image.load(new_image) #Carga nuestra imagen
	while True: #Para que la ventana no se cierre
	#Para poder cerrar la ventana
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	sys.exit(0)
	ventana.blit(imagen,(0,0))#Mostrar la imagen posicion x=0, y=0
	pygame.display.update()
	return 0
	#Convierte la imagen a escalade grises
	def escala_grises(image):
	image = Image.open(image)
	new_image = 'escala_grises.png'
	pixeles = image.load()
	ancho, altura =image.size
	for i in range(ancho):
	for j in range(altura):
	(r,g,b) = image.getpixel((i,j))
	escala = (r+g+b)/3
	pixeles[i,j]=(escala,escala,escala)
	image=image.save(new_image)
	return ancho,altura,new_image
	pygame.init() #Inicializa pygame
	main(argv[1])

view raw escala_grises.py hosted with ❤ by GitHub

Umbral

Pasos:

1. Se definen los umbrales uno minimo y uno maximo
2. Recorremos la imagen pixel por pixel
3. Por cada pixel sacamos su r,g,b ((r,g,b) = image.getpixel((i,j)))
4. Sacamos un promedio(promedio = int((r+g+b)/3))
5. Si promedio<=umbral_minimo: promedio = 0
6. Si promedio>=umbral_maximo: primedio = 1 (Si el umbral no se encuentra entre lo anterior se queda con su mismo valor de grises)
7. Asignamos al pixel (pixeles[i,j]=(promedio,promedio,promedio))

Imagén arrojada, fue probada con un umbral minimo=45 y maximo=139

Otra prueba de umbral: 

umbral minimo=45 y maximo=139

Código:

	import sys,pygame
	import Image
	from sys import argv
	def main(image):
	ancho,altura,new_image=umbral(image)
	ventana = pygame.display.set_mode((ancho,altura))
	pygame.display.set_caption('Imagen')
	imagen = pygame.image.load(new_image)
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	sys.exit(0)
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	return 0
	def umbral(image):
	minimo = int(argv[2])
	maximo = int(argv[3])
	image = Image.open(image)
	new_image = 'umbral.png'
	pixeles = image.load()
	ancho, altura =image.size
	print ancho
	print altura
	for i in range(ancho):
	for j in range(altura):
	(r,g,b) = image.getpixel((i,j))
	promedio = int((r+g+b)/3)
	if promedio <= minimo:
	promedio = 0
	if promedio >= maximo:
	promedio = 255
	pixeles[i,j]=(promedio,promedio,promedio)
	image=image.save(new_image)
	return ancho,altura,new_image
	pygame.init()
	main(argv[1])

view raw umbral.py hosted with ❤ by GitHub

Filtro

Pasos:

Para usar el filtro ya trabajamos con la imagén en escala de grises

1. Seleccionamos los vecinos de cada uno de los pixeles
2. Sumamos la escala de grises q le pertenece a cada pixel vecino
3. Sacamos un promedio de la suma de lo anterior
4. Y lo asignamos al pixel

La imagen arrojada

Código:

	def filtro(image,ancho,alto,matriz):
	new_image = 'filtro.png'
	pixels = image.load()
	lista = [-1,0,1]
	for i in range(ancho):
	for j in range(alto):
	promedio = vecindad(i,j,lista,matriz)
	pixels[i,j] = (promedio,promedio,promedio)
	image_filtro = image.save(new_image)
	return new_image
	def vecindad(i,j,lista,matriz):
	promedio = 0
	indice = 0
	for x in lista:
	for y in lista:
	a = i+x
	b = j+y
	try:
	if matriz[a,b]:
	promedio += matriz[a,b]
	indice +=1
	except IndexError:
	pass
	try:
	promedio=int(promedio/indice)
	return promedio
	except ZeroDivisionError:
	return 0

view raw filtro.py hosted with ❤ by GitHub

Repositorio
https://github.com/alice-rdz/vision-computacional