BlobLRBTFromBGSubstractionModel3.h

#ifndef BLOBLRBTFROMBGSUBSTRACTIONMODEL3_H
#define BLOBLRBTFROMBGSUBSTRACTIONMODEL3_H

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

#include <opencv2/core.hpp>

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

class Datapool;

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

    BlobLRBTFromBGSubstractionModel3(int buffer_size);

    virtual ~BlobLRBTFromBGSubstractionModel3();

    //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);

    //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);

    virtual BoundingBox getEstimator(double &R);

    //Reliability by parameter
    double getLeftReliability(BoundingBox &boundingBox);
    double getRightReliability(BoundingBox &boundingBox);
    double getBottomReliability(BoundingBox &boundingBox);
    double getTopReliability(BoundingBox &boundingBox);

    double contrastGaussianMean(int x, int y, QImage &cn);
    double contrastGaussianMeanFG(int x, int y, QImage *cn, QImage *fg);
    void addLocalBoundPoints(BoundingBox &r, Bound bound, float reliability);


    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[];

    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;
    QImage boundsReliability;
    double localMaxBound;
    bool currentBoundImageOK;
    std::map< int, std::map<int, double> > localBoundList;

    std::vector<float> leftBoundListRel;
    std::vector<cv::Point2d> leftBoundListPos;
    std::vector<float> rightBoundListRel;
    std::vector<cv::Point2d> rightBoundListPos;
    std::vector<float> topBoundListRel;
    std::vector<cv::Point2d> topBoundListPos;
    std::vector<float> bottomBoundListRel;
    std::vector<cv::Point2d> bottomBoundListPos;

//    int xbound, ybound;
};

typedef QSharedPointer<BlobLRBTFromBGSubstractionModel3> SpBlobLRBTFromBGSubstractionModel3;


#endif // BLOB2DFROMBGSUBSTRACTIONMODEL3_H