model.hpp

/* $Id$ */

#ifndef SAMS_MODEL_HPP
#define SAMS_MODEL_HPP

#include <utility>
#include <algorithm>
#include <iostream>
#include "boost/utility.hpp"
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/split_member.hpp"
#include "boost/serialization/map.hpp"
#include "boost/serialization/string.hpp"

#define USE_JMATH_SERIALIZATION 1

#include "jmath/gaussianVector.hpp"
#include "sams/frame.hpp"
#include "sams/tools.hpp"

namespace jafar {
  namespace sams {

    class Match;
    class Hypothesis;
    class ViewPartLink;

    class ModelPart {
    public:
      ModelPart(int id_=0, double confidence_ = 1.0) : m_id(id_), m_confidence(confidence_) {
        m_trCount = 0;
      };

      int id() const { return m_id; };
      double confidence() const { return m_confidence; };
      jblas::vec const & app() const { return m_desc.x; };
      jblas::sym_mat const & cov() const { return m_desc.P; };
      ViewPartLink const * view(int id_) const {
        std::map<int, ViewPartLink *>::const_iterator it = m_views.find(id_);
        return ( it != m_views.end() ? it->second : NULL);
      };
      std::map<int, ViewPartLink*> const & views() const { return m_views; }; 

      double probabilityDensity(jblas::vec const & v) const {
        return m_desc.probabilityDensity(v);
      };

      //operator==
      bool operator== (ModelPart const & p_) const {
        return ( m_id == p_.m_id);
      };

    private:
      int m_id;
      double m_confidence;
      jafar::jmath::GaussianVector m_desc;
      std::map<int, ViewPartLink *> m_views;
      // match times during learning;
      int m_trCount;

      void update(jblas::vec const & v_);

      friend class Model;

      // serialization
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
        // note, version is always the latest when saving
        ar  & BOOST_SERIALIZATION_NVP(m_id);
        ar  & BOOST_SERIALIZATION_NVP(m_confidence);
        ar  & BOOST_SERIALIZATION_NVP(m_trCount);
        ar & BOOST_SERIALIZATION_NVP(m_desc.x);
        ar & BOOST_SERIALIZATION_NVP(m_desc.P);
        ar  & BOOST_SERIALIZATION_NVP(m_views);
      }
      
      
    }; // class ModelPart


    class ModelView {
    public:
      ModelView(int id_=0) : m_id(id_), m_img() {};

      int centerX;
      int centerY;

      int id() const { return m_id; };
      
      jafar::image::Image const & img() const { return m_img; };
      
      int nbParts() const {
        return m_parts.size();
      };

      ViewPartLink const * getPart(int id_) const {
        std::map<int, ViewPartLink *>::const_iterator it = m_parts.find(id_);
        return ( it != m_parts.end() ? it->second : NULL);
      };

      std::map<int, ViewPartLink*> const & parts() const { return m_parts; };

      bool operator== (ModelView const & v_) const {
        return ( m_id == v_.m_id );
      };

      //SWIG

      ViewPartLink const * first() {
        m_it = m_parts.begin();
        return m_it->second;
      };

      bool hasNext() const {
        std::map<int, ViewPartLink *>::const_iterator tmp = m_it;
        return ( ++tmp != m_parts.end() );
      };

      bool hasPrevious() const {
        return ( m_it != m_parts.begin());
      }

      ViewPartLink const * next() {
        return (++m_it)->second;
      };

      ViewPartLink const * previous() {
        return (--m_it)->second;
      };
      
    private:
      int m_id; 
      jafar::image::Image m_img;
      std::map<int, ViewPartLink *> m_parts;
      mutable std::map<int, ViewPartLink *>::const_iterator m_it;     
      
      // serialization
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
        // note, version is always the latest when saving
        ar  & BOOST_SERIALIZATION_NVP(m_id);
        ar  & BOOST_SERIALIZATION_NVP(m_img);
        ar  & BOOST_SERIALIZATION_NVP(m_parts);
      }
      
      friend class Model;

    }; // class ModelView
//    BOOST_CLASS_VERSION(ModelView, 1);

    class ViewPartLink {
    public:
      ViewPartLink(double x_, double y_, double o_, double s_,
        ModelPart * part_,
        ModelView * view_) : m_pos(4), m_part(part_), m_view(view_), m_trCount(1) {
        m_pos.x(0) = x_; m_pos.x(1) = y_;
        m_pos.x(2) = o_; m_pos.x(3) = s_;
        m_pos.P = jblas::identity_mat(4,4);
      };
      ViewPartLink(jafar::jmath::GaussianVector const & gv_,
        ModelPart * part_,
      ModelView * view_) : m_pos(gv_), m_part(part_), m_view(view_), m_trCount(1) {
      };
      
      double x() const { return m_pos.x(0); };
      double y() const { return m_pos.x(1); };
      double o() const { return m_pos.x(2); };
      double s() const { return m_pos.x(3); };
      jblas::vec const & pos() const { return m_pos.x; };
      jblas::sym_mat const & cov() const { return m_pos.P; };
      ModelPart const * part() const { return m_part; };
      ModelView const * view() const { return m_view; };
      double probabilityDensity(jblas::vec const & v) const {
        return m_pos.probabilityDensity(v);
      };
    
      jblas::vec transform (jblas::mat const & t) const;
      
      
    
    private:
      jafar::jmath::GaussianVector m_pos;
      ModelPart * m_part;
      ModelView * m_view;
      int m_trCount;

      ViewPartLink() {};

      void update(jblas::vec const & v_);

      // serialization
      friend class boost::serialization::access;
      
      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
        // note, version is always the latest when saving
        ar  & BOOST_SERIALIZATION_NVP(m_trCount);
        ar & BOOST_SERIALIZATION_NVP(m_pos.x);
        ar & BOOST_SERIALIZATION_NVP(m_pos.P);
        ar & BOOST_SERIALIZATION_NVP(m_part);
        ar & BOOST_SERIALIZATION_NVP(m_view);
      }

      friend class Model;
    }; // class ViewPartLink

    class Model {
    public:
      //constructor
      Model() : pidcount(0), vidcount(0), m_trFr(0), m_label(), currentView(-1) {
      };  

      Model(std::string const & label,jafar::sams::Frame const & f_);

      ~Model() {
        clear();
      };

      //accessors

      std::string label() const { return m_label; };

      typedef std::map<int, ModelPart *>::const_iterator const_parts_iterator;
      typedef std::map<int, ModelPart *>::iterator parts_iterator;
      const_parts_iterator parts_begin() const { return m_parts.begin(); };
      parts_iterator parts_begin() { return m_parts.begin(); };
      const_parts_iterator parts_end() const { return m_parts.end(); };
      parts_iterator parts_end() { return m_parts.end(); };
      typedef std::map<int, ModelView *>::const_iterator const_views_iterator;
      typedef std::map<int, ModelView *>::iterator views_iterator;
      const_views_iterator views_begin() const { return m_views.begin(); };
      views_iterator views_begin() { return m_views.begin(); };
      const_views_iterator views_end() const { return m_views.end(); };
      views_iterator views_end() { return m_views.end(); };

      ModelView const * view(int id_, bool setCurrent_=false) const {
        const_views_iterator it = m_views.find(id_);
        if ( it != views_end() ) {
          if (setCurrent_) currentView = id_;
          return it->second;
          } else
            return NULL;
        }; 

        ModelPart const * part(int id_) const {
          const_parts_iterator it = m_parts.find(id_);
          return ( it != parts_end() ? it->second : NULL);
        };

      // SWIG
        ModelView const * first() {
          JFR_PRECOND(isInitialized(), "Model::first: model not initialized");
          currentView = 0;
          return views_begin()->second;
        };

        ModelView const * current() const {
          JFR_PRECOND(isInitialized(), "Model::current: model not initialized");
          return m_views.find(currentView)->second;
        }

        bool hasNext() const {
          JFR_PRECOND(isInitialized(), "Model::hasNext: model not initialized");
          const_views_iterator tmp = m_views.find(currentView);
          return ( ++tmp != views_end() );
        };

        bool hasPrevious() const {
          JFR_PRECOND(isInitialized(), "Model::hasPrevious: model not initialized");
          return ( m_views.find(currentView) != views_begin());
        }

        ModelView const * next() {
          JFR_PRECOND(isInitialized(), "Model::next: model not initialized");
          const_views_iterator tmp = m_views.find(currentView);
          currentView = (++tmp)->first;
          return tmp->second;
        };

        ModelView const * previous() {
          JFR_PRECOND(isInitialized(), "Model::previous: model not initialized");
          const_views_iterator tmp = m_views.find(currentView);
          currentView = (--tmp)->first;
          return tmp->second;
        };

      //methodes
        inline int parts_size() const {
          return m_parts.size();
        };

        inline int views_size() const {
          return m_views.size();
        };

        void initialize(jafar::sams::Frame const & f_);

        void addFrame(jafar::sams::Frame const & f_);

        void addView(jafar::sams::Frame const & f_, jafar::sams::Hypothesis const & hyp_);

        void updateView(jafar::sams::Frame const & f_, jafar::sams::Hypothesis const & hyp_);


      private:
        int pidcount;
        int vidcount;
        int m_trFr;
        std::string m_label;
        std::map<int, ModelPart *> m_parts;
        std::map<int, ModelView *> m_views;   

        // serialization
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
          // note, version is always the latest when saving
          ar  & BOOST_SERIALIZATION_NVP(pidcount);
          ar  & BOOST_SERIALIZATION_NVP(vidcount);
          ar  & BOOST_SERIALIZATION_NVP(m_trFr);
          ar  & BOOST_SERIALIZATION_NVP(m_label);
          ar  & BOOST_SERIALIZATION_NVP(m_parts);
          ar  & BOOST_SERIALIZATION_NVP(m_views);
        }

        mutable int currentView;  
        
        inline bool isInitialized() const {
          return (m_parts.size() != 0);
        };      


        inline ModelView * new_view(jafar::image::Image const & img_) {
          ModelView * view = new ModelView(vidcount++);
          m_views[view->m_id]=view;
          view->m_img = img_.clone();
          view->centerX = img_.width()/2;
          view->centerY = img_.height()/2;
          return view;
        };

        inline ModelPart * new_part() {
          ModelPart * part = new ModelPart(pidcount++);
          m_parts[part->m_id]=part;
          return part;
        }

        inline void delete_part(ModelPart * p_) {
          std::map<int, ViewPartLink *>::iterator it = p_->m_views.begin();
          for(; it != p_->m_views.end(); it++) {
            (it->second)->m_view->m_parts.erase(p_->m_id);
            delete it->second;
          } 
          m_parts.erase(p_->m_id);
          delete p_;
        };

        inline void delete_view(ModelView * v_) {
          std::map<int, ViewPartLink *>::iterator it = v_->m_parts.begin();
          for(; it != v_->m_parts.end(); it++) {
            (it->second)->m_part->m_views.erase(v_->m_id);
            delete it->second;
          } 
          m_views.erase(v_->m_id);
          delete v_;  
        };
        
        inline void clear() {
          parts_iterator it = parts_begin();
          // delete all vpl
          for(; it != parts_end(); it++)
            tools::map_delete(it->second->m_views.begin(),it->second->m_views.end());
          tools::map_delete(parts_begin(),parts_end());
          tools::map_delete(views_begin(),views_end());
          m_parts.clear();
          m_views.clear();
        };

      }; // class Model

      class ModelDB {
      public:
      //typedef
        typedef std::map<std::string,Model *>::iterator iterator;
        typedef std::map<std::string,Model *>::const_iterator const_iterator;

      // constructors
        ModelDB() {};
        ModelDB(std::string const & path_) {
          loadDB(path_);
        };

      // iterator accesssors
        iterator begin() {
          return db.begin();
        };
        const_iterator begin() const {
          return db.begin();
        };
        iterator end() {
          return db.end();
        };
        const_iterator end() const {
          return db.end();
        }; 


      // methods
        Model const * operator[] (std::string const & name_) const {
          const_iterator it = db.find(name_);
          return ( it == db.end() ? 0 : it->second );
        };

        Model * operator[] (std::string const & name_) {
          const_iterator it = db.find(name_);
          return ( it == db.end() ? 0 : it->second );
        };

        void insert (std::string const & name_, const Model * model_) {
          JFR_PRECOND( db.find(name_) == db.end(), "ModelDB::insert: already used label");
          db.insert(value_type(name_, const_cast<Model *>(model_)));
        } 

        void remove(std::string const & name_) {
          iterator it = db.find(name_);
          if ( it != db.end() ) {
            delete it->second;
            db.erase(it);
          }
        };

        int size() const {
          return db.size();
        };

        int nbParts() const {
          int acc=0;
          const_iterator it = db.begin();
          for(; it != db.end(); it++) 
            acc += it->second->parts_size();
          return acc;
        };

        static void loadModel(Model & model, std::string const & path);
        static void saveModel(Model & model, std::string const & path);

        void load(std::string const & path_);
        void loadDB(std::string const & path_);
        void save(std::string const & name_, std::string const & path_=".") const;
        void saveDB(std::string const & path_=".") const ;

      private:
        typedef std::map<std::string, Model *>::value_type value_type;
        std::map<std::string, Model *> db;
      }; // class ModelDB


    } // namespace sams
  } // namespace jafar

#endif // SAMS_MODEL_HPP