Laboratorio 5:

Detección de circulos sin radio

En esta entrada tenemos que realizar la detección de circulos pero con diferentes radios.
Lo que trate primero fue acomodar mi codigo de la vez anterior ya que no me detectaba lo que son los circulos solo los centros.

Imagen original:

 Lo que hice fue darle una lista de parametros con radios diferentes los radios que tienen mis circulos. Después.

Guarde una imagen por cada iteracion:

Como vemos aun falta ya que lo que hago yo es que le doy estaticos los radios.


Este es sólo mi código relevante:

	def convolucion(self,h1,h2,image):
	pixels = image.load()
	ancho,alto = image.size
	gx=numpy.empty((ancho, alto))
	gy=numpy.empty((ancho, alto))
	a=len(h1[0])
	self.conv = numpy.empty((ancho, alto))
	self.minimo = 255
	self.maximo = 0
	for x in range(ancho):
	for y in range(alto):
	sumax = 0.0
	sumay = 0.0
	for i in range(a):
	for j in range(a):
	try:
	sumax +=(pixels[x+i,y+j][0]*h1[i][j])
	sumay +=(pixels[x+i,y+j][0]*h2[i][j])
	except:
	pass
	gradiente = math.sqrt(pow(sumax,2)+pow(sumay,2))
	self.conv[x,y]=gradiente
	gradiente = int(gradiente)
	pixels[x,y] = (gradiente,gradiente,gradiente)
	p = gradiente
	gx[x,y]=sumax
	gy[x,y]=sumay
	if p < self.minimo:
	self.minimo = p
	if p > self.maximo:
	self.maximo = p
	return image,gx,gy
	def circulos():
	radio=[60,40]
	for i radio:
	maximo = 0
	suma = 0.0
	print "sumando"
	for i in range(alto):
	for j in range(ancho):
	v = frec[j][i]
	suma += v
	if v > maximo:
	maximo = v
	promedio = suma / (ancho * alto)
	umbral = (maximo-promedio)/2.0
	centro = []
	for i in range(alto):
	for j in range(ancho):
	v = frec[j][i]
	if v > umbral:
	print 'Posible centro en (%d, %d). ' % (j, i)
	imagen[i,j]=(123,123,123)
	centro.append((j,i))
	draw = ImageDraw.Draw(ima1)
	ancho,alto = imag.size
	print 'centros',centro
	raw_input()
	#r=0
	for cir in range(len(centro)):
	a = centro[cir][0]
	b = centro[cir][1]
	# if r!=0:
	color = (255,random.randint(200,255), random.randint(0,200))
	draw.ellipse((a-radio, b-radio,a+radio,b+radio), fill=None, outline=color)
	#radio+=2
	draw.ellipse((a-2,b-2,a+2,b+2),fill="green")
	draw.text(((a+2,b+2)), str(cir),fill="red")
	print "ID %s"%cir
	# r+=1
	#m+=1
	print frec
	ni = 'eeeeeeeeeeeeeeee.png'
	imag.save(ni)
	return ni

view raw s.py hosted with ❤ by GitHub

Laboratorio 5

En esta entrada tenemos que poner un listado de proveedores de HW y SW para las personas que quieren implementar sistemas inteligentes, en que se especializan como se pueden comprar los productos y la lista de productos que tienen.

Primero que nada empezaremos con las tiendas que se encuentran en el are en la que vivimos:

La tienda cuenta con muchos productos, los cuales se caracteriza más por vender lo que es la tarjeta arduino, aunque también contamos con muchos otros componentes como:

Microcontroladores

Led

Displays 

Programador para AVR

Modulo Bluetooth

Encontramos muchas mas cosas, las cuales podemos ver con más tranquilidad en su pagina que es: http://www.5hz-electronica.com/

Cuenta con dos tipos de compra:

-Ir directo a la tienda venden las cosas al momento

-Cuenta con un carrito de compra

Lo malo de esta tienda es que solo existe una aquí en monterrey.

Es la tienda a la que asistimos mas común mente, ya que encontramos más locales de ella y uno cerca de nuestra casa. 

También cuenta con una variedad pero no muy grande entre los productos que vende están:

-Led

-Cable para conexiones

-Productos ya completos solo para armar como el brazo mecánico

Para adquirir los productos podemos ir a cualquier local de steren y comprarlo, al igual que también cuenta con un carrito de compra.

Pagina oficial: http://www.steren.com.mx/

AG Electrónica

Esta tienda no la encontramos aquí en Nuevo León y para pedir los productos necesitamos pedirlos, primero  nos registramos y después lo agregamos al carrito de compras. También podemos adquirirlos directamente en la tienda.

En la tienda se encuentra mucha variedad de productos como:
-Sensores
-Arduino
-Pantallas de led´s

Para más información: http://www.agelectronica.com/

Visión Computacional: Detección de Circulos

En esta entrada realizaremos lo que es la detección de circulos.

Los circulos seran del mismo radio el cual se dara como argumento desde la terminal.

Para poder encontrar los circulos primero necesitamos encontrar lo que son los centros de cada uno de ellos y esto lo encontramos teniendo xc, yx.

Para poder calcularlos debemos de tener cosas que se realizaron en las entradas anteriores como lo que es convolución ya que necesitamos lo que es obtener la magnitud del gradiente.

Primero calculamos lo que la magnitud:

Después obtenemos lo siguiente:

Teniendo lo anterior calculamos:

Recuerden que r es el radio que le damos al correr el programa, teniendo ya todo lo anterior se calcula el posible centro de un circulo.

Lo primero que intente fue poner los centros y realmente no los sacaba bien:

Los centros lo puse que me los marcara de color rojo pero en este caso en vez de detectarme 6 centros solo me detecto 3 y fuera del rango donde deberian de estar.

Después trate de agregarle lo demas y el codigo ya no me jalo :(, no logre terminarlo

Código:

	from Tkinter import *
	import Image, ImageTk
	from sys import argv
	from time import *
	import numpy
	from math import floor, fabs
	import math
	class Aplicacion(Frame):
	def __init__(self,parent):
	Frame.__init__(self,parent)
	self.parent = parent
	self.initUI()
	def initUI(self):
	self.parent.title('Ventana')
	self.pack(fill=BOTH, expand=1)
	self.o_imagen=argv[1]
	imagen = self.obtener_imagen()
	self.cargar_imagen(imagen)
	self.conv = Button(text='Convolucion', command =self.boton_convolucion).pack(side=LEFT)
	self.conv = Button(text='Circulos', command =self.boton_circulos).pack(side=LEFT)
	def boton_convolucion(self):
	image = self.filtro()
	ima=image.save('filtrada.jpg')
	img2 = self.mascara(image)
	id = img2.save('mascara.png')
	# img=self.normalizar(img)
	#img2 = img.save('normalizada.png')
	#img = self.binarizar(img)
	#im=img.save('binarizada.png')
	img = self.cargar_imagen(img2)
	print 'sale de vonvolucion'
	return img2
	def boton_circulos(self):
	image=Image.open(self.o_imagen)
	self.radio=int(argv[3])
	img=self.boton_convolucion() #self.conv
	image=self.circulos(img)
	def circulos(self,img):
	print 'entra circulos'
	ancho,alto=img.size
	votos=numpy.empty((ancho, alto))
	pixels=img.load()
	for i in range(ancho):
	y=ancho/2-i
	for j in range(alto):
	x = j-alto/2
	p=self.mxy[i,j]
	if fabs(p) > 0:
	costheta=(float(self.gx[i,j]/p))
	sentheta=(float(self.gy[i,j]/p))
	# print type(self.radio)
	#raw_input()
	xc = int(round(x - self.radio * costheta))
	yc = int(round(y - self.radio * sentheta))
	xcm=xc+alto/2
	ycm = ancho/2-yc
	if xcm >= 0 and xcm < alto and ycm >= 0 and ycm < ancho:
	votos[xc][yc] += 1
	votos=self.votes(ancho,alto,votos)
	maximo = 0
	suma = 0.0
	for x in xrange(ancho):
	for y in xrange(alto):
	v = votos[x][y]
	suma += v
	if v > maximo:
	maximo = v
	promedio = suma / (ancho * alto)
	umbral = (maximo + promedio) / 2.0
	coordenadas = []
	for x in xrange(ancho):
	for y in xrange(alto):
	v = votos[x][y]
	if v > umbral:
	coordenadass.append((x,y))
	draw = ImageDraw.Draw(img)
	colores=[]
	c=0
	for o,p in coordenadas:
	pixels[o,p]=(0,255,0)
	draw.text((o,p), '%s'%s(c+1),(0,0,0))
	rg=random.randint(0,255)
	c +=1
	draw.ellipse((o-self.radio,p-self.radio,o+self.radio,p+self.radio),outline=(rg,rg,0))
	img.save('eeeeeeeeeeeeeeeeeeeee.png')
	print 'sale circulos'
	return
	def votes(self,ancho,alto,votos):
	dim = max(ancho, alto)
	for rango in range(1,int(round(dim*0.1))):
	agregado = True
	while agregado:
	agregado=False
	for y in range(ancho):
	for x in range(alto):
	v = votos[y][x]
	if v>0:
	for dx in range(-rango,rango):
	for dy in range(-rango,rango):
	if y+dy >=0 and y+dy<ancho and x + dx >= 0 and x + dx < alto:
	w = votos[y+dy][x+dx]
	if w>0:
	if v - rango >= w:
	votos[y][x]=v+w
	votos[y+dy][x+dx]=0
	agregado = True
	return votos
	def filtro(self):
	inicio = time()
	image = self.escala_grises()
	pixels = image.load()
	ancho, alto =image.size
	lista = [-1,0,1]
	for i in range(ancho):
	for j in range(alto):
	promedio = self.vecindad(i,j,lista,self.matriz)
	pixels[i,j] = (promedio,promedio,promedio)
	fin = time()
	tiempo_t = fin - inicio
	print "Tiempo que tardo en ejecutarse filtro = "+str(tiempo_t)+" segundos"
	return image
	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
	print "Tiempo que tardo en ejecutarse escala de grises = "+str(tiempo_t)+" segundos"
	df = image.save('escala.png')
	return image
	def vecindad(self,i,j,lista,matriz):
	promedio = 0
	indice = 0
	for x in lista:
	for y in lista:
	a = i+x
	b = j+y
	try:
	if self.matriz[a,b] and (x!=a and y!=b):
	promedio += self.matriz[a,b]
	indice +=1
	except IndexError:
	pass
	try:
	promedio=int(promedio/indice)
	return promedio
	except ZeroDivisionError:
	return 0
	def mascara(self,image):
	inicio = time()
	#Mascara Sobel
	sobelx = ([-1,0,1],[-2,0,2],[-1,0,1]) #gradiente horizontal
	sobely = ([1,2,1],[0,0,0],[-1,-2,-1]) # gradiente vertical
	img=self.convolucion(sobelx,sobely,image)
	fin=time()
	tiempo_t = fin - inicio
	print "Tiempo que tardo en ejecutarse convolucion = "+str(tiempo_t)+" segundos"
	return img
	def convolucion(self,h1,h2,image):
	pixels = image.load()
	ancho,alto = image.size
	#Parte circulo
	self.gx=numpy.empty((ancho, alto))
	self.gy=numpy.empty((ancho, alto))
	self.mxy=numpy.empty((ancho, alto))
	self.votos=numpy.empty((ancho, alto))
	print 'votos',self.votos
	#FIn Parte Circulo
	for e in range(ancho):
	for t in range(alto):
	self.votos[e,t]=0
	a=len(h1[0])
	self.conv = numpy.empty((ancho, alto))
	#self.
	self.minimo = 255
	self.maximo = 0
	for x in range(ancho):
	for y in range(alto):
	#self.votos[x,y]=0
	sumax = 0.0
	sumay = 0.0
	for i in range(a):
	for j in range(a):
	try:
	sumax +=(pixels[x+i,y+j][0]*h1[i][j])
	sumay +=(pixels[x+i,y+j][0]*h2[i][j])
	except:
	pass
	gradiente = math.sqrt(pow(sumax,2)+pow(sumay,2))
	self.conv[x,y]=gradiente
	gradiente = int(gradiente)
	pixels[x,y] = (gradiente,gradiente,gradiente)
	p = gradiente
	self.gx[x,y]=sumax
	self.gy[x,y]=sumay
	self.mxy[x,y]=p
	if p < self.minimo:
	self.minimo = p
	if p > self.maximo:
	self.maximo = p
	print 'botos',self.votos
	#print 'datos',self.datos
	return image
	main()

view raw s.py hosted with ❤ by GitHub