bsfm::NaiveMatcher2D2D Class Reference

#include <naive_matcher_2d2d.h>

Inheritance diagram for bsfm::NaiveMatcher2D2D:

Public Member Functions
	NaiveMatcher2D2D ()
virtual	~NaiveMatcher2D2D ()
Public Member Functions inherited from bsfm::FeatureMatcher
	FeatureMatcher ()
virtual	~FeatureMatcher ()
virtual void	AddImageFeatures (const std::vector< Feature > &image_features, const std::vector< Descriptor > &image_descriptors)
virtual void	AddImageFeatures (const std::vector< std::vector< Feature > > &image_features, const std::vector< std::vector< Descriptor > > &image_descriptors)
virtual bool	MatchImages (const FeatureMatcherOptions &options, PairwiseImageMatchList &image_matches)

Private Member Functions
virtual bool	MatchImagePair (int image_index1, int image_index2, PairwiseImageMatch &feature_matches)
void	ComputePutativeMatches (const std::vector< Descriptor > &descriptors1, const std::vector< Descriptor > &descriptors2, std::vector< LightFeatureMatch > &putative_matches)

Additional Inherited Members
Protected Member Functions inherited from bsfm::FeatureMatcher
virtual void	SymmetricMatches (const std::vector< LightFeatureMatch > &feature_matches_lhs, std::vector< LightFeatureMatch > &feature_matches_rhs)
Protected Attributes inherited from bsfm::FeatureMatcher
std::vector< std::vector< Feature > >	image_features_
std::vector< std::vector< Descriptor > >	image_descriptors_
FeatureMatcherOptions	options_

Detailed Description

Definition at line 65 of file naive_matcher_2d2d.h.

Constructor & Destructor Documentation

bsfm::NaiveMatcher2D2D::NaiveMatcher2D2D ( )

inline

Definition at line 67 of file naive_matcher_2d2d.h.

{ }

virtual bsfm::NaiveMatcher2D2D::~NaiveMatcher2D2D ( )

inlinevirtual

Definition at line 68 of file naive_matcher_2d2d.h.

{ }

Member Function Documentation

void bsfm::NaiveMatcher2D2D::ComputePutativeMatches ( const std::vector< Descriptor > &  descriptors1, const std::vector< Descriptor > &  descriptors2, std::vector< LightFeatureMatch > &  putative_matches  )

private

Definition at line 114 of file naive_matcher_2d2d.cpp.

                                                    {
  putative_matches.clear();

  // Get the singletone distance metric for descriptor comparison.
  DistanceMetric& distance = DistanceMetric::Instance();

  // Set the maximum tolerable distance between descriptors, if applicable.
  if (options_.enforce_maximum_descriptor_distance) {
    distance.SetMaximumDistance(options_.maximum_descriptor_distance);
  }

  // Store all matches and their distances.
  for (size_t ii = 0; ii < descriptors1.size(); ++ii) {
    LightFeatureMatchList one_way_matches;
    for (size_t jj = 0; jj < descriptors2.size(); ++jj) {
      double dist = distance(descriptors1[ii], descriptors2[jj]);

      // If max distance was not set above, distance.Max() will be infinity and
      // this will always be true.
      if (dist < distance.Max()) {
        one_way_matches.emplace_back(ii, jj, dist);
      }
    }

    // Store the best match for this element of features2.
    if (this->options_.use_lowes_ratio) {
      // Sort by distance. We only care about the distances between the best 2
      // matches for the Lowes ratio test.
      std::partial_sort(one_way_matches.begin(),
                        one_way_matches.begin() + 1,
                        one_way_matches.end(),
                        LightFeatureMatch::SortByDistance);

      // The second best match must be within the lowes ratio of the best match.
      double lowes_ratio_squared =
          this->options_.lowes_ratio * this->options_.lowes_ratio;
      if (one_way_matches[0].distance_ <
          lowes_ratio_squared * one_way_matches[1].distance_) {
        putative_matches.emplace_back(one_way_matches[0]);
      }
    } else {
      putative_matches.emplace_back(one_way_matches[0]);
    }
  }
}

bool bsfm::NaiveMatcher2D2D::MatchImagePair ( int  image_index1, int  image_index2, PairwiseImageMatch &  feature_matches  )

privatevirtual

Implements bsfm::FeatureMatcher.

Definition at line 42 of file naive_matcher_2d2d.cpp.

                                     {
  image_match.feature_matches_.clear();
  image_match.descriptor_indices1_.clear();
  image_match.descriptor_indices2_.clear();

  // Get the descriptors corresponding to these two images.
  std::vector<Descriptor>& descriptors1 =
      this->image_descriptors_[image_index1];
  std::vector<Descriptor>& descriptors2 =
      this->image_descriptors_[image_index2];

  // Normalize descriptors if required by the distance metric.
  DistanceMetric::Instance().MaybeNormalizeDescriptors(descriptors1);
  DistanceMetric::Instance().MaybeNormalizeDescriptors(descriptors2);

  // Compute forward (and reverse, if applicable) matches.
  LightFeatureMatchList light_feature_matches;
  ComputePutativeMatches(descriptors1, descriptors2, light_feature_matches);

  // Check that we got enough matches here. If we didn't, reverse matches won't
  // help us.
  if (light_feature_matches.size() < this->options_.min_num_feature_matches) {
    return false;
  }

  if (this->options_.require_symmetric_matches) {
    LightFeatureMatchList reverse_light_feature_matches;
    ComputePutativeMatches(descriptors2, descriptors1,
                           reverse_light_feature_matches);
    this->SymmetricMatches(reverse_light_feature_matches,
                           light_feature_matches);
  }

  if (light_feature_matches.size() < this->options_.min_num_feature_matches) {
    return false;
  }

  // Check how many features the user wants.
  unsigned int num_features_out = light_feature_matches.size();
  if (this->options_.only_keep_best_matches) {
    num_features_out =
        std::min(num_features_out, this->options_.num_best_matches);

    // Return relevant matches in sorted order.
    std::partial_sort(light_feature_matches.begin(),
                      light_feature_matches.begin() + num_features_out,
                      light_feature_matches.end(),
                      LightFeatureMatch::SortByDistance);
  }

  // Convert from LightFeatureMatchList to FeatureMatchList for the output.
  for (int ii = 0; ii < num_features_out; ++ii) {
    const auto& match = light_feature_matches[ii];

    const Feature& matched_feature1 =
        this->image_features_[image_index1][match.feature_index1_];
    const Feature& matched_feature2 =
        this->image_features_[image_index2][match.feature_index2_];

    image_match.feature_matches_.emplace_back(matched_feature1,
                                              matched_feature2);

    // Also store the index of each descriptor used for this match.
    image_match.descriptor_indices1_.push_back(match.feature_index1_);
    image_match.descriptor_indices2_.push_back(match.feature_index2_);
  }

  return true;
}

---

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

• /Users/eanelson/Git/berkeley_sfm/src/cpp/matching/naive_matcher_2d2d.h
• /Users/eanelson/Git/berkeley_sfm/src/cpp/matching/naive_matcher_2d2d.cpp