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

#ifndef _GSOC_SFM_SEQUENCE_ANALYZER_H
#define _GSOC_SFM_SEQUENCE_ANALYZER_H 1

#include "macro.h" //SFM_EXPORTS
#include "PointsToTrackWithImage.h"
#include "MotionProcessor.h"
#include "PointsMatcher.h"
#include "PointOfView.h"
//#include "libmv_mapping.h"
#include "TracksOfPoints.h"
#include "opencv2/calib3d/calib3d.hpp"

namespace OpencvSfM{
  struct MatchingThread;

  class SFM_EXPORTS SequenceAnalyzer
  {
    friend struct MatchingThread;
  protected:
    static int mininum_points_matches;
    static int mininum_image_matches;

    cv::Ptr<cv::FeatureDetector> feature_detector_;
    cv::Ptr<cv::DescriptorExtractor> descriptor_extractor_;
    std::vector< cv::Ptr< PointsToTrack > > points_to_track_;
    std::vector<cv::Mat> images_;
    cv::Ptr<PointsMatcher> match_algorithm_;
    std::vector< cv::Ptr< PointsMatcher > > matches_;
    std::vector<TrackOfPoints> tracks_;
    ImagesGraphConnection images_graph_;
    std::vector< std::vector< cv::Ptr< cv::Mat > > > list_fundamental_;
  public:
    SequenceAnalyzer( MotionProcessor input_sequence,
      cv::Ptr<cv::FeatureDetector> feature_detector,
      cv::Ptr<cv::DescriptorExtractor> descriptor_extractor,
      cv::Ptr<PointsMatcher> match_algorithm );
    SequenceAnalyzer( 
      cv::Ptr<cv::FeatureDetector> feature_detector,
      cv::Ptr<cv::DescriptorExtractor> descriptor_extractor,
      cv::Ptr<PointsMatcher> match_algorithm );
    SequenceAnalyzer(
      std::vector< cv::Ptr< PointsToTrack > > &points_to_track,
      std::vector<cv::Mat> *images = NULL,
      cv::Ptr<PointsMatcher> match_algorithm = NULL );
    SequenceAnalyzer( cv::FileNode file,
      std::vector<cv::Mat> *images = NULL,
      cv::Ptr<PointsMatcher> match_algorithm = NULL );

    ~SequenceAnalyzer( void );
    void addImageToPipeline( cv::Mat image,
      cv::Ptr<PointsToTrack> points = cv::Ptr<PointsToTrack>( ) );
    void addImageToTracks( cv::Mat image,
      cv::Ptr<PointsToTrack> points = cv::Ptr<PointsToTrack>( ) );

    void computeMatches( uchar nbMaxThread = 64, bool printProgress = true );
    static void keepOnlyCorrectMatches(
      std::vector<TrackOfPoints>& tracks,
      unsigned int min_matches = 10,
      unsigned int min_consistance = 3);
    static inline void keepOnlyCorrectMatches(
      SequenceAnalyzer& tracks,
      unsigned int min_matches = 10,
      unsigned int min_consistance = 3)
      {
        keepOnlyCorrectMatches(tracks.getTracks(),min_matches,min_consistance);
      }
    inline std::vector<TrackOfPoints> &getTracks( ){return tracks_;};
    inline std::vector< cv::Ptr< PointsToTrack > > &getPoints( ){
      return points_to_track_;};

    inline ImagesGraphConnection& getImgGraph( )
    {
      if( !images_graph_.isGraphCreated( images_.size( ) ) )
        constructImagesGraph( );
      return images_graph_;
    };
    void showTracks( int timeBetweenImg=25 );
    void showTracks( int img_to_show, int timeBetweenImg );
    cv::Mat showTracksBetween( unsigned int img1, unsigned int img2,
      cv::Mat img = cv::Mat(), bool should_print = true );

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

    static void write( cv::FileStorage& fs, const SequenceAnalyzer& points );

    inline int getNumViews( ) const
    {
      unsigned int maxImg=0;
      std::vector<TrackOfPoints>::size_type key_size = tracks_.size( ),
        i=0;
      for ( i=0; i < key_size; i++ )
      {
        const TrackOfPoints &track = tracks_[ i ];
        int nviews = track.images_indexes_.size( );
        for( int j = 0;j<nviews;++j )
          if( maxImg<track.images_indexes_[ j ] )
            maxImg=track.images_indexes_[ j ];
      }
      return maxImg;
    }

    inline cv::Mat getImage( int idx ) { return images_[ idx ]; };

    void addMatches( std::vector<cv::DMatch> &newMatches,
      unsigned int img1, unsigned int img2 );

    void addTracks( std::vector<TrackOfPoints> &newTracks );
    void constructImagesGraph( );
    std::vector< unsigned int > getColors( );
    std::vector< cv::Vec3d > get3DStructure( );
    void showPointsOnImage(unsigned int i,
      const std::vector<cv::Vec2d>& pixelProjection);

    inline std::vector< cv::Ptr< PointsToTrack > > getPointsToTrack()
    { return points_to_track_; };
    inline cv::Ptr<PointsMatcher> getMatchAlgo()
    { return match_algorithm_->clone( true ); };

    static std::vector< cv::DMatch > simple_matching(
      cv::Ptr<PointsMatcher> point_matcher,
      cv::Ptr<PointsMatcher> point_matcher1,
      unsigned int mininum_points_matches = 10);
    
    static void removePointsWithoutProjection(
      SequenceAnalyzer &motion_estim );
  };

}

#endif