playermodelfromprobabilitymaps.h

#ifndef PLAYERMODELFROMPROBABILITYMAPS_H
#define PLAYERMODELFROMPROBABILITYMAPS_H

#include <QDomNode>
#include <QImage>

#include "reliabilitysinglemodelinterface.h"
#include "src/templateclass.h"

typedef struct mapStruct mapMapStruct;
struct mapStruct
{
    mapStruct( float _maxVal, float _minVal, float _diff , QString _name) :
        maxVal(_maxVal), minVal(_minVal),diff(_diff),name(_name){}
        mapStruct() : maxVal(0.0), minVal(1000.0), diff(0.0), name("UNK"){}

    float maxVal;
    float minVal;
    float diff;
    float alpha, beta;
    float probValue;
    QString name;

};

class PlayerModelFromProbabilityMaps : public ReliabilitySingleModelInterface
{
public:
    PlayerModelFromProbabilityMaps(int buffer_size);

    virtual ~PlayerModelFromProbabilityMaps();

    //IMPLEMENT!! Initializes the model attributes for the interface.
    //The function is called by the interface constructor
    virtual void initInstanceAttributes();

    //IMPLEMENT!! Initializes the dynamics model attributes for the interface.
    //The function is called by the interface constructor
    virtual void initDynamicsAttributes();

    //IMPLEMENT!! Copy function for specific data from the instance (general_copy calls it after copying base info)
    virtual void copy(SpReliabilitySingleModelInterface);

    //IMPLEMENT!! Copy general structures and parameters of specific model, without considering instance specific data
    virtual void copy_structure(SpReliabilitySingleModelInterface);

    //IMPLEMENT!! sets parameters from xml file
    virtual void setParameters(QDomNode &i_parameters);

    //IMPLEMENT!! sets activation criteria for each model: reliability on input (distance, bad data),
    //   needs (occlusion, priority),
    //sets priority of models (hierarchy).
    //Checked before update phase
    virtual void activate(BoundingBox &);

    //IMPLEMENT!! initializes every activated model, according to their own input (region-blob-segments schema)
    //Executed only once at the begginning of single model creation (after 'copy_structure' and 'copy' methods
    //are used to copy the information).
    virtual void init();

    //IMPLEMENT!! updates activated model instance attributes for current frame, and returns the set of detected/enriched objects.
    //            It notifies if roi (bounding box, or segmentation) changes compared to the input, for reprocessing.
    virtual bool updateInstance(BoundingBox &, std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> &);

    //IMPLEMENT!! updates activated model instance attributes for current frame and object, and returns the detected/enriched object.
    //            It notifies if roi (bounding box, or segmentation) changes compared to the input, for reprocessing.
    //            This function does NOT generate mobiles or hypotheses. It processes attributes for the current object.
    //            This function could be used by updateInstance to generate mobile information.
    virtual void updateSingleInstance(BoundingBox &);


    //IMPLEMENT!! updates model dynamics, based on instances information
    virtual void updateModelDynamics();

    //IMPLEMENT!! sets global probability for the model (how good is the model)
    virtual void setProbabilityAndReliability();

    //IMPLEMENT!! sets blob enclosing the model in forward process (update)
    virtual void setForwardInterface();

    //OPTIONAL
    virtual bool draw(QPainter &painter);

    virtual bool draw(QPainter &painter, int r, int g, int b);

    virtual void printGeneral();

    virtual BoundingBox getEstimator(double &R);

    bool getCentersForMultipleClasses(int x_leftBlob, int x_rightBlob, int y_topBlob, int y_bottomBlob);

    BoundingBox setRectModel(cv::Point center);

private:
    //Mapas de Probabilidad
    cv::Mat compactnessMap;
    cv::Mat heightMap;
    cv::Mat widthMap;
    cv::Mat probMap;
    std::map<soccerClass, cv::Mat> colorMapTeam_Map; //Mapa de Probabilidad de Color
    std::map<soccerClass, cv::Mat> probability_Map; //Mapa de Probabilidad 32 bits un canal

    //Directorio donde se encuentran las tablas del modelo de color para cada parte del cuerpo
    std::map<soccerClass, bool > classesIncluded;
    templateClass *Template;

    QVector<QRgb> colorTable;//Tabla de Color para dibujar los mapas de probabilidad

    int candidate_to_draw;
    int currentBlob_id;//Id for current Analized Blob

    bool drawFlag;

    bool valid;

    //Parametros que faltan por setear
    int thresholdPeakImage;

    cv::Mat obtainDistancesIntegralImage(const cv::Mat &frame, cv::Rect roi,soccerClass team, playerPart part);

    //Color Maps
    //0: Red   1 : Blue
    QImage matToQImageOneColor(const cv::Mat& mat);

    void writeMapToSCV(cv::Mat data, QString name);

    void setTemplateColors();

    //Functions to find de Maximun values for center of players
    std::vector<cv::Point> bhContoursCenter(const std::vector<std::vector<cv::Point>>& contours,bool centerOfMass,int contourIdx=-1);
    std::vector<cv::Point> bhFindLocalMaximum(cv::Mat _src, QString name = "UNK");

    std::vector<int> getExtendedRegion(int blob_xleft, int blob_xright, int blob_ytop, int blob_ybottom);

    void obtainIntegralImagesForTemplate(soccerClass team, cv::Rect rect);

    cv::Rect setPlayerSizeAt(int j, int i, int upPart, int height, int width);
    double getHeightMapProbValue(int i, int top, int bottom, int topPart, int bottomPart, int type);
    std::vector<int> getForegroundLimitPoints(const uchar *data,int bpl, int blob_xleft, int blob_xright, int blob_ytop, int blob_ybottom);
    void mapSetParamStepOne(mapStruct &vT);
    void mapSetParamStepTwo(mapStruct &vT);
    void showMaps(int objectId, double scaleFactor);
    void showImageGroup(std::vector<cv::Mat> imagesToShow, QString windowName);
    double getWidthMapProbValue(int j, int left, int right, int ratio, int type);

    double setCandidatesToObjectDistances();

    std::vector<playerCandidate> plCandidates;

    playerCandidate *c;

    BoundingBox m_roi;
    BoundingBox usedRoi;

    double R;

    cv::RotatedRect getProyectedTorso();
};

typedef QSharedPointer<PlayerModelFromProbabilityMaps> SpPlayerModelFromProbabilityMaps;

#endif // PLAYERMODELFROMPROBABILITYMAPS_H