Laboratorio 9: Detección de esquinas

En esta semana tenemos que detectar las esquinas de polígonos.

Pasos

	def boton_esquinas(self):
	imagen_grises=self.escala_grises()
	imagen_filtro,medianas=self.filtro(imagen_grises)
	imagen_dif=self.diferencia(imagen_filtro,imagen_grises,medianas)
	imagen_nor=self.normalizar(imagen_dif)
	esquinas=self.binarizar(imagen_nor)
	bordes_c=self.bordes()
	self.detectar(esquinas,bordes_c,bordes_c)
	print 'termino'
	return

view raw ins.py hosted with ❤ by GitHub

Como se ve en el código las instrucciones son las siguientes:

• Para primero porder detectar las esquinas:
• Tomamos una imagen que contenga polígonos.

• La pasamos a escala de grises

	def escala_grises(self):
	inicio = time()
	image = Image.open(self.o_imagen)
	pixels = image.load()
	ancho,alto = image.size
	self.matriz = numpy.empty((ancho, alto))
	for i in range(ancho):
	for j in range(alto):
	(r,g,b) = image.getpixel((i,j))
	escala = (r+g+b)/3
	pixels[i,j] = (escala,escala,escala)
	self.matriz[i,j] = int(escala)
	fin = time()
	tiempo_t = fin - inicio
	df = image.save('escala.png')
	print self.matriz
	raw_input()
	return image

view raw grises.py hosted with ❤ by GitHub

Comenzamos a sacar su filtro medio:
Lo que hacemos es checar cada vecino de pixel por pixel y ponerlos en una lista.

	def vecindad(self,i,j,lista,matriz,ancho,alto):
	pix=[]
	for x in lista:
	for y in lista:
	a = i+x
	b = j+y
	try:
	if a >= 0 and a < ancho and b >= 0 and b < alto:
	pix.append(self.matriz[a,b])
	except IndexError:
	pass
	return pix

view raw vec.py hosted with ❤ by GitHub

Ya que estan guardados en una lista, los ordenamos  de menor a mayor.
Seleccionamos la media de la lista ordenada.

	def p_medio(self,pix):
	o=sorted(pix)
	mediana=np.median(pix)
	return mediana

view raw media.py hosted with ❤ by GitHub

Se sustituyen ls¿os valores de r,g y b en cada pixel de la imagen dependiendo de la media.

Y nos queda la siguiente imagen:

 Después de lo anterior lo que sigue es sacar la diferencia entre la imagen de escala de grises y la imagen obtenida con el filtro medio:

	def diferencia(self,filtro,grises,medianas):
	pixels = grises.load()
	ancho,alto = grises.size
	self.min = 255
	self.max = 0
	self.fil = numpy.empty((ancho, alto))
	for i in range(ancho):
	for j in range(alto):
	dif=0
	dif=medianas[i,j]-self.matriz[i,j]
	self.fil[i,j]=dif
	if dif < self.min:
	self.min = dif
	if dif > self.max:
	self.max = dif
	dif=int(dif)
	pixels[i,j]=(dif,dif,dif)
	grises.save('diferencia.png')
	return grises

view raw dif.py hosted with ❤ by GitHub

Imagen

Ahora filtramos las esquinas, haciendo una normalización y después binarizamos:

	def normalizar(self,image):
	pixels = image.load()
	r = self.max-self.min
	prop = 255.0/r
	ancho,alto = image.size
	for i in range(ancho):
	for j in range(alto):
	if pixels[i,j][0]!=0:
	p =int(floor((self.fil[i,j]-self.min)*prop))
	pixels[i,j]=(p,p,p)
	image.save('nrmaliza.png')
	return image
	def binarizar(self,img):
	pixels = img.load()
	ancho,alto = img.size
	minimo = int(argv[2])
	for i in range(ancho):
	for j in range(alto):
	if pixels[i,j][1] < minimo:
	p=0
	else:
	p= 255
	pixels[i,j]=(p,p,p)
	img.save('binarizar.png')
	return img

view raw conj.py hosted with ❤ by GitHub

Imagen

Normalizar:

Binarizar

Sacamos bordes (el código ya se implemento en clases anteriores):

Ya obteniendo las esquinas sacamos los bordes solo si los pixeles son blancos, osea que tiene que coincidir las esquinas con bordes blancos(Código de bfs implementado anteriormente).

Otro ejemplo: