Resumen. Suffix Tree

Reference to  "Algorithms on Strings, Trees, and Sequences" by Dan Gusfield.

Introduction

The string of lenght  m can be generated into m sufflix can be stored

•  created this structure requieres time O(m)

• for a parttner requieres tiimeO(n)

These two properties make the suffix tree an appealing structure for a diverse range of bioinformatics applications including: multiple genome alignment (Michael Hohl et al., 2002)

Biological Application

Genome Alignament

 Reference this book "Algorithms on Strings, Trees, and Sequences" by Dan Gusfield.

 At a least two programs based Suffix trees are available for whole gnome alignament. 

MUMmer and MGA both use common subsequences as anchors for the alignment. While they both use the same data structure:

MUMmer extracts Maximal Unique Matches (MUMs)  sequences that occur exactly once in each genome, sorts these sequences to find the longest set of MUMs occurring in the same order in both sequences, and uses this set of sequences to anchor the multiple alignment. 

For this the gaps between anchors are filled using the Needleman Wunsch dynamic programming alignment algorithm.  MUMmer is restricted to comparing two genomes.

The function

MGA computes the longest non-overlapping sequence of Maximal Multiple Exact Matches (multiMEMs) and uses these to guide the multiple alignment. A MEM is defined as a (K+1)-tuple (l, p_0, p_1, ... p_k-1) such that l indicates the length of the MEM, and p_i indicates the start coordinate of the exact match in genome i. A maximal MEM cannot be extended to the left or the right and is referred to as a multiMEM. Gaps are shortened by recursively extracting multiMEM sequences, and finally filled using ClustalW - a progressive/iterative multiple alignment method.

Bibliografia

Link1

Lab #4. Observaciones y Recomendaciones para proyecto

Para esta entrada se realizarían comentarios o retroaliemntaciones a las presentaciones sobre diseño conceptual o contextual de los proyectos.

Auto Seguro (Sergio, Alex, Peke y Cris)

En mi opinion en base a esas encuestas o sugerencias de los usuarios que tomarón en cuenta podrían comenzar un prototipo inicial para ver como interactua el usuario con el sistema que quieren presentar, también observe en su presentación tienen varias tecnologías como aportación con estas  podrían poner cual sería las tecnologías que se acoplarian más a su idea de una manera más definida en el contexto que están presentando, para que no se vuelva mas complicado en el desarrollo.

Casa Segura(Rene, Raúl, Iván)

Su proyecto es muy bueno, por lo que veo en las preguntas de la encuesta tomarón dos temas no uno solo en especifico, si se abarcaran los dos una recomendación sería definir un alcance que tendría su proyecto para obtener un mejor resultado con los usuarios que llegaron a ser parte de esta encuesta, también sería mejor preguntar por características del producto además de las áreas en las que el usuario cree que debería haber mas seguridad.

 

Garage Inteligente (Emmanuel, Max, Carmen, Victor)
Es una idea innovadora  y sería muy util para casas que cuentan con este tipo de compartimento. Una sugerencia sería ampliar las herramientas con que trabajarían para obtener beneficio de quienes no cuentan con uno y ofrecer el producto en otros campos. Dato. Me parecio muy bien estructurado y planeado su poryecto 

Bloqueo de computadora(Obed, Ave, Pedro, Jona) 
Me parecio muy buena idea en cuanto a lo de reconocimiento facial o voz ya que ayudaría a personas que han sufrido algún tipo de broma en sus redes sociales, en sus encuestas me dí cuenta que podrían agregar que tan importante sería un software como este.

Despertador inteligente (Ramón, Cecy, Roberto)

Es una propuesta interestante, lo que observe en sus encuestas es que los usuarios les dieron una buena aportación que era enfocarlo mas a una aplicación y pienso sería mejor ya que la mayoría de esos usuarios cuentan con un smathphone y sería abarcar otro necesidad para los usuarios.

Oficina Inteligente (Lupe, Osvaldo, Triana, Esteban)
Es muy buena propuesta, a mi parecer en su entrevista si falto agregar a otros usuarios ya que los puntos en los que estan enfocados son variados, mi recomendación sería solo definir bien hacia que parte va dirigido,  por ejemplo algo de seguridad o cerrar ventanas o identificar personas para ver que tipo de tecnologías o herrmaientas podrían ser las mas aptas para su idea. 

Localizador GPS (Omar, Saúl Isaías)
Es de gran ayuda para muchos usuarios este tipo de dispositivo, pero no queda claro si será enfocado a niños o mascotas, ya que pienso podría ser diferente en cada caso en cuanto al funcional o en lo fisico también sería diferente ya que en personas si podria ser en forma de brazalete pero en perros sería preferible en collar a mi punto de vista. Y en las encuestas podrían haber recopilado ese dato si al usuario le gustaría que fuera usado en mascotas o niños, para en caso de niños el usuario que podría estar interesado serían las mamas y así ellas les darían su punto de vista.

CarNXP

Para este proyecto sería buena idea establecer otras edades para quien va dirigido el producto ya que no todas las personas mayores manejan o no tienen carro, me parece que sería mejor dirigirlo a jovenes y adultos  entre 20 y 50 años. 

Además, establecer si su producto es de uso compartido o es solo para una persona, y si las demás personas que usan el carro están dispuestas a aprender a usar la tecnología o utilizarla en sus autos.

Lab3. Convex Hull

Mi repositorio

Para esta semana se trabajo nuevamente con los bordes pero ahora, teníamos que ubicar los puntos de las orillas que al unirlos envuelve por completo una figura. 

El algoritmo usado para obtenerlo es  convex hull  al igual que de Jarvi’s march el cual resulta ser uno de los más sencillos

• ·Se inicia a un punto extremo dentro de los puntos del contorno, normalmente el que se encuentre más a la izquierda. 
• En cada paso, se prueba cada punto de los puntos y se encuentra cual hace la vuelta más larga hacia la derecha. Este punto debe estar en el contorno

En este caso no se obuvo el resultado al hacer el envolvimiento uniendo los puntos, pero si aparecen dentro de los bordes

Código

	import Image
	from sys import argv
	import ImageDraw
	TURN_LEFT, TURN_RIGHT, TURN_NONE = (1, -1, 0)
	def turn(p, q, r):
	return cmp((q[0] - p[0])*(r[1] - p[1]) - (r[0] - p[0])*(q[1] - p[1]), 0)
	#distancias entre p y q
	def dist(p, q):
	dx, dy = q[0] - p[0], q[1] - p[1]
	return dx * dx + dy * dy
	def next_hull_pt(points, p): #Para devolver el siguiente punto convexo desde la primer distancia p
	q = p
	for r in points:
	t = turn(p, q, r)
	if t == TURN_RIGHT or t == TURN_NONE and dist(p, r) > dist(p, q):
	q = r
	return q
	def convex_hull(points): # Aplicamos algoritmo Convex Hull que devuelve los puntos envolventes hacia la izquierda
	hull = [min(points)]
	for p in hull:
	q = next_hull_pt(points, p)
	if q != hull[0]:
	hull.append(q)
	return hull
	def bfs(imagen, rcolor, px, altura, ancho): # alicamos bfs para darle color al contorno de la imagen tomando los pixeles vecinos
	pixeles = imagen.load()
	(fila, columna) = px
	original = pixeles[fila, columna]
	cola = [(fila, columna)]
	cola2 = []
	while len(cola) > 0:
	(fila, columna) = cola.pop(0)
	actual = pixeles[fila, columna]
	if actual == original or actual == rcolor:
	for dx in [-1, 0, 1]:
	for dy in [-1, 0, 1]:
	candidato = (fila + dy, columna + dx)
	if candidato[0] >= 0 and candidato[0] < altura and candidato[1] >= 0 and candidato[1] < ancho:
	contenido = pixeles[candidato[0], candidato[1]]
	if contenido == original:
	pixeles[candidato[0], candidato[1]] = rcolor
	cola.append(candidato)
	cola2.append(candidato)
	return cola2
	def main(image):
	im = Image.open(image)
	w, h = im.size
	pix = im.load()
	hulls = []
	#draw = ImageDraw.Draw(im)
	for i in range(w):
	for j in range(h):
	if pix[i, j] == (255, 255, 255):
	coords = bfs(im, (255, 0, 0), (i, j), w, h)#BFS anteri
	#print coords
	hulls.append(convex_hull(coords))
	for hull in hulls:
	for points in hull:
	pix[points] = (0, 0, 0)
	#draw.line(((hulls[i][j], hulls[i][j+1])), fill=(0, 0, 255))
	im.save("fin.jpg")
	return hulls
	image = argv[1]
	main(image)

view raw convex.py hosted with ❤ by GitHub

Tarea2. Metodos de Codificación

Se realizo una simulación utilizando los métodos de búsqueda para palabras utilice el algoritmo de boyer-moore es el unico implementado.

Este algoritmo analiza la cadena de derecha a izquierda esto es eliminando el ultimo elemento del patrón de palabras después de esto se invierte este patrón y se van insertando todos los elementos que no esten en el patrón referente a la cadena de texto.

Y como resultado no obtuve nada porque aun no esta terminado :(

Código

	from sys import argv
	import random
	import time
	n=int(argv[1]) #recibe parametros n= longitud de cadena donde se busca
	m=int(argv[2]) #recibe parametros m=longitud de patron a buscar
	def generan(tam): #Funcion para generar patron o texto
	x=[] #Variable para guardar el texto o patron a generar
	for i in range(tam):
	letra=random.randint(97,122) #random de un numer0 de 97 a 122
	x.append(chr(letra)) #agrega letra
	return x
	def reversa(patron): #funcion para voltear palabra (forma reversa)
	reg_p=[]
	for i in reversed(patron):
	reg_p.append(i)
	return reg_p # regresa la palabra ya en reversa
	def agregar(reg_patron,texto):
	for i in texto:
	if str(texto[i]) in reg_patron:
	pass
	else:
	reg_patron.append(i)
	print reg_patron
	def b_moore(texto,patron): #algoritmo boye-moore
	inicio=time.time()
	intento = 0
	rev_patron=reversa(patron) #manda a poner de reversa la palabra
	rev_patron=rev_patron.pop(0)
	tabla=agregar(rev_patron,texto)
	print rev_patron
	def main():
	texto=generan(n)
	print texto
	patron = generar(m)
	print patron
	b_moore(texto,patron)
	main()

view raw moore.py hosted with ❤ by GitHub

Tecnicas de Diseño Conceptual

El  diseño  conceptual  es  una  parte  fundamental  en  el  proceso  de  diseño  ya que en esté se generan las posibles opciones a tomar en cuenta para el diseño
final. En  primer  lugar  se  deben  tomar  en  cuenta  los  requerimientos  planteados  para  la necesidad  a  cubrir.

Modelos de diseño:
Los modelos y métodos de diseño se pueden presentar dentro del campo que se califican como investigación en diseño cuyo objetivo es establecer nuevas formas o recomendaciones que potencién la eficiencia en el diseño.

Se clasifica los modelos de diseño en dos grupos: descriptivos y prescriptivos,
donde:

• Los modelos descriptivos muestran la secuencia de actividades que ocurren en diseño.
• Los prescriptivos, como su nombre lo indica, prescriben un patrón de actividades de diseño.

En la primera fase se buscan conceptos o principios de identificación de
solución al problema, para la cual se analiza el problema la necesidad identificado, se sintetiza una o varias posibles soluciones y se evalúan con respecto a restricciones (especificaciones)

En la fase de diseño preliminar se avanza en ser concretos en una solución al
problema, determinando componentes e interacciones con el suficiente grado como para poderla evaluar objetivamente.

Modelos cognitivos:
Los modelos cognitivos buscan hacer una descripción formal de la forma de actuación del conocimiento del individuo que diseña.

Se puede concluir que a pesar de las diferencias que pueden existir entre ellos, muestran algunas coincidencias que llevan a afirmar el reconocimiento de etapas comunes, como es el caso concreto de la etapa de generación de conceptos de diseño, esto es, de alternativas de solución al problema que se aborda en un momento determinado y tener creatividad.


Referencia:
Link1
Link2

Lab. Ubicom

Tarea 2(clase). Detección de formas

Para está tarea se utilizaron las rutinas anteriores para poder encontrar las separaciones que existen entre componentes de la imagen y poder diferenciarlos. 

Para detectar los contornos se realizaron los siguientes pasos:

• Conversión de imagen a escala de grises.

• Convolución de la imagen con la máscara aplicada anteriormente

• Binarización de la imagen

Aplique lo anterior a una nueva imagen para ver el comportamiento de la imagen con menos componentes.

Código Binarización https://gist.github.com/vane90/4983297

Detectar formas 

Para realizar el bfs utilice como base el algoritmo bfs utilizado por la Dra con texto ASCII visto en clase. Después de tener los contornos marcados donde tenemos un punto de inicio en las coordenadas x, y, se guarda el valor de su píxel en una variable, así poder recorrer todos los píxeles que son del mismo color y marcarlos de un color determinado. 

Mientras se recorren estos píxeles se va contando la cantidad de los píxeles para después calcular el porcentaje que tiene esa figura con respecto al total de píxeles y al ir recorreriendo cada píxel de la imagen binarizada, se aplicara BFS a cada pixel negro que se encuentre y coloreando sus vecinos con un color aleatorio. 

 

	def im2():
	image = Image.open('binarizada1.png')
	imagen = image.load()
	ancho,alto = image.size
	print ancho
	print alto
	for a in range(ancho):
	for b in range(alto):
	color=(random.randint(0,255),random.randint(0,255),random.randint(0,255))
	if imagen[a,b]==(0,0,0):
	n,xs,xy= bfs(image,color,a,b)
	nueva='formas.jpg'
	image.save(nueva)
	return nueva
	#aplicamos bfs en la imagen
	def bfs(image,color,a,b):
	imagen=image.load()
	ancho,alto=image.size
	original = imagen[a,b]
	c=[] #lista color
	xs=[] #coordenada x
	ys=[] #coordenada y
	c.append((a,b))
	n = 0
	while len(c) > 0:
	(x, y) = c.pop(0)
	actual = imagen[x, y]
	if actual == original or actual == color:
	for dx in [-1, 0, 1]:
	for dy in [-1, 0, 1]:
	i, j = (x + dy, y + dx)
	if i >= 0 and i < ancho and j >= 0 and j < alto:
	contiene = imagen[i, j]
	if contiene == original:
	imagen[i, j] = color
	xs.append(i)
	ys.append(j)
	n += 1
	c.append((i, j))
	forma1 = image.save('formas.png')
	return n, xs, ys

view raw bfs1.py hosted with ❤ by GitHub

Ahora el componente más grande es el fondo y se colorea gris.

Para hacer esto primero se necesitaba tener coloreadas las figuras, después se saca un porcentaje dependiendo de la cantidad de píxeles que cubre una figura con respecto a la cantidad de píxeles totales de la imagen, una vez que se tiene cual es la de mayor porcentaje con ese color que se guardo se hace de nuevo bfs() para pintar todo el fondo de color gris.

	def im2():
	image = Image.open('binarizada2.png') #carca la imagen con convolucion y binarizada
	imagen = image.load()
	ancho,alto = image.size
	total = ancho*alto
	porcentaje = []
	centro = []
	contiene = 0
	print ancho
	print alto
	#aplicamos bfs para la imagen
	for a in range(ancho):
	for b in range(alto):
	if imagen[a,b] == (0, 0, 0):
	color = random.randint(0,255),random.randint(0,255),random.randint(0,255)
	n,xs,xy= bfs(image,color,a,b)
	p = float(n)/float(total) * 100.0 #promedio maximo
	if p > 0.5:
	centro.append((sum(xs)/len(xs),sum(xy)/len(xy))) #obtenemos los centros de la imagen
	porcentaje.append([p, (color)])
	print "Pinta figura %s"%contiene
	contiene +=1
	fondo_new = porcentaje.index(max(porcentaje)) #
	max_c = porcentaje[fondo_new][1]
	print "Pinta fondo"
	for i in range(ancho): #ciclo para pintar en gris la parte con un mayor porcentaje de color
	for j in range(alto):
	if imagen[i,j]==max_c:
	imagen[i,j]=(120,120,120)
	nueva='fondogris.jpg'
	image.save(nueva)

view raw pgris.py hosted with ❤ by GitHub

Imagen con centros, porcentajes y etiquetas: 

Ahora lo que sigue es dibujar el centro de masa esto se obtiene sumando sus coordenadas "x" y "y"  para después promediarlas. Al lado del centro de masa se agrega una etiqueta del ID del componente al que pertenece.

Porcentajes

	import sys, pygame
	import Image
	from math import*
	from time import*
	import math
	import random
	import ImageDraw
	def im2():
	image = Image.open('binarizada2.png') #carca la imagen con convolucion y binarizada
	imagen = image.load()
	ancho,alto = image.size
	total = ancho*alto
	porcentaje = []
	centro = []
	contiene = 0
	print ancho
	print alto
	#aplicamos bfs para la imagen
	for a in range(ancho):
	for b in range(alto):
	if imagen[a,b] == (0, 0, 0):
	color = random.randint(0,255),random.randint(0,255),random.randint(0,255)
	n,xs,xy= bfs(image,color,a,b)
	p = float(n)/float(total) * 100.0 #promedio maximo
	if p > 0.5:
	centro.append((sum(xs)/len(xs),sum(xy)/len(xy))) #obtenemos los centros de la imagen
	porcentaje.append([p, (color)])
	print "Pinta figura %s"%contiene
	contiene +=1
	fondo_new = porcentaje.index(max(porcentaje)) #
	max_c = porcentaje[fondo_new][1]
	print "Pinta fondo"
	for i in range(ancho): #ciclo para pintar en gris la parte con un mayor porcentaje de color
	for j in range(alto):
	if imagen[i,j]==max_c:
	imagen[i,j]=(120,120,120)
	nueva='fondogris.jpg'
	image.save(nueva)
	#return nueva
	print "centros de masa"
	print centro
	#dibujar los centros y las etiquetas en las formas
	draw = ImageDraw.Draw(image)
	m=0
	for i in centro:
	draw.ellipse((i[0]-2, i[1]-2,i[0]+2,i[1]+2), fill=(0,0,0)) #dibuja los puntos en los centros de las formas
	draw.text(((i[0]+4,i[1]+4),), str(m), fill=(0,0,0)) #muestra las etiquetas cerca de los centros
	m +=1
	contiene = 0
	for p in porcentaje: #muestra el id de la etiqueta y el porcentaje de color de cada una
	print "Porcentaje de ID %d: %.2f"%(contiene, p[0])
	contiene +=1
	nueva2 = 'centro.jpg'
	image.save(nueva2)
	return nueva2
	def bfs(image,color,a,b):
	imagen=image.load()
	ancho,alto=image.size
	original = imagen[a,b]
	c=[]
	xs=[]
	ys=[]
	c.append((a,b))
	n = 0
	while len(c) > 0:
	(x, y) = c.pop(0)
	actual = imagen[x, y]
	if actual == original or actual == color:
	for dx in [-1, 0, 1]:
	for dy in [-1, 0, 1]:
	i, j = (x + dy, y + dx)
	if i >= 0 and i < ancho and j >= 0 and j < alto:
	contiene = imagen[i, j]
	if contiene == original:
	imagen[i, j] = color
	xs.append(i)
	ys.append(j)
	n += 1
	c.append((i, j))
	forma1 = image.save('formas.png')
	return n, xs, ys
	def main():
	pygame.init() # Inicializa pygame
	screen = pygame.display.set_mode((550, 300))
	pygame.display.set_caption('Formas')
	imagen = im2()
	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()
	if __name__ == "__main__":
	main()

view raw bfs2.py hosted with ❤ by GitHub

Otro ejemplo :

Repositorio :

Lab 2.Ruido Sal y Pimienta

Para esta semana se continuaando con imágenes ahora aplicando cierto ruido aleatorio y después eliminarlo.

Generación sal y pimienta:

Se observa que el ruido impulsivo tiene un efecto más extremo sobre un subconjunto del total de píxeles de la imagen. Un tanto por ciento de los píxeles de la imagen toman arbitrariamente el valor extremo 0 o 255.

La imagen original que utilice es la siguiente:

Aplicando Ruido

Aplicando a la imágen con el ruido generado aleatoriamente dentro de la imágen con una intensidad para el ruido sal y pimienta.

Al momento de eliminar el ruido en la imagén aún no lo hace por completo

 Código:

	import sys,pygame
	import sys, pygame
	import Image
	from math import*
	from time import*
	import math
	import random
	def main():
	pygame.init() # Inicializa pygame
	screen = pygame.display.set_mode((600, 600))
	pygame.display.set_caption('Ruido')
	imagen = gruido()
	i_fuera = fueraruido(imagen)
	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()
	def gruido():
	#tarda = time()
	image = Image.open("dory.jpg")
	imagen = image.load()
	ancho, alto = image.size
	#intenso = 200
	#cont = 0
	for i in range(ancho):
	for j in range(alto):
	(r,g,b)= image.getpixel((i,j)) #obtener pixeles
	sp = random.randint(0,255) #generar ruido random llenado de toda la imagen
	punto = random.randint(0,6000) #
	try:
	if (sp < 100): #ciclo compara la intensidad del ruido dentro de imagen
	imagen[i+punto,j+punto] = (0,0,0) # Agregamos el ruido en color negro simulando la pimienta
	else:
	imagen[i+punto,j+punto] = (255,255,255) #agregamos el ruido de color blanco simulando la sal
	except:
	pass
	nueva = 'ruido.jpg'
	otra = image.save(nueva)
	#t1 = time()
	#t2 = t1 - tarda
	#print "Tiempo que tardo el procesamiento = "+str(t2)+" segundos"
	return nueva
	def fueraruido(imagen):
	#imagen = 'ruido.jpg'
	imagen=Image.open(imagen)
	ima = imagen.load()
	ancho, alto = imagen.size
	for i in range(ancho):
	for j in range(alto):
	(r,g,b) = imagen.getpixel((i,j))
	try:
	if(pixel[i,j]==(0,0,0) or pixel[i,j]==(255,255,255)):
	pixel[i,j] = pixel[i-1,j]
	else:
	continue
	except:
	pass
	nueva2 = 'elimina.jpg'
	i_fuera = imagen.save(nueva2)
	#tiempo2 = time.time()
	#print "Tiempo de procesamiento filtro"
	return nueva2
	if __name__ == "__main__":
	main()

view raw ruido.py hosted with ❤ by GitHub

Aquí mi Repositorio
https://github.com/vane90/visioncomput/blob/master/v.py

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