martes, 14 de mayo de 2013

Proyecto - Detección de Monedas

Propósito de Proyecto:

Anteriormente, ya había mostrado mi idea, (Enlace de la presentación inicial del proyecto) donde mencione que para este proyecto el propósito fue detectar monedas, dibujando su contorno con un circulo y mencionando de que valor era cada moneda.

Justificación

Este proyecto puede ser utilizado en diferentes ámbitos o utilizarlo de manera diferente en muchas aplicaciones.
  • Puede ser utilizado por personas aficionadas en coleccionar monedas.
  • Podría ser utilizado por personas aficionadas a objetos.
  • Utilizado por bancos en sistemas de seguridad y detectar los valores de monedas y llevar una seguimiento de monedas y evitar procesos lentos de documentación. 
  • Utilizar esta tipo de proyectos en fabricas para detectar objetos circulares y si existen imperfecciones.
  • Podría ser utilizado en sistemas de seguridad..
  • También podría ser utilizado en sistemas sobre detección de mentiras.
  • En procesos de inspección de calidad de figuras circulares, si su radio es exacto. 


Diseño:

El diagrama de cual es el funcionamiento es el siguiente:

Lo muestra de una manera muy simple, mostrando de manera lineal su funcionamiento.
  1. Abrimos la imagen.
  2. Pasamos a escala de grises.
  3. Quitamos Ruido.
  4. Aplicamos HoughCircles.
  5. Dibujamos Circulo.
  6. Detectamos Valor de Moneda.

Herramientas:

Enseguida una explicación de todo lo utilizado para este proyecto:

Sistema Operativo:
  • Windows 7
Web Cam:
  • Toshiba Web Camera Application

Librerías, lenguajes de programacion, etc.

Lenguaje de programación
Librerías
Otras Herramientas:

Descripción de algoritmo:

En esta ocasión utilice la transformada de "Hough Circles" que se encuentra disponible en Opencv, y que nos facilita mucho el trabajo y así evitar realizar muchas lineas de código, enseguida la explicación:

Solo es una linea de código en python, y es la siguiente:


Una pequeña explicación de los argumentos:
  • src_gray: la imagen de entrada (escala de grises)
  • círcles: Un vector que almacena conjuntos de 3 valores: "x, y, r" para cada círculo detectado.
  • cv.CV_HOUGH_GRADIENT: Definimos el método para la deteccion.
  • dp = 1: La relación inversa de la resolución.
  • min_dist = src_gray.rows / 8: Distancia mínima entre ejes detectados.
  • param_1 = 200: Límite superior para el detector de bordes.
  • param_2 = 100*: Umbral de detección del centro.
  • min_radius = 0: Radio mínimo a detectar. (Se puede poner cero por defecto)
  • max_radius = 0: Radio máximo a ser detectado. (Se puede poner cero por defecto)

Si requieren de algún ejemplo en especifico, entren a este Enlace, en la documentación de opencv viene con una explicación mas amplia.

Evaluación de desempeño:

Fotos de Prueba:

En lo primero que realice pruebas y estuve modificando constantemente fue en detectar los círculos en una imagen, pero primero necesitaba imágenes con monedas reales.

Para este caso realice tomas con un smartphone Samsung galaxy young y su cámara incluida, la cual tenia una resolución de 2 Megapixeles, realice tomas, y los resultados no fueron convenientes, no se detecto el circulo:
Nos daba buen resultado imágenes con demasiado ruido.

Después, realice tomas con un smartphone Nextel Motorola con una resolución de 3.2 Mexapixeles , y los resultados también fueron malos, tampoco se detectaban bien los círculos:
Y finalmente realice las tomas con una cámara semi-profesional con una resolución de 16 Megapixeles, aunque hubo errores como lo siguiente:

Detectaba algunos círculos, no tomaba muy bien su circunferencia, ya sea por mucho ruido o iluminación.

Para arreglar los errores anteriores, realice lo siguiente:
  • Tomar fotos de prueba a una altura de entre 18 a 20 cm.
  • Tener suficiente iluminación para realizar la toma.
  • Por ultimo, realizar las tomas de forma horizontal y con un angulo de 90°. (No soy camarografo profesional, así que trate de realizar las tomas lo mas derechas posibles.)

Aquí un diagrama de lo anterior:

Resolución de Imágenes:

En esta parte, igual batalle mucho, realizaba pruebas con imágenes con un tamaño exagerado, con un promedio de dimensiones de 3000x4000, y para esto, las pruebas eran algo pesadas, y el programa no podía procesarla.

Después utilice imágenes con dimensiones con un promedio de 1000x2000 y de igual manera, eran algo pesadas, aunque el programa daba un tiempo menor,  por ejemplo el tiempo era el siguiente:

Imagen de 2048x1356:

Imagen de 1218x1148:

Finalmente utilice imágenes con dimensiones menores de 640x480 y que por lógica, el proceso seria demasiado rápido, el tiempo casi mínimo  y no habría problemas con la detección del circulo

Imagen de 640x480:

Para resolver este problema, solo era utilizar imágenes con poca dimensión.

Gráficas:

Ahora, gráficas con los tiempos obtenidos de las imágenes utilizadas y mostrare mi conclusión sobre porque utilizar imágenes con poca resolución

Nota*: Utilice 6 imágenes diferentes para cada tamaño (6 imágenes de 2048x1356, 6 imágenes de 1218x1148, 6 imágenes de 640x480), y ejecute el programa con cada imagen, para así mostrar el tiempo y realizar gráficas para mostrar las diferencias entre imágenes con diferentes resoluciones.

Con imágenes de 2048 x 1356:

Total de 6 imágenes y los tiempos en que tardaron en procesar:
  1. 0.2029998
  2. 0.1588887
  3. 0.1400001
  4. 0.1711117
  5. 0.1560001
  6. 0.1400009
Gráfica:
............................................................................................................................................

Con imágenes de 1218 x 1148:

Total de 6 imágenes y los tiempos que tardaron en procesar:
  1. 0.1960005
  2. 0.2120000
  3. 0.1949991
  4. 0.2070000
  5. 0.1800000
  6. 0.1810003
Gráfica:
............................................................................................................................................

Con imágenes de 640 x 480:

Total de 6 imágenes y los tiempos que tardaron en procesar:
  1. 0.0279998
  2. 0.0200000
  3. 0.0188888
  4. 0.0100096
  5. 0.0280000
  6. 0.0200077
Gráfica:
............................................................................................................................................
Comparación de tiempos en una sola gráfica:

Gráfica:
............................................................................................................................................

En cada gráfica se muestra el tiempo que se tardaba en procesar las diferentes imágenes, tomando en cuenta las 6 imágenes que se utilizaron a prueba.

Por lógica se muestra que el tiempo es menor en imágenes de menor resolución.

Conclusión de Gráficas: 
  • En la ultima gráfica, muestra de una manera muy clara que las imágenes con una resolución de 640x480 nos da un tiempo de procesamiento muy bajo.

Tiempo de procesamiento promedio:

Imagen de tamaño 2048x1356:
  • 0.85 segundos

Imagen de tamaño 1218x1148:
  • 1.02 segundos

Imagen de tamaño 640x480:
  • 0.10 segundos

Conclusión:

Para evitar procesos largos en la ejecución del programa, es mejor utilizar imágenes con dimensiones de 640x480, ya que por lógica, procesar imágenes con poca resolución, el tiempo de procesamiento es menor

Trabajo a futuro:

Los siguientes puntos los tomare en cuenta a futuro:
  • En esto proyecto seria bueno utilizar vídeo para detectar las monedas, me quede a medio trabajo pero seria buena idea seguir trabajando sobre el código y mejorarlo.
  • Otra idea que propuse fue la de crear una aplicación móvil, tomando en cuenta que ya existen aplicaciones como por ejemplo detectar caras, seria buena idea trabajar en algún proyecto parecido pero detectando monedas.
  • Otra idea a futuro podría ser el de realizar alguna aplicación sobre sistemas de detección de mentiras, detectando los ojos y sus movimientos y aplicar realidad aumentada.
  • Una idea a futura seria la de crear una aplicación donde se puedan detectar imperfecciones de algún objeto circular o verificar si en realidad es un circulo o no.

Pueden descargar el proyecto completo, con el código completo y las imágenes que utilice de prueba, pueden bajarlo de mi repositorio, el cual es el siguiente:

Repositorio:

Y la presentación final es la siguiente:

Presentación Final:



Y esto es todo, si tienen alguna duda, háganme saber con algún comentario, gracias.

Referencias: 
  1. Docs opencv org - Hough Circle - Ultima modificación: 5/Abril/2013
  2. Stackoverflow - python and opencv how do i detect all filledcircles round objects in an image - Ultima modificación: 14/Mayo/2013
  3. Sathyakumar spark blogspot - circle detection using opencv - Ultima modificación: 8/Octubre/2011
  4. Blog weisu - opencv detect circles with hough - Ultima modificación 21/Diciembre/2007

3 comentarios:

  1. Bastante bien. Trabaja más con el reporte aún y checa que tengas todo en el repositorio. 9 pts.

    ResponderEliminar
  2. El reporte presenta detalles de ortografía; 9 pts.

    El repo está bien, pero se me hace un poco simplificado el programa ya que requiere una posición fija de la cámara. 9 pts por el código.

    ResponderEliminar
  3. muy bueno y que pasa si pones una tapa de el diametro de una moneda?

    ResponderEliminar