Lanzando partículas

Poco a poco voy haciendo un acercamiento al filtro de partículas para poder seguir los dedos.

Para ello el primer paso es generar partículas de forma aleatoria sobre una imagen. Las partículas, son los rectángulos que había creado antes, de la clase Rectángulo.

Lanzando un número suficiente de partículas se cubre la imagen que queremos.



Una vez lanzadas las partículas por toda la imagen, lo que interesa son las partículas que estén sobre la parte que nos interesa. Para seleccionar la parte que nos interesa usamos el umbralizado para el rojo como ya he puesto en una entrada anterior.

Una vez que tengo la imagen umbralizada lo que hago es trabajar con ella con las partículas. La forma de seleccionar la que me interesa es añadirle un peso a cada partícula, es decir, el peso en este caso es la cantidad de píxeles que me interesan están dentro de esa partícula. De ésta forma se puede ver cómo seleccionamos las partículas que nos interesan, en la imagen a continuación vemos que en amarillo están las de interés y en azul las que no.



Para que se observe mejor solo pintaré en la imagen las partículas que me interesan.



Una vez conseguido esto, voy a por el siguiente paso del filtro de partículas.

Simulando movimiento

Para poder seguir el movimiento de mis dedos por la pantalla necesito poder hacer que los rectángulos o partículas se muevan de forma aleatoria desde un punto en el que estén inicialmente una distancia que yo elija, me he creado en la clase rectángulo una función dispersar, a la que se le pasa el movimiento que se quiere conseguir.

void dispersar(int mov);


Para probar esta función me creo una partícula y hago que se disperse con diferentes valores, teniendo como resultado esto:

Clase Mano

Ahora he hecho una nueva clase, que contiene varios objetos de la clase anterior, así que para manejarlo me he creado las diferentes funciones:


void setRectangulo(Rectangulo r);
void restarRectangulo();

CvPoint posicionRectangulo (int id);
IplImage* dibujaRectangulo(IplImage* img);


Las funciones lo que hacen es añadir rectángulos en mi clase (hasta un límite de cuatro), también puede quitar uno que se haya añadido antes, la posición de un determinado rectángulo y por último dibujar todos los rectángulos.

Clase rectángulo

Para poder tener todo un poco más ordenado me he creado una clase rectángulo.

Mis rectángulos se definen por la esquina de arriba a la izquierda, la esquina de abajo a la derecha, el color y un identificador.
Al crear un rectángulo se le pasan la posición de las esquinas, y el color y el identificador son opcionales, pudiendo ponerlos en otro momento. Las funciones para manejar estos atributos son las siguientes:

void setID(int i);
void setColor(CvScalar c);

CvPoint getEsquinaIA();
CvPoint getEsquinaDB();
CvScalar getColor();
int getID();



Después, como habrá que dibujar los rectángulos también me he puesto una función para que los dibuje:

IplImage* dibujar(IplImage* img);


Y por último, unas funciones para que me digan la posición del rectángulo (el punto central), la altura y la anchura del mismo:

CvPoint damePosicion ();
int dameAlto();
int dameAncho();


Para ver que funcionaba me he puesto a probar las diferentes funcionalidades en una foto, haciendo dos rectángulos.

Difuminando y eliminando ruido

He descubierto la función cvSmooth, con la que puedo aplicar diferentes tipos de transformaciones en la imagen, como estudié visión hace ya tiempo y me sonaba que el filtro gaussiano lo que hacía era difuminar la imagen y eliminar así el ruido he probado a ver que pasaba.




Como se puede ver, mi gozo en un pozo, porque la idea era que difuminando un poco la imagen pudiera eliminar el ruido, pero con esto no lo elimino, sino que hago que intente pasar desapercibido, que si mi aplicación tuviera un poco de miopía daría el pego, pero creo que no es el caso (aun lo estoy estudiando).


Así que he experimentado un poco más dentro de esa función y he encontrado el filtro "Median blur", que aplicado a mi imagen consigo esto:




¡Tachán! Es más parecido a lo que ando buscando, aunque hay ciertos puntos de ruidos que no elimina (nada es perfecto, por ahora).

Es un buen resultado el obtenido, pero como siempre se quiere más, ahora voy a ponerme a descubrir cómo era eso de disminuir y dilatar los píxeles, que tengo el presentimiento de que eso es lo que estoy buscando.

Añadiendo ruido

Usando la imagen que he obtenido antes de elegir el rojo le he añadido de forma aleatoria puntos con ruido.





Ahora lo que tengo que hacer es usar funciones de opencv para poder quitar ese ruido.

Umbralizando

Después de estar trasteando con ciertas funciones, ahora lo que quiero hacer es seleccionar de una imagen un color determinado, para poder luego trabajar con ello.
El color elegido al azar entre los tres colores importantes es el rojo, así que con una imagen sencilla en la que hay círculos me quedo con los rojos que son los más molones. El resultado es el siguiente:




Como se puede observar ha sido una elección óptima, pero claro, el mundo no es perfecto para estas cosas, así que ahora me dedicaré a meter ruido en la imagen para que sea un poco más real.