bsfm::BundleAdjuster Class Reference

#include <bundle_adjuster.h>

Public Member Functions
	BundleAdjuster ()
	~BundleAdjuster ()
bool	Solve (const BundleAdjustmentOptions &options, const std::vector< ViewIndex > &view_indices) const

Private Member Functions
bool	ConvertOptionsToCeresOptions (const BundleAdjustmentOptions &options, ceres::Solver::Options *ceres_options) const

Detailed Description

Definition at line 72 of file bundle_adjuster.h.

Constructor & Destructor Documentation

bsfm::BundleAdjuster::BundleAdjuster ( )

inline

Definition at line 74 of file bundle_adjuster.h.

{ }

bsfm::BundleAdjuster::~BundleAdjuster ( )

inline

Definition at line 75 of file bundle_adjuster.h.

{ }

Member Function Documentation

bool bsfm::BundleAdjuster::ConvertOptionsToCeresOptions ( const BundleAdjustmentOptions &  options, ceres::Solver::Options *  ceres_options  ) const

private

Definition at line 132 of file bundle_adjuster.cpp.

                                             {
  CHECK_NOTNULL(ceres_options);

  // Trust region strategy must be LM.
  ceres_options->trust_region_strategy_type = ceres::LEVENBERG_MARQUARDT;

  // Set linear solver type.
  if (options.solver_type.compare("DENSE_QR")==0) {
    ceres_options->linear_solver_type = ceres::DENSE_QR;
  } else if (options.solver_type.compare("DENSE_NORMAL_CHOLESKY")==0) {
    ceres_options->linear_solver_type = ceres::DENSE_NORMAL_CHOLESKY;
  } else if (options.solver_type.compare("SPARSE_NORMAL_CHOLESKY")==0) {
    ceres_options->linear_solver_type = ceres::SPARSE_NORMAL_CHOLESKY;
  } else if (options.solver_type.compare("CGNR")==0) {
    ceres_options->linear_solver_type = ceres::CGNR;
  } else if (options.solver_type.compare("DENSE_SCHUR")==0) {
    ceres_options->linear_solver_type = ceres::DENSE_SCHUR;
  } else if (options.solver_type.compare("SPARSE_SCHUR")==0) {
    ceres_options->linear_solver_type = ceres::SPARSE_SCHUR;
  } else if (options.solver_type.compare("ITERATIVE_SCHUR")==0) {
    ceres_options->linear_solver_type = ceres::ITERATIVE_SCHUR;
  } else {
    ceres_options->linear_solver_type = ceres::SPARSE_SCHUR;
  }

  // Set print progress.
  if (options.print_progress) {
    ceres_options->logging_type = ceres::PER_MINIMIZER_ITERATION;
    ceres_options->minimizer_progress_to_stdout = true;
  } else {
    ceres_options->logging_type = ceres::SILENT;
    ceres_options->minimizer_progress_to_stdout = false;
  }

  // Set gradient and function tolerance.
  ceres_options->gradient_tolerance = options.gradient_tolerance;
  ceres_options->function_tolerance = options.function_tolerance;

  // Make sure the options we set are valid.
  std::string error_message;
  bool valid_options = ceres_options->IsValid(&error_message);
  if (!valid_options) {
    LOG(WARNING) << "Ceres options error: " << error_message;
  }
  return valid_options;
}

bool bsfm::BundleAdjuster::Solve	(	const BundleAdjustmentOptions &	options,
		const std::vector< ViewIndex > &	view_indices
	)		const

Definition at line 49 of file bundle_adjuster.cpp.

                                                                           {
  // Create a ceres optimization problem.
  ceres::Problem problem;

  // Create storage containers for optimization variables. We only do this
  // because camera extrinsics by default are represented as a 4x4 homogeneous
  // matrix, and we would prefer to optimize 6 camera variables (rotation and
  // translation) instead of 16.
  std::vector<Vector3d> rotations(view_indices.size());
  std::vector<Vector3d> translations(view_indices.size());

  for (size_t ii = 0; ii < view_indices.size(); ++ii) {
    View::Ptr view = View::GetView(view_indices[ii]);
    if (view == nullptr) {
      LOG(WARNING) << "View is null. Cannot perform bundle adjustment.";
      return false;
    }

    // Get camera extrinsics matrix for optimization.
    rotations[ii] = view->Camera().AxisAngleRotation();
    translations[ii] = view->Camera().Translation();

    // Get static camera intrinsics for evaluating cost function.
    Matrix3d K = view->Camera().K();

    // Make a new residual block on the problem for every 3D point that this
    // view sees.
    const std::vector<Observation::Ptr> observations = view->Observations();
    for (size_t jj = 0; jj < observations.size(); ++jj) {
      CHECK_NOTNULL(observations[jj].get());
      if (!observations[jj]->IsIncorporated())
        continue;

      Landmark::Ptr landmark = observations[jj]->GetLandmark();
      if (landmark == nullptr) {
        LOG(WARNING) << "Landmark is null. Cannot perform bundle adjustment.";
        return false;
      }

      // Make sure the landmark has been seen by at least two of the views we
      // are doing bundle adjustment over.
      if (!landmark->SeenByAtLeastTwoViews(view_indices))
        continue;

      // Add a residual block to the cost function.
      problem.AddResidualBlock(
          BundleAdjustmentError::Create(observations[jj]->Feature(), K),
          NULL, /* squared loss */
          rotations[ii].data(),
          translations[ii].data(),
          landmark->PositionData());
    }
  }

  // Solve the bundle adjustment problem.
  ceres::Solver::Options ceres_options;
  if (!ConvertOptionsToCeresOptions(options, &ceres_options)) {
    LOG(WARNING) << "Bundle adjustment options are not valid.";
  }

  ceres::Solver::Summary summary;
  ceres::Solve(ceres_options, &problem, &summary);

  // Print a summary of the optimization.
  if (options.print_summary) {
    std::cout << summary.FullReport() << std::endl;
  }

  // Assign optimized camera parameters back into views.
  for (size_t ii = 0; ii < view_indices.size(); ++ii) {
    Pose pose;
    pose.FromAxisAngle(rotations[ii]);

    // We already know this view is not null.
    View::Ptr view = View::GetView(view_indices[ii]);
    view->MutableCamera().MutableExtrinsics().SetWorldToCamera(pose);
    view->MutableCamera().MutableExtrinsics().SetTranslation(translations[ii]);
  }

  return summary.IsSolutionUsable();
}

---

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

• /Users/eanelson/Git/berkeley_sfm/src/cpp/sfm/bundle_adjuster.h
• /Users/eanelson/Git/berkeley_sfm/src/cpp/sfm/bundle_adjuster.cpp