SOLUCIÓN RETO III: HACER MÁS FIABLE EL RECONOCIMIENTO DE LA PELOTA

Muy buenas a todos,  ya he conseguido hacer más robusto el algoritmo, para ello, reconocemos el color amarillo de la imagen y la segmentamos.

Para encontrar el color amarillo, nos hemos basado en el espacio de color HSV, del ingles Hue, Saturation, Value -Tonalidad, Saturación, Valor.  

La tonalidad nos representa el tipo del color, por ejemplo el rojo es 0, el verde 120.

La saturación representa la pureza del color, contra menos es su valor menos tonalidad de gris tendrá.

El valor del color es el brillo.

El algoritmo que nos queda es el siguiente:  Primero pasamos la imagen al espacio HSV, después buscamos los puntos donde tenemos el color de nuestra pelota y en una imagen creada en blanco y negro vamos poniendo valor blanco para los puntos de nuestra pelota y valor negro para el resto.  Después dibujamos nuestro circulo donde tenemos la pelota, para esto he utilizado el algoritmo de hough, aunque lo podríamos haber hecho de muchas maneras, esta ya la tenia hecha. 

El código es el siguiente

#include <cv.h>
#include <highgui.h>
#include <math.h>

void main()
{

    cvNamedWindow("Reco Pelota HSV",CV_WINDOW_AUTOSIZE);  //Creamos una ventana
    cvNamedWindow("Reco Pelota RGB",CV_WINDOW_AUTOSIZE);
    cvNamedWindow("Reco Pelota Binearizada",CV_WINDOW_AUTOSIZE);
    cvNamedWindow("Reco Pelota Segmentada",CV_WINDOW_AUTOSIZE);

    CvCapture* capture= cvCreateCameraCapture(0);    //Capturamos la cámara
    assert( capture != NULL ); 
    IplImage* frame;
    IplImage* frameBN;
    IplImage* frameHSV;
    IplImage* frameSeg;


    int height , width , step , channels , k = 1;
    int step_bn , channels_bn;
    int step_fra , channels_fra;
    int step_seg , channels_seg;
    uchar *data_hsv , *data_bn, *data, *data_seg;
    int i,j;

    int percent=200;
    CvSeq* results;
    bool Primera= true;

    int hlower =95;
    int hupper =105;
    int Saturation=0;
    int Brightness=0;


    int Dilate = 10;
    int Erode = 5;

   
    while(1)
    {
        frame=cvQueryFrame(capture);  //Capturamos la primera imagen
        if(!frame) break;  //Si no hay frame salimos
        if (Primera)
        {
            //Creamos la imagen
            frameHSV = cvCreateImage( cvGetSize(frame), IPL_DEPTH_8U, 3 );
            frameBN = cvCreateImage( cvGetSize(frame), IPL_DEPTH_8U, 1 );
            frameSeg=cvCreateImage( cvGetSize(frame), IPL_DEPTH_8U, 3 );

            // Obtenemos atributos de la imagen HSV
            height= frameHSV->height;
            width= frameHSV->width;
            step= frameHSV->widthStep/sizeof(uchar);
            channels   = frameHSV->nChannels;

            step_bn   = frameBN->widthStep/sizeof(uchar);
            channels_bn = frameBN->nChannels;

            step_fra   = frame->widthStep/sizeof(uchar);
            channels_fra = frame->nChannels;

            step_seg   = frameSeg->widthStep/sizeof(uchar);
            channels_seg = frameSeg->nChannels;
   
            //Creamos el lugar donde se almacenaran los circulos en el algoritmo de hough
            CvMemStorage* storage = cvCreateMemStorage(0);

            Primera=false;
        }
        cvCvtColor(frame,frameHSV,CV_RGB2HSV);
       
        // Obtenemos los valores RGB de la Imagen
        data_hsv = (uchar *)frameHSV->imageData;
        data_bn = (uchar *)frameBN->imageData;
        data = (uchar *)frame->imageData;
        data_seg=(uchar *)frameSeg->imageData;

        // Recorremos la imagen
        for(i = 0; i <height; i++ ) {
          for(j = 0; j <width; j++ ) {

                if (((data_hsv[i*step+j*channels])>= hlower)&& ((data_hsv[i*step+j*channels]) <= hupper)){
                    if (data_hsv[i*step+j*channels+1]>= Saturation) {
                        if (data_hsv[i*step+j*channels+2]>= Brightness) {
                            // Coloreamos el pixel en blanco
                            data_bn[i*step_bn+j*channels_bn] =255;

                            data_seg[i*step_seg+j*channels_seg] = data[i*step_fra+j*channels_fra] ;
                             data_seg[i*step_seg+j*channels_seg+1] = data[i*step_fra+j*channels_fra+1];
                            data_seg[i*step_seg+j*channels_seg+2] = data[i*step_fra+j*channels_fra+2];

                        }
                        else
                        {
                            // Coloreamos el pixel en negro
                             data_bn[i*step_bn+j*channels_bn] = 0;
                           
                             data_seg[i*step_seg+j*channels_seg] = 0;
                             data_seg[i*step_seg+j*channels_seg+1] = 0;
                             data_seg[i*step_seg+j*channels_seg+2] = 0;


                        }
                    }
                    else{
                        // Coloreamos el pixel en negro
                        data_bn[i*step_bn+j*channels_bn] = 0;

                          data_seg[i*step_seg+j*channels_seg] = 0;
                        data_seg[i*step_seg+j*channels_seg+1] = 0;
                        data_seg[i*step_seg+j*channels_seg+2] = 0;

                    }
                }
                else{
                    // Coloreamos el pixel en negro
                     data_bn[i*step_bn+j*channels_bn] = 0;

                     data_seg[i*step_seg+j*channels_seg] = 0;
                     data_seg[i*step_seg+j*channels_seg+1] = 0;
                     data_seg[i*step_seg+j*channels_seg+2] = 0;
                }
          }
        }
        // Erocionar y Dilatar , para la eliminacion de pixeles perdidos
        cvErode(frameBN,frameBN,0,Erode);
        cvDilate( frameBN,frameBN,0,Dilate);

        cvErode(frameSeg,frameSeg,0,Erode);
        cvDilate( frameSeg,frameSeg,0,Dilate);



       

        //Suavizamos la imagen
        //cvSmooth(frameBN, frameBN, CV_GAUSSIAN, 5, 5 );
        //Aplicamos el algoritmo de Hough para circulos
        results = cvHoughCircles(
            frameBN,        //Imagen en escala de grises, no hace falta aplicar ni canny ni sobel ya que lo invoca la función
            storage,            //El lugar donde almacena circulos
            CV_HOUGH_GRADIENT,    //El metodo
            1,                    //Resolución del acumulador
            frameBN->width/10,    //Mínima distancia entre dos circulos
            12,                //Umbral del algoritmo canny
            12,                //Acumulador del umbral
            1,                //Minimo radio
            300                    //Máximo radio
            );
        //Dibujamos las circunferencias de color rojo en la imagen en color
        for( int i = 0; i < results->total; i++ ) {
            float* p = (float*) cvGetSeqElem( results, i );
            CvPoint pt = cvPoint( cvRound( p[0] ), cvRound( p[1] ) );
            cvCircle(
                frame,
                pt,
                cvRound( p[2] ),
                CV_RGB(0xff,0x00,0x00),
                2);
            }
       

        cvShowImage("Reco Pelota HSV",frameHSV);
        cvShowImage("Reco Pelota RGB",frame);
        cvShowImage("Reco Pelota Binearizada",frameBN);
        cvShowImage("Reco Pelota Segmentada",frameSeg);

        char c = cvWaitKey(33);
        if(c==27) break;
    }
    cvReleaseCapture(&capture);
    cvDestroyWindow("Reco Pelota HSV");
    cvDestroyWindow("Reco Pelota RGB");
    cvDestroyWindow("Reco Pelota Binearizada");
    cvDestroyWindow("Reco Pelota Segmentada");


}

Los vídeos que dejo son: Pelota binearizada

Pelota en el espacio HSV

Pelota segmentada

Pelota localizada