bsfm::NaiveMatcher2D3D Class Reference

#include <naive_matcher_2d3d.h>

Public Member Functions
	NaiveMatcher2D3D ()
	~NaiveMatcher2D3D ()
bool	Match (const FeatureMatcherOptions &options, const ViewIndex &view_index, const std::vector< LandmarkIndex > &landmark_indices)

Private Member Functions
void	ComputeOneWayMatches (const std::vector< Descriptor > &descriptors1, const std::vector< Descriptor > &descriptors2, std::vector< LightFeatureMatch > &matches)
void	ComputeSymmetricMatches (const std::vector< LightFeatureMatch > &feature_matches_lhs, std::vector< LightFeatureMatch > &feature_matches_rhs)

Private Attributes
FeatureMatcherOptions	options_

Detailed Description

Definition at line 66 of file naive_matcher_2d3d.h.

Constructor & Destructor Documentation

bsfm::NaiveMatcher2D3D::NaiveMatcher2D3D

(

)

Definition at line 42 of file naive_matcher_2d3d.cpp.

{}

bsfm::NaiveMatcher2D3D::~NaiveMatcher2D3D

(

)

Definition at line 44 of file naive_matcher_2d3d.cpp.

{}

Member Function Documentation

void bsfm::NaiveMatcher2D3D::ComputeOneWayMatches ( const std::vector< Descriptor > &  descriptors1, const std::vector< Descriptor > &  descriptors2, std::vector< LightFeatureMatch > &  matches  )

private

Definition at line 133 of file naive_matcher_2d3d.cpp.

                                            {
  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 (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 =
          options_.lowes_ratio * options_.lowes_ratio;
      if (one_way_matches[0].distance_ <
          lowes_ratio_squared * one_way_matches[1].distance_) {
        matches.emplace_back(one_way_matches[0]);
      }
    } else {
      matches.emplace_back(one_way_matches[0]);
    }
  }
}

void bsfm::NaiveMatcher2D3D::ComputeSymmetricMatches ( const std::vector< LightFeatureMatch > &  feature_matches_lhs, std::vector< LightFeatureMatch > &  feature_matches_rhs  )

private

Definition at line 185 of file naive_matcher_2d3d.cpp.

                                                       {
  // Keep track of symmetric matches in a hash table.
  std::unordered_map<int, int> feature_indices;
  feature_indices.reserve(feature_matches_lhs.size());

  // Add all LHS matches to the map.
  for (const auto& feature_match : feature_matches_lhs) {
    feature_indices.insert(std::make_pair(feature_match.feature_index1_,
                                          feature_match.feature_index2_));
  }

  // For each match in the RHS set, search for the same match in the LHS set.
  // If the match is not symmetric, remove it from the RHS set.
  auto rhs_iter = feature_matches_rhs.begin();
  while (rhs_iter != feature_matches_rhs.end()) {
    const auto& lhs_matched_iter =
        feature_indices.find(rhs_iter->feature_index2_);

    // If a symmetric match is found, keep it in the RHS set.
    if (lhs_matched_iter != feature_indices.end()) {
      if (lhs_matched_iter->second == rhs_iter->feature_index1_) {
        ++rhs_iter;
        continue;
      }
    }

    // Remove the non-symmetric match and continue on.
    feature_matches_rhs.erase(rhs_iter);
  }
}

bool bsfm::NaiveMatcher2D3D::Match	(	const FeatureMatcherOptions &	options,
		const ViewIndex &	view_index,
		const std::vector< LandmarkIndex > &	landmark_indices
	)

Definition at line 46 of file naive_matcher_2d3d.cpp.

                                                      {
  // Copy options.
  options_ = options;

  // Make sure the view is valid.
  View::Ptr view = View::GetView(view_index);
  if (view == nullptr) {
    LOG(WARNING) << "Cannot perform 2D<-->3D matching. View must not be null.";
    return false;
  }

  // Get descriptors from unincorporated observations in the view.
  std::vector<Descriptor> descriptors_2d;
  std::vector<size_t> observation_indices;
  std::vector<Observation::Ptr> observations = view->Observations();
  for (size_t ii = 0; ii < observations.size(); ++ii) {
    CHECK_NOTNULL(observations[ii].get());
    if (!observations[ii]->IsIncorporated()) {
      descriptors_2d.push_back(observations[ii]->Descriptor());
      observation_indices.push_back(ii);
    }
  }

  // Get descriptors from landmarks.
  std::vector<Descriptor> descriptors_3d;
  descriptors_3d.reserve(landmark_indices.size());
  for (size_t ii = 0; ii < landmark_indices.size(); ii++) {
    Landmark::Ptr landmark = Landmark::GetLandmark(landmark_indices[ii]);
    CHECK_NOTNULL(landmark.get());
    descriptors_3d.push_back(landmark->Descriptor());
  }

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

  // Compute forward matches.
  std::vector<LightFeatureMatch> forward_matches;
  ComputeOneWayMatches(descriptors_2d, descriptors_3d, forward_matches);

  if (forward_matches.size() < options_.min_num_feature_matches)
    return false;

  // Compute reverse matches if needed.
  if (options_.require_symmetric_matches) {
    std::vector<LightFeatureMatch> reverse_matches;
    ComputeOneWayMatches(descriptors_3d, descriptors_2d, reverse_matches);
    ComputeSymmetricMatches(reverse_matches, forward_matches);
  }

  // Symmetric matches are now stored in 'forward_matches'.
  if (forward_matches.size() < options_.min_num_feature_matches)
    return false;

  // Check how many features the user wants.
  size_t num_features_out = forward_matches.size();
  if (options_.only_keep_best_matches) {
    num_features_out =
      std::min(num_features_out, static_cast<size_t>(options_.num_best_matches));

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

  // Update Observations in the provided view based on their matches with
  // landmarks. Also set all observations as matched.
  for (size_t ii = 0; ii < forward_matches.size(); ii++) {
    const size_t observation_index =
        observation_indices[forward_matches[ii].feature_index1_];
    const LandmarkIndex landmark_index =
        landmark_indices[forward_matches[ii].feature_index2_];

    observations[observation_index]->SetMatchedLandmark(landmark_index);
  }

  return true;
}

Member Data Documentation

FeatureMatcherOptions bsfm::NaiveMatcher2D3D::options_

private

Definition at line 97 of file naive_matcher_2d3d.h.

---

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

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