#include <keypoint_detector.h>

Public Member Functions
	KeypointDetector ()

	~KeypointDetector ()

bool	SetDetector (const std::string &detector_type)

bool	DetectKeypoints (const Image &image, KeypointList &keypoints_out)

void	SetAdaptiveOn (unsigned int min, unsigned int max, unsigned int iters)

void	SetAdaptiveOff ()

bool	SupportsAdaptiveAdjustment () const

Private Attributes
std::string	detector_type_

cv::Ptr< cv::FeatureDetector >	detector_

bool	adaptive_

unsigned int	adaptive_min_

unsigned int	adaptive_max_

unsigned int	adaptive_iters_

Detailed Description

Definition at line 51 of file keypoint_detector.h.

Constructor & Destructor Documentation

bsfm::KeypointDetector::KeypointDetector ( )

Definition at line 44 of file keypoint_detector.cpp.

     : adaptive_(false),
       adaptive_min_(0),
       adaptive_max_(0),
       adaptive_iters_(0) {
   cv::initModule_nonfree();
 }

bsfm::KeypointDetector::~KeypointDetector ( )

inline

Definition at line 54 of file keypoint_detector.h.

54 {}

Member Function Documentation

bool bsfm::KeypointDetector::DetectKeypoints	(	const Image &	image,
		KeypointList &	keypoints_out
	)

Definition at line 148 of file keypoint_detector.cpp.

                                                                     {
   // Make the user has called SetDetector().
   if (detector_type_.empty()) {
     VLOG(1) << "Detector has not been specified via SetDetector(). Failed to "
                "detect keypoints.";
     return false;
   }
   CHECK(detector_) << "The feature detector is null.";
 
   // Clear the output.
   keypoints_out.clear();
 
   // Convert the input image to OpenCV's format. Note that features must be
   // detected on the grayscale image, and that the image format must be CV_8U.
   cv::Mat cv_image;
   image.ToCV(cv_image);
   cv_image.convertTo(cv_image, CV_8U, 255);
 
   // Detect keypoints in the image.
   try {
     detector_->detect(cv_image, keypoints_out);
   } catch (const std::exception& e) {
     VLOG(1) << "Failed to detect keypoints: " << e.what();
     return false;
   }
 
   return true;
 }

void bsfm::KeypointDetector::SetAdaptiveOff ( )

Definition at line 200 of file keypoint_detector.cpp.

                                       {
 if (!SupportsAdaptiveAdjustment()) {
   VLOG(1) << "The detector type \"" << detector_type_
           << "\" does not support adaptive feature count adjustment, and "
              "therefore is already static.";
     return;
   }
 
   adaptive_ = false;
   adaptive_min_ = 0;
   adaptive_max_ = 0;
   adaptive_iters_ = 0;
 
   // If the feature detector is already set, re-initialize it.
   if (detector_ != nullptr) {
     SetDetector(detector_type_);
   }
 }

void bsfm::KeypointDetector::SetAdaptiveOn	(	unsigned int	min,
		unsigned int	max,
		unsigned int	iters
	)

Definition at line 179 of file keypoint_detector.cpp.

                                                          {
   if (!SupportsAdaptiveAdjustment()) {
     VLOG(1) << "The detector type \"" << detector_type_
             << "\" does not support adaptive feature count adjustment. Type "
                "must be one of {FAST, SURF, STAR}";
     return;
   }
 
   adaptive_ = true;
   adaptive_min_ = min;
   adaptive_max_ = max;
   adaptive_iters_ = iters;
 
   // If the feature detector is already set, re-initialize it.
   if (detector_ != nullptr) {
     SetDetector(detector_type_);
   }
 }

bool bsfm::KeypointDetector::SetDetector ( const std::string & detector_type )

Definition at line 52 of file keypoint_detector.cpp.

                                                                  {
   // Set the detector type.
   detector_type_ = detector_type;
   bool valid_detector_type = true;
 
   // Create an OpenCV feature detector. SURF, FAST, and STAR support adjusters.
   if (detector_type.compare("SURF") == 0) {
 
     if (adaptive_) {
       cv::Ptr<cv::AdjusterAdapter> adjuster(
           cv::AdjusterAdapter::create("SURF"));
       detector_ =
           cv::Ptr<cv::FeatureDetector>(new cv::DynamicAdaptedFeatureDetector(
               adjuster, adaptive_min_, adaptive_max_, adaptive_iters_));
     } else {
       detector_ = cv::FeatureDetector::create("SURF");
     }
 
   } else if (detector_type.compare("FAST") == 0) {
 
     if (adaptive_) {
       cv::Ptr<cv::AdjusterAdapter> adjuster(
           cv::AdjusterAdapter::create("FAST"));
       detector_ =
           cv::Ptr<cv::FeatureDetector>(new cv::DynamicAdaptedFeatureDetector(
               adjuster, adaptive_min_, adaptive_max_, adaptive_iters_));
     } else {
       detector_ = cv::FeatureDetector::create("FAST");
     }
 
   } else if (detector_type.compare("STAR") == 0) {
 
     if (adaptive_) {
       cv::Ptr<cv::AdjusterAdapter> adjuster(
           cv::AdjusterAdapter::create("STAR"));
       detector_ =
           cv::Ptr<cv::FeatureDetector>(new cv::DynamicAdaptedFeatureDetector(
               adjuster, adaptive_min_, adaptive_max_, adaptive_iters_));
     } else {
       detector_ = cv::FeatureDetector::create("STAR");
     }
 
   } else if (detector_type.compare("SIFT") == 0) {
 
     detector_ = cv::FeatureDetector::create("SIFT");
 
   } else if (detector_type.compare("ORB") == 0) {
 
     detector_ = cv::FeatureDetector::create("ORB");
 
   } else if (detector_type.compare("BRISK") == 0) {
 
     detector_ = cv::FeatureDetector::create("BRISK");
 
   } else if (detector_type.compare("MSER") == 0) {
 
     detector_ = cv::FeatureDetector::create("MSER");
 
   } else if (detector_type.compare("GFTT") == 0) {
 
     detector_ = cv::FeatureDetector::create("GFTT");
 
   } else if (detector_type.compare("HARRIS") == 0) {
 
     detector_ = cv::FeatureDetector::create("HARRIS");
 
   } else if (detector_type.compare("DENSE") == 0) {
 
     detector_ = cv::FeatureDetector::create("Dense");
 
   } else if (detector_type.compare("SIMPLEBLOB") == 0) {
 
     detector_ = cv::FeatureDetector::create("SimpleBlob");
 
   } else {
     VLOG(1) << "Detector type \"" << detector_type
             << "\"is not available. Defaulting to FAST.";
 
     // Default to a FAST detector.
     if (adaptive_) {
       cv::Ptr<cv::AdjusterAdapter> adjuster(
           cv::AdjusterAdapter::create("FAST"));
       detector_ =
           cv::Ptr<cv::FeatureDetector>(new cv::DynamicAdaptedFeatureDetector(
               adjuster, adaptive_min_, adaptive_max_, adaptive_iters_));
     } else {
       detector_ = cv::FeatureDetector::create("FAST");
     }
 
     valid_detector_type = false;
     detector_type_ = "FAST";
   }
 
   return valid_detector_type;
 }

bool bsfm::KeypointDetector::SupportsAdaptiveAdjustment ( ) const

Definition at line 220 of file keypoint_detector.cpp.

                                                         {
   if (detector_type_.compare("FAST") == 0 ||
       detector_type_.compare("SURF") == 0 ||
       detector_type_.compare("STAR") == 0) {
     return true;
   }
 
   return false;
 }

Member Data Documentation

bool bsfm::KeypointDetector::adaptive_

private

Definition at line 81 of file keypoint_detector.h.

unsigned int bsfm::KeypointDetector::adaptive_iters_

private

Definition at line 86 of file keypoint_detector.h.

unsigned int bsfm::KeypointDetector::adaptive_max_

private

Definition at line 85 of file keypoint_detector.h.

unsigned int bsfm::KeypointDetector::adaptive_min_

private

Definition at line 84 of file keypoint_detector.h.

cv::Ptr<cv::FeatureDetector> bsfm::KeypointDetector::detector_

private

Definition at line 80 of file keypoint_detector.h.

std::string bsfm::KeypointDetector::detector_type_

private

Definition at line 79 of file keypoint_detector.h.

The documentation for this class was generated from the following files:

/Users/eanelson/Git/berkeley_sfm/src/cpp/matching/keypoint_detector.h
/Users/eanelson/Git/berkeley_sfm/src/cpp/matching/keypoint_detector.cpp

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation