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

#ifndef _GSOC_SFM_POINTS_TO_TRACK_H
#define _GSOC_SFM_POINTS_TO_TRACK_H 1

#include "macro.h" //SFM_EXPORTS and remove annoying warnings

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

#include "config_SFM.h"//semaphore...


namespace OpencvSfM{
  class SFM_EXPORTS TrackOfPoints;

  class SFM_EXPORTS PointsToTrack
  {
  protected:
    DECLARE_MUTEX(worker_exclusion);
    unsigned int nb_workers_;
    std::vector<cv::KeyPoint> keypoints_;
    cv::Mat descriptors_;

    cv::Mat imageToAnalyse_;
    std::vector<unsigned int> RGB_values_;
    int corresponding_image_;
    static int glob_number_images_;

    virtual int impl_computeKeypoints_( ){return 0;};
    virtual void impl_computeDescriptors_( ){};
    void impl_filterByDistance_( double dist_min );
    
  public:
    PointsToTrack( int corresponding_image=-1, std::vector<cv::KeyPoint> keypoints=
      std::vector<cv::KeyPoint>( 0 ), cv::Mat descriptors=cv::Mat( ) );
    virtual ~PointsToTrack( void );
    void free_descriptors( bool force = false );

    int computeKeypointsAndDesc( bool forcing_recalculation=false );
    int computeKeypoints( );
    void computeDescriptors( );
    void addKeypoints( std::vector<cv::KeyPoint> keypoints,cv::Mat descriptors=cv::Mat( ),bool computeMissingDescriptor=false );
    inline unsigned int addKeypoint( const cv::KeyPoint point, double min_dist=1.0 )
    {
      double dist = 1e6;
      P_MUTEX(worker_exclusion);
      size_t nb_points = keypoints_.size(),
        close_p = 0;
      float dist_min = 1e10;
      for(size_t i = 0; i<nb_points ; ++i)
      {
        const cv::KeyPoint& kp = keypoints_[i];
        float dist = sqrt( (point.pt.x - kp.pt.x)*(point.pt.x - kp.pt.x)
          + (point.pt.y - kp.pt.y) * (point.pt.y - kp.pt.y) );
        if( dist<dist_min )
        {
          dist_min = dist;
          close_p = i;
        }
      }
      if( dist_min > min_dist )
      {
        keypoints_.push_back( point );
        close_p = keypoints_.size() - 1;
      }
      V_MUTEX(worker_exclusion);
      return close_p;
    };
    inline std::vector<cv::KeyPoint>& getModifiableKeypoints( ) {return keypoints_;};
    inline const std::vector<cv::KeyPoint>& getKeypoints( ) const {return keypoints_;};
    void getKeyMatches( const std::vector<TrackOfPoints>& matches, int otherImage,
      std::vector<cv::Point2f>& pointsVals ) const;
    inline const cv::KeyPoint& getKeypoint( unsigned int index ) const
    {
      //CV_DbgAssert( index<keypoints_.size( ) );
      return keypoints_[ index ];
    };
    size_t getClosestKeypoint( cv::Point2f point );
    cv::Mat getDescriptors( ) const {return descriptors_;};
    inline cv::Mat getImage( ){return imageToAnalyse_;};
    //
    void printPointsOnImage( const cv::Mat &image, cv::Mat& outImg, const cv::Scalar& color=cv::Scalar::all( -1 ), int flags=cv::DrawMatchesFlags::DEFAULT ) const;

    inline unsigned int getColor( unsigned int index ) const{
      if( index<RGB_values_.size() )
        return RGB_values_[index];
      else
        return 0;
    }
    
    void filterByDistance( double dist_min );

    static void read( const cv::FileNode& node, PointsToTrack& points );

    static void write( cv::FileStorage& fs, const PointsToTrack& points );
  };
}
/*
static inline void cv::write( cv::FileStorage& fs, const std::string& name,
  const OpencvSfM::PointsToTrack& points )
{
  OpencvSfM::PointsToTrack::write( fs,points );
};
static inline void cv::read( const cv::FileNode& node, OpencvSfM::PointsToTrack& points,
  OpencvSfM::PointsToTrack defaultValue = OpencvSfM::PointsToTrack( ) )
{
  OpencvSfM::PointsToTrack::read( node,points );
}
*/
#endif