ReliabilityPatchTrackingModel.h

#ifndef RELIABILITYPATCHTRACKINGMODEL_H
#define RELIABILITYPATCHTRACKINGMODEL_H

#include <QDomNode>
#include <QImage>
#include <vector>
#include <QSharedPointer>

#include <opencv2/core.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/xfeatures2d.hpp>

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

class Datapool;

typedef int (*getSegmentation)(Datapool*, BoundingBox&, cv::Mat&, int);

class ReliabilityPatchTrackingModel: public ReliabilitySingleModelInterface {
public:
    enum Bound {
        B_LEFT,
        B_RIGHT,
        B_TOP,
        B_BOTTOM,
    };

    class ReliabilityPatch {
      public:
        double Rs;   //Illumination reliability (TO IMPLEMENT)
        double Rc;   //Contrast reliability
        double R;    //Global patch reliability
        enum Bound origin;
        int x, y;
        int dx, dy; //displacement w.r.t. previous frame
        uchar Y, U, V;
        cv::Mat UVhisto;
        cv::Mat Yhisto;
        int num_foreground;
        double Rcoloured;
        double hm, vm; //horizontal and vertical moments
        int num_seen;
        cv::KeyPoint kp;
        double score; //FAST score;
        cv::Mat descriptor; //FREAK descriptor
        double dscore; //descriptor score;
        uchar T; //Threshold used for segmentation
        friend std::ostream& operator<<(std::ostream&, ReliabilityPatch&);
    };

    class ReliabilityPatchBuffer {
    public:
        ReliabilityPatchBuffer();
        ReliabilityPatchBuffer(int size);
        ~ReliabilityPatchBuffer();
        std::deque<ReliabilityPatch>::iterator begin();
        std::deque<ReliabilityPatch>::iterator end();
        std::deque<ReliabilityPatch>::reverse_iterator rbegin();
        std::deque<ReliabilityPatch>::reverse_iterator rend();
        ReliabilityPatch &operator[](int);
        unsigned int size();
        ReliabilityPatch &back();
        ReliabilityPatch &front();
        void clear();
        void insert(ReliabilityPatch *);
        void insert(ReliabilityPatch &pack);
        void resetMaxLength(int);
        void copyModels(ReliabilityPatchBuffer *);

        friend std::ostream& operator<<(std::ostream&,const ReliabilityPatchBuffer&);

        std::deque<ReliabilityPatch> instances;
        unsigned int maxLength;
    };

    class CentroidBuffer {
    public:
        CentroidBuffer();
        CentroidBuffer(int size);
        ~CentroidBuffer();
        std::deque<point2D<double> >::iterator begin();
        std::deque<point2D<double> >::iterator end();
        std::deque<point2D<double> >::reverse_iterator rbegin();
        std::deque<point2D<double> >::reverse_iterator rend();
        point2D<double> &operator[](int);
        unsigned int size();
        point2D<double> &back();
        point2D<double> &front();
        void clear();
        void insert(point2D<double> *);
        void insert(point2D<double> &pack);
        void resetMaxLength(int);
        void copyModels(CentroidBuffer *);

        friend std::ostream& operator<<(std::ostream&,const point2D<double> &);

        std::deque<point2D<double> > points;
        unsigned int maxLength;
    };


    class ReliabilityPatchTracking {
    public:
        unsigned int id;
        ReliabilityPatchBuffer buffer;
        ReliabilityPatch bestInRc;
        double bestRc;
        double Rpos; //Position reliability (coherence with previous positions)
        double Rpos_p; //Previous position reliability
        double Rg; //Global match reliability
        double Rc; //Buffer contrast reliability
        double R; //Integrated Patch Tracking Reliability
        bool structural;
        bool reliable;
        bool highly;
        int dx_diff; //Differences with bbox center
        int dy_diff;
        bool toErase;

        void setGlobalReliability();
        double getGlobalDisplacement(int &dx, int &dy);
        friend std::ostream& operator<<(std::ostream&, ReliabilityPatchTracking&);
    };

    ReliabilityPatchTrackingModel(int buffer_size);

    virtual ~ReliabilityPatchTrackingModel();

    //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 BoundingBox getEstimator(double &R);

    bool projectBoundingBox(BoundingBox &bbox);


    //Get function pointer to segmentation function
    getSegmentation getResegmentPointer(QString segAlternative, int &threshold);

    //Prints current patches on screen.
    void printPatches();

    //Get strongest (FAST) and nearest-to-center point
    bool getStrongPosition(int ix, int iy, int &ox, int &oy, cv::KeyPoint &op);
    //... and simplified version for refill
    bool refillStrongPosition(int ix, int iy, cv::KeyPoint &op);


    //Initialize attribute with instance value
    void initAttribute(ReliabilityDynamicsAttribute &d, AttributeDupletValue &i);

    //Standard attribute dynamics update, with no attribute value constraints
    void updateAttribute(const QString &name, ReliabilityDynamicsAttribute &d);

    double getAttributeEstimate(ReliabilityDynamicsAttribute &d, double time_diff);


    void updateAttributeDynamics(double data, double RData, double acuity,
                                 double estimate, double currentCooling, AttributeTripletValue &att);

    void updateAttributeDynamicsNoData(double estimate, double acuity, double currentCooling,
                                       AttributeTripletValue &att);

    double projectAttributeValue(ReliabilityDynamicsAttribute &, double &R);

    //Builds initial patches
    void initLeftPatches(BoundingBox &boundingBox);
    void initRightPatches(BoundingBox &boundingBox);
    void initBottomPatches(BoundingBox &boundingBox);
    void initTopPatches(BoundingBox &boundingBox);

    //Refill patches
    void refillLeftPatches(BoundingBox &b);
    void refillRightPatches(BoundingBox &b);
    void refillBottomPatches(BoundingBox &b);
    void refillTopPatches(BoundingBox &b);

    void insertPatch(BoundingBox &bbox, enum Bound bound, int row, int col);
    void refillPatch(BoundingBox &bbox, enum Bound bound, int row, int col);
    void setCentroid(BoundingBox &roi);
    void setInitialCentroid(BoundingBox &roi);

    void preparePatches();
    bool distantToExistingPatches(int x, int y, float response, bool &worst, int &wx, int &wy);
    bool distantToExistingPatches(int x, int y, double distance);
    bool distantToExistingPatches(int x, int y);
    void getFREAKDescriptors();
    void refillFREAKDescriptors(Bound bound);
    void setTrackedPatches(BoundingBox &roi);
    void computeFreak(std::vector<cv::KeyPoint>& points, cv::Mat &descriptors);
    void setHistograms(ReliabilityPatch &p);
    double illuminationReliability(uchar Y);
    double BhattacharyyaDistance(cv::Mat &h1, cv::Mat &h2);

    void completePatch(ReliabilityPatch &p); //Completes patch data.
    //Returns global reliability score (distance to all criteria).
    double globalPatchDistance(ReliabilityPatch &p1, ReliabilityPatch &p2);
    bool adjustBoundingBoxDimensions(BoundingBox &b);
    double displacementCoherenceReliability(double distance);
    void saveWeakReliabilityPatches(BoundingBox &b);
    void deleteWeakPatches();
    void addNewPatches(BoundingBox &roi);


    //Sets the most reliable patches (analyzing short history) in terms of
    // - Coherence with the bounding box movement
    // - Contrast reliability
    // - Low distance among feature
    void setHighlyReliablePatches();
    void setWeakPatches();
    void removeEquallyConverged();
    void setInstancesDisplacement();
    void moveProjectedBoxToLowestDisplacementAndHighestCoveragePosition(BoundingBox &p, BoundingBox &roi);

    double contrastGaussianMean(int x, int y, QImage &cn);
    double contrastGaussianMeanFG(int x, int y, QImage *cn, QImage *fg);

    void printTrackedPatches();
    void printTrackedPatch(unsigned int id);

    std::map<int, std::map<int, ReliabilityPatch> > patches;
    std::deque<ReliabilityPatch *> new_patches;
    std::vector<cv::KeyPoint> new_keypoints;

    std::map<uchar, cv::Mat> new_segmentations;

    std::deque<ReliabilityPatchTracking> tracked_patches;
    std::vector<ReliabilityPatchTracking *> reliable_patches;

    int m_patchSize;
    int m_generationStep;
    int m_topPatchesSize;
    int m_maxDimensionChange;
    int m_histoBins;
    int m_ill_alpha;
    int m_ill_beta;
    int m_ill_gamma;
    double m_minimalPatchReliability;
    int m_refillDistance;
    QString m_auxSegmentation;
    bool showText;
    bool por_aca;
    int patches_initial_count;
    double refPatchesRate; // patches/(w*h) measured to keep the proportion of reference patches. If the value is lower than
                            // this rate, patch refill is activated

    unsigned int tracked_patch_id;
    std::vector<int> gdx;
    std::vector<int> gdy;
    CentroidBuffer centroids;

    BoundingBox current_bbox;
    cv::Mat current_map;
    cv::Mat current_fg;
    cv::Mat current_fg_eroded;
    cv::Mat eelement;

    static const double R_MIN;
    static const bool USE_GAUSSIAN;
    static const int GAUSSIAN_SIZE;
    static const bool USE_FG;
    static const bool USE_SQUARE_DISTANCE;
    static const bool USE_MAX;
    static const bool USE_MEAN;
    static const bool USE_MAX_WEIGHTED;
    static const bool USE_MEAN_WEIGHTED;

    static const int GF7[];
    static const int GF5[];
    static const int GF3[];

    static getSegmentation m_seg;
    static bool availableSeg;
    static int m_referenceThreshold;

    double m_minimalAttributeVelocityReliability;
    double m_minimalAttributeAccelerationReliability;
    double m_minimalWidth;
    double m_minimalHeight;
    int m_pixelAcuity;
    bool m_useReliability;
    bool m_useFeatureMap;

    int *GF;
    double GFactor;

    bool m_showId;
    bool m_blackId;
    bool m_build2DBoundReliabilityImage;
    bool m_activateProjectedBlobCorrection;
    double localMaxBound;

    cv::Ptr<cv::xfeatures2d::FREAK> freak;

    //Pointers to available segmentations

};

typedef QSharedPointer<ReliabilityPatchTrackingModel> SpReliabilityPatchTrackingModel;


#endif // RELIABILITYPATCHTRACKINGMODEL_H