BlobResult.cpp

Go to the documentation of this file.

/************************************************************************
                        BlobResult.cpp
                        
FUNCIONALITAT: Implementació de la classe CBlobResult
AUTOR: Inspecta S.L.
MODIFICACIONS (Modificació, Autor, Data):
 
**************************************************************************/

#include <limits.h>
#include <stdio.h>
#include <functional>
#include <algorithm>
#include "hrl_cvblobslib/BlobResult.h"

#ifdef _DEBUG
        #include <afx.h>                        //suport per a CStrings
        #include <afxwin.h>                     //suport per a AfxMessageBox
#endif

/**************************************************************************
                Constructors / Destructors
**************************************************************************/


CBlobResult::CBlobResult()
{
        m_blobs = Blob_vector();
}

CBlobResult::CBlobResult(IplImage *source, IplImage *mask, uchar backgroundColor )
{
        bool success;

        try
        {
                success = ComponentLabeling( source, mask, backgroundColor, m_blobs );
        }
        catch(...)
        {
                success = false;
        }

        if( !success ) throw EXCEPCIO_CALCUL_BLOBS;
}

CBlobResult::CBlobResult( const CBlobResult &source )
{
        m_blobs = Blob_vector( source.GetNumBlobs() );
        
        // creem el nou a partir del passat com a paràmetre
        m_blobs = Blob_vector( source.GetNumBlobs() );
        // copiem els blobs de l'origen a l'actual
        Blob_vector::const_iterator pBlobsSrc = source.m_blobs.begin();
        Blob_vector::iterator pBlobsDst = m_blobs.begin();

        while( pBlobsSrc != source.m_blobs.end() )
        {
                // no podem cridar a l'operador = ja que Blob_vector és un 
                // vector de CBlob*. Per tant, creem un blob nou a partir del
                // blob original
                *pBlobsDst = new CBlob(**pBlobsSrc);
                pBlobsSrc++;
                pBlobsDst++;
        }
}



CBlobResult::~CBlobResult()
{
        ClearBlobs();
}

/**************************************************************************
                Operadors / Operators
**************************************************************************/


CBlobResult& CBlobResult::operator=(const CBlobResult& source)
{
        // si ja són el mateix, no cal fer res
        if (this != &source)
        {
                // alliberem el conjunt de blobs antic
                for( int i = 0; i < GetNumBlobs(); i++ )
                {
                        delete m_blobs[i];
                }
                m_blobs.clear();
                // creem el nou a partir del passat com a paràmetre
                m_blobs = Blob_vector( source.GetNumBlobs() );
                // copiem els blobs de l'origen a l'actual
                Blob_vector::const_iterator pBlobsSrc = source.m_blobs.begin();
                Blob_vector::iterator pBlobsDst = m_blobs.begin();

                while( pBlobsSrc != source.m_blobs.end() )
                {
                        // no podem cridar a l'operador = ja que Blob_vector és un 
                        // vector de CBlob*. Per tant, creem un blob nou a partir del
                        // blob original
                        *pBlobsDst = new CBlob(**pBlobsSrc);
                        pBlobsSrc++;
                        pBlobsDst++;
                }
        }
        return *this;
}


CBlobResult CBlobResult::operator+( const CBlobResult& source ) const
{       
        //creem el resultat a partir dels blobs actuals
        CBlobResult resultat( *this );
        
        // reservem memòria per als nous blobs
        resultat.m_blobs.resize( resultat.GetNumBlobs() + source.GetNumBlobs() );

        // declarem els iterador per recòrrer els blobs d'origen i desti
        Blob_vector::const_iterator pBlobsSrc = source.m_blobs.begin();
        Blob_vector::iterator pBlobsDst = resultat.m_blobs.end();

        // insertem els blobs de l'origen a l'actual
        while( pBlobsSrc != source.m_blobs.end() )
        {
                pBlobsDst--;
                *pBlobsDst = new CBlob(**pBlobsSrc);
                pBlobsSrc++;
        }
        
        return resultat;
}

/**************************************************************************
                Operacions / Operations
**************************************************************************/

void CBlobResult::AddBlob( CBlob *blob )
{
        if( blob != NULL )
                m_blobs.push_back( new CBlob( blob ) );
}


#ifdef MATRIXCV_ACTIU

double_vector CBlobResult::GetResult( funcio_calculBlob *evaluador ) const
{
        if( GetNumBlobs() <= 0 )
        {
                return double_vector();
        }

        // definim el resultat
        double_vector result = double_vector( GetNumBlobs() );
        // i iteradors sobre els blobs i el resultat
        double_vector::iterator itResult = result.GetIterator();
        Blob_vector::const_iterator itBlobs = m_blobs.begin();

        // avaluem la funció en tots els blobs
        while( itBlobs != m_blobs.end() )
        {
                *itResult = (*evaluador)(**itBlobs);
                itBlobs++;
                itResult++;
        }
        return result;
}
#endif

double_stl_vector CBlobResult::GetSTLResult( funcio_calculBlob *evaluador ) const
{
        if( GetNumBlobs() <= 0 )
        {
                return double_stl_vector();
        }

        // definim el resultat
        double_stl_vector result = double_stl_vector( GetNumBlobs() );
        // i iteradors sobre els blobs i el resultat
        double_stl_vector::iterator itResult = result.begin();
        Blob_vector::const_iterator itBlobs = m_blobs.begin();

        // avaluem la funció en tots els blobs
        while( itBlobs != m_blobs.end() )
        {
                *itResult = (*evaluador)(**itBlobs);
                itBlobs++;
                itResult++;
        }
        return result;
}

double CBlobResult::GetNumber( int indexBlob, funcio_calculBlob *evaluador ) const
{
        if( indexBlob < 0 || indexBlob >= GetNumBlobs() )
                RaiseError( EXCEPTION_BLOB_OUT_OF_BOUNDS );
        return (*evaluador)( *m_blobs[indexBlob] );
}


void CBlobResult::Filter(CBlobResult &dst, 
                                                 int filterAction, 
                                                 funcio_calculBlob *evaluador, 
                                                 int condition, 
                                                 double lowLimit, double highLimit /*=0*/) const
                                                        
{
        // do the job
        DoFilter(dst, filterAction, evaluador, condition, lowLimit, highLimit );
}

void CBlobResult::Filter(CBlobResult &dst, 
                                                 int filterAction, 
                                                 funcio_calculBlob *evaluador, 
                                                 int condition, 
                                                 double lowLimit, double highLimit /*=0*/)
                                                        
{
        int numBlobs = GetNumBlobs();

        // do the job
        DoFilter(dst, filterAction, evaluador, condition, lowLimit, highLimit );

        // inline operation: remove previous blobs
        if( &dst == this ) 
        {
                // esborrem els primers blobs ( que són els originals )
                // ja que els tindrem replicats al final si passen el filtre
                Blob_vector::iterator itBlobs = m_blobs.begin();
                for( int i = 0; i < numBlobs; i++ )
                {
                        delete *itBlobs;
                        itBlobs++;
                }
                m_blobs.erase( m_blobs.begin(), itBlobs );
        }
}


void CBlobResult::DoFilter(CBlobResult &dst, int filterAction, funcio_calculBlob *evaluador, 
                                                   int condition, double lowLimit, double highLimit/* = 0*/) const
{
        int i, numBlobs;
        bool resultavaluacio;
        double_stl_vector avaluacioBlobs;
        double_stl_vector::iterator itavaluacioBlobs;

        if( GetNumBlobs() <= 0 ) return;
        if( !evaluador ) return;
        //avaluem els blobs amb la funció pertinent     
        avaluacioBlobs = GetSTLResult(evaluador);
        itavaluacioBlobs = avaluacioBlobs.begin();
        numBlobs = GetNumBlobs();
        switch(condition)
        {
                case B_EQUAL:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio= *itavaluacioBlobs == lowLimit;
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }                               
                        }
                        break;
                case B_NOT_EQUAL:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio = *itavaluacioBlobs != lowLimit;
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
                case B_GREATER:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio= *itavaluacioBlobs > lowLimit;
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
                case B_LESS:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio= *itavaluacioBlobs < lowLimit;
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
                case B_GREATER_OR_EQUAL:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio= *itavaluacioBlobs>= lowLimit;
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
                case B_LESS_OR_EQUAL:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio= *itavaluacioBlobs <= lowLimit;
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
                case B_INSIDE:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio=( *itavaluacioBlobs >= lowLimit) && ( *itavaluacioBlobs <= highLimit); 
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
                case B_OUTSIDE:
                        for(i=0;i<numBlobs;i++, itavaluacioBlobs++)
                        {
                                resultavaluacio=( *itavaluacioBlobs < lowLimit) || ( *itavaluacioBlobs > highLimit); 
                                if( ( resultavaluacio && filterAction == B_INCLUDE ) ||
                                        ( !resultavaluacio && filterAction == B_EXCLUDE ))
                                {
                                        dst.m_blobs.push_back( new CBlob( GetBlob( i ) ));
                                }
                        }
                        break;
        }
}
/*
- FUNCTION: GetBlob
- FUNCTIONALITY: Gets the n-th blob (without ordering the blobs)
- PARAMETERS:
        - indexblob: index in the blob array
- RESULT:
- RESTRICTIONS:
- AUTHOR: Ricard Borràs
- CREATION DATE: 25-05-2005.
- MODIFICATION: Date. Author. Description.
*/
CBlob CBlobResult::GetBlob(int indexblob) const
{       
        if( indexblob < 0 || indexblob >= GetNumBlobs() )
                RaiseError( EXCEPTION_BLOB_OUT_OF_BOUNDS );

        return *m_blobs[indexblob];
}
CBlob *CBlobResult::GetBlob(int indexblob)
{       
        if( indexblob < 0 || indexblob >= GetNumBlobs() )
                RaiseError( EXCEPTION_BLOB_OUT_OF_BOUNDS );

        return m_blobs[indexblob];
}

/*
- FUNCTION: GetNthBlob
- FUNCTIONALITY: Gets the n-th blob ordering first the blobs with some criteria
- PARAMETERS:
        - criteri: criteria to order the blob array
        - nBlob: index of the returned blob in the ordered blob array
        - dst: where to store the result
- RESULT:
- RESTRICTIONS:
- AUTHOR: Ricard Borràs
- CREATION DATE: 25-05-2005.
- MODIFICATION: Date. Author. Description.
*/
void CBlobResult::GetNthBlob( funcio_calculBlob *criteri, int nBlob, CBlob &dst ) const
{
        // verifiquem que no estem accedint fora el vector de blobs
        if( nBlob < 0 || nBlob >= GetNumBlobs() )
        {
                //RaiseError( EXCEPTION_BLOB_OUT_OF_BOUNDS );
                dst = CBlob();
                return;
        }

        double_stl_vector avaluacioBlobs, avaluacioBlobsOrdenat;
        double valorEnessim;

        //avaluem els blobs amb la funció pertinent     
        avaluacioBlobs = GetSTLResult(criteri);

        avaluacioBlobsOrdenat = double_stl_vector( GetNumBlobs() );

        // obtenim els nBlob primers resultats (en ordre descendent)
        std::partial_sort_copy( avaluacioBlobs.begin(), 
                                                    avaluacioBlobs.end(),
                                                    avaluacioBlobsOrdenat.begin(), 
                                                    avaluacioBlobsOrdenat.end(),
                                                    std::greater<double>() );

        valorEnessim = avaluacioBlobsOrdenat[nBlob];

        // busquem el primer blob que té el valor n-ssim
        double_stl_vector::const_iterator itAvaluacio = avaluacioBlobs.begin();

        bool trobatBlob = false;
        int indexBlob = 0;
        while( itAvaluacio != avaluacioBlobs.end() && !trobatBlob )
        {
                if( *itAvaluacio == valorEnessim )
                {
                        trobatBlob = true;
                        dst = CBlob( GetBlob(indexBlob));
                }
                itAvaluacio++;
                indexBlob++;
        }
}

/*
- FUNCTION: ClearBlobs
- FUNCTIONALITY: Clears all the blobs from the object and releases all its memory
- PARAMETERS:
- RESULT:
- RESTRICTIONS:
- AUTHOR: Ricard Borràs
- CREATION DATE: 25-05-2005.
- MODIFICATION: Date. Author. Description.
*/
void CBlobResult::ClearBlobs()
{
        /*for( int i = 0; i < GetNumBlobs(); i++ )
        {
                delete m_blobs[i];
        }*/
        Blob_vector::iterator itBlobs = m_blobs.begin();
        while( itBlobs != m_blobs.end() )
        {
                delete *itBlobs;
                itBlobs++;
        }

        m_blobs.clear();
}

/*
- FUNCTION: RaiseError
- FUNCTIONALITY: Error handling function
- PARAMETERS:
        - errorCode: reason of the error
- RESULT:
        - in _DEBUG version, shows a message box with the error. In release is silent.
          In both cases throws an exception with the error.
- RESTRICTIONS:
- AUTHOR: Ricard Borràs
- CREATION DATE: 25-05-2005.
- MODIFICATION: Date. Author. Description.
*/
void CBlobResult::RaiseError(const int errorCode) const
{
        // estem en mode debug?
#ifdef _DEBUG
        CString msg, format = "Error en CBlobResult: %s";

        switch (errorCode)
        {
        case EXCEPTION_BLOB_OUT_OF_BOUNDS:
                msg.Format(format, "Intentant accedir a un blob no existent");
                break;
        default:
                msg.Format(format, "Codi d'error desconegut");
                break;
        }

        AfxMessageBox(msg);

#endif
        throw errorCode;
}



/**************************************************************************
                Auxiliars / Auxiliary functions
**************************************************************************/


/*
- FUNCTION: PrintBlobs
- FUNCTIONALITY: Prints some blob features in an ASCII file
- PARAMETERS:
        - nom_fitxer: full path + filename to generate
- RESULT:
- RESTRICTIONS:
- AUTHOR: Ricard Borràs
- CREATION DATE: 25-05-2005.
- MODIFICATION: Date. Author. Description.
*/
void CBlobResult::PrintBlobs( char *nom_fitxer ) const
{
        double_stl_vector area, /*perimetre,*/ exterior, compacitat, longitud, 
                                          externPerimeter, perimetreConvex, perimetre;
        int i;
        FILE *fitxer_sortida;

        area      = GetSTLResult( CBlobGetArea());
        perimetre = GetSTLResult( CBlobGetPerimeter());
        exterior  = GetSTLResult( CBlobGetExterior());
        compacitat = GetSTLResult(CBlobGetCompactness());
        longitud  = GetSTLResult( CBlobGetLength());
        externPerimeter = GetSTLResult( CBlobGetExternPerimeter());
        perimetreConvex = GetSTLResult( CBlobGetHullPerimeter());

        fitxer_sortida = fopen( nom_fitxer, "w" );

        for(i=0; i<GetNumBlobs(); i++)
        {
                fprintf( fitxer_sortida, "blob %d ->\t a=%7.0f\t p=%8.2f (%8.2f extern)\t pconvex=%8.2f\t ext=%.0f\t m=%7.2f\t c=%3.2f\t l=%8.2f\n",
                                 i, area[i], perimetre[i], externPerimeter[i], perimetreConvex[i], exterior[i], compacitat[i], longitud[i] );
        }
        fclose( fitxer_sortida );

}