Add a macro CERES_GET_FLAG.
This is needed to add a layer of indirection which will allow
us to use gflags in the public version and absl inside Google.
Change-Id: I32f3da23200a01c9b658bbf8aaa66cb8fddc2cc3
diff --git a/examples/bundle_adjuster.cc b/examples/bundle_adjuster.cc
index e7b154e..b5b0c55 100644
--- a/examples/bundle_adjuster.cc
+++ b/examples/bundle_adjuster.cc
@@ -136,21 +136,25 @@
namespace {
void SetLinearSolver(Solver::Options* options) {
- CHECK(StringToLinearSolverType(FLAGS_linear_solver,
+ CHECK(StringToLinearSolverType(CERES_GET_FLAG(FLAGS_linear_solver),
&options->linear_solver_type));
- CHECK(StringToPreconditionerType(FLAGS_preconditioner,
+ CHECK(StringToPreconditionerType(CERES_GET_FLAG(FLAGS_preconditioner),
&options->preconditioner_type));
- CHECK(StringToVisibilityClusteringType(FLAGS_visibility_clustering,
- &options->visibility_clustering_type));
+ CHECK(StringToVisibilityClusteringType(
+ CERES_GET_FLAG(FLAGS_visibility_clustering),
+ &options->visibility_clustering_type));
CHECK(StringToSparseLinearAlgebraLibraryType(
- FLAGS_sparse_linear_algebra_library,
+ CERES_GET_FLAG(FLAGS_sparse_linear_algebra_library),
&options->sparse_linear_algebra_library_type));
CHECK(StringToDenseLinearAlgebraLibraryType(
- FLAGS_dense_linear_algebra_library,
+ CERES_GET_FLAG(FLAGS_dense_linear_algebra_library),
&options->dense_linear_algebra_library_type));
- options->use_explicit_schur_complement = FLAGS_explicit_schur_complement;
- options->use_mixed_precision_solves = FLAGS_mixed_precision_solves;
- options->max_num_refinement_iterations = FLAGS_max_num_refinement_iterations;
+ options->use_explicit_schur_complement =
+ CERES_GET_FLAG(FLAGS_explicit_schur_complement);
+ options->use_mixed_precision_solves =
+ CERES_GET_FLAG(FLAGS_mixed_precision_solves);
+ options->max_num_refinement_iterations =
+ CERES_GET_FLAG(FLAGS_max_num_refinement_iterations);
}
void SetOrdering(BALProblem* bal_problem, Solver::Options* options) {
@@ -163,21 +167,22 @@
double* cameras = bal_problem->mutable_cameras();
if (options->use_inner_iterations) {
- if (FLAGS_blocks_for_inner_iterations == "cameras") {
+ if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) == "cameras") {
LOG(INFO) << "Camera blocks for inner iterations";
options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
for (int i = 0; i < num_cameras; ++i) {
options->inner_iteration_ordering->AddElementToGroup(
cameras + camera_block_size * i, 0);
}
- } else if (FLAGS_blocks_for_inner_iterations == "points") {
+ } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) == "points") {
LOG(INFO) << "Point blocks for inner iterations";
options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
for (int i = 0; i < num_points; ++i) {
options->inner_iteration_ordering->AddElementToGroup(
points + point_block_size * i, 0);
}
- } else if (FLAGS_blocks_for_inner_iterations == "cameras,points") {
+ } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) ==
+ "cameras,points") {
LOG(INFO) << "Camera followed by point blocks for inner iterations";
options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
for (int i = 0; i < num_cameras; ++i) {
@@ -188,7 +193,8 @@
options->inner_iteration_ordering->AddElementToGroup(
points + point_block_size * i, 1);
}
- } else if (FLAGS_blocks_for_inner_iterations == "points,cameras") {
+ } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) ==
+ "points,cameras") {
LOG(INFO) << "Point followed by camera blocks for inner iterations";
options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
for (int i = 0; i < num_cameras; ++i) {
@@ -199,11 +205,12 @@
options->inner_iteration_ordering->AddElementToGroup(
points + point_block_size * i, 0);
}
- } else if (FLAGS_blocks_for_inner_iterations == "automatic") {
+ } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) ==
+ "automatic") {
LOG(INFO) << "Choosing automatic blocks for inner iterations";
} else {
LOG(FATAL) << "Unknown block type for inner iterations: "
- << FLAGS_blocks_for_inner_iterations;
+ << CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations);
}
}
@@ -218,7 +225,7 @@
// the right ParameterBlock ordering, or by manually specifying a
// suitable ordering vector and defining
// Options::num_eliminate_blocks.
- if (FLAGS_ordering == "automatic") {
+ if (CERES_GET_FLAG(FLAGS_ordering) == "automatic") {
return;
}
@@ -239,20 +246,22 @@
}
void SetMinimizerOptions(Solver::Options* options) {
- options->max_num_iterations = FLAGS_num_iterations;
+ options->max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
options->minimizer_progress_to_stdout = true;
- options->num_threads = FLAGS_num_threads;
- options->eta = FLAGS_eta;
- options->max_solver_time_in_seconds = FLAGS_max_solver_time;
- options->use_nonmonotonic_steps = FLAGS_nonmonotonic_steps;
- if (FLAGS_line_search) {
+ options->num_threads = CERES_GET_FLAG(FLAGS_num_threads);
+ options->eta = CERES_GET_FLAG(FLAGS_eta);
+ options->max_solver_time_in_seconds = CERES_GET_FLAG(FLAGS_max_solver_time);
+ options->use_nonmonotonic_steps = CERES_GET_FLAG(FLAGS_nonmonotonic_steps);
+ if (CERES_GET_FLAG(FLAGS_line_search)) {
options->minimizer_type = ceres::LINE_SEARCH;
}
- CHECK(StringToTrustRegionStrategyType(FLAGS_trust_region_strategy,
- &options->trust_region_strategy_type));
- CHECK(StringToDoglegType(FLAGS_dogleg, &options->dogleg_type));
- options->use_inner_iterations = FLAGS_inner_iterations;
+ CHECK(StringToTrustRegionStrategyType(
+ CERES_GET_FLAG(FLAGS_trust_region_strategy),
+ &options->trust_region_strategy_type));
+ CHECK(
+ StringToDoglegType(CERES_GET_FLAG(FLAGS_dogleg), &options->dogleg_type));
+ options->use_inner_iterations = CERES_GET_FLAG(FLAGS_inner_iterations);
}
void SetSolverOptionsFromFlags(BALProblem* bal_problem,
@@ -276,14 +285,15 @@
CostFunction* cost_function;
// Each Residual block takes a point and a camera as input and
// outputs a 2 dimensional residual.
- cost_function = (FLAGS_use_quaternions)
+ cost_function = (CERES_GET_FLAG(FLAGS_use_quaternions))
? SnavelyReprojectionErrorWithQuaternions::Create(
observations[2 * i + 0], observations[2 * i + 1])
: SnavelyReprojectionError::Create(
observations[2 * i + 0], observations[2 * i + 1]);
// If enabled use Huber's loss function.
- LossFunction* loss_function = FLAGS_robustify ? new HuberLoss(1.0) : NULL;
+ LossFunction* loss_function =
+ CERES_GET_FLAG(FLAGS_robustify) ? new HuberLoss(1.0) : NULL;
// Each observation correponds to a pair of a camera and a point
// which are identified by camera_index()[i] and point_index()[i]
@@ -294,7 +304,8 @@
problem->AddResidualBlock(cost_function, loss_function, camera, point);
}
- if (FLAGS_use_quaternions && FLAGS_use_local_parameterization) {
+ if (CERES_GET_FLAG(FLAGS_use_quaternions) &&
+ CERES_GET_FLAG(FLAGS_use_local_parameterization)) {
LocalParameterization* camera_parameterization =
new ProductParameterization(new QuaternionParameterization(),
new IdentityParameterization(6));
@@ -306,18 +317,19 @@
}
void SolveProblem(const char* filename) {
- BALProblem bal_problem(filename, FLAGS_use_quaternions);
+ BALProblem bal_problem(filename, CERES_GET_FLAG(FLAGS_use_quaternions));
- if (!FLAGS_initial_ply.empty()) {
- bal_problem.WriteToPLYFile(FLAGS_initial_ply);
+ if (!CERES_GET_FLAG(FLAGS_initial_ply).empty()) {
+ bal_problem.WriteToPLYFile(CERES_GET_FLAG(FLAGS_initial_ply));
}
Problem problem;
- srand(FLAGS_random_seed);
+ srand(CERES_GET_FLAG(FLAGS_random_seed));
bal_problem.Normalize();
- bal_problem.Perturb(
- FLAGS_rotation_sigma, FLAGS_translation_sigma, FLAGS_point_sigma);
+ bal_problem.Perturb(CERES_GET_FLAG(FLAGS_rotation_sigma),
+ CERES_GET_FLAG(FLAGS_translation_sigma),
+ CERES_GET_FLAG(FLAGS_point_sigma));
BuildProblem(&bal_problem, &problem);
Solver::Options options;
@@ -328,8 +340,8 @@
Solve(options, &problem, &summary);
std::cout << summary.FullReport() << "\n";
- if (!FLAGS_final_ply.empty()) {
- bal_problem.WriteToPLYFile(FLAGS_final_ply);
+ if (!CERES_GET_FLAG(FLAGS_final_ply).empty()) {
+ bal_problem.WriteToPLYFile(CERES_GET_FLAG(FLAGS_final_ply));
}
}
@@ -340,14 +352,15 @@
int main(int argc, char** argv) {
GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
google::InitGoogleLogging(argv[0]);
- if (FLAGS_input.empty()) {
+ if (CERES_GET_FLAG(FLAGS_input).empty()) {
LOG(ERROR) << "Usage: bundle_adjuster --input=bal_problem";
return 1;
}
- CHECK(FLAGS_use_quaternions || !FLAGS_use_local_parameterization)
+ CHECK(CERES_GET_FLAG(FLAGS_use_quaternions) ||
+ !CERES_GET_FLAG(FLAGS_use_local_parameterization))
<< "--use_local_parameterization can only be used with "
<< "--use_quaternions.";
- ceres::examples::SolveProblem(FLAGS_input.c_str());
+ ceres::examples::SolveProblem(CERES_GET_FLAG(FLAGS_input).c_str());
return 0;
}
diff --git a/examples/circle_fit.cc b/examples/circle_fit.cc
index c542475..13b4077 100644
--- a/examples/circle_fit.cc
+++ b/examples/circle_fit.cc
@@ -132,8 +132,8 @@
// Configure the loss function.
LossFunction* loss = NULL;
- if (FLAGS_robust_threshold) {
- loss = new CauchyLoss(FLAGS_robust_threshold);
+ if (CERES_GET_FLAG(FLAGS_robust_threshold)) {
+ loss = new CauchyLoss(CERES_GET_FLAG(FLAGS_robust_threshold));
}
// Add the residuals.
diff --git a/examples/denoising.cc b/examples/denoising.cc
index 61ea2c6..eab05be 100644
--- a/examples/denoising.cc
+++ b/examples/denoising.cc
@@ -134,8 +134,9 @@
Problem* problem,
PGMImage<double>* solution) {
// Create the data term
- CHECK_GT(FLAGS_sigma, 0.0);
- const double coefficient = 1 / (2.0 * FLAGS_sigma * FLAGS_sigma);
+ CHECK_GT(CERES_GET_FLAG(FLAGS_sigma), 0.0);
+ const double coefficient =
+ 1 / (2.0 * CERES_GET_FLAG(FLAGS_sigma) * CERES_GET_FLAG(FLAGS_sigma));
for (int index = 0; index < image.NumPixels(); ++index) {
ceres::CostFunction* cost_function = new QuadraticCostFunction(
coefficient, image.PixelFromLinearIndex(index));
@@ -175,31 +176,35 @@
}
void SetLinearSolver(Solver::Options* options) {
- CHECK(StringToLinearSolverType(FLAGS_linear_solver,
+ CHECK(StringToLinearSolverType(CERES_GET_FLAG(FLAGS_linear_solver),
&options->linear_solver_type));
- CHECK(StringToPreconditionerType(FLAGS_preconditioner,
+ CHECK(StringToPreconditionerType(CERES_GET_FLAG(FLAGS_preconditioner),
&options->preconditioner_type));
CHECK(StringToSparseLinearAlgebraLibraryType(
- FLAGS_sparse_linear_algebra_library,
+ CERES_GET_FLAG(FLAGS_sparse_linear_algebra_library),
&options->sparse_linear_algebra_library_type));
- options->use_mixed_precision_solves = FLAGS_mixed_precision_solves;
- options->max_num_refinement_iterations = FLAGS_max_num_refinement_iterations;
+ options->use_mixed_precision_solves =
+ CERES_GET_FLAG(FLAGS_mixed_precision_solves);
+ options->max_num_refinement_iterations =
+ CERES_GET_FLAG(FLAGS_max_num_refinement_iterations);
}
void SetMinimizerOptions(Solver::Options* options) {
- options->max_num_iterations = FLAGS_num_iterations;
+ options->max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
options->minimizer_progress_to_stdout = true;
- options->num_threads = FLAGS_num_threads;
- options->eta = FLAGS_eta;
- options->use_nonmonotonic_steps = FLAGS_nonmonotonic_steps;
- if (FLAGS_line_search) {
+ options->num_threads = CERES_GET_FLAG(FLAGS_num_threads);
+ options->eta = CERES_GET_FLAG(FLAGS_eta);
+ options->use_nonmonotonic_steps = CERES_GET_FLAG(FLAGS_nonmonotonic_steps);
+ if (CERES_GET_FLAG(FLAGS_line_search)) {
options->minimizer_type = ceres::LINE_SEARCH;
}
- CHECK(StringToTrustRegionStrategyType(FLAGS_trust_region_strategy,
- &options->trust_region_strategy_type));
- CHECK(StringToDoglegType(FLAGS_dogleg, &options->dogleg_type));
- options->use_inner_iterations = FLAGS_inner_iterations;
+ CHECK(StringToTrustRegionStrategyType(
+ CERES_GET_FLAG(FLAGS_trust_region_strategy),
+ &options->trust_region_strategy_type));
+ CHECK(
+ StringToDoglegType(CERES_GET_FLAG(FLAGS_dogleg), &options->dogleg_type));
+ options->use_inner_iterations = CERES_GET_FLAG(FLAGS_inner_iterations);
}
// Solves the FoE problem using Ceres and post-processes it to make sure the
@@ -226,7 +231,7 @@
std::default_random_engine engine;
std::uniform_real_distribution<> distribution(0, 1); // rage 0 - 1
for (auto residual_block : residual_blocks) {
- if (distribution(engine) <= FLAGS_subset_fraction) {
+ if (distribution(engine) <= CERES_GET_FLAG(FLAGS_subset_fraction)) {
options.residual_blocks_for_subset_preconditioner.insert(
residual_block);
}
@@ -255,12 +260,12 @@
GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
google::InitGoogleLogging(argv[0]);
- if (FLAGS_input.empty()) {
+ if (CERES_GET_FLAG(FLAGS_input).empty()) {
std::cerr << "Please provide an image file name using -input.\n";
return 1;
}
- if (FLAGS_foe_file.empty()) {
+ if (CERES_GET_FLAG(FLAGS_foe_file).empty()) {
std::cerr << "Please provide a Fields of Experts file name using -foe_file."
"\n";
return 1;
@@ -268,15 +273,16 @@
// Load the Fields of Experts filters from file.
FieldsOfExperts foe;
- if (!foe.LoadFromFile(FLAGS_foe_file)) {
- std::cerr << "Loading \"" << FLAGS_foe_file << "\" failed.\n";
+ if (!foe.LoadFromFile(CERES_GET_FLAG(FLAGS_foe_file))) {
+ std::cerr << "Loading \"" << CERES_GET_FLAG(FLAGS_foe_file)
+ << "\" failed.\n";
return 2;
}
// Read the images
- PGMImage<double> image(FLAGS_input);
+ PGMImage<double> image(CERES_GET_FLAG(FLAGS_input));
if (image.width() == 0) {
- std::cerr << "Reading \"" << FLAGS_input << "\" failed.\n";
+ std::cerr << "Reading \"" << CERES_GET_FLAG(FLAGS_input) << "\" failed.\n";
return 3;
}
PGMImage<double> solution(image.width(), image.height());
@@ -287,9 +293,9 @@
SolveProblem(&problem, &solution);
- if (!FLAGS_output.empty()) {
- CHECK(solution.WriteToFile(FLAGS_output))
- << "Writing \"" << FLAGS_output << "\" failed.";
+ if (!CERES_GET_FLAG(FLAGS_output).empty()) {
+ CHECK(solution.WriteToFile(CERES_GET_FLAG(FLAGS_output)))
+ << "Writing \"" << CERES_GET_FLAG(FLAGS_output) << "\" failed.";
}
return 0;
diff --git a/examples/libmv_bundle_adjuster.cc b/examples/libmv_bundle_adjuster.cc
index b1eb220..77d9ac8 100644
--- a/examples/libmv_bundle_adjuster.cc
+++ b/examples/libmv_bundle_adjuster.cc
@@ -793,7 +793,7 @@
GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
google::InitGoogleLogging(argv[0]);
- if (FLAGS_input.empty()) {
+ if (CERES_GET_FLAG(FLAGS_input).empty()) {
LOG(ERROR) << "Usage: libmv_bundle_adjuster --input=blender_problem";
return EXIT_FAILURE;
}
@@ -804,11 +804,8 @@
bool is_image_space;
vector<Marker> all_markers;
- if (!ReadProblemFromFile(FLAGS_input,
- camera_intrinsics,
- &all_cameras,
- &all_points,
- &is_image_space,
+ if (!ReadProblemFromFile(CERES_GET_FLAG(FLAGS_input), camera_intrinsics,
+ &all_cameras, &all_points, &is_image_space,
&all_markers)) {
LOG(ERROR) << "Error reading problem file";
return EXIT_FAILURE;
@@ -828,14 +825,14 @@
// declare which intrinsics need to be refined and in this case
// refining flags does not depend on problem at all.
int bundle_intrinsics = BUNDLE_NO_INTRINSICS;
- if (FLAGS_refine_intrinsics.empty()) {
+ if (CERES_GET_FLAG(FLAGS_refine_intrinsics).empty()) {
if (is_image_space) {
bundle_intrinsics = BUNDLE_FOCAL_LENGTH | BUNDLE_RADIAL;
}
} else {
- if (FLAGS_refine_intrinsics == "radial") {
+ if (CERES_GET_FLAG(FLAGS_refine_intrinsics) == "radial") {
bundle_intrinsics = BUNDLE_FOCAL_LENGTH | BUNDLE_RADIAL;
- } else if (FLAGS_refine_intrinsics != "none") {
+ } else if (CERES_GET_FLAG(FLAGS_refine_intrinsics) != "none") {
LOG(ERROR) << "Unsupported value for refine-intrinsics";
return EXIT_FAILURE;
}
diff --git a/examples/more_garbow_hillstrom.cc b/examples/more_garbow_hillstrom.cc
index e39d23c..aac7bf9 100644
--- a/examples/more_garbow_hillstrom.cc
+++ b/examples/more_garbow_hillstrom.cc
@@ -78,7 +78,8 @@
const double kDoubleMax = std::numeric_limits<double>::max();
static void SetNumericDiffOptions(ceres::NumericDiffOptions* options) {
- options->max_num_ridders_extrapolations = FLAGS_ridders_extrapolations;
+ options->max_num_ridders_extrapolations =
+ CERES_GET_FLAG(FLAGS_ridders_extrapolations);
}
#define BEGIN_MGH_PROBLEM(name, num_parameters, num_residuals) \
@@ -90,26 +91,20 @@
static const double constrained_optimal_cost; \
static const double unconstrained_optimal_cost; \
static CostFunction* Create() { \
- if (FLAGS_use_numeric_diff) { \
+ if (CERES_GET_FLAG(FLAGS_use_numeric_diff)) { \
ceres::NumericDiffOptions options; \
SetNumericDiffOptions(&options); \
- if (FLAGS_numeric_diff_method == "central") { \
- return new NumericDiffCostFunction<name, \
- ceres::CENTRAL, \
- num_residuals, \
- num_parameters>( \
+ if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "central") { \
+ return new NumericDiffCostFunction<name, ceres::CENTRAL, \
+ num_residuals, num_parameters>( \
new name, ceres::TAKE_OWNERSHIP, num_residuals, options); \
- } else if (FLAGS_numeric_diff_method == "forward") { \
- return new NumericDiffCostFunction<name, \
- ceres::FORWARD, \
- num_residuals, \
- num_parameters>( \
+ } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "forward") { \
+ return new NumericDiffCostFunction<name, ceres::FORWARD, \
+ num_residuals, num_parameters>( \
new name, ceres::TAKE_OWNERSHIP, num_residuals, options); \
- } else if (FLAGS_numeric_diff_method == "ridders") { \
- return new NumericDiffCostFunction<name, \
- ceres::RIDDERS, \
- num_residuals, \
- num_parameters>( \
+ } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "ridders") { \
+ return new NumericDiffCostFunction<name, ceres::RIDDERS, \
+ num_residuals, num_parameters>( \
new name, ceres::TAKE_OWNERSHIP, num_residuals, options); \
} else { \
LOG(ERROR) << "Invalid numeric diff method specified"; \
@@ -597,7 +592,8 @@
#define UNCONSTRAINED_SOLVE(n) \
ss << "Unconstrained Problem " << n << " : "; \
- if (FLAGS_problem == #n || FLAGS_problem == "all") { \
+ if (CERES_GET_FLAG(FLAGS_problem) == #n || \
+ CERES_GET_FLAG(FLAGS_problem) == "all") { \
unconstrained_problems += 3; \
if (Solve<ceres::examples::TestProblem##n>(false, 0)) { \
unconstrained_successes += 1; \
@@ -645,7 +641,8 @@
#define CONSTRAINED_SOLVE(n) \
ss << "Constrained Problem " << n << " : "; \
- if (FLAGS_problem == #n || FLAGS_problem == "all") { \
+ if (CERES_GET_FLAG(FLAGS_problem) == #n || \
+ CERES_GET_FLAG(FLAGS_problem) == "all") { \
constrained_problems += 1; \
if (Solve<ceres::examples::TestProblem##n>(true, 0)) { \
constrained_successes += 1; \
diff --git a/examples/nist.cc b/examples/nist.cc
index 977b69d..70897ac 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -455,41 +455,48 @@
// clang-format on
static void SetNumericDiffOptions(ceres::NumericDiffOptions* options) {
- options->max_num_ridders_extrapolations = FLAGS_ridders_extrapolations;
- options->ridders_relative_initial_step_size = FLAGS_ridders_step_size;
+ options->max_num_ridders_extrapolations =
+ CERES_GET_FLAG(FLAGS_ridders_extrapolations);
+ options->ridders_relative_initial_step_size =
+ CERES_GET_FLAG(FLAGS_ridders_step_size);
}
void SetMinimizerOptions(ceres::Solver::Options* options) {
- CHECK(
- ceres::StringToMinimizerType(FLAGS_minimizer, &options->minimizer_type));
- CHECK(ceres::StringToLinearSolverType(FLAGS_linear_solver,
+ CHECK(ceres::StringToMinimizerType(CERES_GET_FLAG(FLAGS_minimizer),
+ &options->minimizer_type));
+ CHECK(ceres::StringToLinearSolverType(CERES_GET_FLAG(FLAGS_linear_solver),
&options->linear_solver_type));
- CHECK(ceres::StringToPreconditionerType(FLAGS_preconditioner,
+ CHECK(ceres::StringToPreconditionerType(CERES_GET_FLAG(FLAGS_preconditioner),
&options->preconditioner_type));
CHECK(ceres::StringToTrustRegionStrategyType(
- FLAGS_trust_region_strategy, &options->trust_region_strategy_type));
- CHECK(ceres::StringToDoglegType(FLAGS_dogleg, &options->dogleg_type));
+ CERES_GET_FLAG(FLAGS_trust_region_strategy),
+ &options->trust_region_strategy_type));
+ CHECK(ceres::StringToDoglegType(CERES_GET_FLAG(FLAGS_dogleg),
+ &options->dogleg_type));
CHECK(ceres::StringToLineSearchDirectionType(
- FLAGS_line_search_direction, &options->line_search_direction_type));
- CHECK(ceres::StringToLineSearchType(FLAGS_line_search,
+ CERES_GET_FLAG(FLAGS_line_search_direction),
+ &options->line_search_direction_type));
+ CHECK(ceres::StringToLineSearchType(CERES_GET_FLAG(FLAGS_line_search),
&options->line_search_type));
CHECK(ceres::StringToLineSearchInterpolationType(
- FLAGS_line_search_interpolation,
+ CERES_GET_FLAG(FLAGS_line_search_interpolation),
&options->line_search_interpolation_type));
- options->max_num_iterations = FLAGS_num_iterations;
- options->use_nonmonotonic_steps = FLAGS_nonmonotonic_steps;
- options->initial_trust_region_radius = FLAGS_initial_trust_region_radius;
- options->max_lbfgs_rank = FLAGS_lbfgs_rank;
- options->line_search_sufficient_function_decrease = FLAGS_sufficient_decrease;
+ options->max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
+ options->use_nonmonotonic_steps = CERES_GET_FLAG(FLAGS_nonmonotonic_steps);
+ options->initial_trust_region_radius =
+ CERES_GET_FLAG(FLAGS_initial_trust_region_radius);
+ options->max_lbfgs_rank = CERES_GET_FLAG(FLAGS_lbfgs_rank);
+ options->line_search_sufficient_function_decrease =
+ CERES_GET_FLAG(FLAGS_sufficient_decrease);
options->line_search_sufficient_curvature_decrease =
- FLAGS_sufficient_curvature_decrease;
+ CERES_GET_FLAG(FLAGS_sufficient_curvature_decrease);
options->max_num_line_search_step_size_iterations =
- FLAGS_max_line_search_iterations;
+ CERES_GET_FLAG(FLAGS_max_line_search_iterations);
options->max_num_line_search_direction_restarts =
- FLAGS_max_line_search_restarts;
+ CERES_GET_FLAG(FLAGS_max_line_search_restarts);
options->use_approximate_eigenvalue_bfgs_scaling =
- FLAGS_approximate_eigenvalue_bfgs_scaling;
+ CERES_GET_FLAG(FLAGS_approximate_eigenvalue_bfgs_scaling);
options->function_tolerance = std::numeric_limits<double>::epsilon();
options->gradient_tolerance = std::numeric_limits<double>::epsilon();
options->parameter_tolerance = std::numeric_limits<double>::epsilon();
@@ -517,22 +524,22 @@
const int num_observations) {
Model* model = new Model(predictor.data(), response.data(), num_observations);
ceres::CostFunction* cost_function = NULL;
- if (FLAGS_use_numeric_diff) {
+ if (CERES_GET_FLAG(FLAGS_use_numeric_diff)) {
ceres::NumericDiffOptions options;
SetNumericDiffOptions(&options);
- if (FLAGS_numeric_diff_method == "central") {
+ if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "central") {
cost_function = new NumericDiffCostFunction<Model,
ceres::CENTRAL,
ceres::DYNAMIC,
num_parameters>(
model, ceres::TAKE_OWNERSHIP, num_observations, options);
- } else if (FLAGS_numeric_diff_method == "forward") {
+ } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "forward") {
cost_function = new NumericDiffCostFunction<Model,
ceres::FORWARD,
ceres::DYNAMIC,
num_parameters>(
model, ceres::TAKE_OWNERSHIP, num_observations, options);
- } else if (FLAGS_numeric_diff_method == "ridders") {
+ } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "ridders") {
cost_function = new NumericDiffCostFunction<Model,
ceres::RIDDERS,
ceres::DYNAMIC,
@@ -572,7 +579,8 @@
template <typename Model, int num_parameters>
int RegressionDriver(const string& filename) {
- NISTProblem nist_problem(JoinPath(FLAGS_nist_data_dir, filename));
+ NISTProblem nist_problem(
+ JoinPath(CERES_GET_FLAG(FLAGS_nist_data_dir), filename));
CHECK_EQ(num_parameters, nist_problem.num_parameters());
Matrix predictor = nist_problem.predictor();
@@ -593,7 +601,7 @@
double initial_cost;
double final_cost;
- if (!FLAGS_use_tiny_solver) {
+ if (!CERES_GET_FLAG(FLAGS_use_tiny_solver)) {
ceres::Problem problem;
problem.AddResidualBlock(cost_function, NULL, initial_parameters.data());
ceres::Solver::Summary summary;
@@ -609,7 +617,7 @@
ceres::TinySolverCostFunctionAdapter<Eigen::Dynamic, num_parameters>>
Solver;
Solver solver;
- solver.options.max_num_iterations = FLAGS_num_iterations;
+ solver.options.max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
solver.options.gradient_tolerance =
std::numeric_limits<double>::epsilon();
solver.options.parameter_tolerance =
@@ -645,7 +653,7 @@
}
void SolveNISTProblems() {
- if (FLAGS_nist_data_dir.empty()) {
+ if (CERES_GET_FLAG(FLAGS_nist_data_dir).empty()) {
LOG(FATAL) << "Must specify the directory containing the NIST problems";
}
diff --git a/examples/powell.cc b/examples/powell.cc
index c75ad24..7212710 100644
--- a/examples/powell.cc
+++ b/examples/powell.cc
@@ -119,10 +119,9 @@
new AutoDiffCostFunction<F4, 1, 1, 1>(new F4), NULL, &x1, &x4);
Solver::Options options;
- LOG_IF(
- FATAL,
- !ceres::StringToMinimizerType(FLAGS_minimizer, &options.minimizer_type))
- << "Invalid minimizer: " << FLAGS_minimizer
+ LOG_IF(FATAL, !ceres::StringToMinimizerType(CERES_GET_FLAG(FLAGS_minimizer),
+ &options.minimizer_type))
+ << "Invalid minimizer: " << CERES_GET_FLAG(FLAGS_minimizer)
<< ", valid options are: trust_region and line_search.";
options.max_num_iterations = 100;
diff --git a/examples/robot_pose_mle.cc b/examples/robot_pose_mle.cc
index ab9a098..2913758 100644
--- a/examples/robot_pose_mle.cc
+++ b/examples/robot_pose_mle.cc
@@ -181,8 +181,8 @@
}
static OdometryCostFunction* Create(const double odometry_value) {
- return new OdometryCostFunction(
- new OdometryConstraint(odometry_value, FLAGS_odometry_stddev));
+ return new OdometryCostFunction(new OdometryConstraint(
+ odometry_value, CERES_GET_FLAG(FLAGS_odometry_stddev)));
}
const double odometry_mean;
@@ -219,8 +219,11 @@
const double range_reading,
vector<double>* odometry_values,
vector<double*>* parameter_blocks) {
- RangeConstraint* constraint = new RangeConstraint(
- pose_index, range_reading, FLAGS_range_stddev, FLAGS_corridor_length);
+ RangeConstraint* constraint =
+ new RangeConstraint(pose_index,
+ range_reading,
+ CERES_GET_FLAG(FLAGS_range_stddev),
+ CERES_GET_FLAG(FLAGS_corridor_length));
RangeCostFunction* cost_function = new RangeCostFunction(constraint);
// Add all the parameter blocks that affect this constraint.
parameter_blocks->clear();
@@ -243,19 +246,23 @@
void SimulateRobot(vector<double>* odometry_values,
vector<double>* range_readings) {
const int num_steps =
- static_cast<int>(ceil(FLAGS_corridor_length / FLAGS_pose_separation));
+ static_cast<int>(ceil(CERES_GET_FLAG(FLAGS_corridor_length) /
+ CERES_GET_FLAG(FLAGS_pose_separation)));
// The robot starts out at the origin.
double robot_location = 0.0;
for (int i = 0; i < num_steps; ++i) {
const double actual_odometry_value =
- min(FLAGS_pose_separation, FLAGS_corridor_length - robot_location);
+ min(CERES_GET_FLAG(FLAGS_pose_separation),
+ CERES_GET_FLAG(FLAGS_corridor_length) - robot_location);
robot_location += actual_odometry_value;
- const double actual_range = FLAGS_corridor_length - robot_location;
+ const double actual_range =
+ CERES_GET_FLAG(FLAGS_corridor_length) - robot_location;
const double observed_odometry =
- RandNormal() * FLAGS_odometry_stddev + actual_odometry_value;
+ RandNormal() * CERES_GET_FLAG(FLAGS_odometry_stddev) +
+ actual_odometry_value;
const double observed_range =
- RandNormal() * FLAGS_range_stddev + actual_range;
+ RandNormal() * CERES_GET_FLAG(FLAGS_range_stddev) + actual_range;
odometry_values->push_back(observed_odometry);
range_readings->push_back(observed_range);
}
@@ -268,9 +275,10 @@
printf("pose: location odom range r.error o.error\n");
for (int i = 0; i < odometry_readings.size(); ++i) {
robot_location += odometry_readings[i];
- const double range_error =
- robot_location + range_readings[i] - FLAGS_corridor_length;
- const double odometry_error = FLAGS_pose_separation - odometry_readings[i];
+ const double range_error = robot_location + range_readings[i] -
+ CERES_GET_FLAG(FLAGS_corridor_length);
+ const double odometry_error =
+ CERES_GET_FLAG(FLAGS_pose_separation) - odometry_readings[i];
printf("%4d: %8.3f %8.3f %8.3f %8.3f %8.3f\n",
static_cast<int>(i),
robot_location,
@@ -287,10 +295,10 @@
google::InitGoogleLogging(argv[0]);
GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
// Make sure that the arguments parsed are all positive.
- CHECK_GT(FLAGS_corridor_length, 0.0);
- CHECK_GT(FLAGS_pose_separation, 0.0);
- CHECK_GT(FLAGS_odometry_stddev, 0.0);
- CHECK_GT(FLAGS_range_stddev, 0.0);
+ CHECK_GT(CERES_GET_FLAG(FLAGS_corridor_length), 0.0);
+ CHECK_GT(CERES_GET_FLAG(FLAGS_pose_separation), 0.0);
+ CHECK_GT(CERES_GET_FLAG(FLAGS_odometry_stddev), 0.0);
+ CHECK_GT(CERES_GET_FLAG(FLAGS_range_stddev), 0.0);
vector<double> odometry_values;
vector<double> range_readings;
diff --git a/include/ceres/internal/port.h b/include/ceres/internal/port.h
index 040a1ef..620f13a 100644
--- a/include/ceres/internal/port.h
+++ b/include/ceres/internal/port.h
@@ -107,4 +107,8 @@
#define CERES_EXPORT_INTERNAL
#endif
+#ifndef CERES_GET_FLAG
+#define CERES_GET_FLAG(X) X
+#endif
+
#endif // CERES_PUBLIC_INTERNAL_PORT_H_
diff --git a/internal/ceres/test_util.cc b/internal/ceres/test_util.cc
index a131b79..1e0aa6c 100644
--- a/internal/ceres/test_util.cc
+++ b/internal/ceres/test_util.cc
@@ -134,7 +134,8 @@
}
std::string TestFileAbsolutePath(const std::string& filename) {
- return JoinPath(FLAGS_test_srcdir + CERES_TEST_SRCDIR_SUFFIX, filename);
+ return JoinPath(CERES_GET_FLAG(FLAGS_test_srcdir) + CERES_TEST_SRCDIR_SUFFIX,
+ filename);
}
std::string ToString(const Solver::Options& options) {
