diff options
Diffstat (limited to 'extern/ceres/include')
25 files changed, 319 insertions, 200 deletions
diff --git a/extern/ceres/include/ceres/autodiff_cost_function.h b/extern/ceres/include/ceres/autodiff_cost_function.h index 5e6e9c55db5..207f0a41688 100644 --- a/extern/ceres/include/ceres/autodiff_cost_function.h +++ b/extern/ceres/include/ceres/autodiff_cost_function.h @@ -153,28 +153,44 @@ template <typename CostFunctor, int... Ns> // Number of parameters in each parameter block. class AutoDiffCostFunction : public SizedCostFunction<kNumResiduals, Ns...> { public: - // Takes ownership of functor. Uses the template-provided value for the - // number of residuals ("kNumResiduals"). - explicit AutoDiffCostFunction(CostFunctor* functor) : functor_(functor) { + // Takes ownership of functor by default. Uses the template-provided + // value for the number of residuals ("kNumResiduals"). + explicit AutoDiffCostFunction(CostFunctor* functor, + Ownership ownership = TAKE_OWNERSHIP) + : functor_(functor), ownership_(ownership) { static_assert(kNumResiduals != DYNAMIC, "Can't run the fixed-size constructor if the number of " "residuals is set to ceres::DYNAMIC."); } - // Takes ownership of functor. Ignores the template-provided + // Takes ownership of functor by default. Ignores the template-provided // kNumResiduals in favor of the "num_residuals" argument provided. // // This allows for having autodiff cost functions which return varying // numbers of residuals at runtime. - AutoDiffCostFunction(CostFunctor* functor, int num_residuals) - : functor_(functor) { + AutoDiffCostFunction(CostFunctor* functor, + int num_residuals, + Ownership ownership = TAKE_OWNERSHIP) + : functor_(functor), ownership_(ownership) { static_assert(kNumResiduals == DYNAMIC, "Can't run the dynamic-size constructor if the number of " "residuals is not ceres::DYNAMIC."); SizedCostFunction<kNumResiduals, Ns...>::set_num_residuals(num_residuals); } - virtual ~AutoDiffCostFunction() {} + explicit AutoDiffCostFunction(AutoDiffCostFunction&& other) + : functor_(std::move(other.functor_)), ownership_(other.ownership_) {} + + virtual ~AutoDiffCostFunction() { + // Manually release pointer if configured to not take ownership rather than + // deleting only if ownership is taken. + // This is to stay maximally compatible to old user code which may have + // forgotten to implement a virtual destructor, from when the + // AutoDiffCostFunction always took ownership. + if (ownership_ == DO_NOT_TAKE_OWNERSHIP) { + functor_.release(); + } + } // Implementation details follow; clients of the autodiff cost function should // not have to examine below here. @@ -201,6 +217,7 @@ class AutoDiffCostFunction : public SizedCostFunction<kNumResiduals, Ns...> { private: std::unique_ptr<CostFunctor> functor_; + Ownership ownership_; }; } // namespace ceres diff --git a/extern/ceres/include/ceres/c_api.h b/extern/ceres/include/ceres/c_api.h index 0e6e590d0f5..91b82bf995f 100644 --- a/extern/ceres/include/ceres/c_api.h +++ b/extern/ceres/include/ceres/c_api.h @@ -38,8 +38,10 @@ #ifndef CERES_PUBLIC_C_API_H_ #define CERES_PUBLIC_C_API_H_ +// clang-format off #include "ceres/internal/port.h" #include "ceres/internal/disable_warnings.h" +// clang-format on #ifdef __cplusplus extern "C" { diff --git a/extern/ceres/include/ceres/cost_function_to_functor.h b/extern/ceres/include/ceres/cost_function_to_functor.h index 1beeb906063..9364293afc5 100644 --- a/extern/ceres/include/ceres/cost_function_to_functor.h +++ b/extern/ceres/include/ceres/cost_function_to_functor.h @@ -144,8 +144,7 @@ class CostFunctionToFunctor { // Extract parameter block pointers from params. using Indices = - std::make_integer_sequence<int, - ParameterDims::kNumParameterBlocks>; + std::make_integer_sequence<int, ParameterDims::kNumParameterBlocks>; std::array<const T*, ParameterDims::kNumParameterBlocks> parameter_blocks = GetParameterPointers<T>(params, Indices()); diff --git a/extern/ceres/include/ceres/covariance.h b/extern/ceres/include/ceres/covariance.h index 99825c425ad..2fe025df3ce 100644 --- a/extern/ceres/include/ceres/covariance.h +++ b/extern/ceres/include/ceres/covariance.h @@ -51,7 +51,7 @@ class CovarianceImpl; // ======= // It is very easy to use this class incorrectly without understanding // the underlying mathematics. Please read and understand the -// documentation completely before attempting to use this class. +// documentation completely before attempting to use it. // // // This class allows the user to evaluate the covariance for a @@ -73,7 +73,7 @@ class CovarianceImpl; // the maximum likelihood estimate of x given observations y is the // solution to the non-linear least squares problem: // -// x* = arg min_x |f(x)|^2 +// x* = arg min_x |f(x) - y|^2 // // And the covariance of x* is given by // @@ -220,11 +220,11 @@ class CERES_EXPORT Covariance { // 1. DENSE_SVD uses Eigen's JacobiSVD to perform the // computations. It computes the singular value decomposition // - // U * S * V' = J + // U * D * V' = J // // and then uses it to compute the pseudo inverse of J'J as // - // pseudoinverse[J'J]^ = V * pseudoinverse[S] * V' + // pseudoinverse[J'J] = V * pseudoinverse[D^2] * V' // // It is an accurate but slow method and should only be used // for small to moderate sized problems. It can handle @@ -235,7 +235,7 @@ class CERES_EXPORT Covariance { // // Q * R = J // - // [J'J]^-1 = [R*R']^-1 + // [J'J]^-1 = [R'*R]^-1 // // SPARSE_QR is not capable of computing the covariance if the // Jacobian is rank deficient. Depending on the value of diff --git a/extern/ceres/include/ceres/dynamic_autodiff_cost_function.h b/extern/ceres/include/ceres/dynamic_autodiff_cost_function.h index 7b75150b5ce..7ccf6a88c32 100644 --- a/extern/ceres/include/ceres/dynamic_autodiff_cost_function.h +++ b/extern/ceres/include/ceres/dynamic_autodiff_cost_function.h @@ -40,6 +40,7 @@ #include "ceres/dynamic_cost_function.h" #include "ceres/internal/fixed_array.h" #include "ceres/jet.h" +#include "ceres/types.h" #include "glog/logging.h" namespace ceres { @@ -78,10 +79,24 @@ namespace ceres { template <typename CostFunctor, int Stride = 4> class DynamicAutoDiffCostFunction : public DynamicCostFunction { public: - explicit DynamicAutoDiffCostFunction(CostFunctor* functor) - : functor_(functor) {} + // Takes ownership by default. + DynamicAutoDiffCostFunction(CostFunctor* functor, + Ownership ownership = TAKE_OWNERSHIP) + : functor_(functor), ownership_(ownership) {} - virtual ~DynamicAutoDiffCostFunction() {} + explicit DynamicAutoDiffCostFunction(DynamicAutoDiffCostFunction&& other) + : functor_(std::move(other.functor_)), ownership_(other.ownership_) {} + + virtual ~DynamicAutoDiffCostFunction() { + // Manually release pointer if configured to not take ownership + // rather than deleting only if ownership is taken. This is to + // stay maximally compatible to old user code which may have + // forgotten to implement a virtual destructor, from when the + // AutoDiffCostFunction always took ownership. + if (ownership_ == DO_NOT_TAKE_OWNERSHIP) { + functor_.release(); + } + } bool Evaluate(double const* const* parameters, double* residuals, @@ -151,6 +166,9 @@ class DynamicAutoDiffCostFunction : public DynamicCostFunction { } } + if (num_active_parameters == 0) { + return (*functor_)(parameters, residuals); + } // When `num_active_parameters % Stride != 0` then it can be the case // that `active_parameter_count < Stride` while parameter_cursor is less // than the total number of parameters and with no remaining non-constant @@ -248,6 +266,7 @@ class DynamicAutoDiffCostFunction : public DynamicCostFunction { private: std::unique_ptr<CostFunctor> functor_; + Ownership ownership_; }; } // namespace ceres diff --git a/extern/ceres/include/ceres/dynamic_numeric_diff_cost_function.h b/extern/ceres/include/ceres/dynamic_numeric_diff_cost_function.h index 119b3f85e8e..ccc8f66db43 100644 --- a/extern/ceres/include/ceres/dynamic_numeric_diff_cost_function.h +++ b/extern/ceres/include/ceres/dynamic_numeric_diff_cost_function.h @@ -44,6 +44,7 @@ #include "ceres/internal/numeric_diff.h" #include "ceres/internal/parameter_dims.h" #include "ceres/numeric_diff_options.h" +#include "ceres/types.h" #include "glog/logging.h" namespace ceres { @@ -84,6 +85,10 @@ class DynamicNumericDiffCostFunction : public DynamicCostFunction { const NumericDiffOptions& options = NumericDiffOptions()) : functor_(functor), ownership_(ownership), options_(options) {} + explicit DynamicNumericDiffCostFunction( + DynamicNumericDiffCostFunction&& other) + : functor_(std::move(other.functor_)), ownership_(other.ownership_) {} + virtual ~DynamicNumericDiffCostFunction() { if (ownership_ != TAKE_OWNERSHIP) { functor_.release(); diff --git a/extern/ceres/include/ceres/gradient_problem_solver.h b/extern/ceres/include/ceres/gradient_problem_solver.h index 181699d8fd4..9fab62e6d94 100644 --- a/extern/ceres/include/ceres/gradient_problem_solver.h +++ b/extern/ceres/include/ceres/gradient_problem_solver.h @@ -62,7 +62,8 @@ class CERES_EXPORT GradientProblemSolver { // Minimizer options ---------------------------------------- LineSearchDirectionType line_search_direction_type = LBFGS; LineSearchType line_search_type = WOLFE; - NonlinearConjugateGradientType nonlinear_conjugate_gradient_type = FLETCHER_REEVES; + NonlinearConjugateGradientType nonlinear_conjugate_gradient_type = + FLETCHER_REEVES; // The LBFGS hessian approximation is a low rank approximation to // the inverse of the Hessian matrix. The rank of the diff --git a/extern/ceres/include/ceres/internal/autodiff.h b/extern/ceres/include/ceres/internal/autodiff.h index cb7b1aca5b9..9d7de758508 100644 --- a/extern/ceres/include/ceres/internal/autodiff.h +++ b/extern/ceres/include/ceres/internal/autodiff.h @@ -198,7 +198,7 @@ struct Make1stOrderPerturbation { template <int N, int Offset, typename T, typename JetT> struct Make1stOrderPerturbation<N, N, Offset, T, JetT> { public: - static void Apply(const T* /*src*/, JetT* /*dst*/) {} + static void Apply(const T* src, JetT* dst) {} }; // Calls Make1stOrderPerturbation for every parameter block. @@ -229,7 +229,9 @@ struct Make1stOrderPerturbations<std::integer_sequence<int, N, Ns...>, // End of 'recursion'. Nothing more to do. template <int ParameterIdx, int Total> -struct Make1stOrderPerturbations<std::integer_sequence<int>, ParameterIdx, Total> { +struct Make1stOrderPerturbations<std::integer_sequence<int>, + ParameterIdx, + Total> { template <typename T, typename JetT> static void Apply(T const* const* /* NOT USED */, JetT* /* NOT USED */) {} }; diff --git a/extern/ceres/include/ceres/internal/disable_warnings.h b/extern/ceres/include/ceres/internal/disable_warnings.h index fd848feec0f..d7766a0a08f 100644 --- a/extern/ceres/include/ceres/internal/disable_warnings.h +++ b/extern/ceres/include/ceres/internal/disable_warnings.h @@ -34,11 +34,11 @@ #define CERES_WARNINGS_DISABLED #ifdef _MSC_VER -#pragma warning( push ) +#pragma warning(push) // Disable the warning C4251 which is triggered by stl classes in // Ceres' public interface. To quote MSDN: "C4251 can be ignored " // "if you are deriving from a type in the Standard C++ Library" -#pragma warning( disable : 4251 ) +#pragma warning(disable : 4251) #endif #endif // CERES_WARNINGS_DISABLED diff --git a/extern/ceres/include/ceres/internal/eigen.h b/extern/ceres/include/ceres/internal/eigen.h index 59545dfd9c9..b6d0b7f610c 100644 --- a/extern/ceres/include/ceres/internal/eigen.h +++ b/extern/ceres/include/ceres/internal/eigen.h @@ -36,31 +36,26 @@ namespace ceres { typedef Eigen::Matrix<double, Eigen::Dynamic, 1> Vector; -typedef Eigen::Matrix<double, - Eigen::Dynamic, - Eigen::Dynamic, - Eigen::RowMajor> Matrix; +typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> + Matrix; typedef Eigen::Map<Vector> VectorRef; typedef Eigen::Map<Matrix> MatrixRef; typedef Eigen::Map<const Vector> ConstVectorRef; typedef Eigen::Map<const Matrix> ConstMatrixRef; // Column major matrices for DenseSparseMatrix/DenseQRSolver -typedef Eigen::Matrix<double, - Eigen::Dynamic, - Eigen::Dynamic, - Eigen::ColMajor> ColMajorMatrix; +typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor> + ColMajorMatrix; -typedef Eigen::Map<ColMajorMatrix, 0, - Eigen::Stride<Eigen::Dynamic, 1>> ColMajorMatrixRef; +typedef Eigen::Map<ColMajorMatrix, 0, Eigen::Stride<Eigen::Dynamic, 1>> + ColMajorMatrixRef; -typedef Eigen::Map<const ColMajorMatrix, - 0, - Eigen::Stride<Eigen::Dynamic, 1>> ConstColMajorMatrixRef; +typedef Eigen::Map<const ColMajorMatrix, 0, Eigen::Stride<Eigen::Dynamic, 1>> + ConstColMajorMatrixRef; // C++ does not support templated typdefs, thus the need for this // struct so that we can support statically sized Matrix and Maps. - template <int num_rows = Eigen::Dynamic, int num_cols = Eigen::Dynamic> +template <int num_rows = Eigen::Dynamic, int num_cols = Eigen::Dynamic> struct EigenTypes { typedef Eigen::Matrix<double, num_rows, diff --git a/extern/ceres/include/ceres/internal/fixed_array.h b/extern/ceres/include/ceres/internal/fixed_array.h index f8ef02d40e8..dcbddcd3a1d 100644 --- a/extern/ceres/include/ceres/internal/fixed_array.h +++ b/extern/ceres/include/ceres/internal/fixed_array.h @@ -30,6 +30,7 @@ #ifndef CERES_PUBLIC_INTERNAL_FIXED_ARRAY_H_ #define CERES_PUBLIC_INTERNAL_FIXED_ARRAY_H_ +#include <Eigen/Core> // For Eigen::aligned_allocator #include <algorithm> #include <array> #include <cstddef> @@ -37,8 +38,6 @@ #include <tuple> #include <type_traits> -#include <Eigen/Core> // For Eigen::aligned_allocator - #include "ceres/internal/memory.h" #include "glog/logging.h" diff --git a/extern/ceres/include/ceres/internal/integer_sequence_algorithm.h b/extern/ceres/include/ceres/internal/integer_sequence_algorithm.h index 170acac2832..8c0f3bc8ac4 100644 --- a/extern/ceres/include/ceres/internal/integer_sequence_algorithm.h +++ b/extern/ceres/include/ceres/internal/integer_sequence_algorithm.h @@ -62,7 +62,8 @@ struct SumImpl; // Strip of and sum the first number. template <typename T, T N, T... Ns> struct SumImpl<std::integer_sequence<T, N, Ns...>> { - static constexpr T Value = N + SumImpl<std::integer_sequence<T, Ns...>>::Value; + static constexpr T Value = + N + SumImpl<std::integer_sequence<T, Ns...>>::Value; }; // Strip of and sum the first two numbers. @@ -129,10 +130,14 @@ template <typename T, T Sum, typename SeqIn, typename SeqOut> struct ExclusiveScanImpl; template <typename T, T Sum, T N, T... Ns, T... Rs> -struct ExclusiveScanImpl<T, Sum, std::integer_sequence<T, N, Ns...>, +struct ExclusiveScanImpl<T, + Sum, + std::integer_sequence<T, N, Ns...>, std::integer_sequence<T, Rs...>> { using Type = - typename ExclusiveScanImpl<T, Sum + N, std::integer_sequence<T, Ns...>, + typename ExclusiveScanImpl<T, + Sum + N, + std::integer_sequence<T, Ns...>, std::integer_sequence<T, Rs..., Sum>>::Type; }; diff --git a/extern/ceres/include/ceres/internal/numeric_diff.h b/extern/ceres/include/ceres/internal/numeric_diff.h index fb2e00baca5..ff7a2c345e4 100644 --- a/extern/ceres/include/ceres/internal/numeric_diff.h +++ b/extern/ceres/include/ceres/internal/numeric_diff.h @@ -47,15 +47,17 @@ #include "ceres/types.h" #include "glog/logging.h" - namespace ceres { namespace internal { // This is split from the main class because C++ doesn't allow partial template // specializations for member functions. The alternative is to repeat the main // class for differing numbers of parameters, which is also unfortunate. -template <typename CostFunctor, NumericDiffMethodType kMethod, - int kNumResiduals, typename ParameterDims, int kParameterBlock, +template <typename CostFunctor, + NumericDiffMethodType kMethod, + int kNumResiduals, + typename ParameterDims, + int kParameterBlock, int kParameterBlockSize> struct NumericDiff { // Mutates parameters but must restore them before return. @@ -66,23 +68,23 @@ struct NumericDiff { int num_residuals, int parameter_block_index, int parameter_block_size, - double **parameters, - double *jacobian) { + double** parameters, + double* jacobian) { + using Eigen::ColMajor; using Eigen::Map; using Eigen::Matrix; using Eigen::RowMajor; - using Eigen::ColMajor; DCHECK(jacobian); const int num_residuals_internal = (kNumResiduals != ceres::DYNAMIC ? kNumResiduals : num_residuals); const int parameter_block_index_internal = - (kParameterBlock != ceres::DYNAMIC ? kParameterBlock : - parameter_block_index); + (kParameterBlock != ceres::DYNAMIC ? kParameterBlock + : parameter_block_index); const int parameter_block_size_internal = - (kParameterBlockSize != ceres::DYNAMIC ? kParameterBlockSize : - parameter_block_size); + (kParameterBlockSize != ceres::DYNAMIC ? kParameterBlockSize + : parameter_block_size); typedef Matrix<double, kNumResiduals, 1> ResidualVector; typedef Matrix<double, kParameterBlockSize, 1> ParameterVector; @@ -97,17 +99,17 @@ struct NumericDiff { (kParameterBlockSize == 1) ? ColMajor : RowMajor> JacobianMatrix; - Map<JacobianMatrix> parameter_jacobian(jacobian, - num_residuals_internal, - parameter_block_size_internal); + Map<JacobianMatrix> parameter_jacobian( + jacobian, num_residuals_internal, parameter_block_size_internal); Map<ParameterVector> x_plus_delta( parameters[parameter_block_index_internal], parameter_block_size_internal); ParameterVector x(x_plus_delta); - ParameterVector step_size = x.array().abs() * - ((kMethod == RIDDERS) ? options.ridders_relative_initial_step_size : - options.relative_step_size); + ParameterVector step_size = + x.array().abs() * ((kMethod == RIDDERS) + ? options.ridders_relative_initial_step_size + : options.relative_step_size); // It is not a good idea to make the step size arbitrarily // small. This will lead to problems with round off and numerical @@ -118,8 +120,8 @@ struct NumericDiff { // For Ridders' method, the initial step size is required to be large, // thus ridders_relative_initial_step_size is used. if (kMethod == RIDDERS) { - min_step_size = std::max(min_step_size, - options.ridders_relative_initial_step_size); + min_step_size = + std::max(min_step_size, options.ridders_relative_initial_step_size); } // For each parameter in the parameter block, use finite differences to @@ -133,7 +135,9 @@ struct NumericDiff { const double delta = std::max(min_step_size, step_size(j)); if (kMethod == RIDDERS) { - if (!EvaluateRiddersJacobianColumn(functor, j, delta, + if (!EvaluateRiddersJacobianColumn(functor, + j, + delta, options, num_residuals_internal, parameter_block_size_internal, @@ -146,7 +150,9 @@ struct NumericDiff { return false; } } else { - if (!EvaluateJacobianColumn(functor, j, delta, + if (!EvaluateJacobianColumn(functor, + j, + delta, num_residuals_internal, parameter_block_size_internal, x.data(), @@ -182,8 +188,7 @@ struct NumericDiff { typedef Matrix<double, kParameterBlockSize, 1> ParameterVector; Map<const ParameterVector> x(x_ptr, parameter_block_size); - Map<ParameterVector> x_plus_delta(x_plus_delta_ptr, - parameter_block_size); + Map<ParameterVector> x_plus_delta(x_plus_delta_ptr, parameter_block_size); Map<ResidualVector> residuals(residuals_ptr, num_residuals); Map<ResidualVector> temp_residuals(temp_residuals_ptr, num_residuals); @@ -191,9 +196,8 @@ struct NumericDiff { // Mutate 1 element at a time and then restore. x_plus_delta(parameter_index) = x(parameter_index) + delta; - if (!VariadicEvaluate<ParameterDims>(*functor, - parameters, - residuals.data())) { + if (!VariadicEvaluate<ParameterDims>( + *functor, parameters, residuals.data())) { return false; } @@ -206,9 +210,8 @@ struct NumericDiff { // Compute the function on the other side of x(parameter_index). x_plus_delta(parameter_index) = x(parameter_index) - delta; - if (!VariadicEvaluate<ParameterDims>(*functor, - parameters, - temp_residuals.data())) { + if (!VariadicEvaluate<ParameterDims>( + *functor, parameters, temp_residuals.data())) { return false; } @@ -217,8 +220,7 @@ struct NumericDiff { } else { // Forward difference only; reuse existing residuals evaluation. residuals -= - Map<const ResidualVector>(residuals_at_eval_point, - num_residuals); + Map<const ResidualVector>(residuals_at_eval_point, num_residuals); } // Restore x_plus_delta. @@ -254,17 +256,17 @@ struct NumericDiff { double* x_plus_delta_ptr, double* temp_residuals_ptr, double* residuals_ptr) { + using Eigen::aligned_allocator; using Eigen::Map; using Eigen::Matrix; - using Eigen::aligned_allocator; typedef Matrix<double, kNumResiduals, 1> ResidualVector; - typedef Matrix<double, kNumResiduals, Eigen::Dynamic> ResidualCandidateMatrix; + typedef Matrix<double, kNumResiduals, Eigen::Dynamic> + ResidualCandidateMatrix; typedef Matrix<double, kParameterBlockSize, 1> ParameterVector; Map<const ParameterVector> x(x_ptr, parameter_block_size); - Map<ParameterVector> x_plus_delta(x_plus_delta_ptr, - parameter_block_size); + Map<ParameterVector> x_plus_delta(x_plus_delta_ptr, parameter_block_size); Map<ResidualVector> residuals(residuals_ptr, num_residuals); Map<ResidualVector> temp_residuals(temp_residuals_ptr, num_residuals); @@ -275,18 +277,16 @@ struct NumericDiff { // As the derivative is estimated, the step size decreases. // By default, the step sizes are chosen so that the middle column // of the Romberg tableau uses the input delta. - double current_step_size = delta * - pow(options.ridders_step_shrink_factor, - options.max_num_ridders_extrapolations / 2); + double current_step_size = + delta * pow(options.ridders_step_shrink_factor, + options.max_num_ridders_extrapolations / 2); // Double-buffering temporary differential candidate vectors // from previous step size. ResidualCandidateMatrix stepsize_candidates_a( - num_residuals, - options.max_num_ridders_extrapolations); + num_residuals, options.max_num_ridders_extrapolations); ResidualCandidateMatrix stepsize_candidates_b( - num_residuals, - options.max_num_ridders_extrapolations); + num_residuals, options.max_num_ridders_extrapolations); ResidualCandidateMatrix* current_candidates = &stepsize_candidates_a; ResidualCandidateMatrix* previous_candidates = &stepsize_candidates_b; @@ -304,7 +304,9 @@ struct NumericDiff { // 3. Extrapolation becomes numerically unstable. for (int i = 0; i < options.max_num_ridders_extrapolations; ++i) { // Compute the numerical derivative at this step size. - if (!EvaluateJacobianColumn(functor, parameter_index, current_step_size, + if (!EvaluateJacobianColumn(functor, + parameter_index, + current_step_size, num_residuals, parameter_block_size, x.data(), @@ -327,23 +329,24 @@ struct NumericDiff { // Extrapolation factor for Richardson acceleration method (see below). double richardson_factor = options.ridders_step_shrink_factor * - options.ridders_step_shrink_factor; + options.ridders_step_shrink_factor; for (int k = 1; k <= i; ++k) { // Extrapolate the various orders of finite differences using // the Richardson acceleration method. current_candidates->col(k) = (richardson_factor * current_candidates->col(k - 1) - - previous_candidates->col(k - 1)) / (richardson_factor - 1.0); + previous_candidates->col(k - 1)) / + (richardson_factor - 1.0); richardson_factor *= options.ridders_step_shrink_factor * - options.ridders_step_shrink_factor; + options.ridders_step_shrink_factor; // Compute the difference between the previous value and the current. double candidate_error = std::max( - (current_candidates->col(k) - - current_candidates->col(k - 1)).norm(), - (current_candidates->col(k) - - previous_candidates->col(k - 1)).norm()); + (current_candidates->col(k) - current_candidates->col(k - 1)) + .norm(), + (current_candidates->col(k) - previous_candidates->col(k - 1)) + .norm()); // If the error has decreased, update results. if (candidate_error <= norm_error) { @@ -365,8 +368,9 @@ struct NumericDiff { // Check to see if the current gradient estimate is numerically unstable. // If so, bail out and return the last stable result. if (i > 0) { - double tableau_error = (current_candidates->col(i) - - previous_candidates->col(i - 1)).norm(); + double tableau_error = + (current_candidates->col(i) - previous_candidates->col(i - 1)) + .norm(); // Compare current error to the chosen candidate's error. if (tableau_error >= 2 * norm_error) { @@ -482,14 +486,18 @@ struct EvaluateJacobianForParameterBlocks<ParameterDims, // End of 'recursion'. Nothing more to do. template <typename ParameterDims, int ParameterIdx> -struct EvaluateJacobianForParameterBlocks<ParameterDims, std::integer_sequence<int>, +struct EvaluateJacobianForParameterBlocks<ParameterDims, + std::integer_sequence<int>, ParameterIdx> { - template <NumericDiffMethodType method, int kNumResiduals, + template <NumericDiffMethodType method, + int kNumResiduals, typename CostFunctor> static bool Apply(const CostFunctor* /* NOT USED*/, const double* /* NOT USED*/, - const NumericDiffOptions& /* NOT USED*/, int /* NOT USED*/, - double** /* NOT USED*/, double** /* NOT USED*/) { + const NumericDiffOptions& /* NOT USED*/, + int /* NOT USED*/, + double** /* NOT USED*/, + double** /* NOT USED*/) { return true; } }; diff --git a/extern/ceres/include/ceres/internal/port.h b/extern/ceres/include/ceres/internal/port.h index 958b0d15cb7..040a1efba02 100644 --- a/extern/ceres/include/ceres/internal/port.h +++ b/extern/ceres/include/ceres/internal/port.h @@ -35,17 +35,17 @@ #include "ceres/internal/config.h" #if defined(CERES_USE_OPENMP) -# if defined(CERES_USE_CXX_THREADS) || defined(CERES_NO_THREADS) -# error CERES_USE_OPENMP is mutually exclusive to CERES_USE_CXX_THREADS and CERES_NO_THREADS -# endif +#if defined(CERES_USE_CXX_THREADS) || defined(CERES_NO_THREADS) +#error CERES_USE_OPENMP is mutually exclusive to CERES_USE_CXX_THREADS and CERES_NO_THREADS +#endif #elif defined(CERES_USE_CXX_THREADS) -# if defined(CERES_USE_OPENMP) || defined(CERES_NO_THREADS) -# error CERES_USE_CXX_THREADS is mutually exclusive to CERES_USE_OPENMP, CERES_USE_CXX_THREADS and CERES_NO_THREADS -# endif +#if defined(CERES_USE_OPENMP) || defined(CERES_NO_THREADS) +#error CERES_USE_CXX_THREADS is mutually exclusive to CERES_USE_OPENMP, CERES_USE_CXX_THREADS and CERES_NO_THREADS +#endif #elif defined(CERES_NO_THREADS) -# if defined(CERES_USE_OPENMP) || defined(CERES_USE_CXX_THREADS) -# error CERES_NO_THREADS is mutually exclusive to CERES_USE_OPENMP and CERES_USE_CXX_THREADS -# endif +#if defined(CERES_USE_OPENMP) || defined(CERES_USE_CXX_THREADS) +#error CERES_NO_THREADS is mutually exclusive to CERES_USE_OPENMP and CERES_USE_CXX_THREADS +#endif #else # error One of CERES_USE_OPENMP, CERES_USE_CXX_THREADS or CERES_NO_THREADS must be defined. #endif @@ -54,37 +54,57 @@ // compiled without any sparse back-end. Verify that it has not subsequently // been inconsistently redefined. #if defined(CERES_NO_SPARSE) -# if !defined(CERES_NO_SUITESPARSE) -# error CERES_NO_SPARSE requires CERES_NO_SUITESPARSE. -# endif -# if !defined(CERES_NO_CXSPARSE) -# error CERES_NO_SPARSE requires CERES_NO_CXSPARSE -# endif -# if !defined(CERES_NO_ACCELERATE_SPARSE) -# error CERES_NO_SPARSE requires CERES_NO_ACCELERATE_SPARSE -# endif -# if defined(CERES_USE_EIGEN_SPARSE) -# error CERES_NO_SPARSE requires !CERES_USE_EIGEN_SPARSE -# endif +#if !defined(CERES_NO_SUITESPARSE) +#error CERES_NO_SPARSE requires CERES_NO_SUITESPARSE. +#endif +#if !defined(CERES_NO_CXSPARSE) +#error CERES_NO_SPARSE requires CERES_NO_CXSPARSE +#endif +#if !defined(CERES_NO_ACCELERATE_SPARSE) +#error CERES_NO_SPARSE requires CERES_NO_ACCELERATE_SPARSE +#endif +#if defined(CERES_USE_EIGEN_SPARSE) +#error CERES_NO_SPARSE requires !CERES_USE_EIGEN_SPARSE +#endif #endif // A macro to signal which functions and classes are exported when -// building a DLL with MSVC. -// -// Note that the ordering here is important, CERES_BUILDING_SHARED_LIBRARY -// is only defined locally when Ceres is compiled, it is never exported to -// users. However, in order that we do not have to configure config.h -// separately for building vs installing, if we are using MSVC and building -// a shared library, then both CERES_BUILDING_SHARED_LIBRARY and -// CERES_USING_SHARED_LIBRARY will be defined when Ceres is compiled. -// Hence it is important that the check for CERES_BUILDING_SHARED_LIBRARY -// happens first. -#if defined(_MSC_VER) && defined(CERES_BUILDING_SHARED_LIBRARY) -# define CERES_EXPORT __declspec(dllexport) -#elif defined(_MSC_VER) && defined(CERES_USING_SHARED_LIBRARY) -# define CERES_EXPORT __declspec(dllimport) +// building a shared library. +#if defined(_MSC_VER) +#define CERES_API_SHARED_IMPORT __declspec(dllimport) +#define CERES_API_SHARED_EXPORT __declspec(dllexport) +#elif defined(__GNUC__) +#define CERES_API_SHARED_IMPORT __attribute__((visibility("default"))) +#define CERES_API_SHARED_EXPORT __attribute__((visibility("default"))) +#else +#define CERES_API_SHARED_IMPORT +#define CERES_API_SHARED_EXPORT +#endif + +// CERES_BUILDING_SHARED_LIBRARY is only defined locally when Ceres itself is +// compiled as a shared library, it is never exported to users. In order that +// we do not have to configure config.h separately when building Ceres as either +// a static or dynamic library, we define both CERES_USING_SHARED_LIBRARY and +// CERES_BUILDING_SHARED_LIBRARY when building as a shared library. +#if defined(CERES_USING_SHARED_LIBRARY) +#if defined(CERES_BUILDING_SHARED_LIBRARY) +// Compiling Ceres itself as a shared library. +#define CERES_EXPORT CERES_API_SHARED_EXPORT +#else +// Using Ceres as a shared library. +#define CERES_EXPORT CERES_API_SHARED_IMPORT +#endif +#else +// Ceres was compiled as a static library, export everything. +#define CERES_EXPORT +#endif + +// Unit tests reach in and test internal functionality so we need a way to make +// those symbols visible +#ifdef CERES_EXPORT_INTERNAL_SYMBOLS +#define CERES_EXPORT_INTERNAL CERES_EXPORT #else -# define CERES_EXPORT +#define CERES_EXPORT_INTERNAL #endif #endif // CERES_PUBLIC_INTERNAL_PORT_H_ diff --git a/extern/ceres/include/ceres/internal/reenable_warnings.h b/extern/ceres/include/ceres/internal/reenable_warnings.h index 7e410259d64..2c5db061fd7 100644 --- a/extern/ceres/include/ceres/internal/reenable_warnings.h +++ b/extern/ceres/include/ceres/internal/reenable_warnings.h @@ -32,7 +32,7 @@ #undef CERES_WARNINGS_DISABLED #ifdef _MSC_VER -#pragma warning( pop ) +#pragma warning(pop) #endif #endif // CERES_WARNINGS_DISABLED diff --git a/extern/ceres/include/ceres/internal/variadic_evaluate.h b/extern/ceres/include/ceres/internal/variadic_evaluate.h index 046832c0bb4..47ff6b18fa0 100644 --- a/extern/ceres/include/ceres/internal/variadic_evaluate.h +++ b/extern/ceres/include/ceres/internal/variadic_evaluate.h @@ -46,8 +46,10 @@ namespace internal { // For fixed size cost functors template <typename Functor, typename T, int... Indices> -inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input, - T* output, std::false_type /*is_dynamic*/, +inline bool VariadicEvaluateImpl(const Functor& functor, + T const* const* input, + T* output, + std::false_type /*is_dynamic*/, std::integer_sequence<int, Indices...>) { static_assert(sizeof...(Indices), "Invalid number of parameter blocks. At least one parameter " @@ -57,26 +59,31 @@ inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input, // For dynamic sized cost functors template <typename Functor, typename T> -inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input, - T* output, std::true_type /*is_dynamic*/, +inline bool VariadicEvaluateImpl(const Functor& functor, + T const* const* input, + T* output, + std::true_type /*is_dynamic*/, std::integer_sequence<int>) { return functor(input, output); } // For ceres cost functors (not ceres::CostFunction) template <typename ParameterDims, typename Functor, typename T> -inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input, - T* output, const void* /* NOT USED */) { +inline bool VariadicEvaluateImpl(const Functor& functor, + T const* const* input, + T* output, + const void* /* NOT USED */) { using ParameterBlockIndices = std::make_integer_sequence<int, ParameterDims::kNumParameterBlocks>; using IsDynamic = std::integral_constant<bool, ParameterDims::kIsDynamic>; - return VariadicEvaluateImpl(functor, input, output, IsDynamic(), - ParameterBlockIndices()); + return VariadicEvaluateImpl( + functor, input, output, IsDynamic(), ParameterBlockIndices()); } // For ceres::CostFunction template <typename ParameterDims, typename Functor, typename T> -inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input, +inline bool VariadicEvaluateImpl(const Functor& functor, + T const* const* input, T* output, const CostFunction* /* NOT USED */) { return functor.Evaluate(input, output, nullptr); @@ -95,7 +102,8 @@ inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input, // blocks. The signature of the functor must have the following signature // 'bool()(const T* i_1, const T* i_2, ... const T* i_n, T* output)'. template <typename ParameterDims, typename Functor, typename T> -inline bool VariadicEvaluate(const Functor& functor, T const* const* input, +inline bool VariadicEvaluate(const Functor& functor, + T const* const* input, T* output) { return VariadicEvaluateImpl<ParameterDims>(functor, input, output, &functor); } diff --git a/extern/ceres/include/ceres/iteration_callback.h b/extern/ceres/include/ceres/iteration_callback.h index 0a743ecc26f..4507fdf748c 100644 --- a/extern/ceres/include/ceres/iteration_callback.h +++ b/extern/ceres/include/ceres/iteration_callback.h @@ -73,7 +73,7 @@ struct CERES_EXPORT IterationSummary { bool step_is_successful = false; // Value of the objective function. - double cost = 0.90; + double cost = 0.0; // Change in the value of the objective function in this // iteration. This can be positive or negative. diff --git a/extern/ceres/include/ceres/jet.h b/extern/ceres/include/ceres/jet.h index 7aafaa01d30..da49f32019f 100644 --- a/extern/ceres/include/ceres/jet.h +++ b/extern/ceres/include/ceres/jet.h @@ -388,6 +388,8 @@ using std::cbrt; using std::ceil; using std::cos; using std::cosh; +using std::erf; +using std::erfc; using std::exp; using std::exp2; using std::floor; @@ -573,6 +575,21 @@ inline Jet<T, N> fmin(const Jet<T, N>& x, const Jet<T, N>& y) { return y < x ? y : x; } +// erf is defined as an integral that cannot be expressed analyticaly +// however, the derivative is trivial to compute +// erf(x + h) = erf(x) + h * 2*exp(-x^2)/sqrt(pi) +template <typename T, int N> +inline Jet<T, N> erf(const Jet<T, N>& x) { + return Jet<T, N>(erf(x.a), x.v * M_2_SQRTPI * exp(-x.a * x.a)); +} + +// erfc(x) = 1-erf(x) +// erfc(x + h) = erfc(x) + h * (-2*exp(-x^2)/sqrt(pi)) +template <typename T, int N> +inline Jet<T, N> erfc(const Jet<T, N>& x) { + return Jet<T, N>(erfc(x.a), -x.v * M_2_SQRTPI * exp(-x.a * x.a)); +} + // Bessel functions of the first kind with integer order equal to 0, 1, n. // // Microsoft has deprecated the j[0,1,n]() POSIX Bessel functions in favour of diff --git a/extern/ceres/include/ceres/local_parameterization.h b/extern/ceres/include/ceres/local_parameterization.h index 1576e829e73..ba7579deca0 100644 --- a/extern/ceres/include/ceres/local_parameterization.h +++ b/extern/ceres/include/ceres/local_parameterization.h @@ -90,8 +90,8 @@ namespace ceres { // // An example that occurs commonly in Structure from Motion problems // is when camera rotations are parameterized using Quaternion. There, -// it is useful only make updates orthogonal to that 4-vector defining -// the quaternion. One way to do this is to let delta be a 3 +// it is useful to only make updates orthogonal to that 4-vector +// defining the quaternion. One way to do this is to let delta be a 3 // dimensional vector and define Plus to be // // Plus(x, delta) = [cos(|delta|), sin(|delta|) delta / |delta|] * x @@ -99,7 +99,7 @@ namespace ceres { // The multiplication between the two 4-vectors on the RHS is the // standard quaternion product. // -// Given g and a point x, optimizing f can now be restated as +// Given f and a point x, optimizing f can now be restated as // // min f(Plus(x, delta)) // delta @@ -306,6 +306,7 @@ class CERES_EXPORT ProductParameterization : public LocalParameterization { public: ProductParameterization(const ProductParameterization&) = delete; ProductParameterization& operator=(const ProductParameterization&) = delete; + virtual ~ProductParameterization() {} // // NOTE: The constructor takes ownership of the input local // parameterizations. @@ -341,7 +342,8 @@ class CERES_EXPORT ProductParameterization : public LocalParameterization { bool Plus(const double* x, const double* delta, double* x_plus_delta) const override; - bool ComputeJacobian(const double* x, double* jacobian) const override; + bool ComputeJacobian(const double* x, + double* jacobian) const override; int GlobalSize() const override { return global_size_; } int LocalSize() const override { return local_size_; } @@ -354,8 +356,8 @@ class CERES_EXPORT ProductParameterization : public LocalParameterization { } // namespace ceres +// clang-format off #include "ceres/internal/reenable_warnings.h" #include "ceres/internal/line_parameterization.h" #endif // CERES_PUBLIC_LOCAL_PARAMETERIZATION_H_ - diff --git a/extern/ceres/include/ceres/numeric_diff_cost_function.h b/extern/ceres/include/ceres/numeric_diff_cost_function.h index c69f262f572..cf7971cde79 100644 --- a/extern/ceres/include/ceres/numeric_diff_cost_function.h +++ b/extern/ceres/include/ceres/numeric_diff_cost_function.h @@ -192,7 +192,10 @@ class NumericDiffCostFunction : public SizedCostFunction<kNumResiduals, Ns...> { } } - ~NumericDiffCostFunction() { + explicit NumericDiffCostFunction(NumericDiffCostFunction&& other) + : functor_(std::move(other.functor_)), ownership_(other.ownership_) {} + + virtual ~NumericDiffCostFunction() { if (ownership_ != TAKE_OWNERSHIP) { functor_.release(); } diff --git a/extern/ceres/include/ceres/problem.h b/extern/ceres/include/ceres/problem.h index 88f99663f65..add12ea401d 100644 --- a/extern/ceres/include/ceres/problem.h +++ b/extern/ceres/include/ceres/problem.h @@ -453,13 +453,15 @@ class CERES_EXPORT Problem { // problem.AddResidualBlock(new MyCostFunction, nullptr, &x); // // double cost = 0.0; - // problem.Evaluate(Problem::EvaluateOptions(), &cost, nullptr, nullptr, nullptr); + // problem.Evaluate(Problem::EvaluateOptions(), &cost, + // nullptr, nullptr, nullptr); // // The cost is evaluated at x = 1. If you wish to evaluate the // problem at x = 2, then // // x = 2; - // problem.Evaluate(Problem::EvaluateOptions(), &cost, nullptr, nullptr, nullptr); + // problem.Evaluate(Problem::EvaluateOptions(), &cost, + // nullptr, nullptr, nullptr); // // is the way to do so. // @@ -475,7 +477,7 @@ class CERES_EXPORT Problem { // at the end of an iteration during a solve. // // Note 4: If an EvaluationCallback is associated with the problem, - // then its PrepareForEvaluation method will be called everytime + // then its PrepareForEvaluation method will be called every time // this method is called with new_point = true. bool Evaluate(const EvaluateOptions& options, double* cost, @@ -509,23 +511,41 @@ class CERES_EXPORT Problem { // apply_loss_function as the name implies allows the user to switch // the application of the loss function on and off. // - // WARNING: If an EvaluationCallback is associated with the problem - // then it is the user's responsibility to call it before calling - // this method. - // - // This is because, if the user calls this method multiple times, we - // cannot tell if the underlying parameter blocks have changed - // between calls or not. So if EvaluateResidualBlock was responsible - // for calling the EvaluationCallback, it will have to do it - // everytime it is called. Which makes the common case where the - // parameter blocks do not change, inefficient. So we leave it to - // the user to call the EvaluationCallback as needed. + // If an EvaluationCallback is associated with the problem, then its + // PrepareForEvaluation method will be called every time this method + // is called with new_point = true. This conservatively assumes that + // the user may have changed the parameter values since the previous + // call to evaluate / solve. For improved efficiency, and only if + // you know that the parameter values have not changed between + // calls, see EvaluateResidualBlockAssumingParametersUnchanged(). bool EvaluateResidualBlock(ResidualBlockId residual_block_id, bool apply_loss_function, double* cost, double* residuals, double** jacobians) const; + // Same as EvaluateResidualBlock except that if an + // EvaluationCallback is associated with the problem, then its + // PrepareForEvaluation method will be called every time this method + // is called with new_point = false. + // + // This means, if an EvaluationCallback is associated with the + // problem then it is the user's responsibility to call + // PrepareForEvaluation before calling this method if necessary, + // i.e. iff the parameter values have been changed since the last + // call to evaluate / solve.' + // + // This is because, as the name implies, we assume that the + // parameter blocks did not change since the last time + // PrepareForEvaluation was called (via Solve, Evaluate or + // EvaluateResidualBlock). + bool EvaluateResidualBlockAssumingParametersUnchanged( + ResidualBlockId residual_block_id, + bool apply_loss_function, + double* cost, + double* residuals, + double** jacobians) const; + private: friend class Solver; friend class Covariance; diff --git a/extern/ceres/include/ceres/rotation.h b/extern/ceres/include/ceres/rotation.h index 7d5c8ef1fb2..0c82a417a2c 100644 --- a/extern/ceres/include/ceres/rotation.h +++ b/extern/ceres/include/ceres/rotation.h @@ -320,8 +320,8 @@ inline void QuaternionToAngleAxis(const T* quaternion, T* angle_axis) { } template <typename T> -void RotationMatrixToQuaternion(const T* R, T* angle_axis) { - RotationMatrixToQuaternion(ColumnMajorAdapter3x3(R), angle_axis); +void RotationMatrixToQuaternion(const T* R, T* quaternion) { + RotationMatrixToQuaternion(ColumnMajorAdapter3x3(R), quaternion); } // This algorithm comes from "Quaternion Calculus and Fast Animation", diff --git a/extern/ceres/include/ceres/solver.h b/extern/ceres/include/ceres/solver.h index 62631744fe2..61b8dd53eb3 100644 --- a/extern/ceres/include/ceres/solver.h +++ b/extern/ceres/include/ceres/solver.h @@ -360,7 +360,8 @@ class CERES_EXPORT Solver { // // If Solver::Options::preconditioner_type == SUBSET, then // residual_blocks_for_subset_preconditioner must be non-empty. - std::unordered_set<ResidualBlockId> residual_blocks_for_subset_preconditioner; + std::unordered_set<ResidualBlockId> + residual_blocks_for_subset_preconditioner; // Ceres supports using multiple dense linear algebra libraries // for dense matrix factorizations. Currently EIGEN and LAPACK are @@ -838,7 +839,7 @@ class CERES_EXPORT Solver { int num_linear_solves = -1; // Time (in seconds) spent evaluating the residual vector. - double residual_evaluation_time_in_seconds = 1.0; + double residual_evaluation_time_in_seconds = -1.0; // Number of residual only evaluations. int num_residual_evaluations = -1; diff --git a/extern/ceres/include/ceres/types.h b/extern/ceres/include/ceres/types.h index 3a19b7333b2..5ee6fdca576 100644 --- a/extern/ceres/include/ceres/types.h +++ b/extern/ceres/include/ceres/types.h @@ -50,7 +50,7 @@ namespace ceres { // delete on it upon completion. enum Ownership { DO_NOT_TAKE_OWNERSHIP, - TAKE_OWNERSHIP + TAKE_OWNERSHIP, }; // TODO(keir): Considerably expand the explanations of each solver type. @@ -185,19 +185,19 @@ enum SparseLinearAlgebraLibraryType { enum DenseLinearAlgebraLibraryType { EIGEN, - LAPACK + LAPACK, }; // Logging options // The options get progressively noisier. enum LoggingType { SILENT, - PER_MINIMIZER_ITERATION + PER_MINIMIZER_ITERATION, }; enum MinimizerType { LINE_SEARCH, - TRUST_REGION + TRUST_REGION, }; enum LineSearchDirectionType { @@ -412,7 +412,7 @@ enum DumpFormatType { // specified for the number of residuals. If specified, then the // number of residuas for that cost function can vary at runtime. enum DimensionType { - DYNAMIC = -1 + DYNAMIC = -1, }; // The differentiation method used to compute numerical derivatives in @@ -433,7 +433,7 @@ enum NumericDiffMethodType { enum LineSearchInterpolationType { BISECTION, QUADRATIC, - CUBIC + CUBIC, }; enum CovarianceAlgorithmType { @@ -448,8 +448,7 @@ enum CovarianceAlgorithmType { // did not write to that memory location. const double kImpossibleValue = 1e302; -CERES_EXPORT const char* LinearSolverTypeToString( - LinearSolverType type); +CERES_EXPORT const char* LinearSolverTypeToString(LinearSolverType type); CERES_EXPORT bool StringToLinearSolverType(std::string value, LinearSolverType* type); @@ -459,25 +458,23 @@ CERES_EXPORT bool StringToPreconditionerType(std::string value, CERES_EXPORT const char* VisibilityClusteringTypeToString( VisibilityClusteringType type); -CERES_EXPORT bool StringToVisibilityClusteringType(std::string value, - VisibilityClusteringType* type); +CERES_EXPORT bool StringToVisibilityClusteringType( + std::string value, VisibilityClusteringType* type); CERES_EXPORT const char* SparseLinearAlgebraLibraryTypeToString( SparseLinearAlgebraLibraryType type); CERES_EXPORT bool StringToSparseLinearAlgebraLibraryType( - std::string value, - SparseLinearAlgebraLibraryType* type); + std::string value, SparseLinearAlgebraLibraryType* type); CERES_EXPORT const char* DenseLinearAlgebraLibraryTypeToString( DenseLinearAlgebraLibraryType type); CERES_EXPORT bool StringToDenseLinearAlgebraLibraryType( - std::string value, - DenseLinearAlgebraLibraryType* type); + std::string value, DenseLinearAlgebraLibraryType* type); CERES_EXPORT const char* TrustRegionStrategyTypeToString( TrustRegionStrategyType type); -CERES_EXPORT bool StringToTrustRegionStrategyType(std::string value, - TrustRegionStrategyType* type); +CERES_EXPORT bool StringToTrustRegionStrategyType( + std::string value, TrustRegionStrategyType* type); CERES_EXPORT const char* DoglegTypeToString(DoglegType type); CERES_EXPORT bool StringToDoglegType(std::string value, DoglegType* type); @@ -487,41 +484,39 @@ CERES_EXPORT bool StringToMinimizerType(std::string value, MinimizerType* type); CERES_EXPORT const char* LineSearchDirectionTypeToString( LineSearchDirectionType type); -CERES_EXPORT bool StringToLineSearchDirectionType(std::string value, - LineSearchDirectionType* type); +CERES_EXPORT bool StringToLineSearchDirectionType( + std::string value, LineSearchDirectionType* type); CERES_EXPORT const char* LineSearchTypeToString(LineSearchType type); -CERES_EXPORT bool StringToLineSearchType(std::string value, LineSearchType* type); +CERES_EXPORT bool StringToLineSearchType(std::string value, + LineSearchType* type); CERES_EXPORT const char* NonlinearConjugateGradientTypeToString( NonlinearConjugateGradientType type); CERES_EXPORT bool StringToNonlinearConjugateGradientType( - std::string value, - NonlinearConjugateGradientType* type); + std::string value, NonlinearConjugateGradientType* type); CERES_EXPORT const char* LineSearchInterpolationTypeToString( LineSearchInterpolationType type); CERES_EXPORT bool StringToLineSearchInterpolationType( - std::string value, - LineSearchInterpolationType* type); + std::string value, LineSearchInterpolationType* type); CERES_EXPORT const char* CovarianceAlgorithmTypeToString( CovarianceAlgorithmType type); CERES_EXPORT bool StringToCovarianceAlgorithmType( - std::string value, - CovarianceAlgorithmType* type); + std::string value, CovarianceAlgorithmType* type); CERES_EXPORT const char* NumericDiffMethodTypeToString( NumericDiffMethodType type); -CERES_EXPORT bool StringToNumericDiffMethodType( - std::string value, - NumericDiffMethodType* type); +CERES_EXPORT bool StringToNumericDiffMethodType(std::string value, + NumericDiffMethodType* type); CERES_EXPORT const char* LoggingTypeToString(LoggingType type); CERES_EXPORT bool StringtoLoggingType(std::string value, LoggingType* type); CERES_EXPORT const char* DumpFormatTypeToString(DumpFormatType type); -CERES_EXPORT bool StringtoDumpFormatType(std::string value, DumpFormatType* type); +CERES_EXPORT bool StringtoDumpFormatType(std::string value, + DumpFormatType* type); CERES_EXPORT bool StringtoDumpFormatType(std::string value, LoggingType* type); CERES_EXPORT const char* TerminationTypeToString(TerminationType type); diff --git a/extern/ceres/include/ceres/version.h b/extern/ceres/include/ceres/version.h index 50aa2124e75..a76cc1099c5 100644 --- a/extern/ceres/include/ceres/version.h +++ b/extern/ceres/include/ceres/version.h @@ -41,8 +41,9 @@ #define CERES_TO_STRING(x) CERES_TO_STRING_HELPER(x) // The Ceres version as a string; for example "1.9.0". -#define CERES_VERSION_STRING CERES_TO_STRING(CERES_VERSION_MAJOR) "." \ - CERES_TO_STRING(CERES_VERSION_MINOR) "." \ - CERES_TO_STRING(CERES_VERSION_REVISION) +#define CERES_VERSION_STRING \ + CERES_TO_STRING(CERES_VERSION_MAJOR) \ + "." CERES_TO_STRING(CERES_VERSION_MINOR) "." CERES_TO_STRING( \ + CERES_VERSION_REVISION) #endif // CERES_PUBLIC_VERSION_H_ |