BlobOperators.h

Go to the documentation of this file.

#ifndef BLOB_OPERATORS_H_INCLUDED
#define BLOB_OPERATORS_H_INCLUDED

#include "Blob.h"

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

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

#define DEGREE2RAD              (CV_PI / 180.0)


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

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

        operator COperadorBlob*()
        {
                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 CBlobGetID : public COperadorBlob
{
public:
    double operator()(CBlob &blob)
        { 
                return blob.GetID(); 
        }
        const char *GetNom()
        {
                return "CBlobGetID";
        }
};


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

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

class CBlobGetExterior: public COperadorBlob
{
public:
        CBlobGetExterior()
        {
                m_mask = NULL;
                m_xBorder = false;
                m_yBorder = false;
        }
        CBlobGetExterior(IplImage *mask, bool xBorder = true, bool yBorder = true)
        {
                m_mask = mask;
                m_xBorder = xBorder;
                m_yBorder = yBorder;
        }
    double operator()(CBlob &blob)
        { 
                return blob.Exterior(m_mask, m_xBorder, m_yBorder); 
        }
        const char *GetNom()
        {
                return "CBlobGetExterior";
        }
private:
        IplImage *m_mask;
        bool m_xBorder, m_yBorder;
};

class CBlobGetMean: public COperadorBlob
{
public:
        CBlobGetMean()
        {
                m_image = NULL;
        }
        CBlobGetMean( IplImage *image )
        {
                m_image = image;
        };

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

        IplImage *m_image;
};

class CBlobGetStdDev: public COperadorBlob
{
public:
        CBlobGetStdDev()
        {
                m_image = NULL;
        }
        CBlobGetStdDev( IplImage *image )
        {
                m_image = image;
        };
    double operator()(CBlob &blob)
        { 
                return blob.StdDev(m_image); 
        }
        const char *GetNom()
        {
                return "CBlobGetStdDev";
        }
private:

        IplImage *m_image;

};

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

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

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

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

class CBlobGetDiffY: public COperadorBlob
{
public:
    double operator()(CBlob &blob)
        {
                return blob.GetBoundingBox().height;
        }
        const char *GetNom()
        {
                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()(CBlob &blob);
        const char *GetNom()
        {
                return "CBlobGetMoment";
        }

private:
        int m_p, m_q;
};

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

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

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

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

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

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

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

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

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

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


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

class CBlobGetRoughness: public COperadorBlob
{
public:
    double operator()(CBlob &blob);
        const char *GetNom()
        {
                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()(CBlob &blob);
        const char *GetNom()
        {
                return "CBlobGetDistanceFromPoint";
        }

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

class CBlobGetExternPerimeter: public COperadorBlob
{
public:
        CBlobGetExternPerimeter()
        {
                m_mask = NULL;
                m_xBorder = false;
                m_yBorder = false;
        }
        CBlobGetExternPerimeter( IplImage *mask, bool xBorder = true, bool yBorder = true )
        {
                m_mask = mask;
                m_xBorder = xBorder;
                m_yBorder = yBorder;
        }
    double operator()(CBlob &blob)
        {
                return blob.ExternPerimeter(m_mask, m_xBorder, m_yBorder);
        }
        const char *GetNom()
        {
                return "CBlobGetExternPerimeter";
        }
private:
        IplImage *m_mask;
        bool m_xBorder, m_yBorder;
};

class CBlobGetExternPerimeterRatio: public COperadorBlob
{
public:
        CBlobGetExternPerimeterRatio()
        {
                m_mask = NULL;
                m_xBorder = false;
                m_yBorder = false;
        }
        CBlobGetExternPerimeterRatio( IplImage *mask, bool xBorder = true, bool yBorder = true )
        {
                m_mask = mask;
                m_xBorder = xBorder;
                m_yBorder = yBorder;
        }
    double operator()(CBlob &blob)
        {
                if( blob.Perimeter() != 0 )
                        return blob.ExternPerimeter(m_mask, m_xBorder, m_yBorder) / blob.Perimeter();
                else
                        return blob.ExternPerimeter(m_mask,  m_xBorder, m_yBorder);
        }
        const char *GetNom()
        {
                return "CBlobGetExternPerimeterRatio";
        }
private:
        IplImage *m_mask;
        bool  m_xBorder, m_yBorder;
};

class CBlobGetExternHullPerimeterRatio: public COperadorBlob
{
public:
        CBlobGetExternHullPerimeterRatio()
        {
                m_mask = NULL;
                m_xBorder = false;
                m_yBorder = false;
        }
        CBlobGetExternHullPerimeterRatio( IplImage *mask, bool xBorder = true, bool yBorder = true )
        {
                m_mask = mask;
                m_xBorder = xBorder;
                m_yBorder = yBorder;
        }
    double operator()(CBlob &blob)
        {
                CBlobGetHullPerimeter getHullPerimeter;
                double hullPerimeter;

                if( (hullPerimeter = getHullPerimeter( blob ) ) != 0 )
                        return blob.ExternPerimeter(m_mask, m_xBorder, m_yBorder) / hullPerimeter;
                else
                        return blob.ExternPerimeter(m_mask, m_xBorder, m_yBorder);
        }
        const char *GetNom()
        {
                return "CBlobGetExternHullPerimeterRatio";
        }
private:
        IplImage *m_mask;
        bool  m_xBorder, m_yBorder;

};

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

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

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

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

class CBlobGetAreaElipseRatio: public COperadorBlob
{
public:
    double operator()(CBlob &blob)
        {
                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()
        {
                return "CBlobGetAreaElipseRatio";
        }
};

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

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

class CBlobGetOrientation: public COperadorBlob
{
public:
    double operator()(CBlob &blob)
        {
                CvBox2D elipse = blob.GetEllipse();
/*
                if( elipse.angle > 180.0 )
                        return (( elipse.angle - 180.0 )* DEGREE2RAD);
                else
                        return ( elipse.angle * DEGREE2RAD);
*/
                return elipse.angle;
        }
        const char *GetNom()
        {
                return "CBlobGetOrientation";
        }
};

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


class CBlobGetAxisRatio: public COperadorBlob
{
public:
    double operator()(CBlob &blob)
        {
                double major,minor;
                CBlobGetMajorAxisLength getMajor;
                CBlobGetMinorAxisLength getMinor;

                major = getMajor(blob);
                minor = getMinor(blob);

                if( major != 0 )
                        return minor / major;
                else
                        return 0;
        }
        const char *GetNom()
        {
                return "CBlobGetAxisRatio";
        }
};


class CBlobGetXYInside: public COperadorBlob
{
public:
        CBlobGetXYInside()
        {
                m_p.x = 0;
                m_p.y = 0;
        }
        CBlobGetXYInside( CvPoint2D32f p )
        {
                m_p = p;
        };
        double operator()(CBlob &blob);
        const char *GetNom()
        {
                return "CBlobGetXYInside";
        }

private:
        CvPoint2D32f m_p;
};

#endif  //!BLOB_OPERATORS_H_INCLUDED