D:/Travail/These/Determination caracteristiques camera/GSoC/SfM/src/PointsMatcher.h

#ifndef _GSOC_SFM_POINTSMATCHED_H
#define _GSOC_SFM_POINTSMATCHED_H 1

#include "macro.h" //SFM_EXPORTS

#include "opencv2/features2d/features2d.hpp"
#include <vector>

#include "config_SFM.h"  //SEMAPHORE

namespace OpencvSfM{
  class SFM_EXPORTS PointsToTrack;
  class SFM_EXPORTS PointsMatcher
  {
  public:
    PointsMatcher( const cv::Ptr<cv::DescriptorMatcher>& matcher );

    PointsMatcher( const PointsMatcher& copy );
    virtual ~PointsMatcher( );

    static cv::Ptr<PointsMatcher> create( std::string match_algo )
    {
      return cv::Ptr<PointsMatcher>( new PointsMatcher(
        cv::DescriptorMatcher::create( match_algo ) ) );
    };
    virtual void add( cv::Ptr<PointsToTrack> pointCollection );
    virtual void clear( );
    virtual void train( );
    virtual bool isMaskSupported( );
    virtual bool empty( ) const;
    virtual cv::Ptr<PointsMatcher> clone( bool emptyTrainData=true );
    virtual void match( cv::Ptr<PointsToTrack> queryPoints,
      std::vector<cv::DMatch>& matches,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ) );
    virtual void knnMatch( cv::Ptr<PointsToTrack> queryPoints,
      std::vector<std::vector<cv::DMatch> >& matches, int k,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ), bool compactResult = true );
    virtual void radiusMatch( cv::Ptr<PointsToTrack> queryPoints,std::vector<std::vector<cv::DMatch> >& matches, float maxDistance,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ), bool compactResult = true );
    virtual void crossMatch( cv::Ptr<PointsMatcher> otherMatcher,
      std::vector<cv::DMatch>& matches,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ) );

    static void drawMatches( const cv::Mat& img1,
      const std::vector<cv::KeyPoint>& keypoints1,
      const std::vector<cv::KeyPoint>& keypoints2,
      const std::vector<cv::DMatch>& matches1to2, cv::Mat& outImg,
      const cv::Scalar& matchColor=cv::Scalar::all( -1 ),
      const cv::Scalar& singlePointColor=cv::Scalar::all( -1 ),
      const std::vector<char>& matchesMask=std::vector<char>( ),
      int flags=cv::DrawMatchesFlags::DEFAULT
      );
    
    static void read( const cv::FileNode& node, PointsMatcher& points );
    
    static void write( cv::FileStorage& fs, const PointsMatcher& points );

    const cv::KeyPoint &getKeypoint( int numKey ) const;

  protected:
    
    DECLARE_MUTEX( thread_concurr );

    PointsMatcher();

    cv::Ptr<cv::DescriptorMatcher> matcher_;
    std::vector< cv::Ptr< PointsToTrack > > pointCollection_;
  };
  
  class SFM_EXPORTS PointsMatcherOpticalFlow : public PointsMatcher
  {
    int id_algo;
    double max_distance;
  public:
    PointsMatcherOpticalFlow( std::string name_of_algo, double dist_allowed = 2.0 );

    static cv::Ptr<PointsMatcher> create( std::string match_algo, double dist_allowed = 2.0 )
    {
      return cv::Ptr<PointsMatcher>( new PointsMatcherOpticalFlow(
        match_algo, dist_allowed ) );
    };
    virtual void clear( );
    virtual void train( );
    virtual bool isMaskSupported( );
    virtual bool empty( ) const;
    virtual cv::Ptr<PointsMatcher> clone( bool emptyTrainData=true );
    virtual void match( cv::Ptr<PointsToTrack> queryPoints,
      std::vector<cv::DMatch>& matches,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ) );
    virtual void knnMatch( cv::Ptr<PointsToTrack> queryPoints,
      std::vector<std::vector<cv::DMatch> >& matches, int k,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ), bool compactResult = true );
    virtual void radiusMatch( cv::Ptr<PointsToTrack> queryPoints,std::vector<std::vector<cv::DMatch> >& matches, float maxDistance,
      const std::vector<cv::Mat>& masks = std::vector<cv::Mat>( ), bool compactResult = true );
  };

}

#endif