irt.hpp

/* $Id$ */
#ifndef SAS_IRT_HPP
#define SAS_IRT_HPP

#include "kernel/keyValueFile.hpp"
#include "image/Image.hpp"
#include <cvaux.h> // opencv
#include "sas/irdm.hpp"
#include "sas/ird.hpp"

namespace jafar {
  namespace sas {
    
    struct SRoi : public CvBlob{
      float angle;

      SRoi (float x_=0, float y_=0, float width_=0, float height_=0, float angle_=0) {
        x=x_; y=y_; w=width_; h=height_; ID=0; angle=angle_;
      };
    };
    
    
    class CS_IRT {
    public:
      CS_IRT() : isInitialized(false), isObject2TrackSet(false), tracker() {};
      
      ~CS_IRT() {};
      
      void initialize(int nbins_=16);
      
      void setObject2Track(const jafar::image::Image& src_,
         CvRect const & rect);
      
      SRoi trackObject(const jafar::image::Image& img_);
      
    private:
      bool isInitialized;
      bool isObject2TrackSet;
      CvCamShiftTracker tracker;      
    }; // class CS_IRT
    
    
    class CV_IRT_BlobDetector : public CvFGDetector, /* public CvBlobDetector, */ public jafar::sas::IRD {
    public:
      CV_IRT_BlobDetector (IRDM * dm): CvFGDetector(), /* CvBlobDetector(), */ jafar::sas::IRD (dm), m_dm(dm) {};
      virtual ~CV_IRT_BlobDetector () {};

      virtual IplImage* GetMask() {
        return m_mask;
      };
      virtual void    Process(IplImage* pImg=0) {
        computeSaliency();
        if ( !m_mask || m_dm->m_imgs["src"].width() != m_dm->m_imgs["src"].width() || m_mask.height() != m_dm->m_imgs["src"].height() )
          m_mask = jafar::image::Image(m_dm->m_imgs["src"].width(),m_dm->m_imgs["src"].height(),IPL_DEPTH_8U,JfrImage_CS_GRAY); 
        jafar::image::Image tmp = m_dm->m_imgs["saliency"].clone();
        cvNormalize(tmp,tmp,0.,255.,CV_MINMAX); 
        tmp.resize(m_mask.width(),m_mask.height());
        cvConvertScale(tmp,m_mask);
      };
      virtual void Release() {};

    private:
      IRDM * m_dm;
      jafar::image::Image m_mask;
    }; /* class BlobDetector */
    
    
    class CV_IRT {
    public:
            
      CV_IRT (IRDM * dm) : m_dm(dm), m_cvparams(), m_tracker(0), pMask(0) {
        m_cvparams.pBT = 0;
        m_cvparams.pBD = 0;
        m_cvparams.pBTGen = 0;
        m_cvparams.pBTA = 0;
        m_cvparams.pFG = 0;
        m_cvparams.pBTPP = 0;
      };
      
      virtual ~CV_IRT () {
        release();
      };

      void init();

      void release();
      
      void process(jafar::image::Image & display);

    private:
      IRDM * m_dm;
      CvBlobTrackerAutoParam1 m_cvparams;
      CvBlobTrackerAuto * m_tracker;
      IplImage*   pMask;
    };
    
    
    class BK_IRT {
    public:
      
      class Params : public jafar::kernel::KeyValueFileLoad {
      public:
        float m_thd_confidence; 
        float m_ModelNoise; 
        float m_DataNoisePos; 
        float m_DataNoiseSize; 
    
        Params(float tdc=0.5, float mn=1e-5f, float dnp=1e-1f, float dns= 1e-1f) :
        m_thd_confidence(tdc), m_ModelNoise(mn),m_DataNoisePos(dnp),m_DataNoiseSize(dns) {};
      protected:
        void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile);
      }; /* struct Params */
      
      
      BK_IRT (IRDM * dm, Params params=Params()) : m_dm(dm), m_params(params) {};
      
      static inline BK_IRT * createBKIRT(IRDM * dm, std::string const & filename) {
        BK_IRT::Params params;
        params.load(filename);
        return new BK_IRT(dm,params);
      };
      virtual ~BK_IRT ();

      void process();
      
      void draw(jafar::image::Image & display);

    private:
      // internal structures
      struct tracker {
        CvKalman* m_Kalman;
        sTrack * m_track;
        sir * m_predict;
        
        ~tracker() {
          cvReleaseKalman(&m_Kalman);
          delete m_predict;
          m_track->m_tracked = false;
        };
        
        float getConfidence(sir * s, int w_);

        void update(sir * s);
      }; /* struct tracker */
      
      // members
      IRDM * m_dm;
      Params m_params;
      std::list<tracker *> m_trackers;
      std::list<sir *> m_candidates;
      
      // private methods
      tracker * startTracker(sir * s, sir * c);
      tracker * endTracker(tracker * tr);     
      float getConfidence(sir * s, sir * c, int w_);
      
    }; /* class BK_IRT */
    
  } // namespace sas
} // namespace jafar

#endif // SAS_IRT_HPP