bsfm::EssentialMatrixSolver Class Reference

#include <essential_matrix_solver.h>

Public Member Functions
	EssentialMatrixSolver ()
	~EssentialMatrixSolver ()
Matrix3d	ComputeEssentialMatrix (const Matrix3d &F, const CameraIntrinsics &intrinsics1, const CameraIntrinsics &intrinsics2)
bool	ComputeExtrinsics (const Matrix3d &E, const FeatureMatchList &matches, const CameraIntrinsics &intrinsics1, const CameraIntrinsics &intrinsics2, Pose &relative_pose)

Detailed Description

Definition at line 62 of file essential_matrix_solver.h.

Constructor & Destructor Documentation

bsfm::EssentialMatrixSolver::EssentialMatrixSolver ( )

inline

Definition at line 66 of file essential_matrix_solver.h.

{}

bsfm::EssentialMatrixSolver::~EssentialMatrixSolver ( )

inline

Definition at line 67 of file essential_matrix_solver.h.

{}

Member Function Documentation

Matrix3d bsfm::EssentialMatrixSolver::ComputeEssentialMatrix	(	const Matrix3d &	F,
		const CameraIntrinsics &	intrinsics1,
		const CameraIntrinsics &	intrinsics2
	)

Definition at line 66 of file essential_matrix_solver.cpp.

                                         {
  // Extract intrinsics matrices.
  Matrix3d K1(intrinsics1.K());
  Matrix3d K2(intrinsics2.K());

  // Calculate the essential matrix.
  return K2.transpose() * F * K1;
}

bool bsfm::EssentialMatrixSolver::ComputeExtrinsics	(	const Matrix3d &	E,
		const FeatureMatchList &	matches,
		const CameraIntrinsics &	intrinsics1,
		const CameraIntrinsics &	intrinsics2,
		Pose &	relative_pose
	)

Definition at line 81 of file essential_matrix_solver.cpp.

                         {
  // Initialize the W matrix.
  Matrix3d W;
  W << 0.0, -1.0, 0.0,
       1.0,  0.0, 0.0,
       0.0,  0.0, 1.0;

  // Perform an SVD on the essential matrix.
  Eigen::JacobiSVD<Matrix3d> svd;
  svd.compute(E, Eigen::ComputeFullU | Eigen::ComputeFullV);
  if (!svd.computeU() || !svd.computeV()) {
    VLOG(1) << "Failed to compute a singular value decomposition of "
            << "the essential matrix.";
    return false;
  }

  // The essential matrix must satisfy E = U * diag(1, 1, 0) * V^T. Use U and V
  // to get a new E, run another SVD, and get the normalized U and V.
  Matrix3d sigma(Matrix3d::Identity());
  sigma(2, 2) = 0;
  Matrix3d E_augmented = svd.matrixU() * sigma * svd.matrixV().transpose();

  svd.compute(E_augmented, Eigen::ComputeFullU | Eigen::ComputeFullV);
  if (!svd.computeU() || !svd.computeV()) {
    VLOG(1) << "Failed to compute a singular value decomposition of "
            << "the essential matrix.";
    return false;
  }

  // Compute two possibilities for rotation.
  Matrix3d R1 = svd.matrixU() * W * svd.matrixV().transpose();
  Matrix3d R2 = svd.matrixU() * W.transpose() * svd.matrixV().transpose();

  // Ensure positive determinants.
  if (R1.determinant() < 0)
    R1 = -R1;
  if (R2.determinant() < 0)
    R2 = -R2;

  // Compute two possibilities for translation
  Vector3d t1, t2;
  t1 = svd.matrixU().col(2);
  t2 = -t1;

  // Build four possible Poses.
  std::vector<Pose> poses;
  poses.push_back(Pose(R1, t1));
  poses.push_back(Pose(R1, t2));
  poses.push_back(Pose(R2, t1));
  poses.push_back(Pose(R2, t2));

  // Set the first camera's position to identity in rotation and translation.
  CameraExtrinsics extrinsics1;
  extrinsics1.SetWorldToCamera(Pose());

  Camera camera1;
  camera1.SetExtrinsics(extrinsics1);
  camera1.SetIntrinsics(intrinsics1);

  // Test how many points are in front of each pose and the identity pose.
  Pose best_pose;
  int best_num_points = -1;

  double u = 0.0, v = 0.0;
  for (int ii = 0; ii < poses.size(); ii++) {
    int num_points = 0;

    CameraExtrinsics extrinsics2;
    extrinsics2.SetWorldToCamera(poses[ii]);

    Camera camera2;
    camera2.SetExtrinsics(extrinsics2);
    camera2.SetIntrinsics(intrinsics2);

    for (int jj = 0; jj < matches.size(); jj++) {
      // Triangulate points and test if the 3D estimate is in front of both
      // cameras.
      Point3D point;
      if (!Triangulate(matches[jj], camera1, camera2, point)) {
        continue;
      }

      num_points++;
    }

    // Update best_cnt and best_pose.
    if (num_points > best_num_points) {
      best_num_points = num_points;
      best_pose = poses[ii];
    }
  }

  // Return with false if not enough points found in front of the cameras.
  if (best_num_points < FLAGS_min_points_visible_ratio * matches.size()) {
    VLOG(1) << "Did not find enough points in front of both cameras.";
    return false;
  }

  relative_pose = best_pose;

  return true;
}

---

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

• /Users/eanelson/Git/berkeley_sfm/src/cpp/geometry/essential_matrix_solver.h
• /Users/eanelson/Git/berkeley_sfm/src/cpp/geometry/essential_matrix_solver.cpp