miércoles, 22 de mayo de 2013

Laboratorio - Puntos extras: Wavelets

Esta entrada es para puntos extras, sobre Wavelets, y a continuación una explicación:

Herramientas:

Primero que nada, instale el modulo:
  • PyWavelets 0.2.2 (Enlace para descargar el modulo: Aquí)
    • Descargue: "PyWavelets-0.2.2.win32-py2.7"
  • Se necesita tener instalado Numpy
Utilice imágenes con extensión JPG.

Funcionamiento:

Lo que consiste en su funcionamiento, es que se mezcla la textura de una imagen con otra, y nos da como salida la imagen mezclada en una sola, es bastante interesante y algo llamativo, aquí un diagrama del funcionamiento:


Resultados:

Imágenes de pruebas 1:
Imagen A
Imagen B

Salida:

Imágenes de pruebas 2:
Imagen A
Imagen B

Salida:

Imágenes de pruebas 3:
Imagen A
Imagen B

Salida:

En las imágenes de salida, se muestran las dos imágenes en una sola combinación , cabe mencionar que utilice una sola imagen como "imagen A" que es un fondo.

Código:


Pruebas:

Ejecucion:

Para ejecutar el programa, se realiza de la siguiente manera:

python "programa".py -b "imagen_A".jpg -t "imagen_B".jpg -w "filtro_wavelet" -l "nivel" -m "descomponer"

Tiempos:

Realice unas pequeñas pruebas calculando el promedio de tiempo del funcionamiento del programa, los resultados fueron los siguientes:

Tiempo con imágenes 1:

Tiempo con imágenes 2:

Tiempo con imágenes 3:

Promedio:

2.241 segundos

Comentarios:

El proceso fue rápido, solo tomaba algo de tiempo si se utilizaban imágenes con dimensiones superiores a 1000 x 700, así que tome imágenes con dimensiones menores.

Repositorio:
Referencias:

jueves, 16 de mayo de 2013

Laboratorio - Entrega 10: Detección de movimiento

Para esta semana, se encargo detección de movimiento, y el cual explicare algunos detalles de este trabajo:

Primero que nada, para esta tarea utilice las siguientes herramientas:
  • Opencv: Habilitando camara web
  • PIL: Leer frames
  • Numpy: Realizo los cálculos de imágenes
Utilice la cámara web que viene instalada en mi laptop y use capturas con una resolución de 160 x 120.

Detectando movimiento

Para la detección de movimiento detectaron los cambios de movimiento en 2 frames, se binariza, se calcula la diferencia de su posición entre esos 2 frames y se aplica Gasussian Blur para eliminar ruido.
Se obtienen dos imágenes, un donde hubo movimiento y otra en donde no hubo, se busca el borde y después se crea una rejilla, que se modifica según sea la resolución del vídeo, que en este caso el vídeo es de 160 x 120 y mas o menos queda así:

Una rejilla de 10 x 8:


Y cuando se detecta el movimiento, se dibuja un triángulo de color, donde indica que hubo movimiento.

Y ahora ejemplos donde muestro vídeos y que se detecta movimiento:

Ejemplos:

Vídeo 1:
video

Vídeo 2:
video

Vídeo 3:
video

Vídeo 4:
video

Comentarios:

En esta parte seria bueno calibrar bien la detección, ya que con demasiado ruido se llega a detectar movimiento innecesario.

Dirección:

Una pequeña captura donde se detecta el movimiento:

Se muestra si fue en derecha, izquierda, arriba o abajo.

Aquí el código de lo anterior:

Código:


Animaciones

En esta parte, detecte cada movimiento y lo pase a un frame que se dibuja como un cuadrado (Color negro), así generando casa frame en imágenes y guardándolas en una carpeta, si se sigue una secuencia de cada imagen, se mostrara los frames de manera continua.

Aquí un pequeño vídeo:
video

Muy simple la verdad, utilice el teclado para ir viendo la imagen una por una.

Código de lo anterior: 

Código:


Pruebas

En esta parte, realice pruebas con vídeos con resoluciones de 160 x 120 y de formato avi, eso realizaba el proceso mucho mas rápido.

Errores

Utilizaba vídeos con resolución de 640 x 480, pero por alguna razón el programa dejaba de funcionar y la terminal de igual manera, dejaba de funcionar, entonces la solución fue grabar vídeos de 160 x 120 y así el programa funcionaba, no al 100% pero al menos se detectaba el movimiento y el programa funcionaba

Tamaño de vídeos:

Conclusiones: 
  • Tomar en cuenta el formato a grabar
  • Captar vídeos con una resolución de 160 x 120

Aquí el repositorio:

Repositorio:

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

jueves, 9 de mayo de 2013

Laboratorio - Actividad 9: Detección de esquinas

Para esta semana, se encargo la detección de esquinas.

El programa debe hacer lo siguiente:
  • Parte básica: detectar las esquinas con el método de diferencia de filtro mediano.
  • Parte avanzada: Teniendo las esquinas, podemos sacar un “wire-frame” al borde.
    • Uniendo las esquinas con segmentos de líneas rectas (u otras curvas estimadas desde las partes de borde cubiertas).
    • Recorriendo en un orden que sigue el borde (que habría que detectarse aparte con las técnicas ya conocidas) para saber en qué orden conectar las esquinas. 

Me base en tareas de mis compañeros, para realizar la tarea, ya que batalle algo en el código

Imágenes:

Y el código es el siguiente:

Código:

Procedimiento:

Aplicando filtro mediano:

Ahora, detectamos las esquinas:

Y los resultados son los siguientes:

Resultados:


Ya detectadas las esquinas, se trazan las lineas de esquina a esquina con su respectivo color.

Repositorio:

jueves, 2 de mayo de 2013

Laboratorio - Actividad 8: Polígonos

Para esta semana, se encargo el detectar polígonos, darle una etiquetas y un color aleatorio.

El programa debe de tener lo siguiente:
  • Identificar, clasificar y etiquetar cada polígono.
  • Calcular su tamaño y rellenarlo con color aleatorio.

Imágenes


Y el código es el siguiente:

Código:
Y los resultados son los siguientes:

Resultados:

Para esta entrada utilice como base la tarea sobre detección de lineas.

Como primera prueba fue la de detectar las lineas de las figuras, la cual nos dio como resultado la siguiente imagen:

Imagen 1: 
Imagen 2: 
Imagen 3:

Y ... ya ...

Me falto agregar mas filtros, pero no alcance a terminar. 

:(

Repositorio: