ModelEntry.h

Go to the documentation of this file.

#ifndef _MODEL_ENTRY_H_
#define _MODEL_ENTRY_H_

#include <blort/TomGine/tgMathlib.h>
#include <blort/Tracker/TrackerModel.h>
#include <blort/Tracker/Distribution.h>
#include <blort/Tracker/Predictor.h>
#include <blort/Tracker/Filter.h>

namespace Tracking{

enum quality_state{
        ST_OK,
        ST_OCCLUDED,
        ST_LOST,
        ST_LOCKED,
};

enum confidence_state{
        ST_GOOD,
        ST_FAIR,
        ST_BAD,
};

enum movement_state{
        ST_FAST,
        ST_SLOW,
        ST_STILL,
};

class ModelEntry
{
private:
        void poseDiff(float &t, float &a);
        void speed();

        float max(float a, float b){ return (((a) > (b)) ? (a) : (b)); }
        float abs(float a){ return ((a>=0.0f) ? a : (-a)); }
        
        
        
public:
        ModelEntry();
        ModelEntry(const TomGine::tgModel& m);
        ~ModelEntry();
        
        void setInitialPose(const TomGine::tgPose &p, float lpf_delay=0.0f, float lpf_delay_z=0.0f);
        void filter_pose();
        void evaluate_states(   const Particle &variation, unsigned rec,
                                                        float c_th_base=0.6f, float c_th_min=0.3f, float c_th_fair=0.5f,
                                                        float c_mv_not=0.01f, float c_mv_slow=0.05f, float c_th_lost=0.1f);
        
        std::string label;
        
        float t, a, t_max, a_max, c_edge, c_th, c_lost, abs_a, abs_t;
        
        movement_state st_movement;                             
        confidence_state st_confidence;                 
        quality_state st_quality;                               
        
        TrackerModel            model;                          
        Distribution            distribution;           
        Predictor*                      predictor;                      
        Texture*                        mask;                           
        Particle                        pose;                           
        Particle                        pose_prev;                      
        Particle                        lpf_pose;               
        Particle                        initial_pose;           
        
        float   speed_angular;                                  
        float   speed_translational;                    

        float   confidence_color;                               
        float   confidence_edge;                                
        
        int     id;                                                     
        unsigned        num_convergence;                        
        unsigned        hypothesis_id;                          
        std::vector<float> past_confidences;    
        unsigned        num_particles;                          
        unsigned        num_recursions;                         
        
        bool            bfc;                                            
        bool            lock;                                           
        bool            mask_geometry_edges;            
        
        mat4 modelviewprojection;                               
        TomGine::tgVector3 vCam2Model;                  
        
private:
        Predictor* del_predictor;
        SmoothFilter m_lpf_pose_tx;
        SmoothFilter m_lpf_pose_ty;
        SmoothFilter m_lpf_pose_tz;
        SmoothFilter m_lpf_pose_qx;
        SmoothFilter m_lpf_pose_qy;
        SmoothFilter m_lpf_pose_qz;
        SmoothFilter m_lpf_pose_qw;

public:
        SmoothFilter m_lpf_a;
        SmoothFilter m_lpf_t;
        SmoothFilter m_lpf_cs;
        SmoothFilter m_lpf_cl;

};

} // namespace Tracking

#endif