apparienceModelLearning.h

#ifndef APPARIENCEMODELLEARNING_H
#define APPARIENCEMODELLEARNING_H

#include <opencv/cv.h>
#include <opencv/highgui.h>
#include "opencv2/opencv.hpp"
#include <QString>

#include <src/footballConstants.h>

enum typeDistanceMetric{
    Single,
    Complete,
    Average,
    Weighted,
    Median
};

typedef struct sampleAppModel sampleAppModel;
struct sampleAppModel
{
    double L;
    double U;
    double V;
    soccerClass clase;
};

typedef struct appModel appModel;
struct appModel
{
    QString name;//Name of Model
    cv::Ptr<cv::ml::EM> emAl; //EM Algorithm
    bool isTrained; //Flag que indica si la clase esta entrenada
    typeCluster typeTrained;
    std::map< soccerClass, unsigned long> nSamples; //Enumera la cantidad de muestras actuales en cada Modelo
    unsigned long pSamples; //Cantidad de muestras con la que se entreno el Modelo
    double probability; //Confiabilidad del Modelo
    std::vector<sampleAppModel> samples; //Muestras actuales por cada Clase

    clusters2D_BOF ClustersUV; //Meta-Prototypes Chrominancy
    clusters3D_BOF ClustersLUV; //Meta-Prototypes LUV
    clusters1D_BOF ClustersL; //Meta-Prototypes Luminancy

};

class apparienceModelLearning
{
public:
    apparienceModelLearning();
    apparienceModelLearning(QString name, int cls = 15, double bottomTh=0.0, double topTh=100.0, typeDistanceMetric type = Complete);
    ~apparienceModelLearning();


    bool trainAll();
    void resetTrain();
    void generateMetaPrototypesFor3DCluster(int n_clusters);
    void generateMetaPrototypesFor2DCluster(int n_clusters);
    void generateMetaPrototypesFor1DCluster(int n_clusters);
    void updateMode();
    void saveModel(QString directory);
    bool readChroma_Model(QString filePath);
    bool readLuma_Model(QString filePath);
    bool readLuv_Model(QString filePath);


    //With these methods we obtain Mixture of Gaussians Parameters
    bool getWeights(cv::Mat &mat);
    bool getMeans(cv::Mat &mat);
    bool getCovs(std::vector< cv::Mat > &vmat);
    QString getName();
    cv::Ptr<cv::ml::EM> getEM();
    bool getSamplesFromCSV(QString filePath, int part, soccerClass cl);

    clusters2D_BOF getClusters2D_BOF();
    clusters1D_BOF getClusters1D_BOF();
    clusters3D_BOF getClusters3D_BOF();

    static cv::Vec3d valueLUVConvert(cv::Vec3d val);
    static cv::Vec2d valueUVConvert(cv::Vec2d val);
    static cv::Scalar valueLUVConvertInv(cv::Scalar val);

    //Histogram Computation
    double* create1DFeature_Histogram(soccerClass clase, bool showH = false);
    double* create2DFeature_Histogram(soccerClass clase, bool showH = false);
    double* create3DFeature_Histogram(soccerClass clase, bool showH = false);

    //Distance Measures
    static double BhattacharryaDistance(double *h1, double *h2, int size);
    static double chiSquare(double *h1, double *h2, int size);
    static double intersectionDist(double *h1, double *h2, int size);
    static double correlationDist(double *h1, double *h2, int size);

    static bool evaluatePixeltoCluster(cv::Vec2d value, std::vector < cv::Vec2d > cluster,int type);
    static bool evaluatePixeltoCluster(cv::Vec3d value, std::vector < cv::Vec3d > cluster, int type);
    static bool evaluatePixeltoCluster(double value, std::vector < double > cluster,int type);
    static void showHistogram(int *count, const clusters2D_BOF &clusters, QString name = "UNKNOWN");
    static void showHistogram(int *count, const clusters3D_BOF &clusters, QString name = "UNKNOWN");
    static void showHistogram(int *count, const clusters1D_BOF &clusters, QString name = "UNKNOWN");
    static void printClusters(clusters2D_BOF clusters);
    static void printClusters(clusters1D_BOF clusters);
    static void printClusters(clusters3D_BOF clusters);
    static bool filterByLuma(double l, double bottomTh, double topTh);


private:

    bool trainEM(typeCluster typeCl);

    void addSamples();
    void eraseSamples(unsigned long init, unsigned long end);

    //Heriarquical Clustering
    double calcDist(cv::Vec2d p1, cv::Vec2d p2);
    cv::Point findMinDist(cv::Mat proximityMat);
    double distNewCluster(cv::Point rsPoint, int k, cv::Mat distanceMat, typeDistanceMetric type, int nr, int ns);

    int n_clusters;
    int n_parametersCSV;

    appModel model;

    double m_topTh;
    double m_bottomTh;

    typeDistanceMetric dMetric;

    //Almacena muestras de jugador de la clase especificada en una variable tipo cv::map
    unsigned int samplesToMap(cv::Mat &mat, soccerClass clase, typeCluster type);

    unsigned int countAllSamples();

};

#endif // APPARIENCEMODELLEARNING_H