Lab 4-Deteccion de Lineas Diagonales

Para este laboratorio se nos encargo detectar lineas diagonales , para hacer esto me base en la tarea pasada haciéndole unas pequeñas modificaciones. De igual manera volví a utilizar las mascaras de Prewitt.

Esta fue la imagen utilizada

Aquí esta el código.

	import pygame
	from pygame.locals import *
	import Image
	from math import floor, atan, fabs, pi, cos, sin, ceil
	import math
	pygame.init()
	pantalla = pygame.display.set_mode((190,250))
	# FOTO NORMAL
	imagen = pygame.image.load("salidaconvolubinariza.png")
	#CONVOLUCION A ESCALA DE GRISES Y FILTRADA
	image = Image.open("rayitas.png")
	pixeles = image.load()
	pixelesY= image.load()
	ancho, altura =image.size
	rango=100
	msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1]) #Para gradiente de x.
	msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) #Para gradiente de y.
	prewittX=([-1, 0, 1], [-1, 0, 1], [-1, 0, 1])#EJE X PREWITT
	prewittY=([1, 1, 1], [0, 0, 0], [-1,-1,-1])#EJE Y PREWITT
	tamanomatriz=3
	sumatoriaX = 0
	sumariaY = 0
	seleccion=raw_input("INGRESA 1 PARA SOBEL y DOS PARA PREWITT ")
	matrizagarrada=int(seleccion)
	if matrizagarrada==1:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	if x != 0 and y != 0 and y != ancho and x != altura:
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = prewittX[i][j]*pixeles[y+j, x+i][1]
	gy = prewittY[i][j]*pixelesY[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	#gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	#pixelNuevo=gradienteResultante
	#if pixelNuevo> 255:
	# pixelNuevo = 255
	#if pixelNuevo < 0:
	#pixelNuevo = 0
	pixeles[y,x] = ( gxalcuadrado, gxalcuadrado,gxalcuadrado)
	image.save("imagenhorizo.png",'png')
	pixelesY[y,x] = ( gyalcuadrado, gyalcuadrado,gyalcuadrado)
	image.save("imagenverti.png",'png')
	#image.show()
	listcompl = list()
	valor=raw_input("INGRESA el valor para trabajar ")
	#
	valoragarr=float(valor)
	#print (" valor agarrado",valoragarr)
	comparaAng = 0.00001 #comparacion de ang
	for y in range(altura):
	listtempor = list()
	for x in range(ancho):
	enX = float(sum(pixeles[x, y]))/3.0
	enY = float(sum(pixelesY[x, y]))/3.0
	#se checa si no es cero para poder dividirlo
	if fabs(enX) > comparaAng:
	angulo = atan(enY/enX)
	else: #si llega a ser igual a cero
	if fabs(enX) + fabs(enY) <= comparaAng:
	angulo = None #No hay nada en ninguna direccion
	elif enX == 0 and enY == 255:
	angulo = 90.0
	else:
	angulo = 0.0
	if angulo is not None:
	rho = (x - ancho/2) * math.cos(angulo) + (altura/2 - y) * math.sin(angulo)
	listtempor.append(('%.2f' % angulo, '%.0f' % rho))
	else:
	listtempor.append((None, None))
	listcompl.append(listtempor)
	diccionario = dict()
	for y in xrange(altura):
	for x in xrange(ancho):
	if x > 0 and y > 0 and x < ancho - 1 and y < altura - 1:
	(angulo, rho) = listcompl[y][x]
	if angulo is not None:
	matr = (angulo, rho)
	if matr in diccionario:
	diccionario[matr] += 1#checa si esta sino
	else:
	diccionario[matr] = 1# lo agrega aqui y pone un 1
	valfrec = repeticion(comb, int(math.ceil(len(comb) * valoragarr))) #Relevante
	pixeles3 = image.load()
	for y in range(altura):
	for x in range(ancho):
	(angulo, rho) = listcompl[y][x]
	if (angulo, rho) in valfrec:
	if angulo == 0.00:
	pixeles3[x,y] (255,0,0)
	elif angulo == 90.00:
	pixeles3[x,y], (0,0,255)
	else
	pixeles3[x,y], (0,255,0)
	imagen.save("imagensalida.png")
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	exit()
	pantalla.blit(imagen,(0,0))
	pygame.display.update()

view raw gistfile1.py hosted with ❤ by GitHub

X

La imagen obtenida fue esta .

Detección de lineas

En esta semana para la materia de visión computacional se encargo detección de lineas. 
Se utilizaron las tareas pasadas para realizar esto. 


Se tiene que sacar los gradientes verticales y horizontales de la imagen en este caso yo utilice esta imagen .

Ahora utilizando las mascaras de gradientes para detectar lineas verticales y horizontales de una imagen se calculan utilizando el método de convolución de la tarea pasad en este caso utilice el Prewitt.

Aquí el código

	import pygame
	from pygame.locals import *
	import Image
	import math
	pygame.init()
	pantalla = pygame.display.set_mode((190,250))
	# FOTO NORMAL
	imagen = pygame.image.load("salidaconvolubinariza.png")
	#CONVOLUCION A ESCALA DE GRISES Y FILTRADA
	image = Image.open("salidaconvolubinariza.png")
	pixeles = image.load()
	ancho, altura =image.size
	rango=100
	msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1]) #Para gradiente de x.
	msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) #Para gradiente de y.
	prewittX=([-1, 0, 1], [-1, 0, 1], [-1, 0, 1])#EJE X PREWITT
	prewittY=([1, 1, 1], [0, 0, 0], [-1,-1,-1])#EJE Y PREWITT
	tamanomatriz=3
	sumatoriaX = 0
	sumariaY = 0
	seleccion=raw_input("INGRESA 1 PARA SOBEL y DOS PARA PREWITT ")
	matrizagarrada=int(seleccion)
	if matrizagarrada==1:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	if x != 0 and y != 0 and y != ancho and x != altura:
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = prewittX[i][j]*pixeles[y+j, x+i][1]
	gy = prewittY[i][j]*pixeles[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	pixelNuevo=gradienteResultante
	if pixelNuevo> 255:
	pixelNuevo = 255
	if pixelNuevo < 0:
	pixelNuevo = 0
	pixeles[y,x] = ( gyalcuadrado, gyalcuadrado,gyalcuadrado)#para verticales u horizontales
	image.show()
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	exit()
	pantalla.blit(imagen,(0,0))
	pygame.display.update()

view raw gistfile1.py hosted with ❤ by GitHub

X 

Y aquí el resultado.

Ahora como se menciono en la clase se debe sacar el angulo de  el pixel y dependiendo el angulo que tenga serán verticales u horizontales.

Aquí dejo el código

	import pygame
	from pygame.locals import *
	import Image
	from math import floor, atan, fabs, pi, cos, sin, ceil
	import math
	pygame.init()
	pantalla = pygame.display.set_mode((190,250))
	# FOTO NORMAL
	imagen = pygame.image.load("salidaconvolubinariza.png")
	#CONVOLUCION A ESCALA DE GRISES Y FILTRADA
	image = Image.open("rayitas.png")
	pixeles = image.load()
	pixelesY= image.load()
	ancho, altura =image.size
	rango=100
	msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1]) #Para gradiente de x.
	msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) #Para gradiente de y.
	prewittX=([-1, 0, 1], [-1, 0, 1], [-1, 0, 1])#EJE X PREWITT
	prewittY=([1, 1, 1], [0, 0, 0], [-1,-1,-1])#EJE Y PREWITT
	tamanomatriz=3
	sumatoriaX = 0
	sumariaY = 0
	seleccion=raw_input("INGRESA 1 PARA SOBEL y DOS PARA PREWITT ")
	matrizagarrada=int(seleccion)
	if matrizagarrada==1:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	if x != 0 and y != 0 and y != ancho and x != altura:
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = prewittX[i][j]*pixeles[y+j, x+i][1]
	gy = prewittY[i][j]*pixelesY[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	#gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	#pixelNuevo=gradienteResultante
	#if pixelNuevo> 255:
	# pixelNuevo = 255
	#if pixelNuevo < 0:
	#pixelNuevo = 0
	pixeles[y,x] = ( gxalcuadrado, gxalcuadrado,gxalcuadrado)
	image.save("imagenhorizo.png",'png')
	pixelesY[y,x] = ( gyalcuadrado, gyalcuadrado,gyalcuadrado)
	image.save("imagenverti.png",'png')
	#image.show()
	listcompl = list()
	valor=raw_input("INGRESA el valor para trabajar ")
	#
	valoragarr=float(valor)
	#print (" valor agarrado",valoragarr)
	comparaAng = 0.00001 #comparacion de ang
	for y in range(altura):
	listtempor = list()
	for x in range(ancho):
	enX = float(sum(pixeles[x, y]))/3.0
	enY = float(sum(pixelesY[x, y]))/3.0
	#se checa si no es cero para poder dividirlo
	if fabs(enX) > comparaAng:
	angulo = atan(enY/enX)
	else: #si llega a ser igual a cero
	if fabs(enX) + fabs(enY) <= comparaAng:
	angulo = None #No hay nada en ninguna direccion
	elif enX == 0 and enY == 255:
	angulo = 90.0
	else:
	angulo = 0.0
	if angulo is not None:
	rho = (x - ancho/2) * math.cos(angulo) + (altura/2 - y) * math.sin(angulo)
	listtempor.append(('%.2f' % angulo, '%.0f' % rho))
	else:
	listtempor.append((None, None))
	listcompl.append(listtempor)
	diccionario = dict()
	for y in xrange(altura):
	for x in xrange(ancho):
	if x > 0 and y > 0 and x < ancho - 1 and y < altura - 1:
	(angulo, rho) = listcompl[y][x]
	if angulo is not None:
	matr = (angulo, rho)
	if matr in diccionario:
	diccionario[matr] += 1#checa si esta sino
	else:
	diccionario[matr] = 1# lo agrega aqui y pone un 1
	valfrec = repeticion(comb, int(math.ceil(len(comb) * valoragarr)))
	pixeles3 = image.load()
	for y in range(altura):
	for x in range(ancho):
	(angulo, rho) = listcompl[y][x]
	if (angulo, rho) in valfrec:
	if angulo == 0:
	pixeles3[x,y] (255,0,0)
	if angulo == 90:
	pixeles3[x,y], (0,0,255)
	imagen.save("imagensalida.png")
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	exit()
	pantalla.blit(imagen,(0,0))
	pygame.display.update()

view raw gistfile1.py hosted with ❤ by GitHub

X

Lab 4 Computo Ubicuo

En esta entrada de laboratorio se nos pidió hacer una crítica constructiva, recomendaciones o sugerencias a los equipos de esta materia. Aquí les dejo mis comentarios.

Seguridad en Computadora

La idea de un bloqueo a la computadora parece muy bueno y útil en todos los ámbitos ya sea en el trabajo , la escuela o la casa . Esto porque cuantos no hemos sido victimas de bromas en la escuela a causa de dejar abierta nuestra sesión , o en nuestra casa quizás también dejando abierto algo y que nuestros papas o hermanos vean, en el trabajo también se presta mucho estas situaciones y aquí es donde muchas veces se hace mal uso de la información. 

Entonces yo les sugiero que implementen este sistema que seria muy útil , creo que si implementan un reconocimiento facial , utilizando quizás una cámara web o un reconocimiento mediante huella digital seria muy interesante verlo en acción. Otra recomendación podría ser que lograran identificar el iris de la persona o su voz. Para poder bloquear o desbloquear una computadora.

Localizador

Este proyecto me pareció muy interesante aunque me quede con muchas dudas para que seria el propósito de este proyecto, para niños perdidos? , para mascotas? , para paquetes o mercancía , creo que deberían definir un poco mejor esto ya que depende del contexto donde lo quieran usar seria mejor darles una buena critica constructiva , aunque me parece que es un proyecto demasiado bueno , ya que podrían comercializarlo quizás para padres de familia saber siempre donde se encuentra su hijo pequeño o su mascota y así se podrían prevenir muchas mascotas perdidas o escapadas , también quizás para parejas celosas :P podría ser interesante saber siempre donde esta el uno o el otro en fin , para la parte física quizás un brazalete estaría bien aunque no todo mundo quiere andar con un brazalete por ahí , podrían buscar alguna forma de hacerlo mas compacto o menos vistoso.

Galería Inteligente

A mi parecer no esta muy claro a que se refieren con una galería inteligente , recomendaría a este equipo investigar mucho mas de proyectos relacionados o similares y de este modo darles una mejor sugerencia de que podrían innovar en ello, encontré poca información sobre este tema, pero creo que es algo muy bueno para atraer publico a los museos que hoy en día la gente no esta acostumbrada a su visita, pero si en cambio se llega a implementar la gente siempre quiere ver las cosas novedosas y seria beneficio para los museos, quizás algo que me da un poco de ruido es eso de ponerse frente a la escultura o fotografía la grabación empiece automáticamente , que podría hacer el usuario para detenerla o adelantarla o incluso silenciarla, podrían quizás incluir un reconocimiento de palabras como stop, forward o algo por el estilo para hacerlo mas dinámico para las personas que lo visitan.

Despertador inteligente

Creo que el haber cambiado el enfoque de cama inteligente a despertador inteligente , el simple nombre hace mas factible la compra o comercializción ya que una cama es algo que no se compra o adquiere regularmente , en cambio un despertador si , y los precios en el mercado podrían ser muy competitivos y ademas de un producto novedoso.

Algo que creo podrían modificar o adecuar seria lo de que el despertador antes de la hora empiece a sonar con una leve melodía ya que en mi caso si pongo el despertador a las 6 30 , a esa hora quiero que me despierte no a las 6 25 ya que cinco minutos hacen la diferencia en mi caso :P , creo que podrían implementar en el sistema también algún tipo de selección rápida, por ejemplo en mi caso al ir en el camión en un recorrido de 15 o 20 minutos si me duermo o me da sueño tengo que ir al pendiente de que no se me pase la parada así que podrían incluir algo como una etiqueta que diga 10 min de sueño, o guardar situaciones por ejemplo ir "en el camión " y darle la configuración de tiempo para esa etiqueta y seleccionar 15 min así de esta manera al subirte ya sabes que a los 15 min el despertador sonara .

Casa Segura o Inteligente

Me gusto este proyecto y quizás a como se escucha podríamos decir que es uno de los que mas abarca , ya que si se habla de una casa inteligente se esta hablando de TODA la casa , cuartos , baños , salas, cocinas etc.

Aunque este equipo especifico Casa Inteligente dirigida el sistema de seguridad entones si solamente se van a enfocar en esta parte creo que podrían redefinir el nombre del proyecto para hacerlo mas especifico o menos general para los usuarios .

Un punto negativo de un proyecto como este seria el costo del mismo , ya que la mayoría de las personas no disponen de capital para adquirirlo o prefieren gastar su dinero en otras cosas, así que les recomendaría que si lo quieren sacar al mercado tengan un buen logo y una buena publicidad y mercadotecnia de este producto ademas de que muestren vídeos o garanticen un cierto grado de confianza para que los usuarios lo adquieran.

Lo del simulador de presencia esta genial aunque creo que no debería siempre de activarse , me imagino que esto seria muy útil cuando alguien sale de vacaciones y que no quiere que su casa se vea sola por mucho tiempo, aunque tienen que tener en cuenta los precios de la luz y si el sistema funciona adecuadamente ademas de ofrecer muchísima confianza a los usuarios en la cuestión de que prendan aparatos eléctricos sin su presencia, aquí lo que podrían manejar seria algún aparato de pilas que reproduzca sonidos de algún programa de televisión o conversaciones o genere alguna luz para que de esta manera no exista riesgo eléctrico.

Automóvil NFC 

Algo que note aquí es que encuestaron a personas de 15 a 19 años no entendí muy bien el concepto de esto , o el porque a este tipo de personas , ya que representan un porcentaje muy bajo de el total de vehículos o conductores en México. Pero lo demás del proyecto me pareció muy bueno el utilizar tu móvil como llave aunque habría que tener encuesta que nivel de seguridad piensas aplicarle a el, ya que si llega a perderlo a se lo roban entonces la persona que lo tenga podría hacer mal uso de el o robarlo .

Garage inteligente

Muy interesante proyecto aunque creo que podría tener un mayor impacto en el mercado estadounidense ya que aquí en México las personas que cuentan con garage es muy poca en comparación con EUA. 

Pero el proyecto en si es mu bueno , lo que vi es que existen varios métodos de hacer este sistema, con QR, o Smartphone etc. quizás deberían decir específicamente cual método van a utilizar para poder dar una mejor sugerencia, aunque creo que no seria muy buena idea que el garage se abra automáticamente al detectar el carro ya que muchas veces uno no esta dispuesto a meter el carro a el garage ya que lo usara después etc , así que aquí podrían diseñar un botón en una aplicación para accionar el mecanismo de apertura.

Laboratorio 3 Vision- Convex Hull

Para esta entrada de laboratorio se pidió obtener el Convex Hull de una imagen.

Esto es un polígono que recubre todo el contorno de la imagen.Se dijo que podíamos utilizar algún método para obtener los contornos de las imágenes , ya sea el de laboratorio o una imagen dibujada en alguna herramienta con fondo negro y los bordes blancos.  

Primeramente se aplica le echo en la tarea 2 pasada donde se programo un algoritmo BFS. Donde se buscaba el fondo negro y la figura, que en este caso es al reves busca el color blanco del contorno.

Aquí el código del BFS

	from random import *
	import random
	import pygame
	from pygame.locals import *
	import Image
	import math
	def bfs(image, dondeinicia, color):
	image = Image.open("salidaconvolubinariza.png")
	pixeles = image.load()
	ancho, altura =image.size
	for i in range(ancho):
	for j in range(altura):
	if pixeles[i, j] == (255, 255, 255):
	pixeles = image.load()
	ancho, altura = image.size
	cola = []
	ver = []
	hor= []
	cola.append((dondeinicia))
	pixeldondeinicia = pixeles[dondeinicia]#Donde empezara
	contador= 0
	while len(cola) > 0:#mientras la cola tenga valores
	(x, y) = cola.pop(0)#se quita de la cola
	puntoactual = pixeles[x, y]#punto actual toma el valor de la cola
	if puntoactual == pixeldondeinicia or puntoactual == (color):#Si es igual al pixel donde inicia o a el color
	for parax in [-1, 0, 1]:#Revisar los vecinos
	for paray in [-1, 0, 1]:
	i, j = (x + parax, y + paray)
	if i >= 0 and i < ancho and j >= 0 and j < altura:#Si el pixel se encuentra dentro de los limites de la figura
	contenido = pixeles[i, j]
	if contenido == pixeldondeinicia:
	pixeles[i, j] = (color)#le da el color r,g,b que tenga
	ver.append((i,j))
	#hor.append(j)
	contador += 1
	cola.append((i, j))
	return contador,ver

view raw gistfile1.py hosted with ❤ by GitHub

X

Se crearon estas imagen para esta prueba. y este fue el resultado

Aquí esta el código

	from random import *
	import random
	import pygame
	from pygame.locals import *
	import Image
	import math
	def bfs(image, dondeinicia, color):
	image = Image.open("salidaconvolubinariza.png")
	pixeles = image.load()
	ancho, altura =image.size
	for i in range(ancho):
	for j in range(altura):
	if pixeles[i, j] == (255, 255, 255):
	pixeles = image.load()
	ancho, altura = image.size
	cola = []
	ver = []
	hor= []
	cola.append((dondeinicia))
	pixeldondeinicia = pixeles[dondeinicia]#Donde empezara
	contador= 0
	while len(cola) > 0:#mientras la cola tenga valores
	(x, y) = cola.pop(0)#se quita de la cola
	puntoactual = pixeles[x, y]#punto actual toma el valor de la cola
	if puntoactual == pixeldondeinicia or puntoactual == (color):#Si es igual al pixel donde inicia o a el color
	for parax in [-1, 0, 1]:#Revisar los vecinos
	for paray in [-1, 0, 1]:
	i, j = (x + parax, y + paray)
	if i >= 0 and i < ancho and j >= 0 and j < altura:#Si el pixel se encuentra dentro de los limites de la figura
	contenido = pixeles[i, j]
	if contenido == pixeldondeinicia:
	pixeles[i, j] = (color)#le da el color r,g,b que tenga
	ver.append((i,j))
	#hor.append(j)
	contador += 1
	cola.append((i, j))
	return contador,ver
	TURN_LEFT, TURN_RIGHT, TURN_NONE = (1, -1, 0)
	def turn(punto1, punto2, punto3):
	return cmp((punto2[0] - punto1[0])*(punto3[1] - punto1[1]) - (punto3[0] - punto1[0])*(punto2[1] - punto1[1]), 0)
	def cv(puntos):
	convex_hull = [min(puntos)]
	for i in range(len(puntos)):
	q = puntos[0]
	for j in range(len(puntos)):
	t = turn(puntos[j], cv[i], q)
	if q == cv[i] or t == TURN_LEFT :
	q = puntos[j]
	cv.append(q)
	if q == cvl[0]:
	break
	return cv
	def cv_bn(im):
	image = Image.open("salidaconvolubinariza.png")
	pixeles = image.load()
	ancho, altura =image.size
	hulls = []
	for i in range(ancho):
	for j in range(altura):
	if pixeles[i, j] == (255, 255, 255):#Se cambio para que encontrara blancos en vez de negros
	contador, ver= bfs(image, (i, j), (255, 0, 0))#a mi Bfs que ya tenia
	hulls.append(cv(ver))
	for hull in hulls:
	for puntos in hull:
	pixeles[puntos] = (0, 255, 0)
	image.save("imagenfXXFINALLL.png",'png')
	return hulls

view raw gistfile1.py hosted with ❤ by GitHub

X

Debo de dar las gracias a Rafael Lopez que me ayudo y me paso este link de abajo que sirvió de muy buena referencia.

Referencias 

http://tomswitzer.net/2009/12/jarvis-march/

Lab. 3 - Técnicas de Diseño Conceptual

Cuando se trabaja bajo el análisis conceptual de una situación, nos referimos a la abstracción de hechos reales de los cuales se emite un concepto o es posible hacer una idea de ello.Nosotros para poder realizar la abstracción de un tema en un área especifica , a nivel informático,  es necesario tener los requerimientos formulados por los usuarios con respecto a este.

Estos requerimientos contienen el conjunto de hechos y reglas que dan pauta a la creación del esquema conceptual donde por medio de este se podrá realizar una descripción de alto nivel de la futura base de datos.  Para manipular este esquema se utiliza un modelo conceptual que proporciona un lenguaje que permite utilizar un conjunto de símbolos (estándares) para la creación de este.

Este método de diseño  es un método centrado en el usuario , este permite entender de mejor forma el entorno de trabajo de los usuarios y las necesidades reales que ellos tienen , no las que nosotros como desarrolladores pensamos que tienen. Es una parte muy importante en la planeación de un producto o servicio que se quiere sacar al mercado o renovar.

El diseño conceptual es muy importante ya que como se menciono arriba con el se puede comprender a todos los usuarios . Y este es la primera fase de un diseño donde los dibujos son el foco principal, que se componen de planes simples y secciones. Estos dibujos simples deben poder se prestan fácilmente a un mayor número de conjuntos específicos de planes.

Características

Hay fases específicas o pasos, de diseño conceptual que se necesitan para transferir ideas a los requisitos. Estos pasos incluyen una definición o descripción del concepto general, la definición de las especificaciones o requisitos del plan, la descripción de lo que el concepto se pretende alcanzar y una lista priorizada de objetivos para el concepto.

Durante el proceso de diseño conceptual, no es raro encontrarse con aquellos que creen que un diseño sea verdaderamente conceptual, no debe ser práctico. Hay otros que creen que un diseño conceptual debe reflejar el diseño terminado en su totalidad, no en parte. Esto resulta frustrante para el diseñador, que requiere de estos conceptos para llegar a un buen término.

El diseño conceptual deberá estar compuesto por la creación de una idea, la exploración de las intenciones de una idea y la representación de una idea.  El diseño conceptual puede variar desde los planos de una estructura de edificio hasta el diseño de un diagrama de una placa de un circuito y si los conceptos no están claramente dibujados la idea no se entiende completamente y el resultado final se vera comprometido.

Se deben considerar distintos puntos como la usabilidad y viabilidad del proyecto, esto para saber si en verdad es necesario este producto y si el costo comparado con las ganancias no resulta negativo, ademas de saber exactamente las necesidades , los intereses de los usuarios y las expectativas que estos tienen. Se consulta al usuario para saber sus opiniones  y ademas aceptar sugerencias y posibles cambios o mejoras.

En el proceso se debe :

Identificar a las personas que utilizaran el producto y para que.

Producir soluciones de diseño

Especificar los requisitos , tanto de los desarrolladores o creadores , así como el de los usuarios.

Y realizar una evaluación esto para detectar problemas o validar las soluciones de diseño.

Dos métodos parecidos pero diferentes son la entrevista y los cuestionarios la primera es el de realizar entrevistas a los usuarios. Aquí las preguntas deben tener cada una un propósito en particular ademas de estar bien formuladas para evitar confusiones al momento de realizar la evaluación. Y se realiza frente a frente a ellos tomando nota de sus reacciones de primera mano así como de sus respuestas. 

La otra es el cuestionario que consiste en una lista de preguntas de igual manera bien formuladas y esta puede ser realizada a varios usuarios ya sea directa o indirectamente por correo , papel. El formato debe ser entendible para los usuarios y mediante esta se conocerá la forma de pensar de cada uno de ellos y sus necesidades. 

Después de esto entre las personas encargadas del desarrollo del producto se tienen que analizar detalladamente los resultados.

Ya para finalizar se procede a tomar el camino mas viable y mejor tanto para los usuarios como para los desarrolladores.

Referencias

http://www.ehow.com/about_4570087_conceptual-design.html#page=0

http://www.unalmed.edu.co/~mstabare/diseno_conceptual.htm

TAREA 2 -VISION

Detección de Formas

En la tarea 2 de clase se encargo realizar un programa que detectara formas en la imagen, y deberían estar separadas por sus bordes.

Se debe pintar cada imagen de diferente color , y la figura de mayor tamaño debería ser de un solo color ya que es el fondo de la imagen.

Antes de detectar formas 

Se utilizó el código programado en la tarea anterior, para la detección de los contornos.

Se convirtió la imagen a escala de grises y se aplico convolución y binarización.

Código

	from random import *
	import random
	import pygame
	from pygame.locals import *
	import Image
	import math
	#IMAGEN BORROSA
	image = Image.open("casa.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	numero=raw_input("Teclea el numero de filtro que quieres ")
	numerofiltro=int(numero)
	for z in range(numerofiltro):
	for x in range(ancho):
	for y in range(altura):
	contador = 1
	promedio = 0
	# Toma el RGB del pixel
	(r,g,b) = pixeles[ x, y ]
	promedio += ( r + g + b ) / 3
	# Vecino Norte
	try :
	if x - 1 < 0:
	None
	else:
	r1, g1, b1 = pixeles[ ( x - 1 ), y ]
	promedio += ( r1 + g1 + b1 ) / 3
	contador = contador + 1
	except:
	pass
	# Vecino Sur
	try :
	if x + 1 >= ancho:
	None
	else:
	r2, g2, b2 = pixeles[ ( x + 1 ), y ]
	promedio += ( r2 + g2 + b2 ) / 3
	contador = contador + 1
	except:
	pass
	# Vecino Oeste
	try:
	if y - 1 < 0:
	None
	else:
	r3, g3, b3 = pixeles[ x, ( y - 1 ) ]
	promedio += ( r3 + g3 + b3 ) / 3
	contador = contador + 1
	except:
	pass
	# Vecino Este
	try:
	if y + 1 >= altura:
	None
	else:
	r4, g4, b4 = pixeles[ x, ( y + 1 ) ]
	promedio += ( r4 + g4 + b4 ) / 3
	contador = contador + 1
	except:
	pass
	promedio /= contador
	# Coloca el valor obtenido en el pixel actual
	pixeles[ x, y ] = ( promedio, promedio, promedio )
	image.save('salidafiltrada2.png', 'png')
	#image.show()
	#FOTO ESCALA DE GRISES
	image = Image.open("casa.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	promedio=((r+g+b)/3)
	pixeles[x,y] = (promedio,promedio,promedio)
	image.save('salidafiltrada3.png', 'png')
	image.show()
	#CONVOLUCION DE LA ESCALA DE GRISES Y FILTRADA
	image = Image.open("salidafiltrada2.png")
	pixeles = image.load()
	ancho, altura =image.size
	mascara4 = [[0,1,0],[1,-4,1],[0,1,0]]
	msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1]) #Para gradiente de x.
	msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) #Para gradiente de y.
	tamanomatriz=3
	sumatoriaX = 0
	sumariaY = 0
	seleccion=raw_input("INGRESA 1 PARA SOBEL y DOS PARA PREWITT ")
	matrizagarrada=int(seleccion)
	if matrizagarrada==1:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	if x != 0 and y != 0 and y != ancho and x != altura:
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = msobelX[i][j]*pixeles[y+j, x+i][1]
	gy = msobelY[i][j]*pixeles[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	pixelNuevo=gradienteResultante
	if pixelNuevo> 255:
	pixelNuevo = 255
	if pixelNuevo < 0:
	pixelNuevo = 0
	pixeles[y,x] = ( pixelNuevo, pixelNuevo, pixelNuevo)
	image.save('salidatarea2.png', 'png')
	#image.show()
	#NORMALIZADAAAAAA
	imagen_original = Image.open("salidatarea2.png")
	x, y = imagen_original.size
	imagen_normalizada = Image.new("RGB", (x, y))
	pixeles = []
	for a in range(y):
	for b in range(x):
	pix = imagen_original.getpixel((b, a))[0]
	pixeles.append(pix)
	maximo = max(pixeles)
	minimo = min(pixeles)
	print maximo
	print minimo
	l = 256.0/(maximo - minimo)
	pixeles = []
	for a in range(y):
	for b in range(x):
	pix = imagen_original.getpixel((b, a))[0]
	nuevo_pix = int(math.floor((pix-minimo)*l))
	pixeles.append((nuevo_pix, nuevo_pix, nuevo_pix))
	imagen_normalizada.putdata(pixeles)
	imagen_normalizada.save("imagen_normalizada.png",'png')
	#FOTO BINARISARLA
	image = Image.open("imagen_normalizada.png")
	pixeles = image.load()
	ancho, altura =image.size
	minimoo=7
	for x in range(ancho):
	for y in range(altura):
	if pixeles[x,y][1] < minimoo:
	prom=0
	else:
	prom= 255
	pixeles[x,y] = (prom,prom,prom)
	#image.show()
	image.save("imagenyafinal.png",'png')

view raw gistfile1.py hosted with ❤ by GitHub

Imagen Original

Imagen Binarizada 

Ahora se aplica BFS.

	from time import *
	import sys
	import Tkinter
	from PIL import Image, ImageTk
	import random
	import math
	from math import *
	image = Image.open("salidaconvolubinariza.png")
	pixeles = image.load()
	ancho, altura =image.size
	for i in range(ancho):
	for j in range (altura):
	if pixeles[i,j]==(0,0,0):#Si es negro
	r=random.randint(0,255)#Color random entre 0 y 255
	g=random.randint(0,255)
	b=random.randint(0,255)
	pixeles = image.load()
	ancho, altura = image.size
	cola = []
	ver = []
	hor= []
	cola.append((i,j))
	pixeldondeinicia = pixeles[i,j]#Donde empezara
	contador= 0
	while len(cola) > 0:#mientras la cola tenga valores
	(x, y) = cola.pop(0)#se quita de la cola
	puntoactual = pixeles[x, y]#punto actual toma el valor de la cola
	if puntoactual == pixeldondeinicia or puntoactual == (r,g,b):#Si es igual al pixel donde inicia o a el color
	for parax in [-1, 0, 1]:#Revisar los vecinos
	for paray in [-1, 0, 1]:
	i, j = (x + parax, y + paray)
	if i >= 0 and i < ancho and j >= 0 and j < altura:
	contenido = pixeles[i, j]
	if contenido == pixeldondeinicia:
	pixeles[i, j] = (r,g,b)#le da el color r,g,b que tenga
	ver.append(i)
	hor.append(j)
	contador += 1
	cola.append((i, j))
	image.save("imagenfFINALLL.png",'png')
	image.save("imagenfFINALLL.png",'png')

view raw gistfile1.py hosted with ❤ by GitHub

Y esta es la imagen obtenida.

Después se agrega al código un método para sacar los porcentajes que ocupa cada figura en la imagen.

Y aquí esta la ejecución en la terminal identificando las 15 figura contando el fondo.

	from time import *
	import sys
	import Tkinter
	from PIL import Image, ImageTk
	import random
	import math
	from math import *
	image = Image.open("salidaconvolubinariza.png")
	pixeles = image.load()
	ancho, altura =image.size
	contadordefiguras = 0
	for i in range(ancho):
	for j in range (altura):
	if pixeles[i,j]==(0,0,0):#Si es negro
	r=random.randint(0,255)#Color random entre 0 y 255
	g=random.randint(0,255)
	b=random.randint(0,255)
	pixeles = image.load()
	ancho, altura = image.size
	cola = []
	ver = []
	hor= []
	cola.append((i,j))
	pixeldondeinicia = pixeles[i,j]#Donde empezara
	contador= 0
	while len(cola) > 0:#mientras la cola tenga valores
	(x, y) = cola.pop(0)#se quita de la cola
	puntoactual = pixeles[x, y]#punto actual toma el valor de la cola
	if puntoactual == pixeldondeinicia or puntoactual == (r,g,b):#Si es igual al pixel donde inicia o a el color
	for parax in [-1, 0, 1]:#Revisar los vecinos
	for paray in [-1, 0, 1]:
	i, j = (x + parax, y + paray)
	if i >= 0 and i < ancho and j >= 0 and j < altura:#Si el pixel se encuentra dentro de los limites de la figura
	contenido = pixeles[i, j]
	if contenido == pixeldondeinicia:
	pixeles[i, j] = (r,g,b)#le da el color r,g,b que tenga
	ver.append((i,j))
	#hor.append(j)
	contador += 1
	cola.append((i, j))
	tamanodefigura = len(ver)#Se saca el tamano de cada forma
	tamanodelaimagen = ancho * altura #se saca el tamano de la imagen (area)
	porcent = tamanodefigura * 100 #Porcentaje
	porcent = porcent/ float(tamanodelaimagen)
	if porcent > .5:
	contadordefiguras +=1
	print "Porcentaje de la figura numero " +str(contadordefiguras) + " es de " +str(porcent)
	image.save("imagenfFINALLL.png",'png')
	image.save("imagenfFINALLL.png",'png')

view raw gistfile1.py hosted with ❤ by GitHub

LABORATORIO 2 - VISION

Para esta entrada de laboratorio se nos encargo hacer ciertas tarea.

1) Generar ruido sal y pimienta

2) Eliminación de ruido sal y pimienta con alguna combinación de filtrado/umbrales que se les ocurra.

RUIDO SAL Y PIMIENTA

Utilice esta imagen para esta entrada de laboratorio. 

Para indicar la intensidad de el ruido que se desea agregar es pedido como parámetro , se indica un texto en terminal que dice "Teclea la intensidad que quieres aplicar de ruido sal y pimienta". Suponiendo que el usuario teclea un "1 " El for solamente recorrerá una vez la imagen, y asi con un "dos" o "cuatro" etc.

Para poder hacer el ruido sal y pimienta mediante dos random que seleccionan al aleatoriamente un punto en "X" y "Y" , cuando el recorrido se encuentre en dicha posición se pintara el pixel.

Ahora para la polarización se pide en terminal que se ingrese un numero entre "0" y "255" dependiendo el numero que se escriba sera el color que tomaran los pixeles.

Aquí el código.

	from random import *
	import random
	import pygame
	from pygame.locals import *
	import Image
	pygame.init()
	pantalla = pygame.display.set_mode((193,261))
	# FOTO NORMAL
	imagen = pygame.image.load("imagen.jpg")
	# ELIMINACION DE RUIDO SAL Y PIMIENTA
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	print altura
	numero=raw_input("Teclea la intensitad que quieres aplicar ruido sal y pimienta ")
	numerosalypimienta=int(numero)
	pola=raw_input("Teclea la polarizacion que quieres de 0 - 255 ")
	polarizacion=int(pola)
	for z in range(numerosalypimienta):
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = pixeles[ x, y ]
	promedio=((r+g+b)/3)
	# Aqui si i y j son las posiciones seleccionadas al azar
	# cuando el for este en la posicion i o j seleccionada al azar se pintara el pixel entre un color que estara entre 0 y 255
	# (Polarizacion)
	i = random.randint(0,ancho)
	j = random.randint(0,altura)
	valor = random.randint(0,255)
	if i == x:
	r= polarizacion
	g = polarizacion
	b = polarizacion
	if y == j:
	r = polarizacion
	g = polarizacion
	b = polarizacion
	pixeles[x,y] = (r,g,b)
	image.show()

view raw gistfile1.py hosted with ❤ by GitHub

Aquí esta el ejemplo con ruido de intensidad 1  y polarización de 255:

Ruido intensidad 3 y polarización de 0:

Ruido intensidad 10 y polarización 128:

ELIMINACIÓN DE RUIDO SAL Y PIMIENTA

2)Lo que se encargo eliminación de ruido sal y pimienta con alguna combinación de filtrado/umbrales que se les ocurra.

Para eliminar el ruido en esta foto lo que hice fue fue agregarle al mismo código que genera la imagen de ruido sal y pimienta , una conversión a escala de grises de toda la imagen así como un filtro analizando todos sus vecinos. Ya a el final decidí restarle un valor a la imagen que se mostrará. Esto lo hice para que se pudiera apreciar mucho mejor la imagen mas oscura y con menos brillo.

 Y el resultado fue este.
 

Aqui podemos observar la imagen original , la que tiene el ruido y la imagen donde ya se elimino el ruido. Con una intensidad de uno y una polarización de 0.

Este es el resultado de la imagen con una intensidad de 1 y una polarización de 255 pero sin restarle el ultimo valor. Para que puedan observar la diferencia.

Aquí todo el código.

	from random import *
	import random
	import pygame
	from pygame.locals import *
	import Image
	pygame.init()
	pantalla = pygame.display.set_mode((193,261))
	# FOTO NORMAL
	imagen = pygame.image.load("imagen.jpg")
	# ELIMINACION DE RUIDO SAL Y PIMIENTA
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	numero=raw_input("Teclea la intensitad que quieres aplicar ruido sal y pimienta ")
	numerosalypimienta=int(numero)
	pola=raw_input("Teclea la polarizacion que quieres de 0 - 255 ")
	polarizacion=int(pola)
	for z in range(numerosalypimienta):
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = pixeles[ x, y ]
	promedio=((r+g+b)/3)
	# Aqui si i y j son las posiciones seleccionadas al azar
	# cuando el for este en la posicion i o j seleccionada al azar se pintara el pixel entre un color que estara entre 0 y 255
	# (Polarizacion)
	i = random.randint(0,ancho)
	j = random.randint(0,altura)
	# valor = random.randint(0,255)
	if i == x:
	r= polarizacion
	g = polarizacion
	b = polarizacion
	if y == j:
	r = polarizacion
	g = polarizacion
	b = polarizacion
	try :
	if x - 1 < 0:
	None
	else:
	r ,g, b = pixeles[ ( x - 1 ), y ]
	promedio += ( r + g + b ) / 3
	except:
	pass
	try :
	if x + 1 >= ancho:
	None
	else:
	r, g, b = pixeles[ ( x + 1 ), y ]
	promedio += ( r + g+ b ) / 3
	except:
	pass
	try:
	if y - 1 < 0:
	None
	else:
	r, g, b = pixeles[ x, ( y - 1 ) ]
	promedio += ( r + g + b ) / 3
	except:
	pass
	try:
	if y + 1 >= altura:
	None
	else:
	r, g, b = pixeles[ x, ( y + 1 ) ]
	promedio += ( r + g + b ) / 3
	except:
	pass
	promedio = promedio/4
	r=promedio-30
	g=promedio-30
	b=promedio-30
	pixeles[x,y] = (r,g,b)
	image.show()
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	exit()
	pantalla.blit(imagen,(0,0))
	pygame.display.update()

view raw gistfile1.py hosted with ❤ by GitHub

TAREA 1 - VISION COMPUTACIONAL

Para esta entrada que es la tarea 1 se pidieron distintas tareas que son estas:

1) Subrutina para aplicar una máscara de convolución discreta, de preferencia centralizado al pixel en cuestión.

2) Con esa subrutina, calcular por lo menos un gradiente horizontal y un gradiente vertical, posiblemente más o también diagonales, con la posibilidad de combinarlos al tiempo de calcularlos a uno solo o combinando entre múltiples matrices de gradiente una vez terminada la aplicación de todas las máscaras de gradiente:

3) Normalización de la matriz resultante de la manera que perciben factible y útil a [0, 255]

4)Binarización que deje los bordes como zonas blancas y el resto negro.

La imagen que utilice para estas pruebas fue esta. 

Para realizar esta primera tarea utilice dos máscaras.

Estas máscaras presentan una ventaja en cuanto a las demás como la de Robert, es que además de estimar el valor del módulo del gradiente, producen un alisamiento en la imagen que resulta beneficioso.

1.- Mascara Sobel.- Que utiliza esta matriz para sus operaciones

2- Mascara Prewitt, Esta mascara utiliza esta matriz de 3 x 3 para sus operaciones.

 

Ya una vez sabiendo lo teórico,  se procede a implementar la convolución. Aquí utilice la imagen en escala de grises y filtrada de la entrada de laboratorio.

Aquí se encuentra el código que hace esto.

	#IMAGEN BORROSA
	image = Image.open("linea.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	numero=raw_input("Teclea el numero de filtro que quieres ")
	numerofiltro=int(numero)
	for z in range(numerofiltro):
	for x in range(ancho):
	for y in range(altura):
	contador = 1
	promedio = 0
	(r,g,b) = pixeles[ x, y ]
	promedio += ( r + g + b ) / 3
	try :
	if x - 1 < 0:
	None
	else:
	r1, g1, b1 = pixeles[ ( x - 1 ), y ]
	promedio += ( r1 + g1 + b1 ) / 3
	contador = contador + 1
	except:
	pass
	try :
	if x + 1 >= ancho:
	None
	else:
	r2, g2, b2 = pixeles[ ( x + 1 ), y ]
	promedio += ( r2 + g2 + b2 ) / 3
	contador = contador + 1
	except:
	pass
	try:
	if y - 1 < 0:
	None
	else:
	r3, g3, b3 = pixeles[ x, ( y - 1 ) ]
	promedio += ( r3 + g3 + b3 ) / 3
	contador = contador + 1
	except:
	pass
	try:
	if y + 1 >= altura:
	None
	else:
	r4, g4, b4 = pixeles[ x, ( y + 1 ) ]
	promedio += ( r4 + g4 + b4 ) / 3
	contador = contador + 1
	except:
	pass
	promedio /= contador
	pixeles[ x, y ] = ( promedio, promedio, promedio )
	image.show()

view raw gistfile1.py hosted with ❤ by GitHub

Esta es la imagen resultante.

Ahora se procederá a implementar las mascaras , y con esto obtendremos los bordes de la imagen. 

Como se mencionó existen distintos métodos yo utilice Prewitt y Sobel.

Aquí  está el código , y se carga la matriz Sobel y Prewitt con sus valores respectivos.

	import pygame
	from pygame.locals import *
	import Image
	import math
	pygame.init()
	pantalla = pygame.display.set_mode((190,250))
	# FOTO NORMAL
	imagen = pygame.image.load("linea.jpg")
	#CONVOLUCION A ESCALA DE GRISES Y FILTRADA
	image = Image.open("convol.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1]) #Para gradiente de x.
	msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) #Para gradiente de y.
	prewittX=([-1, 0, 1], [-1, 0, 1], [-1, 0, 1])#EJE X PREWITT
	prewittY=([1, 1, 1], [0, 0, 0], [-1,-1,-1])#EJE Y PREWITT
	tamanomatriz=3
	sumatoriaX = 0
	sumariaY = 0
	seleccion=raw_input("INGRESA 1 PARA SOBEL y DOS PARA PREWITT ")
	matrizagarrada=int(seleccion)
	if matrizagarrada==1:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = msobelX[i][j]*pixeles[y+j, x+i][1]
	gy = msobelY[i][j]*pixeles[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	pixelNuevo=gradienteResultante
	if pixelNuevo> 255:
	pixelNuevo = 255
	if pixelNuevo < 0:
	pixelNuevo = 0
	pixeles[y,x] = ( pixelNuevo, pixelNuevo, pixelNuevo)
	image.show()
	if matrizagarrada==2:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = prewittX[i][j]*pixeles[y+j, x+i][1]
	gy = prewittY[i][j]*pixeles[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	pixelNuevo=gradienteResultante
	if pixelNuevo> 255:
	pixelNuevo = 255
	if pixelNuevo < 0:
	pixelNuevo = 0
	pixeles[y,x] = ( pixelNuevo, pixelNuevo, pixelNuevo)
	image.show()
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	exit()
	pantalla.blit(imagen,(0,0))
	pygame.display.update()

view raw gistfile1.py hosted with ❤ by GitHub

msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1])
msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) 

prewittX=([-1, 0, 1], [-1, 0, 1], [-1, 0, 1])
prewittY=([1, 1, 1], [0, 0, 0], [-1,-1,-1]) 


Se pide que ingreses un "UNO" para trabajar con la matriz Sobel y un "DOS" para trabajar con la matriz prewitt.

Aquí están las distintas pruebas que realice.

4760862 Mascara sobel.

Imagen original                                          Imagen con Mascara   
            

Imagen Original                                                     Imagen con máscara                            

 














 Mascara Prewitt

Imagen original                                                               Imagen con máscara

 

Y aquí todo el código

	import pygame
	from pygame.locals import *
	import Image
	import math
	pygame.init()
	pantalla = pygame.display.set_mode((190,250))
	# FOTO NORMAL
	imagen = pygame.image.load("imagen.jpg")
	#FOTO ESCALA DE GRISES
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	promedio=((r+g+b)/3)
	pixeles[x,y] = (promedio,promedio,promedio)
	#image.show()
	#FOTO Invertida
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	if (r>0 and g>0 and b>0):
	r=255-r
	g=255-g
	b=255-b
	pixeles[x,y] = (r,g,b)
	#image.show()
	#FOTO binarizada con un umbral
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	if (r<128 and g<128 and b<128):
	r=0
	g=0
	b=0
	if (r>128 and g>128 and b>128):
	r=255
	g=255
	b=255
	pixeles[x,y] = (r,g,b)
	#image.show()
	#FOTO Escala de grises con binarizacion
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	promedio=((r+g+b)/3)
	if (promedio<=128 and promedio<=128 and promedio<=128):
	r=0
	g=0
	b=0
	else:
	r=255
	g=255
	b=255
	pixeles[x,y] = (r,g,b)
	#image.show()
	#FOTO binarizada con dos UMBRALes
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	promedio = (r+g+b/3)
	if promedio <= 100:
	r=0
	g=0
	b=0
	if promedio >= 220:
	r=255
	g=255
	b=255
	pixeles[x,y] = (promedio,promedio,promedio)
	#image.show()
	#FOTO PLATEADAS
	image = Image.open("imagen.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	for x in range(ancho):
	for y in range(altura):
	(r,g,b) = image.getpixel((x,y))
	promedio =((r-80)+(g-80)+(b-80)/3)
	pixeles[x,y] = (promedio,promedio,promedio)
	#image.show()
	#IMAGEN BORROSA
	image = Image.open("linea.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	numero=raw_input("Teclea el numero de filtro que quieres ")
	numerofiltro=int(numero)
	for z in range(numerofiltro):
	for x in range(ancho):
	for y in range(altura):
	contador = 1
	promedio = 0
	(r,g,b) = pixeles[ x, y ]
	promedio += ( r + g + b ) / 3
	try :
	if x - 1 < 0:
	None
	else:
	r1, g1, b1 = pixeles[ ( x - 1 ), y ]
	promedio += ( r1 + g1 + b1 ) / 3
	contador = contador + 1
	except:
	pass
	try :
	if x + 1 >= ancho:
	None
	else:
	r2, g2, b2 = pixeles[ ( x + 1 ), y ]
	promedio += ( r2 + g2 + b2 ) / 3
	contador = contador + 1
	except:
	pass
	try:
	if y - 1 < 0:
	None
	else:
	r3, g3, b3 = pixeles[ x, ( y - 1 ) ]
	promedio += ( r3 + g3 + b3 ) / 3
	contador = contador + 1
	except:
	pass
	try:
	if y + 1 >= altura:
	None
	else:
	r4, g4, b4 = pixeles[ x, ( y + 1 ) ]
	promedio += ( r4 + g4 + b4 ) / 3
	contador = contador + 1
	except:
	pass
	promedio /= contador
	pixeles[ x, y ] = ( promedio, promedio, promedio )
	image.show()
	#CONVOLUCION A ESCALA DE GRISES Y FILTRADA
	image = Image.open("perrito.jpg")
	pixeles = image.load()
	ancho, altura =image.size
	msobelX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1]) #Para gradiente de x.
	msobelY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1]) #Para gradiente de y.
	prewittX=([-1, 0, 1], [-1, 0, 1], [-1, 0, 1])#EJE X PREWITT
	prewittY=([1, 1, 1], [0, 0, 0], [-1,-1,-1])#EJE Y PREWITT
	tamanomatriz=3
	sumatoriaX = 0
	sumariaY = 0
	seleccion=raw_input("INGRESA 1 PARA SOBEL y DOS PARA PREWITT ")
	matrizagarrada=int(seleccion)
	if matrizagarrada==1:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = msobelX[i][j]*pixeles[y+j, x+i][1]
	gy = msobelY[i][j]*pixeles[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	pixelNuevo=gradienteResultante
	if pixelNuevo> 255:
	pixelNuevo = 255
	if pixelNuevo < 0:
	pixelNuevo = 0
	pixeles[y,x] = ( pixelNuevo, pixelNuevo, pixelNuevo)
	image.show()
	if matrizagarrada==2:
	for x in range(altura):
	for y in range(ancho):
	sumatoriaX = 0
	sumatoriaY = 0
	for i in range(tamanomatriz):
	for j in range(tamanomatriz):
	try:
	gx = prewittX[i][j]*pixeles[y+j, x+i][1]
	gy = prewittY[i][j]*pixeles[y+j, x+i][1]
	except:
	productosGX = 0
	productosGY = 0
	sumatoriaX = gx+sumatoriaX
	sumatoriaY = gy+sumatoriaY
	gxalcuadrado = pow(sumatoriaX, 2)
	gyalcuadrado = pow(sumatoriaY, 2)
	gradienteResultante = int(math.sqrt(gxalcuadrado+gyalcuadrado))
	pixelNuevo=gradienteResultante
	if pixelNuevo> 255:
	pixelNuevo = 255
	if pixelNuevo < 0:
	pixelNuevo = 0
	pixeles[y,x] = ( pixelNuevo, pixelNuevo, pixelNuevo)
	image.show()
	while True:
	for eventos in pygame.event.get():
	if eventos.type == pygame.QUIT:
	exit()
	pantalla.blit(imagen,(0,0))
	pygame.display.update()

view raw gistfile1.py hosted with ❤ by GitHub

Aquí esta el link a el codigo.

https://gist.github.com/robertovalenzuela91/4760862

LABORATORIO VISION

Para esta entrada se nos pidio que procesaremos alguna imagen y le aplicaremos efectos o filtros  tales como escala de grises , binarizacion (con umbral) negativos etc.

Yo utilice el lenguaje Python ,Pygame  y PIL.

En una ventana muestro la imagen original y creo otras ventanas donde aparecen los efectos que le aplique para poder compararlos.

La imagen utilizada fue esta.

 

Al correr mi programa como digo se generan las dos ventanas primero genere la escala de grises que se ve en la imagen de abajo.

Para sacar la escala de grises realice una sumatoria de los valores R G B y después les saque un promedio , que fue agregado después.

 

Umbral. Para este filtro seleccione varios valores para que se compararan .
Y dependiendo si era mayor o menor se convertían a "255" o "0" .

Que los convierte a blanco o negro. y el efecto obtenido es el siguiente.

Yo aplique en estas 3 fotos un umbral de 50, 200 y 128 y podemos observar los diferentes resultados, mas blanco o mas oscuro.

También aplique una binarizacion a una imagen en escala de grises  y este fue el resultado.

Para obtener estos volví a aplicar los mismos umbrales 50,200 y 128 y podemos observar los resultados.

En otra prueba aplique dos umbrales uno menor y uno mayor . Si era menor o igual a mi umbral menor lo convertida a "0" y si era mayor o igual a mi umbral mayor lo convertia a "225". Y este fue el resultado.

Para el siguiente efecto inverti los colores de la imagen, para poder hacer esto lo que hice fue a  255 le reste el valor del pixel. Y se obtuvo lo siguiente.

 

Segui aplicando mas efectos ala imagen , probe tambien a el valor de R G B

restarle un valor y despues sacar su promedio ,   promedio =((r-80)+(g-80)+(b-80)/3)   para obtener otra imagen, el resultado es un estilo plateado en la imagen.

Ya para finalizar aqui estan  varias imágenes finales que las pongo juntas para que se pueda comparar la diferencia.

Y aqui esta el link a mi codigo.

https://gist.github.com/robertovalenzuela91/4728920