reliabilitymultimodel.h

#ifndef RELIABILITYMULTIMODEL_H
#define RELIABILITYMULTIMODEL_H

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

class Blob;

class RMMMobileObject;

class ReliabilityMultiModel;

class Datapool;

typedef QSharedPointer<ReliabilityMultiModel> SpReliabilityMultiModel;

enum MultiModelDynamicsAttributes {
    WIDTH,
    HEIGHT,
    X,
    Y,
};

class ReliabilityMultiModelTemplate {
public:

    ReliabilityMultiModelTemplate(Datapool *i_data);
    ~ReliabilityMultiModelTemplate();

    //Starts processing of parameters (only for multimodel template)
    bool setParameters(QDomDocument &);

    //Set class structure for quick verification on branching nodes
    void setClassStructure();

    //Completes a branch with class until a branching node is found.
    void iterateClassStructure(SpReliabilitySingleModelInterface model, std::set<ObjectType> &new_classes);

    //Process names for model and model class. Checks availability of classes and unicity of names.
    // (only for multimodel template)
    bool setModelList(QDomElement &parent);

    //Checks model dependences and applies a topological order of models,
    //to allow processing accomplishing dependences. If ordering is
    //not achieved, this means that the Directed Graph is not acyclic (error)
    bool checkDependences(std::map<QString, QString> &dependences, std::deque<QString> &name_list);

    //Process dependences for each model and checks DAG constraint, using topological ordering.
    //Generates pre-loaded lists for backward and forward independent models in DAG, based on dependences.
    void setDependences(std::map<QString, QString> &dependences, std::deque<QString> &ordered_list);

    //Iteratively completes class hierarchy
    void processClassHierarchyList(QDomNodeList &l, ObjectType parent);

    std::vector<SpReliabilitySingleModelInterface> multiModelDAG;
    std::map<QString, int> namePositionMap;
    std::map<int, int> dependants_count;
    std::vector<int> independentModelIndex;
    std::map<ObjectType, ObjectType> class_hierarchy; //Each considered object class (key), and its parent (value). If parent is UNKNOWN, class
                                                      //is root.
    std::vector<ObjectType> parent_classes;           //Parent classes in hierarchy
    Datapool *m_data;
    std::map<int, std::map<int, std::set<ObjectType> > > class_structure; //Each index (key) (-1 for base branches), with a list of dependants indexes of those branches which perform classification.

    std::map<int, std::set<ObjectType> > class_synth_structure; //Each index (key) (-1 for base branches), with an accumulated list of dependant classes which perform classification.

};

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

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

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

class ModelGeneralDynamics {
public:
    ModelGeneralDynamics();
    ReliabilityDynamicsAttribute width;
    ReliabilityDynamicsAttribute height;
    ReliabilityDynamicsAttribute x;
    ReliabilityDynamicsAttribute y;
};

class ModelKalmanPack {
public:
    double z;
    double Rz;
    double accRz;
    double sigmaZ;
    cv::KalmanFilter k;
    double A;    //current acceleration
    double RA;   //
    double varA; //variance of acceleration
    cv::Mat prediction;
    cv::Mat correction;
};

class ModelKalmanDynamics {
public:
    ModelKalmanPack x;
    ModelKalmanPack y;
    ModelKalmanPack width;
    ModelKalmanPack height;
};


class ReliabilityMultiModel {

public:
    ReliabilityMultiModel(Datapool *i_data, int trajectory_max_size, int buffer_size);
    ReliabilityMultiModel(ReliabilityMultiModel *model);
    ~ReliabilityMultiModel();
    //sets activation flags for each model, according to the current context
    void activateModels();
    void activateModels(std::deque<SpReliabilitySingleModelInterface> &);

    //Initializes owner mobile object pointer for every model.
    void init(RMMMobileObject *);
    void init(RMMMobileObject *, std::deque<SpReliabilitySingleModelInterface> &);

    //Gets last Model instance according to its name, else return spointer, with spointer.isNull() == true.
    SpReliabilitySingleModelInterface getSingleModelByName(QString name);
    SpReliabilitySingleModelInterface getSingleModelByClassName(QString className,
                                                                std::vector<SpReliabilitySingleModelInterface> &models);
    SpReliabilitySingleModelInterface getSingleModelByName(QString name,
                                                           std::vector<SpReliabilitySingleModelInterface> &models);

    //Returns true if it finds a Model instance according to its name, else returns false.
    bool findSingleModelByName(QString name);
    bool findSingleModelByName(QString name, std::vector<SpReliabilitySingleModelInterface> &models);

    //forward process of models, starting with non-dependant models.
    void update(BoundingBox &bbox, std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> &hset);

    //Estimator of position of visual evidence
    Rectangle<int> getVisualEvidenceEstimator(double &R);

    void getGlobalProbability(double &R, double &P);

    void set2DTrajectoryPoint();

    void set2DTrajectoryPointEstimation();

    void setPriorDynamics();

    void updateDynamics();

    void setProbabilityAndReliability();


    //Standard attribute dynamics update, with no attribute value constraints
    void updateAttribute(MultiModelDynamicsAttributes name, double data, double RData, ReliabilityDynamicsAttribute &d);

    //Using Kalman Filter considering state vector (x, Vx) and acceleration as a control parameter
    void updateKalmanAttribute(MultiModelDynamicsAttributes name, double data, double RData, ModelKalmanPack &d);
    void initKalmanAttribute(ModelKalmanPack &d, double value, double r);
    void updateKalmanDynamics();
    double setKalmanAcceleration(MultiModelDynamicsAttributes name, double data, double RData, ModelKalmanPack &d, double &R);


    void getBufferAttributeValue(ModelInstanceGeneralPack &pack, MultiModelDynamicsAttributes name, double &value, double &R);
    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 normalisedSigmaCoherenceReliability(double sigma, double acuity);
    double getAttributeEstimate(ReliabilityDynamicsAttribute &d, double time_diff);
    void initAttribute(ReliabilityDynamicsAttribute &d, double value, double r);
    BoundingBox getEstimator(double &R);
    BoundingBox getKalmanEstimator(double &R);

    double projectAttributeValue(ReliabilityDynamicsAttribute &attr, double &R);
    double projectKalmanAttributeValue(ModelKalmanPack &attr, double &R);

    void setValidatedModels(ModelInstanceGeneralPack& p);
    void setMultiModelGeneralInstance(ModelInstanceGeneralPack& p);
    ModelInstanceGeneralPack *completeBranch(int index, ModelInstanceGeneralPack& p);


    static ReliabilityMultiModelTemplate *m_template;
    static int m_pixelAcuity;
    static double m_minimalAttributeVelocityReliability;
    static double m_minimalAttributeAccelerationReliability;

    //accumulatedPclass/accumulatedPclasses_in_branch > m_minimalClassDifferentiationProbability to become a validatedClass (and accumulatedPclass > m_ensureNumber)
    static double m_minimalClassDifferentiationProbability;

    Datapool *m_data;
    RMMMobileObject *mobile;
    std::vector<SpReliabilitySingleModelInterface> multiModelDAG;
    std::map <ObjectType, double> accumulatedClassScore; //Stores the accumulated class score to the object model
    std::set<ObjectType> validatedTypes;
    //History of previously seen positions
    Trajectory trajectory2D;
    Trajectory trajectory2Destimation;
    Trajectory3D trajectory3D;

//    bool active;
    BoundingBox binterface_in;
    BoundingBox binterface_out;

    GeneralModelBuffer buffer;
    ModelGeneralDynamics dynamics;
    ModelKalmanDynamics kdynamics;

    //Global Probabilities
    double P; //Model Coherence        (tracker probability)
    double R; //Input Data Reliability (tracker reliability)

    double currentTimeDiffSeconds;

    int currentCompareModel;

};


typedef QSharedPointer<ReliabilityMultiModel> SpReliabilityMultiModel;


#endif // RELIABILITYMULTIMODEL_H