Laboratorio 2

Código:

	from Tkinter import *
	from PIL import Image, ImageTk
	import math
	def convolucion(image, mascara):
	x,y = image.size
	foto = image.load()
	image_new = Image.new("RGB",(x,y))
	foto_new = image_new.load()
	for i in range(x):
	for j in range(y):
	total = 0
	for a in range(i-1,i+2):
	for b in range(j-2,j+2):
	if a>=0 and b>=0 and a<x and b<y:
	total += mascara[a-(i-1)][b-(j-1)]*foto[a,b][0]
	foto_new[i,j]=(total,total,total)
	image_new.save("convolucion.png")
	return image_new
	def normalizar(image):
	x,y = image.size
	image_normalizada = Image.new("RGB",(x,y))
	foto = []
	for i in range(y):
	for j in range(x):
	fot = image.getpixel((i,j))[0]
	foto.append(fot)
	maximo = max(foto)
	minimo = min(foto)
	a = 256.0/(maximo - minimo)
	foto = []
	for i in range(y):
	for j in range(x):
	fot = image.getpixel((i,j))[0]
	foto_new = int(math.floor((fot-minimo)*1))
	foto.append((foto_new,foto_new,foto_new))
	image_normalizada.putdata(foto)
	image_normalizada.save("normalizada.png")
	return image_normalizada
	def main():
	image = Image.open("imagen.jpg")
	image = image.convert('RGB')
	new = normalizar(image)
	sobel_h = [[-1,0,1],[-2,0,2],[-1,0,1]]
	sobel_v = [[1,1,1],[0,0,0],[-1,-1,-1]]
	prewitt_h = [[1,1,1],[-1,-2,1],[-1,-1,1]]
	prewitt_v = [[-1,1,1],[-1,-2,1],[-1,1,1]]
	new = convolucion(new, sobel_h)
	new.save("sobelh.png")
	new = convolucion(new, sobel_v)
	new.save("sobelv.png")
	new = convolucion(new, prewitt_h)
	new.save("prewith.png")
	new = convolucion(new, prewitt_v)
	new.save("prewitv.png")
	main()

view raw lab_2.py hosted with ❤ by GitHub

Resultados:

imagen original

mascara

mascara

mascara

mascara

mascara

normalizada

                                                     

Laboratorio 1

Código: 

	import Image
	import math
	from sys import argv
	import random
	def cambio():
	image = Image.open("imagen.jpg")
	x,y = image.size
	print "elije: r , g, b"
	foto = image.load()
	elejir = raw_input()
	for i in range(x):
	for j in range(y):
	(r,g,b) = image.getpixel((i,j))
	if(elejir == "r"):
	foto[i,j] = (r,0,0)
	if(elejir == "g"):
	foto[i,j] = (0,g,0)
	if(elejir == "b"):
	foto[i,j]=(0,0,b)
	image.save("cambiar.png")
	return image
	def contraste():
	image = Image.open("imagen.jpg")
	x,y = image.size
	foto = image.load()
	minimo = int(argv[1])
	for i in range(x):
	for j in range(y):
	a = foto[i,j]
	rgb = (a[0] + a[1] + a[2])/3
	foto[i,j] = (rgb, rgb, rgb)
	if foto[i,j][1] < minimo:
	p=0
	else:
	p= 255
	foto[i,j]=(p,p,p)
	image.save("contraste.png")
	return image
	def invertir():
	image = Image.open("imagen.jpg")
	x,y = image.size
	foto = image.load()
	for i in range(x):
	for j in range(y):
	(r,g,b) = image.getpixel((i,j))
	rr = (255-r)
	gg = (255-g)
	bb = (255-b)
	foto[i,j] = (rr-gg-bb)
	image.save("invertida.png")
	return image
	def luminosidad():
	image = Image.open("imagen.jpg")
	x,y = image.size
	foto = image.load()
	minimo = random.randint(1,100)
	maximo = random.randint(101,200)
	print "Valor minimo: "+str(minimo)
	print "Valor maximo: "+str(maximo)
	for i in range(x):
	for j in range(y):
	(r,g,b) = image.getpixel((i,j))
	promedio=int((r+g+b)/3)
	if promedio <= minimo:
	promedio=0
	if promedio >= maximo:
	promedio=255
	foto[i,j]=(promedio,promedio,promedio)
	image.save("luminosidad.png")
	return image
	def luz():
	image = Image.open("imagen.jpg")
	x,y = image.size
	foto = image.load()
	luz = int(argv[2])#cantidad de luz
	for i in range(x):
	for j in range(y):
	(r,g,b) = image.getpixel((i,j))
	rr = (luz+r)
	gg = (luz+g)
	bb = (luz+b)
	foto[i,j] = (rr,gg,bb)
	image.save("luz.png")
	return image
	def main():
	cam = cambio()
	cont = contraste()
	inver = invertir()
	lum = luminosidad()
	lu = luz()
	main()

view raw lab_1.py hosted with ❤ by GitHub

Resultados:

imagen original

cambio

contraste

invertida

luminosidad 1

luminosidad 2

Laboratorio 10. Detección de movimiento

Detección de movimiento

Mi Repositorio

Para esta semana la tarea de laboratorio es detectar los movimientos en una imagen

Las técnicas que yo utilice para realizar esto fueron basadas en tares anteriores:

• Escala de grises 
• Filtro 
• Convolución 
• Binarizacion 
• Formas 
• Diferencia 

Estas actividades se realizaron en tareas anteriores y podemos encontrar en que consiste cada una en entradas anteriores al blog.

Lo primero que realice fue hacer un programa que generara 3 imágenes en movimiento, y partir de una imagen tomada de ese movimiento.

Después de realizar esta actividad seguimos con el programa que detectara el movimiento de las figuras, en esta parte es donde se aplican  todas los procesos de las imágenes descritos en entradas anteriores. 

Al funcionar el programa se obtiene una primer imagen ala cual se le calculan sus centros de masa y se le aplican todas las funciones requeridas para procesar la imagen y de ahi al terminar de procesarla se genera otra imagen. 

La segunda imagen creada por la animación se le aplica el mismo proceso:

• Escala de grises
• Filtro
• Convolución
• Formas

De la misma manera se obtiene lo que son sus centros
Ahora para saber si existe movimiento comparamos lo la posición de los centros y si la posición es diferente entonces encontramos que si se realizo movimiento.

primer imagen generada

segunda imagen generada

primer imagen generada en escala

segunda imagen generada en escala

primer imagen en filtro

segunda imagen generada en filtro

primer imagen generada en convolución

segunda imagen generada en convolución 

resultados en la terminal

Código generador de movimiento:

	import pygame, sys
	from pygame.locals import *
	import time
	pygame.init()
	ancho_ventana = 500
	alto_ventana = 500
	ventanaSurface = pygame.display.set_mode((ancho_ventana, alto_ventana), 0, 32)
	b_izq = 1
	b_der = 5
	s_izq = 7
	s_der = 9
	mueve_rect = 4
	blanco = (255,255,255)
	naranja = (255,69,0)
	verde = (0,128,0)
	amarillo = (255,255,0)
	fig_1 = {'rect':pygame.Rect(300, 80, 50, 100), 'color':naranja, 'dir':s_der}
	fig_2 = {'rect':pygame.Rect(300, 80, 60, 100), 'color':verde, 'dir':s_izq}
	fig_3 = {'rect':pygame.Rect(300, 80, 60, 100), 'color':amarillo,'dir':b_izq}
	rect = [fig_1, fig_2, fig_3]
	while True:
	for event in pygame.event.get():
	if event.type == QUIT:
	pygame.quit()
	sys.exit()
	ventanaSurface.fill(blanco)
	for fig in rect:
	if fig['dir'] == b_izq:
	fig['rect'].left -= mueve_rect
	fig['rect'].top += mueve_rect
	if fig['dir'] == b_der:
	fig['rect'].left += mueve_rect
	fig['rect'].top += mueve_rect
	if fig['dir'] == s_izq:
	fig['rect'].left -= mueve_rect
	fig['rect'].top -= mueve_rect
	if fig['dir'] == s_der:
	fig['rect'].left += mueve_rect
	fig['rect'].top -= mueve_rect
	if fig['rect'].top < 0:
	if fig['dir'] == s_izq:
	fig['dir'] = b_izq
	if fig['dir'] == s_der:
	fig['dir'] = b_der
	if fig['rect'].bottom > ancho_ventana:
	if fig['dir'] == b_izq:
	fig['dir'] = s_izq
	if fig['dir'] == b_der:
	fig['dir'] = s_der
	if fig['rect'].left < 0:
	if fig['dir'] == b_izq:
	fig['dir'] = b_der
	if fig['dir'] == s_der:
	fig['dir'] = s_der
	if fig['rect'].right > alto_ventana:
	if fig['dir'] == b_der:
	fig['dir'] = b_izq
	if fig['dir'] == s_der:
	fig['dir'] = s_izq
	pygame.draw.rect(ventanaSurface, fig['color'], fig['rect'])
	pygame.image.save(ventanaSurface,'movimiento.png')
	pygame.display.update()
	time.sleep(0.02)

view raw gen_mov.py hosted with ❤ by GitHub

Código detector de movimiento:

	import pygame, sys, time
	from pygame.locals import *
	import Image
	import numpy
	img='movimiento.png'
	ancho = 500
	alto = 500
	ventana = None
	def abrir_imagen():
	imagen = Image.open('movimiento.png')
	foto = imagen.load()
	return foto
	def detectar_mov(pix1,pix2):
	global img,ancho,alto
	pix=[pix1,pix2]
	for p in pix:
	obt_pix(p)
	return
	def formas(pix):
	image = filtro(pix)
	image_c,minimo,maximo,gx,gy,conv = mascara(image)
	pix_n = normalizar(image_c,minimo,maximo,conv)
	pix_b = binarizar(pix_n)
	deteccion(pix_b,pix_b)
	def deteccion(img,im):
	imagen,masa,centros = colorear(img,im)
	return masa,imagen,centros
	def colorear(im,imag):
	foto = im.load()
	global ancho,alto
	porc=[]
	fondos=[]
	centro=[]
	masa=[]
	ancho,alto = im.size
	pixeles = ancho*alto
	c = 0
	pintar = []
	f = 0
	m = []
	for i in range(ancho):
	for j in range(alto):
	pix = foto[i,j]
	r,g,b= random.randint(0,255),random.randint(0,255), random.randint(0,255)
	fondo = (r,g,b)
	if (pix==(0,0,0)):
	c +=1
	origen=(i,j)
	num_pixeles,abscisa,ordenada,puntos=bfs(pix,origen,imag,fondo)
	p=(num_pixels/float(pixeles))*100
	if p>.3:
	centro=(sum(abscisa)/float(num_pixeles),sum(ordenada)/float(num_pixeles))
	masa.append(num_pixeles)
	porcentajes.append(p)
	fondos.append(fondo)
	centro_masa.append(centro)
	print centro
	im.save('formas.png')
	return im,m,centro_masa
	def bfs(pix,origen,im,fondo):
	foto = im.load()
	cola=list()
	lista = [-1,0,1]
	abscisa = []
	ordenada = []
	pts = []
	cola.append(origen)
	original = foto[origen]
	num=1
	while len(cola) > 0:
	(i,j)=cola.pop(0)
	actual = foto[i,j]
	if actual == original or actual==fondo:
	for x in lista:
	for y in lista:
	a= i+x
	b = j+y
	try:
	if foto[a,b]:
	contenido = foto[a,b]
	if contenido == original:
	foto[a,b] = fondo
	abscisa.append(a)
	ordenada.append(b)
	num +=1
	cola.append((a,b))
	puntos.append((a,b))
	except IndexError:
	pass
	return num,abscisa,ordenada,puntos
	def obtener_pix(m):
	global ancho,alto
	analis=numpy.empty((ancho, alto))
	for i in range(ancho):
	for j in range(alto):
	print analis[i,j]
	print 'i',i
	print 'j',j
	r,g,b = m[i,j]
	print type(r)
	print type(g)
	print type(b)
	raw_input()
	analis[i,j]=(r,g,b)
	return analis
	def filtro(pix):
	escala(pix)
	raw_input()
	foto = image.load()
	ancho, alto =image.size
	lista = [-1,0,1]
	for i in range(ancho):
	for j in range(alto):
	prom = self.vecino(i,j,listas,self.analis)
	foto[i,j] = (prom,prom,prom)
	return image
	image = filtro(pix)
	def normalizar(image,minimo,maximo,conv):
	foto = image.load()
	global anocho,alto
	r = maximo-minimo
	prop = 255.0/r
	for i in range(ancho):
	for j in range(alto):
	p =int(floor((conv[i,j]-minimo)*prop))
	foto[i,j]=(p,p,p);
	image.save('normalizar.png')
	return image
	def binarizar(img):
	global anocho,alto
	foto=img.load()
	img.save('para.png')
	minimo = int(argv[1])
	for i in range(ancho):
	for j in range(alto):
	if pixels[i,j][0] < minimo:
	p=0
	else:
	p= 255
	foto[i,j]=(p,p,p)
	img.save('binarizar.png')
	return img
	def mascara(image):
	sobelx = ([-1,0,1],[-2,0,2],[-1,0,1])
	sobely = ([1,2,1],[0,0,0],[-1,-2,-1])
	pixels,minimo,maximo,gx,gy,conv=convolucion(sobelx,sobely,image)
	return pixels,minimo,maximo,gx,gy,conv
	def convolucion(sobelx,sobely,image):
	foto = image.load()
	ancho, alto = image.size
	m = len(sobelx[0])
	conv = np.empty((ancho, alto))
	gx = numpy.empty((ancho, alto))
	gy = numpy.empty((ancho, alto))
	minimo = 255
	maximo = 0
	for x in range(ancho):
	for y in range(alto):
	sumax = 0.0
	sumay = 0.0
	for i in range(m):
	for j in range(m):
	try:
	sumax +=(foto[x+i,y+j][0]*sobelx[i][j])
	sumay +=(foto[x+i,y+j][0]*sobely[i][j])
	except:
	pass
	gradiente = math.sqrt(pow(sumax,2)+pow(sumay,2))
	conv[x,y]=gradiente
	gx[x,y]=sumax
	gy[x,y]=sumay
	gradiente = int(gradiente)
	foto[x,y] = (gradiente,gradiente,gradiente)
	p = gradiente
	if p <minimo:
	minimo = p
	if p > maximo:
	maximo = p
	image.save('convolucion.png')
	return image,gx,gy,minimo,maximo,conv
	def vecindad(i,j,lista,image):
	foto = image.load()
	promedio = 0
	indice = 0
	for x in lista:
	for y in lista:
	a = i+x
	b = j+y
	try:
	if pixels[a,b] and (x!=a and y!=b):
	promedio += pixels[a,b][0]
	indice +=1
	except IndexError:
	pass
	try:
	promedio = int(promedio/indice)
	return promedio
	except ZeroDivisionError:
	return 0
	def escala(pix):
	global ancho,alto
	foto = pix
	analis = numpy.empty((ancho, alto))
	for i in range(ancho):
	for j in range(alto):
	(r,g,b) = foto[i,j]
	escala_gris = (r+g+b)/3
	foto[i,j] = (escala_gris,escala_gris,escala_gris)
	analis[i,j] = int(escala_gris)
	im = Image.fromarray(foto)
	im.save()
	return image
	def main():
	anterior=None
	siguiente=None
	global img
	pygame.init()
	ancho = 500
	alto = 500
	ventana= pygame.display.set_mode((ancho, alto), 0, 32)
	b_izq = 1
	b_der = 5
	s_izq = 7
	s_der = 9
	mueve_rect = 4
	naranja = (255,69,0)
	verde = (0,128,0)
	amarillo = (255,255,0)
	fig = {'rect':pygame.Rect(50, 50,50, 50), 'color':naranja,'dir':s_der}
	rect = [fig]
	while True:
	for event in pygame.event.get():
	if event.type == QUIT:
	pygame.quit()
	sys.exit()
	ventana.fill((255,255,255))
	for fig in rect:
	if fig['dir'] == b_izq:
	fig['rect'].left -= mueve_rect
	fig['rect'].top += mueve_rect
	if fig['dir'] == b_der:
	fig['rect'].left += mueve_rect
	fig['rect'].top += mueve_rect
	if fig['dir'] == s_izq:
	fig['rect'].left -= mueve_rect
	fig['rect'].top -= mueve_rect
	if fig['dir'] == s_der:
	fig['rect'].left += mueve_rect
	fig['rect'].top -= mueve_rect
	if fig['rect'].top < 0:
	if fig['dir'] == s_izq:
	fig['dir'] = b_izq
	if fig['dir'] == s_der:
	fig['dir'] = b_der
	if fig['rect'].bottom > ancho:
	if fig['dir'] == b_izq:
	fig['dir'] = s_izq
	if fig['dir'] == b_der:
	fig['dir'] = s_der
	if fig['rect'].left < 0:
	if fig['dir'] == b_izq:
	fig['dir'] = b_der
	if fig['dir'] == s_der:
	fig['dir'] = s_der
	if fig['rect'].right > alto:
	if fig['dir'] == b_der:
	fig['dir'] = b_izq
	if fig['dir'] == s_der:
	fig['dir'] = s_izq
	pygame.draw.rect(ventana, fig['color'], fig['rect'])
	pygame.image.save(ventana,img)
	if anterior==None:
	pix_a = abrir_imagen()
	anterior = pix_a
	print 'anterior',anterior
	else:
	pix_s = abrir_imagen()
	siguiente = pix_s
	print 'siguiente'
	ddetectar_mov(pix_a,pix_s)
	anterior = siguiente
	print 'detect'
	raw_input()
	pygame.display.update()
	time.sleep(0.02)
	main()

view raw seg_mov.py hosted with ❤ by GitHub

  

Reporte de proyecto: Detección de glóbulos rojos en la sangre

Link del proyecto en mi repositorio: https://github.com/cristhianguardado/proyecto-de-vison-

Propósito:

El objetivo del siguiente trabajo es detectar círculos en una imagen de pruebas clínicas, donde se pone una muestra en un reactivo. El objetivo de reconocer los círculos en la imagen (coordenadas del centro y radio) puede ser contado, etiquetarlos o hacer un promediado de color dentro de estos.

Alcance:

Todo el procesamiento y la detección de los círculos en este trabajo esta pensado para las imágenes que se nos suministraron.

Estas imágenes siguen un patrón que comienza con una muestra en un fondo claro y luego viene una franja oscura donde no hay círculos.

Justificación:

La justificación del proyecto por sus aplicaciones en la vida real.

La aplicación más importante es o pude tener en un laboratorio clínico dando mejores resultados en el momento de un análisis clínico de frotis de sangre, ayudando al químico en este caso la persona que analiza la muestra de manera convencional la cual es observando desde un microscopio pudiendo tener un error al momento de no observar bien alguna área de la muestra o haciendo mal el conteo de dichas células en este caso los glóbulos rojos.

                                                   

Esto no descarta que sea bueno que el químico que analiza la muestra no haga su trabajo checando la muestra el programa fue echo para hacer más seguro el resultado obtenido y tener una mayor confiabilidad tanto para los pacientes como para las personas que analizan estas muestras de manera manual y visual mediante el uso de un microscopio.

EL vídeo explica un poco las células que se pueden encontrar en una muestra de sangre las cuales son analizadas por una persona.

Descripción textual:

Lo que el programa realiza básicamente es que al recibir una imagen de un amuestra de sangre o alguna muestra clínica, donde al analizar la imagen dada el programa realiza una serie de procesos a la imagen antes de poder detectar las células que se encuentran en una muestra clínica.

Al realizar todos los procesos se debe calcular un valor “umbral” para cada imagen individualmente para que funcione de mejor manera y se puedan detectar las figuras con mayor certeza y facilidad, al determinar el valor umbral de cada imagen se obtienen mejores resultados al aplicar las etapas de erosión y dilatación ayudando a que la imagen resultante no presente ruido.

Al tener identificado el umbral las demás etapas de la detección de células en la imagen que se procesara pasaran por más etapas de modificación las cuales darán una imagen resultante por cada etapa del procesamiento por la que pasa la imagen.

Al finalizar el procesamiento se presenta un resultado de cuantas células se detectaron en la imagen.

Morfología Matemática:

La palabra morfología significa forma y estructura de un objeto. Para imágenes binarias se definen operaciones morfológicas. Y con estas se constituye una herramienta de extracción de componentes de imagen útiles en la representación y descripción de la forma de las regiones.

Las operaciones básicas de la morfología matemática son: dilatación se puede simplificar a decir que es agregar píxeles a un objeto, hacerlo más grande, y luego erosión es hacerlo mas chico.

Luego la combinación de estas da origen a los operadores de Apertura y Clausura. El primero consiste en aplicar una erosión seguida de una dilatación aplicando la misma forma estructurada, como resultado esta tiende a “abrir pequeños huecos”. La clausura es el la aplicación de las operaciones básicas en el sentido inverso, y resulta en “cerrar los huecos”.

Estas operaciones morfológicas son de gran importancia para lograr obtener un resultado en el análisis de dichas imágenes.

Dilatación:
Las operaciones morfológicas en el valor de cada píxel en la imagen de salida depende del valor de ese píxel en la imagen de entrada y su relación con la vecindad. El elemento estructural define el tamaño y la forma de la vecindad en la que se aplicara la operación morfológica.

                                        

Dilatación:
En la dilatación se adiciona píxeles al contorno de objetos presentes en la imagen mientras que los píxeles de salida el máximo de estos presentes en la vecindad está definida por el elemento estructural.

Erosión:
En las imágenes binarias la erosión elimina los píxeles del contorno de objetos presentes en la imagen y el píxel de salida debe ser el mínimo de los píxeles presentes en la vecindad definida por el elemento estructural

Diseño:

1. Carga imagen 
2. Escala de grises
3. Filtro 
4. Convolución 
5. Normalización 
6. Binarizacion 
7. Erosión
8. Dilatación 
9. Detección de círculos 

                                 

Librerías, lenguajes etc.:

Lenguaje de programación:

• Python 

Librerías: 

• Pil 
• Numpy 

Evaluación y desempeño:

Lo primero fue conseguir las imágenes de frotis sanguíneo, las cuales fueron encontradas en diferentes sitios web relacionados con imágenes histologícas, estudios clínicos y materias relacionadas con el área medica, algunas referencias son:

http://www.elrincondelamedicinainterna.com/2012/10/frotis-de-sangre-periferica-extendido.html

http://tmumayor.com/moodle/course/info.php?id=15

http://mondomedico.es/2012/07/01/el-oraculo-del-microscopio/

Y algunos lugares de interés donde podríamos encontrar imágenes interesantes.

http://lahistoteca.blogspot.mx/2008_10_01_archive.html
http://miriamencalada.wordpress.com/2010/02/11/frotis-sanguineo/

En esos link´s se habla sobre las histologia de las células pero para este caso solo fue de interés las imágenes que se encontraban ahí, y alguna que otra referencia sobre la morfología de las células, lo cual me ayudo un poco a entender la forma que tienen. es importante que las imágenes que utilizaremos para realizar las pruebas no contengan figuras muy pequeñas si no que hayan sido tomadas con un buen aumento.

Como para cada imagen es necesario calcular un valor umbral único ya que si no se mostrarían resultados distintos o poco seguros usando un umbral estándar para todas.
Calcule el umbral para cada imagen y son los siguientes:

Umbral calculado de 100

Umbral calculado de 170

Umbral calculado de 255

Umbral calculado de 95

Al calcular esto para cada imagen el ruido se disminuye de manera considerable en las imágenes al aplicarle la binarizacion y se obtienen mejores resultados en la dilatación obteniendo las figuras totalmente cerradas.

Estas son algunas pruebas:

Imagen original

escala de grises

filtro

binarizada

mascara

 erosión

 dilatación

resultado final

Otro ejemplo:                                                         

   

  imagen original

escala de grises 

filtro

convolución

binarizada 

erosión 

dilatación                                                                    

resultado final    

                             

   

En cuanto al desempeño el programa suele ser un poco tardado en identificar todas las formas en imágenes que cuentan con demasiadas formas en ella haciendo lento el procedimiento de relleno de las formas en total.

Trabajo futuro:

Implementar directamente en el microscopio para que el sistema analice directamente los análisis clínicos e incorporar un módulo que se encargue de formatear la información obtenida por el sistema y que sea guardado en un documento pdf.

Bibliografias:

1.- Omar Sanchez (2008).
     Disponible en: http://www.slideshare.net/omarspp/imagen-morfologicas
     (Fecha de consulta 13 de mayo de 2013)
2.- Rafael Proveda, "Filtros y  operaciones en imágenes", (2011)
      Disponible en: http://www.raerpo.com/2011/01/13-ejercicios-capitulo-5.html
      (Fecha de consulta 13 de mayo de 2013)

Presentación:

Presentación final from Cristhian Estrada Guardado

Link Presentación