MatchingResult.hpp

/* $Id$ */

#ifndef _GFM_MATCHING_RESULT_HPP_
#define _GFM_MATCHING_RESULT_HPP_

#include <boost/serialization/nvp.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/shared_ptr.hpp>

#include "fdetect/InterestFeature.hpp"
#include "fdetect/DetectionResult.hpp"

namespace jafar {
  namespace gfm {
    struct Match {
      Match(fdetect::InterestFeature* p_r, fdetect::InterestFeature* p_m, int i) :
        point_ref(p_r), point_match(p_m), index(i)
      {
      }
      fdetect::InterestFeature* point_ref;
      fdetect::InterestFeature* point_match;
      int index;
      // template<class Archive>
      // void serialize(Archive &ar, const unsigned int version) 
      // {
      //  ar & BOOST_SERIALIZATION_NVP(point_ref);
      //  ar & BOOST_SERIALIZATION_NVP(point_match);
      //  ar & index;
      // }
    };
    typedef std::vector<Match> vMatches;
    typedef std::vector<Match>::iterator vMatches_it;
    class MatchingResult {
      struct Shared;
    public:
        
      MatchingResult();
      MatchingResult(const jafar::fdetect::DetectionResult& pr, const jafar::fdetect::DetectionResult& pm );
      MatchingResult(const MatchingResult&);
      MatchingResult& operator=(const MatchingResult&);
      /*
       * Performs a deep copy of the matches to the destination. Note: only the 
       * vector m_shared->matches is copied. m_shared->points_ref and 
       * m_shared->points_match are not copied. Use this function carefully!
       */
      // void deepCopy( MatchingResult &dst );

      ~MatchingResult();
    public:
      void addMatch(fdetect::InterestFeature* ip1, fdetect::InterestFeature* ip2);
      void merge( jafar::gfm::vMatches m);
      void propageId();
      void propageStereoIndex();
      void propagateId( unsigned int &idVal );
      std::size_t nbMatches() const;
      const jafar::fdetect::DetectionResult& pointsRef() const;
      const jafar::fdetect::DetectionResult& pointsMatch() const;
      vMatches& matches() const;
      bool valid() const { return (m_shared!=NULL); }
    private:
      void unref();
      Shared* m_shared;
      // friend class boost::serialization::access;
      // template<class Archive>
      // void save(Archive &ar, const unsigned int version) const
      // {
      //  // ar & BOOST_SERIALIZATION_NVP(pointsRef());
      //  // ar & BOOST_SERIALIZATION_NVP(pointsMatch());
      //  size_t count = nbMatches();
      //  ar & BOOST_SERIALIZATION_NVP(count);
      //  for(vMatches_it it = matches().begin(); it != matches().end(); ++it) {
      //    ar & BOOST_SERIALIZATION_NVP(it->point_ref);
      //    ar & BOOST_SERIALIZATION_NVP(it->point_match);
      //  }
      // }
      // template<class Archive>
      // void load(Archive &ar, const unsigned int version)
      // {
      //  size_t nb;
      //  ar & BOOST_SERIALIZATION_NVP(nb);
      //  for(unsigned int counter = 0; counter < nb; ++counter) {
      //    fdetect::InterestFeature *ref, *match;
      //    ar & BOOST_SERIALIZATION_NVP(ref);
      //    ar & BOOST_SERIALIZATION_NVP(match);
      //    this->addMatch(ref, match);
      //  }
      //  assert(nbMatches() == nb);
      // }
      // BOOST_SERIALIZATION_SPLIT_MEMBER()
    };
  }

  namespace gfm_v2 {
    template<typename InterestFeatureT>
    struct Match {
      Match(InterestFeatureT* p_r, 
            InterestFeatureT* p_m, int i) :
        point_ref(p_r), point_match(p_m), index(i)
      {
      }
      InterestFeatureT* point_ref;
      InterestFeatureT* point_match;
      int index;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version) 
      {
        ar & BOOST_SERIALIZATION_NVP(point_ref);
        ar & BOOST_SERIALIZATION_NVP(point_match);
        ar & index;
      }
    };
    template<typename InterestFeatureT>
    class MatchingResult {
    public:
      typedef typename gfm_v2::Match< InterestFeatureT > MatchType;
      typedef std::vector< MatchType > vMatches;
      typedef typename std::vector< MatchType >::iterator iterator;
      typedef typename std::vector< MatchType >::const_iterator const_iterator;
      typedef fdetect_v2::DetectionResult<InterestFeatureT> DetectionResult;

    private:
      struct Shared {
        Shared() {};
        Shared(const DetectionResult& pr, 
               const DetectionResult& pm )
          : points_ref(pr), points_match(pm) { }
        vMatches matches;
        DetectionResult points_ref;
        DetectionResult points_match;
      };

      boost::shared_ptr<Shared> m_shared;

    public:
      MatchingResult() : m_shared(new Shared()) {};
      MatchingResult(const DetectionResult& pr, 
                     const DetectionResult& pm ) :
        m_shared(new Shared(pr,pm)) {};
      MatchingResult(const MatchingResult& mr) :
        m_shared(mr.m_shared) {};
      
      ~MatchingResult() {};
    public:
      void addMatch(InterestFeatureT* ip1, 
                    InterestFeatureT* ip2) 
      {
        m_shared->matches.push_back(Match<InterestFeatureT>(ip1, ip2, m_shared->matches.size()));
      }
      void push_back(InterestFeatureT* ip1, 
                     InterestFeatureT* ip2) 
      {
        m_shared->matches.push_back(MatchType(ip1, ip2, m_shared->matches.size()));
      }
      iterator begin() 
      {
        return m_shared->matches.begin();
      }
      iterator end() 
      {
        return m_shared->matches.end();
      }
      const_iterator begin() const
      {
        return m_shared->matches.begin();
      }
      const_iterator end() const
      {
        return m_shared->matches.end();
      }
      size_t size() const
      {
        return m_shared->matches.size();
      }
      void merge( const vMatches &m)
      {
        for(iterator it = m.begin(); it != m.end(); ++it)
        {
          Match<InterestFeatureT> m = *it;
          m.index = m_shared->matches.size();
          m_shared->matches.push_back(m);
        }
      }
      void propageId()
      {
        for( iterator it = m_shared->matches.begin(); 
             it != m_shared->matches.end(); 
             ++it)
        {
          it->point_match->setId( it->point_ref->id() );
        }
      }
      void propageStereoIndex()
      {
        for( iterator it = m_shared->matches.begin(); 
             it != m_shared->matches.end(); 
             ++it)
        {
          it->point_match->setStereoIndex(it->point_ref->index());
          it->point_ref->setStereoIndex(it->point_match->index());
        }
      }
      void propagateId( unsigned int &idVal )
      {
        for( iterator it = m_shared->matches.begin(); 
             it != m_shared->matches.end(); 
             ++it)
        {
          if (it->point_ref->id() == geom::InterestPoint::NO_ID)
          {
            if (it->point_ref->id() == geom::InterestPoint::NO_ID)
            {
              it->point_match->setId( idVal );
              it->point_ref->setId( idVal );
              ++idVal;
            }
            else
            {
              it->point_match->setId( it->point_ref->id() );
            }
          }
          else
          {
            it->point_match->setId( it->point_ref->id() );
          }
        }
      }
      std::size_t nbMatches() const
      {
        return m_shared->matches.size();
      }
      const DetectionResult& pointsRef() const
      {
        return m_shared->points_ref;
      }
      const DetectionResult& pointsMatch() const
      {
        return m_shared->points_match;
      }
      vMatches& matches() const
      {
        return m_shared->matches;
      }
      bool valid() const 
      { 
        return (m_shared!=NULL); 
      }
      void clear() 
      {
        m_shared->matches.clear();
      }
      void erase(size_t pos)
      {
        iterator it = begin();
        it+=pos;
        m_shared->matches.erase(it);
      }
    //  !!! nizar 20100912 : serialization stuff
    //  friend class boost::serialization::access;
    //  template<class Archive>
    //  void save(Archive &ar, const unsigned int version) const
    //  {
    //    // ar & BOOST_SERIALIZATION_NVP(pointsRef());
    //    // ar & BOOST_SERIALIZATION_NVP(pointsMatch());
    //    size_t count = nbMatches();
    //    ar & BOOST_SERIALIZATION_NVP(count);
    //    for(vMatches_it it = matches().begin(); it != matches().end(); ++it) {
    //      ar & BOOST_SERIALIZATION_NVP(it->point_ref);
    //      ar & BOOST_SERIALIZATION_NVP(it->point_match);
    //    }
    //  }
    //  template<class Archive>
    //  void load(Archive &ar, const unsigned int version)
    //  {
    //    size_t nb;
    //    ar & BOOST_SERIALIZATION_NVP(nb);
    //    for(unsigned int counter = 0; counter < nb; ++counter) {
    //      fdetect::InterestFeature *ref, *match;
    //      ar & BOOST_SERIALIZATION_NVP(ref);
    //      ar & BOOST_SERIALIZATION_NVP(match);
    //      this->addMatch(ref, match);
    //    }
    //    assert(nbMatches() == nb);
    //  }
    //  BOOST_SERIALIZATION_SPLIT_MEMBER()
    };
    template<typename T>
    std::ostream& operator <<(std::ostream& s, const MatchingResult<T> &mr)
    {
      using namespace std;
      for(typename MatchingResult<T>::const_iterator mit = mr.begin(); 
          mit != mr.end(); 
          ++mit) {
        s << "ref "<< mit->point_ref->parent_id << "," << mit->point_ref->index();
        s << "\tmatch "<< mit->point_match->parent_id << "," << mit->point_match->index();
        s << endl;
      }
      return s;
    }
  }
}

#endif