Actividad 1 de Laboratorio de Visión Computacional

Para la actividad de laboratorio se realizo primero un filtro a escala de grises tomando el RGB de cada pixel, para luego promediarlo y colocar el mismo valor en cada canal.

Como se puede apreciar en la ventana, la imagen de arriba es la original y la imagen de abajo es una imagen en escala de grises. El código es el siguiente:

	import numpy as np
	import Tkinter
	from PIL import ImageDraw
	import Image
	import ImageTk
	def escalaDeGrises(im):
	width, height = im.size
	print width, height
	im = im.convert('RGB')
	pix = im.load()
	promedio = 0.0
	for y in xrange(height):
	for x in xrange(width):
	r, g, b = pix[x, y]
	promedio = (r+g+b)/3.0
	pix[x, y] = int(promedio), int(promedio), int(promedio)
	data = np.array(im)
	im2 = Image.fromarray(data)
	return im2
	imagen = Image.open('comida_indu.png')
	imagenModificada = imagen
	imagenModificada = escalaDeGrises(imagen)
	root = Tkinter.Tk()
	tkimage = ImageTk.PhotoImage(imagen)
	tkimageMod = ImageTk.PhotoImage(imagenModificada)
	Tkinter.Label(root, image = tkimage).pack()
	Tkinter.Label(root, image = tkimageMod).pack()
	root.mainloop()

view raw image-escalaDeGrises.py hosted with ❤ by GitHub

Para correr el código solo corrermos el programa como cualquier otro en python:

Después se realizo otro filtro para hacer un efecto borroso sobre la misma imagen en escala de grises, pero esta fue tomada directamente en escala de grises por medio de un método dado por la librería, con el fin de evitar sobre uso de memoria en canales como RGB y fueron tomados a solo un canal, aunque dicha imagen tomada ya esta en escala de grises. Este fue realizado haciendo una sumatoría de los valores de los vecinos de arriba, abajo, izquierda y derecha del pixel, para sacar un promedio de ellas en el pixel actual, y este poniendolo en una nueva imagen.

Se puede observar el efecto borroso en la imagen de arriba en comparación con la original.
Código:

	import numpy as np
	import Tkinter
	from PIL import ImageDraw
	import Image
	import ImageTk
	from sys import argv
	def filtro(original):
	width, height = original.size
	print width, height
	original = original.convert('L')
	modificado = Image.new(mode='L', size =(width,height))
	org = original.load()
	mod = modificado.load()
	contador = 0
	for y in xrange(height):
	for x in xrange(width):
	pixel = org[x,y]
	try:
	pixel += org[x-1,y]
	contador+=1
	except:
	None
	try:
	pixel += org[x+1,y]
	contador+=1
	except:
	None
	try:
	pixel += org[x,y+1]
	contador+=1
	except:
	None
	try:
	pixel += org[x,y-1]
	contador+=1
	except:
	None
	promedio = (pixel)/ (contador)
	mod[x,y] = int(promedio)
	print x,y
	contador = 1
	pixel = 0
	data = np.array(modificado)
	print data
	print data.shape
	im = Image.fromarray(data)
	return im
	def filtroPorNumeros(im,n):
	for x in xrange(n):
	im = filtro(im)
	return im
	def escalaDeGrises(im):
	width, height = im.size
	print width, height
	im = im.convert('RGB')
	pix = im.load()
	promedio = 0.0
	for y in xrange(height):
	for x in xrange(width):
	r, g, b = pix[x, y]
	promedio = (r+g+b)/3.0
	pix[x, y] = int(promedio), int(promedio), int(promedio)
	data = np.array(im)
	im2 = Image.fromarray(data)
	return im2
	def main():
	imagen = Image.open(argv[1])
	original = imagen
	escalaGrises = escalaDeGrises(imagen)
	modificado = filtroPorNumeros(escalaGrises, int(argv[2]))
	root = Tkinter.Tk()
	tkimageModf = ImageTk.PhotoImage(modificado)
	tkimageOrig = ImageTk.PhotoImage(original)
	Tkinter.Label(root, image = tkimageModf).pack()
	Tkinter.Label(root, image = tkimageOrig).pack()
	root.mainloop()
	main()

view raw filtro.py hosted with ❤ by GitHub

Y se puede puede correr de esta manera, donde el primer parámetro que toma es el nombre de la imagen y el segundo es el número de veces que se quiere filtrar la imagen:

Para ver más ejemplos pueden ver mi GitHub:

https://github.com/SaulG/VisionComputacional