diff options
Diffstat (limited to 'extern/ceres/include/ceres/covariance.h')
| -rw-r--r-- | extern/ceres/include/ceres/covariance.h | 79 |
1 files changed, 38 insertions, 41 deletions
diff --git a/extern/ceres/include/ceres/covariance.h b/extern/ceres/include/ceres/covariance.h index 930f96cf3ae..99825c425ad 100644 --- a/extern/ceres/include/ceres/covariance.h +++ b/extern/ceres/include/ceres/covariance.h @@ -1,5 +1,5 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2015 Google Inc. All rights reserved. +// Copyright 2019 Google Inc. All rights reserved. // http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without @@ -31,12 +31,13 @@ #ifndef CERES_PUBLIC_COVARIANCE_H_ #define CERES_PUBLIC_COVARIANCE_H_ +#include <memory> #include <utility> #include <vector> + +#include "ceres/internal/disable_warnings.h" #include "ceres/internal/port.h" -#include "ceres/internal/scoped_ptr.h" #include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" namespace ceres { @@ -60,7 +61,7 @@ class CovarianceImpl; // Background // ========== // One way to assess the quality of the solution returned by a -// non-linear least squares solve is to analyze the covariance of the +// non-linear least squares solver is to analyze the covariance of the // solution. // // Let us consider the non-linear regression problem @@ -158,7 +159,7 @@ class CovarianceImpl; // Gauge Invariance // ---------------- // In structure from motion (3D reconstruction) problems, the -// reconstruction is ambiguous upto a similarity transform. This is +// reconstruction is ambiguous up to a similarity transform. This is // known as a Gauge Ambiguity. Handling Gauges correctly requires the // use of SVD or custom inversion algorithms. For small problems the // user can use the dense algorithm. For more details see @@ -183,7 +184,7 @@ class CovarianceImpl; // Covariance::Options options; // Covariance covariance(options); // -// std::vector<std::pair<const double*, const double*> > covariance_blocks; +// std::vector<std::pair<const double*, const double*>> covariance_blocks; // covariance_blocks.push_back(make_pair(x, x)); // covariance_blocks.push_back(make_pair(y, y)); // covariance_blocks.push_back(make_pair(x, y)); @@ -200,19 +201,19 @@ class CovarianceImpl; class CERES_EXPORT Covariance { public: struct CERES_EXPORT Options { - Options() -#ifndef CERES_NO_SUITESPARSE - : algorithm_type(SUITE_SPARSE_QR), + // Sparse linear algebra library to use when a sparse matrix + // factorization is being used to compute the covariance matrix. + // + // Currently this only applies to SPARSE_QR. + SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type = +#if !defined(CERES_NO_SUITESPARSE) + SUITE_SPARSE; #else - : algorithm_type(EIGEN_SPARSE_QR), + // Eigen's QR factorization is always available. + EIGEN_SPARSE; #endif - min_reciprocal_condition_number(1e-14), - null_space_rank(0), - num_threads(1), - apply_loss_function(true) { - } - // Ceres supports three different algorithms for covariance + // Ceres supports two different algorithms for covariance // estimation, which represent different tradeoffs in speed, // accuracy and reliability. // @@ -229,23 +230,20 @@ class CERES_EXPORT Covariance { // for small to moderate sized problems. It can handle // full-rank as well as rank deficient Jacobians. // - // 2. EIGEN_SPARSE_QR uses the sparse QR factorization algorithm - // in Eigen to compute the decomposition + // 2. SPARSE_QR uses the sparse QR factorization algorithm + // to compute the decomposition // // Q * R = J // // [J'J]^-1 = [R*R']^-1 // - // It is a moderately fast algorithm for sparse matrices. - // - // 3. SUITE_SPARSE_QR uses the SuiteSparseQR sparse QR - // factorization algorithm. It uses dense linear algebra and is - // multi threaded, so for large sparse sparse matrices it is - // significantly faster than EIGEN_SPARSE_QR. - // - // Neither EIGEN_SPARSE_QR not SUITE_SPARSE_QR are capable of - // computing the covariance if the Jacobian is rank deficient. - CovarianceAlgorithmType algorithm_type; + // SPARSE_QR is not capable of computing the covariance if the + // Jacobian is rank deficient. Depending on the value of + // Covariance::Options::sparse_linear_algebra_library_type, either + // Eigen's Sparse QR factorization algorithm will be used or + // SuiteSparse's high performance SuiteSparseQR algorithm will be + // used. + CovarianceAlgorithmType algorithm_type = SPARSE_QR; // If the Jacobian matrix is near singular, then inverting J'J // will result in unreliable results, e.g, if @@ -270,7 +268,7 @@ class CERES_EXPORT Covariance { // where min_sigma and max_sigma are the minimum and maxiumum // singular values of J respectively. // - // 2. SUITE_SPARSE_QR and EIGEN_SPARSE_QR + // 2. SPARSE_QR // // rank(J) < num_col(J) // @@ -278,7 +276,7 @@ class CERES_EXPORT Covariance { // sparse QR factorization algorithm. It is a fairly reliable // indication of rank deficiency. // - double min_reciprocal_condition_number; + double min_reciprocal_condition_number = 1e-14; // When using DENSE_SVD, the user has more control in dealing with // singular and near singular covariance matrices. @@ -313,9 +311,9 @@ class CERES_EXPORT Covariance { // // This option has no effect on the SUITE_SPARSE_QR and // EIGEN_SPARSE_QR algorithms. - int null_space_rank; + int null_space_rank = 0; - int num_threads; + int num_threads = 1; // Even though the residual blocks in the problem may contain loss // functions, setting apply_loss_function to false will turn off @@ -323,7 +321,7 @@ class CERES_EXPORT Covariance { // function and in turn its effect on the covariance. // // TODO(sameergaarwal): Expand this based on Jim's experiments. - bool apply_loss_function; + bool apply_loss_function = true; }; explicit Covariance(const Options& options); @@ -352,10 +350,9 @@ class CERES_EXPORT Covariance { // covariance computation. Please see the documentation for // Covariance::Options for more on the conditions under which this // function returns false. - bool Compute( - const std::vector<std::pair<const double*, - const double*> >& covariance_blocks, - Problem* problem); + bool Compute(const std::vector<std::pair<const double*, const double*>>& + covariance_blocks, + Problem* problem); // Compute a part of the covariance matrix. // @@ -428,8 +425,8 @@ class CERES_EXPORT Covariance { // a square matrix whose row and column count is equal to the sum of // the sizes of the individual parameter blocks. The covariance // matrix will be a row-major matrix. - bool GetCovarianceMatrix(const std::vector<const double *> ¶meter_blocks, - double *covariance_matrix); + bool GetCovarianceMatrix(const std::vector<const double*>& parameter_blocks, + double* covariance_matrix) const; // Return the covariance matrix corresponding to parameter_blocks // in the tangent space if a local parameterization is associated @@ -448,10 +445,10 @@ class CERES_EXPORT Covariance { // blocks. The covariance matrix will be a row-major matrix. bool GetCovarianceMatrixInTangentSpace( const std::vector<const double*>& parameter_blocks, - double* covariance_matrix); + double* covariance_matrix) const; private: - internal::scoped_ptr<internal::CovarianceImpl> impl_; + std::unique_ptr<internal::CovarianceImpl> impl_; }; } // namespace ceres |