ArFeaturedMarker.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
/*
 Toolkit based on OpenCV library
 First version : dec 2010
 Author : Bastien BOURINEAU
*/
 
#ifndef __BTK_FEATUREDMARKER_H__
#define __BTK_FEATUREDMARKER_H__
 
#include <vector>
#include <iostream>
#include "opencv2/features2d/features2d.hpp"
#include "cameraparameters.h"
#include "ArMarker.h"
#include "Prerequisites.h"
#include <boost/thread.hpp>
#include <iostream>
 
class RobustMatcher {
public:
  RobustMatcher();
  virtual ~RobustMatcher();
 
  // Set the feature detector
  void setFeatureDetector(const cv::Ptr<cv::FeatureDetector>& detect) { detector_ = detect; }
 
  // Set the train feature detector
  void setTrainFeatureDetector(const cv::Ptr<cv::FeatureDetector>& detect) { traindetector_ = detect; }
 
  // Set the matcher
  void setDescriptorMatcher(const cv::Ptr<cv::DescriptorMatcher>& match) { matcher_ = match; }
 
  // Set ratio parameter for the ratio test
  void setRatio(float rat) { ratio_ = rat; }
 
  // Clear matches for which NN ratio is > than threshold
  // return the number of removed points
  // (corresponding entries being cleared,
  // i.e. size will be 0)
  int ratioTest(std::vector<std::vector<cv::DMatch> > &matches);
 
  // Insert symmetrical matches in symMatches vector
  void symmetryTest(const std::vector<std::vector<cv::DMatch> >& matches1, const std::vector<std::vector<cv::DMatch> >& matches2, std::vector<cv::DMatch>& symMatches);
 
  // Match feature points using ratio and symmetry test
  void robustMatch(const cv::Mat& frame, std::vector<cv::DMatch>& good_matches, std::vector<cv::KeyPoint>& keypoints_frame, const cv::Mat& descriptors_model, const cv::Mat& mask);
 
  // Match feature points using ratio test
  void fastRobustMatch(const cv::Mat& frame, std::vector<cv::DMatch>& good_matches, std::vector<cv::KeyPoint>& keypoints_frame, const cv::Mat& mask);
 
  bool addTrainData(const cv::Mat& frame, std::vector<cv::KeyPoint> &marker_keypoints);
 
private:
  // pointer to the feature point detector for training
  cv::Ptr<cv::FeatureDetector> traindetector_;
  // pointer to the feature point detector object
  cv::Ptr<cv::FeatureDetector> detector_;
  // pointer to the matcher object
  cv::Ptr<cv::DescriptorMatcher> matcher_;
  // max ratio between 1st and 2nd NN
 
  /*
  // pointer to the feature point detector object
  cv::FeatureDetector* detector_;
  // pointer to the feature descriptor extractor object
  cv::DescriptorExtractor* extractor_;
  // pointer to the matcher object
  cv::DescriptorMatcher* matcher_;
  */
 
  // max ratio between 1st and 2nd NN
  float ratio_;
};
 
class ArFeaturedMarker : public ArMarker
{
protected:
  cv::Mat m_image;
  cv::Mat m_dmask;
  bool m_lastFound;
  std::vector<cv::Point2f> m_prevFramePoints;
  std::vector<cv::Mat> m_prevPyr;
  std::vector<cv::Mat> m_nextPyr;
 
public:
  std::vector<cv::Point2f> m_lastCorner;
 
  ArFeaturedMarker(std::string filePath, unsigned int nid, float size, unsigned int maxFeatures = 600);
  
  ArFeaturedMarker(cv::Mat tpl, unsigned int nid, float size, unsigned int maxFeatures = 600);
 
  ArFeaturedMarker(unsigned int nid, float size);
 
  virtual ~ArFeaturedMarker();
 
  void SetTrackedImage(cv::Mat tpl);
 
  void RegisterNextFrame(cv::Point point, cv::Size size);
 
  bool GetWarpedMarker(cv::Mat &image);
 
  void calculateFeaturedExtrinsics(float markerSize, aruco::CameraParameters& camParams, bool setYPerpendicular = true);
 
  bool detectFeatured(cv::Mat &frame, cv::Mat &color, cv::Size camsize);
 
  void Update(cv::Mat frame, cv::Mat color, aruco::CameraParameters& camparam, bool reverse);
private:
  boost::mutex m_mutex;
  int64 m_lastTick;
  unsigned int m_maxFeatures;
  std::string m_file;
  cv::Mat m_warped;
  unsigned int m_minMatches;
  double m_HomographyThreshold;
 
  std::vector<cv::Point2f> m_prevTrainPoints;
  std::vector<cv::Point2f> m_pcorners;
  cv::Size m_lastFrameSize;
 
  cv::Ptr<cv::FeatureDetector> m_detector;
  cv::Ptr<cv::DescriptorMatcher> m_matcher;
 
  RobustMatcher* m_robustMatcher;
  std::vector<cv::KeyPoint> m_trainKeypoints;
  bool m_registerNextFrame;
  bool m_KalmanInit;
  cv::Point m_cropPos;
  cv::Size m_cropSize;
  FilterDoubleExponential m_CornerSmoothers;
 
  bool trainMatcher();
 
  bool initTrackingPicture();
 
  void CommonConstructor();
 
 
  bool GetPointsFromMatches(const std::vector<cv::KeyPoint> &querykeypoints, const std::vector<cv::KeyPoint> &trainKeypoints, std::vector<cv::DMatch> matches, std::vector<cv::Point2f> &trainPoints, std::vector<cv::Point2f> &framePoints);
 
  bool GetHomography(std::vector<cv::Point2f> &trainPoints, std::vector<cv::Point2f> &framePoints, cv::Mat &HMatrix);
 
  bool detectMotionFlow(cv::Mat &frame, cv::Mat &color, const std::vector<cv::Point2f> &trainPoints, const std::vector<cv::Point2f> &framePoints, std::vector<cv::Point2f> &gtrainPoints, std::vector<cv::Point2f> &gframePoints);
 
  bool GetCorners(cv::Mat &HMatrix);
};
 
#endif