Distribution.h

Go to the documentation of this file.

#ifndef DISTRIBUTION_H
#define DISTRIBUTION_H

#include <blort/Tracker/Particle.h>
#include <blort/TomGine/tgQuaternion.h>
#include <blort/TomGine/tgMathlib.h>
#include <blort/Tracker/Resources.h>
#include <blort/Tracker/Timer.h>
#include <blort/Tracker/headers.h>  // stdio.h, stdlib.h, algorithm, gl.h, vector
#include <blort/TomGine/tgVector3.h>

namespace Tracking{

typedef std::vector<Particle> ParticleList;

class Distribution
{
public:
        
        ParticleList m_particlelist;                    
        std::vector<unsigned int> queryMatches; 
        std::vector<unsigned int> queryEdges;   
        Particle m_meanParticle;                                
        
        int v_max;                                                              
        float w_sum;                                                    
        float w_max;                                                    
        float c_max;                                                    
        float c_mean;
        float c_min;
        TomGine::tgVector3 m_cam_view;
        
        // Functions
        
        void updateQueries();
        void drawParticlesEdges(TrackerModel& model, Shader* shadeCompare, bool showparticles=false);
        void drawParticlesTextured(TrackerModel& model, Shader* shadeCompare, bool showparticles=false);
        void calcLikelihood(int convergence=5); 
        
        void calcMean();
        
public:
        Distribution();
        ~Distribution();
        
        Particle                getMean(){ return m_meanParticle; }
        
        float                   getMeanC(){ return m_meanParticle.c; }
        
        Particle                getParticle(int id){ return (m_particlelist[id]); }
        
        double                  getVarianceC();
        
        double                  getVariancePt();
        
        void                    normalizeW();
        
        float                   getMaxW(){ return w_max; }
        
        float                   getMaxC(){ return c_max; }
        
        float                   getMinC(){ return c_min; }
        
        float                   getW(int id){ return m_particlelist[id].w; }
        
        float                   getC(int id){ return m_particlelist[id].c; }
        
        int                     size(){ return m_particlelist.size(); }
        
        void                    copy(ParticleList &list){ list = m_particlelist; }
        
        void                    copyParticle(Particle& p, unsigned int id){ if(id<=m_particlelist.size()) p = m_particlelist[id]; }
        
        void                    clear(){ m_particlelist.clear(); }
        
        void                    push_back(Particle p){ m_particlelist.push_back(p); }
        
        float                   confidenceFunction(const float &m, const float &e);
        
        void            updateLikelihood(TrackerModel& model, Shader* shadeCompare, bool textured, int convergence=5, bool showparticles=false);
        
        void            updateLikelihood(TrackerModel& model, Shader* shadeCompare, TomGine::tgCamera* cam, Texture* tex_edge, int res=256);
        
};

} // namespace Tracking


#endif