Tarea #5. Detección de elipses

Para esta semana se nos asigno de tarea contruir una rutina que detecta todos los elipses en la imagen con el método cuerda-targente.

Repositorio

Primero utilice lo que es parte de detección de bordes con las mascaras de sobel y la binarización de la imagén, esto ya hecho en la tarea 1.
Original

 

Borde

 Binarizada

Después se agrupan lo que son los bordes en este caso utilice la tarea de detección de formas donde utilizamos el bfs para eliminar pixeles que no son necesarios.

Para la parte donde se detectan las elipses ya entrando al método cuerda-tangente.

Este opera con pares de puntos; para ambos se calcula un tangente al elipse potencial y se calcula la intersección de estos dos tangentes T, al igual como el punto central M de la línea que conecta a los dos puntos.

Se tomarian parejas de puntos al azar, para obtener la recta tangente, se va utilizando el gradiente en este caso Gx y Gy para calcular la pendiente de la recta en forma m = Gy/Gx

Después se calcularia su distancia media, además de calcular en que punto se cruzan dos lineas que se prolonguen a partir de estos puntos y por ultimo las lineas con más cruces pueden ser parte de la elipse.

Código :(

	import Image
	from math import*
	from time import*
	import math
	import random
	import ImageDraw
	#Aplica bfs
	def im2():
	image = Image.open('binarizada.png') #carca la imagen con convolucion y binarizada
	imagen = image.load()
	ancho,alto = image.size
	total = ancho*alto
	#porcentaje = []
	centro = []
	contiene = 0
	fel=[]
	puntos = [] #
	print ancho
	print alto
	#aplicamos bfs para la imagen
	for a in range(ancho):
	for b in range(alto):
	if imagen[a,b] == (255, 255, 255):
	color = random.randint(0,255),random.randint(0,255),random.randint(0,255)
	n,xs,xy,c= 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)))
	fel.append(c)
	#obtenemos los centros de la imagen
	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, fel
	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, c
	def b_elipse(imagen,fel): #
	for i in fel:
	print len(i)
	def t_elipse(imagen):
	ancho,alto = ima1.size
	frec = numpy.empty((ancho, alto)) #frecuecia en centros
	gx_s = []
	gy_s = []
	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):
	gx_s, gy_s = 0, 0
	#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
	#gx = pow(sumx,2)
	#gy = pow(sumy,2)
	#grad = int(math.sqrt(gx + gy))
	#imagen[i,j] = (grad, grad, grad)
	gx_s.append(mul_x)
	gy_s.append(mul_y)
	return gxs, gys
	#obtenemos puntos random y verifica si son parte de la elipse
	def puntos_e(gx_s, gy_s, ps):
	l = 0
	for i in range(len(gx_s)):
	if(gx_s[i] == 0):
	gx_s.pop(i)
	if(gy_s[i] == 0):
	gy_s.pop(i)
	while(l == 0):
	p1 = random.randint(0, len(gx_s)-1)
	p2 = random.randint(0, len(gx_s)-1)
	x1, y1 = ps[p1]
	x2, y2 = ps[p2]
	print x1, y1
	print x2, y2
	m1 = gy_s[p1] / gx_s[p1]
	m2 = gy_s[p2] / gx_s[p2]
	if (m1 != 0 and m2 != 0 and m1 != m2):
	l = 1
	return m1, m2
	def main():
	imagen, fel, puntos = im2()
	gx_s, gy_s = t_elipse(imagen)
	imagen2 = b_elipse(imagen,fel)
	m1,m2 = puntos_e(gx_s,gy_s, ps)
	print m1, m2
	if __name__ == "__main__":
	main()

view raw noelip.py hosted with ❤ by GitHub

Y aun no esta terminado solo pude obtener detección de las formas, continuara...