footballConstants.h

#ifndef FOOTBALLCONSTANTS_H
#define FOOTBALLCONSTANTS_H

#include <vector>
#include <map>
#include <QString>
#include <opencv2/core.hpp>
#include <src/common.h>

//Vectors Structures for Apparience Model Clusters based on Bag of Features
typedef std::vector< std::vector <cv::Vec2d > > clusters2D_BOF;
typedef std::vector< std::vector <cv::Vec3d > > clusters3D_BOF;
typedef std::vector< std::vector < double > > clusters1D_BOF;


//Apparience Color Model Features Type
enum typeCluster
{
    Chroma,
    Luma,
    Luv,
    All
};

//Defnied Classes for Soccer Match Player Tracking
enum soccerClass
{
    UNK,
    FIELD,
    TEAMA,
    TEAMB,
    GKTA,
    GKTB,
    REF,
    LINES,
    BALL
};


typedef std::map< soccerClass , std::map< typeCluster, double *> > appHistType;

//Fraction of Clothing Types
enum playerPart
{
    SOCKS,
    SHORT,
    SHIRT
};

//For Template of Detection Players Module
enum mapClass
{
    TEAM_A_MAP,
    TEAM_B_MAP,
    COMPACT,
    HGT
};

//Color models types for all possible classes
enum ColorModelType
{
    //SHIRTS
    TEAMA_SHIRT,
    TEAMB_SHIRT,
    REFEREE_SHIRT,
    GKPTA_SHIRT,
    GKPTB_SHIRT,

    //SHORTS
    TEAMA_SHORT,
    TEAMB_SHORT,
    REFEREE_SHORT,
    GKPTA_SHORT,
    GKPTB_SHORT,

    //SOCKS
    TEAMA_SOCKS,
    TEAMB_SOCKS,
    REFEREE_SOCKS,
    GKPTA_SOCKS,
    GKPTB_SOCKS,

    //STADIUM
    FIELD_MODELTYPE,
    LINES_MODELTYPE,

    //UNDEFINED
    UNDEFINED
};

typedef struct playerCandidate playerCandidate;
struct playerCandidate
{
    playerCandidate( cv::Point _center, float _prob, float reliab , ObjectType _type, cv::Rect _model, int _blob_id) :
        center(_center), prob(_prob),reliab(reliab),type(_type),model(_model),blob_id(_blob_id){}

    playerCandidate() : center(cv::Point(0,0)), prob(0.0),reliab(0.0),type(UNKNOWN),model(cv::Rect(0,0,0,0)),blob_id(-1){}

    cv::Point center; //Centro del jugador
    float prob; //Probabilidad de Centro
    float reliab; //Confiabilidad
    ObjectType type; //Clase desde la que se obtuvo
    cv::Rect model; //Modelo de Tamaño
    int blob_id;//Id del Blob del que se obtuvo
    bool used; //Señala si fue ocupado por un objeto
    double distanceToObject; //Distancia al Objeto que detecto el Candidato

    bool operator < (const playerCandidate& str) const
        {
            return (distanceToObject < str.distanceToObject);
        }
};

template< int Unused > std::vector< ColorModelType > colorModelToCMType_(soccerClass m)
{

    switch(m)
    {
        case TEAMA:
        {
           std::vector<ColorModelType> retVec;
           retVec.push_back(TEAMA_SHIRT);
           retVec.push_back(TEAMA_SHORT);
           retVec.push_back(TEAMA_SOCKS);
           return retVec;
        }
        case TEAMB:
        {
           std::vector<ColorModelType> retVec;
           retVec.push_back(TEAMB_SHIRT);
           retVec.push_back(TEAMB_SHORT);
           retVec.push_back(TEAMB_SOCKS);
           return retVec;
        }
        case REF:
        {
           std::vector<ColorModelType> retVec;
           retVec.push_back(REFEREE_SHIRT);
           retVec.push_back(REFEREE_SHORT);
           retVec.push_back(REFEREE_SOCKS);
           return retVec;
        }
        case GKTA:
        {
           std::vector<ColorModelType> retVec;
           retVec.push_back(GKPTA_SHIRT);
           retVec.push_back(GKPTA_SHORT);
           retVec.push_back(GKPTA_SOCKS);
           return retVec;
        }
        case GKTB:
        {
           std::vector<ColorModelType> retVec;
           retVec.push_back(GKPTB_SHIRT);
           retVec.push_back(GKPTB_SHORT);
           retVec.push_back(GKPTB_SOCKS);
           return retVec;
        }
        default:
        {
            std::vector<ColorModelType> retVec;
            return retVec;
        }
    }
}

template< int Unused > QString modelTypeToQString_(soccerClass m) {
  // definition
    switch (m)
    {
    case TEAMA:
        return "T_A";
    case TEAMB:
        return "T_B";
    case REF:
        return "REF";
    case GKTA:
        return "GKT_A";
    case GKTB:
        return "GKT_B";
    case FIELD:
        return "FIELD";
    case LINES:
        return "LINES";
    case UNK:
        return "UNK";
    default:
        return "UNK";

    }
}

template< int Unused > ObjectType soccerClassToObjectType_(soccerClass sc)
{
    switch (sc)
    {
        case TEAMA:
            return TEAM_A;
        case TEAMB:
            return TEAM_B;
        case GKTA:
            return GKEEPER_A;
        case GKTB:
            return GKEEPER_B;
        case REF:
            return REFEREE;
        default :
            return FOOTBALL;
    }
}

namespace { QString (&modelTypeToQString)(soccerClass m) = modelTypeToQString_<0>; }
namespace { std::vector< ColorModelType > (&colorModelToCMType)(soccerClass m) = colorModelToCMType_<0>; }
namespace { ObjectType (&soccerClassToObjectType)(soccerClass sc) = soccerClassToObjectType_<0>; }


#endif // FOOTBALLCONSTANTS_H