RMMMobileObject.h

#ifndef __RMM_MOBILE_OBJECT_H__
#define __RMM_MOBILE_OBJECT_H__

#include "MODELS/reliabilitymultimodel.h"
#include "src/ModelInterface.h"
#include <iostream>
#include <map>
#include <deque>
#include <QImage>

#define MOBILE_DEBUG_DATA 
#define MOBILE_DETAILS 
#define SHOW_BLOB_BUFFER

class RMMMobileObject;

class RMMTracker;

class hypothesesOrderedByBestProbabilityOperator;

class ReliabilityMultiModelTemplate;
class ReliabilityMultiModel;

typedef QSharedPointer<RMMMobileObject> SpRMMMobileObject;

struct RMMorderedByBestCoherenceOperator {
    bool operator()(SpRMMMobileObject mobile1, SpRMMMobileObject mobile2);
};

struct RMMorderedByMobileIdOperator {
    bool operator()(SpRMMMobileObject mobile1, SpRMMMobileObject mobile2);
};



class RMMMobileObject {
  public:
    static SceneModel *m_context;

    static double m_maxSpeed;
    static int m_currentTrackingBlobsNumber;
    static double m_lambda; //Cooling parameter
    static int m_MultiModelBufferSize;
    static int m_trajectoryMaxSize;
    static double m_knownSolutionThreshold;
    static double m_mobile2DCoverageRateToConsiderEqual;
    static double m_mobile2DCoverageSegmentationToConsiderEqual;
    static double m_mobileMinProbabilityToClassify;

    //Used to find the best type and to update buffer information
    static double m_CoherenceReliabilityThreshold;  //REMOVE FROM PARAMETERS FIRST
    static double m_CoherenceProbabilityThreshold;  //REMOVE FROM PARAMETERS FIRST
    static double m_probabilityToEnsureMode;        //REMOVE FROM PARAMETERS FIRST
    static int m_reliableFrames;
    static double zeroTolerance;

    static double *secDiffSequence;
    static double *secDiffToCurrent;
    static double *coolingValue;
    static ReliabilityMultiModelTemplate *m_modelTemplate;
    static RMMTracker *m_tracker;

    static cv::KalmanFilter m_kalman;

    static bool m_useKalman;
    static int m_kalmanMaxPixelError;

    static SpRMMHypothesis activeHypothesis;//Active Hypothesis on update phase of tracking

    Datapool *m_data;

    unsigned long mobile_id;

    ObjectType best_type;
    ObjectSubtype best_subtype;

    int best_index;

    bool ensureMode; //Flag for indicating when a mobile object becomes "sure" in terms of type.
                     //Important flag for performing coherence validation just for one class type,
                     //optimizing computational cost.

    int numberOfFramesNotSeen, numberOfFramesSinceFirstTimeSeen;

    int currentFrame; //Marks if the mobile information is updated to the current frame (made by updateMobileBufferStructures method)
    long timeStamp;   //Time in milliseconds, corresponding to the time of current frame.
    bool firstUpdate;

    DetectionProblemType currentVisualState;
    bool foundSupport;
    int numberOfFound;

    //General cooling variables:
    double prevCooling, sumCooling;

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

    //Variables used by RMM Tracker
    bool *usedBlobs;
    int numUsed;
    bool *involvedBlobs;
    int numInvolved;
    Rectangle<int> iestimator;
    bool comparedMobile;
    bool toErase;

    int firstForwardModel; //Flag for indicating if model processing completion is required.
                           //It indicates the first processed model index for a new object.
                           //If index is -1, it means no reprocessing is required (for initial object).

    std::deque<SpRMMMobileObject> history; //History of objects before specialization
    int firstFrameSeen; //First frame in sequence where the object appears: useful to establish the history of the object.

    //The multi-model object
    ReliabilityMultiModel multiModel;


    RMMMobileObject(Datapool *i_data, bool init_models=true);
    RMMMobileObject(SpRMMMobileObject m);
    RMMMobileObject(RMMMobileObject *m);
    ~RMMMobileObject();

    //Copy elements when a new object is created from a model
    void copyForNewObject(RMMMobileObject *to_copy);

    //Init functions
    void initUsedBlobs();
    void initInvolvedBlobs();
    static void initKalman();

    //Inserting Functions
    std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> setInitialMultiModel(BoundingBox &bbox);

    //Build new model instances from template and associate pointer to mobile object
    void renewModels();
    //Build new model instances from existing ReliabilityModel and associate pointer to mobile object
    void renewModels(ReliabilityMultiModel &rm);

    //Setting Functions
    void setMobileId(unsigned long i_id);
    void setNewMobileFromBlob(Blob *blob, unsigned long mobile_id);
    void setNumberOfFramesNotSeen(int num);
    void incrementNumberOfFramesNotSeen();
    void incrementNumberOfFramesSinceFirstTimeSeen();
    void setGlobalProbability();
    BoundingBox determineMostLikelyBoundingBox();
    //Getting Functions
    unsigned long getMobileId();
    ObjectType getBestType();
    ObjectSubtype getBestSubType();
    int  getNumberOfFramesNotSeen();
    int  getNumberOfFramesSinceFirstTimeSeen();
    double getGlobalProbability();
    SpReliabilitySingleModelInterface getSubModel(QString);
    SpReliabilitySingleModelInterface getSubModel(QString name, std::deque<SpReliabilitySingleModelInterface> &models);

    bool findSingleModelByName(QString name);

    //Auxiliar fuctions
    static double NormalizeOrientation(double);
    static double minimalAngularDistance(double alpha1, double alpha2);
    static double NormalizeVelocityAngle(double);
    static double coolingFunction(double x);

    std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> updateMobilePath(BoundingBox &bbox, DetectionProblemType dp_type);
    void updateMobileBufferStructures(BoundingBox &bbox, DetectionProblemType dp_type);
    void updateMobileDynamics();
    void initDynamics();

    void initCooling();

    double DimensionalCoherenceReliability(double sigma_dim, double min, double max);

    //Rendering Functions
    friend std::ostream& operator<<(std::ostream&, SpRMMMobileObject);

    //Incremental Implementation for Updating Mobile Information
    void updateBestTypeInformation();
    void incrementalUpdateDynamics(std::deque<SpReliabilitySingleModelInterface> &dyn);
    void updateCooling();
    bool mobileOutOfScene();

    void setMobileReference();

    Rectangle<int> getVisualEvidenceEstimator();
    Rectangle<int> getVisualEvidenceEstimator(double &R);

    void prepareNewMobile(BoundingBox &bbox, unsigned long mobile_id, DetectionProblemType dp_type);
    void prepareExistingMobile(BoundingBox &bbox, DetectionProblemType dp_type);
    bool differentEnoughForWorthyBackReprocessing(SpReliabilitySingleModelInterface current, SpReliabilitySingleModelInterface dependant);
    static bool diffEnoughSegmentation(cv::Mat &current, cv::Mat &dependant);
    void genROIFromFg(cv::Mat &image_roi, BoundingBox &roi);
    void mergeSegmentation(ModelInstanceGeneralPack &m1, ModelInstanceGeneralPack &m2);
    void mergeGeneralPacks(ModelInstanceGeneralPack *packs[], int size, ModelInstanceGeneralPack &result);
    void weightedMergeGeneralPacks(ModelInstanceGeneralPack *packs[], int size, ModelInstanceGeneralPack &result);
    bool oneStrongClass(int index, int &strong_dep_index, ModelInstanceGeneralPack *post[], int size);

    void integrateInsideForeground(ModelInstanceGeneralPack &result, ModelInstanceGeneralPack &toCopy);
    double segmentationSimilarity(ModelInstanceGeneralPack &m1, ModelInstanceGeneralPack &m2);
    double segmentationSimilarity(ModelInstanceGeneralPack &m1, BoundingBox &roi2);
    void cloneSegmentation(ModelInstanceGeneralPack &result, ModelInstanceGeneralPack &copy, bool gen_fg);

    static void genROIFromSpecificSegmentation(cv::Mat &image_roi, BoundingBox &roi, BoundingBox &original_roi, cv::Mat &original_seg);
    static double boundingBoxSimilarity(BoundingBox &b1, BoundingBox &b2);
    static double segmentationSimilarity(cv::Mat &m1, cv::Mat &m2);
    static double classSimilarity(ModelInstanceGeneralPack &m1, ModelInstanceGeneralPack &m2);


    ModelInstanceGeneralPack &generatePostCompletion(int origin, int modelIndex, ModelInstanceGeneralPack &dpack);
    void generatePostCompletion(int modelIndex, ModelInstanceGeneralPack& dpack);

 };



typedef RMMMobileObject* rmm_mobile_object_t;

#endif