reliabilitysinglemodelinterface.h

#ifndef RELIABILITYSINGLEMODELINTERFACE_H
#define RELIABILITYSINGLEMODELINTERFACE_H

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

#include "reliabilityattribute.h"
#include "src/blob.h"
#include "src/common.h"

class Datapool;
class RMMTracker;
class RMMMobileObject;
typedef QSharedPointer<RMMMobileObject> SpRMMMobileObject;

class RMMHypothesis;
typedef QSharedPointer<RMMHypothesis> SpRMMHypothesis;

struct hypothesesOrderedByBestProbabilityOperator {
    bool operator()(SpRMMHypothesis a1, SpRMMHypothesis a2);
};

class ReliabilityMultiModelTemplate;

class ModelInstanceGeneralPack {
public:
    ModelInstanceGeneralPack(int frame); //It is a requirement to set the frame number, in order to check when the instance was inserted
    ModelInstanceGeneralPack(); //It is a requirement to set the frame number, in order to check when the instance was inserted
    int frameNumber;      //Current frame number (automatic fill).
    long timeStamp;       //Current timestamp in milliseconds (automatic fill).
    bool foundSupport;    //true if the bounding box finds support in segmentation (automatic fill).
                          //false commonly indicates that the object is considered lost in this frame.
                          //IT COULD BE CHANGED TO true IF EVIDENCE FROM OTHER SEGMENTATION HAS BEEN FOUND
    DetectionProblemType dp_type; //It signals different problems that could potentially have the visual evidence from the
                                  //bounding box for the object in the current frame (automatic fill, but can be modified).

    //TO COMPLETE BY EACH MODEL (normally with updateSingleInstance method):
    AttributeSegmentation segmentation; //Used segmentation. If RD==0, standard segmentation is considered (m_data->fgImage)
    bool changedSegmentation; //Change as true if segmentation is modified
    BoundingBox roi; //Region of interest
    double R_incorporate;       //It globally indicates if the roi information should be incorporated as the integrated data from
                                // the multimodel structure in the report to the object. Value 1 indicates full incorporation,
                                // and 0 indicates to ignore it. Values in the middle indicate the degree of trust in the estimated
                                // roi. The multimodel reports the oldest non zero value and roi. When branches exist, it is used as
                                // global weight when merging. If the final report indicates 0 value, the original input bounding
                                // box to the multimodel will be considered.
    Rectangle<double> Rroi;     //ROI bounds reliability
    std::map <ObjectType, double> classScore;    
};

class ModelInstanceDataPack {
public:
    std::map <QString, AttributeDupletValue> attributes;
    std::map <QString, AttributeDupletImage> attributes_image;
    std::map <QString, AttributeDupletDataset> attributes_dataset;
    ModelInstanceGeneralPack ginfo;
};

class ModelDynamicsDataPack {
public:
    std::map <QString, ReliabilityDynamicsAttribute> dynamics;
    std::map <QString, ReliabilityDynamicsAttributeDataset> dynamics_dataset;
};

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

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

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

class ReliabilitySingleModelInterface;

typedef QSharedPointer<ReliabilitySingleModelInterface> SpReliabilitySingleModelInterface;

class ReliabilitySingleModelInterface
{
public:
    ReliabilitySingleModelInterface(int buffer_size);

    //IMPLEMENT!!
    virtual ~ReliabilitySingleModelInterface();


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

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

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

    //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 &) = 0;

    //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() = 0;

    //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> &) = 0;

    //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, for the generated mobiles.
    //            IT MUST INSERT A NEW ModelInstanceDataPack IN instances buffer and update ginfo attribute of the ModelInstanceDataPack
    //            properly (see ModelInstanceGeneralPack).
    //            IF CALLED INSIDE ONE METHOD OF THIS CLASS, IT MUST INCLUDE A CALL TO METHOD: updateCurrentGeneralInfo();
    //              ALSO WHEN CREATING NEW OBJECTS (IT MUST BE CALLED FOR THE CREATED OBJECT).
    virtual void updateSingleInstance(BoundingBox &) = 0;

    //IMPLEMENT!! updates model dynamics, based on instances information: work on post_dynamics structure
    virtual void updateModelDynamics() = 0;

    //Visualization
    virtual void printInstances();

    virtual void printDynamics();

    virtual void printGeneral();

    virtual void printGeneral(std::ostream& out);

    virtual bool draw(QImage *image);

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

    //Starts dynamics in multimodel and calls specific model dynamics with updateModelDynamics();
    void updateDynamics();

    //sets global probability P for the model (how good is the model)
    //sets global reliability R for the model (how good is the data used in the model)
    virtual void setProbabilityAndReliability() = 0;

    //sets data pack general information of the model in forward process (update)
    virtual void setForwardInterface() = 0;

    //Get 2D central bounding box point from the model
    virtual void setTrajectory2D(double &, double &, double &);

    //Estimates the bounding box size and position for next
    //frame according to its own dynamics model
    //It also sets Reliability R of the model estimation.
    //The function defaults to the 'binterface' bounding box.
    //Nevertheless, a better implementation really depending on the
    //specific dynamics model is expected.
    virtual BoundingBox getEstimator(double &R);

    //This function sets parameters from xml
    void initFromXML(Datapool *i_data, int bsize, QString name);

    //Copy general structures and call specific copy function, including data for specific instances
    void general_copy(SpReliabilitySingleModelInterface);

    //Copy general structures: for new mobiles not related with a previous model
    void copy_general_structure(SpReliabilitySingleModelInterface);

    //Adds current classes information to integratedInfo
    void addCurrentClassInfo();
    void addCurrentClassInfo(ModelInstanceGeneralPack &gpack);
    static void addCurrentClassInfo(ModelInstanceGeneralPack &gpack1, ModelInstanceGeneralPack &gpack2);

    //Adds frame and timeStamp information to current instance of 'instances'
    void updateCurrentGeneralInfo();

    //FOR USING IN DETECTION OF MORE THAN ONE OBJECT FROM CURRENT EVIDENCE:
    //Generates copy of current mobile: copies models, multimodel, dynamics and history, same id
    SpRMMMobileObject generateCurrentMobile(BoundingBox &bbox);

    //Generates new mobile: copies structure, multimodel, new id
    SpRMMMobileObject generateNewMobile(BoundingBox &bbox);

    //Generates new hypothesis to store new mobiles
    SpRMMHypothesis generateNewHypothesis();

    //OPTIONAL IMPLEMENTATION: Project current bounding box with the dynamics model information.
    //It returns false, if multimodel dynamics are utilized, which is the implemented default behaviour in
    //this class. If implemented in derived class, it MUST return true to signal the existence of the implementation
    virtual bool projectBoundingBox(BoundingBox &bbox);


    static double normalisedSigmaCoherenceReliability(double sigma, double acuity);

    //Tag name
    QString name;

    //Model class name
    QString model_name;


    //Static link to the Multimodel template
    static ReliabilityMultiModelTemplate *m_template;

    //Link to datapool
    Datapool *m_data;

    //Flag for activation according to different criteria
    bool active;

    //Global probability and reliability for model
    double P, R_forward, R_backward;

    //Object classes able to detect (those classes determined by the model)
    std::set<ObjectType> dclasses;

    //Object classes to classify (those classes discriminated by the model, among the different dependant branches)
    std::set<ObjectType> cclasses;


    //Required classes to activate (checked from the dependence) and corresponding class probability in [0; 1]
    std::map<ObjectType, double> rclasses;

    //Reference to the associated mobile object
    RMMMobileObject *m_mobile;

    //Attributes

    //1. Instance buffer
    ModelBuffer instances; //Sets frame information (Here insert new information for frame with updateInstance and updateSingle instance)

    ModelInstanceGeneralPack integratedInfo; //Returned information to be considered as general feedback (automatic)

    ModelInstanceDataPack instanceTemplate;
    static RMMTracker *m_tracker;

    //2. Dynamics model
    ModelDynamicsDataPack prior_dynamics; //Copy of previous tracker iteration info.
    ModelDynamicsDataPack post_dynamics;  //Resulting dynamics for the object (generated by updateDynamics)
                                          //(to start processing dynamics, first do 'post_dynamics = prior_dynamics;')

    //Output bounding box and information after update (forward) process
    BoundingBox binterface_in; //Input roi

    //Output bounding box and information after feedback (backward) process
    BoundingBox binterface_out; //Output roi

    //Access to dependence, or dependants indexes
    //To access a model in the structure do: m_mobile->multiModel.multiModelDAG[index];
    int dependence; //-1 reflects no dependence
    std::vector<int> dependants;

    //Hypotheses structure generated by the model (here copy hypotheses if generated by this model with updateInstance)
    std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> generated_hypotheses;

    //Hypotheses structure returned by the forward process (DO NOT EDIT: it integrates hypotheses of dependants)
    std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> hypotheses;

};

#endif // RELIABILITYSINGLEMODELINTERFACE_H