Polígonos

Para esta tarea se nos pide detectar polígonos por medio del método detección de lineas rectas.

Lo que realicé y no está terminado es:

1. Cambiar a grises
2. Sacar convolución Laplaciana para sacar bordes
3. Normalizo la imagen
4. Binarizo los datos
5. Sacamos el promedio
6. Se agrega un umbral
7. Agregamos BFS para detectar todos los bordes 
8. Los pintamos de diferentes colores
9. Sacamos mascara de sobel en X
10. Sacamos mascara de sobel en Y
11. Detectamos la pendiente de cada pixel
12. Calculamos su theta (pendiente) 
13. Ordenamos valores calculados según su pendiente.
14. Checamos el cambio de cada theta para detectar los lados
15. Pintamos cada lado de diferente color.

Les muestro unas capturas de pantalla del procedimiento:

Existe mucho ruido en la imagen y no pude detectar cada lado de los polígonos, por ejemplo en la primera imagen obtuve estos lados.

Donde si tengo 5 figuras, pero los lados no concuerdan.

Código relevante

	def boton_poli():
	inicio = time.time()
	label.destroy()
	max = 0
	suma = 0.0
	#A grises
	imagen = cambiar_agrises(path_imagen_original)
	imagen.save("paso_1.jpg")
	votos = list()
	#A grises
	imagen = cambiar_agrises(path_imagen_original)
	imagen.save("paso_1.jpg")
	#Agrego Laplaciana
	h_lap = numpy.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]])
	imagen_prom, puntos = convolucion(imagen, numpy.multiply(1.0/1.0,h_lap))
	imagen_prom = cambiar_umbral(imagen_prom, 0.1)
	imagen_prom.save("paso_2.jpg")
	#Agrego normalizacion
	imagen_nor = normalizacion(imagen_prom)
	imagen_nor.save("paso_3.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.1
	imagen_bin = cambiar_umbral(imagen_nor.convert("RGB"), umbral_valor)
	imagen_bin.save("paso_4.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_bin.convert("RGB"))
	imagen_prom.save("paso_5.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.08
	imagen_bin2 = cambiar_umbral(imagen_prom.convert("RGB"), umbral_valor)
	imagen_bin2.save("paso_6.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_bin2.convert("RGB"))
	imagen_prom.save("paso_7.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_prom.convert("RGB"))
	imagen_prom.save("paso_8.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.5
	imagen_BFS = cambiar_umbral(imagen_prom.convert("RGB"), umbral_valor)
	imagen_BFS.save("paso_9.jpg")
	imagen_BFS, colores, poligonos = aplicar_BFS(imagen_BFS)
	imagen_BFS.save("paso_10.jpg")
	x, y = imagen_BFS.size
	pixeles = imagen_BFS.load()
	bordes_detectados = []
	h_Y = numpy.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
	h_X = numpy.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
	imagen_hori, puntos_GX = convolucion(imagen, numpy.multiply(1.0/1.0,h_X))
	imagen_hori.save("paso_sobelX.jpg")
	pixeles_GX = imagen_hori.load()
	imagen_verti, puntos_GY = convolucion(imagen, numpy.multiply(1.0/1.0,h_Y))
	imagen_verti.save("paso_sobelY.jpg")
	pixeles_GY = imagen_verti.load()
	dibuja = ImageDraw.Draw(imagen_BFS)
	x, y = imagen_BFS.size
	puntos = numpy.zeros(x*y).reshape((x, y))
	lados = []
	for poli in poligonos:
	fig = []
	x, y = imagen_BFS.size
	puntos = numpy.zeros(x*y).reshape((x, y))
	for i in range(len(poli)):
	gx = puntos_GX[poli[i][0], poli[i][1]]
	gy = puntos_GY[poli[i][0], poli[i][1]]
	tangente = atan2(gy, gx)
	tan = degrees(tangente)
	fig.append((poli[i][0], poli[i][1], tan))
	arreglado = sorted(fig, key=lambda tup: tup[2])
	lados.append(arreglado)
	for i in range(len(lados)):
	cont = 0
	for j in range(len(lados[i])):
	cambio = lados[i][j][2] - lados[i][j-1][2]
	cambio = fabs(cambio)
	if cambio > 10.0:
	color = (random.randint(0,255), random.randint(0,255), random.randint(0, 255))
	cont = cont + 1
	dibuja.ellipse((lados[i][j][0]-3,lados[i][j][1]-3,lados[i][j][0]+3, lados[i][j][1]+3), fill=color)
	print "LADOS == " + str(cont)
	poner_imagen(imagen_BFS)
	imagen_BFS.save("paso_11.jpg")
	#Tiempo
	fin = time.time()
	tiempo = fin - inicio
	print "Tiempo que trascurrio -> " + str(tiempo)

view raw Poli.py hosted with ❤ by GitHub

Eso es lo que tengo :(