export.hpp

/* $Id$ */

#ifndef HPM_EXPORT_HPP
#define HPM_EXPORT_HPP

#include <vector>
#include <map>
#include <utility>

#include "fdetect/DetectionResult.hpp"
#include "gfm/MatchingResult.hpp"
#include "hpm/CompatStructures.hpp"

namespace jafar {
  namespace hpm {


    class HarrisPoint {
    public:

      typedef std::vector<HarrisPoint> Vec;

      static const unsigned int NO_ID;

      unsigned int id;

      float u;
      float v;

      float lambdaHigh;
      float lambdaLow;

      HarrisPoint();
      virtual ~HarrisPoint();

      virtual void clear();
    };

    class StereoHarrisPoint : public HarrisPoint {
    public:

      typedef std::vector<StereoHarrisPoint> Vec;

      static const int NO_STEREO_INDEX;

      int stereoIndex;

      StereoHarrisPoint();
      virtual ~StereoHarrisPoint();

      virtual void clear();

    };


#ifndef SWIG
    std::ostream& operator <<(std::ostream& s, const HarrisPoint& p_);
    std::ostream& operator <<(std::ostream& s, const StereoHarrisPoint& p_);
#endif


    struct HpmGroup {
      HpmGroup();
      HarrisPoint points[LOCAL_GROUP_MEMBER_NUM];
      int match_index;
    };

    typedef std::vector<HarrisPoint> vecHarrisPoints;
    
    typedef std::vector<StereoHarrisPoint> vecStereoHarrisPoints;

    typedef std::pair<std::size_t, std::size_t> match;
    //    typedef std::pair<unsigned int, unsigned int> match;

    typedef std::vector<match> vecMatches;

    typedef std::map<std::size_t, std::size_t> mapMatches;

    typedef std::vector<HpmGroup> vecGroups;

    template<class Point>
    void exportHarrisPoints(const jafar::fdetect::DetectionResult & saveResult, 
          std::vector<Point>& points)
    {
      points.resize(saveResult.countInterestFeatures());
      int i = 0;
      for(fdetect::vInterestFeatures_cit it = saveResult.beginFeatures();
          it != saveResult.endFeatures(); it++, i++) {
  points[i].clear();
  points[i].u = (*it)->u();
  points[i].v = (*it)->v();
  points[i].lambdaHigh = (*it)->quality();
  points[i].lambdaLow = (*it)->quality();
      }
    };


    void exportMatches(const jafar::gfm::MatchingResult& gfm_result,
           jafar::hpm::vecMatches& matches);

    void exportMatches(const jafar::gfm::MatchingResult& gfm_result,
           mapMatches& matches);

    void exportStereoMatches(vecMatches const& matches,
           vecStereoHarrisPoints & vecPointsLeft,
           vecStereoHarrisPoints & vecPointsRight);

    template<class PointRef, class PointMatch>
    unsigned int propagateId(vecMatches const& matches,
           std::vector<PointRef> const& vecPointsRef,
           std::vector<PointMatch> & vecPointsMatch)
    {
      unsigned int cpt = 0;
      for (vecMatches::const_iterator it = matches.begin() ; it!=matches.end() ; it++) {
  if (vecPointsRef.at(it->first).id != HarrisPoint::NO_ID) {
    vecPointsMatch.at(it->second).id = vecPointsRef.at(it->first).id;
    cpt++;
  }
      }
      return cpt;
    };

    template<class PointRef, class PointMatch>
    unsigned int backPropagateId(mapMatches const& matches,
         std::vector<PointRef> & vecPointsRef,
         std::vector<PointMatch> const& vecPointsMatch)
    {
      unsigned int cpt = 0;
      for (mapMatches::const_iterator it = matches.begin() ; it!=matches.end() ; it++) {
  if (vecPointsMatch.at(it->second).id != HarrisPoint::NO_ID) {
    vecPointsRef.at(it->first).id = vecPointsMatch.at(it->second).id;
    cpt++;
  }
      }
      return cpt;
    };

  } // namespace hpm
} // namespace jafar

#endif // HPM_EXPORT_HARRIS_HPP