background.hpp

/* $Id$ */
#ifndef SAMS_BACKGROUND_HPP
#define SAMS_BACKGROUND_HPP

#define USE_JMATH_SERIALIZATION

#include <string>
#include <map>
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/map.hpp"
#include "boost/serialization/string.hpp"
#include "jmath/jblas.hpp"
#include "jmath/pca.hpp"
#include "image/Image.hpp"

namespace jafar {
  namespace sams {

    class BackgroundAnalysis {
    public:
      class Params {
      public:
        int template_width;
        int template_height;
        int nDims;
        double simThd;

        Params(int tw_=11, int th_=11, int nd_=4, double sT_=0.75) :
        template_width(tw_), template_height(th_), nDims(nd_), simThd(sT_) {};

      private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive & ar, const unsigned int version) {
          ar & BOOST_SERIALIZATION_NVP(template_width);
          ar & BOOST_SERIALIZATION_NVP(template_height);
          ar & BOOST_SERIALIZATION_NVP(nDims);
          ar & BOOST_SERIALIZATION_NVP(simThd);
        };

      }; // class Params

      BackgroundAnalysis(Params params_=Params()) : params(params_) {};

      // BackgroundAnalysis(std::string const & fname_) {
      //  load(fname_);
      // };

      ~BackgroundAnalysis() {
        std::map<std::string,Bkg>::iterator it = backgrounds.begin();
        for(; it != backgrounds.end(); it++)
          delete it->second.rec_img;
      };

      //  void load(std::string const & fname_);

      //  void save(std::string const & fname_);

      inline std::vector<std::string> getLabels() const {
        std::vector<std::string> res;
        std::map<std::string, Bkg>::const_iterator it = backgrounds.begin();
        for(;it != backgrounds.end(); it++)
          res.push_back(it->first);
        return res;
      };

        void learnNewBackground(std::string const & label_, std::vector<jafar::image::Image> const & vImg_);

        void updateBackground(std::string const & label_, jafar::image::Image const & img_);

        bool checkSimilarity(jafar::image::Image const & img_) const;


    private:
      Params params;

      // internal structure
      struct Bkg {
        jafar::image::Image * rec_img;
        jafar::jmath::PCA pca;
        
        template<class Archive>
        void serialize (Archive & ar, const unsigned int version) {
          ar & BOOST_SERIALIZATION_NVP(rec_img);
          ar & BOOST_SERIALIZATION_NVP(pca);
        }
      };

      std::map<std::string, Bkg> backgrounds;

      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int version) {
        ar & BOOST_SERIALIZATION_NVP(params);
        ar & BOOST_SERIALIZATION_NVP(backgrounds);
      };

      // internal functions
      jblas::vec img2vec(jafar::image::Image const & img_) const;
      jafar::image::Image * vec2img(jblas::vec const & vec_) const;

    }; // class BackgroundAnalysis
  }
}

#endif // SAMS_BACKGROUND_HPP