Blob.h

/************************************************************************
                        Blob.h
                        
FUNCIONALITAT: Definici�de la classe CBlob
AUTOR: Inspecta S.L.
MODIFICACIONS (Modificaci� Autor, Data):

FUNCTIONALITY: Definition of the CBlob class and some helper classes to perform
                           some calculations on it
AUTHOR: Inspecta S.L.
MODIFICATIONS (Modification, Author, Date):
LICENSE: See README.TXT

**************************************************************************/

#pragma warning( disable : 4786 ) 

#ifndef CBLOB_INSPECTA_INCLUDED
#define CBLOB_INSPECTA_INCLUDED

#include <cxcore.h>
#include <BlobLibraryConfiguration.h>
#include <functional>
#include <vector>
#include <algorithm>


#ifdef BLOB_OBJECT_FACTORY
        #include "..\inspecta\DesignPatterns\ObjectFactory.h"
#endif


#define DEGREE2RAD              (CV_PI / 180.0)

class CBlob
{
public:
        CBlob();
        CBlob( const CBlob &src );
        CBlob( const CBlob *src );

        ~CBlob();
        
        CBlob& operator=(const CBlob &src );

        bool IsEmpty() const
        {
                return (area == 0.0 && perimeter == 0.0 );
        };

        void ClearEdges();
        void CopyEdges( CBlob &destination ) const;
        bool GetConvexHull( CvSeq **dst ) const;
        CvBox2D GetEllipse() const;

        void FillBlob( IplImage *imatge, CvScalar color, int offsetX = 0, int offsetY = 0 ) const;


        inline int Label() const        { return etiqueta; }
        inline int Parent() const       { return parent; }
        inline double Area() const { return area; }
        inline double Perimeter() const { return perimeter; }
        inline double ExternPerimeter() const { return externPerimeter; }
        inline int        Exterior() const { return exterior; }
        inline double Mean() const { return mean; }
        inline double StdDev() const { return stddev; }
        inline double MinX() const { return minx; }
        inline double MinY() const { return miny; }
        inline double MaxX() const { return maxx; }
        inline double MaxY() const { return maxy; }
        inline CvSeq *Edges() const { return edges; }
        inline double SumX() const { return sumx; }
        inline double SumY() const { return sumy; }
        inline double SumXX() const { return sumxx; }
        inline double SumYY() const { return sumyy; }
        inline double SumXY() const { return sumxy; }
        
        int etiqueta;
        int exterior;
        double area;
        double perimeter;
        double externPerimeter;
        int parent;
        double sumx;
        double sumy;
        double sumxx;
        double sumyy;
        double sumxy;
        double minx;
        double maxx;
        double miny;
        double maxy;
        
        double mean;
        double stddev;

        CvMemStorage *m_storage;
        CvSeq *edges;
        

        typedef std::vector<CvPoint> vectorPunts;

        struct comparaCvPoint : public std::binary_function<CvPoint, CvPoint, bool> 
        {
                bool operator()(CvPoint a, CvPoint b) 
                { 
                        if( a.y == b.y ) 
                                return a.x < b.x;
                        else 
                                return a.y < b.y; 
                }
        };
};



/**************************************************************************
                Definici�de les classes per a fer operacions sobre els blobs

                Helper classes to perform operations on blobs
**************************************************************************/


class COperadorBlob
{
public:
        virtual ~COperadorBlob(){};

        virtual double operator()(const CBlob &blob) const = 0;
        virtual const char *GetNom() const = 0;

        operator COperadorBlob*() const
        {
                return (COperadorBlob*)this;
        }
};

typedef COperadorBlob funcio_calculBlob;

#ifdef BLOB_OBJECT_FACTORY

        struct functorComparacioIdOperador
        {
          bool operator()(const char* s1, const char* s2) const
          {
                return strcmp(s1, s2) < 0;
          }
        };

        typedef ObjectFactory<COperadorBlob, const char *, functorComparacioIdOperador > t_OperadorBlobFactory;

        void RegistraTotsOperadors( t_OperadorBlobFactory &fabricaOperadorsBlob );

#endif

class CBlobGetArea : public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        { 
                return blob.Area(); 
        }
        const char *GetNom() const
        {
                return "CBlobGetArea";
        }
};

class CBlobGetPerimeter: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        { 
                return blob.Perimeter(); 
        }
        const char *GetNom() const
        {
                return "CBlobGetPerimeter";
        }
};

class CBlobGetExterior: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        { 
                return blob.Exterior(); 
        }
        const char *GetNom() const
        {
                return "CBlobGetExterior";
        }
};

class CBlobGetMean: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        { 
                return blob.Mean(); 
        }
        const char *GetNom() const
        {
                return "CBlobGetMean";
        }
};

class CBlobGetStdDev: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        { 
                return blob.StdDev(); 
        }
        const char *GetNom() const
        {
                return "CBlobGetStdDev";
        }
};

class CBlobGetCompactness: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetCompactness";
        }
};

class CBlobGetLength: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetLength";
        }
};

class CBlobGetBreadth: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetBreadth";
        }
};

class CBlobGetDiffX: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.maxx - blob.minx;
        }
        const char *GetNom() const
        {
                return "CBlobGetDiffX";
        }
};

class CBlobGetDiffY: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.maxy - blob.miny;
        }
        const char *GetNom() const
        {
                return "CBlobGetDiffY";
        }
};

class CBlobGetMoment: public COperadorBlob
{
public:
        CBlobGetMoment()
        {
                m_p = m_q = 0;
        }
        CBlobGetMoment( int p, int q )
        {
                m_p = p;
                m_q = q;
        };
        double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetMoment";
        }

private:
        int m_p, m_q;
};

class CBlobGetHullPerimeter: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetHullPerimeter";
        }
};

class CBlobGetHullArea: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetHullArea";
        }
};

class CBlobGetMinXatMinY: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetMinXatMinY";
        }
};

class CBlobGetMinYatMaxX: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetMinYatMaxX";
        }
};

class CBlobGetMaxXatMaxY: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetMaxXatMaxY";
        }
};

class CBlobGetMaxYatMinX: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetMaxYatMinX";
        }
};

class CBlobGetMinX: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.MinX();
        }
        const char *GetNom() const
        {
                return "CBlobGetMinX";
        }
};

class CBlobGetMaxX: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.MaxX();
        }
        const char *GetNom() const
        {
                return "CBlobGetMaxX";
        }
};

class CBlobGetMinY: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.MinY();
        }
        const char *GetNom() const
        {
                return "CBlobGetMinY";
        }
};

class CBlobGetMaxY: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.MaxY();
        }
        const char *GetNom() const
        {
                return "CBlobGetMax";
        }
};


class CBlobGetElongation: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetElongation";
        }
};

class CBlobGetRoughness: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetRoughness";
        }
};

class CBlobGetDistanceFromPoint: public COperadorBlob
{
public:
        CBlobGetDistanceFromPoint()
        {
                m_x = m_y = 0.0;
        }
        CBlobGetDistanceFromPoint( const double x, const double y )
        {
                m_x = x;
                m_y = y;
        }

    double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetDistanceFromPoint";
        }

private:
        // coordenades del punt on volem calcular la dist�cia
        double m_x, m_y;
};

class CBlobGetExternPerimeter: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.ExternPerimeter();
        }
        const char *GetNom() const
        {
                return "CBlobGetExternPerimeter";
        }
};

class CBlobGetExternPerimeterRatio: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                if( blob.Perimeter() != 0 )
                        return blob.ExternPerimeter() / blob.Perimeter();
                else
                        return blob.ExternPerimeter();
        }
        const char *GetNom() const
        {
                return "CBlobGetExternPerimeterRatio";
        }
};

class CBlobGetExternHullPerimeterRatio: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                CBlobGetHullPerimeter getHullPerimeter;
                double hullPerimeter;

                if( (hullPerimeter = getHullPerimeter( blob ) ) != 0 )
                        return blob.ExternPerimeter() / hullPerimeter;
                else
                        return blob.ExternPerimeter();
        }
        const char *GetNom() const
        {
                return "CBlobGetExternHullPerimeterRatio";
        }
};

class CBlobGetXCenter: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.MinX() + (( blob.MaxX() - blob.MinX() ) / 2.0);
        }
        const char *GetNom() const
        {
                return "CBlobGetXCenter";
        }
};

class CBlobGetYCenter: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                return blob.MinY() + (( blob.MaxY() - blob.MinY() ) / 2.0);
        }
        const char *GetNom() const
        {
                return "CBlobGetYCenter";
        }
};

class CBlobGetMajorAxisLength: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                CvBox2D elipse = blob.GetEllipse();

                return elipse.size.width;
        }
        const char *GetNom() const
        {
                return "CBlobGetMajorAxisLength";
        }
};

class CBlobGetAreaElipseRatio: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                if( blob.Area()==0.0 ) return 0.0;

                CvBox2D elipse = blob.GetEllipse();
                double ratioAreaElipseAreaTaca = ( (elipse.size.width/2.0)
                                                                                   *
                                                                                   (elipse.size.height/2.0)
                                                                       *CV_PI
                                                                 )
                                                                             /
                                                                             blob.Area();

                return ratioAreaElipseAreaTaca;
        }
        const char *GetNom() const
        {
                return "CBlobGetAreaElipseRatio";
        }
};

class CBlobGetMinorAxisLength: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                CvBox2D elipse = blob.GetEllipse();

                return elipse.size.height;
        }
        const char *GetNom() const
        {
                return "CBlobGetMinorAxisLength";
        }
};

class CBlobGetOrientation: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                CvBox2D elipse = blob.GetEllipse();

                if( elipse.angle > 180.0 )
                        return (( elipse.angle - 180.0 )* DEGREE2RAD);
                else
                        return ( elipse.angle * DEGREE2RAD);

        }
        const char *GetNom() const
        {
                return "CBlobGetOrientation";
        }
};

class CBlobGetOrientationCos: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                CBlobGetOrientation getOrientation;
                return fabs( cos( getOrientation(blob) ));
        }
        const char *GetNom() const
        {
                return "CBlobGetOrientationCos";
        }
};


class CBlobGetAxisRatio: public COperadorBlob
{
public:
    double operator()(const CBlob &blob) const
        {
                CvBox2D elipse = blob.GetEllipse();

                return elipse.size.height / elipse.size.width;
        }
        const char *GetNom() const
        {
                return "CBlobGetAxisRatio";
        }
};


class CBlobGetXYInside: public COperadorBlob
{
public:
        CBlobGetXYInside()
        {
                m_p = cvPoint(0,0);
        }
        CBlobGetXYInside( CvPoint p )
        {
                m_p = p;
        };
        double operator()(const CBlob &blob) const;
        const char *GetNom() const
        {
                return "CBlobGetXYInside";
        }

private:
        CvPoint m_p;
};

#endif //CBLOB_INSPECTA_INCLUDED