En el artículo anterior vimos como, teniendo un conjunto de colores, hallar la distancia mínima entre ellos, lo que nos sirve para calcular posteriormente un umbral aceptable que nos sirve para distinguir distintos colores por su RGB. En este artículo vamos a aplicar estos conocimientos a un programa que sea capaz de detectar varias piezas de diferentes colores, algunos de ellos muy parecidos. Si fueramos capaces de distinguir una pieza de determinado color entre piezas de más de diez colores distintos sería una gran hazaña, pues significaría que el programa tendría muchas aplicaciones.

Búsqueda del valor umbral:

Antes que nada necesitamos especificar el valor umbral que determina si un píxel pertenece a una pieza de un color u otro. Partimos de la distancia mínima entre dos colores, sabiendo que ésta se ha calculado como la distancia entre dos puntos en tres dimensiones. La pregunta es ¿cuánto podríamos aumentar o disminuir los valores base de RGB de un color para que no se acerque demasiado a otro color?.

Si cogemos de nuevo la formula de la distancia entre dos puntos en las tres dimensiones la podemos invertir, para calcular la relación entre el valor umbral que queremos hallar y la distancia que ya tenemos. En el programa que pondré después podréis ver la formula para calcular dicho umbral.

Una vez tengamos ese umbral lo usaremos para calcular si un píxel con determinado RGB pertenece o no a alguno de los colores que tenemos. Para que pertenezca tiene que cumplir las siguientes condiciones:

• Que el valor de R del píxel menos el umbral sea menor que el valor de R de nuestro color.
• Que el valor de R del píxel más el umbral sea mayor que el valor de R de nuestro color.
• Que el valor de G del píxel menos el umbral sea menor que el valor de G de nuestro color.
• Que el valor de G del píxel más el umbral sea mayor que el valor de G de nuestro color.
• Que el valor de B del píxel menos el umbral sea menor que el valor de B de nuestro color.
• Que el valor de B del píxel más el umbral sea mayor que el valor de B de nuestro color.

Si las cumple podremos decir que dicho píxel pertenece a nuestro color. Del mismo modo, si tenemos diez colores, por ejemplo, habrá que hacer las comprobaciones con los diez colores, hasta que coincida con alguno o no haya más colores con los que comparar.

Programa en OpenCV:

En este programa vamos a utilizar las clases implementadas en el artículo anterior, solo que modificadas y mejoradas, con una funcionalidad mayor. Así las podremos usar dentro de nuestro programa de reconocimiento de colores y nos quedará todo mucho más ordenado. En este programa se hace uso de clases, por eso os recomiendo que leáis el primer artículo de la serie LeJOS, que habla de la programación orientada a objetos. Vamos a partir de la siguiente imagen, donde podéis observar catorce piezas de distintos colores:

La calidad de la imagen es bastante buena en este caso, ¿pero serán los colores suficientemente parecidos a los originales como para poder identificarlos?.

Color.h
//=============================================================
// Nombre : Color.h
// Autor : Álvaro Peláez Santana
// Version : 1.2
// Copyright : www.electricbricks.com
// Descripción : Clase color
//=============================================================

class Color {
private:
string nombre;
int rojo, verde, azul;
int cont;
int x_total;
int y_total;
public:
void SetRGB(int R, int G, int B, string nm);
int Rojo();
int Verde();
int Azul();
string Nombre();
float Distancia(Color color);
void ActualizarPixel(int x, int y);
void PuntoMedio(uchar *data, int anchura_fila, int canales);
};

Se le han añadido datos como el nombre del color, o las variables que usaremos para el cálculo del punto medio de ese color, así como la función para calcularlo. Como estamos hablando de clases, los valores de R, G y B, así como el nombre y demás serán los atributos de la clase, mientras que las funciones son sus métodos.

Color.cpp
//=============================================================
// Nombre : Color.cpp
// Autor : Álvaro Peláez Santana
// Version : 1.2
// Copyright : www.electricbricks.com
// Descripción : Clase color
//=============================================================

void Color::PuntoMedio(uchar *data, int anchura_fila, int canales){
if (cont == 0){
cout << "Pieza color " << nombre << " no encontradan"; }else{ int x_medio = x_total / cont; int y_medio = y_total / cont; cout << "Punto medio de la pieza color " << nombre << " en " << x_medio << " " << y_medio << "n"; for(int i = y_medio - 5; i <= y_medio + 5; i++) for (int j = x_medio - 5; j <= x_medio + 5; j++){ data[i*anchura_fila+j*canales + 2] = rojo; data[i*anchura_fila+j*canales + 1] = verde; data[i*anchura_fila+j*canales + 0] = azul; } } }

Una pequeña explicación de lo que hacen las funciones (o mejor dicho métodos):

14 - Con este método inicializamos los valores de los atributos de nuestro objeto de la clase color, como sus valores RGB, o su nombre.

24, 28, 32 y 36 - Estos métodos sirven para devolver el valor de los atributos del objeto. Si por ejemplo necesitamos saber el valor R de nuestro color lila no tendremos más que llamar a lila.Rojo().

40 - Haya la distancia entre dos colores como la distancia entre dos puntos en las tres dimensiones.

47 - Tenemos que utilizar está función cada vez que encontremos un píxel en la imagen que corresponda con nuestro color.

53 - Halla el punto medio del objeto de determinado color en una imagen, y lo dibuja como un cuadrado de 5x5.

ListaColores.h
//=============================================================
// Nombre : ListaColores.h
// Autor : Álvaro Peláez Santana
// Version : 1.3
// Copyright : www.electricbricks.com
// Descripción : Clase ListaColores
//=============================================================

public:
void NumColores(int num);
void AnadirColor(Color color1);
float DistanciaMinima();
void ComprobarColor(int R, int G, int B, int umbral, int x, int y);
void PuntosMedios(uchar *data, int anchura_fila, int canales);
};

Los nuevos métodos son ComprobarColor y PuntosMedios.

ListaColores.cpp
//=============================================================
// Nombre : ListaColores.cpp
// Autor : Álvaro Peláez Santana
// Version : 1.3
// Copyright : www.electricbricks.com
// Descripción : Clase ListaColores
//=============================================================

void ListaColores::AnadirColor(Color color1){
if (colores_act < num_colores){ colores[colores_act] = color1; colores_act++; } } float ListaColores::DistanciaMinima(){ float min = 4000; int id_col1, id_col2; for(int i = 0; i < num_colores; i++){ for(int j = i + 1; j < num_colores; j++){ if (colores[i].Distancia(colores[j]) < min){ min = colores[i].Distancia(colores[j]);; id_col1 = i; id_col2 = j; } } } cout << "La distancia mínima es de: " << min << " entre el color " << colores[id_col1].Nombre() << " y el color " << colores[id_col2].Nombre() << "n"; return min; } void ListaColores::ComprobarColor(int R, int G, int B, int umbral, int x, int y){ int rojo, azul, verde; for(int i = 0; i < num_colores; i++){ rojo = colores[i].Rojo(); azul = colores[i].Azul(); verde = colores[i].Verde(); if((((R - umbral) < rojo) && (rojo < (R + umbral))) && (((G - umbral) < verde) && (verde < (G + umbral))) && (((B - umbral) < azul) && (azul < (B + umbral)))){ colores[i].ActualizarPixel(x,y); break; } } } void ListaColores::PuntosMedios(uchar *data, int anchura_fila, int canales){ for(int i = 0; i < num_colores; i++){ colores[i].PuntoMedio(data, anchura_fila, canales); } }

Donde los métodos hacen las siguientes funciones:

13 - Inicializa el número de colores total que vamos a manejar.

18 - Añade un color a nuestra lista de colores.

25 - Calcula la distancia mínima entre todos los colores.

43 - Comprueba si determinado píxel pertenece a alguno de los colores que tenemos en la lista.

58 - Calcula los puntos medios de todos los objetos de cada color.

Y el programa principal queda de la siguiente manera:

DeteccionObjetos.cpp
//=============================================================
// Nombre : DeteccionObjetos.cpp
// Autor : Álvaro Peláez Santana
// Version : 3.0
// Copyright : www.electricbricks.com
// Descripción : Programa principal que calcula los puntos
// medios de objetos de varios colores
//=============================================================