diff options
author | Sergey Sharybin <sergey.vfx@gmail.com> | 2015-10-28 16:55:04 +0300 |
---|---|---|
committer | Sergey Sharybin <sergey.vfx@gmail.com> | 2015-10-28 17:20:50 +0300 |
commit | ced1c34f74d115f81052667d4d17e4efd6b282c4 (patch) | |
tree | 8f236e4a3183bdfe3d7d7ab19e6a5b5703c9ae84 /extern | |
parent | f10db730bc4d8139e86ce078dd0fdd9fd07a8f35 (diff) |
Ceres: Update to the latest version
It brings all the performance improvements, bug fixes and stability improvements
which were done in the last year of Ceres development.
Diffstat (limited to 'extern')
268 files changed, 3920 insertions, 2552 deletions
diff --git a/extern/libmv/third_party/ceres/CMakeLists.txt b/extern/libmv/third_party/ceres/CMakeLists.txt index 694982ec606..f9a7d0631c0 100644 --- a/extern/libmv/third_party/ceres/CMakeLists.txt +++ b/extern/libmv/third_party/ceres/CMakeLists.txt @@ -80,7 +80,6 @@ set(SRC internal/ceres/gradient_problem.cc internal/ceres/gradient_problem_solver.cc internal/ceres/implicit_schur_complement.cc - internal/ceres/incomplete_lq_factorization.cc internal/ceres/iterative_schur_complement_solver.cc internal/ceres/lapack.cc internal/ceres/levenberg_marquardt_strategy.cc @@ -209,7 +208,6 @@ set(SRC internal/ceres/graph_algorithms.h internal/ceres/graph.h internal/ceres/implicit_schur_complement.h - internal/ceres/incomplete_lq_factorization.h internal/ceres/integral_types.h internal/ceres/iterative_schur_complement_solver.h internal/ceres/lapack.h @@ -270,6 +268,7 @@ if(WITH_LIBMV_SCHUR_SPECIALIZATIONS) internal/ceres/generated/partitioned_matrix_view_2_2_d.cc internal/ceres/generated/partitioned_matrix_view_2_3_3.cc internal/ceres/generated/partitioned_matrix_view_2_3_4.cc + internal/ceres/generated/partitioned_matrix_view_2_3_6.cc internal/ceres/generated/partitioned_matrix_view_2_3_9.cc internal/ceres/generated/partitioned_matrix_view_2_3_d.cc internal/ceres/generated/partitioned_matrix_view_2_4_3.cc @@ -288,6 +287,7 @@ if(WITH_LIBMV_SCHUR_SPECIALIZATIONS) internal/ceres/generated/schur_eliminator_2_2_d.cc internal/ceres/generated/schur_eliminator_2_3_3.cc internal/ceres/generated/schur_eliminator_2_3_4.cc + internal/ceres/generated/schur_eliminator_2_3_6.cc internal/ceres/generated/schur_eliminator_2_3_9.cc internal/ceres/generated/schur_eliminator_2_3_d.cc internal/ceres/generated/schur_eliminator_2_4_3.cc diff --git a/extern/libmv/third_party/ceres/ChangeLog b/extern/libmv/third_party/ceres/ChangeLog index b4f78ee0731..0e6c195174c 100644 --- a/extern/libmv/third_party/ceres/ChangeLog +++ b/extern/libmv/third_party/ceres/ChangeLog @@ -1,673 +1,659 @@ -commit 0435246de5f45e69b2c97d244ed61bedd340215a -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Oct 8 18:12:53 2014 -0700 +commit aef9c9563b08d5f39eee1576af133a84749d1b48 +Author: Alessandro Gentilini <agentilini@gmail.com> +Date: Tue Oct 6 20:43:45 2015 +0200 - Add seene to users.rst + Add test for Bessel functions. - Change-Id: If40726775a3d4b234b6e10517fe9943d122a3384 + Change-Id: Ief5881e8027643d7ef627e60a88fdbad17f3d884 -commit fdf32b315f39553639f0becf078ad4eec763a10e -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Oct 8 16:04:32 2014 -0700 +commit 49c86018e00f196c4aa9bd25daccb9919917efee +Author: Alessandro Gentilini <agentilini@gmail.com> +Date: Wed Sep 23 21:59:44 2015 +0200 - Fix some errant tabs. + Add Bessel functions in order to use them in residual code. - Change-Id: Iaf1906eaade49467ba282656cf0a10879d258b1f + See "How can I use the Bessel function in the residual function?" at + https://groups.google.com/d/msg/ceres-solver/Vh1gpqac8v0/NIK1EiWJCAAJ + + Change-Id: I3e80d9f9d1cadaf7177076e493ff46ace5233b76 -commit 6768b3586a027bb850c0a50e2a27380f5d80142a -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Oct 8 12:48:16 2014 -0700 +commit dfb201220c034fde00a242d0533bef3f73b2907d +Author: Simon Rutishauser <simon.rutishauser@pix4d.com> +Date: Tue Oct 13 07:33:58 2015 +0200 - Minor cleanups in preparation for a release. + Make miniglog threadsafe on non-windows system by using + localtime_r() instead of localtime() for time formatting - 1. Fix the release script to ignore the version.h checking. - 2. Fix some ceres documentation formatting errors. - - Change-Id: I3fd6b85e771b242f463d6a36c3efd8d691f9242f + Change-Id: Ib8006c685cd8ed4f374893bef56c4061ca2c9747 -commit 7b6bd1cd31aa0b8cb7fb97600c1b9999846e3152 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Oct 2 16:16:26 2014 -0700 +commit 41455566ac633e55f222bce7c4d2cb4cc33d5c72 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Mon Sep 28 22:43:42 2015 +0100 - Documentation update. + Remove link-time optimisation (LTO). - 1. Complete restructuring of the documentation to account for - GradientProblemSolver. - 2. Update the version history to account for changes since 1.9.0. - 3. Add links and document the various examples that ship with ceres. - 4. Documentation for GradientProblem GradientProblemSolver. + - On GCC 4.9+ although GCC supports LTO, it requires use of the + non-default gcc-ar & gcc-ranlib. Whilst we can ensure Ceres is + compiled with these, doing so with GCC 4.9 causes multiple definition + linker errors of static ints inside Eigen when compiling the tests + and examples when they are not also built with LTO. + - On OS X (Xcode 6 & 7) after the latest update to gtest, if LTO + is used when compiling the tests (& examples), two tests fail + due to typeinfo::operator== (things are fine if only Ceres itself is + compiled with LTO). + - This patch disables LTO for all compilers. It should be revisited when + the performance is more stable across our supported compilers. - Change-Id: If3a18f2850cbc98be1bc34435e9ea468785b8b27 + Change-Id: I17b52957faefbdeff0aa40846dc9b342db1b02e3 -commit b7d321f505e936b6c09aeb43ae3f7b1252388a95 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Fri Oct 3 15:47:59 2014 -0700 +commit 89c40005bfceadb4163bd16b7464b3c2ce740daf +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Sep 27 13:37:26 2015 +0100 - Relax the warning/error handing in GCC. + Only use LTO when compiling Ceres itself, not tests or examples. - Thanks to Matthew Woehlke for suggesting this. + - If Ceres is built as a shared library, and LTO is enabled for Ceres + and the tests, then type_info::operator==() incorrectly returns false + in gtests' CheckedDowncastToActualType() in the following tests: + -- levenberg_marquardt_strategy_test. + -- gradient_checking_cost_function_test. + on at least Xcode 6 & 7 as reported here: + https://github.com/google/googletest/issues/595. + - This does not appear to be a gtest issue, but is perhaps an LLVM bug + or an RTTI shared library issue. Either way, disabling the use of + LTO when compiling the test application resolves the issue. + - Allow LTO to be enabled for GCC, if it is supported. + - Add CMake function to allow easy appending to target properties s/t + Ceres library-specific compile flags can be iteratively constructed. - Change-Id: Iae754465c086b0841a7816df1a36781371d0dc9a + Change-Id: I923e6aae4f7cefa098cf32b2f8fc19389e7918c9 -commit 94c6e7d27b5d48d81ab54ed9cdcbc55c3c099311 +commit 0794f41cca440f7f65d9a44e671f66f6e498ef7c Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Oct 1 15:55:13 2014 -0700 +Date: Sat Sep 26 14:10:15 2015 -0700 - Improve multithreading when using inner iterations. - - Inner iterations by default would use problems where the evaluator - was configured to use exactly one thread for doing the evaluation. - This is fine when there are multiple inner iteration problems - being executed concurrently, but every now and then there are - problem decompositions where there is just one parameter block - in the current independent set and it touches every single - residual block. In such cases it is essential that the evaluator - be configured to use multiple threads. + Documentation updates. - We now pay attention to the size of the independent set and - dynamically configure the number of threads being used by the - outer loop and the evaluator loop. + 1. Fix a typo in the Trust Region algorithm. + 2. Add ARL in the list of users. + 3. Update the version history. - Thanks to William Rucklidge for reporting this issue and providing - a test problem to debug. - - Change-Id: Iaff9a4ab6d2658cf7b61ea213575d23aab604e3b + Change-Id: Ic286e8ef1a71af07f3890b7592dd3aed9c5f87ce -commit 9e11cd16d09403b9270e621e839d5948b6a74b8d -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Mon Sep 29 14:27:58 2014 -0700 +commit 90e32a8dc437dfb0e6747ce15a1f3193c13b7d5b +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Mon Sep 21 21:08:25 2015 +0100 - Faster BlockRandomAccessSparseMatrix::SymmetricRightMultiply. - - Trade a small amount of memory to improve the cache coherency of - the SymmetricRightMultiply operation. + Use old minimum iOS version flags on Xcode < 7.0. - The resulting code leads to a 10-20% speedup in the linear solver - end to end. + - The newer style, which are more specific and match the SDK names + are not available on Xcode < 7.0. - Change-Id: I8ab2fe152099e849b211b5b19e4ef9f03d8e7f1c + Change-Id: I2f07a0365183d2781157cdb05fd49b30ae001ac5 -commit 46b8461fd010c1e7ffce6bb2bdf8a84b659d5e09 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Mon Sep 29 15:10:58 2014 -0700 +commit 26cd5326a1fb99ae02c667eab9942e1308046984 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Mon Sep 21 10:16:01 2015 +0100 - Various minor fixes from William Rucklidge. + Add gtest-specific flags when building/using as a shared library. + + - Currently these flags are only used to define the relevant DLL export + prefix for Windows. - Change-Id: Ibe731d5db374ad8ee148d62a9fdd8d726b607a3f + Change-Id: I0c05207b512cb4a985390aefc779b91febdabb38 -commit b44cfdef25f6bf0917a23b3fd65cce38aa6a3362 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Mon Sep 29 07:53:54 2014 -0700 +commit c4c79472112a49bc1340da0074af2d15b1c89749 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Sep 20 18:26:59 2015 +0100 - Let ITERATIVE_SCHUR use an explicit Schur Complement matrix. - - Up till now ITERATIVE_SCHUR evaluates matrix-vector products - between the Schur complement and a vector implicitly by exploiting - the algebraic expression for the Schur complement. - - This cost of this evaluation scales with the number of non-zeros - in the Jacobian. - - For small to medium sized problems there is a sweet spot where - computing the Schur complement is cheap enough that it is much - more efficient to explicitly compute it and use it for evaluating - the matrix-vector products. - - This changes implements support for an explicit Schur complement - in ITERATIVE_SCHUR in combination with the SCHUR_JACOBI preconditioner. - - API wise a new bool Solver::Options::use_explicit_schur_complement - has been added. - - The implementation extends the SparseSchurComplementSolver to use - Conjugate Gradients. - - Example speedup: - - use_explicit_schur_complement = false - - Time (in seconds): - Preprocessor 0.585 - - Residual evaluation 0.319 - Jacobian evaluation 1.590 - Linear solver 25.685 - Minimizer 27.990 - - Postprocessor 0.010 - Total 28.585 + Clean up iOS.cmake to use xcrun/xcodebuild & libtool. - use_explicit_schur_complement = true + - Substantial cleanup of iOS.cmake to use xcrun & xcodebuild to + determine the SDK & tool paths. + - Use libtool -static to link libraries instead of ar + ranlib, which + is not compatible with Xcode 7+, this change should be backwards + compatible to at least Xcode 6. + - Force locations of unordered_map & shared_ptr on iOS to work around + check_cxx_source_compiles() running in a forked CMake instance without + access to the variables (IOS_PLATFORM) defined by the user. + - Minor CMake style updates. - Time (in seconds): - Preprocessor 0.638 - - Residual evaluation 0.318 - Jacobian evaluation 1.507 - Linear solver 5.930 - Minimizer 8.144 - - Postprocessor 0.010 - Total 8.791 - - Which indicates an end-to-end speedup of more than 3x, with the linear - solver being sped up by > 4x. - - The idea to explore this optimization was inspired by the recent paper: - - Mining structure fragments for smart bundle adjustment - L. Carlone, P. Alcantarilla, H. Chiu, K. Zsolt, F. Dellaert - British Machine Vision Conference, 2014 - - which uses a more complicated algorithm to compute parts of the - Schur complement to speed up the matrix-vector product. - - Change-Id: I95324af0ab351faa1600f5204039a1d2a64ae61d + Change-Id: I5f83a60607db34d461ebe85f9dce861f53d98277 -commit 4ad91490827f2ebebcc70d17e63ef653bf06fd0d +commit 155765bbb358f1d19f072a4b54825faf1c059910 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Sep 24 23:54:18 2014 -0700 +Date: Wed Sep 16 06:56:08 2015 -0700 - Simplify the Block Jacobi and Schur Jacobi preconditioners. - - 1. Extend the implementation of BlockRandomAccessDiagonalMatrix - by adding Invert and RightMultiply methods. + Import the latest version of gtest and gmock. - 2. Simplify the implementation of the Schur Jacobi preconditioner - using these new methods. - - 3. Replace the custom storage used inside Block Jacobi preconditioner - with BlockRandomAccessDiagonalMatrix and simplify its implementation - too. - - Change-Id: I9d4888b35f0f228c08244abbdda5298b3ce9c466 + Change-Id: I4b686c44bba823cab1dae40efa99e31340d2b52a -commit 8f7be1036b853addc33224d97b92412b5a1281b6 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Mon Sep 29 08:13:35 2014 -0700 +commit 0c4647b8f1496c97c6b9376d9c49ddc204aa08dd +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Wed Sep 16 20:01:11 2015 +0100 - Fix a formatting error TrustRegionMinimizer logging. + Remove FAQ about increasing inlining threshold for Clang. - Change-Id: Iad1873c51eece46c3fdee1356d154367cfd7925e + - Changing the inlining threshold for Clang as described has a minimal + effect on user performance. + - The problem that originally prompted the belief that it did was + due to an erroneous CXX flag configuration (in user code). + + Change-Id: I03017241c0f87b8dcefb8c984ec3b192afd97fc2 -commit c99872d48e322662ea19efb9010a62b7432687ae +commit f4b768b69afcf282568f9ab3a3f0eb8078607468 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Sep 24 21:30:02 2014 -0700 +Date: Mon Sep 14 13:53:24 2015 -0700 - Add BlockRandomAccessSparseMatrix::SymmetricRightMultiply. + Lint changes from William Rucklidge - Change-Id: Ib06a22a209b4c985ba218162dfb6bf46bd93169e + Change-Id: I0dac2549a8fa2bfd12f745a8d8a0db623b7ec1ac -commit d3ecd18625ba260e0d00912a305a448b566acc59 +commit 5f2f05c726443e35767d677daba6d25dbc2d7ff8 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Tue Sep 23 10:12:42 2014 -0700 +Date: Fri Sep 11 22:19:38 2015 -0700 - Add an explicit include for local_parameterization.h + Refactor system_test + + 1. Move common test infrastructure into test_util. + 2. system_test now only contains powells function. + 3. Add bundle_adjustment_test. - Thanks to cooordz for reporting this. + Instead of a single function which computes everything, + there is now a test for each solver configuration which + uses the reference solution computed by the fixture. - Change-Id: I7d345404e362a94ff1eb433ad6b9dcc4960ba76d + Change-Id: I16a9a9a83a845a7aaf28762bcecf1a8ff5aee805 -commit 5dd76869cf45122c79579423f09e0de08cf04092 +commit 1936d47e213142b8bf29d3f548905116092b093d Author: Alex Stewart <alexs.mac@gmail.com> -Date: Fri Sep 19 16:08:25 2014 +0100 +Date: Tue Sep 8 23:27:42 2015 +0100 - Fix unused-function warning with Eigen < 3.2.2. + Revert increased inline threshold (iff Clang) to exported Ceres target. - - CreateBlockJacobian() is only ever used when Eigen >= 3.2.2 is - detected, but was previously defined whenever CERES_USE_EIGEN_SPARSE - was defined with no check on the Eigen version. - - This resulted in an unused-function compile warning that became an - error due to -Werror, preventing compilation when using Eigen < 3.2.2. + - Increasing the inline threshold results in very variable performance + improvements, and could potentially confuse users if they are trying + to set the inline threshold themselves. + - As such, we no longer export our inline threshold configuration for + Clang, but instead document how to change it in the FAQs. - Change-Id: I24628ff329f14b087ece66bf2626bdc0de4ba224 + Change-Id: I88e2e0001e4586ba2718535845ed1e4b1a5b72bc -commit 820cb7b14831aa03eca1e8186000cebfdf0a42f3 +commit a66d89dcda47cefda83758bfb9e7374bec4ce866 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Sep 17 09:46:08 2014 -0700 +Date: Sat Sep 5 16:50:20 2015 -0700 - Add solver_utils.cc to Android.mk + Get ready for 1.11.0RC1 + + Update version numbers. + Drop CERES_VERSION_ABI macro. - Change-Id: I358522971711280f4362a1fa39b1568160e21e63 + Change-Id: Ib3eadabb318afe206bb196a5221b195d26cbeaa0 -commit 092b94970a073f8b47179d96160226fc19095898 +commit 1ac3dd223c179fbadaed568ac532af4139c75d84 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Fri Sep 5 11:56:29 2014 -0700 +Date: Sat Sep 5 15:30:01 2015 -0700 - Add GradientProblem and GradientProblemSolver. + Fix a bug in CompressedRowSparseMatrix::AppendRows - The line search minimizer in Ceres does not require that the - problems that is solving is a sum of squares. Over the past - year there have been multiple requests to expose this algorithm - on its own so that it can be used to solve unconstrained - non-linear minimization problems on its own. + The test for CompressedRowSparseMatrix::AppendRows tries to add + a matrix of size zero, which results in an invalid pointer deferencing + even though that pointer is never written to. - With this change, a new optimization problem called - GradientProblem is introduced which is basically a thin - wrapper around a user defined functor that evaluates cost - and gradients (FirstOrderFunction) and an optional LocalParameterization. - - Corresponding to it, a GradientProblemSolver and its associated - options and summary structs are introduced too. - - An example that uses the new API to find the minimum of Rosenbrock's - function is also added. - - Change-Id: I42bf687540da25de991e9bdb00e321239244e8b4 + Change-Id: I97dba37082bd5dad242ae1af0447a9178cd92027 -commit 6c45d6b891aac01489b478a021f99081c61792cb +commit 67622b080c8d37b5e932120a53d4ce76b80543e5 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Sep 11 07:48:30 2014 -0700 +Date: Sat Sep 5 13:18:38 2015 -0700 - Add more inspection methods to Problem. - - Problem::GetCostFunctionForResidualBlock - Problem::GetLossFunctionForResidualBlock + Fix a pointer access bug in Ridders' algorithm. - are added, so that users do not have to maintain this mapping - outside the Problem. + A pointer to an Eigen matrix was being used as an array. - Change-Id: I38356dfa094b2c7eec90651dafeaf3a33c5f5f56 + Change-Id: Ifaea14fa3416eda5953de49afb78dc5a6ea816eb -commit 6ad9b8e2ae66c9009441d0f9304486ec8dfa9a6a +commit 5742b7d0f14d2d170054623ccfee09ea214b8ed9 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Tue Sep 9 14:29:28 2014 -0700 +Date: Wed Aug 26 09:24:33 2015 -0700 - Ignore row/column blocks structure when using dynamic sparsity + Improve performance of SPARSE_NORMAL_CHOLESKY + dynamic_sparsity - The row/column blocks can be huge when using dynamic sparsity. This - can result in very large memory usage when augmenting the jacobian - with the LM diagonal. + The outer product computation logic in SparseNormalCholeskySolver + does not work well with dynamic sparsity. The overhead of computing + the sparsity pattern of the normal equations is only amortized if + the sparsity is constant. If the sparsity can change from call to call + SparseNormalCholeskySolver will actually be more expensive. - Thanks to Mingsong Dou for reporting this. - - Change-Id: I6aa140ceefa98389ae17958f89ca76e0c76f95b8 + For Eigen and for CXSparse we now explicitly compute the normal + equations using their respective matrix-matrix product routines and solve. + Change-Id: Ifbd8ed78987cdf71640e66ed69500442526a23d4 -commit 7e43460d42e20be1ba13121655dbbfd0d1c751ae -Author: Martin Baeuml <baeuml@gmail.com> -Date: Mon Sep 8 16:49:06 2014 +0200 +commit d0b6cf657d6ef0dd739e958af9a5768f2eecfd35 +Author: Keir Mierle <mierle@gmail.com> +Date: Fri Sep 4 18:43:41 2015 -0700 - Fix a few typos in the documentation. + Fix incorrect detect structure test - Change-Id: I541db56b2b81ae758e233ce850d78c3cbb4b6fa3 + Change-Id: I7062f3639147c40b57947790d3b18331a39a366b -commit 1aef66eeae7042902655a11b0d6a1a32900abb7b -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sun Sep 7 21:18:44 2014 -0700 +commit 0e8264cc47661651a11e2dd8570c210082963545 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sat Aug 22 16:23:05 2015 +0100 - Remove errant space. + Add increased inline threshold (iff Clang) to exported Ceres target. - Change-Id: Iedc06960417a9b938d57f623b4beb87a98e3d081 + - When compiled with Clang, Ceres and all of the examples are compiled + with an increased inlining-threshold, as the default value can result + in poor Eigen performance. + - Previously, client code using Ceres would typically not use an + increased inlining-threshold (unless the user has specifically added + it themselves). However, increasing the inlining threshold can result + in significant performance improvements in auto-diffed CostFunctions. + - This patch adds the inlining-threshold flags to the interface flags + for the Ceres CMake target s/t any client code using Ceres (via + CMake), and compiled with Clang, will now be compiled with the same + increased inlining threshold as used by Ceres itself. + + Change-Id: I31e8f1abfda140d22e85bb48aa57f028a68a415e -commit 89080ab153a33008782759187fa8e9af7d2f83f1 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sat Sep 6 21:13:48 2014 -0700 +commit a1b3fce9e0a4141b973f6b4dd9b08c4c13052d52 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Mon Aug 31 14:14:56 2015 +0100 - Add LocalParameterization::MultiplyByJacobian. - - This is needed to efficiently support LocalParameterization objects - in GradientProblemSolver. + Add optional export of Ceres build directory to new features list. - Change-Id: Ic7b715b8be694b099dc95d6707a67474297533e6 + Change-Id: I6f1e42b41957ae9cc98fd9dcd1969ef64c4cd96f -commit d76da16f49d419ae3664ca1bdc2286c1ea78ebed -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sun Sep 7 18:42:49 2014 -0700 +commit e46777d8df068866ef80902401a03e29348d11ae +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Mon Aug 31 12:41:54 2015 +0100 - Move some routines to solver_utils.h/cc - - This moves a couple of routines from solver.cc into solver_utils.h/cc - so that they can also be used by the upcoming GradientProblemSolver. + Credit reporters of buildsystem bugs in version history. - Change-Id: I627b32ad3dc639422aacde78a8e391459d947e99 + Change-Id: I16fe7973534cd556d97215e84268ae0b8ec4e11a -commit cbf03ac292a0c0e9e6b7fcc1b08b67e95965922f +commit 01548282cb620e5e3ac79a63a391cd0afd5433e4 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sat Sep 6 21:07:08 2014 -0700 +Date: Sun Aug 30 22:29:27 2015 -0700 - Make LineSearchMinimizer consistent with TrustRegionMinimizer. + Update the version history. - Change the logic for how IterationSummary objects are added to - Summary::iterations to match the one in TrustRegionMinimizer. - - Change-Id: I57851ad8294e58f83b9115cca9c24695d86ee92a + Change-Id: I29873bed31675e0108f1a44f53f7bc68976b7f98 -commit f04c32319751e1efd610acd3699bca0a6dd6c6d1 +commit 2701429f770fce69ed0c77523fa43d7bc20ac6dc Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sat Sep 6 21:05:41 2014 -0700 +Date: Sun Aug 30 21:33:57 2015 -0700 - Fix some obsolete documentation in CostFunction::Evaluate + Use Eigen::Dynamic instead of ceres::DYNAMIC in numeric_diff.h - Change-Id: I1d7ee5c596fbf6a4d886dce5b989c8eb18af2dce + Change-Id: Iccb0284a8fb4c2160748dfae24bcd595f1d4cb5c -commit 9263547c02a1807532b159c217e7acd124d3db10 -Author: Johannes Schönberger <hannesschoenberger@gmail.com> -Date: Sat Sep 6 17:26:15 2014 -0400 +commit 4f049db7c2a3ee8cf9910c6eac96be6a28a5999c +Author: Tal Ben-Nun <tbennun@gmail.com> +Date: Wed May 13 15:43:51 2015 +0300 - Fix CG solver options for ITERATIVE_SCHUR, which did not copy min_num_iterations + Adaptive numeric differentiation using Ridders' method. - Change-Id: If31bc53b49ec20426fd438b79b8fa1f69d11e861 - -commit b41f048256d1a8184cbe874b5a96dffa7fa4630d -Author: Martin Baeuml <baeuml@gmail.com> -Date: Fri Sep 5 15:03:32 2014 +0200 - - Remove obsolete include of numeric_diff_functor.h. + This method numerically computes function derivatives in different + scales, extrapolating between intermediate results to conserve function + evaluations. Adaptive differentiation is essential to produce accurate + results for functions with noisy derivatives. - numeric_diff_functor.h was removed and does not exist anymore. + Full changelist: + -Created a new type of NumericDiffMethod (RIDDERS). + -Implemented EvaluateRiddersJacobianColumn in NumericDiff. + -Created unit tests with f(x) = x^2 + [random noise] and + f(x) = exp(x). - Change-Id: I07bf04bf81142551e867b95b83a0653e11cad54c + Change-Id: I2d6e924d7ff686650272f29a8c981351e6f72091 -commit b7fb6056a717cc3c372cfb7115c527ee8bc05ddb +commit 070bba4b43b4b7449628bf456a10452fd2b34d28 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Sep 3 11:19:02 2014 -0700 +Date: Tue Aug 25 13:37:33 2015 -0700 - Remove NumericDiffFunctor. + Lint fixes from William Rucklidge - Its API was broken, and its implementation was an unnecessary - layer of abstraction over CostFunctionToFunctor. - - Change-Id: I18fc261fc6a3620b51a9eeb4dde0af03d753af69 + Change-Id: I719e8852859c970091df842e59c44e02e2c65827 -commit 175fa8ff09049110a8509409f60cee5fd52cdbe6 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Tue Sep 2 06:49:08 2014 -0700 +commit 887a20ca7f02a1504e35f7cabbdfb2e0842a0b0b +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Wed Aug 12 21:41:43 2015 +0100 - CostFunctionToFunctor allows dynamic number of residuals. + Build position independent code when compiling Ceres statically. - The code itself was perfectly capable of handling residuals, but there - was an overly strict runtime check that had to be removed. + - Previously, when Ceres was built as a static library we did not + compile position independent code. This means that the resulting + static library could not be linked against shared libraries, but + could be used by executables. + - To enable the use of a static Ceres library by other shared libraries + as reported in [1], the static library must be generated from + position independent code (except on Windows, where PIC does not + apply). - Thanks to Domink Reitzle for reporting this. + [1] https://github.com/Itseez/opencv_contrib/pull/290#issuecomment-130389471 - Change-Id: I6a6d000a7c5203dd5945a61b4caeda1b8aeb09c9 + Change-Id: I99388f1784ece688f91b162d009578c5c97ddaf6 -commit 70ace0d5a5601901288974fcf27919754260cf0e -Author: Johannes Schönberger <hannesschoenberger@gmail.com> -Date: Sat Aug 30 15:52:34 2014 -0400 - - Fix max. linear solver iterations in ConjugateGradientsSolver - - Change-Id: Ice0cef46441dbc1c121eeb42113667a46c96936f - -commit c5d8d0680250f5eb554577d30d28fc805b03fab9 +commit 860bba588b981a5718f6b73e7e840e5b8757fe65 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Fri Aug 29 20:31:19 2014 -0700 +Date: Tue Aug 25 09:43:21 2015 -0700 - Fix a unused function error with Eigen version 3.2.1 or less. + Fix a bug in DetectStructure - Thanks to Johannes Schoenberger for reporting this. + The logic for determing static/dynamic f-block size in + DetectStructure was broken in a corner case, where the very first + row block which was used to initialize the f_block_size contained + more than one f blocks of varying sizes. The way the if block + was structured, no iteration was performed on the remaining + f-blocks and the loop failed to detect that the f-block size + was actually changing. - Change-Id: Ie17d28f2a68734a978a8c95007724bc4055de43a - -commit 0e1cc2a55488e4cf381833baaa3531c02ce9d69e -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Fri Aug 29 09:16:56 2014 -0700 - - Fix the build on Eigen version 3.2.1 and older. + If in the remaining row blocks, there were no row blocks + with varying f-block sizes, the function will erroneously + return a static f-block size. + + Thanks to Johannes Schonberger for providing a reproduction for this + rather tricky corner case. - Change-Id: I18f5cb5d42113737d7b8f78a67acee28bd5b3e08 + Change-Id: Ib442a041d8b7efd29f9653be6a11a69d0eccd1ec -commit 5f96c62b56222f27e606f2246a8a16b6942af8d1 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 23:06:17 2014 -0700 +commit b0cbc0f0b0a22f01724b7b647a4a94db959cc4e4 +Author: Johannes Schönberger <hannesschoenberger@gmail.com> +Date: Thu Aug 20 14:21:30 2015 -0400 - Add Block AMD ordering for SPARSE_SCHUR + EIGEN_SPARSE. - - Ordering routines for the Schur complement when using EIGEN_SPARSE. - Also integration into SchurComplementSolver. - - Part of this CL is also a refactoring of the block jacobian matrix - construction. + Reduce memory footprint of SubsetParameterization - Change-Id: I11d665cc7d4867c64190e6fed1118f4d2e13d59b + Change-Id: If113cb4696d5aef3e50eed01fba7a3d4143b7ec8 -commit 7344626c04d19ca1dc4871c377c4422c744b1bca -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 22:03:09 2014 -0700 +commit ad2a99777786101411a971e59576ca533a297013 +Author: Sergey Sharybin <sergey.vfx@gmail.com> +Date: Sat Aug 22 11:18:45 2015 +0200 - Let EIGEN_SPARSE + SPARSE_NORMAL_CHOLESKY use block AMD. + Fix for reoder program unit test when built without suitesparse - Modify SparseNormalCholeskySolver to use a pre-ordered Jacobian - matrix. + This commit fixes failure of reorder_program_test when Ceres is built without + any suitesparse. - Change-Id: Ib4d725d7a2d7bb94ea76dbb3a9b172784dbc8ea0 + Change-Id: Ia23ae8dfd20c482cb9cd1301f17edf9a34df3235 -commit 9f7032369ea4e432f0fb507cb6d2209741ee6946 +commit 4bf3868beca9c17615f72ec03730cddb3676acaa Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 21:46:43 2014 -0700 +Date: Sun Aug 9 15:24:45 2015 -0700 - Block AMD for SparseNormalCholesky + EIGEN_SPARSE. + Fix a bug in the Schur eliminator - This is just the reordering routine. The integration with - SparseNormalCholesky shall happen in a subsequent CL. + The schur eliminator treats rows with e blocks and row with + no e blocks separately. The template specialization logic only + applies to the rows with e blocks. - Change-Id: I39ddc32aa66b11c368faf75404850fa0ae0d2b3a - -commit b9331cd4077100d645be22a912d5743eeda72878 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 14:42:27 2014 -0700 - - Cleanup reorder_program.cc + So, in cases where the rows with e-blocks have a fixed size f-block + but the rows without e-blocks have f-blocks of varying sizes, + DetectStructure will return a static f-block size, but we need to be + careful that we do not blindly use that static f-block size everywhere. - Program::SetParameterOffsetsAndIndex() was being called willy nilly. - Now the invariant is that any function that actually reorders the - program, updates the offsets and indices. + This patch fixes a bug where such care was not being taken, where + it was assumed that the static f-block size could be assumed for all + f-block sizes. - Also the logic around handling EIGEN_SPARSE has been simplified in - anticipation of the block AMD code that is forthcoming. + A new test is added, which triggers an exception in debug mode. In + release mode this error does not present itself, due to a peculiarity + of the way Eigen works. - Last but not the least, num_eliminate_blocks, which is a rather - cryptic name to begin with has been replaced by the more meaningful - size_of_first_elimination_group. + Thanks to Werner Trobin for reporting this bug. - Change-Id: I77e684f699a93b53e76aa406d64f40f8704df813 + Change-Id: I8ae7aabf8eed8c3f9cf74b6c74d632ba44f82581 -commit 79491a3f4a3939a3cce4644da7a998b7782b963a +commit 1635ce726078f00264b89d7fb6e76fd1c2796e59 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 13:57:50 2014 -0700 +Date: Wed Aug 19 00:26:02 2015 -0700 - Solver::FullReport now reports build config. + Fix a bug in the reordering code. - The header of Summary::FullReport now looks like + When the user provides an ordering which starts at a non-zero group id, + or has gaps in the groups, then CAMD, the algorithm used to reorder + the program can crash or return garbage results. - Solver Summary (v 1.10.0-suitesparse-cxsparse-lapack-no_openmp) + The solution is to map the ordering into grouping constraints, and then + to re-number the groups to be contiguous using a call to + MapValuesToContiguousRange. This was already done for CAMD based + ordering for Schur type solvers, but was not done for SPARSE_NORMAL_CHOLESKY. - Original Reduced - Parameter blocks 22122 22122 - Parameters 66462 66462 - Residual blocks 83718 83718 - Residual 167436 167436 + Thanks to Bernhard Zeisl for not only reporting the bug but also + providing a reproduction. - Change-Id: Id1b81bbf90ba412d19e2dd3687eeb9d372b72c1b + Change-Id: I5cfae222d701dfdb8e1bda7f0b4670a30417aa89 -commit 48068c753e91d77f6c96ef2d529a27ef8ee3947c -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 13:03:40 2014 -0700 +commit 4c3f8987e7f0c51fd367cf6d43d7eb879e79589f +Author: Simon Rutishauser <simon.rutishauser@pix4d.com> +Date: Thu Aug 13 11:10:44 2015 +0200 - Lint cleanup from William Rucklidge. + Add missing CERES_EXPORT to ComposedLoss - Change-Id: Ie0e0aa58440be7a4f67dcd633dbb6f1bb0c051a8 + Change-Id: Id7db388d41bf53e6e5704039040c9d2c6bf4c29c -commit 6a51b135e6298e8ba44a58cc2b54a170ab61a82f +commit 1a740cc787b85b883a0703403a99fe49662acb79 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Aug 28 10:48:29 2014 -0700 +Date: Tue Aug 11 18:08:05 2015 -0700 - Fix solver_test.cc + Add the option to use numeric differentiation to nist and more_garbow_hillstrom - When Eigen is not installed, Solver::IsValid was not detecting - it correctly. - - Change-Id: Id285a84d829a9e20bc5de663adfca66ac31e08f3 + Change-Id: If0a5caef90b524dcf5e2567c5b681987f5459401 -commit 62a8d64453ee41dae56710a4eead3fadf2fe1a4e -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Aug 27 22:54:00 2014 -0700 +commit ea667ede5c038d6bf3d1c9ec3dbdc5072d1beec6 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Aug 9 16:56:13 2015 +0100 - Expand check for lack of a sparse linear algebra library. - - The LinearSolver factory was creating a NULL linear solver - if only Eigen's sparse linear algebra backend was available. + Fix EIGENSPARSE option help s/t it displays in CMake ncurses GUI. - Thanks to Michael Samples and Domink Reitzle for reporting this. + - Shorten description for EIGENSPARSE to a single line, as otherwise + it is not correctly displayed in the ncurses CMake GUI. + - Made explicit in description that this results in an LGPL licensed + version of Ceres (this is also made clear in the CMake log output if + EIGENSPARSE is enabled). - Change-Id: I35e3a6c0fd0da2a31934adb5dfe4cad29577cc73 + Change-Id: I11678a9cbc7a817133c22128da01055a3cb8a26d -commit 12eb389b4ec4113a2260c1a192a1d3f8d1b6a2d3 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Aug 27 22:18:33 2014 -0700 +commit a14ec27fb28ab2e8d7f1c9d88e41101dc6c0aab5 +Author: Richard Stebbing <richie.stebbing@gmail.com> +Date: Fri Aug 7 08:42:03 2015 -0700 - Fix Eigen Row/ColMajor bug in NumericDiffCostFunction. + Fix SparseNormalCholeskySolver with dynamic sparsity. - If the parameter block size is 1, asking Eigen to create - a row-major matrix triggers a compile time error. Previously - we were handling the case where the number of rows in the - jacobian block was known statically, but the problem is present - when the nummber of rows is dynamic. + The previous implementation incorrectly cached the outer product matrix + pattern even when `dynamic_sparsity = true`. - This CL fixes this problem. + Change-Id: I1e58315a9b44f2f457d07c56b203ab2668bfb8a2 + +commit 3dd7fced44ff00197fa9fcb1f2081d12be728062 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Aug 9 16:38:50 2015 +0100 + + Remove legacy dependency detection macros. - Thanks to Dominik Reitzle for reporting this. + - Before the new CMake buildsystem in 1.8, Ceres used non-standard + HINTS variables for dependencies. For backwards compatibility CMake + macros were added to translate these legacy variables into the new + (standard) variables. + - As it has now been multiple releases since the legacy variables + were used and they no longer appear in any of the documentation + support for them has now expired. - Change-Id: I99c3eec3558e66ebf4efa51c4dee8ce292ffe0c1 + Change-Id: I2cc72927ed711142ba7943df334ee008181f86a2 -commit 6c25185bb1643d8d0f3d8e1a7b82a058156aa869 +commit 8b32e258ccce1eed2a50bb002add16cad13aff1e Author: Alex Stewart <alexs.mac@gmail.com> -Date: Thu Aug 28 16:07:51 2014 +0100 +Date: Sun Aug 9 15:42:39 2015 +0100 - Fix crash in Covariance if # threads > 1 requested without OpenMP. + Fix failed if() condition expansion if gflags is not found. - - Previously if options.num_threads > 1 was given to Covariance compiled - without OpenMP, a CHECK() would be triggered in program_evalutor. + - If a CMake-ified version of gflags is not detected, then + gflags_LIBRARIES is not set and the TARGET condition within a + multiconditional if() statement prevents configuration. - Change-Id: Iaade4f5ed5326b0c59a7014c750c41ee026e1124 + Change-Id: Ia92e97523d7a1478ab36539726b9540d7cfee5d0 -commit 6f89d850fb4ace0104abccf467c4fe37ad378b79 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Aug 27 11:51:50 2014 -0700 +commit cc8d47aabb9d63ba4588ba7295058a6191c2df83 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Aug 9 15:18:42 2015 +0100 - Further build breakage fixes. + Update all CMake to lowercase function name style. - 1. Allow the minimum number of linear solver iterations to be zero. - 2. Fix conjugate gradients solver's iteration loop to be sane again. + - Updated to new CMake style where function names are all lowercase, + this will be backwards compatible as CMake function names are + case insensitive. + - Updated using Emacs' M-x unscreamify-cmake-buffer. - Change-Id: I8594815fec940c2b30e28eb58ec5d8baacf13dae + Change-Id: If7219816f560270e59212813aeb021353a64a0e2 -commit dd596d0f0d6d08951efc2c11a639b546db2080c6 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Wed Aug 27 11:26:50 2014 -0700 +commit 1f106904c1f47460c35ac03258d6506bb2d60838 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Aug 9 14:55:02 2015 +0100 - Fix the broken build. + Update minimum iOS version to 7.0 for shared_ptr/unordered_map. + + - In order to correctly detect shared_ptr (& unordered_map) + the iOS version must be >= 7.0 (Xcode 5.0+). This only affects the + SIMULATOR(64) platform builds, as the OS (device) build uses the + latest SDK which is now likely 8.0+. - Change-Id: I083cf1cca1bf4cca956193022d450364e73f833a + Change-Id: Iefec8f03408b8cdc7a495f442ebba081f800adb0 -commit d906afae22b05b9b9a9a2657924f4c0bf1a9b5ea -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Mon Aug 25 22:32:38 2014 -0700 +commit 16ecd40523a408e7705c9fdb0e159cef2007b8ab +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sat Aug 8 17:32:31 2015 +0100 - A number of bug fixes. + Fix bug in gflags' <= 2.1.2 exported CMake configuration. - 1. Fix a build breakage in graph_test. - 2. Respect Solver::Options::min_num_linear_solver_iterations in - conjugate_gradients_solver.cc + - gflags <= 2.1.2 has a bug in its exported gflags-config.cmake: + https://github.com/gflags/gflags/issues/110 whereby it sets + gflags_LIBRARIES to a non-existent 'gflags' target. + - This causes linker errors if gflags is installed in a non-standard + location (as otherwise CMake resolves gflags to -lgflags which + links if gflags is installed somewhere on the current path). + - We now check for this case, and search for the correct gflags imported + target and update gflags_LIBRARIES to reference it if found, otherwise + proceed on to the original manual search to try to find gflags. - Thanks to Johannes Schönberger for reporting these. - - Change-Id: Ib32e3929bf5d92dd576ae5b53d4d88797095136e + Change-Id: Iceccc3ee53c7c2010e41cc45255f966e7b13d526 -commit dab955928c6d0942d6acc5b5f1c4c11260d0767d -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sun Aug 17 13:14:50 2014 -0700 +commit 56be8de007dfd65ed5a31c795eb4a08ad765f411 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Thu Jun 25 21:31:00 2015 +0100 - Add an unweighted graph. - - Rename Graph -> WeightedGraph. - Add a new Graph class, which is cheaper to construct and - work with if the weights are not needed. + Add docs for new CXX11 option & mask option for Windows. - This cuts down the cost of building the Hessian graph - significantly. + - The CXX11 option has no effect on Windows, as there, any new C++11 + features are enabled by default, as such to avoid confusion we only + present the option for non-Windows. - Change-Id: Id0cfc81dd2c0bb5ff8f63a1b55aa133c53c0c869 + Change-Id: I38925ae3bb8c16682d404468ba95c611a519b9b9 -commit a0c282adbd268c2ad82551fab31fe1cf8d0c4282 +commit cf863b6415ac4dbf3626e70adeac1ac0f3d87ee5 Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Sun Aug 24 22:19:03 2014 -0700 +Date: Thu Aug 6 14:52:18 2015 -0700 - Add EIGEN_STRONG_INLINE annotation to jet.h + Remove the spec file needed for generating RPMs. - This improves performance when using MSVC on Windows. On GCC - there will be no effect. + Now that ceres is part of RawHide, there is no need to carry + this spec file with the ceres distribution. - Change-Id: I555a81ff6823c2855d64773073f75af50c48d716 + Change-Id: Icc400b9874ba05ba05b353e2658f1de94c72299e -commit 20de0a7793c574e964350a623446136889f74632 -Author: Björn Piltz <bjornpiltz@gmail.com> -Date: Mon Aug 25 17:05:54 2014 +0200 +commit 560940fa277a469c1ab34f1aa303ff1af9c3cacf +Author: Sameer Agarwal <sameeragarwal@google.com> +Date: Sat Jul 11 22:21:31 2015 -0700 - Fixed Malformed regex + A refactor of the cubic interpolation code - I got the following error with MSVC: - Syntax error at index 9 in simple regular expression "NumGroups()": '(' is unsupported. + 1. Push the boundary handling logic into the underlying array + object. This has two very significant impacts: - Change-Id: Id1952831d81d3eb5d73bbed8c311914c4c8ab51f + a. The interpolation code becomes extremely simple to write + and to test. + + b. The user has more flexibility in implementing how out of bounds + values are handled. We provide one default implementation. + + Change-Id: Ic2f6cf9257ce7110c62e492688e5a6c8be1e7df2 -commit ccf8aea988269841d84d746e52164d5056c67a10 -Author: Björn Piltz <bjornpiltz@gmail.com> -Date: Mon Aug 25 16:16:01 2014 +0200 +commit dfdf19e111c2b0e6daeb6007728ec2f784106d49 +Author: Sameer Agarwal <sameeragarwal@google.com> +Date: Wed Aug 5 15:20:57 2015 -0700 - Fixed MSVC error C2124: divide or mod by zero - - Alternatively, if quiet_NaN is not available on all platforms a workaround would be: - volatile double zero = 0.0; - double x = 1.0/zero; - The 'volatile' is needed to shut up "warning C4723: potential divide by 0". + Lint cleanup from Jim Roseborough - Change-Id: If2bbdab8540595aa2e0079e1eb6b6fed6d4a6ef7 + Change-Id: Id6845c85644d40e635ed196ca74fc51a387aade4 -commit 8de27be218d42b282d7f15867733ad07058b0887 +commit 7444f23ae245476a7ac8421cc2f88d6947fd3e5f Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Tue Aug 19 08:22:40 2014 -0700 +Date: Mon Aug 3 12:22:44 2015 -0700 - Fix a bug in TrustRegionPreprocessor + Fix a typo in small_blas.h - TrustRegionPreprocessor was not setting Minimizer::Options::is_constrained. - This meant that the line search for bounds constraints was not being - invoked for bounds constrained problems. + The reason this rather serious looking typo has not + caused any problems uptil now is because NUM_ROW_B is + computed but never actually used. - And some minor lint cleanup. + Thanks to Werner Trobin for pointing this out. - Change-Id: I18852cfaf1b33fd90b7d8c196f2063c128126658 + Change-Id: Id2b4d9326ec21baec8a85423e3270aefbafb611e -commit 1745dd615b3897a3ef9896acfdba67eee1739bf4 -Author: Sameer Agarwal <sameeragarwal@google.com> -Date: Thu Jun 5 21:30:13 2014 -0700 +commit 5a48b92123b30a437f031eb24b0deaadc8f60d26 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sat Jul 4 17:59:52 2015 +0100 - Refactor SolverImpl. - - Replace SolverImpl with + Export Ceres build directory into local CMake package registry. - a. A minimizer specific preprocessor class. - b. A generic Solve function inside solver.cc - c. Presummarize and Postsummarize functions to handle - updates to the summary object. + - Optionally use CMake's export() functionality to export the Ceres + build directory as a package into the local CMake package registry. + - This enables the detection & use of Ceres from CMake *without* + requiring that Ceres be installed. - The existing SolverImpl class was a mixture of the above three - things and was increasingly complicated code to follow. This change, - breaks it into its three separate constituents, with the aims of - better separation of concerns and thus better testability and - reliability. + Change-Id: Ib5a7588446f490e1b405878475b6b1dd13accd1f + +commit d9790e77894ea99d38137d359d6118315b2d1601 +Author: Sameer Agarwal <sameeragarwal@google.com> +Date: Sun Jul 12 19:39:47 2015 -0700 + + Add ProductParameterization - The call to Solver::Solve() now consists of + Often a parameter block is the Cartesian product of a number of + manifolds. For example, a rigid transformation SE(3) = SO(3) x R^3 + In such cases, where you have the local parameterization + of the individual manifolds available, + ProductParameterization can be used to construct a local + parameterization of the cartesian product. - 1. Presummarize - summarize the given state of the problem and solver - options. - 2. Preprocess - Setup everything that is needed to call the minimizer. - This includes, removing redundant parameter and residual blocks, - setting up the reordering for the linear solver, creating the - linear solver, evaluator, inner iteration minimizer etc. - 3. Minimize. - 4. Post summarize - summarize the result of the preprocessing and the - solve. + Change-Id: I4b5bcbd2407a38739c7725b129789db5c3d65a20 + +commit 7b4fb69dad49eaefb5d2d47ef0d76f48ad7fef73 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Sun Jun 28 21:43:46 2015 +0100 + + Cleanup FindGflags & use installed gflags CMake config if present. + + - Split out gflags namespace detection methods: + check_cxx_source_compiles() & regex, into separate functions. + - Use installed/exported gflags CMake configuration (present for + versions >= 2.1) if available, unless user expresses a preference not + to, or specifies search directories, in which case fall back to manual + search for components. + -- Prefer installed gflags CMake configurations over exported gflags + build directories on all OSs. + - Remove custom version of check_cxx_source_compiles() that attempted + to force the build type of the test project. This only worked for + NMake on Windows, not MSVC as msbuild ignored our attempts to force + the build type. Now we always use the regex method on Windows if + we cannot find an installed gflags CMake configuration which works + even on MSVC by bypassing msbuild. + - Add default search paths for gflags on Windows. + + Change-Id: I083b267d97a7a5838a1314f3d41a61ae48d5a2d7 + +commit b3063c047906d4a44503dc0187fdcbbfcdda5f38 +Author: Alex Stewart <alexs.mac@gmail.com> +Date: Wed Jul 15 20:56:56 2015 +0100 + + Add default glog install location on Windows to search paths. - Change-Id: I80f35cfc9f2cbf78f1df4aceace27075779d8a3a + Change-Id: I083d368be48986e6780c11460f5a07b2f3b6c900 diff --git a/extern/libmv/third_party/ceres/SConscript b/extern/libmv/third_party/ceres/SConscript index f53d54ba94b..7b46083f386 100644 --- a/extern/libmv/third_party/ceres/SConscript +++ b/extern/libmv/third_party/ceres/SConscript @@ -1,4 +1,4 @@ -#!/usr/bin/python +#!/usr/bin/env python # NOTE: This file is automatically generated by bundle.sh script # If you're doing changes in this file, please update template diff --git a/extern/libmv/third_party/ceres/bundle.sh b/extern/libmv/third_party/ceres/bundle.sh index 0becc87dd4f..0418356c6f4 100755 --- a/extern/libmv/third_party/ceres/bundle.sh +++ b/extern/libmv/third_party/ceres/bundle.sh @@ -129,7 +129,7 @@ set(INC ) set(INC_SYS - ${EIGEN3_INCLUDE_DIRS} + \${EIGEN3_INCLUDE_DIRS} ) set(SRC diff --git a/extern/libmv/third_party/ceres/config/ceres/internal/config.h b/extern/libmv/third_party/ceres/config/ceres/internal/config.h index c9d2c16e865..1cf034ded5f 100644 --- a/extern/libmv/third_party/ceres/config/ceres/internal/config.h +++ b/extern/libmv/third_party/ceres/config/ceres/internal/config.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -30,13 +30,16 @@ // Default (empty) configuration options for Ceres. // -// IMPORTANT: Most users of Ceres will not use this file, when compiling Ceres -// with CMake, CMake will configure a new config.h with the currently -// selected Ceres compile options and copy it into the source -// directory before compilation. However, for some users of Ceres -// who compile without CMake, this file ensures that Ceres will -// compile, with the user either specifying manually the Ceres -// compile options, or passing them directly through the compiler. +// IMPORTANT: Most users of Ceres will not use this file, when +// compiling Ceres with CMake, CMake will configure a new +// config.h with the currently selected Ceres compile +// options in <BUILD_DIR>/config, which will be added to +// the include path for compilation, and installed with the +// public Ceres headers. However, for some users of Ceres +// who compile without CMake (Android), this file ensures +// that Ceres will compile, with the user either specifying +// manually the Ceres compile options, or passing them +// directly through the compiler. #ifndef CERES_PUBLIC_INTERNAL_CONFIG_H_ #define CERES_PUBLIC_INTERNAL_CONFIG_H_ diff --git a/extern/libmv/third_party/ceres/files.txt b/extern/libmv/third_party/ceres/files.txt index d1bd69672c8..976200b6229 100644 --- a/extern/libmv/third_party/ceres/files.txt +++ b/extern/libmv/third_party/ceres/files.txt @@ -157,8 +157,6 @@ internal/ceres/graph_algorithms.h internal/ceres/graph.h internal/ceres/implicit_schur_complement.cc internal/ceres/implicit_schur_complement.h -internal/ceres/incomplete_lq_factorization.cc -internal/ceres/incomplete_lq_factorization.h internal/ceres/integral_types.h internal/ceres/iterative_schur_complement_solver.cc internal/ceres/iterative_schur_complement_solver.h diff --git a/extern/libmv/third_party/ceres/include/ceres/autodiff_cost_function.h b/extern/libmv/third_party/ceres/include/ceres/autodiff_cost_function.h index 7c0fa79ad0b..e7893e4828e 100644 --- a/extern/libmv/third_party/ceres/include/ceres/autodiff_cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/autodiff_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/autodiff_local_parameterization.h b/extern/libmv/third_party/ceres/include/ceres/autodiff_local_parameterization.h index c100d4825d2..27397e20d3b 100644 --- a/extern/libmv/third_party/ceres/include/ceres/autodiff_local_parameterization.h +++ b/extern/libmv/third_party/ceres/include/ceres/autodiff_local_parameterization.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -33,9 +33,9 @@ #ifndef CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_ #define CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_ +#include "ceres/local_parameterization.h" #include "ceres/internal/autodiff.h" #include "ceres/internal/scoped_ptr.h" -#include "ceres/local_parameterization.h" namespace ceres { diff --git a/extern/libmv/third_party/ceres/include/ceres/c_api.h b/extern/libmv/third_party/ceres/include/ceres/c_api.h index 71f41fd226b..df7c9b6d671 100644 --- a/extern/libmv/third_party/ceres/include/ceres/c_api.h +++ b/extern/libmv/third_party/ceres/include/ceres/c_api.h @@ -1,6 +1,6 @@ /* Ceres Solver - A fast non-linear least squares minimizer - * Copyright 2013 Google Inc. All rights reserved. - * http://code.google.com/p/ceres-solver/ + * Copyright 2015 Google Inc. All rights reserved. + * http://ceres-solver.org/ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/ceres.h b/extern/libmv/third_party/ceres/include/ceres/ceres.h index 7c8981e2994..64ffb99798a 100644 --- a/extern/libmv/third_party/ceres/include/ceres/ceres.h +++ b/extern/libmv/third_party/ceres/include/ceres/ceres.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/conditioned_cost_function.h b/extern/libmv/third_party/ceres/include/ceres/conditioned_cost_function.h index 3f0087c7815..29597d935cb 100644 --- a/extern/libmv/third_party/ceres/include/ceres/conditioned_cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/conditioned_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -78,7 +78,7 @@ class CERES_EXPORT ConditionedCostFunction : public CostFunction { // functions, or not, depending on the ownership parameter. Conditioners // may be NULL, in which case the corresponding residual is not modified. ConditionedCostFunction(CostFunction* wrapped_cost_function, - const vector<CostFunction*>& conditioners, + const std::vector<CostFunction*>& conditioners, Ownership ownership); virtual ~ConditionedCostFunction(); @@ -88,7 +88,7 @@ class CERES_EXPORT ConditionedCostFunction : public CostFunction { private: internal::scoped_ptr<CostFunction> wrapped_cost_function_; - vector<CostFunction*> conditioners_; + std::vector<CostFunction*> conditioners_; Ownership ownership_; }; diff --git a/extern/libmv/third_party/ceres/include/ceres/cost_function.h b/extern/libmv/third_party/ceres/include/ceres/cost_function.h index fe8fc07d2ce..f051a897c0d 100644 --- a/extern/libmv/third_party/ceres/include/ceres/cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -115,7 +115,7 @@ class CERES_EXPORT CostFunction { double* residuals, double** jacobians) const = 0; - const vector<int32>& parameter_block_sizes() const { + const std::vector<int32>& parameter_block_sizes() const { return parameter_block_sizes_; } @@ -124,7 +124,7 @@ class CERES_EXPORT CostFunction { } protected: - vector<int32>* mutable_parameter_block_sizes() { + std::vector<int32>* mutable_parameter_block_sizes() { return ¶meter_block_sizes_; } @@ -135,7 +135,7 @@ class CERES_EXPORT CostFunction { private: // Cost function signature metadata: number of inputs & their sizes, // number of outputs (residuals). - vector<int32> parameter_block_sizes_; + std::vector<int32> parameter_block_sizes_; int num_residuals_; CERES_DISALLOW_COPY_AND_ASSIGN(CostFunction); }; diff --git a/extern/libmv/third_party/ceres/include/ceres/cost_function_to_functor.h b/extern/libmv/third_party/ceres/include/ceres/cost_function_to_functor.h index b4a516e0ab1..6c67ac0f937 100644 --- a/extern/libmv/third_party/ceres/include/ceres/cost_function_to_functor.h +++ b/extern/libmv/third_party/ceres/include/ceres/cost_function_to_functor.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -29,7 +29,7 @@ // Author: sameeragarwal@google.com (Sameer Agarwal) // // CostFunctionToFunctor is an adapter class that allows users to use -// CostFunction objects in templated functors which are to be used for +// SizedCostFunction objects in templated functors which are to be used for // automatic differentiation. This allows the user to seamlessly mix // analytic, numeric and automatic differentiation. // @@ -37,7 +37,7 @@ // // class IntrinsicProjection : public SizedCostFunction<2, 5, 3> { // public: -// IntrinsicProjection(const double* observations); +// IntrinsicProjection(const double* observation); // virtual bool Evaluate(double const* const* parameters, // double* residuals, // double** jacobians) const; @@ -62,10 +62,8 @@ // Then we can now do the following, // // struct CameraProjection { -// CameraProjection(double* observation) { -// intrinsic_projection_.reset( -// new CostFunctionToFunctor<2, 5, 3>( -// new IntrinsicProjection(observation_))); +// CameraProjection(const double* observation) +// : intrinsic_projection_(new IntrinsicProjection(observation)) { // } // template <typename T> // bool operator()(const T* rotation, @@ -79,11 +77,11 @@ // // Note that we call intrinsic_projection_, just like it was // // any other templated functor. // -// return (*intrinsic_projection_)(intrinsics, transformed_point, residual); +// return intrinsic_projection_(intrinsics, transformed_point, residual); // } // // private: -// scoped_ptr<CostFunctionToFunctor<2,5,3> > intrinsic_projection_; +// CostFunctionToFunctor<2,5,3> intrinsic_projection_; // }; #ifndef CERES_PUBLIC_COST_FUNCTION_TO_FUNCTOR_H_ @@ -93,6 +91,7 @@ #include <vector> #include "ceres/cost_function.h" +#include "ceres/dynamic_cost_function_to_functor.h" #include "ceres/internal/fixed_array.h" #include "ceres/internal/port.h" #include "ceres/internal/scoped_ptr.h" @@ -104,28 +103,29 @@ template <int kNumResiduals, int N5 = 0, int N6 = 0, int N7 = 0, int N8 = 0, int N9 = 0> class CostFunctionToFunctor { public: + // Takes ownership of cost_function. explicit CostFunctionToFunctor(CostFunction* cost_function) - : cost_function_(cost_function) { + : cost_functor_(cost_function) { CHECK_NOTNULL(cost_function); CHECK(kNumResiduals > 0 || kNumResiduals == DYNAMIC); // This block breaks the 80 column rule to keep it somewhat readable. CHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0))) + ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0))) // NOLINT << "Zero block cannot precede a non-zero block. Block sizes are " << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", " << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", " << N8 << ", " << N9; - const vector<int32>& parameter_block_sizes = + const std::vector<int32>& parameter_block_sizes = cost_function->parameter_block_sizes(); const int num_parameter_blocks = (N0 > 0) + (N1 > 0) + (N2 > 0) + (N3 > 0) + (N4 > 0) + @@ -160,7 +160,7 @@ class CostFunctionToFunctor { CHECK_EQ(N8, 0); CHECK_EQ(N9, 0); - return cost_function_->Evaluate(&x0, residuals, NULL); + return cost_functor_(&x0, residuals); } bool operator()(const double* x0, @@ -179,7 +179,7 @@ class CostFunctionToFunctor { internal::FixedArray<const double*> parameter_blocks(2); parameter_blocks[0] = x0; parameter_blocks[1] = x1; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -200,7 +200,7 @@ class CostFunctionToFunctor { parameter_blocks[0] = x0; parameter_blocks[1] = x1; parameter_blocks[2] = x2; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -223,7 +223,7 @@ class CostFunctionToFunctor { parameter_blocks[1] = x1; parameter_blocks[2] = x2; parameter_blocks[3] = x3; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -248,7 +248,7 @@ class CostFunctionToFunctor { parameter_blocks[2] = x2; parameter_blocks[3] = x3; parameter_blocks[4] = x4; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -275,7 +275,7 @@ class CostFunctionToFunctor { parameter_blocks[3] = x3; parameter_blocks[4] = x4; parameter_blocks[5] = x5; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -304,7 +304,7 @@ class CostFunctionToFunctor { parameter_blocks[4] = x4; parameter_blocks[5] = x5; parameter_blocks[6] = x6; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -335,7 +335,7 @@ class CostFunctionToFunctor { parameter_blocks[5] = x5; parameter_blocks[6] = x6; parameter_blocks[7] = x7; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -368,7 +368,7 @@ class CostFunctionToFunctor { parameter_blocks[6] = x6; parameter_blocks[7] = x7; parameter_blocks[8] = x8; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } bool operator()(const double* x0, @@ -403,7 +403,7 @@ class CostFunctionToFunctor { parameter_blocks[7] = x7; parameter_blocks[8] = x8; parameter_blocks[9] = x9; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); + return cost_functor_(parameter_blocks.get(), residuals); } template <typename JetT> @@ -418,7 +418,7 @@ class CostFunctionToFunctor { CHECK_EQ(N7, 0); CHECK_EQ(N8, 0); CHECK_EQ(N9, 0); - return EvaluateWithJets(&x0, residuals); + return cost_functor_(&x0, residuals); } template <typename JetT> @@ -438,7 +438,7 @@ class CostFunctionToFunctor { internal::FixedArray<const JetT*> jets(2); jets[0] = x0; jets[1] = x1; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -460,7 +460,7 @@ class CostFunctionToFunctor { jets[0] = x0; jets[1] = x1; jets[2] = x2; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -484,7 +484,7 @@ class CostFunctionToFunctor { jets[1] = x1; jets[2] = x2; jets[3] = x3; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -510,7 +510,7 @@ class CostFunctionToFunctor { jets[2] = x2; jets[3] = x3; jets[4] = x4; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -538,7 +538,7 @@ class CostFunctionToFunctor { jets[3] = x3; jets[4] = x4; jets[5] = x5; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -568,7 +568,7 @@ class CostFunctionToFunctor { jets[4] = x4; jets[5] = x5; jets[6] = x6; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -600,7 +600,7 @@ class CostFunctionToFunctor { jets[5] = x5; jets[6] = x6; jets[7] = x7; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -634,7 +634,7 @@ class CostFunctionToFunctor { jets[6] = x6; jets[7] = x7; jets[8] = x8; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } template <typename JetT> @@ -670,79 +670,11 @@ class CostFunctionToFunctor { jets[7] = x7; jets[8] = x8; jets[9] = x9; - return EvaluateWithJets(jets.get(), residuals); + return cost_functor_(jets.get(), residuals); } private: - template <typename JetT> - bool EvaluateWithJets(const JetT** inputs, JetT* output) const { - const int kNumParameters = N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9; - const vector<int32>& parameter_block_sizes = - cost_function_->parameter_block_sizes(); - const int num_parameter_blocks = parameter_block_sizes.size(); - const int num_residuals = cost_function_->num_residuals(); - - internal::FixedArray<double> parameters(kNumParameters); - internal::FixedArray<double*> parameter_blocks(num_parameter_blocks); - internal::FixedArray<double> jacobians(num_residuals * kNumParameters); - internal::FixedArray<double*> jacobian_blocks(num_parameter_blocks); - internal::FixedArray<double> residuals(num_residuals); - - // Build a set of arrays to get the residuals and jacobians from - // the CostFunction wrapped by this functor. - double* parameter_ptr = parameters.get(); - double* jacobian_ptr = jacobians.get(); - for (int i = 0; i < num_parameter_blocks; ++i) { - parameter_blocks[i] = parameter_ptr; - jacobian_blocks[i] = jacobian_ptr; - for (int j = 0; j < parameter_block_sizes[i]; ++j) { - *parameter_ptr++ = inputs[i][j].a; - } - jacobian_ptr += num_residuals * parameter_block_sizes[i]; - } - - if (!cost_function_->Evaluate(parameter_blocks.get(), - residuals.get(), - jacobian_blocks.get())) { - return false; - } - - // Now that we have the incoming Jets, which are carrying the - // partial derivatives of each of the inputs w.r.t to some other - // underlying parameters. The derivative of the outputs of the - // cost function w.r.t to the same underlying parameters can now - // be computed by applying the chain rule. - // - // d output[i] d output[i] d input[j] - // -------------- = sum_j ----------- * ------------ - // d parameter[k] d input[j] d parameter[k] - // - // d input[j] - // -------------- = inputs[j], so - // d parameter[k] - // - // outputJet[i] = sum_k jacobian[i][k] * inputJet[k] - // - // The following loop, iterates over the residuals, computing one - // output jet at a time. - for (int i = 0; i < num_residuals; ++i) { - output[i].a = residuals[i]; - output[i].v.setZero(); - - for (int j = 0; j < num_parameter_blocks; ++j) { - const int32 block_size = parameter_block_sizes[j]; - for (int k = 0; k < parameter_block_sizes[j]; ++k) { - output[i].v += - jacobian_blocks[j][i * block_size + k] * inputs[j][k].v; - } - } - } - - return true; - } - - private: - internal::scoped_ptr<CostFunction> cost_function_; + DynamicCostFunctionToFunctor cost_functor_; }; } // namespace ceres diff --git a/extern/libmv/third_party/ceres/include/ceres/covariance.h b/extern/libmv/third_party/ceres/include/ceres/covariance.h index 35fde4de05d..dd20dc36ba1 100644 --- a/extern/libmv/third_party/ceres/include/ceres/covariance.h +++ b/extern/libmv/third_party/ceres/include/ceres/covariance.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -183,7 +183,7 @@ class CovarianceImpl; // Covariance::Options options; // Covariance covariance(options); // -// vector<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)); @@ -353,10 +353,11 @@ class CERES_EXPORT Covariance { // Covariance::Options for more on the conditions under which this // function returns false. bool Compute( - const vector<pair<const double*, const double*> >& covariance_blocks, + const std::vector<std::pair<const double*, + const double*> >& covariance_blocks, Problem* problem); - // Return the block of the covariance matrix corresponding to + // Return the block of the cross-covariance matrix corresponding to // parameter_block1 and parameter_block2. // // Compute must be called before the first call to @@ -373,6 +374,26 @@ class CERES_EXPORT Covariance { const double* parameter_block2, double* covariance_block) const; + // Return the block of the cross-covariance matrix corresponding to + // parameter_block1 and parameter_block2. + // Returns cross-covariance in the tangent space if a local + // parameterization is associated with either parameter block; + // else returns cross-covariance in the ambient space. + // + // Compute must be called before the first call to + // GetCovarianceBlock and the pair <parameter_block1, + // parameter_block2> OR the pair <parameter_block2, + // parameter_block1> must have been present in the vector + // covariance_blocks when Compute was called. Otherwise + // GetCovarianceBlock will return false. + // + // covariance_block must point to a memory location that can store a + // parameter_block1_local_size x parameter_block2_local_size matrix. The + // returned covariance will be a row-major matrix. + bool GetCovarianceBlockInTangentSpace(const double* parameter_block1, + const double* parameter_block2, + double* covariance_block) const; + private: internal::scoped_ptr<internal::CovarianceImpl> impl_; }; diff --git a/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h b/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h index d2d62894194..23687c4670e 100644 --- a/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h +++ b/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -74,9 +74,9 @@ struct CERES_EXPORT CRSMatrix { // cols = [ 1, 3, 1, 2, 3, 0, 1] // values = [10, 4, 2, -3, 2, 1, 2] - vector<int> cols; - vector<int> rows; - vector<double> values; + std::vector<int> cols; + std::vector<int> rows; + std::vector<double> values; }; } // namespace ceres diff --git a/extern/libmv/third_party/ceres/include/ceres/dynamic_autodiff_cost_function.h b/extern/libmv/third_party/ceres/include/ceres/dynamic_autodiff_cost_function.h index f9342cdbab9..e6d26111f18 100644 --- a/extern/libmv/third_party/ceres/include/ceres/dynamic_autodiff_cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/dynamic_autodiff_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -120,18 +120,18 @@ class DynamicAutoDiffCostFunction : public CostFunction { 0); // Allocate scratch space for the strided evaluation. - vector<Jet<double, Stride> > input_jets(num_parameters); - vector<Jet<double, Stride> > output_jets(num_residuals()); + std::vector<Jet<double, Stride> > input_jets(num_parameters); + std::vector<Jet<double, Stride> > output_jets(num_residuals()); // Make the parameter pack that is sent to the functor (reused). - vector<Jet<double, Stride>* > jet_parameters(num_parameter_blocks, + std::vector<Jet<double, Stride>* > jet_parameters(num_parameter_blocks, static_cast<Jet<double, Stride>* >(NULL)); int num_active_parameters = 0; // To handle constant parameters between non-constant parameter blocks, the // start position --- a raw parameter index --- of each contiguous block of // non-constant parameters is recorded in start_derivative_section. - vector<int> start_derivative_section; + std::vector<int> start_derivative_section; bool in_derivative_section = false; int parameter_cursor = 0; diff --git a/extern/libmv/third_party/ceres/include/ceres/dynamic_cost_function_to_functor.h b/extern/libmv/third_party/ceres/include/ceres/dynamic_cost_function_to_functor.h new file mode 100644 index 00000000000..9339a503ea0 --- /dev/null +++ b/extern/libmv/third_party/ceres/include/ceres/dynamic_cost_function_to_functor.h @@ -0,0 +1,190 @@ +// Ceres Solver - A fast non-linear least squares minimizer +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// Author: sameeragarwal@google.com (Sameer Agarwal) +// dgossow@google.com (David Gossow) +// +// DynamicCostFunctionToFunctor allows users to use CostFunction +// objects in templated functors which are to be used for automatic +// differentiation. It works similar to CostFunctionToFunctor, with the +// difference that it allows you to wrap a cost function with dynamic numbers +// of parameters and residuals. +// +// For example, let us assume that +// +// class IntrinsicProjection : public CostFunction { +// public: +// IntrinsicProjection(const double* observation); +// virtual bool Evaluate(double const* const* parameters, +// double* residuals, +// double** jacobians) const; +// }; +// +// is a cost function that implements the projection of a point in its +// local coordinate system onto its image plane and subtracts it from +// the observed point projection. It can compute its residual and +// either via analytic or numerical differentiation can compute its +// jacobians. The intrinsics are passed in as parameters[0] and the point as +// parameters[1]. +// +// Now we would like to compose the action of this CostFunction with +// the action of camera extrinsics, i.e., rotation and +// translation. Say we have a templated function +// +// template<typename T> +// void RotateAndTranslatePoint(double const* const* parameters, +// double* residuals); +// +// Then we can now do the following, +// +// struct CameraProjection { +// CameraProjection(const double* observation) +// : intrinsic_projection_.(new IntrinsicProjection(observation)) { +// } +// template <typename T> +// bool operator()(T const* const* parameters, +// T* residual) const { +// const T* rotation = parameters[0]; +// const T* translation = parameters[1]; +// const T* intrinsics = parameters[2]; +// const T* point = parameters[3]; +// T transformed_point[3]; +// RotateAndTranslatePoint(rotation, translation, point, transformed_point); +// +// // Note that we call intrinsic_projection_, just like it was +// // any other templated functor. +// const T* projection_parameters[2]; +// projection_parameters[0] = intrinsics; +// projection_parameters[1] = transformed_point; +// return intrinsic_projection_(projection_parameters, residual); +// } +// +// private: +// DynamicCostFunctionToFunctor intrinsic_projection_; +// }; + +#ifndef CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_ +#define CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_ + +#include <numeric> +#include <vector> + +#include "ceres/cost_function.h" +#include "ceres/internal/fixed_array.h" +#include "ceres/internal/port.h" +#include "ceres/internal/scoped_ptr.h" + +namespace ceres { + +class DynamicCostFunctionToFunctor { + public: + // Takes ownership of cost_function. + explicit DynamicCostFunctionToFunctor(CostFunction* cost_function) + : cost_function_(cost_function) { + CHECK_NOTNULL(cost_function); + } + + bool operator()(double const* const* parameters, double* residuals) const { + return cost_function_->Evaluate(parameters, residuals, NULL); + } + + template <typename JetT> + bool operator()(JetT const* const* inputs, JetT* output) const { + const std::vector<int32>& parameter_block_sizes = + cost_function_->parameter_block_sizes(); + const int num_parameter_blocks = parameter_block_sizes.size(); + const int num_residuals = cost_function_->num_residuals(); + const int num_parameters = std::accumulate(parameter_block_sizes.begin(), + parameter_block_sizes.end(), 0); + + internal::FixedArray<double> parameters(num_parameters); + internal::FixedArray<double*> parameter_blocks(num_parameter_blocks); + internal::FixedArray<double> jacobians(num_residuals * num_parameters); + internal::FixedArray<double*> jacobian_blocks(num_parameter_blocks); + internal::FixedArray<double> residuals(num_residuals); + + // Build a set of arrays to get the residuals and jacobians from + // the CostFunction wrapped by this functor. + double* parameter_ptr = parameters.get(); + double* jacobian_ptr = jacobians.get(); + for (int i = 0; i < num_parameter_blocks; ++i) { + parameter_blocks[i] = parameter_ptr; + jacobian_blocks[i] = jacobian_ptr; + for (int j = 0; j < parameter_block_sizes[i]; ++j) { + *parameter_ptr++ = inputs[i][j].a; + } + jacobian_ptr += num_residuals * parameter_block_sizes[i]; + } + + if (!cost_function_->Evaluate(parameter_blocks.get(), + residuals.get(), + jacobian_blocks.get())) { + return false; + } + + // Now that we have the incoming Jets, which are carrying the + // partial derivatives of each of the inputs w.r.t to some other + // underlying parameters. The derivative of the outputs of the + // cost function w.r.t to the same underlying parameters can now + // be computed by applying the chain rule. + // + // d output[i] d output[i] d input[j] + // -------------- = sum_j ----------- * ------------ + // d parameter[k] d input[j] d parameter[k] + // + // d input[j] + // -------------- = inputs[j], so + // d parameter[k] + // + // outputJet[i] = sum_k jacobian[i][k] * inputJet[k] + // + // The following loop, iterates over the residuals, computing one + // output jet at a time. + for (int i = 0; i < num_residuals; ++i) { + output[i].a = residuals[i]; + output[i].v.setZero(); + + for (int j = 0; j < num_parameter_blocks; ++j) { + const int32 block_size = parameter_block_sizes[j]; + for (int k = 0; k < parameter_block_sizes[j]; ++k) { + output[i].v += + jacobian_blocks[j][i * block_size + k] * inputs[j][k].v; + } + } + } + + return true; + } + + private: + internal::scoped_ptr<CostFunction> cost_function_; +}; + +} // namespace ceres + +#endif // CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/dynamic_numeric_diff_cost_function.h b/extern/libmv/third_party/ceres/include/ceres/dynamic_numeric_diff_cost_function.h index 2b6e8260286..c852d57a3fc 100644 --- a/extern/libmv/third_party/ceres/include/ceres/dynamic_numeric_diff_cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/dynamic_numeric_diff_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -29,6 +29,7 @@ // Author: mierle@gmail.com (Keir Mierle) // sameeragarwal@google.com (Sameer Agarwal) // thadh@gmail.com (Thad Hughes) +// tbennun@gmail.com (Tal Ben-Nun) // // This numeric diff implementation differs from the one found in // numeric_diff_cost_function.h by supporting numericdiff on cost @@ -41,7 +42,6 @@ // numeric diff; the expected interface for the cost functors is: // // struct MyCostFunctor { -// template<typename T> // bool operator()(double const* const* parameters, double* residuals) const { // // Use parameters[i] to access the i'th parameter block. // } @@ -68,19 +68,37 @@ #include "ceres/internal/scoped_ptr.h" #include "ceres/internal/eigen.h" #include "ceres/internal/numeric_diff.h" +#include "ceres/numeric_diff_options.h" #include "glog/logging.h" namespace ceres { -template <typename CostFunctor, NumericDiffMethod method = CENTRAL> +template <typename CostFunctor, NumericDiffMethodType method = CENTRAL> class DynamicNumericDiffCostFunction : public CostFunction { public: - explicit DynamicNumericDiffCostFunction(const CostFunctor* functor, - Ownership ownership = TAKE_OWNERSHIP, - double relative_step_size = 1e-6) + explicit DynamicNumericDiffCostFunction( + const CostFunctor* functor, + Ownership ownership = TAKE_OWNERSHIP, + const NumericDiffOptions& options = NumericDiffOptions()) : functor_(functor), ownership_(ownership), - relative_step_size_(relative_step_size) { + options_(options) { + } + + // Deprecated. New users should avoid using this constructor. Instead, use the + // constructor with NumericDiffOptions. + DynamicNumericDiffCostFunction( + const CostFunctor* functor, + Ownership ownership, + double relative_step_size) + : functor_(functor), + ownership_(ownership), + options_() { + LOG(WARNING) << "This constructor is deprecated and will be removed in " + "a future version. Please use the NumericDiffOptions " + "constructor instead."; + + options_.relative_step_size = relative_step_size; } virtual ~DynamicNumericDiffCostFunction() { @@ -100,11 +118,12 @@ class DynamicNumericDiffCostFunction : public CostFunction { virtual bool Evaluate(double const* const* parameters, double* residuals, double** jacobians) const { + using internal::NumericDiff; CHECK_GT(num_residuals(), 0) << "You must call DynamicNumericDiffCostFunction::SetNumResiduals() " << "before DynamicNumericDiffCostFunction::Evaluate()."; - const vector<int32>& block_sizes = parameter_block_sizes(); + const std::vector<int32>& block_sizes = parameter_block_sizes(); CHECK(!block_sizes.empty()) << "You must call DynamicNumericDiffCostFunction::AddParameterBlock() " << "before DynamicNumericDiffCostFunction::Evaluate()."; @@ -116,8 +135,8 @@ class DynamicNumericDiffCostFunction : public CostFunction { // Create local space for a copy of the parameters which will get mutated. int parameters_size = accumulate(block_sizes.begin(), block_sizes.end(), 0); - vector<double> parameters_copy(parameters_size); - vector<double*> parameters_references_copy(block_sizes.size()); + std::vector<double> parameters_copy(parameters_size); + std::vector<double*> parameters_references_copy(block_sizes.size()); parameters_references_copy[0] = ¶meters_copy[0]; for (int block = 1; block < block_sizes.size(); ++block) { parameters_references_copy[block] = parameters_references_copy[block - 1] @@ -133,12 +152,18 @@ class DynamicNumericDiffCostFunction : public CostFunction { for (int block = 0; block < block_sizes.size(); ++block) { if (jacobians[block] != NULL && - !EvaluateJacobianForParameterBlock(block_sizes[block], - block, - relative_step_size_, + !NumericDiff<CostFunctor, method, DYNAMIC, + DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC, + DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC, + DYNAMIC, DYNAMIC>::EvaluateJacobianForParameterBlock( + functor_.get(), residuals, + options_, + this->num_residuals(), + block, + block_sizes[block], ¶meters_references_copy[0], - jacobians)) { + jacobians[block])) { return false; } } @@ -146,91 +171,6 @@ class DynamicNumericDiffCostFunction : public CostFunction { } private: - bool EvaluateJacobianForParameterBlock(const int parameter_block_size, - const int parameter_block, - const double relative_step_size, - double const* residuals_at_eval_point, - double** parameters, - double** jacobians) const { - using Eigen::Map; - using Eigen::Matrix; - using Eigen::Dynamic; - using Eigen::RowMajor; - - typedef Matrix<double, Dynamic, 1> ResidualVector; - typedef Matrix<double, Dynamic, 1> ParameterVector; - typedef Matrix<double, Dynamic, Dynamic, RowMajor> JacobianMatrix; - - int num_residuals = this->num_residuals(); - - Map<JacobianMatrix> parameter_jacobian(jacobians[parameter_block], - num_residuals, - parameter_block_size); - - // Mutate one element at a time and then restore. - Map<ParameterVector> x_plus_delta(parameters[parameter_block], - parameter_block_size); - ParameterVector x(x_plus_delta); - ParameterVector step_size = x.array().abs() * relative_step_size; - - // To handle cases where a paremeter is exactly zero, instead use - // the mean step_size for the other dimensions. - double fallback_step_size = step_size.sum() / step_size.rows(); - if (fallback_step_size == 0.0) { - // If all the parameters are zero, there's no good answer. Use the given - // relative step_size as absolute step_size and hope for the best. - fallback_step_size = relative_step_size; - } - - // For each parameter in the parameter block, use finite - // differences to compute the derivative for that parameter. - for (int j = 0; j < parameter_block_size; ++j) { - if (step_size(j) == 0.0) { - // The parameter is exactly zero, so compromise and use the - // mean step_size from the other parameters. This can break in - // many cases, but it's hard to pick a good number without - // problem specific knowledge. - step_size(j) = fallback_step_size; - } - x_plus_delta(j) = x(j) + step_size(j); - - ResidualVector residuals(num_residuals); - if (!EvaluateCostFunctor(parameters, &residuals[0])) { - // Something went wrong; bail. - return false; - } - - // Compute this column of the jacobian in 3 steps: - // 1. Store residuals for the forward part. - // 2. Subtract residuals for the backward (or 0) part. - // 3. Divide out the run. - parameter_jacobian.col(j).matrix() = residuals; - - double one_over_h = 1 / step_size(j); - if (method == CENTRAL) { - // Compute the function on the other side of x(j). - x_plus_delta(j) = x(j) - step_size(j); - - if (!EvaluateCostFunctor(parameters, &residuals[0])) { - // Something went wrong; bail. - return false; - } - - parameter_jacobian.col(j) -= residuals; - one_over_h /= 2; - } else { - // Forward difference only; reuse existing residuals evaluation. - parameter_jacobian.col(j) -= - Map<const ResidualVector>(residuals_at_eval_point, num_residuals); - } - x_plus_delta(j) = x(j); // Restore x_plus_delta. - - // Divide out the run to get slope. - parameter_jacobian.col(j) *= one_over_h; - } - return true; - } - bool EvaluateCostFunctor(double const* const* parameters, double* residuals) const { return EvaluateCostFunctorImpl(functor_.get(), @@ -257,7 +197,7 @@ class DynamicNumericDiffCostFunction : public CostFunction { internal::scoped_ptr<const CostFunctor> functor_; Ownership ownership_; - const double relative_step_size_; + NumericDiffOptions options_; }; } // namespace ceres diff --git a/extern/libmv/third_party/ceres/include/ceres/fpclassify.h b/extern/libmv/third_party/ceres/include/ceres/fpclassify.h index da8a4d086b8..bc2dc90026c 100644 --- a/extern/libmv/third_party/ceres/include/ceres/fpclassify.h +++ b/extern/libmv/third_party/ceres/include/ceres/fpclassify.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -50,26 +50,9 @@ namespace ceres { inline bool IsFinite (double x) { return _finite(x) != 0; } inline bool IsInfinite(double x) { return _finite(x) == 0 && _isnan(x) == 0; } inline bool IsNaN (double x) { return _isnan(x) != 0; } -inline bool IsNormal (double x) { - int classification = _fpclass(x); - return classification == _FPCLASS_NN || - classification == _FPCLASS_PN; -} - -#elif defined(ANDROID) && defined(_STLPORT_VERSION) - -// On Android, when using the STLPort, the C++ isnan and isnormal functions -// are defined as macros. -inline bool IsNaN (double x) { return isnan(x); } -inline bool IsNormal (double x) { return isnormal(x); } -// On Android NDK r6, when using STLPort, the isinf and isfinite functions are -// not available, so reimplement them. -inline bool IsInfinite(double x) { - return x == std::numeric_limits<double>::infinity() || - x == -std::numeric_limits<double>::infinity(); -} -inline bool IsFinite(double x) { - return !isnan(x) && !IsInfinite(x); +inline bool IsNormal (double x) { // NOLINT + const int classification = _fpclass(x); + return (classification == _FPCLASS_NN || classification == _FPCLASS_PN); } # else diff --git a/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h b/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h index 79ebae5f13e..28304159b44 100644 --- a/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h +++ b/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -78,10 +78,10 @@ class GradientChecker { // block. // Derivatives as computed by the cost function. - vector<Matrix> term_jacobians; + std::vector<Matrix> term_jacobians; // Derivatives as computed by finite differencing. - vector<Matrix> finite_difference_jacobians; + std::vector<Matrix> finite_difference_jacobians; // Infinity-norm of term_jacobians - finite_difference_jacobians. double error_jacobians; @@ -119,7 +119,7 @@ class GradientChecker { // Do a consistency check between the term and the template parameters. CHECK_EQ(M, term->num_residuals()); const int num_residuals = M; - const vector<int32>& block_sizes = term->parameter_block_sizes(); + const std::vector<int32>& block_sizes = term->parameter_block_sizes(); const int num_blocks = block_sizes.size(); CHECK_LE(num_blocks, 5) << "Unable to test functions that take more " diff --git a/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h b/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h index 55a8be1df09..1226a4cd895 100644 --- a/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h +++ b/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/gradient_problem_solver.h b/extern/libmv/third_party/ceres/include/ceres/gradient_problem_solver.h index db706f7dbaf..a7d0121ea0c 100644 --- a/extern/libmv/third_party/ceres/include/ceres/gradient_problem_solver.h +++ b/extern/libmv/third_party/ceres/include/ceres/gradient_problem_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -81,7 +81,7 @@ class CERES_EXPORT GradientProblemSolver { // Returns true if the options struct has a valid // configuration. Returns false otherwise, and fills in *error // with a message describing the problem. - bool IsValid(string* error) const; + bool IsValid(std::string* error) const; // Minimizer options ---------------------------------------- LineSearchDirectionType line_search_direction_type; @@ -261,7 +261,7 @@ class CERES_EXPORT GradientProblemSolver { // executed, then set update_state_every_iteration to true. // // The solver does NOT take ownership of these pointers. - vector<IterationCallback*> callbacks; + std::vector<IterationCallback*> callbacks; }; struct CERES_EXPORT Summary { @@ -269,11 +269,11 @@ class CERES_EXPORT GradientProblemSolver { // A brief one line description of the state of the solver after // termination. - string BriefReport() const; + std::string BriefReport() const; // A full multiline description of the state of the solver after // termination. - string FullReport() const; + std::string FullReport() const; bool IsSolutionUsable() const; @@ -281,7 +281,7 @@ class CERES_EXPORT GradientProblemSolver { TerminationType termination_type; // Reason why the solver terminated. - string message; + std::string message; // Cost of the problem (value of the objective function) before // the optimization. @@ -292,7 +292,7 @@ class CERES_EXPORT GradientProblemSolver { double final_cost; // IterationSummary for each minimizer iteration in order. - vector<IterationSummary> iterations; + std::vector<IterationSummary> iterations; // Sum total of all time spent inside Ceres when Solve is called. double total_time_in_seconds; @@ -303,6 +303,10 @@ class CERES_EXPORT GradientProblemSolver { // Time (in seconds) spent evaluating the gradient. double gradient_evaluation_time_in_seconds; + // Time (in seconds) spent minimizing the interpolating polynomial + // to compute the next candidate step size as part of a line search. + double line_search_polynomial_minimization_time_in_seconds; + // Number of parameters in the probem. int num_parameters; diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h b/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h index 3a96625e3fd..136152a36cd 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -214,15 +214,15 @@ struct AutoDiff { // This block breaks the 80 column rule to keep it somewhat readable. DCHECK_GT(num_outputs, 0); DCHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0))) + ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || + ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0))) // NOLINT << "Zero block cannot precede a non-zero block. Block sizes are " << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", " << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", " diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/disable_warnings.h b/extern/libmv/third_party/ceres/include/ceres/internal/disable_warnings.h index 78924de1346..094124f7159 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/disable_warnings.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/disable_warnings.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h b/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h index 85df54b8f99..7138804ace4 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/fixed_array.h b/extern/libmv/third_party/ceres/include/ceres/internal/fixed_array.h index 694070b228c..387298c58d0 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/fixed_array.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/fixed_array.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/macros.h b/extern/libmv/third_party/ceres/include/ceres/internal/macros.h index 1ed55be6e03..bebb965e25b 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/macros.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/macros.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/manual_constructor.h b/extern/libmv/third_party/ceres/include/ceres/internal/manual_constructor.h index 7ea723d2a83..0d7633cef83 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/manual_constructor.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/manual_constructor.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/numeric_diff.h b/extern/libmv/third_party/ceres/include/ceres/internal/numeric_diff.h index 3b264b45af3..11e8275b1d3 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/numeric_diff.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/numeric_diff.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -28,8 +28,9 @@ // // Author: sameeragarwal@google.com (Sameer Agarwal) // mierle@gmail.com (Keir Mierle) +// tbennun@gmail.com (Tal Ben-Nun) // -// Finite differencing routine used by NumericDiffCostFunction. +// Finite differencing routines used by NumericDiffCostFunction. #ifndef CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_ #define CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_ @@ -37,9 +38,12 @@ #include <cstring> #include "Eigen/Dense" +#include "Eigen/StdVector" #include "ceres/cost_function.h" +#include "ceres/internal/fixed_array.h" #include "ceres/internal/scoped_ptr.h" #include "ceres/internal/variadic_evaluate.h" +#include "ceres/numeric_diff_options.h" #include "ceres/types.h" #include "glog/logging.h" @@ -78,7 +82,7 @@ bool EvaluateImpl(const CostFunctor* functor, // specializations for member functions. The alternative is to repeat the main // class for differing numbers of parameters, which is also unfortunate. template <typename CostFunctor, - NumericDiffMethod kMethod, + NumericDiffMethodType kMethod, int kNumResiduals, int N0, int N1, int N2, int N3, int N4, int N5, int N6, int N7, int N8, int N9, @@ -88,9 +92,11 @@ struct NumericDiff { // Mutates parameters but must restore them before return. static bool EvaluateJacobianForParameterBlock( const CostFunctor* functor, - double const* residuals_at_eval_point, - const double relative_step_size, + const double* residuals_at_eval_point, + const NumericDiffOptions& options, int num_residuals, + int parameter_block_index, + int parameter_block_size, double **parameters, double *jacobian) { using Eigen::Map; @@ -98,8 +104,14 @@ struct NumericDiff { using Eigen::RowMajor; using Eigen::ColMajor; - const int NUM_RESIDUALS = + const int num_residuals_internal = (kNumResiduals != ceres::DYNAMIC ? kNumResiduals : num_residuals); + const int parameter_block_index_internal = + (kParameterBlock != ceres::DYNAMIC ? kParameterBlock : + parameter_block_index); + const int parameter_block_size_internal = + (kParameterBlockSize != ceres::DYNAMIC ? kParameterBlockSize : + parameter_block_size); typedef Matrix<double, kNumResiduals, 1> ResidualVector; typedef Matrix<double, kParameterBlockSize, 1> ParameterVector; @@ -115,73 +127,288 @@ struct NumericDiff { JacobianMatrix; Map<JacobianMatrix> parameter_jacobian(jacobian, - NUM_RESIDUALS, - kParameterBlockSize); + num_residuals_internal, + parameter_block_size_internal); - // Mutate 1 element at a time and then restore. - Map<ParameterVector> x_plus_delta(parameters[kParameterBlock], - kParameterBlockSize); + 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() * 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 + // instability when dividing by the step size. The general + // recommendation is to not go down below sqrt(epsilon). + double min_step_size = std::sqrt(std::numeric_limits<double>::epsilon()); - // To handle cases where a parameter is exactly zero, instead use - // the mean step_size for the other dimensions. If all the - // parameters are zero, there's no good answer. Take - // relative_step_size as a guess and hope for the best. - const double fallback_step_size = - (step_size.sum() == 0) - ? relative_step_size - : step_size.sum() / step_size.rows(); + // 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); + } // For each parameter in the parameter block, use finite differences to // compute the derivative for that parameter. + FixedArray<double> temp_residual_array(num_residuals_internal); + FixedArray<double> residual_array(num_residuals_internal); + Map<ResidualVector> residuals(residual_array.get(), + num_residuals_internal); + + for (int j = 0; j < parameter_block_size_internal; ++j) { + const double delta = std::max(min_step_size, step_size(j)); + + if (kMethod == RIDDERS) { + if (!EvaluateRiddersJacobianColumn(functor, j, delta, + options, + num_residuals_internal, + parameter_block_size_internal, + x.data(), + residuals_at_eval_point, + parameters, + x_plus_delta.data(), + temp_residual_array.get(), + residual_array.get())) { + return false; + } + } else { + if (!EvaluateJacobianColumn(functor, j, delta, + num_residuals_internal, + parameter_block_size_internal, + x.data(), + residuals_at_eval_point, + parameters, + x_plus_delta.data(), + temp_residual_array.get(), + residual_array.get())) { + return false; + } + } - ResidualVector residuals(NUM_RESIDUALS); - for (int j = 0; j < kParameterBlockSize; ++j) { - const double delta = - (step_size(j) == 0.0) ? fallback_step_size : step_size(j); + parameter_jacobian.col(j).matrix() = residuals; + } + return true; + } - x_plus_delta(j) = x(j) + delta; + static bool EvaluateJacobianColumn(const CostFunctor* functor, + int parameter_index, + double delta, + int num_residuals, + int parameter_block_size, + const double* x_ptr, + const double* residuals_at_eval_point, + double** parameters, + double* x_plus_delta_ptr, + double* temp_residuals_ptr, + double* residuals_ptr) { + using Eigen::Map; + using Eigen::Matrix; + + typedef Matrix<double, kNumResiduals, 1> ResidualVector; + 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<ResidualVector> residuals(residuals_ptr, num_residuals); + Map<ResidualVector> temp_residuals(temp_residuals_ptr, num_residuals); + + // Mutate 1 element at a time and then restore. + x_plus_delta(parameter_index) = x(parameter_index) + delta; + + if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>( + functor, parameters, residuals.data(), functor)) { + return false; + } + + // Compute this column of the jacobian in 3 steps: + // 1. Store residuals for the forward part. + // 2. Subtract residuals for the backward (or 0) part. + // 3. Divide out the run. + double one_over_delta = 1.0 / delta; + if (kMethod == CENTRAL || kMethod == RIDDERS) { + // Compute the function on the other side of x(parameter_index). + x_plus_delta(parameter_index) = x(parameter_index) - delta; if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>( - functor, parameters, residuals.data(), functor)) { + functor, parameters, temp_residuals.data(), functor)) { return false; } - // Compute this column of the jacobian in 3 steps: - // 1. Store residuals for the forward part. - // 2. Subtract residuals for the backward (or 0) part. - // 3. Divide out the run. - parameter_jacobian.col(j) = residuals; + residuals -= temp_residuals; + one_over_delta /= 2; + } else { + // Forward difference only; reuse existing residuals evaluation. + residuals -= + Map<const ResidualVector>(residuals_at_eval_point, + num_residuals); + } - double one_over_delta = 1.0 / delta; - if (kMethod == CENTRAL) { - // Compute the function on the other side of x(j). - x_plus_delta(j) = x(j) - delta; + // Restore x_plus_delta. + x_plus_delta(parameter_index) = x(parameter_index); - if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>( - functor, parameters, residuals.data(), functor)) { - return false; + // Divide out the run to get slope. + residuals *= one_over_delta; + + return true; + } + + // This numeric difference implementation uses adaptive differentiation + // on the parameters to obtain the Jacobian matrix. The adaptive algorithm + // is based on Ridders' method for adaptive differentiation, which creates + // a Romberg tableau from varying step sizes and extrapolates the + // intermediate results to obtain the current computational error. + // + // References: + // C.J.F. Ridders, Accurate computation of F'(x) and F'(x) F"(x), Advances + // in Engineering Software (1978), Volume 4, Issue 2, April 1982, + // Pages 75-76, ISSN 0141-1195, + // http://dx.doi.org/10.1016/S0141-1195(82)80057-0. + static bool EvaluateRiddersJacobianColumn( + const CostFunctor* functor, + int parameter_index, + double delta, + const NumericDiffOptions& options, + int num_residuals, + int parameter_block_size, + const double* x_ptr, + const double* residuals_at_eval_point, + double** parameters, + double* x_plus_delta_ptr, + double* temp_residuals_ptr, + double* residuals_ptr) { + 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, 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<ResidualVector> residuals(residuals_ptr, num_residuals); + Map<ResidualVector> temp_residuals(temp_residuals_ptr, num_residuals); + + // In order for the algorithm to converge, the step size should be + // initialized to a value that is large enough to produce a significant + // change in the function. + // 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-buffering temporary differential candidate vectors + // from previous step size. + ResidualCandidateMatrix stepsize_candidates_a( + num_residuals, + options.max_num_ridders_extrapolations); + ResidualCandidateMatrix stepsize_candidates_b( + num_residuals, + options.max_num_ridders_extrapolations); + ResidualCandidateMatrix* current_candidates = &stepsize_candidates_a; + ResidualCandidateMatrix* previous_candidates = &stepsize_candidates_b; + + // Represents the computational error of the derivative. This variable is + // initially set to a large value, and is set to the difference between + // current and previous finite difference extrapolations. + // norm_error is supposed to decrease as the finite difference tableau + // generation progresses, serving both as an estimate for differentiation + // error and as a measure of differentiation numerical stability. + double norm_error = std::numeric_limits<double>::max(); + + // Loop over decreasing step sizes until: + // 1. Error is smaller than a given value (ridders_epsilon), + // 2. Maximal order of extrapolation reached, or + // 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, + num_residuals, + parameter_block_size, + x.data(), + residuals_at_eval_point, + parameters, + x_plus_delta.data(), + temp_residuals.data(), + current_candidates->col(0).data())) { + // Something went wrong; bail. + return false; + } + + // Store initial results. + if (i == 0) { + residuals = current_candidates->col(0); + } + + // Shrink differentiation step size. + current_step_size /= options.ridders_step_shrink_factor; + + // Extrapolation factor for Richardson acceleration method (see below). + double richardson_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); + + richardson_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()); + + // If the error has decreased, update results. + if (candidate_error <= norm_error) { + norm_error = candidate_error; + residuals = current_candidates->col(k); + + // If the error is small enough, stop. + if (norm_error < options.ridders_epsilon) { + break; + } } + } - parameter_jacobian.col(j) -= residuals; - one_over_delta /= 2; - } else { - // Forward difference only; reuse existing residuals evaluation. - parameter_jacobian.col(j) -= - Map<const ResidualVector>(residuals_at_eval_point, NUM_RESIDUALS); + // After breaking out of the inner loop, declare convergence. + if (norm_error < options.ridders_epsilon) { + break; + } + + // 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(); + + // Compare current error to the chosen candidate's error. + if (tableau_error >= 2 * norm_error) { + break; + } } - x_plus_delta(j) = x(j); // Restore x_plus_delta. - // Divide out the run to get slope. - parameter_jacobian.col(j) *= one_over_delta; + std::swap(current_candidates, previous_candidates); } return true; } }; template <typename CostFunctor, - NumericDiffMethod kMethod, + NumericDiffMethodType kMethod, int kNumResiduals, int N0, int N1, int N2, int N3, int N4, int N5, int N6, int N7, int N8, int N9, @@ -192,11 +419,22 @@ struct NumericDiff<CostFunctor, kMethod, kNumResiduals, // Mutates parameters but must restore them before return. static bool EvaluateJacobianForParameterBlock( const CostFunctor* functor, - double const* residuals_at_eval_point, - const double relative_step_size, + const double* residuals_at_eval_point, + const NumericDiffOptions& options, const int num_residuals, + const int parameter_block_index, + const int parameter_block_size, double **parameters, double *jacobian) { + // Silence unused parameter compiler warnings. + (void)functor; + (void)residuals_at_eval_point; + (void)options; + (void)num_residuals; + (void)parameter_block_index; + (void)parameter_block_size; + (void)parameters; + (void)jacobian; LOG(FATAL) << "Control should never reach here."; return true; } diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/port.h b/extern/libmv/third_party/ceres/include/ceres/internal/port.h index e38eb713aa8..e57049dde4b 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/port.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/port.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -34,8 +34,6 @@ // This file needs to compile as c code. #ifdef __cplusplus -#include <string> - #include "ceres/internal/config.h" #if defined(CERES_TR1_MEMORY_HEADER) @@ -46,16 +44,6 @@ namespace ceres { -// It is unfortunate that this import of the entire standard namespace is -// necessary. The reasons are historical and won't be explained here, but -// suffice to say it is not a mistake and can't be removed without breaking -// things outside of the Ceres optimization package. -using namespace std; - -// This is necessary to properly handle the case that there is a different -// "string" implementation in the global namespace. -using std::string; - #if defined(CERES_TR1_SHARED_PTR) using std::tr1::shared_ptr; #else diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/reenable_warnings.h b/extern/libmv/third_party/ceres/include/ceres/internal/reenable_warnings.h index 1f477d8d2ac..7e410259d64 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/reenable_warnings.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/reenable_warnings.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/scoped_ptr.h b/extern/libmv/third_party/ceres/include/ceres/internal/scoped_ptr.h index 5dfb551243c..fa0ac25a031 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/scoped_ptr.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/scoped_ptr.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/variadic_evaluate.h b/extern/libmv/third_party/ceres/include/ceres/internal/variadic_evaluate.h index 9a473d5b25c..b3515b96d18 100644 --- a/extern/libmv/third_party/ceres/include/ceres/internal/variadic_evaluate.h +++ b/extern/libmv/third_party/ceres/include/ceres/internal/variadic_evaluate.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -35,6 +35,7 @@ #include <stddef.h> #include "ceres/jet.h" +#include "ceres/types.h" #include "ceres/internal/eigen.h" #include "ceres/internal/fixed_array.h" #include "glog/logging.h" @@ -176,6 +177,17 @@ struct VariadicEvaluate<Functor, T, N0, 0, 0, 0, 0, 0, 0, 0, 0, 0> { } }; +// Template instantiation for dynamically-sized functors. +template<typename Functor, typename T> +struct VariadicEvaluate<Functor, T, ceres::DYNAMIC, ceres::DYNAMIC, + ceres::DYNAMIC, ceres::DYNAMIC, ceres::DYNAMIC, + ceres::DYNAMIC, ceres::DYNAMIC, ceres::DYNAMIC, + ceres::DYNAMIC, ceres::DYNAMIC> { + static bool Call(const Functor& functor, T const *const *input, T* output) { + return functor(input, output); + } +}; + } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h b/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h index 237ada6e0c9..6bab00439c5 100644 --- a/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h +++ b/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/jet.h b/extern/libmv/third_party/ceres/include/ceres/jet.h index 74ce1e9dd53..a21fd7adb90 100644 --- a/extern/libmv/third_party/ceres/include/ceres/jet.h +++ b/extern/libmv/third_party/ceres/include/ceres/jet.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -106,8 +106,8 @@ // Jet<double, 2> y(1); // Pick the 1st dual number for y. // Jet<double, 2> z = f(x, y); // -// LOG(INFO) << "df/dx = " << z.a[0] -// << "df/dy = " << z.a[1]; +// LOG(INFO) << "df/dx = " << z.v[0] +// << "df/dy = " << z.v[1]; // // Most users should not use Jet objects directly; a wrapper around Jet objects, // which makes computing the derivative, gradient, or jacobian of templated @@ -482,6 +482,41 @@ Jet<T, N> tanh(const Jet<T, N>& f) { return Jet<T, N>(tanh_a, tmp * f.v); } +// Bessel functions of the first kind with integer order equal to 0, 1, n. +inline double BesselJ0(double x) { return j0(x); } +inline double BesselJ1(double x) { return j1(x); } +inline double BesselJn(int n, double x) { return jn(n, x); } + +// For the formulae of the derivatives of the Bessel functions see the book: +// Olver, Lozier, Boisvert, Clark, NIST Handbook of Mathematical Functions, +// Cambridge University Press 2010. +// +// Formulae are also available at http://dlmf.nist.gov + +// See formula http://dlmf.nist.gov/10.6#E3 +// j0(a + h) ~= j0(a) - j1(a) h +template <typename T, int N> inline +Jet<T, N> BesselJ0(const Jet<T, N>& f) { + return Jet<T, N>(BesselJ0(f.a), + -BesselJ1(f.a) * f.v); +} + +// See formula http://dlmf.nist.gov/10.6#E1 +// j1(a + h) ~= j1(a) + 0.5 ( j0(a) - j2(a) ) h +template <typename T, int N> inline +Jet<T, N> BesselJ1(const Jet<T, N>& f) { + return Jet<T, N>(BesselJ1(f.a), + T(0.5) * (BesselJ0(f.a) - BesselJn(2, f.a)) * f.v); +} + +// See formula http://dlmf.nist.gov/10.6#E1 +// j_n(a + h) ~= j_n(a) + 0.5 ( j_{n-1}(a) - j_{n+1}(a) ) h +template <typename T, int N> inline +Jet<T, N> BesselJn(int n, const Jet<T, N>& f) { + return Jet<T, N>(BesselJn(n, f.a), + T(0.5) * (BesselJn(n - 1, f.a) - BesselJn(n + 1, f.a)) * f.v); +} + // Jet Classification. It is not clear what the appropriate semantics are for // these classifications. This picks that IsFinite and isnormal are "all" // operations, i.e. all elements of the jet must be finite for the jet itself @@ -573,22 +608,101 @@ Jet<T, N> pow(const Jet<T, N>& f, double g) { } // pow -- base is a constant, exponent is a differentiable function. -// (a)^(p+dp) ~= a^p + a^p log(a) dp +// We have various special cases, see the comment for pow(Jet, Jet) for +// analysis: +// +// 1. For f > 0 we have: (f)^(g + dg) ~= f^g + f^g log(f) dg +// +// 2. For f == 0 and g > 0 we have: (f)^(g + dg) ~= f^g +// +// 3. For f < 0 and integer g we have: (f)^(g + dg) ~= f^g but if dg +// != 0, the derivatives are not defined and we return NaN. + template <typename T, int N> inline Jet<T, N> pow(double f, const Jet<T, N>& g) { + if (f == 0 && g.a > 0) { + // Handle case 2. + return Jet<T, N>(T(0.0)); + } + if (f < 0 && g.a == floor(g.a)) { + // Handle case 3. + Jet<T, N> ret(pow(f, g.a)); + for (int i = 0; i < N; i++) { + if (g.v[i] != T(0.0)) { + // Return a NaN when g.v != 0. + ret.v[i] = std::numeric_limits<T>::quiet_NaN(); + } + } + return ret; + } + // Handle case 1. T const tmp = pow(f, g.a); return Jet<T, N>(tmp, log(f) * tmp * g.v); } +// pow -- both base and exponent are differentiable functions. This has a +// variety of special cases that require careful handling. +// +// 1. For f > 0: +// (f + df)^(g + dg) ~= f^g + f^(g - 1) * (g * df + f * log(f) * dg) +// The numerical evaluation of f * log(f) for f > 0 is well behaved, even for +// extremely small values (e.g. 1e-99). +// +// 2. For f == 0 and g > 1: (f + df)^(g + dg) ~= 0 +// This cases is needed because log(0) can not be evaluated in the f > 0 +// expression. However the function f*log(f) is well behaved around f == 0 +// and its limit as f-->0 is zero. +// +// 3. For f == 0 and g == 1: (f + df)^(g + dg) ~= 0 + df +// +// 4. For f == 0 and 0 < g < 1: The value is finite but the derivatives are not. +// +// 5. For f == 0 and g < 0: The value and derivatives of f^g are not finite. +// +// 6. For f == 0 and g == 0: The C standard incorrectly defines 0^0 to be 1 +// "because there are applications that can exploit this definition". We +// (arbitrarily) decree that derivatives here will be nonfinite, since that +// is consistent with the behavior for f == 0, g < 0 and 0 < g < 1. +// Practically any definition could have been justified because mathematical +// consistency has been lost at this point. +// +// 7. For f < 0, g integer, dg == 0: (f + df)^(g + dg) ~= f^g + g * f^(g - 1) df +// This is equivalent to the case where f is a differentiable function and g +// is a constant (to first order). +// +// 8. For f < 0, g integer, dg != 0: The value is finite but the derivatives are +// not, because any change in the value of g moves us away from the point +// with a real-valued answer into the region with complex-valued answers. +// +// 9. For f < 0, g noninteger: The value and derivatives of f^g are not finite. -// pow -- both base and exponent are differentiable functions. -// (a+da)^(b+db) ~= a^b + b * a^(b-1) da + a^b log(a) * db template <typename T, int N> inline Jet<T, N> pow(const Jet<T, N>& f, const Jet<T, N>& g) { + if (f.a == 0 && g.a >= 1) { + // Handle cases 2 and 3. + if (g.a > 1) { + return Jet<T, N>(T(0.0)); + } + return f; + } + if (f.a < 0 && g.a == floor(g.a)) { + // Handle cases 7 and 8. + T const tmp = g.a * pow(f.a, g.a - T(1.0)); + Jet<T, N> ret(pow(f.a, g.a), tmp * f.v); + for (int i = 0; i < N; i++) { + if (g.v[i] != T(0.0)) { + // Return a NaN when g.v != 0. + ret.v[i] = std::numeric_limits<T>::quiet_NaN(); + } + } + return ret; + } + // Handle the remaining cases. For cases 4,5,6,9 we allow the log() function + // to generate -HUGE_VAL or NaN, since those cases result in a nonfinite + // derivative. T const tmp1 = pow(f.a, g.a); T const tmp2 = g.a * pow(f.a, g.a - T(1.0)); T const tmp3 = tmp1 * log(f.a); - return Jet<T, N>(tmp1, tmp2 * f.v + tmp3 * g.v); } diff --git a/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h b/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h index 656c4d46662..67633de309f 100644 --- a/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h +++ b/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -34,6 +34,7 @@ #include <vector> #include "ceres/internal/port.h" +#include "ceres/internal/scoped_ptr.h" #include "ceres/internal/disable_warnings.h" namespace ceres { @@ -173,7 +174,7 @@ class CERES_EXPORT IdentityParameterization : public LocalParameterization { class CERES_EXPORT SubsetParameterization : public LocalParameterization { public: explicit SubsetParameterization(int size, - const vector<int>& constant_parameters); + const std::vector<int>& constant_parameters); virtual ~SubsetParameterization() {} virtual bool Plus(const double* x, const double* delta, @@ -191,7 +192,7 @@ class CERES_EXPORT SubsetParameterization : public LocalParameterization { private: const int local_size_; - vector<int> constancy_mask_; + std::vector<char> constancy_mask_; }; // Plus(x, delta) = [cos(|delta|), sin(|delta|) delta / |delta|] * x @@ -210,6 +211,89 @@ class CERES_EXPORT QuaternionParameterization : public LocalParameterization { virtual int LocalSize() const { return 3; } }; + +// This provides a parameterization for homogeneous vectors which are commonly +// used in Structure for Motion problems. One example where they are used is +// in representing points whose triangulation is ill-conditioned. Here +// it is advantageous to use an over-parameterization since homogeneous vectors +// can represent points at infinity. +// +// The plus operator is defined as +// Plus(x, delta) = +// [sin(0.5 * |delta|) * delta / |delta|, cos(0.5 * |delta|)] * x +// with * defined as an operator which applies the update orthogonal to x to +// remain on the sphere. We assume that the last element of x is the scalar +// component. The size of the homogeneous vector is required to be greater than +// 1. +class CERES_EXPORT HomogeneousVectorParameterization : + public LocalParameterization { + public: + explicit HomogeneousVectorParameterization(int size); + virtual ~HomogeneousVectorParameterization() {} + virtual bool Plus(const double* x, + const double* delta, + double* x_plus_delta) const; + virtual bool ComputeJacobian(const double* x, + double* jacobian) const; + virtual int GlobalSize() const { return size_; } + virtual int LocalSize() const { return size_ - 1; } + + private: + const int size_; +}; + +// Construct a local parameterization by taking the Cartesian product +// of a number of other local parameterizations. This is useful, when +// a parameter block is the cartesian product of two or more +// manifolds. For example the parameters of a camera consist of a +// rotation and a translation, i.e., SO(3) x R^3. +// +// Currently this class supports taking the cartesian product of up to +// four local parameterizations. +// +// Example usage: +// +// ProductParameterization product_param(new QuaterionionParameterization(), +// new IdentityParameterization(3)); +// +// is the local parameterization for a rigid transformation, where the +// rotation is represented using a quaternion. +class CERES_EXPORT ProductParameterization : public LocalParameterization { + public: + // + // NOTE: All the constructors take ownership of the input local + // parameterizations. + // + ProductParameterization(LocalParameterization* local_param1, + LocalParameterization* local_param2); + + ProductParameterization(LocalParameterization* local_param1, + LocalParameterization* local_param2, + LocalParameterization* local_param3); + + ProductParameterization(LocalParameterization* local_param1, + LocalParameterization* local_param2, + LocalParameterization* local_param3, + LocalParameterization* local_param4); + + virtual ~ProductParameterization(); + virtual bool Plus(const double* x, + const double* delta, + double* x_plus_delta) const; + virtual bool ComputeJacobian(const double* x, + double* jacobian) const; + virtual int GlobalSize() const { return global_size_; } + virtual int LocalSize() const { return local_size_; } + + private: + void Init(); + + std::vector<LocalParameterization*> local_params_; + int local_size_; + int global_size_; + int buffer_size_; +}; + } // namespace ceres #include "ceres/internal/reenable_warnings.h" diff --git a/extern/libmv/third_party/ceres/include/ceres/loss_function.h b/extern/libmv/third_party/ceres/include/ceres/loss_function.h index 2c585009990..0512c135143 100644 --- a/extern/libmv/third_party/ceres/include/ceres/loss_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/loss_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -274,10 +274,28 @@ class CERES_EXPORT TolerantLoss : public LossFunction { const double a_, b_, c_; }; +// This is the Tukey biweight loss function which aggressively +// attempts to suppress large errors. +// +// The term is computed as: +// +// rho(s) = a^2 / 6 * (1 - (1 - s / a^2)^3 ) for s <= a^2, +// rho(s) = a^2 / 6 for s > a^2. +// +// At s = 0: rho = [0, 0.5, -1 / a^2] +class CERES_EXPORT TukeyLoss : public ceres::LossFunction { + public: + explicit TukeyLoss(double a) : a_squared_(a * a) { } + virtual void Evaluate(double, double*) const; + + private: + const double a_squared_; +}; + // Composition of two loss functions. The error is the result of first // evaluating g followed by f to yield the composition f(g(s)). // The loss functions must not be NULL. -class ComposedLoss : public LossFunction { +class CERES_EXPORT ComposedLoss : public LossFunction { public: explicit ComposedLoss(const LossFunction* f, Ownership ownership_f, const LossFunction* g, Ownership ownership_g); @@ -340,6 +358,9 @@ class CERES_EXPORT ScaledLoss : public LossFunction { // whose scale can be mutated after an optimization problem has been // constructed. // +// Since we treat the a NULL Loss function as the Identity loss +// function, rho = NULL is a valid input. +// // Example usage // // Problem problem; @@ -376,8 +397,14 @@ class CERES_EXPORT LossFunctionWrapper : public LossFunction { } virtual void Evaluate(double sq_norm, double out[3]) const { - CHECK_NOTNULL(rho_.get()); - rho_->Evaluate(sq_norm, out); + if (rho_.get() == NULL) { + out[0] = sq_norm; + out[1] = 1.0; + out[2] = 0.0; + } + else { + rho_->Evaluate(sq_norm, out); + } } void Reset(LossFunction* rho, Ownership ownership) { @@ -396,6 +423,6 @@ class CERES_EXPORT LossFunctionWrapper : public LossFunction { } // namespace ceres -#include "ceres/internal/disable_warnings.h" +#include "ceres/internal/reenable_warnings.h" #endif // CERES_PUBLIC_LOSS_FUNCTION_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/normal_prior.h b/extern/libmv/third_party/ceres/include/ceres/normal_prior.h index df665054530..cd98b4c846b 100644 --- a/extern/libmv/third_party/ceres/include/ceres/normal_prior.h +++ b/extern/libmv/third_party/ceres/include/ceres/normal_prior.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/include/ceres/numeric_diff_cost_function.h b/extern/libmv/third_party/ceres/include/ceres/numeric_diff_cost_function.h index de6b74ad552..fa96078df02 100644 --- a/extern/libmv/third_party/ceres/include/ceres/numeric_diff_cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/numeric_diff_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -132,7 +132,7 @@ // // ALTERNATE INTERFACE // -// For a variety of reason, including compatibility with legacy code, +// For a variety of reasons, including compatibility with legacy code, // NumericDiffCostFunction can also take CostFunction objects as // input. The following describes how. // @@ -165,6 +165,7 @@ #include "ceres/cost_function.h" #include "ceres/internal/numeric_diff.h" #include "ceres/internal/scoped_ptr.h" +#include "ceres/numeric_diff_options.h" #include "ceres/sized_cost_function.h" #include "ceres/types.h" #include "glog/logging.h" @@ -172,7 +173,7 @@ namespace ceres { template <typename CostFunctor, - NumericDiffMethod method = CENTRAL, + NumericDiffMethodType method = CENTRAL, int kNumResiduals = 0, // Number of residuals, or ceres::DYNAMIC int N0 = 0, // Number of parameters in block 0. int N1 = 0, // Number of parameters in block 1. @@ -189,19 +190,43 @@ class NumericDiffCostFunction N0, N1, N2, N3, N4, N5, N6, N7, N8, N9> { public: + NumericDiffCostFunction( + CostFunctor* functor, + Ownership ownership = TAKE_OWNERSHIP, + int num_residuals = kNumResiduals, + const NumericDiffOptions& options = NumericDiffOptions()) + : functor_(functor), + ownership_(ownership), + options_(options) { + if (kNumResiduals == DYNAMIC) { + SizedCostFunction<kNumResiduals, + N0, N1, N2, N3, N4, + N5, N6, N7, N8, N9> + ::set_num_residuals(num_residuals); + } + } + + // Deprecated. New users should avoid using this constructor. Instead, use the + // constructor with NumericDiffOptions. NumericDiffCostFunction(CostFunctor* functor, - Ownership ownership = TAKE_OWNERSHIP, - int num_residuals = kNumResiduals, - const double relative_step_size = 1e-6) + Ownership ownership, + int num_residuals, + const double relative_step_size) :functor_(functor), ownership_(ownership), - relative_step_size_(relative_step_size) { + options_() { + LOG(WARNING) << "This constructor is deprecated and will be removed in " + "a future version. Please use the NumericDiffOptions " + "constructor instead."; + if (kNumResiduals == DYNAMIC) { SizedCostFunction<kNumResiduals, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9> ::set_num_residuals(num_residuals); } + + options_.relative_step_size = relative_step_size; } ~NumericDiffCostFunction() { @@ -250,25 +275,25 @@ class NumericDiffCostFunction if (N8) parameters_reference_copy[8] = parameters_reference_copy[7] + N7; if (N9) parameters_reference_copy[9] = parameters_reference_copy[8] + N8; -#define COPY_PARAMETER_BLOCK(block) \ +#define CERES_COPY_PARAMETER_BLOCK(block) \ if (N ## block) memcpy(parameters_reference_copy[block], \ parameters[block], \ sizeof(double) * N ## block); // NOLINT - COPY_PARAMETER_BLOCK(0); - COPY_PARAMETER_BLOCK(1); - COPY_PARAMETER_BLOCK(2); - COPY_PARAMETER_BLOCK(3); - COPY_PARAMETER_BLOCK(4); - COPY_PARAMETER_BLOCK(5); - COPY_PARAMETER_BLOCK(6); - COPY_PARAMETER_BLOCK(7); - COPY_PARAMETER_BLOCK(8); - COPY_PARAMETER_BLOCK(9); + CERES_COPY_PARAMETER_BLOCK(0); + CERES_COPY_PARAMETER_BLOCK(1); + CERES_COPY_PARAMETER_BLOCK(2); + CERES_COPY_PARAMETER_BLOCK(3); + CERES_COPY_PARAMETER_BLOCK(4); + CERES_COPY_PARAMETER_BLOCK(5); + CERES_COPY_PARAMETER_BLOCK(6); + CERES_COPY_PARAMETER_BLOCK(7); + CERES_COPY_PARAMETER_BLOCK(8); + CERES_COPY_PARAMETER_BLOCK(9); -#undef COPY_PARAMETER_BLOCK +#undef CERES_COPY_PARAMETER_BLOCK -#define EVALUATE_JACOBIAN_FOR_BLOCK(block) \ +#define CERES_EVALUATE_JACOBIAN_FOR_BLOCK(block) \ if (N ## block && jacobians[block] != NULL) { \ if (!NumericDiff<CostFunctor, \ method, \ @@ -278,28 +303,30 @@ class NumericDiffCostFunction N ## block >::EvaluateJacobianForParameterBlock( \ functor_.get(), \ residuals, \ - relative_step_size_, \ + options_, \ SizedCostFunction<kNumResiduals, \ N0, N1, N2, N3, N4, \ N5, N6, N7, N8, N9>::num_residuals(), \ + block, \ + N ## block, \ parameters_reference_copy.get(), \ jacobians[block])) { \ return false; \ } \ } - EVALUATE_JACOBIAN_FOR_BLOCK(0); - EVALUATE_JACOBIAN_FOR_BLOCK(1); - EVALUATE_JACOBIAN_FOR_BLOCK(2); - EVALUATE_JACOBIAN_FOR_BLOCK(3); - EVALUATE_JACOBIAN_FOR_BLOCK(4); - EVALUATE_JACOBIAN_FOR_BLOCK(5); - EVALUATE_JACOBIAN_FOR_BLOCK(6); - EVALUATE_JACOBIAN_FOR_BLOCK(7); - EVALUATE_JACOBIAN_FOR_BLOCK(8); - EVALUATE_JACOBIAN_FOR_BLOCK(9); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(0); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(1); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(2); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(3); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(4); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(5); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(6); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(7); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(8); + CERES_EVALUATE_JACOBIAN_FOR_BLOCK(9); -#undef EVALUATE_JACOBIAN_FOR_BLOCK +#undef CERES_EVALUATE_JACOBIAN_FOR_BLOCK return true; } @@ -307,7 +334,7 @@ class NumericDiffCostFunction private: internal::scoped_ptr<CostFunctor> functor_; Ownership ownership_; - const double relative_step_size_; + NumericDiffOptions options_; }; } // namespace ceres diff --git a/extern/libmv/third_party/ceres/include/ceres/numeric_diff_options.h b/extern/libmv/third_party/ceres/include/ceres/numeric_diff_options.h new file mode 100644 index 00000000000..119c8a86596 --- /dev/null +++ b/extern/libmv/third_party/ceres/include/ceres/numeric_diff_options.h @@ -0,0 +1,79 @@ +// Ceres Solver - A fast non-linear least squares minimizer +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// Author: tbennun@gmail.com (Tal Ben-Nun) +// + +#ifndef CERES_PUBLIC_NUMERIC_DIFF_OPTIONS_H_ +#define CERES_PUBLIC_NUMERIC_DIFF_OPTIONS_H_ + +namespace ceres { + +// Options pertaining to numeric differentiation (e.g., convergence criteria, +// step sizes). +struct CERES_EXPORT NumericDiffOptions { + NumericDiffOptions() { + relative_step_size = 1e-6; + ridders_relative_initial_step_size = 1e-2; + max_num_ridders_extrapolations = 10; + ridders_epsilon = 1e-12; + ridders_step_shrink_factor = 2.0; + } + + // Numeric differentiation step size (multiplied by parameter block's + // order of magnitude). If parameters are close to zero, the step size + // is set to sqrt(machine_epsilon). + double relative_step_size; + + // Initial step size for Ridders adaptive numeric differentiation (multiplied + // by parameter block's order of magnitude). + // If parameters are close to zero, Ridders' method sets the step size + // directly to this value. This parameter is separate from + // "relative_step_size" in order to set a different default value. + // + // Note: For Ridders' method to converge, the step size should be initialized + // to a value that is large enough to produce a significant change in the + // function. As the derivative is estimated, the step size decreases. + double ridders_relative_initial_step_size; + + // Maximal number of adaptive extrapolations (sampling) in Ridders' method. + int max_num_ridders_extrapolations; + + // Convergence criterion on extrapolation error for Ridders adaptive + // differentiation. The available error estimation methods are defined in + // NumericDiffErrorType and set in the "ridders_error_method" field. + double ridders_epsilon; + + // The factor in which to shrink the step size with each extrapolation in + // Ridders' method. + double ridders_step_shrink_factor; +}; + +} // namespace ceres + +#endif // CERES_PUBLIC_NUMERIC_DIFF_OPTIONS_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/ordered_groups.h b/extern/libmv/third_party/ceres/include/ceres/ordered_groups.h index c316d712e97..aa1bd3a7da1 100644 --- a/extern/libmv/third_party/ceres/include/ceres/ordered_groups.h +++ b/extern/libmv/third_party/ceres/include/ceres/ordered_groups.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -63,7 +63,8 @@ class OrderedGroups { return false; } - typename map<T, int>::const_iterator it = element_to_group_.find(element); + typename std::map<T, int>::const_iterator it = + element_to_group_.find(element); if (it != element_to_group_.end()) { if (it->second == group) { // Element is already in the right group, nothing to do. @@ -107,7 +108,7 @@ class OrderedGroups { // Bulk remove elements. The return value indicates the number of // elements successfully removed. - int Remove(const vector<T>& elements) { + int Remove(const std::vector<T>& elements) { if (NumElements() == 0 || elements.size() == 0) { return 0; } @@ -121,14 +122,18 @@ class OrderedGroups { // Reverse the order of the groups in place. void Reverse() { - typename map<int, set<T> >::reverse_iterator it = + if (NumGroups() == 0) { + return; + } + + typename std::map<int, std::set<T> >::reverse_iterator it = group_to_elements_.rbegin(); - map<int, set<T> > new_group_to_elements; + std::map<int, std::set<T> > new_group_to_elements; new_group_to_elements[it->first] = it->second; int new_group_id = it->first + 1; for (++it; it != group_to_elements_.rend(); ++it) { - for (typename set<T>::const_iterator element_it = it->second.begin(); + for (typename std::set<T>::const_iterator element_it = it->second.begin(); element_it != it->second.end(); ++element_it) { element_to_group_[*element_it] = new_group_id; @@ -143,7 +148,8 @@ class OrderedGroups { // Return the group id for the element. If the element is not a // member of any group, return -1. int GroupId(const T element) const { - typename map<T, int>::const_iterator it = element_to_group_.find(element); + typename std::map<T, int>::const_iterator it = + element_to_group_.find(element); if (it == element_to_group_.end()) { return -1; } @@ -151,14 +157,15 @@ class OrderedGroups { } bool IsMember(const T element) const { - typename map<T, int>::const_iterator it = element_to_group_.find(element); + typename std::map<T, int>::const_iterator it = + element_to_group_.find(element); return (it != element_to_group_.end()); } // This function always succeeds, i.e., implicitly there exists a // group for every integer. int GroupSize(const int group) const { - typename map<int, set<T> >::const_iterator it = + typename std::map<int, std::set<T> >::const_iterator it = group_to_elements_.find(group); return (it == group_to_elements_.end()) ? 0 : it->second.size(); } @@ -180,17 +187,17 @@ class OrderedGroups { return group_to_elements_.begin()->first; } - const map<int, set<T> >& group_to_elements() const { + const std::map<int, std::set<T> >& group_to_elements() const { return group_to_elements_; } - const map<T, int>& element_to_group() const { + const std::map<T, int>& element_to_group() const { return element_to_group_; } private: - map<int, set<T> > group_to_elements_; - map<T, int> element_to_group_; + std::map<int, std::set<T> > group_to_elements_; + std::map<T, int> element_to_group_; }; // Typedef for the most commonly used version of OrderedGroups. diff --git a/extern/libmv/third_party/ceres/include/ceres/problem.h b/extern/libmv/third_party/ceres/include/ceres/problem.h index f75ede3a5c6..409274c62c2 100644 --- a/extern/libmv/third_party/ceres/include/ceres/problem.h +++ b/extern/libmv/third_party/ceres/include/ceres/problem.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -211,9 +211,10 @@ class CERES_EXPORT Problem { // problem.AddResidualBlock(new MyUnaryCostFunction(...), NULL, x1); // problem.AddResidualBlock(new MyBinaryCostFunction(...), NULL, x2, x1); // - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - const vector<double*>& parameter_blocks); + ResidualBlockId AddResidualBlock( + CostFunction* cost_function, + LossFunction* loss_function, + const std::vector<double*>& parameter_blocks); // Convenience methods for adding residuals with a small number of // parameters. This is the common case. Instead of specifying the @@ -356,17 +357,17 @@ class CERES_EXPORT Problem { // Fills the passed parameter_blocks vector with pointers to the // parameter blocks currently in the problem. After this call, // parameter_block.size() == NumParameterBlocks. - void GetParameterBlocks(vector<double*>* parameter_blocks) const; + void GetParameterBlocks(std::vector<double*>* parameter_blocks) const; // Fills the passed residual_blocks vector with pointers to the // residual blocks currently in the problem. After this call, // residual_blocks.size() == NumResidualBlocks. - void GetResidualBlocks(vector<ResidualBlockId>* residual_blocks) const; + void GetResidualBlocks(std::vector<ResidualBlockId>* residual_blocks) const; // Get all the parameter blocks that depend on the given residual block. void GetParameterBlocksForResidualBlock( const ResidualBlockId residual_block, - vector<double*>* parameter_blocks) const; + std::vector<double*>* parameter_blocks) const; // Get the CostFunction for the given residual block. const CostFunction* GetCostFunctionForResidualBlock( @@ -385,7 +386,7 @@ class CERES_EXPORT Problem { // block will incur a scan of the entire Problem object. void GetResidualBlocksForParameterBlock( const double* values, - vector<ResidualBlockId>* residual_blocks) const; + std::vector<ResidualBlockId>* residual_blocks) const; // Options struct to control Problem::Evaluate. struct EvaluateOptions { @@ -408,18 +409,17 @@ class CERES_EXPORT Problem { // used to add parameter blocks to the Problem. These parameter // block should NOT point to new memory locations. Bad things will // happen otherwise. - vector<double*> parameter_blocks; + std::vector<double*> parameter_blocks; // The set of residual blocks to evaluate. This vector determines // the order in which the residuals occur, and how the rows of the // jacobian are ordered. If residual_blocks is empty, then it is - // assumed to be equal to the vector containing all the residual - // blocks. If this vector is empty, then it is assumed to be equal - // to a vector containing ALL the residual blocks. Generally - // speaking the residual blocks will occur in the order in which - // they were added to the problem. But, this may change if the - // user removes any residual blocks from the problem. - vector<ResidualBlockId> residual_blocks; + // assumed to be equal to the vector containing ALL the residual + // blocks. Generally speaking the residual blocks will occur in + // the order in which they were added to the problem. But, this + // may change if the user removes any residual blocks from the + // problem. + std::vector<ResidualBlockId> residual_blocks; // Even though the residual blocks in the problem may contain loss // functions, setting apply_loss_function to false will turn off @@ -463,8 +463,8 @@ class CERES_EXPORT Problem { // columns in the jacobian). bool Evaluate(const EvaluateOptions& options, double* cost, - vector<double>* residuals, - vector<double>* gradient, + std::vector<double>* residuals, + std::vector<double>* gradient, CRSMatrix* jacobian); private: diff --git a/extern/libmv/third_party/ceres/include/ceres/rotation.h b/extern/libmv/third_party/ceres/include/ceres/rotation.h index e3dbfe84a5a..e9496d772e4 100644 --- a/extern/libmv/third_party/ceres/include/ceres/rotation.h +++ b/extern/libmv/third_party/ceres/include/ceres/rotation.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -47,6 +47,7 @@ #include <algorithm> #include <cmath> +#include <limits> #include "glog/logging.h" namespace ceres { @@ -95,6 +96,17 @@ template<typename T> void QuaternionToAngleAxis(const T* quaternion, T* angle_axis); // Conversions between 3x3 rotation matrix (in column major order) and +// quaternion rotation representations. Templated for use with +// autodifferentiation. +template <typename T> +void RotationMatrixToQuaternion(const T* R, T* quaternion); + +template <typename T, int row_stride, int col_stride> +void RotationMatrixToQuaternion( + const MatrixAdapter<const T, row_stride, col_stride>& R, + T* quaternion); + +// Conversions between 3x3 rotation matrix (in column major order) and // axis-angle rotation representations. Templated for use with // autodifferentiation. template <typename T> @@ -141,11 +153,11 @@ void EulerAnglesToRotationMatrix( // the cross-product matrix of [a b c]. Together with the property that // R(q1 * q2) = R(q1) * R(q2) this uniquely defines the mapping from q to R. // -// The rotation matrix is row-major. -// // No normalization of the quaternion is performed, i.e. // R = ||q||^2 * Q, where Q is an orthonormal matrix // such that det(Q) = 1 and Q*Q' = I +// +// WARNING: The rotation matrix is ROW MAJOR template <typename T> inline void QuaternionToScaledRotation(const T q[4], T R[3 * 3]); @@ -156,6 +168,8 @@ void QuaternionToScaledRotation( // Same as above except that the rotation matrix is normalized by the // Frobenius norm, so that R * R' = I (and det(R) = 1). +// +// WARNING: The rotation matrix is ROW MAJOR template <typename T> inline void QuaternionToRotation(const T q[4], T R[3 * 3]); @@ -294,6 +308,46 @@ 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); +} + +// This algorithm comes from "Quaternion Calculus and Fast Animation", +// Ken Shoemake, 1987 SIGGRAPH course notes +template <typename T, int row_stride, int col_stride> +void RotationMatrixToQuaternion( + const MatrixAdapter<const T, row_stride, col_stride>& R, + T* quaternion) { + const T trace = R(0, 0) + R(1, 1) + R(2, 2); + if (trace >= 0.0) { + T t = sqrt(trace + T(1.0)); + quaternion[0] = T(0.5) * t; + t = T(0.5) / t; + quaternion[1] = (R(2, 1) - R(1, 2)) * t; + quaternion[2] = (R(0, 2) - R(2, 0)) * t; + quaternion[3] = (R(1, 0) - R(0, 1)) * t; + } else { + int i = 0; + if (R(1, 1) > R(0, 0)) { + i = 1; + } + + if (R(2, 2) > R(i, i)) { + i = 2; + } + + const int j = (i + 1) % 3; + const int k = (j + 1) % 3; + T t = sqrt(R(i, i) - R(j, j) - R(k, k) + T(1.0)); + quaternion[i + 1] = T(0.5) * t; + t = T(0.5) / t; + quaternion[0] = (R(k, j) - R(j, k)) * t; + quaternion[j + 1] = (R(j, i) + R(i, j)) * t; + quaternion[k + 1] = (R(k, i) + R(i, k)) * t; + } +} + // The conversion of a rotation matrix to the angle-axis form is // numerically problematic when then rotation angle is close to zero // or to Pi. The following implementation detects when these two cases @@ -308,80 +362,10 @@ template <typename T, int row_stride, int col_stride> void RotationMatrixToAngleAxis( const MatrixAdapter<const T, row_stride, col_stride>& R, T* angle_axis) { - // x = k * 2 * sin(theta), where k is the axis of rotation. - angle_axis[0] = R(2, 1) - R(1, 2); - angle_axis[1] = R(0, 2) - R(2, 0); - angle_axis[2] = R(1, 0) - R(0, 1); - - static const T kOne = T(1.0); - static const T kTwo = T(2.0); - - // Since the right hand side may give numbers just above 1.0 or - // below -1.0 leading to atan misbehaving, we threshold. - T costheta = std::min(std::max((R(0, 0) + R(1, 1) + R(2, 2) - kOne) / kTwo, - T(-1.0)), - kOne); - - // sqrt is guaranteed to give non-negative results, so we only - // threshold above. - T sintheta = std::min(sqrt(angle_axis[0] * angle_axis[0] + - angle_axis[1] * angle_axis[1] + - angle_axis[2] * angle_axis[2]) / kTwo, - kOne); - - // Use the arctan2 to get the right sign on theta - const T theta = atan2(sintheta, costheta); - - // Case 1: sin(theta) is large enough, so dividing by it is not a - // problem. We do not use abs here, because while jets.h imports - // std::abs into the namespace, here in this file, abs resolves to - // the int version of the function, which returns zero always. - // - // We use a threshold much larger then the machine epsilon, because - // if sin(theta) is small, not only do we risk overflow but even if - // that does not occur, just dividing by a small number will result - // in numerical garbage. So we play it safe. - static const double kThreshold = 1e-12; - if ((sintheta > kThreshold) || (sintheta < -kThreshold)) { - const T r = theta / (kTwo * sintheta); - for (int i = 0; i < 3; ++i) { - angle_axis[i] *= r; - } - return; - } - - // Case 2: theta ~ 0, means sin(theta) ~ theta to a good - // approximation. - if (costheta > 0.0) { - const T kHalf = T(0.5); - for (int i = 0; i < 3; ++i) { - angle_axis[i] *= kHalf; - } - return; - } - - // Case 3: theta ~ pi, this is the hard case. Since theta is large, - // and sin(theta) is small. Dividing by theta by sin(theta) will - // either give an overflow or worse still numerically meaningless - // results. Thus we use an alternate more complicated formula - // here. - - // Since cos(theta) is negative, division by (1-cos(theta)) cannot - // overflow. - const T inv_one_minus_costheta = kOne / (kOne - costheta); - - // We now compute the absolute value of coordinates of the axis - // vector using the diagonal entries of R. To resolve the sign of - // these entries, we compare the sign of angle_axis[i]*sin(theta) - // with the sign of sin(theta). If they are the same, then - // angle_axis[i] should be positive, otherwise negative. - for (int i = 0; i < 3; ++i) { - angle_axis[i] = theta * sqrt((R(i, i) - costheta) * inv_one_minus_costheta); - if (((sintheta < 0.0) && (angle_axis[i] > 0.0)) || - ((sintheta > 0.0) && (angle_axis[i] < 0.0))) { - angle_axis[i] = -angle_axis[i]; - } - } + T quaternion[4]; + RotationMatrixToQuaternion(R, quaternion); + QuaternionToAngleAxis(quaternion, angle_axis); + return; } template <typename T> diff --git a/extern/libmv/third_party/ceres/include/ceres/sized_cost_function.h b/extern/libmv/third_party/ceres/include/ceres/sized_cost_function.h index 4f98d4eb95c..b10421e81be 100644 --- a/extern/libmv/third_party/ceres/include/ceres/sized_cost_function.h +++ b/extern/libmv/third_party/ceres/include/ceres/sized_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -55,15 +55,15 @@ class SizedCostFunction : public CostFunction { // This block breaks the 80 column rule to keep it somewhat readable. CHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) || - ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0))) + ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || + ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) || // NOLINT + ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0))) // NOLINT << "Zero block cannot precede a non-zero block. Block sizes are " << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", " << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", " @@ -71,19 +71,19 @@ class SizedCostFunction : public CostFunction { set_num_residuals(kNumResiduals); -#define ADD_PARAMETER_BLOCK(N) \ +#define CERES_ADD_PARAMETER_BLOCK(N) \ if (N) mutable_parameter_block_sizes()->push_back(N); - ADD_PARAMETER_BLOCK(N0); - ADD_PARAMETER_BLOCK(N1); - ADD_PARAMETER_BLOCK(N2); - ADD_PARAMETER_BLOCK(N3); - ADD_PARAMETER_BLOCK(N4); - ADD_PARAMETER_BLOCK(N5); - ADD_PARAMETER_BLOCK(N6); - ADD_PARAMETER_BLOCK(N7); - ADD_PARAMETER_BLOCK(N8); - ADD_PARAMETER_BLOCK(N9); -#undef ADD_PARAMETER_BLOCK + CERES_ADD_PARAMETER_BLOCK(N0); + CERES_ADD_PARAMETER_BLOCK(N1); + CERES_ADD_PARAMETER_BLOCK(N2); + CERES_ADD_PARAMETER_BLOCK(N3); + CERES_ADD_PARAMETER_BLOCK(N4); + CERES_ADD_PARAMETER_BLOCK(N5); + CERES_ADD_PARAMETER_BLOCK(N6); + CERES_ADD_PARAMETER_BLOCK(N7); + CERES_ADD_PARAMETER_BLOCK(N8); + CERES_ADD_PARAMETER_BLOCK(N9); +#undef CERES_ADD_PARAMETER_BLOCK } virtual ~SizedCostFunction() { } diff --git a/extern/libmv/third_party/ceres/include/ceres/solver.h b/extern/libmv/third_party/ceres/include/ceres/solver.h index a5efa2a3915..318cf48cb83 100644 --- a/extern/libmv/third_party/ceres/include/ceres/solver.h +++ b/extern/libmv/third_party/ceres/include/ceres/solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -92,7 +92,7 @@ class CERES_EXPORT Solver { gradient_tolerance = 1e-10; parameter_tolerance = 1e-8; -#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE) +#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE) // NOLINT linear_solver_type = DENSE_QR; #else linear_solver_type = SPARSE_NORMAL_CHOLESKY; @@ -104,7 +104,8 @@ class CERES_EXPORT Solver { // Choose a default sparse linear algebra library in the order: // - // SUITE_SPARSE > CX_SPARSE > EIGEN_SPARSE + // SUITE_SPARSE > CX_SPARSE > EIGEN_SPARSE > NO_SPARSE + sparse_linear_algebra_library_type = NO_SPARSE; #if !defined(CERES_NO_SUITESPARSE) sparse_linear_algebra_library_type = SUITE_SPARSE; #else @@ -140,7 +141,7 @@ class CERES_EXPORT Solver { // Returns true if the options struct has a valid // configuration. Returns false otherwise, and fills in *error // with a message describing the problem. - bool IsValid(string* error) const; + bool IsValid(std::string* error) const; // Minimizer options ---------------------------------------- @@ -676,13 +677,13 @@ class CERES_EXPORT Solver { // List of iterations at which the minimizer should dump the trust // region problem. Useful for testing and benchmarking. If empty // (default), no problems are dumped. - vector<int> trust_region_minimizer_iterations_to_dump; + std::vector<int> trust_region_minimizer_iterations_to_dump; // Directory to which the problems should be written to. Should be // non-empty if trust_region_minimizer_iterations_to_dump is // non-empty and trust_region_problem_dump_format_type is not // CONSOLE. - string trust_region_problem_dump_directory; + std::string trust_region_problem_dump_directory; DumpFormatType trust_region_problem_dump_format_type; // Finite differences options ---------------------------------------------- @@ -746,7 +747,7 @@ class CERES_EXPORT Solver { // executed, then set update_state_every_iteration to true. // // The solver does NOT take ownership of these pointers. - vector<IterationCallback*> callbacks; + std::vector<IterationCallback*> callbacks; }; struct CERES_EXPORT Summary { @@ -754,11 +755,11 @@ class CERES_EXPORT Solver { // A brief one line description of the state of the solver after // termination. - string BriefReport() const; + std::string BriefReport() const; // A full multiline description of the state of the solver after // termination. - string FullReport() const; + std::string FullReport() const; bool IsSolutionUsable() const; @@ -768,7 +769,7 @@ class CERES_EXPORT Solver { TerminationType termination_type; // Reason why the solver terminated. - string message; + std::string message; // Cost of the problem (value of the objective function) before // the optimization. @@ -784,7 +785,7 @@ class CERES_EXPORT Solver { double fixed_cost; // IterationSummary for each minimizer iteration in order. - vector<IterationSummary> iterations; + std::vector<IterationSummary> iterations; // Number of minimizer iterations in which the step was // accepted. Unless use_non_monotonic_steps is true this is also @@ -832,6 +833,26 @@ class CERES_EXPORT Solver { // Time (in seconds) spent doing inner iterations. double inner_iteration_time_in_seconds; + // Cumulative timing information for line searches performed as part of the + // solve. Note that in addition to the case when the Line Search minimizer + // is used, the Trust Region minimizer also uses a line search when + // solving a constrained problem. + + // Time (in seconds) spent evaluating the univariate cost function as part + // of a line search. + double line_search_cost_evaluation_time_in_seconds; + + // Time (in seconds) spent evaluating the gradient of the univariate cost + // function as part of a line search. + double line_search_gradient_evaluation_time_in_seconds; + + // Time (in seconds) spent minimizing the interpolating polynomial + // to compute the next candidate step size as part of a line search. + double line_search_polynomial_minimization_time_in_seconds; + + // Total time (in seconds) spent performing line searches. + double line_search_total_time_in_seconds; + // Number of parameter blocks in the problem. int num_parameter_blocks; @@ -871,6 +892,9 @@ class CERES_EXPORT Solver { // Number of residuals in the reduced problem. int num_residuals_reduced; + // Is the reduced problem bounds constrained. + bool is_constrained; + // Number of threads specified by the user for Jacobian and // residual evaluation. int num_threads_given; @@ -902,7 +926,7 @@ class CERES_EXPORT Solver { // Size of the elimination groups given by the user as hints to // the linear solver. - vector<int> linear_solver_ordering_given; + std::vector<int> linear_solver_ordering_given; // Size of the parameter groups used by the solver when ordering // the columns of the Jacobian. This maybe different from @@ -910,7 +934,7 @@ class CERES_EXPORT Solver { // linear_solver_ordering_given blank and asked for an automatic // ordering, or if the problem contains some constant or inactive // parameter blocks. - vector<int> linear_solver_ordering_used; + std::vector<int> linear_solver_ordering_used; // True if the user asked for inner iterations to be used as part // of the optimization. @@ -924,7 +948,7 @@ class CERES_EXPORT Solver { // Size of the parameter groups given by the user for performing // inner iterations. - vector<int> inner_iteration_ordering_given; + std::vector<int> inner_iteration_ordering_given; // Size of the parameter groups given used by the solver for // performing inner iterations. This maybe different from @@ -932,7 +956,7 @@ class CERES_EXPORT Solver { // inner_iteration_ordering_given blank and asked for an automatic // ordering, or if the problem contains some constant or inactive // parameter blocks. - vector<int> inner_iteration_ordering_used; + std::vector<int> inner_iteration_ordering_used; // Type of the preconditioner requested by the user. PreconditionerType preconditioner_type_given; diff --git a/extern/libmv/third_party/ceres/include/ceres/types.h b/extern/libmv/third_party/ceres/include/ceres/types.h index a07c8933e64..2ea41803629 100644 --- a/extern/libmv/third_party/ceres/include/ceres/types.h +++ b/extern/libmv/third_party/ceres/include/ceres/types.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -157,7 +157,12 @@ enum SparseLinearAlgebraLibraryType { // Eigen's sparse linear algebra routines. In particular Ceres uses // the Simplicial LDLT routines. - EIGEN_SPARSE + EIGEN_SPARSE, + + // No sparse linear solver should be used. This does not necessarily + // imply that Ceres was built without any sparse library, although that + // is the likely use case, merely that one should not be used. + NO_SPARSE }; enum DenseLinearAlgebraLibraryType { @@ -392,9 +397,19 @@ enum DimensionType { DYNAMIC = -1 }; -enum NumericDiffMethod { +// The differentiation method used to compute numerical derivatives in +// NumericDiffCostFunction and DynamicNumericDiffCostFunction. +enum NumericDiffMethodType { + // Compute central finite difference: f'(x) ~ (f(x+h) - f(x-h)) / 2h. CENTRAL, - FORWARD + + // Compute forward finite difference: f'(x) ~ (f(x+h) - f(x)) / h. + FORWARD, + + // Adaptive numerical differentiation using Ridders' method. Provides more + // accurate and robust derivatives at the expense of additional cost + // function evaluations. + RIDDERS }; enum LineSearchInterpolationType { @@ -411,67 +426,73 @@ enum CovarianceAlgorithmType { CERES_EXPORT const char* LinearSolverTypeToString( LinearSolverType type); -CERES_EXPORT bool StringToLinearSolverType(string value, +CERES_EXPORT bool StringToLinearSolverType(std::string value, LinearSolverType* type); CERES_EXPORT const char* PreconditionerTypeToString(PreconditionerType type); -CERES_EXPORT bool StringToPreconditionerType(string value, +CERES_EXPORT bool StringToPreconditionerType(std::string value, PreconditionerType* type); CERES_EXPORT const char* VisibilityClusteringTypeToString( VisibilityClusteringType type); -CERES_EXPORT bool StringToVisibilityClusteringType(string value, +CERES_EXPORT bool StringToVisibilityClusteringType(std::string value, VisibilityClusteringType* type); CERES_EXPORT const char* SparseLinearAlgebraLibraryTypeToString( SparseLinearAlgebraLibraryType type); CERES_EXPORT bool StringToSparseLinearAlgebraLibraryType( - string value, + std::string value, SparseLinearAlgebraLibraryType* type); CERES_EXPORT const char* DenseLinearAlgebraLibraryTypeToString( DenseLinearAlgebraLibraryType type); CERES_EXPORT bool StringToDenseLinearAlgebraLibraryType( - string value, + std::string value, DenseLinearAlgebraLibraryType* type); CERES_EXPORT const char* TrustRegionStrategyTypeToString( TrustRegionStrategyType type); -CERES_EXPORT bool StringToTrustRegionStrategyType(string value, +CERES_EXPORT bool StringToTrustRegionStrategyType(std::string value, TrustRegionStrategyType* type); CERES_EXPORT const char* DoglegTypeToString(DoglegType type); -CERES_EXPORT bool StringToDoglegType(string value, DoglegType* type); +CERES_EXPORT bool StringToDoglegType(std::string value, DoglegType* type); CERES_EXPORT const char* MinimizerTypeToString(MinimizerType type); -CERES_EXPORT bool StringToMinimizerType(string value, MinimizerType* type); +CERES_EXPORT bool StringToMinimizerType(std::string value, MinimizerType* type); CERES_EXPORT const char* LineSearchDirectionTypeToString( LineSearchDirectionType type); -CERES_EXPORT bool StringToLineSearchDirectionType(string value, +CERES_EXPORT bool StringToLineSearchDirectionType(std::string value, LineSearchDirectionType* type); CERES_EXPORT const char* LineSearchTypeToString(LineSearchType type); -CERES_EXPORT bool StringToLineSearchType(string value, LineSearchType* type); +CERES_EXPORT bool StringToLineSearchType(std::string value, LineSearchType* type); CERES_EXPORT const char* NonlinearConjugateGradientTypeToString( NonlinearConjugateGradientType type); CERES_EXPORT bool StringToNonlinearConjugateGradientType( - string value, + std::string value, NonlinearConjugateGradientType* type); CERES_EXPORT const char* LineSearchInterpolationTypeToString( LineSearchInterpolationType type); CERES_EXPORT bool StringToLineSearchInterpolationType( - string value, + std::string value, LineSearchInterpolationType* type); CERES_EXPORT const char* CovarianceAlgorithmTypeToString( CovarianceAlgorithmType type); CERES_EXPORT bool StringToCovarianceAlgorithmType( - string value, + std::string value, CovarianceAlgorithmType* type); +CERES_EXPORT const char* NumericDiffMethodTypeToString( + NumericDiffMethodType type); +CERES_EXPORT bool StringToNumericDiffMethodType( + std::string value, + NumericDiffMethodType* type); + CERES_EXPORT const char* TerminationTypeToString(TerminationType type); CERES_EXPORT bool IsSchurType(LinearSolverType type); diff --git a/extern/libmv/third_party/ceres/include/ceres/version.h b/extern/libmv/third_party/ceres/include/ceres/version.h index 370b08af73e..66505a515c9 100644 --- a/extern/libmv/third_party/ceres/include/ceres/version.h +++ b/extern/libmv/third_party/ceres/include/ceres/version.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -32,9 +32,8 @@ #define CERES_PUBLIC_VERSION_H_ #define CERES_VERSION_MAJOR 1 -#define CERES_VERSION_MINOR 10 +#define CERES_VERSION_MINOR 11 #define CERES_VERSION_REVISION 0 -#define CERES_VERSION_ABI 1 // Classic CPP stringifcation; the extra level of indirection allows the // preprocessor to expand the macro before being converted to a string. diff --git a/extern/libmv/third_party/ceres/internal/ceres/array_utils.cc b/extern/libmv/third_party/ceres/internal/ceres/array_utils.cc index 205ddaf27c9..7be3c78ce24 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/array_utils.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/array_utils.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -41,6 +41,8 @@ namespace ceres { namespace internal { +using std::string; + // It is a near impossibility that user code generates this exact // value in normal operation, thus we will use it to fill arrays // before passing them to user code. If on return an element of the @@ -71,7 +73,7 @@ int FindInvalidValue(const int size, const double* x) { } return size; -}; +} void InvalidateArray(const int size, double* x) { if (x != NULL) { diff --git a/extern/libmv/third_party/ceres/internal/ceres/array_utils.h b/extern/libmv/third_party/ceres/internal/ceres/array_utils.h index 7f56947066b..2d2ffca8809 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/array_utils.h +++ b/extern/libmv/third_party/ceres/internal/ceres/array_utils.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -43,6 +43,7 @@ #ifndef CERES_INTERNAL_ARRAY_UTILS_H_ #define CERES_INTERNAL_ARRAY_UTILS_H_ +#include <string> #include "ceres/internal/port.h" namespace ceres { @@ -63,7 +64,7 @@ int FindInvalidValue(const int size, const double* x); // Utility routine to print an array of doubles to a string. If the // array pointer is NULL, it is treated as an array of zeros. -void AppendArrayToString(const int size, const double* x, string* result); +void AppendArrayToString(const int size, const double* x, std::string* result); extern const double kImpossibleValue; diff --git a/extern/libmv/third_party/ceres/internal/ceres/blas.cc b/extern/libmv/third_party/ceres/internal/ceres/blas.cc index b919e13c4a9..3ba63bbed5a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/blas.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/blas.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -32,6 +32,7 @@ #include "ceres/internal/port.h" #include "glog/logging.h" +#ifndef CERES_NO_LAPACK extern "C" void dsyrk_(char* uplo, char* trans, int* n, @@ -42,6 +43,7 @@ extern "C" void dsyrk_(char* uplo, double* beta, double* c, int* ldc); +#endif namespace ceres { namespace internal { diff --git a/extern/libmv/third_party/ceres/internal/ceres/blas.h b/extern/libmv/third_party/ceres/internal/ceres/blas.h index 2ab666395b9..a43301c5d18 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/blas.h +++ b/extern/libmv/third_party/ceres/internal/ceres/blas.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.cc b/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.cc index 9edc4fa23bd..59c0d3ecc10 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.h b/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.h index 354acc031f4..4378689729f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.cc b/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.cc index 7f79a4f993d..22d4b351c51 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -43,7 +43,7 @@ namespace internal { BlockJacobiPreconditioner::BlockJacobiPreconditioner( const BlockSparseMatrix& A) { const CompressedRowBlockStructure* bs = A.block_structure(); - vector<int> blocks(bs->cols.size()); + std::vector<int> blocks(bs->cols.size()); for (int i = 0; i < blocks.size(); ++i) { blocks[i] = bs->cols[i].size; } @@ -60,7 +60,7 @@ bool BlockJacobiPreconditioner::UpdateImpl(const BlockSparseMatrix& A, m_->SetZero(); for (int i = 0; i < bs->rows.size(); ++i) { const int row_block_size = bs->rows[i].block.size; - const vector<Cell>& cells = bs->rows[i].cells; + const std::vector<Cell>& cells = bs->rows[i].cells; for (int j = 0; j < cells.size(); ++j) { const int block_id = cells[j].block_id; const int col_block_size = bs->cols[block_id].size; diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.h b/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.h index e23e0e2d24c..14007295823 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.cc b/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.cc index f90c350cc80..7a3fee4fbdf 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -41,6 +41,9 @@ namespace ceres { namespace internal { + +using std::vector; + namespace { // Given the residual block ordering, build a lookup table to determine which @@ -163,8 +166,7 @@ SparseMatrix* BlockJacobianWriter::CreateJacobian() const { } // Construct the cells in each row. - const vector<ResidualBlock*>& residual_blocks = - program_->residual_blocks(); + const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks(); int row_block_position = 0; bs->rows.resize(residual_blocks.size()); for (int i = 0; i < residual_blocks.size(); ++i) { diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.h b/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.h index 140c7211129..8e6f45130a4 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -115,10 +115,10 @@ class BlockJacobianWriter { // // which indicates that dr/dx is located at values_[0], and dr/dz is at // values_[12]. See BlockEvaluatePreparer::Prepare()'s comments about 'j'. - vector<int*> jacobian_layout_; + std::vector<int*> jacobian_layout_; // The pointers in jacobian_layout_ point directly into this vector. - vector<int> jacobian_layout_storage_; + std::vector<int> jacobian_layout_storage_; }; } // namespace internal diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.cc index e5822792fa1..61748ef6f7f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -39,7 +39,7 @@ namespace ceres { namespace internal { BlockRandomAccessDenseMatrix::BlockRandomAccessDenseMatrix( - const vector<int>& blocks) { + const std::vector<int>& blocks) { const int num_blocks = blocks.size(); block_layout_.resize(num_blocks, 0); num_rows_ = 0; diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.h index d160fd96013..89689082561 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -56,7 +56,7 @@ class BlockRandomAccessDenseMatrix : public BlockRandomAccessMatrix { public: // blocks is a vector of block sizes. The resulting matrix has // blocks.size() * blocks.size() cells. - explicit BlockRandomAccessDenseMatrix(const vector<int>& blocks); + explicit BlockRandomAccessDenseMatrix(const std::vector<int>& blocks); // The destructor is not thread safe. It assumes that no one is // modifying any cells when the matrix is being destroyed. @@ -85,7 +85,7 @@ class BlockRandomAccessDenseMatrix : public BlockRandomAccessMatrix { private: int num_rows_; - vector<int> block_layout_; + std::vector<int> block_layout_; scoped_array<double> values_; scoped_array<CellInfo> cell_infos_; diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.cc index b7ff33184cb..052690d18be 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -45,6 +45,8 @@ namespace ceres { namespace internal { +using std::vector; + // TODO(sameeragarwal): Drop the dependence on TripletSparseMatrix. BlockRandomAccessDiagonalMatrix::BlockRandomAccessDiagonalMatrix( diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.h index ea9967817db..07ffc9d4a0d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -52,7 +52,7 @@ namespace internal { class BlockRandomAccessDiagonalMatrix : public BlockRandomAccessMatrix { public: // blocks is an array of block sizes. - explicit BlockRandomAccessDiagonalMatrix(const vector<int>& blocks); + explicit BlockRandomAccessDiagonalMatrix(const std::vector<int>& blocks); // The destructor is not thread safe. It assumes that no one is // modifying any cells when the matrix is being destroyed. @@ -85,8 +85,8 @@ class BlockRandomAccessDiagonalMatrix : public BlockRandomAccessMatrix { private: // row/column block sizes. - const vector<int> blocks_; - vector<CellInfo*> layout_; + const std::vector<int> blocks_; + std::vector<CellInfo*> layout_; // The underlying matrix object which actually stores the cells. scoped_ptr<TripletSparseMatrix> tsm_; diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.cc index 58fe4a10de3..347d765bbca 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.h index b76cb78b160..34c8bf5cd4d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.cc index c43a9b78feb..5432ec1064a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -44,6 +44,11 @@ namespace ceres { namespace internal { +using std::make_pair; +using std::pair; +using std::set; +using std::vector; + BlockRandomAccessSparseMatrix::BlockRandomAccessSparseMatrix( const vector<int>& blocks, const set<pair<int, int> >& block_pairs) diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.h index 51b5d20cfe0..2b3c7fdabae 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -57,8 +57,9 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix { // blocks is an array of block sizes. block_pairs is a set of // <row_block_id, col_block_id> pairs to identify the non-zero cells // of this matrix. - BlockRandomAccessSparseMatrix(const vector<int>& blocks, - const set<pair<int, int> >& block_pairs); + BlockRandomAccessSparseMatrix( + const std::vector<int>& blocks, + const std::set<std::pair<int, int> >& block_pairs); // The destructor is not thread safe. It assumes that no one is // modifying any cells when the matrix is being destroyed. @@ -103,8 +104,8 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix { const int64 kMaxRowBlocks; // row/column block sizes. - const vector<int> blocks_; - vector<int> block_positions_; + const std::vector<int> blocks_; + std::vector<int> block_positions_; // A mapping from <row_block_id, col_block_id> to the position in // the values array of tsm_ where the block is stored. @@ -114,7 +115,7 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix { // In order traversal of contents of the matrix. This allows us to // implement a matrix-vector which is 20% faster than using the // iterator in the Layout object instead. - vector<pair<pair<int, int>, double*> > cell_values_; + std::vector<std::pair<std::pair<int, int>, double*> > cell_values_; // The underlying matrix object which actually stores the cells. scoped_ptr<TripletSparseMatrix> tsm_; diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.cc index a4872626114..68d0780156c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -42,6 +42,8 @@ namespace ceres { namespace internal { +using std::vector; + BlockSparseMatrix::~BlockSparseMatrix() {} BlockSparseMatrix::BlockSparseMatrix( @@ -82,7 +84,7 @@ BlockSparseMatrix::BlockSparseMatrix( } void BlockSparseMatrix::SetZero() { - fill(values_.get(), values_.get() + num_nonzeros_, 0.0); + std::fill(values_.get(), values_.get() + num_nonzeros_, 0.0); } void BlockSparseMatrix::RightMultiply(const double* x, double* y) const { diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.h index e17d12a706e..2f9afb738f8 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_structure.cc b/extern/libmv/third_party/ceres/internal/ceres/block_structure.cc index 00c4ce2814b..6479b60f700 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_structure.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/block_structure.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/block_structure.h b/extern/libmv/third_party/ceres/internal/ceres/block_structure.h index 656716ef022..6e7003addb6 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/block_structure.h +++ b/extern/libmv/third_party/ceres/internal/ceres/block_structure.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -71,20 +71,20 @@ bool CellLessThan(const Cell& lhs, const Cell& rhs); struct CompressedList { Block block; - vector<Cell> cells; + std::vector<Cell> cells; }; typedef CompressedList CompressedRow; typedef CompressedList CompressedColumn; struct CompressedRowBlockStructure { - vector<Block> cols; - vector<CompressedRow> rows; + std::vector<Block> cols; + std::vector<CompressedRow> rows; }; struct CompressedColumnBlockStructure { - vector<Block> rows; - vector<CompressedColumn> cols; + std::vector<Block> rows; + std::vector<CompressedColumn> cols; }; } // namespace internal diff --git a/extern/libmv/third_party/ceres/internal/ceres/c_api.cc b/extern/libmv/third_party/ceres/internal/ceres/c_api.cc index 1fd01c9f0bd..ada8f3e0013 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/c_api.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/c_api.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/callbacks.cc b/extern/libmv/third_party/ceres/internal/ceres/callbacks.cc index 7d5ce2548e4..50a0ec19924 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/callbacks.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/callbacks.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -37,6 +37,8 @@ namespace ceres { namespace internal { +using std::string; + StateUpdatingCallback::StateUpdatingCallback(Program* program, double* parameters) : program_(program), parameters_(parameters) {} @@ -78,27 +80,27 @@ CallbackReturnType LoggingCallback::operator()( summary.cumulative_time_in_seconds); } else if (minimizer_type == TRUST_REGION) { if (summary.iteration == 0) { - output = "iter cost cost_change |gradient| |step| tr_ratio tr_radius ls_iter iter_time total_time\n"; + output = "iter cost cost_change |gradient| |step| tr_ratio tr_radius ls_iter iter_time total_time\n"; // NOLINT } const char* kReportRowFormat = - "% 4d % 8e % 3.2e % 3.2e % 3.2e % 3.2e % 3.2e % 4d % 3.2e % 3.2e"; + "% 4d % 8e % 3.2e % 3.2e % 3.2e % 3.2e % 3.2e % 4d % 3.2e % 3.2e"; // NOLINT output += StringPrintf(kReportRowFormat, - summary.iteration, - summary.cost, - summary.cost_change, - summary.gradient_max_norm, - summary.step_norm, - summary.relative_decrease, - summary.trust_region_radius, - summary.linear_solver_iterations, - summary.iteration_time_in_seconds, - summary.cumulative_time_in_seconds); + summary.iteration, + summary.cost, + summary.cost_change, + summary.gradient_max_norm, + summary.step_norm, + summary.relative_decrease, + summary.trust_region_radius, + summary.linear_solver_iterations, + summary.iteration_time_in_seconds, + summary.cumulative_time_in_seconds); } else { LOG(FATAL) << "Unknown minimizer type."; } if (log_to_stdout_) { - cout << output << endl; + std::cout << output << std::endl; } else { VLOG(1) << output; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/callbacks.h b/extern/libmv/third_party/ceres/internal/ceres/callbacks.h index 93704dfd6d1..33c66df5c11 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/callbacks.h +++ b/extern/libmv/third_party/ceres/internal/ceres/callbacks.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.cc b/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.cc index 9bbab4b2377..b655b1eccd3 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -45,6 +45,8 @@ namespace ceres { namespace internal { +using std::vector; + typedef HashMap<int, int> IntMap; typedef HashSet<int> IntSet; diff --git a/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.h b/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.h index d3fa5725831..6b0b38a854d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.h +++ b/extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -102,7 +102,7 @@ struct CanonicalViewsClusteringOptions; void ComputeCanonicalViewsClustering( const CanonicalViewsClusteringOptions& options, const WeightedGraph<int>& graph, - vector<int>* centers, + std::vector<int>* centers, HashMap<int, int>* membership); struct CanonicalViewsClusteringOptions { diff --git a/extern/libmv/third_party/ceres/internal/ceres/casts.h b/extern/libmv/third_party/ceres/internal/ceres/casts.h index 99cf2186cc7..f18fdea2d86 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/casts.h +++ b/extern/libmv/third_party/ceres/internal/ceres/casts.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/cgnr_linear_operator.h b/extern/libmv/third_party/ceres/internal/ceres/cgnr_linear_operator.h index f32d8d95c19..44c07cabd01 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/cgnr_linear_operator.h +++ b/extern/libmv/third_party/ceres/internal/ceres/cgnr_linear_operator.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.cc index 88e61d9ed1b..61fae758d5b 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.h b/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.h index c63484c628b..f7a15736925 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/collections_port.h b/extern/libmv/third_party/ceres/internal/ceres/collections_port.h index 3f976b9fb59..e699a661b8b 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/collections_port.h +++ b/extern/libmv/third_party/ceres/internal/ceres/collections_port.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -69,7 +69,6 @@ #include <utility> #include "ceres/integral_types.h" -#include "ceres/internal/port.h" // Some systems don't have access to unordered_map/unordered_set. In // that case, substitute the hash map/set with normal map/set. The diff --git a/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc b/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc index b62a6ed3830..ebb2a62c544 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -38,12 +38,15 @@ namespace ceres { namespace internal { -void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows, - const int* scalar_cols, - const vector<int>& row_blocks, - const vector<int>& col_blocks, - vector<int>* block_rows, - vector<int>* block_cols) { +using std::vector; + +void CompressedColumnScalarMatrixToBlockMatrix( + const int* scalar_rows, + const int* scalar_cols, + const vector<int>& row_blocks, + const vector<int>& col_blocks, + vector<int>* block_rows, + vector<int>* block_cols) { CHECK_NOTNULL(block_rows)->clear(); CHECK_NOTNULL(block_cols)->clear(); const int num_row_blocks = row_blocks.size(); @@ -66,9 +69,10 @@ void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows, for (int col_block = 0; col_block < num_col_blocks; ++col_block) { int column_size = 0; for (int idx = scalar_cols[c]; idx < scalar_cols[c + 1]; ++idx) { - vector<int>::const_iterator it = lower_bound(row_block_starts.begin(), - row_block_starts.end(), - scalar_rows[idx]); + vector<int>::const_iterator it = + std::lower_bound(row_block_starts.begin(), + row_block_starts.end(), + scalar_rows[idx]); // Since we are using lower_bound, it will return the row id // where the row block starts. For everything but the first row // of the block, where these values will be the same, we can diff --git a/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h b/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h index c8de2a1591a..da2109fba3e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h +++ b/extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -47,19 +47,21 @@ namespace internal { // and column block j, then it is expected that A contains at least // one non-zero entry corresponding to the top left entry of c_ij, // as that entry is used to detect the presence of a non-zero c_ij. -void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows, - const int* scalar_cols, - const vector<int>& row_blocks, - const vector<int>& col_blocks, - vector<int>* block_rows, - vector<int>* block_cols); +void CompressedColumnScalarMatrixToBlockMatrix( + const int* scalar_rows, + const int* scalar_cols, + const std::vector<int>& row_blocks, + const std::vector<int>& col_blocks, + std::vector<int>* block_rows, + std::vector<int>* block_cols); // Given a set of blocks and a permutation of these blocks, compute // the corresponding "scalar" ordering, where the scalar ordering of // size sum(blocks). -void BlockOrderingToScalarOrdering(const vector<int>& blocks, - const vector<int>& block_ordering, - vector<int>* scalar_ordering); +void BlockOrderingToScalarOrdering( + const std::vector<int>& blocks, + const std::vector<int>& block_ordering, + std::vector<int>* scalar_ordering); // Solve the linear system // @@ -120,7 +122,7 @@ void SolveRTRWithSparseRHS(IntegerType num_cols, const double* values, const int rhs_nonzero_index, double* solution) { - fill(solution, solution + num_cols, 0.0); + std::fill(solution, solution + num_cols, 0.0); solution[rhs_nonzero_index] = 1.0 / values[cols[rhs_nonzero_index + 1] - 1]; for (IntegerType c = rhs_nonzero_index + 1; c < num_cols; ++c) { diff --git a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.cc b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.cc index ed8db14c99a..64b6ac00447 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -30,6 +30,9 @@ #include "ceres/compressed_row_jacobian_writer.h" +#include <utility> +#include <vector> + #include "ceres/casts.h" #include "ceres/compressed_row_sparse_matrix.h" #include "ceres/parameter_block.h" @@ -40,6 +43,10 @@ namespace ceres { namespace internal { +using std::make_pair; +using std::pair; +using std::vector; + void CompressedRowJacobianWriter::PopulateJacobianRowAndColumnBlockVectors( const Program* program, CompressedRowSparseMatrix* jacobian) { const vector<ParameterBlock*>& parameter_blocks = @@ -214,9 +221,9 @@ void CompressedRowJacobianWriter::Write(int residual_id, double* column_block_begin = jacobian_values + jacobian_rows[residual_offset + r] + col_pos; - copy(block_row_begin, - block_row_begin + parameter_block_size, - column_block_begin); + std::copy(block_row_begin, + block_row_begin + parameter_block_size, + column_block_begin); } col_pos += parameter_block_size; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.h b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.h index a722a7c28e3..1cd01235ccf 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -33,6 +33,9 @@ #ifndef CERES_INTERNAL_COMPRESSED_ROW_JACOBIAN_WRITER_H_ #define CERES_INTERNAL_COMPRESSED_ROW_JACOBIAN_WRITER_H_ +#include <utility> +#include <vector> + #include "ceres/evaluator.h" #include "ceres/scratch_evaluate_preparer.h" @@ -80,7 +83,7 @@ class CompressedRowJacobianWriter { static void GetOrderedParameterBlocks( const Program* program, int residual_id, - vector<pair<int, int> >* evaluated_jacobian_blocks); + std::vector<std::pair<int, int> >* evaluated_jacobian_blocks); // JacobianWriter interface. diff --git a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.cc index 7993ed6917a..91d18bbd604 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -40,6 +40,9 @@ namespace ceres { namespace internal { + +using std::vector; + namespace { // Helper functor used by the constructor for reordering the contents @@ -155,7 +158,7 @@ CompressedRowSparseMatrix::~CompressedRowSparseMatrix() { } void CompressedRowSparseMatrix::SetZero() { - fill(values_.begin(), values_.end(), 0); + std::fill(values_.begin(), values_.end(), 0); } void CompressedRowSparseMatrix::RightMultiply(const double* x, @@ -184,7 +187,7 @@ void CompressedRowSparseMatrix::LeftMultiply(const double* x, double* y) const { void CompressedRowSparseMatrix::SquaredColumnNorm(double* x) const { CHECK_NOTNULL(x); - fill(x, x + num_cols_, 0.0); + std::fill(x, x + num_cols_, 0.0); for (int idx = 0; idx < rows_[num_rows_]; ++idx) { x[cols_[idx]] += values_[idx] * values_[idx]; } @@ -238,26 +241,38 @@ void CompressedRowSparseMatrix::AppendRows(const CompressedRowSparseMatrix& m) { << "The matrix being appended has: " << m.row_blocks().size() << " row blocks."; + if (m.num_rows() == 0) { + return; + } + if (cols_.size() < num_nonzeros() + m.num_nonzeros()) { cols_.resize(num_nonzeros() + m.num_nonzeros()); values_.resize(num_nonzeros() + m.num_nonzeros()); } // Copy the contents of m into this matrix. - copy(m.cols(), m.cols() + m.num_nonzeros(), &cols_[num_nonzeros()]); - copy(m.values(), m.values() + m.num_nonzeros(), &values_[num_nonzeros()]); + DCHECK_LT(num_nonzeros(), cols_.size()); + if (m.num_nonzeros() > 0) { + std::copy(m.cols(), m.cols() + m.num_nonzeros(), &cols_[num_nonzeros()]); + std::copy(m.values(), + m.values() + m.num_nonzeros(), + &values_[num_nonzeros()]); + } + rows_.resize(num_rows_ + m.num_rows() + 1); // new_rows = [rows_, m.row() + rows_[num_rows_]] - fill(rows_.begin() + num_rows_, - rows_.begin() + num_rows_ + m.num_rows() + 1, - rows_[num_rows_]); + std::fill(rows_.begin() + num_rows_, + rows_.begin() + num_rows_ + m.num_rows() + 1, + rows_[num_rows_]); for (int r = 0; r < m.num_rows() + 1; ++r) { rows_[num_rows_ + r] += m.rows()[r]; } num_rows_ += m.num_rows(); - row_blocks_.insert(row_blocks_.end(), m.row_blocks().begin(), m.row_blocks().end()); + row_blocks_.insert(row_blocks_.end(), + m.row_blocks().begin(), + m.row_blocks().end()); } void CompressedRowSparseMatrix::ToTextFile(FILE* file) const { @@ -329,7 +344,7 @@ CompressedRowSparseMatrix* CompressedRowSparseMatrix::CreateBlockDiagonalMatrix( int* rows = matrix->mutable_rows(); int* cols = matrix->mutable_cols(); double* values = matrix->mutable_values(); - fill(values, values + num_nonzeros, 0.0); + std::fill(values, values + num_nonzeros, 0.0); int idx_cursor = 0; int col_cursor = 0; @@ -481,8 +496,9 @@ CompressedRowSparseMatrix::CreateOuterProductMatrixAndProgram( const CompressedRowSparseMatrix& m, vector<int>* program) { CHECK_NOTNULL(program)->clear(); - CHECK_GT(m.num_nonzeros(), 0) << "Congratulations, " - << "you found a bug in Ceres. Please report it."; + CHECK_GT(m.num_nonzeros(), 0) + << "Congratulations, " + << "you found a bug in Ceres. Please report it."; vector<ProductTerm> product; const vector<int>& row_blocks = m.row_blocks(); @@ -495,7 +511,9 @@ CompressedRowSparseMatrix::CreateOuterProductMatrixAndProgram( // Compute the lower triangular part of the product. for (int idx1 = m.rows()[r]; idx1 < m.rows()[r + 1]; ++idx1) { for (int idx2 = m.rows()[r]; idx2 <= idx1; ++idx2) { - product.push_back(ProductTerm(m.cols()[idx1], m.cols()[idx2], product.size())); + product.push_back(ProductTerm(m.cols()[idx1], + m.cols()[idx2], + product.size())); } } row_block_begin = row_block_end; diff --git a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.h index a0ba7eeb6ce..987339d09a1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -109,11 +109,11 @@ class CompressedRowSparseMatrix : public SparseMatrix { const int* rows() const { return &rows_[0]; } int* mutable_rows() { return &rows_[0]; } - const vector<int>& row_blocks() const { return row_blocks_; } - vector<int>* mutable_row_blocks() { return &row_blocks_; } + const std::vector<int>& row_blocks() const { return row_blocks_; } + std::vector<int>* mutable_row_blocks() { return &row_blocks_; } - const vector<int>& col_blocks() const { return col_blocks_; } - vector<int>* mutable_col_blocks() { return &col_blocks_; } + const std::vector<int>& col_blocks() const { return col_blocks_; } + std::vector<int>* mutable_col_blocks() { return &col_blocks_; } // Destructive array resizing method. void SetMaxNumNonZeros(int num_nonzeros); @@ -129,7 +129,7 @@ class CompressedRowSparseMatrix : public SparseMatrix { static CompressedRowSparseMatrix* CreateBlockDiagonalMatrix( const double* diagonal, - const vector<int>& blocks); + const std::vector<int>& blocks); // Compute the sparsity structure of the product m.transpose() * m // and create a CompressedRowSparseMatrix corresponding to it. @@ -147,30 +147,30 @@ class CompressedRowSparseMatrix : public SparseMatrix { // this information for each row in the row block. static CompressedRowSparseMatrix* CreateOuterProductMatrixAndProgram( const CompressedRowSparseMatrix& m, - vector<int>* program); + std::vector<int>* program); // Compute the values array for the expression m.transpose() * m, // where the matrix used to store the result and a program have been // created using the CreateOuterProductMatrixAndProgram function // above. static void ComputeOuterProduct(const CompressedRowSparseMatrix& m, - const vector<int>& program, + const std::vector<int>& program, CompressedRowSparseMatrix* result); private: int num_rows_; int num_cols_; - vector<int> rows_; - vector<int> cols_; - vector<double> values_; + std::vector<int> rows_; + std::vector<int> cols_; + std::vector<double> values_; // If the matrix has an underlying block structure, then it can also // carry with it row and column block sizes. This is auxilliary and // optional information for use by algorithms operating on the // matrix. The class itself does not make use of this information in // any way. - vector<int> row_blocks_; - vector<int> col_blocks_; + std::vector<int> row_blocks_; + std::vector<int> col_blocks_; CERES_DISALLOW_COPY_AND_ASSIGN(CompressedRowSparseMatrix); }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/conditioned_cost_function.cc b/extern/libmv/third_party/ceres/internal/ceres/conditioned_cost_function.cc index 7322790f717..08899e3d246 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/conditioned_cost_function.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/conditioned_cost_function.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -45,7 +45,7 @@ namespace ceres { // the one it's wrapping. ConditionedCostFunction::ConditionedCostFunction( CostFunction* wrapped_cost_function, - const vector<CostFunction*>& conditioners, + const std::vector<CostFunction*>& conditioners, Ownership ownership) : wrapped_cost_function_(wrapped_cost_function), conditioners_(conditioners), diff --git a/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.cc index 3071a0918e4..3702276a2fb 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -114,7 +114,6 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( double Q0 = -1.0 * xref.dot(bref + r); for (summary.num_iterations = 1;; ++summary.num_iterations) { - // Apply preconditioner if (per_solve_options.preconditioner != NULL) { z.setZero(); @@ -129,7 +128,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( summary.termination_type = LINEAR_SOLVER_FAILURE; summary.message = StringPrintf("Numerical failure. rho = r'z = %e.", rho); break; - }; + } if (summary.num_iterations == 1) { p = z; @@ -138,7 +137,8 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( if (IsZeroOrInfinity(beta)) { summary.termination_type = LINEAR_SOLVER_FAILURE; summary.message = StringPrintf( - "Numerical failure. beta = rho_n / rho_{n-1} = %e.", beta); + "Numerical failure. beta = rho_n / rho_{n-1} = %e, " + "rho_n = %e, rho_{n-1} = %e", beta, rho, last_rho); break; } p = z + beta * p; @@ -149,8 +149,11 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( A->RightMultiply(p.data(), q.data()); const double pq = p.dot(q); if ((pq <= 0) || IsInfinite(pq)) { - summary.termination_type = LINEAR_SOLVER_FAILURE; - summary.message = StringPrintf("Numerical failure. p'q = %e.", pq); + summary.termination_type = LINEAR_SOLVER_NO_CONVERGENCE; + summary.message = StringPrintf( + "Matrix is indefinite, no more progress can be made. " + "p'q = %e. |p| = %e, |q| = %e", + pq, p.norm(), q.norm()); break; } @@ -158,7 +161,8 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( if (IsInfinite(alpha)) { summary.termination_type = LINEAR_SOLVER_FAILURE; summary.message = - StringPrintf("Numerical failure. alpha = rho / pq = %e", alpha); + StringPrintf("Numerical failure. alpha = rho / pq = %e, " + "rho = %e, pq = %e.", alpha, rho, pq); break; } @@ -210,9 +214,11 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( summary.num_iterations >= options_.min_num_iterations) { summary.termination_type = LINEAR_SOLVER_SUCCESS; summary.message = - StringPrintf("Convergence: zeta = %e < %e", + StringPrintf("Iteration: %d Convergence: zeta = %e < %e. |r| = %e", + summary.num_iterations, zeta, - per_solve_options.q_tolerance); + per_solve_options.q_tolerance, + r.norm()); break; } Q0 = Q1; @@ -223,7 +229,10 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( summary.num_iterations >= options_.min_num_iterations) { summary.termination_type = LINEAR_SOLVER_SUCCESS; summary.message = - StringPrintf("Convergence. |r| = %e <= %e.", norm_r, tol_r); + StringPrintf("Iteration: %d Convergence. |r| = %e <= %e.", + summary.num_iterations, + norm_r, + tol_r); break; } @@ -233,7 +242,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve( } return summary; -}; +} } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.h b/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.h index b8dfa56b526..a1e18334414 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.cc b/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.cc index 0d8adee7cd8..c6b42cf1516 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -48,11 +48,17 @@ #include "ceres/solver.h" #include "ceres/trust_region_minimizer.h" #include "ceres/trust_region_strategy.h" -#include "ceres/parameter_block_ordering.h" namespace ceres { namespace internal { +using std::map; +using std::max; +using std::min; +using std::set; +using std::string; +using std::vector; + CoordinateDescentMinimizer::~CoordinateDescentMinimizer() { } @@ -244,7 +250,7 @@ bool CoordinateDescentMinimizer::IsOrderingValid( // Verify that each group is an independent set map<int, set<double*> >::const_iterator it = group_to_elements.begin(); - for ( ; it != group_to_elements.end(); ++it) { + for (; it != group_to_elements.end(); ++it) { if (!program.IsParameterBlockSetIndependent(it->second)) { *message = StringPrintf("The user-provided " diff --git a/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.h b/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.h index c1f8ffcd02a..25ea04ce622 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -60,7 +60,7 @@ class CoordinateDescentMinimizer : public Minimizer { bool Init(const Program& program, const ProblemImpl::ParameterMap& parameter_map, const ParameterBlockOrdering& ordering, - string* error); + std::string* error); // Minimizer interface. virtual ~CoordinateDescentMinimizer(); @@ -71,7 +71,7 @@ class CoordinateDescentMinimizer : public Minimizer { // Verify that each group in the ordering forms an independent set. static bool IsOrderingValid(const Program& program, const ParameterBlockOrdering& ordering, - string* message); + std::string* message); // Find a recursive decomposition of the Hessian matrix as a set // of independent sets of decreasing size and invert it. This @@ -85,13 +85,13 @@ class CoordinateDescentMinimizer : public Minimizer { double* parameters, Solver::Summary* summary); - vector<ParameterBlock*> parameter_blocks_; - vector<vector<ResidualBlock*> > residual_blocks_; + std::vector<ParameterBlock*> parameter_blocks_; + std::vector<std::vector<ResidualBlock*> > residual_blocks_; // The optimization is performed in rounds. In each round all the // parameter blocks that form one independent set are optimized in // parallel. This array, marks the boundaries of the independent // sets in parameter_blocks_. - vector<int> independent_set_offsets_; + std::vector<int> independent_set_offsets_; Evaluator::Options evaluator_options_; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/corrector.cc b/extern/libmv/third_party/ceres/internal/ceres/corrector.cc index 581fc6d4fc0..720182868c1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/corrector.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/corrector.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/corrector.h b/extern/libmv/third_party/ceres/internal/ceres/corrector.h index 2137221784e..315f012ab1d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/corrector.h +++ b/extern/libmv/third_party/ceres/internal/ceres/corrector.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/covariance.cc b/extern/libmv/third_party/ceres/internal/ceres/covariance.cc index 35146c582b2..690847945a9 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/covariance.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/covariance.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -38,6 +38,9 @@ namespace ceres { +using std::pair; +using std::vector; + Covariance::Covariance(const Covariance::Options& options) { impl_.reset(new internal::CovarianceImpl(options)); } @@ -54,9 +57,20 @@ bool Covariance::Compute( bool Covariance::GetCovarianceBlock(const double* parameter_block1, const double* parameter_block2, double* covariance_block) const { - return impl_->GetCovarianceBlock(parameter_block1, - parameter_block2, - covariance_block); + return impl_->GetCovarianceBlockInTangentOrAmbientSpace(parameter_block1, + parameter_block2, + true, // ambient + covariance_block); +} + +bool Covariance::GetCovarianceBlockInTangentSpace( + const double* parameter_block1, + const double* parameter_block2, + double* covariance_block) const { + return impl_->GetCovarianceBlockInTangentOrAmbientSpace(parameter_block1, + parameter_block2, + false, // tangent + covariance_block); } } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.cc b/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.cc index cfbfb445343..3e8302bed55 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -38,26 +38,11 @@ #include <cstdlib> #include <utility> #include <vector> -#include "Eigen/SparseCore" -// Suppress unused local variable warning from Eigen Ordering.h #included by -// SparseQR in Eigen 3.2.0. This was fixed in Eigen 3.2.1, but 3.2.0 is still -// widely used (Ubuntu 14.04), and Ceres won't compile otherwise due to -Werror. -#if defined(_MSC_VER) -#pragma warning( push ) -#pragma warning( disable : 4189 ) -#else -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif +#include "Eigen/SparseCore" #include "Eigen/SparseQR" -#if defined(_MSC_VER) -#pragma warning( pop ) -#else -#pragma GCC diagnostic pop -#endif - #include "Eigen/SVD" + #include "ceres/compressed_col_sparse_matrix_utils.h" #include "ceres/compressed_row_sparse_matrix.h" #include "ceres/covariance.h" @@ -73,6 +58,12 @@ namespace ceres { namespace internal { +using std::make_pair; +using std::map; +using std::pair; +using std::swap; +using std::vector; + typedef vector<pair<const double*, const double*> > CovarianceBlocks; CovarianceImpl::CovarianceImpl(const Covariance::Options& options) @@ -106,9 +97,11 @@ bool CovarianceImpl::Compute(const CovarianceBlocks& covariance_blocks, return is_valid_; } -bool CovarianceImpl::GetCovarianceBlock(const double* original_parameter_block1, - const double* original_parameter_block2, - double* covariance_block) const { +bool CovarianceImpl::GetCovarianceBlockInTangentOrAmbientSpace( + const double* original_parameter_block1, + const double* original_parameter_block2, + bool lift_covariance_to_ambient_space, + double* covariance_block) const { CHECK(is_computed_) << "Covariance::GetCovarianceBlock called before Covariance::Compute"; CHECK(is_valid_) @@ -137,7 +130,7 @@ bool CovarianceImpl::GetCovarianceBlock(const double* original_parameter_block1, const double* parameter_block2 = original_parameter_block2; const bool transpose = parameter_block1 > parameter_block2; if (transpose) { - std::swap(parameter_block1, parameter_block2); + swap(parameter_block1, parameter_block2); } // Find where in the covariance matrix the block is located. @@ -181,14 +174,17 @@ bool CovarianceImpl::GetCovarianceBlock(const double* original_parameter_block1, block1_size, row_size); - // Fast path when there are no local parameterizations. - if (local_param1 == NULL && local_param2 == NULL) { + // Fast path when there are no local parameterizations or if the + // user does not want it lifted to the ambient space. + if ((local_param1 == NULL && local_param2 == NULL) || + !lift_covariance_to_ambient_space) { if (transpose) { - MatrixRef(covariance_block, block2_size, block1_size) = - cov.block(0, offset, block1_size, block2_size).transpose(); + MatrixRef(covariance_block, block2_local_size, block1_local_size) = + cov.block(0, offset, block1_local_size, + block2_local_size).transpose(); } else { - MatrixRef(covariance_block, block1_size, block2_size) = - cov.block(0, offset, block1_size, block2_size); + MatrixRef(covariance_block, block1_local_size, block2_local_size) = + cov.block(0, offset, block1_local_size, block2_local_size); } return true; } @@ -257,7 +253,8 @@ bool CovarianceImpl::ComputeCovarianceSparsity( problem->GetParameterBlocks(&all_parameter_blocks); const ProblemImpl::ParameterMap& parameter_map = problem->parameter_map(); constant_parameter_blocks_.clear(); - vector<double*>& active_parameter_blocks = evaluate_options_.parameter_blocks; + vector<double*>& active_parameter_blocks = + evaluate_options_.parameter_blocks; active_parameter_blocks.clear(); for (int i = 0; i < all_parameter_blocks.size(); ++i) { double* parameter_block = all_parameter_blocks[i]; @@ -270,7 +267,7 @@ bool CovarianceImpl::ComputeCovarianceSparsity( } } - sort(active_parameter_blocks.begin(), active_parameter_blocks.end()); + std::sort(active_parameter_blocks.begin(), active_parameter_blocks.end()); // Compute the number of rows. Map each parameter block to the // first row corresponding to it in the covariance matrix using the @@ -609,8 +606,8 @@ bool CovarianceImpl::ComputeCovarianceValuesUsingDenseSVD() { sqrt(options_.min_reciprocal_condition_number); const bool automatic_truncation = (options_.null_space_rank < 0); - const int max_rank = min(num_singular_values, - num_singular_values - options_.null_space_rank); + const int max_rank = std::min(num_singular_values, + num_singular_values - options_.null_space_rank); // Compute the squared inverse of the singular values. Truncate the // computation based on min_singular_value_ratio and @@ -687,7 +684,7 @@ bool CovarianceImpl::ComputeCovarianceValuesUsingEigenSparseQR() { qr_solver(sparse_jacobian); event_logger.AddEvent("QRDecomposition"); - if(qr_solver.info() != Eigen::Success) { + if (qr_solver.info() != Eigen::Success) { LOG(ERROR) << "Eigen::SparseQR decomposition failed."; return false; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.h b/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.h index 135f4a1d624..eb0cd040666 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.h +++ b/extern/libmv/third_party/ceres/internal/ceres/covariance_impl.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -41,7 +41,6 @@ #include "ceres/suitesparse.h" namespace ceres { - namespace internal { class CompressedRowSparseMatrix; @@ -52,15 +51,19 @@ class CovarianceImpl { ~CovarianceImpl(); bool Compute( - const vector<pair<const double*, const double*> >& covariance_blocks, + const std::vector<std::pair<const double*, + const double*> >& covariance_blocks, ProblemImpl* problem); - bool GetCovarianceBlock(const double* parameter_block1, - const double* parameter_block2, - double* covariance_block) const; + bool GetCovarianceBlockInTangentOrAmbientSpace( + const double* parameter_block1, + const double* parameter_block2, + bool lift_covariance_to_ambient_space, + double* covariance_block) const; bool ComputeCovarianceSparsity( - const vector<pair<const double*, const double*> >& covariance_blocks, + const std::vector<std::pair<const double*, + const double*> >& covariance_blocks, ProblemImpl* problem); bool ComputeCovarianceValues(); @@ -78,8 +81,8 @@ class CovarianceImpl { Problem::EvaluateOptions evaluate_options_; bool is_computed_; bool is_valid_; - map<const double*, int> parameter_block_to_row_index_; - set<const double*> constant_parameter_blocks_; + std::map<const double*, int> parameter_block_to_row_index_; + std::set<const double*> constant_parameter_blocks_; scoped_ptr<CompressedRowSparseMatrix> covariance_matrix_; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/cxsparse.cc b/extern/libmv/third_party/ceres/internal/ceres/cxsparse.cc index 87503d06c99..60b58089bb5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/cxsparse.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/cxsparse.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -38,13 +38,14 @@ #include <vector> #include "ceres/compressed_col_sparse_matrix_utils.h" #include "ceres/compressed_row_sparse_matrix.h" -#include "ceres/internal/port.h" #include "ceres/triplet_sparse_matrix.h" #include "glog/logging.h" namespace ceres { namespace internal { +using std::vector; + CXSparse::CXSparse() : scratch_(NULL), scratch_size_(0) { } @@ -128,7 +129,7 @@ cs_dis* CXSparse::BlockAnalyzeCholesky(cs_di* A, int* ordering = cs_amd(1, &block_matrix); vector<int> block_ordering(num_row_blocks, -1); - copy(ordering, ordering + num_row_blocks, &block_ordering[0]); + std::copy(ordering, ordering + num_row_blocks, &block_ordering[0]); cs_free(ordering); vector<int> scalar_ordering; @@ -191,7 +192,7 @@ cs_di* CXSparse::CreateSparseMatrix(TripletSparseMatrix* tsm) { void CXSparse::ApproximateMinimumDegreeOrdering(cs_di* A, int* ordering) { int* cs_ordering = cs_amd(1, A); - copy(cs_ordering, cs_ordering + A->m, ordering); + std::copy(cs_ordering, cs_ordering + A->m, ordering); cs_free(cs_ordering); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/cxsparse.h b/extern/libmv/third_party/ceres/internal/ceres/cxsparse.h index 5868401b961..26dd1927a78 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/cxsparse.h +++ b/extern/libmv/third_party/ceres/internal/ceres/cxsparse.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -107,8 +107,8 @@ class CXSparse { // The returned matrix should be deallocated with Free when not used // anymore. cs_dis* BlockAnalyzeCholesky(cs_di* A, - const vector<int>& row_blocks, - const vector<int>& col_blocks); + const std::vector<int>& row_blocks, + const std::vector<int>& col_blocks); // Compute an fill-reducing approximate minimum degree ordering of // the matrix A. ordering should be non-NULL and should point to @@ -133,8 +133,7 @@ typedef void cs_dis; class CXSparse { public: - void Free(void*) {}; - + void Free(void* arg) {} }; #endif // CERES_NO_CXSPARSE diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_jacobian_writer.h b/extern/libmv/third_party/ceres/internal/ceres/dense_jacobian_writer.h index be743a8591c..1b04f383f09 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_jacobian_writer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_jacobian_writer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -70,10 +70,7 @@ class DenseJacobianWriter { int residual_offset, double **jacobians, SparseMatrix* jacobian) { - DenseSparseMatrix* dense_jacobian; - if (jacobian != NULL) { - dense_jacobian = down_cast<DenseSparseMatrix*>(jacobian); - } + DenseSparseMatrix* dense_jacobian = down_cast<DenseSparseMatrix*>(jacobian); const ResidualBlock* residual_block = program_->residual_blocks()[residual_id]; int num_parameter_blocks = residual_block->NumParameterBlocks(); diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.cc index f44d6da824c..b13cf3fc9f6 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.h b/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.h index e35053f5234..11287ebf675 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.cc index 4388357bd2d..e85fdfc0c68 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.h b/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.h index e745c63cb44..1a6e0898c56 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.cc index d67474fed32..19db867d4aa 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.h index 981e2d14562..b011bfddee7 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/detect_structure.cc b/extern/libmv/third_party/ceres/internal/ceres/detect_structure.cc index ea5bf2e9690..959a0ee3c84 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/detect_structure.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/detect_structure.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -54,8 +54,8 @@ void DetectStructure(const CompressedRowBlockStructure& bs, if (row.cells.front().block_id >= num_eliminate_blocks) { break; } - const int e_block_id = row.cells.front().block_id; + // Detect fixed or dynamic row block size. if (*row_block_size == 0) { *row_block_size = row.block.size; } else if (*row_block_size != Eigen::Dynamic && @@ -66,7 +66,8 @@ void DetectStructure(const CompressedRowBlockStructure& bs, *row_block_size = Eigen::Dynamic; } - + // Detect fixed or dynamic e-block size. + const int e_block_id = row.cells.front().block_id; if (*e_block_size == 0) { *e_block_size = bs.cols[e_block_id].size; } else if (*e_block_size != Eigen::Dynamic && @@ -77,19 +78,24 @@ void DetectStructure(const CompressedRowBlockStructure& bs, *e_block_size = Eigen::Dynamic; } - if (*f_block_size == 0) { - if (row.cells.size() > 1) { + // Detect fixed or dynamic f-block size. We are only interested in + // rows with e-blocks, and the e-block is always the first block, + // so only rows of size greater than 1 are of interest. + if (row.cells.size() > 1) { + if (*f_block_size == 0) { const int f_block_id = row.cells[1].block_id; *f_block_size = bs.cols[f_block_id].size; } - } else if (*f_block_size != Eigen::Dynamic) { - for (int c = 1; c < row.cells.size(); ++c) { - if (*f_block_size != bs.cols[row.cells[c].block_id].size) { + + for (int c = 1; + (c < row.cells.size()) && (*f_block_size != Eigen::Dynamic); + ++c) { + const int f_block_id = row.cells[c].block_id; + if (*f_block_size != bs.cols[f_block_id].size) { VLOG(2) << "Dynamic f block size because the block size " << "changed from " << *f_block_size << " to " - << bs.cols[row.cells[c].block_id].size; + << bs.cols[f_block_id].size; *f_block_size = Eigen::Dynamic; - break; } } } diff --git a/extern/libmv/third_party/ceres/internal/ceres/detect_structure.h b/extern/libmv/third_party/ceres/internal/ceres/detect_structure.h index 5f8e1b4ff46..602581c846e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/detect_structure.h +++ b/extern/libmv/third_party/ceres/internal/ceres/detect_structure.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -51,6 +51,10 @@ namespace internal { // For more details about e_blocks and f_blocks, see // schur_eliminator.h. This information is used to initialized an // appropriate template specialization of SchurEliminator. +// +// Note: The structure of rows without any e-blocks has no effect on +// the values returned by this function. It is entirely possible that +// the f_block_size and row_blocks_size is not constant in such rows. void DetectStructure(const CompressedRowBlockStructure& bs, const int num_eliminate_blocks, int* row_block_size, diff --git a/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.cc b/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.cc index f29376db793..839e1816338 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -120,7 +120,8 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep( // jacobian->SquaredColumnNorm(diagonal_.data()); for (int i = 0; i < n; ++i) { - diagonal_[i] = min(max(diagonal_[i], min_diagonal_), max_diagonal_); + diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_), + max_diagonal_); } diagonal_ = diagonal_.array().sqrt(); @@ -618,13 +619,13 @@ void DoglegStrategy::StepAccepted(double step_quality) { } if (step_quality > increase_threshold_) { - radius_ = max(radius_, 3.0 * dogleg_step_norm_); + radius_ = std::max(radius_, 3.0 * dogleg_step_norm_); } // Reduce the regularization multiplier, in the hope that whatever // was causing the rank deficiency has gone away and we can return // to doing a pure Gauss-Newton solve. - mu_ = max(min_mu_, 2.0 * mu_ / mu_increase_factor_); + mu_ = std::max(min_mu_, 2.0 * mu_ / mu_increase_factor_); reuse_ = false; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.h b/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.h index 71c785cc3f7..046b9d824c9 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_finalizer.h b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_finalizer.h index 5e6b0d84510..a25a3083120 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_finalizer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_finalizer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -48,4 +48,4 @@ struct DynamicCompressedRowJacobianFinalizer { } // namespace internal } // namespace ceres -#endif // CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALISER_H_ +#endif // CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALISER_H_ diff --git a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.cc b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.cc index b46cb797ff2..fd5d89e350a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -39,6 +39,9 @@ namespace ceres { namespace internal { +using std::pair; +using std::vector; + ScratchEvaluatePreparer* DynamicCompressedRowJacobianWriter::CreateEvaluatePreparers(int num_threads) { return ScratchEvaluatePreparer::Create(*program_, num_threads); diff --git a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.h b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.h index df9581b145d..6e5ac38f07e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -80,4 +80,4 @@ class DynamicCompressedRowJacobianWriter { } // namespace internal } // namespace ceres -#endif // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_JACOBIAN_WRITER_H_ +#endif // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_JACOBIAN_WRITER_H_ diff --git a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.cc index f285d52a342..f020768ce10 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.h index 7a89a708658..cab860bddbd 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -41,6 +41,8 @@ #ifndef CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_ #define CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_ +#include <vector> + #include "ceres/compressed_row_sparse_matrix.h" namespace ceres { @@ -89,11 +91,11 @@ class DynamicCompressedRowSparseMatrix : public CompressedRowSparseMatrix { void Finalize(int num_additional_elements); private: - vector<vector<int> > dynamic_cols_; - vector<vector<double> > dynamic_values_; + std::vector<std::vector<int> > dynamic_cols_; + std::vector<std::vector<double> > dynamic_values_; }; } // namespace internal } // namespace ceres -#endif // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_ +#endif // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_ diff --git a/extern/libmv/third_party/ceres/internal/ceres/evaluator.cc b/extern/libmv/third_party/ceres/internal/ceres/evaluator.cc index c94c62c29b5..baba9afa11b 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/evaluator.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/evaluator.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -50,7 +50,7 @@ Evaluator::~Evaluator() {} Evaluator* Evaluator::Create(const Evaluator::Options& options, Program* program, - string* error) { + std::string* error) { switch (options.linear_solver_type) { case DENSE_QR: case DENSE_NORMAL_CHOLESKY: diff --git a/extern/libmv/third_party/ceres/internal/ceres/evaluator.h b/extern/libmv/third_party/ceres/internal/ceres/evaluator.h index 8fc60b87869..fea307919d0 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/evaluator.h +++ b/extern/libmv/third_party/ceres/internal/ceres/evaluator.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -72,7 +72,7 @@ class Evaluator { static Evaluator* Create(const Options& options, Program* program, - string* error); + std::string* error); // This is used for computing the cost, residual and Jacobian for // returning to the user. For actually solving the optimization @@ -95,8 +95,8 @@ class Evaluator { static bool Evaluate(Program* program, int num_threads, double* cost, - vector<double>* residuals, - vector<double>* gradient, + std::vector<double>* residuals, + std::vector<double>* gradient, CRSMatrix* jacobian); // Build and return a sparse matrix for storing and working with the Jacobian @@ -190,12 +190,12 @@ class Evaluator { // that the base class implementation does not have to worry about // life time issues. Further, these calls are not expected to be // frequent or performance sensitive. - virtual map<string, int> CallStatistics() const { - return map<string, int>(); + virtual std::map<std::string, int> CallStatistics() const { + return std::map<std::string, int>(); } - virtual map<string, double> TimeStatistics() const { - return map<string, double>(); + virtual std::map<std::string, double> TimeStatistics() const { + return std::map<std::string, double>(); } }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/execution_summary.h b/extern/libmv/third_party/ceres/internal/ceres/execution_summary.h index 29bdc69ecd7..aa9929d8974 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/execution_summary.h +++ b/extern/libmv/third_party/ceres/internal/ceres/execution_summary.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -46,30 +46,30 @@ namespace internal { // can be used for reporting times associated with various activities. class ExecutionSummary { public: - void IncrementTimeBy(const string& name, const double value) { + void IncrementTimeBy(const std::string& name, const double value) { CeresMutexLock l(×_mutex_); times_[name] += value; } - void IncrementCall(const string& name) { + void IncrementCall(const std::string& name) { CeresMutexLock l(&calls_mutex_); calls_[name] += 1; } - const map<string, double>& times() const { return times_; } - const map<string, int>& calls() const { return calls_; } + const std::map<std::string, double>& times() const { return times_; } + const std::map<std::string, int>& calls() const { return calls_; } private: Mutex times_mutex_; - map<string, double> times_; + std::map<std::string, double> times_; Mutex calls_mutex_; - map<string, int> calls_; + std::map<std::string, int> calls_; }; class ScopedExecutionTimer { public: - ScopedExecutionTimer(const string& name, ExecutionSummary* summary) + ScopedExecutionTimer(const std::string& name, ExecutionSummary* summary) : start_time_(WallTimeInSeconds()), name_(name), summary_(summary) {} @@ -80,7 +80,7 @@ class ScopedExecutionTimer { private: const double start_time_; - const string name_; + const std::string name_; ExecutionSummary* summary_; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/file.cc b/extern/libmv/third_party/ceres/internal/ceres/file.cc index 5226c85e6ee..c95a44d2c38 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/file.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/file.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/file.h b/extern/libmv/third_party/ceres/internal/ceres/file.h index 4741d650646..219b459b919 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/file.h +++ b/extern/libmv/third_party/ceres/internal/ceres/file.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -39,12 +39,13 @@ namespace ceres { namespace internal { -void WriteStringToFileOrDie(const string &data, const string &filename); -void ReadFileToStringOrDie(const string &filename, string *data); +void WriteStringToFileOrDie(const std::string &data, + const std::string &filename); +void ReadFileToStringOrDie(const std::string &filename, std::string *data); // Join two path components, adding a slash if necessary. If basename is an // absolute path then JoinPath ignores dirname and simply returns basename. -string JoinPath(const string& dirname, const string& basename); +std::string JoinPath(const std::string& dirname, const std::string& basename); } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/generate_eliminator_specialization.py b/extern/libmv/third_party/ceres/internal/ceres/generate_eliminator_specialization.py index 2ec3c5b42ca..e89e7a48c98 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generate_eliminator_specialization.py +++ b/extern/libmv/third_party/ceres/internal/ceres/generate_eliminator_specialization.py @@ -1,6 +1,6 @@ # Ceres Solver - A fast non-linear least squares minimizer -# Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -# http://code.google.com/p/ceres-solver/ +# Copyright 2015 Google Inc. All rights reserved. +# http://ceres-solver.org/ # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: @@ -55,6 +55,7 @@ SPECIALIZATIONS = [(2, 2, 2), (2, 2, "Eigen::Dynamic"), (2, 3, 3), (2, 3, 4), + (2, 3, 6), (2, 3, 9), (2, 3, "Eigen::Dynamic"), (2, 4, 3), @@ -69,8 +70,8 @@ SPECIALIZATIONS = [(2, 2, 2), (4, 4, "Eigen::Dynamic"), ("Eigen::Dynamic", "Eigen::Dynamic", "Eigen::Dynamic")] HEADER = """// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generate_partitioned_matrix_view_specializations.py b/extern/libmv/third_party/ceres/internal/ceres/generate_partitioned_matrix_view_specializations.py index c9bdf238ce0..c4ac3cf2332 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generate_partitioned_matrix_view_specializations.py +++ b/extern/libmv/third_party/ceres/internal/ceres/generate_partitioned_matrix_view_specializations.py @@ -1,6 +1,6 @@ # Ceres Solver - A fast non-linear least squares minimizer -# Copyright 2013 Google Inc. All rights reserved. -# http://code.google.com/p/ceres-solver/ +# Copyright 2015 Google Inc. All rights reserved. +# http://ceres-solver.org/ # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: @@ -53,6 +53,7 @@ SPECIALIZATIONS = [(2, 2, 2), (2, 2, "Eigen::Dynamic"), (2, 3, 3), (2, 3, 4), + (2, 3, 6), (2, 3, 9), (2, 3, "Eigen::Dynamic"), (2, 4, 3), @@ -67,8 +68,8 @@ SPECIALIZATIONS = [(2, 2, 2), (4, 4, "Eigen::Dynamic"), ("Eigen::Dynamic", "Eigen::Dynamic", "Eigen::Dynamic")] HEADER = """// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_2.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_2.cc index a7d802ad8c0..500115b9897 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_2.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_2.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_3.cc index 89e6f7750b1..1384cb619e3 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_4.cc index 3a3e8b67243..030035ec97b 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_d.cc index 661f135cd10..c9501b50170 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_3.cc index e79e001d6c6..c2639bff69e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_4.cc index 2f1ae68d66a..693e43959c1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_6.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_6.cc new file mode 100644 index 00000000000..7b9368ffefd --- /dev/null +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_6.cc @@ -0,0 +1,59 @@ +// Ceres Solver - A fast non-linear least squares minimizer +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// Author: sameeragarwal@google.com (Sameer Agarwal) +// +// Template specialization of PartitionedMatrixView. +// +// ======================================== +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +//========================================= +// +// This file is generated using generate_partitioned_matrix_view_specializations.py. +// Editing it manually is not recommended. + +// This include must come before any #ifndef check on Ceres compile options. +#include "ceres/internal/port.h" + +#ifndef CERES_RESTRICT_SCHUR_SPECIALIZATION + +#include "ceres/partitioned_matrix_view_impl.h" +#include "ceres/internal/eigen.h" + +namespace ceres { +namespace internal { + +template class PartitionedMatrixView<2, 3, 6>; + +} // namespace internal +} // namespace ceres + +#endif // CERES_RESTRICT_SCHUR_SPECIALIZATION diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_9.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_9.cc index ab405503925..e72c5f6937a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_9.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_9.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_d.cc index 89ecff73319..c1f410eb64c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_3.cc index 182707d7df7..7292c333d5d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc index a2cf8f4a9dd..891d65a8646 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_8.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_8.cc index a2637691cb0..395f6bd4c13 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_8.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_8.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_9.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_9.cc index d853860326e..88952b10e34 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_9.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_9.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_d.cc index 7d622fcabbb..7733e1993eb 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_d_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_d_d.cc index 31981cae461..117a0cdb8c1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_d_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_d_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_2.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_2.cc index d51ab5ff715..a620bb70dba 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_2.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_2.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_3.cc index 4b17fbdecde..2978630832c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_4.cc index 7b5fe0f35a7..bcd03b02e3a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_d.cc index c31fed395a8..6b541ecf0d9 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_d_d_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_d_d_d.cc index a3308ede789..85111e722c4 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_d_d_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_d_d_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_2.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_2.cc index db2a4dc6b44..ac07a3f229e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_2.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_2.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_3.cc index f53c12a4373..0ec09553f9e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_4.cc index 9e29383b00f..74a42cc4a16 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_d.cc index 541def6fc37..5ce757fda5d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_3.cc index e450263825b..2e7ae28b4ea 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_4.cc index 0618c684af8..443207070cf 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_6.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_6.cc new file mode 100644 index 00000000000..ac2f358b383 --- /dev/null +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_6.cc @@ -0,0 +1,59 @@ +// Ceres Solver - A fast non-linear least squares minimizer +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// Author: sameeragarwal@google.com (Sameer Agarwal) +// +// Template specialization of SchurEliminator. +// +// ======================================== +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +//========================================= +// +// This file is generated using generate_eliminator_specialization.py. +// Editing it manually is not recommended. + +// This include must come before any #ifndef check on Ceres compile options. +#include "ceres/internal/port.h" + +#ifndef CERES_RESTRICT_SCHUR_SPECIALIZATION + +#include "ceres/schur_eliminator_impl.h" +#include "ceres/internal/eigen.h" + +namespace ceres { +namespace internal { + +template class SchurEliminator<2, 3, 6>; + +} // namespace internal +} // namespace ceres + +#endif // CERES_RESTRICT_SCHUR_SPECIALIZATION diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_9.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_9.cc index c1ca665d45f..930ab440fa5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_9.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_9.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_d.cc index 1b6092c75a9..486c53d36f4 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_3.cc index edce8ef717b..6f247a7b832 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_4.cc index a6f3c52d7f2..c44cd045263 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_8.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_8.cc index bf2f0abb1cf..c9a0d5fc729 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_8.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_8.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_9.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_9.cc index a63d0bbe0a6..b0455b0bca0 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_9.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_9.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_d.cc index b3a7fffb33e..3234380f23c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_d_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_d_d.cc index f4d28cd1642..311f8556932 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_d_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_d_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_2.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_2.cc index d1eadc1fc83..bc40bd55296 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_2.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_2.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_3.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_3.cc index c340dbfc754..cca88c802b0 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_3.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_3.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_4.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_4.cc index b7d58ad026f..33c94a907b9 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_4.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_4.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_d.cc index 47e00592b4e..1a1866f93a8 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_d_d_d.cc b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_d_d_d.cc index d54a03cadd4..6b18ef8c863 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_d_d_d.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_d_d_d.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.cc b/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.cc index 3272848a499..580fd260e15 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -51,6 +51,12 @@ namespace ceres { namespace internal { + +using std::abs; +using std::max; +using std::string; +using std::vector; + namespace { // True if x and y have an absolute relative difference less than @@ -67,20 +73,20 @@ bool IsClose(double x, double y, double relative_precision, if (!relative_error) { relative_error = &local_relative_error; } - *absolute_error = fabs(x - y); - *relative_error = *absolute_error / max(fabs(x), fabs(y)); + *absolute_error = abs(x - y); + *relative_error = *absolute_error / max(abs(x), abs(y)); if (x == 0 || y == 0) { // If x or y is exactly zero, then relative difference doesn't have any // meaning. Take the absolute difference instead. *relative_error = *absolute_error; } - return fabs(*relative_error) < fabs(relative_precision); + return abs(*relative_error) < abs(relative_precision); } class GradientCheckingCostFunction : public CostFunction { public: GradientCheckingCostFunction(const CostFunction* function, - double relative_step_size, + const NumericDiffOptions& options, double relative_precision, const string& extra_info) : function_(function), @@ -91,7 +97,7 @@ class GradientCheckingCostFunction : public CostFunction { new DynamicNumericDiffCostFunction<CostFunction, CENTRAL>( function, DO_NOT_TAKE_OWNERSHIP, - relative_step_size); + options); const vector<int32>& parameter_block_sizes = function->parameter_block_sizes(); @@ -181,8 +187,7 @@ class GradientCheckingCostFunction : public CostFunction { relative_precision_, &relative_error, &absolute_error); - worst_relative_error = std::max(worst_relative_error, - relative_error); + worst_relative_error = max(worst_relative_error, relative_error); StringAppendF(&m, "%6d %4d %4d %17g %17g %17g %17g %17g %17g", k, i, j, @@ -230,8 +235,11 @@ CostFunction *CreateGradientCheckingCostFunction( double relative_step_size, double relative_precision, const string& extra_info) { + NumericDiffOptions numeric_diff_options; + numeric_diff_options.relative_step_size = relative_step_size; + return new GradientCheckingCostFunction(cost_function, - relative_step_size, + numeric_diff_options, relative_precision, extra_info); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.h b/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.h index d49c8e6c244..cf92cb72bc5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.h +++ b/extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -61,7 +61,7 @@ CostFunction* CreateGradientCheckingCostFunction( const CostFunction* cost_function, double relative_step_size, double relative_precision, - const string& extra_info); + const std::string& extra_info); // Create a new ProblemImpl object from the input problem_impl, where // each CostFunctions in problem_impl are wrapped inside a diff --git a/extern/libmv/third_party/ceres/internal/ceres/gradient_problem.cc b/extern/libmv/third_party/ceres/internal/ceres/gradient_problem.cc index 8f9a842bd89..4ebd3e60610 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/gradient_problem.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/gradient_problem.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_evaluator.h b/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_evaluator.h index 20053de2af6..2c562544768 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_evaluator.h +++ b/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_evaluator.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -79,11 +79,11 @@ class GradientProblemEvaluator : public Evaluator { virtual int NumResiduals() const { return 1; } - virtual map<string, int> CallStatistics() const { + virtual std::map<std::string, int> CallStatistics() const { return execution_summary_.calls(); } - virtual map<string, double> TimeStatistics() const { + virtual std::map<std::string, double> TimeStatistics() const { return execution_summary_.times(); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_solver.cc index 4024f4cc4e6..9a549c23dac 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/gradient_problem_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -46,6 +46,7 @@ namespace ceres { using internal::StringPrintf; using internal::StringAppendF; +using std::string; namespace { @@ -138,6 +139,7 @@ void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options, solver_summary.fixed_cost = 0.0; solver_summary.preprocessor_time_in_seconds = 0.0; solver_summary.postprocessor_time_in_seconds = 0.0; + solver_summary.line_search_polynomial_minimization_time_in_seconds = 0.0; minimizer->Minimize(minimizer_options, solution.data(), &solver_summary); @@ -146,13 +148,15 @@ void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options, summary->initial_cost = solver_summary.initial_cost; summary->final_cost = solver_summary.final_cost; summary->iterations = solver_summary.iterations; + summary->line_search_polynomial_minimization_time_in_seconds = + solver_summary.line_search_polynomial_minimization_time_in_seconds; if (summary->IsSolutionUsable()) { parameters = solution; SetSummaryFinalCost(summary); } - const map<string, double>& evaluator_time_statistics = + const std::map<string, double>& evaluator_time_statistics = minimizer_options.evaluator->TimeStatistics(); summary->cost_evaluation_time_in_seconds = FindWithDefault(evaluator_time_statistics, "Evaluator::Residual", 0.0); @@ -172,6 +176,7 @@ GradientProblemSolver::Summary::Summary() total_time_in_seconds(-1.0), cost_evaluation_time_in_seconds(-1.0), gradient_evaluation_time_in_seconds(-1.0), + line_search_polynomial_minimization_time_in_seconds(-1.0), num_parameters(-1), num_local_parameters(-1), line_search_direction_type(LBFGS), @@ -195,7 +200,7 @@ string GradientProblemSolver::Summary::BriefReport() const { initial_cost, final_cost, TerminationTypeToString(termination_type)); -}; +} string GradientProblemSolver::Summary::FullReport() const { using internal::VersionString; @@ -246,18 +251,20 @@ string GradientProblemSolver::Summary::FullReport() const { StringAppendF(&report, "\nTime (in seconds):\n"); - StringAppendF(&report, "\n Cost evaluation %23.3f\n", + StringAppendF(&report, "\n Cost evaluation %23.4f\n", cost_evaluation_time_in_seconds); - StringAppendF(&report, " Gradient evaluation %23.3f\n", + StringAppendF(&report, " Gradient evaluation %23.4f\n", gradient_evaluation_time_in_seconds); + StringAppendF(&report, " Polynomial minimization %17.4f\n", + line_search_polynomial_minimization_time_in_seconds); - StringAppendF(&report, "Total %25.3f\n\n", + StringAppendF(&report, "Total %25.4f\n\n", total_time_in_seconds); StringAppendF(&report, "Termination: %25s (%s)\n", TerminationTypeToString(termination_type), message.c_str()); return report; -}; +} void Solve(const GradientProblemSolver::Options& options, const GradientProblem& problem, diff --git a/extern/libmv/third_party/ceres/internal/ceres/graph.h b/extern/libmv/third_party/ceres/internal/ceres/graph.h index f639d15323d..b96b67265cb 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/graph.h +++ b/extern/libmv/third_party/ceres/internal/ceres/graph.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -139,9 +139,9 @@ class WeightedGraph { for (typename HashSet<Vertex>::const_iterator it = sinks.begin(); it != sinks.end(); ++it) { if (vertex < *it) { - edge_weights_.erase(make_pair(vertex, *it)); + edge_weights_.erase(std::make_pair(vertex, *it)); } else { - edge_weights_.erase(make_pair(*it, vertex)); + edge_weights_.erase(std::make_pair(*it, vertex)); } edges_[*it].erase(vertex); } @@ -165,9 +165,9 @@ class WeightedGraph { } if (vertex1 < vertex2) { - edge_weights_[make_pair(vertex1, vertex2)] = weight; + edge_weights_[std::make_pair(vertex1, vertex2)] = weight; } else { - edge_weights_[make_pair(vertex2, vertex1)] = weight; + edge_weights_[std::make_pair(vertex2, vertex1)] = weight; } } @@ -188,9 +188,11 @@ class WeightedGraph { // the edge weight is zero. double EdgeWeight(const Vertex& vertex1, const Vertex& vertex2) const { if (vertex1 < vertex2) { - return FindWithDefault(edge_weights_, make_pair(vertex1, vertex2), 0.0); + return FindWithDefault(edge_weights_, + std::make_pair(vertex1, vertex2), 0.0); } else { - return FindWithDefault(edge_weights_, make_pair(vertex2, vertex1), 0.0); + return FindWithDefault(edge_weights_, + std::make_pair(vertex2, vertex1), 0.0); } } @@ -206,13 +208,13 @@ class WeightedGraph { static double InvalidWeight() { return std::numeric_limits<double>::quiet_NaN(); - }; + } private: HashSet<Vertex> vertices_; HashMap<Vertex, double> vertex_weights_; HashMap<Vertex, HashSet<Vertex> > edges_; - HashMap<pair<Vertex, Vertex>, double> edge_weights_; + HashMap<std::pair<Vertex, Vertex>, double> edge_weights_; CERES_DISALLOW_COPY_AND_ASSIGN(WeightedGraph); }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/graph_algorithms.h b/extern/libmv/third_party/ceres/internal/ceres/graph_algorithms.h index fb75e2f45f2..d1d3f52cd22 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/graph_algorithms.h +++ b/extern/libmv/third_party/ceres/internal/ceres/graph_algorithms.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -95,7 +95,7 @@ class VertexDegreeLessThan { // cardinality of S. template <typename Vertex> int IndependentSetOrdering(const Graph<Vertex>& graph, - vector<Vertex>* ordering) { + std::vector<Vertex>* ordering) { const HashSet<Vertex>& vertices = graph.vertices(); const int num_vertices = vertices.size(); @@ -110,7 +110,7 @@ int IndependentSetOrdering(const Graph<Vertex>& graph, // Mark all vertices white. HashMap<Vertex, char> vertex_color; - vector<Vertex> vertex_queue; + std::vector<Vertex> vertex_queue; for (typename HashSet<Vertex>::const_iterator it = vertices.begin(); it != vertices.end(); ++it) { @@ -119,8 +119,8 @@ int IndependentSetOrdering(const Graph<Vertex>& graph, } - sort(vertex_queue.begin(), vertex_queue.end(), - VertexTotalOrdering<Vertex>(graph)); + std::sort(vertex_queue.begin(), vertex_queue.end(), + VertexTotalOrdering<Vertex>(graph)); // Iterate over vertex_queue. Pick the first white vertex, add it // to the independent set. Mark it black and its neighbors grey. @@ -145,7 +145,7 @@ int IndependentSetOrdering(const Graph<Vertex>& graph, // Iterate over the vertices and add all the grey vertices to the // ordering. At this stage there should only be black or grey // vertices in the graph. - for (typename vector<Vertex>::const_iterator it = vertex_queue.begin(); + for (typename std::vector<Vertex>::const_iterator it = vertex_queue.begin(); it != vertex_queue.end(); ++it) { const Vertex vertex = *it; @@ -171,7 +171,7 @@ int IndependentSetOrdering(const Graph<Vertex>& graph, // ordering algorithm over all. template <typename Vertex> int StableIndependentSetOrdering(const Graph<Vertex>& graph, - vector<Vertex>* ordering) { + std::vector<Vertex>* ordering) { CHECK_NOTNULL(ordering); const HashSet<Vertex>& vertices = graph.vertices(); const int num_vertices = vertices.size(); @@ -182,10 +182,10 @@ int StableIndependentSetOrdering(const Graph<Vertex>& graph, const char kGrey = 1; const char kBlack = 2; - vector<Vertex> vertex_queue(*ordering); + std::vector<Vertex> vertex_queue(*ordering); - stable_sort(vertex_queue.begin(), vertex_queue.end(), - VertexDegreeLessThan<Vertex>(graph)); + std::stable_sort(vertex_queue.begin(), vertex_queue.end(), + VertexDegreeLessThan<Vertex>(graph)); // Mark all vertices white. HashMap<Vertex, char> vertex_color; @@ -220,7 +220,7 @@ int StableIndependentSetOrdering(const Graph<Vertex>& graph, // Iterate over the vertices and add all the grey vertices to the // ordering. At this stage there should only be black or grey // vertices in the graph. - for (typename vector<Vertex>::const_iterator it = vertex_queue.begin(); + for (typename std::vector<Vertex>::const_iterator it = vertex_queue.begin(); it != vertex_queue.end(); ++it) { const Vertex vertex = *it; @@ -274,7 +274,7 @@ template <typename Vertex> WeightedGraph<Vertex>* Degree2MaximumSpanningForest(const WeightedGraph<Vertex>& graph) { // Array of edges sorted in decreasing order of their weights. - vector<pair<double, pair<Vertex, Vertex> > > weighted_edges; + std::vector<std::pair<double, std::pair<Vertex, Vertex> > > weighted_edges; WeightedGraph<Vertex>* forest = new WeightedGraph<Vertex>(); // Disjoint-set to keep track of the connected components in the @@ -302,19 +302,20 @@ Degree2MaximumSpanningForest(const WeightedGraph<Vertex>& graph) { continue; } const double weight = graph.EdgeWeight(vertex1, vertex2); - weighted_edges.push_back(make_pair(weight, make_pair(vertex1, vertex2))); + weighted_edges.push_back( + std::make_pair(weight, std::make_pair(vertex1, vertex2))); } } // The elements of this vector, are pairs<edge_weight, // edge>. Sorting it using the reverse iterators gives us the edges // in decreasing order of edges. - sort(weighted_edges.rbegin(), weighted_edges.rend()); + std::sort(weighted_edges.rbegin(), weighted_edges.rend()); // Greedily add edges to the spanning tree/forest as long as they do // not violate the degree/cycle constraint. for (int i =0; i < weighted_edges.size(); ++i) { - const pair<Vertex, Vertex>& edge = weighted_edges[i].second; + const std::pair<Vertex, Vertex>& edge = weighted_edges[i].second; const Vertex vertex1 = edge.first; const Vertex vertex2 = edge.second; @@ -350,7 +351,7 @@ Degree2MaximumSpanningForest(const WeightedGraph<Vertex>& graph) { // lookup. if (root2 < root1) { std::swap(root1, root2); - }; + } disjoint_set[root2] = root1; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/householder_vector.h b/extern/libmv/third_party/ceres/internal/ceres/householder_vector.h new file mode 100644 index 00000000000..f54feea054d --- /dev/null +++ b/extern/libmv/third_party/ceres/internal/ceres/householder_vector.h @@ -0,0 +1,85 @@ +// Ceres Solver - A fast non-linear least squares minimizer +// Copyright 2015 Google Inc. All rights reserved. +// http://code.google.com/p/ceres-solver/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Google Inc. nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// Author: vitus@google.com (Michael Vitus) + +#ifndef CERES_PUBLIC_HOUSEHOLDER_VECTOR_H_ +#define CERES_PUBLIC_HOUSEHOLDER_VECTOR_H_ + +#include "Eigen/Core" +#include "glog/logging.h" + +namespace ceres { +namespace internal { + +// Algorithm 5.1.1 from 'Matrix Computations' by Golub et al. (Johns Hopkins +// Studies in Mathematical Sciences) but using the nth element of the input +// vector as pivot instead of first. This computes the vector v with v(n) = 1 +// and beta such that H = I - beta * v * v^T is orthogonal and +// H * x = ||x||_2 * e_n. +template <typename Scalar> +void ComputeHouseholderVector(const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>& x, + Eigen::Matrix<Scalar, Eigen::Dynamic, 1>* v, + Scalar* beta) { + CHECK_NOTNULL(beta); + CHECK_NOTNULL(v); + CHECK_GT(x.rows(), 1); + CHECK_EQ(x.rows(), v->rows()); + + Scalar sigma = x.head(x.rows() - 1).squaredNorm(); + *v = x; + (*v)(v->rows() - 1) = Scalar(1.0); + + *beta = Scalar(0.0); + const Scalar& x_pivot = x(x.rows() - 1); + + if (sigma <= Scalar(std::numeric_limits<double>::epsilon())) { + if (x_pivot < Scalar(0.0)) { + *beta = Scalar(2.0); + } + return; + } + + const Scalar mu = sqrt(x_pivot * x_pivot + sigma); + Scalar v_pivot = Scalar(1.0); + + if (x_pivot <= Scalar(0.0)) { + v_pivot = x_pivot - mu; + } else { + v_pivot = -sigma / (x_pivot + mu); + } + + *beta = Scalar(2.0) * v_pivot * v_pivot / (sigma + v_pivot * v_pivot); + + v->head(v->rows() - 1) /= v_pivot; +} + +} // namespace internal +} // namespace ceres + +#endif // CERES_PUBLIC_HOUSEHOLDER_VECTOR_H_ diff --git a/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.cc b/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.cc index 2da6235f513..d05f03817b7 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.h b/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.h index c992bdc206e..5d822ebaeef 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.h +++ b/extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -97,7 +97,7 @@ class ImplicitSchurComplement : public LinearOperator { // // TODO(sameeragarwal): Get rid of the two bools below and replace // them with enums. - ImplicitSchurComplement(const LinearSolver::Options& options); + explicit ImplicitSchurComplement(const LinearSolver::Options& options); virtual ~ImplicitSchurComplement(); // Initialize the Schur complement for a linear least squares diff --git a/extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.cc b/extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.cc deleted file mode 100644 index 6ba38ec8eec..00000000000 --- a/extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.cc +++ /dev/null @@ -1,239 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// * Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// * Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. -// -// Author: sameeragarwal@google.com (Sameer Agarwal) - -#include "ceres/incomplete_lq_factorization.h" - -#include <vector> -#include <utility> -#include <cmath> -#include "ceres/compressed_row_sparse_matrix.h" -#include "ceres/internal/eigen.h" -#include "ceres/internal/port.h" -#include "glog/logging.h" - -namespace ceres { -namespace internal { - -// Normalize a row and return it's norm. -inline double NormalizeRow(const int row, CompressedRowSparseMatrix* matrix) { - const int row_begin = matrix->rows()[row]; - const int row_end = matrix->rows()[row + 1]; - - double* values = matrix->mutable_values(); - double norm = 0.0; - for (int i = row_begin; i < row_end; ++i) { - norm += values[i] * values[i]; - } - - norm = sqrt(norm); - const double inverse_norm = 1.0 / norm; - for (int i = row_begin; i < row_end; ++i) { - values[i] *= inverse_norm; - } - - return norm; -} - -// Compute a(row_a,:) * b(row_b, :)' -inline double RowDotProduct(const CompressedRowSparseMatrix& a, - const int row_a, - const CompressedRowSparseMatrix& b, - const int row_b) { - const int* a_rows = a.rows(); - const int* a_cols = a.cols(); - const double* a_values = a.values(); - - const int* b_rows = b.rows(); - const int* b_cols = b.cols(); - const double* b_values = b.values(); - - const int row_a_end = a_rows[row_a + 1]; - const int row_b_end = b_rows[row_b + 1]; - - int idx_a = a_rows[row_a]; - int idx_b = b_rows[row_b]; - double dot_product = 0.0; - while (idx_a < row_a_end && idx_b < row_b_end) { - if (a_cols[idx_a] == b_cols[idx_b]) { - dot_product += a_values[idx_a++] * b_values[idx_b++]; - } - - while (a_cols[idx_a] < b_cols[idx_b] && idx_a < row_a_end) { - ++idx_a; - } - - while (a_cols[idx_a] > b_cols[idx_b] && idx_b < row_b_end) { - ++idx_b; - } - } - - return dot_product; -} - -struct SecondGreaterThan { - public: - bool operator()(const pair<int, double>& lhs, - const pair<int, double>& rhs) const { - return (fabs(lhs.second) > fabs(rhs.second)); - } -}; - -// In the row vector dense_row(0:num_cols), drop values smaller than -// the max_value * drop_tolerance. Of the remaining non-zero values, -// choose at most level_of_fill values and then add the resulting row -// vector to matrix. - -void DropEntriesAndAddRow(const Vector& dense_row, - const int num_entries, - const int level_of_fill, - const double drop_tolerance, - vector<pair<int, double> >* scratch, - CompressedRowSparseMatrix* matrix) { - int* rows = matrix->mutable_rows(); - int* cols = matrix->mutable_cols(); - double* values = matrix->mutable_values(); - int num_nonzeros = rows[matrix->num_rows()]; - - if (num_entries == 0) { - matrix->set_num_rows(matrix->num_rows() + 1); - rows[matrix->num_rows()] = num_nonzeros; - return; - } - - const double max_value = dense_row.head(num_entries).cwiseAbs().maxCoeff(); - const double threshold = drop_tolerance * max_value; - - int scratch_count = 0; - for (int i = 0; i < num_entries; ++i) { - if (fabs(dense_row[i]) > threshold) { - pair<int, double>& entry = (*scratch)[scratch_count]; - entry.first = i; - entry.second = dense_row[i]; - ++scratch_count; - } - } - - if (scratch_count > level_of_fill) { - nth_element(scratch->begin(), - scratch->begin() + level_of_fill, - scratch->begin() + scratch_count, - SecondGreaterThan()); - scratch_count = level_of_fill; - sort(scratch->begin(), scratch->begin() + scratch_count); - } - - for (int i = 0; i < scratch_count; ++i) { - const pair<int, double>& entry = (*scratch)[i]; - cols[num_nonzeros] = entry.first; - values[num_nonzeros] = entry.second; - ++num_nonzeros; - } - - matrix->set_num_rows(matrix->num_rows() + 1); - rows[matrix->num_rows()] = num_nonzeros; -} - -// Saad's Incomplete LQ factorization algorithm. -CompressedRowSparseMatrix* IncompleteLQFactorization( - const CompressedRowSparseMatrix& matrix, - const int l_level_of_fill, - const double l_drop_tolerance, - const int q_level_of_fill, - const double q_drop_tolerance) { - const int num_rows = matrix.num_rows(); - const int num_cols = matrix.num_cols(); - const int* rows = matrix.rows(); - const int* cols = matrix.cols(); - const double* values = matrix.values(); - - CompressedRowSparseMatrix* l = - new CompressedRowSparseMatrix(num_rows, - num_rows, - l_level_of_fill * num_rows); - l->set_num_rows(0); - - CompressedRowSparseMatrix q(num_rows, num_cols, q_level_of_fill * num_rows); - q.set_num_rows(0); - - int* l_rows = l->mutable_rows(); - int* l_cols = l->mutable_cols(); - double* l_values = l->mutable_values(); - - int* q_rows = q.mutable_rows(); - int* q_cols = q.mutable_cols(); - double* q_values = q.mutable_values(); - - Vector l_i(num_rows); - Vector q_i(num_cols); - vector<pair<int, double> > scratch(num_cols); - for (int i = 0; i < num_rows; ++i) { - // l_i = q * matrix(i,:)'); - l_i.setZero(); - for (int j = 0; j < i; ++j) { - l_i(j) = RowDotProduct(matrix, i, q, j); - } - DropEntriesAndAddRow(l_i, - i, - l_level_of_fill, - l_drop_tolerance, - &scratch, - l); - - // q_i = matrix(i,:) - q(0:i-1,:) * l_i); - q_i.setZero(); - for (int idx = rows[i]; idx < rows[i + 1]; ++idx) { - q_i(cols[idx]) = values[idx]; - } - - for (int j = l_rows[i]; j < l_rows[i + 1]; ++j) { - const int r = l_cols[j]; - const double lij = l_values[j]; - for (int idx = q_rows[r]; idx < q_rows[r + 1]; ++idx) { - q_i(q_cols[idx]) -= lij * q_values[idx]; - } - } - DropEntriesAndAddRow(q_i, - num_cols, - q_level_of_fill, - q_drop_tolerance, - &scratch, - &q); - - // lii = |qi| - l_cols[l->num_nonzeros()] = i; - l_values[l->num_nonzeros()] = NormalizeRow(i, &q); - l_rows[l->num_rows()] += 1; - } - - return l; -} - -} // namespace internal -} // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.h b/extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.h deleted file mode 100644 index e678463cf8d..00000000000 --- a/extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.h +++ /dev/null @@ -1,90 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// * Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// * Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. -// -// Author: sameeragarwal@google.com (Sameer Agarwal) - -#ifndef CERES_INTERNAL_INCOMPLETE_LQ_FACTORIZATION_H_ -#define CERES_INTERNAL_INCOMPLETE_LQ_FACTORIZATION_H_ - -#include <vector> -#include <utility> -#include "ceres/compressed_row_sparse_matrix.h" - -namespace ceres { -namespace internal { - -// Incomplete LQ factorization as described in -// -// Preconditioning techniques for indefinite and nonsymmetric linear -// systems. Yousef Saad, Preprint RIACS-ILQ-TR, RIACS, NASA Ames -// Research Center, Moffett Field, CA, 1987. -// -// An incomplete LQ factorization of a matrix A is a decomposition -// -// A = LQ + E -// -// Where L is a lower triangular matrix, and Q is a near orthonormal -// matrix. The extent of orthonormality depends on E. E is the "drop" -// matrix. Each row of L has a maximum of l_level_of_fill entries, and -// all non-zero entries are within l_drop_tolerance of the largest -// entry. Each row of Q has a maximum of q_level_of_fill entries and -// all non-zero entries are within q_drop_tolerance of the largest -// entry. -// -// E is the error of the incomplete factorization. -// -// The purpose of incomplete factorizations is preconditioning and -// there one only needs the L matrix, therefore this function just -// returns L. -// -// Caller owns the result. -CompressedRowSparseMatrix* IncompleteLQFactorization( - const CompressedRowSparseMatrix& matrix, - const int l_level_of_fill, - const double l_drop_tolerance, - const int q_level_of_fill, - const double q_drop_tolerance); - -// In the row vector dense_row(0:num_cols), drop values smaller than -// the max_value * drop_tolerance. Of the remaining non-zero values, -// choose at most level_of_fill values and then add the resulting row -// vector to matrix. -// -// scratch is used to prevent allocations inside this function. It is -// assumed that scratch is of size matrix->num_cols(). -void DropEntriesAndAddRow(const Vector& dense_row, - const int num_entries, - const int level_of_fill, - const double drop_tolerance, - vector<pair<int, double> >* scratch, - CompressedRowSparseMatrix* matrix); - -} // namespace internal -} // namespace ceres - -#endif // CERES_INTERNAL_INCOMPLETE_LQ_FACTORIZATION_H_ diff --git a/extern/libmv/third_party/ceres/internal/ceres/integral_types.h b/extern/libmv/third_party/ceres/internal/ceres/integral_types.h index d4913f53745..98a746f13ff 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/integral_types.h +++ b/extern/libmv/third_party/ceres/internal/ceres/integral_types.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.cc index 0cf08fef5f7..9d4e30d69d2 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.h b/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.h index b056a694478..e90d310de07 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/lapack.cc b/extern/libmv/third_party/ceres/internal/ceres/lapack.cc index e124d757024..6fc23f4e658 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/lapack.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/lapack.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -70,7 +70,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingCholesky( int num_rows, const double* in_lhs, double* rhs_and_solution, - string* message) { + std::string* message) { #ifdef CERES_NO_LAPACK LOG(FATAL) << "Ceres was built without a BLAS library."; return LINEAR_SOLVER_FATAL_ERROR; @@ -110,7 +110,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingCholesky( *message = "Success"; return LINEAR_SOLVER_SUCCESS; #endif -}; +} int LAPACK::EstimateWorkSizeForQR(int num_rows, int num_cols) { #ifdef CERES_NO_LAPACK @@ -151,7 +151,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingQR( int work_size, double* work, double* rhs_and_solution, - string* message) { + std::string* message) { #ifdef CERES_NO_LAPACK LOG(FATAL) << "Ceres was built without a LAPACK library."; return LINEAR_SOLVER_FATAL_ERROR; diff --git a/extern/libmv/third_party/ceres/internal/ceres/lapack.h b/extern/libmv/third_party/ceres/internal/ceres/lapack.h index 8933c2c8d83..5bb1a220c26 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/lapack.h +++ b/extern/libmv/third_party/ceres/internal/ceres/lapack.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -58,7 +58,7 @@ class LAPACK { int num_rows, const double* lhs, double* rhs_and_solution, - string* message); + std::string* message); // The SolveUsingQR function requires a buffer for its temporary // computation. This function given the size of the lhs matrix will @@ -91,7 +91,7 @@ class LAPACK { int work_size, double* work, double* rhs_and_solution, - string* message); + std::string* message); }; } // namespace internal diff --git a/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.cc b/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.cc index ce3b69a8005..e9833805ef5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -79,7 +79,8 @@ TrustRegionStrategy::Summary LevenbergMarquardtStrategy::ComputeStep( jacobian->SquaredColumnNorm(diagonal_.data()); for (int i = 0; i < num_parameters; ++i) { - diagonal_[i] = min(max(diagonal_[i], min_diagonal_), max_diagonal_); + diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_), + max_diagonal_); } } @@ -107,9 +108,12 @@ TrustRegionStrategy::Summary LevenbergMarquardtStrategy::ComputeStep( linear_solver_->Solve(jacobian, residuals, solve_options, step); if (linear_solver_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) { - LOG(WARNING) << "Linear solver fatal error."; - } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE || - !IsArrayValid(num_parameters, step)) { + LOG(WARNING) << "Linear solver fatal error: " + << linear_solver_summary.message; + } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE) { + LOG(WARNING) << "Linear solver failure. Failed to compute a step: " + << linear_solver_summary.message; + } else if (!IsArrayValid(num_parameters, step)) { LOG(WARNING) << "Linear solver failure. Failed to compute a finite step."; linear_solver_summary.termination_type = LINEAR_SOLVER_FAILURE; } else { diff --git a/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.h b/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.h index 344e3285422..c87a016c8f4 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.h +++ b/extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search.cc b/extern/libmv/third_party/ceres/internal/ceres/line_search.cc index 7ff11646dd3..9cdcb7b77e5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -28,20 +28,28 @@ // // Author: sameeragarwal@google.com (Sameer Agarwal) +#include "ceres/line_search.h" + #include <iomanip> #include <iostream> // NOLINT -#include "ceres/line_search.h" - -#include "ceres/fpclassify.h" +#include "glog/logging.h" #include "ceres/evaluator.h" #include "ceres/internal/eigen.h" +#include "ceres/fpclassify.h" +#include "ceres/map_util.h" #include "ceres/polynomial.h" #include "ceres/stringprintf.h" -#include "glog/logging.h" +#include "ceres/wall_time.h" namespace ceres { namespace internal { + +using std::map; +using std::ostream; +using std::string; +using std::vector; + namespace { // Precision used for floating point values in error message output. const int kErrorMessageNumericPrecision = 8; @@ -52,7 +60,7 @@ FunctionSample ValueSample(const double x, const double value) { sample.value = value; sample.value_is_valid = true; return sample; -}; +} FunctionSample ValueAndGradientSample(const double x, const double value, @@ -64,15 +72,15 @@ FunctionSample ValueAndGradientSample(const double x, sample.value_is_valid = true; sample.gradient_is_valid = true; return sample; -}; +} } // namespace -std::ostream& operator<<(std::ostream &os, const FunctionSample& sample); +ostream& operator<<(ostream &os, const FunctionSample& sample); // Convenience stream operator for pushing FunctionSamples into log messages. -std::ostream& operator<<(std::ostream &os, const FunctionSample& sample) { +ostream& operator<<(ostream &os, const FunctionSample& sample) { os << sample.ToDebugString(); return os; } @@ -106,8 +114,9 @@ LineSearchFunction::LineSearchFunction(Evaluator* evaluator) direction_(evaluator->NumEffectiveParameters()), evaluation_point_(evaluator->NumParameters()), scaled_direction_(evaluator->NumEffectiveParameters()), - gradient_(evaluator->NumEffectiveParameters()) { -} + gradient_(evaluator->NumEffectiveParameters()), + initial_evaluator_residual_time_in_seconds(0.0), + initial_evaluator_jacobian_time_in_seconds(0.0) {} void LineSearchFunction::Init(const Vector& position, const Vector& direction) { @@ -125,14 +134,12 @@ bool LineSearchFunction::Evaluate(double x, double* f, double* g) { if (g == NULL) { return (evaluator_->Evaluate(evaluation_point_.data(), - f, NULL, NULL, NULL) && + f, NULL, NULL, NULL) && IsFinite(*f)); } if (!evaluator_->Evaluate(evaluation_point_.data(), - f, - NULL, - gradient_.data(), NULL)) { + f, NULL, gradient_.data(), NULL)) { return false; } @@ -144,6 +151,54 @@ double LineSearchFunction::DirectionInfinityNorm() const { return direction_.lpNorm<Eigen::Infinity>(); } +void LineSearchFunction::ResetTimeStatistics() { + const map<string, double> evaluator_time_statistics = + evaluator_->TimeStatistics(); + initial_evaluator_residual_time_in_seconds = + FindWithDefault(evaluator_time_statistics, "Evaluator::Residual", 0.0); + initial_evaluator_jacobian_time_in_seconds = + FindWithDefault(evaluator_time_statistics, "Evaluator::Jacobian", 0.0); +} + +void LineSearchFunction::TimeStatistics( + double* cost_evaluation_time_in_seconds, + double* gradient_evaluation_time_in_seconds) const { + const map<string, double> evaluator_time_statistics = + evaluator_->TimeStatistics(); + *cost_evaluation_time_in_seconds = + FindWithDefault(evaluator_time_statistics, "Evaluator::Residual", 0.0) - + initial_evaluator_residual_time_in_seconds; + // Strictly speaking this will slightly underestimate the time spent + // evaluating the gradient of the line search univariate cost function as it + // does not count the time spent performing the dot product with the direction + // vector. However, this will typically be small by comparison, and also + // allows direct subtraction of the timing information from the totals for + // the evaluator returned in the solver summary. + *gradient_evaluation_time_in_seconds = + FindWithDefault(evaluator_time_statistics, "Evaluator::Jacobian", 0.0) - + initial_evaluator_jacobian_time_in_seconds; +} + +void LineSearch::Search(double step_size_estimate, + double initial_cost, + double initial_gradient, + Summary* summary) const { + const double start_time = WallTimeInSeconds(); + *CHECK_NOTNULL(summary) = LineSearch::Summary(); + + summary->cost_evaluation_time_in_seconds = 0.0; + summary->gradient_evaluation_time_in_seconds = 0.0; + summary->polynomial_minimization_time_in_seconds = 0.0; + + options().function->ResetTimeStatistics(); + this->DoSearch(step_size_estimate, initial_cost, initial_gradient, summary); + options().function-> + TimeStatistics(&summary->cost_evaluation_time_in_seconds, + &summary->gradient_evaluation_time_in_seconds); + + summary->total_time_in_seconds = WallTimeInSeconds() - start_time; +} + // Returns step_size \in [min_step_size, max_step_size] which minimizes the // polynomial of degree defined by interpolation_type which interpolates all // of the provided samples with valid values. @@ -159,7 +214,7 @@ double LineSearch::InterpolatingPolynomialMinimizingStepSize( max_step_size <= current.x)) { // Either: sample is invalid; or we are using BISECTION and contracting // the step size. - return min(max(current.x * 0.5, min_step_size), max_step_size); + return std::min(std::max(current.x * 0.5, min_step_size), max_step_size); } else if (interpolation_type == BISECTION) { CHECK_GT(max_step_size, current.x); // We are expanding the search (during a Wolfe bracketing phase) using @@ -219,16 +274,15 @@ double LineSearch::InterpolatingPolynomialMinimizingStepSize( ArmijoLineSearch::ArmijoLineSearch(const LineSearch::Options& options) : LineSearch(options) {} -void ArmijoLineSearch::Search(const double step_size_estimate, - const double initial_cost, - const double initial_gradient, - Summary* summary) { - *CHECK_NOTNULL(summary) = LineSearch::Summary(); +void ArmijoLineSearch::DoSearch(const double step_size_estimate, + const double initial_cost, + const double initial_gradient, + Summary* summary) const { CHECK_GE(step_size_estimate, 0.0); CHECK_GT(options().sufficient_decrease, 0.0); CHECK_LT(options().sufficient_decrease, 1.0); CHECK_GT(options().max_num_iterations, 0); - Function* function = options().function; + LineSearchFunction* function = options().function; // Note initial_cost & initial_gradient are evaluated at step_size = 0, // not step_size_estimate, which is our starting guess. @@ -247,8 +301,7 @@ void ArmijoLineSearch::Search(const double step_size_estimate, // gradient at the current query point. const bool interpolation_uses_gradient_at_current_sample = options().interpolation_type == CUBIC; - const double descent_direction_max_norm = - static_cast<const LineSearchFunction*>(function)->DirectionInfinityNorm(); + const double descent_direction_max_norm = function->DirectionInfinityNorm(); ++summary->num_function_evaluations; if (interpolation_uses_gradient_at_current_sample) { @@ -279,6 +332,7 @@ void ArmijoLineSearch::Search(const double step_size_estimate, return; } + const double polynomial_minimization_start_time = WallTimeInSeconds(); const double step_size = this->InterpolatingPolynomialMinimizingStepSize( options().interpolation_type, @@ -287,6 +341,8 @@ void ArmijoLineSearch::Search(const double step_size_estimate, current, (options().max_step_contraction * current.x), (options().min_step_contraction * current.x)); + summary->polynomial_minimization_time_in_seconds += + (WallTimeInSeconds() - polynomial_minimization_start_time); if (step_size * descent_direction_max_norm < options().min_step_size) { summary->error = @@ -320,11 +376,10 @@ void ArmijoLineSearch::Search(const double step_size_estimate, WolfeLineSearch::WolfeLineSearch(const LineSearch::Options& options) : LineSearch(options) {} -void WolfeLineSearch::Search(const double step_size_estimate, - const double initial_cost, - const double initial_gradient, - Summary* summary) { - *CHECK_NOTNULL(summary) = LineSearch::Summary(); +void WolfeLineSearch::DoSearch(const double step_size_estimate, + const double initial_cost, + const double initial_gradient, + Summary* summary) const { // All parameters should have been validated by the Solver, but as // invalid values would produce crazy nonsense, hard check them here. CHECK_GE(step_size_estimate, 0.0); @@ -456,15 +511,15 @@ bool WolfeLineSearch::BracketingPhase( FunctionSample* bracket_low, FunctionSample* bracket_high, bool* do_zoom_search, - Summary* summary) { - Function* function = options().function; + Summary* summary) const { + LineSearchFunction* function = options().function; FunctionSample previous = initial_position; FunctionSample current = ValueAndGradientSample(step_size_estimate, 0.0, 0.0); current.value_is_valid = false; const double descent_direction_max_norm = - static_cast<const LineSearchFunction*>(function)->DirectionInfinityNorm(); + function->DirectionInfinityNorm(); *do_zoom_search = false; *bracket_low = initial_position; @@ -594,6 +649,7 @@ bool WolfeLineSearch::BracketingPhase( const FunctionSample unused_previous; DCHECK(!unused_previous.value_is_valid); // Contracts step size if f(current) is not valid. + const double polynomial_minimization_start_time = WallTimeInSeconds(); const double step_size = this->InterpolatingPolynomialMinimizingStepSize( options().interpolation_type, @@ -602,6 +658,8 @@ bool WolfeLineSearch::BracketingPhase( current, previous.x, max_step_size); + summary->polynomial_minimization_time_in_seconds += + (WallTimeInSeconds() - polynomial_minimization_start_time); if (step_size * descent_direction_max_norm < options().min_step_size) { summary->error = StringPrintf("Line search failed: step_size too small: %.5e " @@ -642,8 +700,8 @@ bool WolfeLineSearch::ZoomPhase(const FunctionSample& initial_position, FunctionSample bracket_low, FunctionSample bracket_high, FunctionSample* solution, - Summary* summary) { - Function* function = options().function; + Summary* summary) const { + LineSearchFunction* function = options().function; CHECK(bracket_low.value_is_valid && bracket_low.gradient_is_valid) << std::scientific << std::setprecision(kErrorMessageNumericPrecision) @@ -697,8 +755,7 @@ bool WolfeLineSearch::ZoomPhase(const FunctionSample& initial_position, } const int num_bracketing_iterations = summary->num_iterations; - const double descent_direction_max_norm = - static_cast<const LineSearchFunction*>(function)->DirectionInfinityNorm(); + const double descent_direction_max_norm = function->DirectionInfinityNorm(); while (true) { // Set solution to bracket_low, as it is our best step size (smallest f()) @@ -741,6 +798,7 @@ bool WolfeLineSearch::ZoomPhase(const FunctionSample& initial_position, // value that will therefore be ignored. const FunctionSample unused_previous; DCHECK(!unused_previous.value_is_valid); + const double polynomial_minimization_start_time = WallTimeInSeconds(); solution->x = this->InterpolatingPolynomialMinimizingStepSize( options().interpolation_type, @@ -749,6 +807,8 @@ bool WolfeLineSearch::ZoomPhase(const FunctionSample& initial_position, upper_bound_step, lower_bound_step.x, upper_bound_step.x); + summary->polynomial_minimization_time_in_seconds += + (WallTimeInSeconds() - polynomial_minimization_start_time); // No check on magnitude of step size being too small here as it is // lower-bounded by the initial bracket start point, which was valid. // diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search.h b/extern/libmv/third_party/ceres/internal/ceres/line_search.h index 97b9bc68cfe..6a21cbeac11 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search.h +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -44,6 +44,7 @@ namespace internal { class Evaluator; struct FunctionSample; +class LineSearchFunction; // Line search is another name for a one dimensional optimization // algorithm. The name "line search" comes from the fact one @@ -57,7 +58,7 @@ struct FunctionSample; // algorithms, e.g., Armijo, Wolfe etc. class LineSearch { public: - class Function; + struct Summary; struct Options { Options() @@ -147,31 +148,7 @@ class LineSearch { // The one dimensional function that the line search algorithm // minimizes. - Function* function; - }; - - // An object used by the line search to access the function values - // and gradient of the one dimensional function being optimized. - // - // In practice, this object will provide access to the objective - // function value and the directional derivative of the underlying - // optimization problem along a specific search direction. - // - // See LineSearchFunction for an example implementation. - class Function { - public: - virtual ~Function() {} - // Evaluate the line search objective - // - // f(x) = p(position + x * direction) - // - // Where, p is the objective function of the general optimization - // problem. - // - // g is the gradient f'(x) at x. - // - // f must not be null. The gradient is computed only if g is not null. - virtual bool Evaluate(double x, double* f, double* g) = 0; + LineSearchFunction* function; }; // Result of the line search. @@ -181,14 +158,28 @@ class LineSearch { optimal_step_size(0.0), num_function_evaluations(0), num_gradient_evaluations(0), - num_iterations(0) {} + num_iterations(0), + cost_evaluation_time_in_seconds(-1.0), + gradient_evaluation_time_in_seconds(-1.0), + polynomial_minimization_time_in_seconds(-1.0), + total_time_in_seconds(-1.0) {} bool success; double optimal_step_size; int num_function_evaluations; int num_gradient_evaluations; int num_iterations; - string error; + // Cumulative time spent evaluating the value of the cost function across + // all iterations. + double cost_evaluation_time_in_seconds; + // Cumulative time spent evaluating the gradient of the cost function across + // all iterations. + double gradient_evaluation_time_in_seconds; + // Cumulative time spent minimizing the interpolating polynomial to compute + // the next candidate step size across all iterations. + double polynomial_minimization_time_in_seconds; + double total_time_in_seconds; + std::string error; }; explicit LineSearch(const LineSearch::Options& options); @@ -196,7 +187,7 @@ class LineSearch { static LineSearch* Create(const LineSearchType line_search_type, const LineSearch::Options& options, - string* error); + std::string* error); // Perform the line search. // @@ -208,10 +199,10 @@ class LineSearch { // search. // // Summary::success is true if a non-zero step size is found. - virtual void Search(double step_size_estimate, - double initial_cost, - double initial_gradient, - Summary* summary) = 0; + void Search(double step_size_estimate, + double initial_cost, + double initial_gradient, + Summary* summary) const; double InterpolatingPolynomialMinimizingStepSize( const LineSearchInterpolationType& interpolation_type, const FunctionSample& lowerbound_sample, @@ -224,16 +215,41 @@ class LineSearch { const LineSearch::Options& options() const { return options_; } private: + virtual void DoSearch(double step_size_estimate, + double initial_cost, + double initial_gradient, + Summary* summary) const = 0; + + private: LineSearch::Options options_; }; -class LineSearchFunction : public LineSearch::Function { +// An object used by the line search to access the function values +// and gradient of the one dimensional function being optimized. +// +// In practice, this object provides access to the objective +// function value and the directional derivative of the underlying +// optimization problem along a specific search direction. +class LineSearchFunction { public: explicit LineSearchFunction(Evaluator* evaluator); - virtual ~LineSearchFunction() {} void Init(const Vector& position, const Vector& direction); - virtual bool Evaluate(double x, double* f, double* g); + // Evaluate the line search objective + // + // f(x) = p(position + x * direction) + // + // Where, p is the objective function of the general optimization + // problem. + // + // g is the gradient f'(x) at x. + // + // f must not be null. The gradient is computed only if g is not null. + bool Evaluate(double x, double* f, double* g); double DirectionInfinityNorm() const; + // Resets to now, the start point for the results from TimeStatistics(). + void ResetTimeStatistics(); + void TimeStatistics(double* cost_evaluation_time_in_seconds, + double* gradient_evaluation_time_in_seconds) const; private: Evaluator* evaluator_; @@ -246,6 +262,13 @@ class LineSearchFunction : public LineSearch::Function { // scaled_direction = x * direction_; Vector scaled_direction_; Vector gradient_; + + // We may not exclusively own the evaluator (e.g. in the Trust Region + // minimizer), hence we need to save the initial evaluation durations for the + // value & gradient to accurately determine the duration of the evaluations + // we invoked. These are reset by a call to ResetTimeStatistics(). + double initial_evaluator_residual_time_in_seconds; + double initial_evaluator_jacobian_time_in_seconds; }; // Backtracking and interpolation based Armijo line search. This @@ -257,10 +280,12 @@ class ArmijoLineSearch : public LineSearch { public: explicit ArmijoLineSearch(const LineSearch::Options& options); virtual ~ArmijoLineSearch() {} - virtual void Search(double step_size_estimate, - double initial_cost, - double initial_gradient, - Summary* summary); + + private: + virtual void DoSearch(double step_size_estimate, + double initial_cost, + double initial_gradient, + Summary* summary) const; }; // Bracketing / Zoom Strong Wolfe condition line search. This implementation @@ -274,23 +299,26 @@ class WolfeLineSearch : public LineSearch { public: explicit WolfeLineSearch(const LineSearch::Options& options); virtual ~WolfeLineSearch() {} - virtual void Search(double step_size_estimate, - double initial_cost, - double initial_gradient, - Summary* summary); + // Returns true iff either a valid point, or valid bracket are found. bool BracketingPhase(const FunctionSample& initial_position, const double step_size_estimate, FunctionSample* bracket_low, FunctionSample* bracket_high, bool* perform_zoom_search, - Summary* summary); + Summary* summary) const; // Returns true iff final_line_sample satisfies strong Wolfe conditions. bool ZoomPhase(const FunctionSample& initial_position, FunctionSample bracket_low, FunctionSample bracket_high, FunctionSample* solution, - Summary* summary); + Summary* summary) const; + + private: + virtual void DoSearch(double step_size_estimate, + double initial_cost, + double initial_gradient, + Summary* summary) const; }; } // namespace internal diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.cc b/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.cc index dddcecdb196..1f9d205bff5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -86,7 +86,7 @@ class NonlinearConjugateGradient : public LineSearchDirection { LOG(WARNING) << "Restarting non-linear conjugate gradients: " << directional_derivative; *search_direction = -current.gradient; - }; + } return true; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.h b/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.h index c77fdc8e65b..467578d5f7c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.h +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search_direction.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.cc b/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.cc index ad28ffb137d..62264fb0b64 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -69,7 +69,7 @@ namespace { bool Evaluate(Evaluator* evaluator, const Vector& x, LineSearchMinimizer::State* state, - string* message) { + std::string* message) { if (!evaluator->Evaluate(x.data(), &(state->cost), NULL, @@ -290,9 +290,9 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options, // iteration. const double initial_step_size = (iteration_summary.iteration == 1 || !line_search_status) - ? min(1.0, 1.0 / current_state.gradient_max_norm) - : min(1.0, 2.0 * (current_state.cost - previous_state.cost) / - current_state.directional_derivative); + ? std::min(1.0, 1.0 / current_state.gradient_max_norm) + : std::min(1.0, 2.0 * (current_state.cost - previous_state.cost) / + current_state.directional_derivative); // By definition, we should only ever go forwards along the specified search // direction in a line search, most likely cause for this being violated // would be a numerical failure in the line search direction calculation. @@ -332,6 +332,8 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options, iteration_summary.step_solver_time_in_seconds = WallTimeInSeconds() - iteration_start_time; + const double x_norm = x.norm(); + if (!evaluator->Plus(x.data(), delta.data(), x_plus_delta.data())) { summary->termination_type = FAILURE; summary->message = @@ -361,7 +363,6 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options, iteration_summary.step_norm = delta.norm(); iteration_summary.step_is_valid = true; iteration_summary.step_is_successful = true; - iteration_summary.step_norm = delta.norm(); iteration_summary.step_size = current_state.step_size; iteration_summary.line_search_function_evaluations = line_search_summary.num_function_evaluations; @@ -375,8 +376,30 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options, WallTimeInSeconds() - start_time + summary->preprocessor_time_in_seconds; + summary->line_search_cost_evaluation_time_in_seconds += + line_search_summary.cost_evaluation_time_in_seconds; + summary->line_search_gradient_evaluation_time_in_seconds += + line_search_summary.gradient_evaluation_time_in_seconds; + summary->line_search_polynomial_minimization_time_in_seconds += + line_search_summary.polynomial_minimization_time_in_seconds; + summary->line_search_total_time_in_seconds += + line_search_summary.total_time_in_seconds; ++summary->num_successful_steps; + const double step_size_tolerance = options.parameter_tolerance * + (x_norm + options.parameter_tolerance); + if (iteration_summary.step_norm <= step_size_tolerance) { + summary->message = + StringPrintf("Parameter tolerance reached. " + "Relative step_norm: %e <= %e.", + (iteration_summary.step_norm / + (x_norm + options.parameter_tolerance)), + options.parameter_tolerance); + summary->termination_type = CONVERGENCE; + VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message; + return; + } + if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) { summary->message = StringPrintf("Gradient tolerance reached. " "Gradient max norm: %e <= %e", @@ -389,7 +412,7 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options, const double absolute_function_tolerance = options.function_tolerance * previous_state.cost; - if (fabs(iteration_summary.cost_change) < absolute_function_tolerance) { + if (fabs(iteration_summary.cost_change) <= absolute_function_tolerance) { summary->message = StringPrintf("Function tolerance reached. " "|cost_change|/cost: %e <= %e", diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.h b/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.h index f82f13984a8..54b7202e0c3 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.cc b/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.cc index bf17dee351d..831f5e8d079 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -42,7 +42,7 @@ namespace ceres { namespace internal { namespace { -bool IsProgramValid(const Program& program, string* error) { +bool IsProgramValid(const Program& program, std::string* error) { if (program.IsBoundsConstrained()) { *error = "LINE_SEARCH Minimizer does not support bounds."; return false; diff --git a/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.h b/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.h index 54b968bc29e..132d83a0a9a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.h +++ b/extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.cc b/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.cc index 24ba565daf9..0a69375f7b5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -46,6 +46,8 @@ namespace ceres { namespace internal { +using std::string; + LinearLeastSquaresProblem* CreateLinearLeastSquaresProblemFromId(int id) { switch (id) { case 0: @@ -56,6 +58,8 @@ LinearLeastSquaresProblem* CreateLinearLeastSquaresProblemFromId(int id) { return LinearLeastSquaresProblem2(); case 3: return LinearLeastSquaresProblem3(); + case 4: + return LinearLeastSquaresProblem4(); default: LOG(FATAL) << "Unknown problem id requested " << id; } @@ -97,11 +101,11 @@ LinearLeastSquaresProblem* LinearLeastSquaresProblem0() { int counter = 0; for (int i = 0; i < 3; ++i) { for (int j = 0; j< 2; ++j) { - Ai[counter]=i; - Aj[counter]=j; + Ai[counter] = i; + Aj[counter] = j; ++counter; } - }; + } Ax[0] = 1.; Ax[1] = 2.; @@ -503,6 +507,106 @@ LinearLeastSquaresProblem* LinearLeastSquaresProblem3() { return problem; } +/* + A = [1 2 0 0 0 1 1 + 1 4 0 0 0 5 6 + 0 0 9 0 0 3 1] + + b = [0 + 1 + 2] +*/ +// BlockSparseMatrix version +// +// This problem has the unique property that it has two different +// sized f-blocks, but only one of them occurs in the rows involving +// the one e-block. So performing Schur elimination on this problem +// tests the Schur Eliminator's ability to handle non-e-block rows +// correctly when their structure does not conform to the static +// structure determined by DetectStructure. +// +// NOTE: This problem is too small and rank deficient to be solved without +// the diagonal regularization. +LinearLeastSquaresProblem* LinearLeastSquaresProblem4() { + int num_rows = 3; + int num_cols = 7; + + LinearLeastSquaresProblem* problem = new LinearLeastSquaresProblem; + + problem->b.reset(new double[num_rows]); + problem->D.reset(new double[num_cols]); + problem->num_eliminate_blocks = 1; + + CompressedRowBlockStructure* bs = new CompressedRowBlockStructure; + scoped_array<double> values(new double[num_rows * num_cols]); + + // Column block structure + bs->cols.push_back(Block()); + bs->cols.back().size = 2; + bs->cols.back().position = 0; + + bs->cols.push_back(Block()); + bs->cols.back().size = 3; + bs->cols.back().position = 2; + + bs->cols.push_back(Block()); + bs->cols.back().size = 2; + bs->cols.back().position = 5; + + int nnz = 0; + + // Row 1 & 2 + { + bs->rows.push_back(CompressedRow()); + CompressedRow& row = bs->rows.back(); + row.block.size = 2; + row.block.position = 0; + + row.cells.push_back(Cell(0, nnz)); + values[nnz++] = 1; + values[nnz++] = 2; + values[nnz++] = 1; + values[nnz++] = 4; + + row.cells.push_back(Cell(2, nnz)); + values[nnz++] = 1; + values[nnz++] = 1; + values[nnz++] = 5; + values[nnz++] = 6; + } + + // Row 3 + { + bs->rows.push_back(CompressedRow()); + CompressedRow& row = bs->rows.back(); + row.block.size = 1; + row.block.position = 2; + + row.cells.push_back(Cell(1, nnz)); + values[nnz++] = 9; + values[nnz++] = 0; + values[nnz++] = 0; + + row.cells.push_back(Cell(2, nnz)); + values[nnz++] = 3; + values[nnz++] = 1; + } + + BlockSparseMatrix* A = new BlockSparseMatrix(bs); + memcpy(A->mutable_values(), values.get(), nnz * sizeof(*A->values())); + + for (int i = 0; i < num_cols; ++i) { + problem->D.get()[i] = (i + 1) * 100; + } + + for (int i = 0; i < num_rows; ++i) { + problem->b.get()[i] = i; + } + + problem->A.reset(A); + return problem; +} + namespace { bool DumpLinearLeastSquaresProblemToConsole(const SparseMatrix* A, const double* D, @@ -527,7 +631,7 @@ bool DumpLinearLeastSquaresProblemToConsole(const SparseMatrix* A, LOG(INFO) << "x: \n" << ConstVectorRef(x, A->num_cols()); } return true; -}; +} void WriteArrayToFileOrDie(const string& filename, const double* x, @@ -619,7 +723,7 @@ bool DumpLinearLeastSquaresProblem(const string& filename_base, num_eliminate_blocks); default: LOG(FATAL) << "Unknown DumpFormatType " << dump_format_type; - }; + } return true; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.h b/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.h index fdeed70de62..384efb59a2b 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.h +++ b/extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -68,10 +68,11 @@ LinearLeastSquaresProblem* LinearLeastSquaresProblem0(); LinearLeastSquaresProblem* LinearLeastSquaresProblem1(); LinearLeastSquaresProblem* LinearLeastSquaresProblem2(); LinearLeastSquaresProblem* LinearLeastSquaresProblem3(); +LinearLeastSquaresProblem* LinearLeastSquaresProblem4(); // Write the linear least squares problem to disk. The exact format // depends on dump_format_type. -bool DumpLinearLeastSquaresProblem(const string& filename_base, +bool DumpLinearLeastSquaresProblem(const std::string& filename_base, DumpFormatType dump_format_type, const SparseMatrix* A, const double* D, diff --git a/extern/libmv/third_party/ceres/internal/ceres/linear_operator.cc b/extern/libmv/third_party/ceres/internal/ceres/linear_operator.cc index 4b59fa13009..9d291bd3465 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/linear_operator.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/linear_operator.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/linear_operator.h b/extern/libmv/third_party/ceres/internal/ceres/linear_operator.h index d5c15cee6a9..6463fb5089a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/linear_operator.h +++ b/extern/libmv/third_party/ceres/internal/ceres/linear_operator.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/linear_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/linear_solver.cc index e479b751363..38e4625f747 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/linear_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/linear_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/linear_solver.h b/extern/libmv/third_party/ceres/internal/ceres/linear_solver.h index 5f59765f074..fb9332ca6e3 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/linear_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/linear_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -144,7 +144,7 @@ class LinearSolver { // elimination group must form an independent set in the normal // equations. The first elimination group corresponds to the // num_eliminate_blocks in the Schur type solvers. - vector<int> elimination_groups; + std::vector<int> elimination_groups; // Iterative solvers, e.g. Preconditioned Conjugate Gradients // maintain a cheap estimate of the residual which may become @@ -273,7 +273,7 @@ class LinearSolver { double residual_norm; int num_iterations; LinearSolverTerminationType termination_type; - string message; + std::string message; }; // If the optimization problem is such that there are no remaining @@ -296,12 +296,12 @@ class LinearSolver { // that the base class implementation does not have to worry about // life time issues. Further, these calls are not expected to be // frequent or performance sensitive. - virtual map<string, int> CallStatistics() const { - return map<string, int>(); + virtual std::map<std::string, int> CallStatistics() const { + return std::map<std::string, int>(); } - virtual map<string, double> TimeStatistics() const { - return map<string, double>(); + virtual std::map<std::string, double> TimeStatistics() const { + return std::map<std::string, double>(); } // Factory @@ -331,11 +331,11 @@ class TypedLinearSolver : public LinearSolver { return SolveImpl(down_cast<MatrixType*>(A), b, per_solve_options, x); } - virtual map<string, int> CallStatistics() const { + virtual std::map<std::string, int> CallStatistics() const { return execution_summary_.calls(); } - virtual map<string, double> TimeStatistics() const { + virtual std::map<std::string, double> TimeStatistics() const { return execution_summary_.times(); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/local_parameterization.cc b/extern/libmv/third_party/ceres/internal/ceres/local_parameterization.cc index a4832c57443..82004761ec0 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/local_parameterization.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/local_parameterization.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -30,12 +30,16 @@ #include "ceres/local_parameterization.h" +#include "ceres/householder_vector.h" #include "ceres/internal/eigen.h" +#include "ceres/internal/fixed_array.h" #include "ceres/rotation.h" #include "glog/logging.h" namespace ceres { +using std::vector; + LocalParameterization::~LocalParameterization() { } @@ -180,4 +184,162 @@ bool QuaternionParameterization::ComputeJacobian(const double* x, return true; } +HomogeneousVectorParameterization::HomogeneousVectorParameterization(int size) + : size_(size) { + CHECK_GT(size_, 1) << "The size of the homogeneous vector needs to be " + << "greater than 1."; +} + +bool HomogeneousVectorParameterization::Plus(const double* x_ptr, + const double* delta_ptr, + double* x_plus_delta_ptr) const { + ConstVectorRef x(x_ptr, size_); + ConstVectorRef delta(delta_ptr, size_ - 1); + VectorRef x_plus_delta(x_plus_delta_ptr, size_); + + const double norm_delta = delta.norm(); + + if (norm_delta == 0.0) { + x_plus_delta = x; + return true; + } + + // Map the delta from the minimum representation to the over parameterized + // homogeneous vector. See section A6.9.2 on page 624 of Hartley & Zisserman + // (2nd Edition) for a detailed description. Note there is a typo on Page + // 625, line 4 so check the book errata. + const double norm_delta_div_2 = 0.5 * norm_delta; + const double sin_delta_by_delta = sin(norm_delta_div_2) / + norm_delta_div_2; + + Vector y(size_); + y.head(size_ - 1) = 0.5 * sin_delta_by_delta * delta; + y(size_ - 1) = cos(norm_delta_div_2); + + Vector v(size_); + double beta; + internal::ComputeHouseholderVector<double>(x, &v, &beta); + + // Apply the delta update to remain on the unit sphere. See section A6.9.3 + // on page 625 of Hartley & Zisserman (2nd Edition) for a detailed + // description. + x_plus_delta = x.norm() * (y - v * (beta * (v.transpose() * y))); + + return true; +} + +bool HomogeneousVectorParameterization::ComputeJacobian( + const double* x_ptr, double* jacobian_ptr) const { + ConstVectorRef x(x_ptr, size_); + MatrixRef jacobian(jacobian_ptr, size_, size_ - 1); + + Vector v(size_); + double beta; + internal::ComputeHouseholderVector<double>(x, &v, &beta); + + // The Jacobian is equal to J = 0.5 * H.leftCols(size_ - 1) where H is the + // Householder matrix (H = I - beta * v * v'). + for (int i = 0; i < size_ - 1; ++i) { + jacobian.col(i) = -0.5 * beta * v(i) * v; + jacobian.col(i)(i) += 0.5; + } + jacobian *= x.norm(); + + return true; +} + +ProductParameterization::ProductParameterization( + LocalParameterization* local_param1, + LocalParameterization* local_param2) { + local_params_.push_back(local_param1); + local_params_.push_back(local_param2); + Init(); +} + +ProductParameterization::ProductParameterization( + LocalParameterization* local_param1, + LocalParameterization* local_param2, + LocalParameterization* local_param3) { + local_params_.push_back(local_param1); + local_params_.push_back(local_param2); + local_params_.push_back(local_param3); + Init(); +} + +ProductParameterization::ProductParameterization( + LocalParameterization* local_param1, + LocalParameterization* local_param2, + LocalParameterization* local_param3, + LocalParameterization* local_param4) { + local_params_.push_back(local_param1); + local_params_.push_back(local_param2); + local_params_.push_back(local_param3); + local_params_.push_back(local_param4); + Init(); +} + +ProductParameterization::~ProductParameterization() { + for (int i = 0; i < local_params_.size(); ++i) { + delete local_params_[i]; + } +} + +void ProductParameterization::Init() { + global_size_ = 0; + local_size_ = 0; + buffer_size_ = 0; + for (int i = 0; i < local_params_.size(); ++i) { + const LocalParameterization* param = local_params_[i]; + buffer_size_ = std::max(buffer_size_, + param->LocalSize() * param->GlobalSize()); + global_size_ += param->GlobalSize(); + local_size_ += param->LocalSize(); + } +} + +bool ProductParameterization::Plus(const double* x, + const double* delta, + double* x_plus_delta) const { + int x_cursor = 0; + int delta_cursor = 0; + for (int i = 0; i < local_params_.size(); ++i) { + const LocalParameterization* param = local_params_[i]; + if (!param->Plus(x + x_cursor, + delta + delta_cursor, + x_plus_delta + x_cursor)) { + return false; + } + delta_cursor += param->LocalSize(); + x_cursor += param->GlobalSize(); + } + + return true; +} + +bool ProductParameterization::ComputeJacobian(const double* x, + double* jacobian_ptr) const { + MatrixRef jacobian(jacobian_ptr, GlobalSize(), LocalSize()); + jacobian.setZero(); + internal::FixedArray<double> buffer(buffer_size_); + + int x_cursor = 0; + int delta_cursor = 0; + for (int i = 0; i < local_params_.size(); ++i) { + const LocalParameterization* param = local_params_[i]; + const int local_size = param->LocalSize(); + const int global_size = param->GlobalSize(); + + if (!param->ComputeJacobian(x + x_cursor, buffer.get())) { + return false; + } + + jacobian.block(x_cursor, delta_cursor, global_size, local_size) + = MatrixRef(buffer.get(), global_size, local_size); + delta_cursor += local_size; + x_cursor += global_size; + } + + return true; +} + } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/loss_function.cc b/extern/libmv/third_party/ceres/internal/ceres/loss_function.cc index 62b545be12f..eb5026784dd 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/loss_function.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/loss_function.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -114,6 +114,22 @@ void TolerantLoss::Evaluate(double s, double rho[3]) const { } } +void TukeyLoss::Evaluate(double s, double* rho) const { + if (s <= a_squared_) { + // Inlier region. + const double value = 1.0 - s / a_squared_; + const double value_sq = value * value; + rho[0] = a_squared_ / 6.0 * (1.0 - value_sq * value); + rho[1] = 0.5 * value_sq; + rho[2] = -1.0 / a_squared_ * value; + } else { + // Outlier region. + rho[0] = a_squared_ / 6.0; + rho[1] = 0.0; + rho[2] = 0.0; + } +} + ComposedLoss::ComposedLoss(const LossFunction* f, Ownership ownership_f, const LossFunction* g, Ownership ownership_g) : f_(CHECK_NOTNULL(f)), diff --git a/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.cc b/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.cc index 4816e3c20f0..1c6c9925f1c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -37,6 +37,8 @@ namespace ceres { namespace internal { +using std::list; + // The (L)BFGS algorithm explicitly requires that the secant equation: // // B_{k+1} * s_k = y_k @@ -126,7 +128,7 @@ void LowRankInverseHessian::RightMultiply(const double* x_ptr, const int num_corrections = indices_.size(); Vector alpha(num_corrections); - for (std::list<int>::const_reverse_iterator it = indices_.rbegin(); + for (list<int>::const_reverse_iterator it = indices_.rbegin(); it != indices_.rend(); ++it) { const double alpha_i = delta_x_history_.col(*it).dot(search_direction) / @@ -173,7 +175,7 @@ void LowRankInverseHessian::RightMultiply(const double* x_ptr, << "approximation."; } - for (std::list<int>::const_iterator it = indices_.begin(); + for (list<int>::const_iterator it = indices_.begin(); it != indices_.end(); ++it) { const double beta = delta_gradient_history_.col(*it).dot(search_direction) / diff --git a/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.h b/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.h index 19ab7606aa0..2c768c2ca53 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.h +++ b/extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/map_util.h b/extern/libmv/third_party/ceres/internal/ceres/map_util.h index 929c6b36982..61c531f297c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/map_util.h +++ b/extern/libmv/third_party/ceres/internal/ceres/map_util.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -87,8 +87,8 @@ bool InsertIfNotPresent( Collection * const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value) { - pair<typename Collection::iterator, bool> ret = - collection->insert(typename Collection::value_type(key, value)); + std::pair<typename Collection::iterator, bool> ret = + collection->insert(typename Collection::value_type(key, value)); return ret.second; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/minimizer.cc b/extern/libmv/third_party/ceres/internal/ceres/minimizer.cc index 558921b8441..f5960336f12 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/minimizer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/minimizer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -68,7 +68,8 @@ bool Minimizer::RunCallbacks(const Minimizer::Options& options, return true; case SOLVER_TERMINATE_SUCCESSFULLY: summary->termination_type = USER_SUCCESS; - summary->message = "User callback returned SOLVER_TERMINATE_SUCCESSFULLY."; + summary->message = + "User callback returned SOLVER_TERMINATE_SUCCESSFULLY."; VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message; return false; case SOLVER_ABORT: diff --git a/extern/libmv/third_party/ceres/internal/ceres/minimizer.h b/extern/libmv/third_party/ceres/internal/ceres/minimizer.h index dabf07e583a..b59372806e7 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/minimizer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/minimizer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -132,9 +132,9 @@ class Minimizer { bool jacobi_scaling; bool use_nonmonotonic_steps; int max_consecutive_nonmonotonic_steps; - vector<int> trust_region_minimizer_iterations_to_dump; + std::vector<int> trust_region_minimizer_iterations_to_dump; DumpFormatType trust_region_problem_dump_format_type; - string trust_region_problem_dump_directory; + std::string trust_region_problem_dump_directory; int max_num_consecutive_invalid_steps; double min_trust_region_radius; LineSearchDirectionType line_search_direction_type; @@ -163,7 +163,7 @@ class Minimizer { // of each iteration. // // The Options struct does not own these pointers. - vector<IterationCallback*> callbacks; + std::vector<IterationCallback*> callbacks; // Object responsible for evaluating the cost, residuals and // Jacobian matrix. diff --git a/extern/libmv/third_party/ceres/internal/ceres/mutex.h b/extern/libmv/third_party/ceres/internal/ceres/mutex.h index 97e2cd360c2..2ce97772755 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/mutex.h +++ b/extern/libmv/third_party/ceres/internal/ceres/mutex.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/normal_prior.cc b/extern/libmv/third_party/ceres/internal/ceres/normal_prior.cc index 392d728fb32..b3666cd702f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/normal_prior.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/normal_prior.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/parameter_block.h b/extern/libmv/third_party/ceres/internal/ceres/parameter_block.h index 7bc823d4ec6..cb7140d9582 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/parameter_block.h +++ b/extern/libmv/third_party/ceres/internal/ceres/parameter_block.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -193,7 +193,7 @@ class ParameterBlock { } upper_bounds_[index] = upper_bound; - }; + } void SetLowerBound(int index, double lower_bound) { CHECK_LT(index, size_); @@ -237,10 +237,11 @@ class ParameterBlock { return true; } - string ToString() const { - return StringPrintf("{ user_state=%p, state=%p, size=%d, " + std::string ToString() const { + return StringPrintf("{ this=%p, user_state=%p, state=%p, size=%d, " "constant=%d, index=%d, state_offset=%d, " "delta_offset=%d }", + this, user_state_, state_, size_, diff --git a/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.cc b/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.cc index 1525de90d60..efba339977c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -43,6 +43,10 @@ namespace ceres { namespace internal { +using std::map; +using std::set; +using std::vector; + int ComputeStableSchurOrdering(const Program& program, vector<ParameterBlock*>* ordering) { CHECK_NOTNULL(ordering)->clear(); diff --git a/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.h b/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.h index 5de99511138..f996929f6b3 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.h +++ b/extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -56,13 +56,13 @@ class ParameterBlock; // complement of the independent set, // fixed blocks] int ComputeSchurOrdering(const Program& program, - vector<ParameterBlock* >* ordering); + std::vector<ParameterBlock* >* ordering); // Same as above, except that ties while computing the independent set // ordering are resolved in favour of the order in which the parameter // blocks occur in the program. int ComputeStableSchurOrdering(const Program& program, - vector<ParameterBlock* >* ordering); + std::vector<ParameterBlock* >* ordering); // Use an approximate independent set ordering to decompose the // parameter blocks of a problem in a sequence of independent @@ -81,7 +81,7 @@ Graph<ParameterBlock*>* CreateHessianGraph(const Program& program); // Iterate over each of the groups in order of their priority and fill // summary with their sizes. void OrderingToGroupSizes(const ParameterBlockOrdering* ordering, - vector<int>* group_sizes); + std::vector<int>* group_sizes); } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.cc b/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.cc index d745a9b358d..8054964e039 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -89,6 +89,12 @@ PartitionedMatrixViewBase::Create(const LinearSolver::Options& options, } if ((options.row_block_size == 2) && (options.e_block_size == 3) && + (options.f_block_size == 6)) { + return new PartitionedMatrixView<2, 3, 6>( + matrix, options.elimination_groups[0]); + } + if ((options.row_block_size == 2) && + (options.e_block_size == 3) && (options.f_block_size == 9)) { return new PartitionedMatrixView<2, 3, 9>( matrix, options.elimination_groups[0]); diff --git a/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.h b/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.h index 661252d404f..6e75060a47e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.h +++ b/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view_impl.h b/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view_impl.h index ae7f776e6b1..86fb278fa27 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view_impl.h +++ b/extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view_impl.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -61,7 +61,7 @@ PartitionedMatrixView( // explicit_schur_complement_solver.h num_row_blocks_e_ = 0; for (int r = 0; r < bs->rows.size(); ++r) { - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; if (cells[0].block_id < num_col_blocks_e_) { ++num_row_blocks_e_; } @@ -131,7 +131,7 @@ RightMultiplyF(const double* x, double* y) const { for (int r = 0; r < num_row_blocks_e_; ++r) { const int row_block_pos = bs->rows[r].block.position; const int row_block_size = bs->rows[r].block.size; - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; for (int c = 1; c < cells.size(); ++c) { const int col_block_id = cells[c].block_id; const int col_block_pos = bs->cols[col_block_id].position; @@ -146,7 +146,7 @@ RightMultiplyF(const double* x, double* y) const { for (int r = num_row_blocks_e_; r < bs->rows.size(); ++r) { const int row_block_pos = bs->rows[r].block.position; const int row_block_size = bs->rows[r].block.size; - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; for (int c = 0; c < cells.size(); ++c) { const int col_block_id = cells[c].block_id; const int col_block_pos = bs->cols[col_block_id].position; @@ -197,7 +197,7 @@ LeftMultiplyF(const double* x, double* y) const { for (int r = 0; r < num_row_blocks_e_; ++r) { const int row_block_pos = bs->rows[r].block.position; const int row_block_size = bs->rows[r].block.size; - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; for (int c = 1; c < cells.size(); ++c) { const int col_block_id = cells[c].block_id; const int col_block_pos = bs->cols[col_block_id].position; @@ -212,7 +212,7 @@ LeftMultiplyF(const double* x, double* y) const { for (int r = num_row_blocks_e_; r < bs->rows.size(); ++r) { const int row_block_pos = bs->rows[r].block.position; const int row_block_size = bs->rows[r].block.size; - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; for (int c = 0; c < cells.size(); ++c) { const int col_block_id = cells[c].block_id; const int col_block_pos = bs->cols[col_block_id].position; @@ -339,7 +339,7 @@ UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const { const double* values = matrix_.values(); for (int r = 0; r < num_row_blocks_e_; ++r) { const int row_block_size = bs->rows[r].block.size; - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; for (int c = 1; c < cells.size(); ++c) { const int col_block_id = cells[c].block_id; const int col_block_size = bs->cols[col_block_id].size; @@ -358,7 +358,7 @@ UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const { for (int r = num_row_blocks_e_; r < bs->rows.size(); ++r) { const int row_block_size = bs->rows[r].block.size; - const vector<Cell>& cells = bs->rows[r].cells; + const std::vector<Cell>& cells = bs->rows[r].cells; for (int c = 0; c < cells.size(); ++c) { const int col_block_id = cells[c].block_id; const int col_block_size = bs->cols[col_block_id].size; diff --git a/extern/libmv/third_party/ceres/internal/ceres/polynomial.cc b/extern/libmv/third_party/ceres/internal/ceres/polynomial.cc index 75f43de409a..13bf8edeee6 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/polynomial.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/polynomial.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -42,6 +42,10 @@ namespace ceres { namespace internal { + +using std::string; +using std::vector; + namespace { // Balancing function as described by B. N. Parlett and C. Reinsch, diff --git a/extern/libmv/third_party/ceres/internal/ceres/polynomial.h b/extern/libmv/third_party/ceres/internal/ceres/polynomial.h index 80ce77e6ae1..09a64c577f5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/polynomial.h +++ b/extern/libmv/third_party/ceres/internal/ceres/polynomial.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -32,6 +32,7 @@ #ifndef CERES_INTERNAL_POLYNOMIAL_SOLVER_H_ #define CERES_INTERNAL_POLYNOMIAL_SOLVER_H_ +#include <string> #include <vector> #include "ceres/internal/eigen.h" #include "ceres/internal/port.h" @@ -95,7 +96,7 @@ struct FunctionSample { gradient(0.0), gradient_is_valid(false) { } - string ToDebugString() const; + std::string ToDebugString() const; double x; double value; // value = f(x) @@ -115,7 +116,7 @@ struct FunctionSample { // Of course its possible to sample a polynomial any number of times, // in which case, generally speaking the spurious higher order // coefficients will be zero. -Vector FindInterpolatingPolynomial(const vector<FunctionSample>& samples); +Vector FindInterpolatingPolynomial(const std::vector<FunctionSample>& samples); // Interpolate the function described by samples with a polynomial, // and minimize it on the interval [x_min, x_max]. Depending on the @@ -123,7 +124,7 @@ Vector FindInterpolatingPolynomial(const vector<FunctionSample>& samples); // finding algorithms may fail due to numerical difficulties. But the // function is guaranteed to return its best guess of an answer, by // considering the samples and the end points as possible solutions. -void MinimizeInterpolatingPolynomial(const vector<FunctionSample>& samples, +void MinimizeInterpolatingPolynomial(const std::vector<FunctionSample>& samples, double x_min, double x_max, double* optimal_x, diff --git a/extern/libmv/third_party/ceres/internal/ceres/preconditioner.cc b/extern/libmv/third_party/ceres/internal/ceres/preconditioner.cc index 062347fccc1..82621dae50c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/preconditioner.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/preconditioner.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/preconditioner.h b/extern/libmv/third_party/ceres/internal/ceres/preconditioner.h index e8d5994269a..a248eae060d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/preconditioner.h +++ b/extern/libmv/third_party/ceres/internal/ceres/preconditioner.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -80,7 +80,7 @@ class Preconditioner : public LinearOperator { // elimination group must form an independent set in the normal // equations. The first elimination group corresponds to the // num_eliminate_blocks in the Schur type solvers. - vector<int> elimination_groups; + std::vector<int> elimination_groups; // If the block sizes in a BlockSparseMatrix are fixed, then in // some cases the Schur complement based solvers can detect and diff --git a/extern/libmv/third_party/ceres/internal/ceres/preprocessor.cc b/extern/libmv/third_party/ceres/internal/ceres/preprocessor.cc index 318c5e2ebef..4aba6a39ce8 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/preprocessor.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/preprocessor.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/preprocessor.h b/extern/libmv/third_party/ceres/internal/ceres/preprocessor.h index b4ca5b11747..ff53d6f0d3f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/preprocessor.h +++ b/extern/libmv/third_party/ceres/internal/ceres/preprocessor.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -31,6 +31,9 @@ #ifndef CERES_INTERNAL_PREPROCESSOR_H_ #define CERES_INTERNAL_PREPROCESSOR_H_ +#include <string> +#include <vector> + #include "ceres/coordinate_descent_minimizer.h" #include "ceres/evaluator.h" #include "ceres/internal/eigen.h" @@ -65,7 +68,7 @@ struct PreprocessedProblem; // The output of the Preprocessor is stored in a PreprocessedProblem // object. class Preprocessor { -public: + public: // Factory. static Preprocessor* Create(MinimizerType minimizer_type); virtual ~Preprocessor(); @@ -81,7 +84,7 @@ struct PreprocessedProblem { : fixed_cost(0.0) { } - string error; + std::string error; Solver::Options options; LinearSolver::Options linear_solver_options; Evaluator::Options evaluator_options; @@ -97,7 +100,7 @@ struct PreprocessedProblem { shared_ptr<Evaluator> evaluator; shared_ptr<CoordinateDescentMinimizer> inner_iteration_minimizer; - vector<double*> removed_parameter_blocks; + std::vector<double*> removed_parameter_blocks; Vector reduced_parameters; double fixed_cost; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/problem.cc b/extern/libmv/third_party/ceres/internal/ceres/problem.cc index bbfaa98769f..03b7d6afa48 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/problem.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/problem.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -37,6 +37,8 @@ namespace ceres { +using std::vector; + Problem::Problem() : problem_impl_(new internal::ProblemImpl) {} Problem::Problem(const Problem::Options& options) : problem_impl_(new internal::ProblemImpl(options)) {} @@ -225,11 +227,11 @@ int Problem::NumResiduals() const { int Problem::ParameterBlockSize(const double* parameter_block) const { return problem_impl_->ParameterBlockSize(parameter_block); -}; +} int Problem::ParameterBlockLocalSize(const double* parameter_block) const { return problem_impl_->ParameterBlockLocalSize(parameter_block); -}; +} bool Problem::HasParameterBlock(const double* values) const { return problem_impl_->HasParameterBlock(values); diff --git a/extern/libmv/third_party/ceres/internal/ceres/problem_impl.cc b/extern/libmv/third_party/ceres/internal/ceres/problem_impl.cc index 67cac94d6ac..8547d5d3f77 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/problem_impl.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/problem_impl.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -55,18 +55,12 @@ namespace ceres { namespace internal { -typedef map<double*, internal::ParameterBlock*> ParameterMap; +using std::map; +using std::string; +using std::vector; +typedef std::map<double*, internal::ParameterBlock*> ParameterMap; namespace { -internal::ParameterBlock* FindParameterBlockOrDie( - const ParameterMap& parameter_map, - double* parameter_block) { - ParameterMap::const_iterator it = parameter_map.find(parameter_block); - CHECK(it != parameter_map.end()) - << "Parameter block not found: " << parameter_block; - return it->second; -} - // Returns true if two regions of memory, a and b, with sizes size_a and size_b // respectively, overlap. bool RegionsAlias(const double* a, int size_a, @@ -530,7 +524,12 @@ void ProblemImpl::RemoveResidualBlock(ResidualBlock* residual_block) { void ProblemImpl::RemoveParameterBlock(double* values) { ParameterBlock* parameter_block = - FindParameterBlockOrDie(parameter_block_map_, values); + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "it can be removed."; + } if (options_.enable_fast_removal) { // Copy the dependent residuals from the parameter block because the set of @@ -562,38 +561,81 @@ void ProblemImpl::RemoveParameterBlock(double* values) { } void ProblemImpl::SetParameterBlockConstant(double* values) { - FindParameterBlockOrDie(parameter_block_map_, values)->SetConstant(); + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "it can be set constant."; + } + + parameter_block->SetConstant(); } void ProblemImpl::SetParameterBlockVariable(double* values) { - FindParameterBlockOrDie(parameter_block_map_, values)->SetVarying(); + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "it can be set varying."; + } + + parameter_block->SetVarying(); } void ProblemImpl::SetParameterization( double* values, LocalParameterization* local_parameterization) { - FindParameterBlockOrDie(parameter_block_map_, values) - ->SetParameterization(local_parameterization); + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can set its local parameterization."; + } + + parameter_block->SetParameterization(local_parameterization); } const LocalParameterization* ProblemImpl::GetParameterization( double* values) const { - return FindParameterBlockOrDie(parameter_block_map_, values) - ->local_parameterization(); + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can get its local parameterization."; + } + + return parameter_block->local_parameterization(); } void ProblemImpl::SetParameterLowerBound(double* values, int index, double lower_bound) { - FindParameterBlockOrDie(parameter_block_map_, values) - ->SetLowerBound(index, lower_bound); + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can set a lower bound on one of its components."; + } + + parameter_block->SetLowerBound(index, lower_bound); } void ProblemImpl::SetParameterUpperBound(double* values, int index, double upper_bound) { - FindParameterBlockOrDie(parameter_block_map_, values) - ->SetUpperBound(index, upper_bound); + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, values, NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can set an upper bound on one of its components."; + } + parameter_block->SetUpperBound(index, upper_bound); } bool ProblemImpl::Evaluate(const Problem::EvaluateOptions& evaluate_options, @@ -635,9 +677,14 @@ bool ProblemImpl::Evaluate(const Problem::EvaluateOptions& evaluate_options, // 1. Convert double* into ParameterBlock* parameter_blocks.resize(parameter_block_ptrs.size()); for (int i = 0; i < parameter_block_ptrs.size(); ++i) { - parameter_blocks[i] = - FindParameterBlockOrDie(parameter_block_map_, - parameter_block_ptrs[i]); + parameter_blocks[i] = FindWithDefault(parameter_block_map_, + parameter_block_ptrs[i], + NULL); + if (parameter_blocks[i] == NULL) { + LOG(FATAL) << "No known parameter block for " + << "Problem::Evaluate::Options.parameter_blocks[" << i << "]" + << " = " << parameter_block_ptrs[i]; + } } // 2. The user may have only supplied a subset of parameter @@ -684,7 +731,15 @@ bool ProblemImpl::Evaluate(const Problem::EvaluateOptions& evaluate_options, // the Evaluator decides the storage for the Jacobian based on the // type of linear solver being used. evaluator_options.linear_solver_type = SPARSE_NORMAL_CHOLESKY; +#ifndef CERES_USE_OPENMP + LOG_IF(WARNING, evaluate_options.num_threads > 1) + << "OpenMP support is not compiled into this binary; " + << "only evaluate_options.num_threads = 1 is supported. Switching " + << "to single threaded mode."; + evaluator_options.num_threads = 1; +#else evaluator_options.num_threads = evaluate_options.num_threads; +#endif // CERES_USE_OPENMP string error; scoped_ptr<Evaluator> evaluator( @@ -781,15 +836,29 @@ int ProblemImpl::NumResiduals() const { return program_->NumResiduals(); } -int ProblemImpl::ParameterBlockSize(const double* parameter_block) const { - return FindParameterBlockOrDie(parameter_block_map_, - const_cast<double*>(parameter_block))->Size(); -}; +int ProblemImpl::ParameterBlockSize(const double* values) const { + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, const_cast<double*>(values), NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can get its size."; + } -int ProblemImpl::ParameterBlockLocalSize(const double* parameter_block) const { - return FindParameterBlockOrDie( - parameter_block_map_, const_cast<double*>(parameter_block))->LocalSize(); -}; + return parameter_block->Size(); +} + +int ProblemImpl::ParameterBlockLocalSize(const double* values) const { + ParameterBlock* parameter_block = + FindWithDefault(parameter_block_map_, const_cast<double*>(values), NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can get its local size."; + } + + return parameter_block->LocalSize(); +} bool ProblemImpl::HasParameterBlock(const double* parameter_block) const { return (parameter_block_map_.find(const_cast<double*>(parameter_block)) != @@ -837,8 +906,12 @@ void ProblemImpl::GetResidualBlocksForParameterBlock( const double* values, vector<ResidualBlockId>* residual_blocks) const { ParameterBlock* parameter_block = - FindParameterBlockOrDie(parameter_block_map_, - const_cast<double*>(values)); + FindWithDefault(parameter_block_map_, const_cast<double*>(values), NULL); + if (parameter_block == NULL) { + LOG(FATAL) << "Parameter block not found: " << values + << ". You must add the parameter block to the problem before " + << "you can get the residual blocks that depend on it."; + } if (options_.enable_fast_removal) { // In this case the residual blocks that depend on the parameter block are diff --git a/extern/libmv/third_party/ceres/internal/ceres/problem_impl.h b/extern/libmv/third_party/ceres/internal/ceres/problem_impl.h index 3d84de83c5a..f42bde6c793 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/problem_impl.h +++ b/extern/libmv/third_party/ceres/internal/ceres/problem_impl.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -63,7 +63,7 @@ class ResidualBlock; class ProblemImpl { public: - typedef map<double*, ParameterBlock*> ParameterMap; + typedef std::map<double*, ParameterBlock*> ParameterMap; typedef HashSet<ResidualBlock*> ResidualBlockSet; ProblemImpl(); @@ -72,9 +72,10 @@ class ProblemImpl { ~ProblemImpl(); // See the public problem.h file for description of these methods. - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - const vector<double*>& parameter_blocks); + ResidualBlockId AddResidualBlock( + CostFunction* cost_function, + LossFunction* loss_function, + const std::vector<double*>& parameter_blocks); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0); @@ -136,8 +137,8 @@ class ProblemImpl { bool Evaluate(const Problem::EvaluateOptions& options, double* cost, - vector<double>* residuals, - vector<double>* gradient, + std::vector<double>* residuals, + std::vector<double>* gradient, CRSMatrix* jacobian); int NumParameterBlocks() const; @@ -150,12 +151,12 @@ class ProblemImpl { bool HasParameterBlock(const double* parameter_block) const; - void GetParameterBlocks(vector<double*>* parameter_blocks) const; - void GetResidualBlocks(vector<ResidualBlockId>* residual_blocks) const; + void GetParameterBlocks(std::vector<double*>* parameter_blocks) const; + void GetResidualBlocks(std::vector<ResidualBlockId>* residual_blocks) const; void GetParameterBlocksForResidualBlock( const ResidualBlockId residual_block, - vector<double*>* parameter_blocks) const; + std::vector<double*>* parameter_blocks) const; const CostFunction* GetCostFunctionForResidualBlock( const ResidualBlockId residual_block) const; @@ -164,7 +165,7 @@ class ProblemImpl { void GetResidualBlocksForParameterBlock( const double* values, - vector<ResidualBlockId>* residual_blocks) const; + std::vector<ResidualBlockId>* residual_blocks) const; const Program& program() const { return *program_; } Program* mutable_program() { return program_.get(); } @@ -182,15 +183,15 @@ class ProblemImpl { bool InternalEvaluate(Program* program, double* cost, - vector<double>* residuals, - vector<double>* gradient, + std::vector<double>* residuals, + std::vector<double>* gradient, CRSMatrix* jacobian); // Delete the arguments in question. These differ from the Remove* functions // in that they do not clean up references to the block to delete; they // merely delete them. template<typename Block> - void DeleteBlockInVector(vector<Block*>* mutable_blocks, + void DeleteBlockInVector(std::vector<Block*>* mutable_blocks, Block* block_to_remove); void DeleteBlock(ResidualBlock* residual_block); void DeleteBlock(ParameterBlock* parameter_block); @@ -198,7 +199,7 @@ class ProblemImpl { const Problem::Options options_; // The mapping from user pointers to parameter blocks. - map<double*, ParameterBlock*> parameter_block_map_; + std::map<double*, ParameterBlock*> parameter_block_map_; // Iff enable_fast_removal is enabled, contains the current residual blocks. ResidualBlockSet residual_block_set_; @@ -212,9 +213,9 @@ class ProblemImpl { // residual or parameter blocks, buffer them until destruction. // // TODO(keir): See if it makes sense to use sets instead. - vector<CostFunction*> cost_functions_to_delete_; - vector<LossFunction*> loss_functions_to_delete_; - vector<LocalParameterization*> local_parameterizations_to_delete_; + std::vector<CostFunction*> cost_functions_to_delete_; + std::vector<LossFunction*> loss_functions_to_delete_; + std::vector<LocalParameterization*> local_parameterizations_to_delete_; CERES_DISALLOW_COPY_AND_ASSIGN(ProblemImpl); }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/program.cc b/extern/libmv/third_party/ceres/internal/ceres/program.cc index 1d0a1573e3b..8e97f072113 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/program.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/program.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -50,6 +50,11 @@ namespace ceres { namespace internal { +using std::max; +using std::set; +using std::string; +using std::vector; + Program::Program() {} Program::Program(const Program& program) @@ -261,9 +266,10 @@ bool Program::IsFeasible(string* message) const { return true; } -Program* Program::CreateReducedProgram(vector<double*>* removed_parameter_blocks, - double* fixed_cost, - string* error) const { +Program* Program::CreateReducedProgram( + vector<double*>* removed_parameter_blocks, + double* fixed_cost, + string* error) const { CHECK_NOTNULL(removed_parameter_blocks); CHECK_NOTNULL(fixed_cost); CHECK_NOTNULL(error); @@ -342,7 +348,8 @@ bool Program::RemoveFixedBlocks(vector<double*>* removed_parameter_blocks, for (int i = 0; i < parameter_blocks_.size(); ++i) { ParameterBlock* parameter_block = parameter_blocks_[i]; if (parameter_block->index() == -1) { - removed_parameter_blocks->push_back(parameter_block->mutable_user_state()); + removed_parameter_blocks->push_back( + parameter_block->mutable_user_state()); } else { parameter_blocks_[num_active_parameter_blocks++] = parameter_block; } @@ -360,7 +367,8 @@ bool Program::RemoveFixedBlocks(vector<double*>* removed_parameter_blocks, return true; } -bool Program::IsParameterBlockSetIndependent(const set<double*>& independent_set) const { +bool Program::IsParameterBlockSetIndependent( + const set<double*>& independent_set) const { // Loop over each residual block and ensure that no two parameter // blocks in the same residual block are part of // parameter_block_ptrs as that would violate the assumption that it @@ -495,8 +503,7 @@ int Program::MaxParametersPerResidualBlock() const { int Program::MaxResidualsPerResidualBlock() const { int max_residuals = 0; for (int i = 0; i < residual_blocks_.size(); ++i) { - max_residuals = max(max_residuals, - residual_blocks_[i]->NumResiduals()); + max_residuals = max(max_residuals, residual_blocks_[i]->NumResiduals()); } return max_residuals; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/program.h b/extern/libmv/third_party/ceres/internal/ceres/program.h index c7b22c4d244..38c958fe34a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/program.h +++ b/extern/libmv/third_party/ceres/internal/ceres/program.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -60,10 +60,10 @@ class Program { explicit Program(const Program& program); // The ordered parameter and residual blocks for the program. - const vector<ParameterBlock*>& parameter_blocks() const; - const vector<ResidualBlock*>& residual_blocks() const; - vector<ParameterBlock*>* mutable_parameter_blocks(); - vector<ResidualBlock*>* mutable_residual_blocks(); + const std::vector<ParameterBlock*>& parameter_blocks() const; + const std::vector<ResidualBlock*>& residual_blocks() const; + std::vector<ParameterBlock*>* mutable_parameter_blocks(); + std::vector<ResidualBlock*>* mutable_residual_blocks(); // Serialize to/from the program and update states. // @@ -105,7 +105,7 @@ class Program { // offsets) are correct. bool IsValid() const; - bool ParameterBlocksAreFinite(string* message) const; + bool ParameterBlocksAreFinite(std::string* message) const; // Returns true if the program has any non-constant parameter blocks // which have non-trivial bounds constraints. @@ -114,13 +114,14 @@ class Program { // Returns false, if the program has any constant parameter blocks // which are not feasible, or any variable parameter blocks which // have a lower bound greater than or equal to the upper bound. - bool IsFeasible(string* message) const; + bool IsFeasible(std::string* message) const; // Loop over each residual block and ensure that no two parameter // blocks in the same residual block are part of // parameter_blocks as that would violate the assumption that it // is an independent set in the Hessian matrix. - bool IsParameterBlockSetIndependent(const set<double*>& independent_set) const; + bool IsParameterBlockSetIndependent( + const std::set<double*>& independent_set) const; // Create a TripletSparseMatrix which contains the zero-one // structure corresponding to the block sparsity of the transpose of @@ -142,9 +143,9 @@ class Program { // If there was a problem, then the function will return a NULL // pointer and error will contain a human readable description of // the problem. - Program* CreateReducedProgram(vector<double*>* removed_parameter_blocks, + Program* CreateReducedProgram(std::vector<double*>* removed_parameter_blocks, double* fixed_cost, - string* error) const; + std::string* error) const; // See problem.h for what these do. int NumParameterBlocks() const; @@ -160,7 +161,7 @@ class Program { // A human-readable dump of the parameter blocks for debugging. // TODO(keir): If necessary, also dump the residual blocks. - string ToString() const; + std::string ToString() const; private: // Remove constant parameter blocks and residual blocks with no @@ -174,13 +175,13 @@ class Program { // // If there was a problem, then the function will return false and // error will contain a human readable description of the problem. - bool RemoveFixedBlocks(vector<double*>* removed_parameter_blocks, + bool RemoveFixedBlocks(std::vector<double*>* removed_parameter_blocks, double* fixed_cost, - string* message); + std::string* message); // The Program does not own the ParameterBlock or ResidualBlock objects. - vector<ParameterBlock*> parameter_blocks_; - vector<ResidualBlock*> residual_blocks_; + std::vector<ParameterBlock*> parameter_blocks_; + std::vector<ResidualBlock*> residual_blocks_; friend class ProblemImpl; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/program_evaluator.h b/extern/libmv/third_party/ceres/internal/ceres/program_evaluator.h index 672c233b379..74a812adeef 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/program_evaluator.h +++ b/extern/libmv/third_party/ceres/internal/ceres/program_evaluator.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -116,9 +116,13 @@ class ProgramEvaluator : public Evaluator { evaluate_preparers_( jacobian_writer_.CreateEvaluatePreparers(options.num_threads)) { #ifndef CERES_USE_OPENMP - CHECK_EQ(1, options_.num_threads) - << "OpenMP support is not compiled into this binary; " - << "only options.num_threads=1 is supported."; + if (options_.num_threads > 1) { + LOG(WARNING) + << "OpenMP support is not compiled into this binary; " + << "only options.num_threads = 1 is supported. Switching " + << "to single threaded mode."; + options_.num_threads = 1; + } #endif BuildResidualLayout(*program, &residual_layout_); @@ -297,11 +301,11 @@ class ProgramEvaluator : public Evaluator { return program_->NumResiduals(); } - virtual map<string, int> CallStatistics() const { + virtual std::map<std::string, int> CallStatistics() const { return execution_summary_.calls(); } - virtual map<string, double> TimeStatistics() const { + virtual std::map<std::string, double> TimeStatistics() const { return execution_summary_.times(); } @@ -332,8 +336,9 @@ class ProgramEvaluator : public Evaluator { }; static void BuildResidualLayout(const Program& program, - vector<int>* residual_layout) { - const vector<ResidualBlock*>& residual_blocks = program.residual_blocks(); + std::vector<int>* residual_layout) { + const std::vector<ResidualBlock*>& residual_blocks = + program.residual_blocks(); residual_layout->resize(program.NumResidualBlocks()); int residual_pos = 0; for (int i = 0; i < residual_blocks.size(); ++i) { @@ -369,7 +374,7 @@ class ProgramEvaluator : public Evaluator { JacobianWriter jacobian_writer_; scoped_array<EvaluatePreparer> evaluate_preparers_; scoped_array<EvaluateScratch> evaluate_scratch_; - vector<int> residual_layout_; + std::vector<int> residual_layout_; ::ceres::internal::ExecutionSummary execution_summary_; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/random.h b/extern/libmv/third_party/ceres/internal/ceres/random.h index 352c0032b5a..2a025600609 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/random.h +++ b/extern/libmv/third_party/ceres/internal/ceres/random.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/reorder_program.cc b/extern/libmv/third_party/ceres/internal/ceres/reorder_program.cc index aa3d4cec396..d0e8f32b3b7 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/reorder_program.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/reorder_program.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -56,6 +56,12 @@ namespace ceres { namespace internal { + +using std::map; +using std::set; +using std::string; +using std::vector; + namespace { // Find the minimum index of any parameter block to the given @@ -87,7 +93,7 @@ Eigen::SparseMatrix<int> CreateBlockJacobian( const int* rows = block_jacobian_transpose.rows(); const int* cols = block_jacobian_transpose.cols(); int num_nonzeros = block_jacobian_transpose.num_nonzeros(); - std::vector<Triplet> triplets; + vector<Triplet> triplets; triplets.reserve(num_nonzeros); for (int i = 0; i < num_nonzeros; ++i) { triplets.push_back(Triplet(cols[i], rows[i], 1)); @@ -126,6 +132,11 @@ void OrderingForSparseNormalCholeskyUsingSuiteSparse( parameter_block_ordering.GroupId( parameter_blocks[i]->mutable_user_state())); } + + // Renumber the entries of constraints to be contiguous integers + // as CAMD requires that the group ids be in the range [0, + // parameter_blocks.size() - 1]. + MapValuesToContiguousRange(constraints.size(), &constraints[0]); ss.ConstrainedApproximateMinimumDegreeOrdering(block_jacobian_transpose, &constraints[0], ordering); @@ -217,9 +228,7 @@ bool ApplyOrdering(const ProblemImpl::ParameterMap& parameter_map, program->mutable_parameter_blocks(); parameter_blocks->clear(); - const map<int, set<double*> >& groups = - ordering.group_to_elements(); - + const map<int, set<double*> >& groups = ordering.group_to_elements(); for (map<int, set<double*> >::const_iterator group_it = groups.begin(); group_it != groups.end(); ++group_it) { @@ -344,8 +353,8 @@ void MaybeReorderSchurComplementColumnsUsingSuiteSparse( parameter_blocks[i]->mutable_user_state())); } - // Renumber the entries of constraints to be contiguous integers - // as camd requires that the group ids be in the range [0, + // Renumber the entries of constraints to be contiguous integers as + // CAMD requires that the group ids be in the range [0, // parameter_blocks.size() - 1]. MapValuesToContiguousRange(constraints.size(), &constraints[0]); @@ -531,6 +540,15 @@ bool ReorderProgramForSparseNormalCholesky( const ParameterBlockOrdering& parameter_block_ordering, Program* program, string* error) { + if (parameter_block_ordering.NumElements() != program->NumParameterBlocks()) { + *error = StringPrintf( + "The program has %d parameter blocks, but the parameter block " + "ordering has %d parameter blocks.", + program->NumParameterBlocks(), + parameter_block_ordering.NumElements()); + return false; + } + // Compute a block sparse presentation of J'. scoped_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose( program->CreateJacobianBlockSparsityTranspose()); diff --git a/extern/libmv/third_party/ceres/internal/ceres/reorder_program.h b/extern/libmv/third_party/ceres/internal/ceres/reorder_program.h index 0474c1fb912..36e5d1637a9 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/reorder_program.h +++ b/extern/libmv/third_party/ceres/internal/ceres/reorder_program.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -46,14 +46,14 @@ class Program; bool ApplyOrdering(const ProblemImpl::ParameterMap& parameter_map, const ParameterBlockOrdering& ordering, Program* program, - string* error); + std::string* error); // Reorder the residuals for program, if necessary, so that the residuals // involving each E block occur together. This is a necessary condition for the // Schur eliminator, which works on these "row blocks" in the jacobian. bool LexicographicallyOrderResidualBlocks(int size_of_first_elimination_group, Program* program, - string* error); + std::string* error); // Schur type solvers require that all parameter blocks eliminated // by the Schur eliminator occur before others and the residuals be @@ -77,7 +77,7 @@ bool ReorderProgramForSchurTypeLinearSolver( const ProblemImpl::ParameterMap& parameter_map, ParameterBlockOrdering* parameter_block_ordering, Program* program, - string* error); + std::string* error); // Sparse cholesky factorization routines when doing the sparse // cholesky factorization of the Jacobian matrix, reorders its @@ -93,7 +93,7 @@ bool ReorderProgramForSparseNormalCholesky( SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type, const ParameterBlockOrdering& parameter_block_ordering, Program* program, - string* error); + std::string* error); } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/residual_block.cc b/extern/libmv/third_party/ceres/internal/ceres/residual_block.cc index 621082ac0ea..9a123cf132e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/residual_block.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/residual_block.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -49,10 +49,11 @@ using Eigen::Dynamic; namespace ceres { namespace internal { -ResidualBlock::ResidualBlock(const CostFunction* cost_function, - const LossFunction* loss_function, - const vector<ParameterBlock*>& parameter_blocks, - int index) +ResidualBlock::ResidualBlock( + const CostFunction* cost_function, + const LossFunction* loss_function, + const std::vector<ParameterBlock*>& parameter_blocks, + int index) : cost_function_(cost_function), loss_function_(loss_function), parameter_blocks_( @@ -116,7 +117,7 @@ bool ResidualBlock::Evaluate(const bool apply_loss_function, cost, residuals, eval_jacobians)) { - string message = + std::string message = "\n\n" "Error in evaluating the ResidualBlock.\n\n" "There are two possible reasons. Either the CostFunction did not evaluate and fill all \n" // NOLINT diff --git a/extern/libmv/third_party/ceres/internal/ceres/residual_block.h b/extern/libmv/third_party/ceres/internal/ceres/residual_block.h index 9c3671bb0a4..05e6d1f81e5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/residual_block.h +++ b/extern/libmv/third_party/ceres/internal/ceres/residual_block.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -71,7 +71,7 @@ class ResidualBlock { // residual_blocks array. ResidualBlock(const CostFunction* cost_function, const LossFunction* loss_function, - const vector<ParameterBlock*>& parameter_blocks, + const std::vector<ParameterBlock*>& parameter_blocks, int index); // Evaluates the residual term, storing the scalar cost in *cost, the residual @@ -127,7 +127,7 @@ class ResidualBlock { int index() const { return index_; } void set_index(int index) { index_ = index; } - string ToString() { + std::string ToString() { return StringPrintf("{residual block; index=%d}", index_); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.cc b/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.cc index d2564a7692e..dd2bd73a6ac 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -44,6 +44,8 @@ namespace ceres { namespace internal { +using std::string; + void InvalidateEvaluation(const ResidualBlock& block, double* cost, double* residuals, diff --git a/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.h b/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.h index 7051c2112fd..627337f743c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.h +++ b/extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -68,11 +68,11 @@ bool IsEvaluationValid(const ResidualBlock& block, // Create a string representation of the Residual block containing the // value of the parameters, residuals and jacobians if present. // Useful for debugging output. -string EvaluationToString(const ResidualBlock& block, - double const* const* parameters, - double* cost, - double* residuals, - double** jacobians); +std::string EvaluationToString(const ResidualBlock& block, + double const* const* parameters, + double* cost, + double* residuals, + double** jacobians); } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.cc index 33f812b8c96..2491060dcdc 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -57,10 +57,16 @@ namespace ceres { namespace internal { + +using std::make_pair; +using std::pair; +using std::set; +using std::vector; + namespace { class BlockRandomAccessSparseMatrixAdapter : public LinearOperator { - public: + public: explicit BlockRandomAccessSparseMatrixAdapter( const BlockRandomAccessSparseMatrix& m) : m_(m) { @@ -86,7 +92,7 @@ class BlockRandomAccessSparseMatrixAdapter : public LinearOperator { }; class BlockRandomAccessDiagonalMatrixAdapter : public LinearOperator { - public: + public: explicit BlockRandomAccessDiagonalMatrixAdapter( const BlockRandomAccessDiagonalMatrix& m) : m_(m) { @@ -130,7 +136,7 @@ LinearSolver::Summary SchurComplementSolver::SolveImpl( eliminator_.reset(CHECK_NOTNULL(SchurEliminatorBase::Create(options_))); eliminator_->Init(options_.elimination_groups[0], A->block_structure()); }; - fill(x, x + A->num_cols(), 0.0); + std::fill(x, x + A->num_cols(), 0.0); event_logger.AddEvent("Setup"); eliminator_->Eliminate(A, b, per_solve_options.D, lhs_.get(), rhs_.get()); diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.h b/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.h index 93d23e3d012..714dafc5b0c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -188,7 +188,7 @@ class SparseSchurComplementSolver : public SchurComplementSolver { double* solution); // Size of the blocks in the Schur complement. - vector<int> blocks_; + std::vector<int> blocks_; SuiteSparse ss_; // Symbolic factorization of the reduced linear system. Precomputed diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.cc b/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.cc index 4d9b175b139..ec0e2a020e5 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -82,6 +82,11 @@ SchurEliminatorBase::Create(const LinearSolver::Options& options) { } if ((options.row_block_size == 2) && (options.e_block_size == 3) && + (options.f_block_size == 6)) { + return new SchurEliminator<2, 3, 6>(options); + } + if ((options.row_block_size == 2) && + (options.e_block_size == 3) && (options.f_block_size == 9)) { return new SchurEliminator<2, 3, 9>(options); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.h b/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.h index 8fe8b9c88b7..761b58adc7f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.h +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -263,7 +263,7 @@ class SchurEliminator : public SchurEliminatorBase { // buffer_layout[z1] = 0 // buffer_layout[z5] = y1 * z1 // buffer_layout[z2] = y1 * z1 + y1 * z5 - typedef map<int, int> BufferLayoutType; + typedef std::map<int, int> BufferLayoutType; struct Chunk { Chunk() : size(0) {} int size; @@ -315,11 +315,11 @@ class SchurEliminator : public SchurEliminatorBase { // position of each f block in the row/col of the reduced linear // system. Thus lhs_row_layout_[i] is the row/col position of the // i^th f block. - vector<int> lhs_row_layout_; + std::vector<int> lhs_row_layout_; // Combinatorial structure of the chunks in A. For more information // see the documentation of the Chunk object above. - vector<Chunk> chunks_; + std::vector<Chunk> chunks_; // TODO(sameeragarwal): The following two arrays contain per-thread // storage. They should be refactored into a per thread struct. @@ -346,7 +346,7 @@ class SchurEliminator : public SchurEliminatorBase { // Locks for the blocks in the right hand side of the reduced linear // system. - vector<Mutex*> rhs_locks_; + std::vector<Mutex*> rhs_locks_; }; } // namespace internal diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator_impl.h b/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator_impl.h index 305d94e8cc7..f2535880f15 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator_impl.h +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_eliminator_impl.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -139,7 +139,7 @@ Init(int num_eliminate_blocks, const CompressedRowBlockStructure* bs) { } } - buffer_size_ = max(buffer_size, buffer_size_); + buffer_size_ = std::max(buffer_size, buffer_size_); ++chunk.size; } @@ -194,7 +194,7 @@ Eliminate(const BlockSparseMatrix* A, &row_stride, &col_stride); if (cell_info != NULL) { const int block_size = bs->cols[i].size; - typename EigenTypes<kFBlockSize>::ConstVectorRef + typename EigenTypes<Eigen::Dynamic>::ConstVectorRef diag(D + bs->cols[i].position, block_size); CeresMutexLock l(&cell_info->m); @@ -205,20 +205,19 @@ Eliminate(const BlockSparseMatrix* A, } } - // Eliminate y blocks one chunk at a time. For each chunk,x3 - // compute the entries of the normal equations and the gradient - // vector block corresponding to the y block and then apply - // Gaussian elimination to them. The matrix ete stores the normal - // matrix corresponding to the block being eliminated and array - // buffer_ contains the non-zero blocks in the row corresponding - // to this y block in the normal equations. This computation is - // done in ChunkDiagonalBlockAndGradient. UpdateRhs then applies - // gaussian elimination to the rhs of the normal equations, - // updating the rhs of the reduced linear system by modifying rhs - // blocks for all the z blocks that share a row block/residual - // term with the y block. EliminateRowOuterProduct does the - // corresponding operation for the lhs of the reduced linear - // system. + // Eliminate y blocks one chunk at a time. For each chunk, compute + // the entries of the normal equations and the gradient vector block + // corresponding to the y block and then apply Gaussian elimination + // to them. The matrix ete stores the normal matrix corresponding to + // the block being eliminated and array buffer_ contains the + // non-zero blocks in the row corresponding to this y block in the + // normal equations. This computation is done in + // ChunkDiagonalBlockAndGradient. UpdateRhs then applies gaussian + // elimination to the rhs of the normal equations, updating the rhs + // of the reduced linear system by modifying rhs blocks for all the + // z blocks that share a row block/residual term with the y + // block. EliminateRowOuterProduct does the corresponding operation + // for the lhs of the reduced linear system. #pragma omp parallel for num_threads(num_threads_) schedule(dynamic) for (int i = 0; i < chunks_.size(); ++i) { #ifdef CERES_USE_OPENMP @@ -594,8 +593,8 @@ template <int kRowBlockSize, int kEBlockSize, int kFBlockSize> void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>:: NoEBlockRowOuterProduct(const BlockSparseMatrix* A, - int row_block_index, - BlockRandomAccessMatrix* lhs) { + int row_block_index, + BlockRandomAccessMatrix* lhs) { const CompressedRowBlockStructure* bs = A->block_structure(); const CompressedRow& row = bs->rows[row_block_index]; const double* values = A->values(); diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.cc b/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.cc index cbdb7086102..3e6cc90f63c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -54,7 +54,7 @@ SchurJacobiPreconditioner::SchurJacobiPreconditioner( << "Jacobian should have atleast 1 f_block for " << "SCHUR_JACOBI preconditioner."; - vector<int> blocks(num_blocks); + std::vector<int> blocks(num_blocks); for (int i = 0; i < num_blocks; ++i) { blocks[i] = bs.cols[i + options_.elimination_groups[0]].size; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.h b/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.h index 8b528e25075..5398f3ff35d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.h +++ b/extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.cc b/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.cc index 6f0ceefd87d..f01ef11c26f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.h b/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.h index 6b127081976..fa9ebd0e50e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.cc b/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.cc index f0f7e0e1e06..490fcd87cad 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.h b/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.h index 79c4da114c2..fb02f01de45 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.h +++ b/extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/small_blas.h b/extern/libmv/third_party/ceres/internal/ceres/small_blas.h index 5639664b925..264ac53047d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/small_blas.h +++ b/extern/libmv/third_party/ceres/internal/ceres/small_blas.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -73,7 +73,7 @@ namespace internal { DCHECK((kColB == Eigen::Dynamic) || (kColB == num_col_b)); \ const int NUM_ROW_A = (kRowA != Eigen::Dynamic ? kRowA : num_row_a); \ const int NUM_COL_A = (kColA != Eigen::Dynamic ? kColA : num_col_a); \ - const int NUM_ROW_B = (kColB != Eigen::Dynamic ? kRowB : num_row_b); \ + const int NUM_ROW_B = (kRowB != Eigen::Dynamic ? kRowB : num_row_b); \ const int NUM_COL_B = (kColB != Eigen::Dynamic ? kColB : num_col_b); #define CERES_GEMM_EIGEN_HEADER \ diff --git a/extern/libmv/third_party/ceres/internal/ceres/solver.cc b/extern/libmv/third_party/ceres/internal/ceres/solver.cc index 3512e156f9e..9f3228bb0be 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -49,6 +49,10 @@ namespace ceres { namespace { +using std::map; +using std::string; +using std::vector; + #define OPTION_OP(x, y, OP) \ if (!(options.x OP y)) { \ std::stringstream ss; \ @@ -150,15 +154,11 @@ bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) { *error = "Can't use DENSE_NORMAL_CHOLESKY with LAPACK because " "LAPACK was not enabled when Ceres was built."; return false; - } - - if (options.linear_solver_type == DENSE_QR) { + } else if (options.linear_solver_type == DENSE_QR) { *error = "Can't use DENSE_QR with LAPACK because " "LAPACK was not enabled when Ceres was built."; return false; - } - - if (options.linear_solver_type == DENSE_SCHUR) { + } else if (options.linear_solver_type == DENSE_SCHUR) { *error = "Can't use DENSE_SCHUR with LAPACK because " "LAPACK was not enabled when Ceres was built."; return false; @@ -172,21 +172,15 @@ bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) { *error = "Can't use SPARSE_NORMAL_CHOLESKY with SUITESPARSE because " "SuiteSparse was not enabled when Ceres was built."; return false; - } - - if (options.linear_solver_type == SPARSE_SCHUR) { + } else if (options.linear_solver_type == SPARSE_SCHUR) { *error = "Can't use SPARSE_SCHUR with SUITESPARSE because " "SuiteSparse was not enabled when Ceres was built."; return false; - } - - if (options.preconditioner_type == CLUSTER_JACOBI) { + } else if (options.preconditioner_type == CLUSTER_JACOBI) { *error = "CLUSTER_JACOBI preconditioner not supported. " "SuiteSparse was not enabled when Ceres was built."; return false; - } - - if (options.preconditioner_type == CLUSTER_TRIDIAGONAL) { + } else if (options.preconditioner_type == CLUSTER_TRIDIAGONAL) { *error = "CLUSTER_TRIDIAGONAL preconditioner not supported. " "SuiteSparse was not enabled when Ceres was built."; return false; @@ -200,9 +194,7 @@ bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) { *error = "Can't use SPARSE_NORMAL_CHOLESKY with CX_SPARSE because " "CXSparse was not enabled when Ceres was built."; return false; - } - - if (options.linear_solver_type == SPARSE_SCHUR) { + } else if (options.linear_solver_type == SPARSE_SCHUR) { *error = "Can't use SPARSE_SCHUR with CX_SPARSE because " "CXSparse was not enabled when Ceres was built."; return false; @@ -217,9 +209,7 @@ bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) { "Eigen's sparse linear algebra was not enabled when Ceres was " "built."; return false; - } - - if (options.linear_solver_type == SPARSE_SCHUR) { + } else if (options.linear_solver_type == SPARSE_SCHUR) { *error = "Can't use SPARSE_SCHUR with EIGEN_SPARSE because " "Eigen's sparse linear algebra was not enabled when Ceres was " "built."; @@ -228,6 +218,18 @@ bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) { } #endif + if (options.sparse_linear_algebra_library_type == NO_SPARSE) { + if (options.linear_solver_type == SPARSE_NORMAL_CHOLESKY) { + *error = "Can't use SPARSE_NORMAL_CHOLESKY as " + "sparse_linear_algebra_library_type is NO_SPARSE."; + return false; + } else if (options.linear_solver_type == SPARSE_SCHUR) { + *error = "Can't use SPARSE_SCHUR as " + "sparse_linear_algebra_library_type is NO_SPARSE."; + return false; + } + } + if (options.trust_region_strategy_type == DOGLEG) { if (options.linear_solver_type == ITERATIVE_SCHUR || options.linear_solver_type == CGNR) { @@ -349,6 +351,10 @@ void PreSolveSummarize(const Solver::Options& options, summary->dense_linear_algebra_library_type = options.dense_linear_algebra_library_type; // NOLINT summary->dogleg_type = options.dogleg_type; summary->inner_iteration_time_in_seconds = 0.0; + summary->line_search_cost_evaluation_time_in_seconds = 0.0; + summary->line_search_gradient_evaluation_time_in_seconds = 0.0; + summary->line_search_polynomial_minimization_time_in_seconds = 0.0; + summary->line_search_total_time_in_seconds = 0.0; summary->inner_iterations_given = options.use_inner_iterations; summary->line_search_direction_type = options.line_search_direction_type; // NOLINT summary->line_search_interpolation_type = options.line_search_interpolation_type; // NOLINT @@ -446,11 +452,16 @@ bool Solver::Options::IsValid(string* error) const { return false; } - if (minimizer_type == TRUST_REGION) { - return TrustRegionOptionsAreValid(*this, error); + if (minimizer_type == TRUST_REGION && + !TrustRegionOptionsAreValid(*this, error)) { + return false; } - CHECK_EQ(minimizer_type, LINE_SEARCH); + // We do not know if the problem is bounds constrained or not, if it + // is then the trust region solver will also use the line search + // solver to do a projection onto the box constraints, so make sure + // that the line search options are checked independent of what + // minimizer algorithm is being used. return LineSearchOptionsAreValid(*this, error); } @@ -553,6 +564,10 @@ Solver::Summary::Summary() residual_evaluation_time_in_seconds(-1.0), jacobian_evaluation_time_in_seconds(-1.0), inner_iteration_time_in_seconds(-1.0), + line_search_cost_evaluation_time_in_seconds(-1.0), + line_search_gradient_evaluation_time_in_seconds(-1.0), + line_search_polynomial_minimization_time_in_seconds(-1.0), + line_search_total_time_in_seconds(-1.0), num_parameter_blocks(-1), num_parameters(-1), num_effective_parameters(-1), @@ -563,6 +578,7 @@ Solver::Summary::Summary() num_effective_parameters_reduced(-1), num_residual_blocks_reduced(-1), num_residuals_reduced(-1), + is_constrained(false), num_threads_given(-1), num_threads_used(-1), num_linear_solver_threads_given(-1), @@ -597,7 +613,7 @@ string Solver::Summary::BriefReport() const { initial_cost, final_cost, TerminationTypeToString(termination_type)); -}; +} string Solver::Summary::FullReport() const { using internal::VersionString; @@ -768,38 +784,55 @@ string Solver::Summary::FullReport() const { num_inner_iteration_steps); } + const bool print_line_search_timing_information = + minimizer_type == LINE_SEARCH || + (minimizer_type == TRUST_REGION && is_constrained); + StringAppendF(&report, "\nTime (in seconds):\n"); - StringAppendF(&report, "Preprocessor %25.3f\n", + StringAppendF(&report, "Preprocessor %25.4f\n", preprocessor_time_in_seconds); - StringAppendF(&report, "\n Residual evaluation %23.3f\n", + StringAppendF(&report, "\n Residual evaluation %23.4f\n", residual_evaluation_time_in_seconds); - StringAppendF(&report, " Jacobian evaluation %23.3f\n", + if (print_line_search_timing_information) { + StringAppendF(&report, " Line search cost evaluation %10.4f\n", + line_search_cost_evaluation_time_in_seconds); + } + StringAppendF(&report, " Jacobian evaluation %23.4f\n", jacobian_evaluation_time_in_seconds); + if (print_line_search_timing_information) { + StringAppendF(&report, " Line search gradient evaluation %6.4f\n", + line_search_gradient_evaluation_time_in_seconds); + } if (minimizer_type == TRUST_REGION) { - StringAppendF(&report, " Linear solver %23.3f\n", + StringAppendF(&report, " Linear solver %23.4f\n", linear_solver_time_in_seconds); } if (inner_iterations_used) { - StringAppendF(&report, " Inner iterations %23.3f\n", + StringAppendF(&report, " Inner iterations %23.4f\n", inner_iteration_time_in_seconds); } - StringAppendF(&report, "Minimizer %25.3f\n\n", + if (print_line_search_timing_information) { + StringAppendF(&report, " Line search polynomial minimization %.4f\n", + line_search_polynomial_minimization_time_in_seconds); + } + + StringAppendF(&report, "Minimizer %25.4f\n\n", minimizer_time_in_seconds); - StringAppendF(&report, "Postprocessor %24.3f\n", + StringAppendF(&report, "Postprocessor %24.4f\n", postprocessor_time_in_seconds); - StringAppendF(&report, "Total %25.3f\n\n", + StringAppendF(&report, "Total %25.4f\n\n", total_time_in_seconds); StringAppendF(&report, "Termination: %25s (%s)\n", TerminationTypeToString(termination_type), message.c_str()); return report; -}; +} bool Solver::Summary::IsSolutionUsable() const { return internal::IsSolutionUsable(*this); diff --git a/extern/libmv/third_party/ceres/internal/ceres/solver_utils.cc b/extern/libmv/third_party/ceres/internal/ceres/solver_utils.cc index bd304e7ac5d..7f4ff7eb940 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/solver_utils.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/solver_utils.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -30,14 +30,22 @@ #include <string> +#include "Eigen/Core" #include "ceres/internal/port.h" +#include "ceres/solver_utils.h" #include "ceres/version.h" namespace ceres { namespace internal { -string VersionString() { - string value = string(CERES_VERSION_STRING); +#define CERES_EIGEN_VERSION \ + CERES_TO_STRING(EIGEN_WORLD_VERSION) "." \ + CERES_TO_STRING(EIGEN_MAJOR_VERSION) "." \ + CERES_TO_STRING(EIGEN_MINOR_VERSION) + +std::string VersionString() { + std::string value = std::string(CERES_VERSION_STRING); + value += "-eigen-(" + std::string(CERES_EIGEN_VERSION) + ")"; #ifdef CERES_NO_LAPACK value += "-no_lapack"; @@ -46,11 +54,11 @@ string VersionString() { #endif #ifndef CERES_NO_SUITESPARSE - value += "-suitesparse"; + value += "-suitesparse-(" + std::string(CERES_SUITESPARSE_VERSION) + ")"; #endif #ifndef CERES_NO_CXSPARSE - value += "-cxsparse"; + value += "-cxsparse-(" + std::string(CERES_CXSPARSE_VERSION) + ")"; #endif #ifdef CERES_USE_EIGEN_SPARSE diff --git a/extern/libmv/third_party/ceres/internal/ceres/solver_utils.h b/extern/libmv/third_party/ceres/internal/ceres/solver_utils.h index 41c8a6e1292..85fbf3776ab 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/solver_utils.h +++ b/extern/libmv/third_party/ceres/internal/ceres/solver_utils.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -31,6 +31,9 @@ #include <algorithm> #include <string> +#include "ceres/iteration_callback.h" +#include "ceres/types.h" + namespace ceres { namespace internal { @@ -48,11 +51,11 @@ void SetSummaryFinalCost(SummaryType* summary) { // iteration because the minimizer maybe making non-monotonic steps. for (int i = 0; i < summary->iterations.size(); ++i) { const IterationSummary& iteration_summary = summary->iterations[i]; - summary->final_cost = min(iteration_summary.cost, summary->final_cost); + summary->final_cost = std::min(iteration_summary.cost, summary->final_cost); } } -string VersionString(); +std::string VersionString(); } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.cc index 55336fd3130..f95ff3220bd 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.h index f3b96712a70..b3af1d06440 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.cc b/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.cc index 94f7e5803c4..ed00879b47a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -57,9 +57,9 @@ namespace { // A templated factorized and solve function, which allows us to use // the same code independent of whether a AMD or a Natural ordering is // used. -template <typename SimplicialCholeskySolver> +template <typename SimplicialCholeskySolver, typename SparseMatrixType> LinearSolver::Summary SimplicialLDLTSolve( - Eigen::MappedSparseMatrix<double, Eigen::ColMajor>& lhs, + const SparseMatrixType& lhs, const bool do_symbolic_analysis, SimplicialCholeskySolver* solver, double* rhs_and_solution, @@ -103,6 +103,53 @@ LinearSolver::Summary SimplicialLDLTSolve( #endif // CERES_USE_EIGEN_SPARSE +#ifndef CERES_NO_CXSPARSE +LinearSolver::Summary ComputeNormalEquationsAndSolveUsingCXSparse( + CompressedRowSparseMatrix* A, + double * rhs_and_solution, + EventLogger* event_logger) { + LinearSolver::Summary summary; + summary.num_iterations = 1; + summary.termination_type = LINEAR_SOLVER_SUCCESS; + summary.message = "Success."; + + CXSparse cxsparse; + + // Wrap the augmented Jacobian in a compressed sparse column matrix. + cs_di a_transpose = cxsparse.CreateSparseMatrixTransposeView(A); + + // Compute the normal equations. J'J delta = J'f and solve them + // using a sparse Cholesky factorization. Notice that when compared + // to SuiteSparse we have to explicitly compute the transpose of Jt, + // and then the normal equations before they can be + // factorized. CHOLMOD/SuiteSparse on the other hand can just work + // off of Jt to compute the Cholesky factorization of the normal + // equations. + cs_di* a = cxsparse.TransposeMatrix(&a_transpose); + cs_di* lhs = cxsparse.MatrixMatrixMultiply(&a_transpose, a); + cxsparse.Free(a); + event_logger->AddEvent("NormalEquations"); + + cs_dis* factor = cxsparse.AnalyzeCholesky(lhs); + event_logger->AddEvent("Analysis"); + + if (factor == NULL) { + summary.termination_type = LINEAR_SOLVER_FATAL_ERROR; + summary.message = "CXSparse::AnalyzeCholesky failed."; + } else if (!cxsparse.SolveCholesky(lhs, factor, rhs_and_solution)) { + summary.termination_type = LINEAR_SOLVER_FAILURE; + summary.message = "CXSparse::SolveCholesky failed."; + } + event_logger->AddEvent("Solve"); + + cxsparse.Free(lhs); + cxsparse.Free(factor); + event_logger->AddEvent("TearDown"); + return summary; +} + +#endif // CERES_NO_CXSPARSE + } // namespace SparseNormalCholeskySolver::SparseNormalCholeskySolver( @@ -155,13 +202,13 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImpl( LinearSolver::Summary summary; switch (options_.sparse_linear_algebra_library_type) { case SUITE_SPARSE: - summary = SolveImplUsingSuiteSparse(A, per_solve_options, x); + summary = SolveImplUsingSuiteSparse(A, x); break; case CX_SPARSE: - summary = SolveImplUsingCXSparse(A, per_solve_options, x); + summary = SolveImplUsingCXSparse(A, x); break; case EIGEN_SPARSE: - summary = SolveImplUsingEigen(A, per_solve_options, x); + summary = SolveImplUsingEigen(A, x); break; default: LOG(FATAL) << "Unknown sparse linear algebra library : " @@ -177,7 +224,6 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImpl( LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingEigen( CompressedRowSparseMatrix* A, - const LinearSolver::PerSolveOptions& per_solve_options, double * rhs_and_solution) { #ifndef CERES_USE_EIGEN_SPARSE @@ -200,9 +246,28 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingEigen( // before they can be factorized. CHOLMOD/SuiteSparse on the other // hand can just work off of Jt to compute the Cholesky // factorization of the normal equations. - // - // TODO(sameeragarwal): See note about how this maybe a bad idea for - // dynamic sparsity. + + if (options_.dynamic_sparsity) { + // In the case where the problem has dynamic sparsity, it is not + // worth using the ComputeOuterProduct routine, as the setup cost + // is not amortized over multiple calls to Solve. + Eigen::MappedSparseMatrix<double, Eigen::RowMajor> a( + A->num_rows(), + A->num_cols(), + A->num_nonzeros(), + A->mutable_rows(), + A->mutable_cols(), + A->mutable_values()); + + Eigen::SparseMatrix<double> lhs = a.transpose() * a; + Eigen::SimplicialLDLT<Eigen::SparseMatrix<double> > solver; + return SimplicialLDLTSolve(lhs, + true, + &solver, + rhs_and_solution, + &event_logger); + } + if (outer_product_.get() == NULL) { outer_product_.reset( CompressedRowSparseMatrix::CreateOuterProductMatrixAndProgram( @@ -217,7 +282,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingEigen( // outer_product_ is a compressed row sparse matrix and in lower // triangular form, when mapped to a compressed column sparse // matrix, it becomes an upper triangular matrix. - Eigen::MappedSparseMatrix<double, Eigen::ColMajor> AtA( + Eigen::MappedSparseMatrix<double, Eigen::ColMajor> lhs( outer_product_->num_rows(), outer_product_->num_rows(), outer_product_->num_nonzeros(), @@ -225,27 +290,19 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingEigen( outer_product_->mutable_cols(), outer_product_->mutable_values()); - // Dynamic sparsity means that we cannot depend on a static analysis - // of sparsity structure of the jacobian, so we compute a new - // symbolic factorization every time. - if (options_.dynamic_sparsity) { - amd_ldlt_.reset(NULL); - } - bool do_symbolic_analysis = false; - // If using post ordering or dynamic sparsity, or an old version of - // Eigen, we cannot depend on a preordered jacobian, so we work with - // a SimplicialLDLT decomposition with AMD ordering. + // If using post ordering or an old version of Eigen, we cannot + // depend on a preordered jacobian, so we work with a SimplicialLDLT + // decomposition with AMD ordering. if (options_.use_postordering || - options_.dynamic_sparsity || !EIGEN_VERSION_AT_LEAST(3, 2, 2)) { if (amd_ldlt_.get() == NULL) { amd_ldlt_.reset(new SimplicialLDLTWithAMDOrdering); do_symbolic_analysis = true; } - return SimplicialLDLTSolve(AtA, + return SimplicialLDLTSolve(lhs, do_symbolic_analysis, amd_ldlt_.get(), rhs_and_solution, @@ -259,7 +316,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingEigen( do_symbolic_analysis = true; } - return SimplicialLDLTSolve(AtA, + return SimplicialLDLTSolve(lhs, do_symbolic_analysis, natural_ldlt_.get(), rhs_and_solution, @@ -269,11 +326,8 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingEigen( #endif // EIGEN_USE_EIGEN_SPARSE } - - LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse( CompressedRowSparseMatrix* A, - const LinearSolver::PerSolveOptions& per_solve_options, double * rhs_and_solution) { #ifdef CERES_NO_CXSPARSE @@ -290,6 +344,11 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse( #else EventLogger event_logger("SparseNormalCholeskySolver::CXSparse::Solve"); + if (options_.dynamic_sparsity) { + return ComputeNormalEquationsAndSolveUsingCXSparse(A, + rhs_and_solution, + &event_logger); + } LinearSolver::Summary summary; summary.num_iterations = 1; @@ -302,10 +361,6 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse( // before they can be factorized. CHOLMOD/SuiteSparse on the other // hand can just work off of Jt to compute the Cholesky // factorization of the normal equations. - // - // TODO(sameeragarwal): If dynamic sparsity is enabled, then this is - // not a good idea performance wise, since the jacobian has far too - // many entries and the program will go crazy with memory. if (outer_product_.get() == NULL) { outer_product_.reset( CompressedRowSparseMatrix::CreateOuterProductMatrixAndProgram( @@ -314,27 +369,19 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse( CompressedRowSparseMatrix::ComputeOuterProduct( *A, pattern_, outer_product_.get()); - cs_di AtA_view = + cs_di lhs = cxsparse_.CreateSparseMatrixTransposeView(outer_product_.get()); - cs_di* AtA = &AtA_view; event_logger.AddEvent("Setup"); // Compute symbolic factorization if not available. - if (options_.dynamic_sparsity) { - FreeFactorization(); - } if (cxsparse_factor_ == NULL) { if (options_.use_postordering) { - cxsparse_factor_ = cxsparse_.BlockAnalyzeCholesky(AtA, + cxsparse_factor_ = cxsparse_.BlockAnalyzeCholesky(&lhs, A->col_blocks(), A->col_blocks()); } else { - if (options_.dynamic_sparsity) { - cxsparse_factor_ = cxsparse_.AnalyzeCholesky(AtA); - } else { - cxsparse_factor_ = cxsparse_.AnalyzeCholeskyWithNaturalOrdering(AtA); - } + cxsparse_factor_ = cxsparse_.AnalyzeCholeskyWithNaturalOrdering(&lhs); } } event_logger.AddEvent("Analysis"); @@ -343,7 +390,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse( summary.termination_type = LINEAR_SOLVER_FATAL_ERROR; summary.message = "CXSparse failure. Unable to find symbolic factorization."; - } else if (!cxsparse_.SolveCholesky(AtA, + } else if (!cxsparse_.SolveCholesky(&lhs, cxsparse_factor_, rhs_and_solution)) { summary.termination_type = LINEAR_SOLVER_FAILURE; @@ -357,7 +404,6 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse( LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingSuiteSparse( CompressedRowSparseMatrix* A, - const LinearSolver::PerSolveOptions& per_solve_options, double * rhs_and_solution) { #ifdef CERES_NO_SUITESPARSE @@ -385,6 +431,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingSuiteSparse( if (options_.dynamic_sparsity) { FreeFactorization(); } + if (factor_ == NULL) { if (options_.use_postordering) { factor_ = ss_.BlockAnalyzeCholesky(&lhs, diff --git a/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.h b/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.h index 12c05245075..2a93bc56d29 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.h +++ b/extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -69,19 +69,15 @@ class SparseNormalCholeskySolver : public CompressedRowSparseMatrixSolver { LinearSolver::Summary SolveImplUsingSuiteSparse( CompressedRowSparseMatrix* A, - const LinearSolver::PerSolveOptions& options, double* rhs_and_solution); - // Crashes if CSparse is not installed. + LinearSolver::Summary SolveImplUsingCXSparse( CompressedRowSparseMatrix* A, - const LinearSolver::PerSolveOptions& options, double* rhs_and_solution); - // Crashes if CERES_USE_EIGEN_SPARSE is not defined. LinearSolver::Summary SolveImplUsingEigen( CompressedRowSparseMatrix* A, - const LinearSolver::PerSolveOptions& options, double* rhs_and_solution); void FreeFactorization(); @@ -120,7 +116,7 @@ class SparseNormalCholeskySolver : public CompressedRowSparseMatrixSolver { #endif scoped_ptr<CompressedRowSparseMatrix> outer_product_; - vector<int> pattern_; + std::vector<int> pattern_; const LinearSolver::Options options_; CERES_DISALLOW_COPY_AND_ASSIGN(SparseNormalCholeskySolver); }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/split.cc b/extern/libmv/third_party/ceres/internal/ceres/split.cc index 3edbc281340..296c09a6440 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/split.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/split.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -30,12 +30,17 @@ #include "ceres/split.h" +#include <iterator> #include <string> #include <vector> -#include <iterator> + #include "ceres/internal/port.h" namespace ceres { +namespace internal { + +using std::string; +using std::vector; // If we know how much to allocate for a vector of strings, we can allocate the // vector<string> only once and directly to the right size. This saves in @@ -110,8 +115,9 @@ void SplitStringUsing(const string& full, const char* delim, vector<string>* result) { result->reserve(result->size() + CalculateReserveForVector(full, delim)); - back_insert_iterator< vector<string> > it(*result); + std::back_insert_iterator<vector<string> > it(*result); SplitStringToIteratorUsing(full, delim, it); } +} // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/split.h b/extern/libmv/third_party/ceres/internal/ceres/split.h index 2334d26037f..94b773dee4d 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/split.h +++ b/extern/libmv/third_party/ceres/internal/ceres/split.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2011 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -36,13 +36,15 @@ #include "ceres/internal/port.h" namespace ceres { +namespace internal { // Split a string using one or more character delimiters, presented as a // nul-terminated c string. Append the components to 'result'. If there are // consecutive delimiters, this function skips over all of them. -void SplitStringUsing(const string& full, const char* delim, - vector<string>* res); +void SplitStringUsing(const std::string& full, const char* delim, + std::vector<std::string>* res); +} // namespace internal } // namespace ceres #endif // CERES_INTERNAL_SPLIT_H_ diff --git a/extern/libmv/third_party/ceres/internal/ceres/stl_util.h b/extern/libmv/third_party/ceres/internal/ceres/stl_util.h index 08f15ec8398..0595a4cf2e9 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/stl_util.h +++ b/extern/libmv/third_party/ceres/internal/ceres/stl_util.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/stringprintf.cc b/extern/libmv/third_party/ceres/internal/ceres/stringprintf.cc index 0f85f05e056..d1d8b5fe8ab 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/stringprintf.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/stringprintf.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -41,6 +41,8 @@ namespace ceres { namespace internal { +using std::string; + #ifdef _MSC_VER enum { IS_COMPILER_MSVC = 1 }; #if _MSC_VER < 1800 diff --git a/extern/libmv/third_party/ceres/internal/ceres/stringprintf.h b/extern/libmv/third_party/ceres/internal/ceres/stringprintf.h index cd1be142aed..feeb9c23430 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/stringprintf.h +++ b/extern/libmv/third_party/ceres/internal/ceres/stringprintf.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -63,23 +63,23 @@ namespace internal { #endif // Return a C++ string. -extern string StringPrintf(const char* format, ...) +extern std::string StringPrintf(const char* format, ...) // Tell the compiler to do printf format string checking. CERES_PRINTF_ATTRIBUTE(1, 2); // Store result into a supplied string and return it. -extern const string& SStringPrintf(string* dst, const char* format, ...) +extern const std::string& SStringPrintf(std::string* dst, const char* format, ...) // Tell the compiler to do printf format string checking. CERES_PRINTF_ATTRIBUTE(2, 3); // Append result to a supplied string. -extern void StringAppendF(string* dst, const char* format, ...) +extern void StringAppendF(std::string* dst, const char* format, ...) // Tell the compiler to do printf format string checking. CERES_PRINTF_ATTRIBUTE(2, 3); // Lower-level routine that takes a va_list and appends to a specified string. // All other routines are just convenience wrappers around it. -extern void StringAppendV(string* dst, const char* format, va_list ap); +extern void StringAppendV(std::string* dst, const char* format, va_list ap); #undef CERES_PRINTF_ATTRIBUTE diff --git a/extern/libmv/third_party/ceres/internal/ceres/suitesparse.cc b/extern/libmv/third_party/ceres/internal/ceres/suitesparse.cc index 1df7566e00a..200daa2d8bf 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/suitesparse.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/suitesparse.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -44,6 +44,9 @@ namespace ceres { namespace internal { +using std::string; +using std::vector; + SuiteSparse::SuiteSparse() { cholmod_start(&cc_); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/suitesparse.h b/extern/libmv/third_party/ceres/internal/ceres/suitesparse.h index baab8998b29..380d76e003a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/suitesparse.h +++ b/extern/libmv/third_party/ceres/internal/ceres/suitesparse.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -42,7 +42,6 @@ #include <string> #include <vector> -#include "ceres/internal/port.h" #include "ceres/linear_solver.h" #include "cholmod.h" #include "glog/logging.h" @@ -144,12 +143,12 @@ class SuiteSparse { // message contains an explanation of the failures if any. // // Caller owns the result. - cholmod_factor* AnalyzeCholesky(cholmod_sparse* A, string* message); + cholmod_factor* AnalyzeCholesky(cholmod_sparse* A, std::string* message); cholmod_factor* BlockAnalyzeCholesky(cholmod_sparse* A, - const vector<int>& row_blocks, - const vector<int>& col_blocks, - string* message); + const std::vector<int>& row_blocks, + const std::vector<int>& col_blocks, + std::string* message); // If A is symmetric, then compute the symbolic Cholesky // factorization of A(ordering, ordering). If A is unsymmetric, then @@ -162,9 +161,10 @@ class SuiteSparse { // message contains an explanation of the failures if any. // // Caller owns the result. - cholmod_factor* AnalyzeCholeskyWithUserOrdering(cholmod_sparse* A, - const vector<int>& ordering, - string* message); + cholmod_factor* AnalyzeCholeskyWithUserOrdering( + cholmod_sparse* A, + const std::vector<int>& ordering, + std::string* message); // Perform a symbolic factorization of A without re-ordering A. No // postordering of the elimination tree is performed. This ensures @@ -173,7 +173,7 @@ class SuiteSparse { // // message contains an explanation of the failures if any. cholmod_factor* AnalyzeCholeskyWithNaturalOrdering(cholmod_sparse* A, - string* message); + std::string* message); // Use the symbolic factorization in L, to find the numerical // factorization for the matrix A or AA^T. Return true if @@ -183,14 +183,14 @@ class SuiteSparse { // message contains an explanation of the failures if any. LinearSolverTerminationType Cholesky(cholmod_sparse* A, cholmod_factor* L, - string* message); + std::string* message); // Given a Cholesky factorization of a matrix A = LL^T, solve the // linear system Ax = b, and return the result. If the Solve fails // NULL is returned. Caller owns the result. // // message contains an explanation of the failures if any. - cholmod_dense* Solve(cholmod_factor* L, cholmod_dense* b, string* message); + cholmod_dense* Solve(cholmod_factor* L, cholmod_dense* b, std::string* message); // By virtue of the modeling layer in Ceres being block oriented, // all the matrices used by Ceres are also block oriented. When @@ -215,9 +215,9 @@ class SuiteSparse { // A. If this is the case, only the first sum(col_blocks) are used // to compute the ordering. bool BlockAMDOrdering(const cholmod_sparse* A, - const vector<int>& row_blocks, - const vector<int>& col_blocks, - vector<int>* ordering); + const std::vector<int>& row_blocks, + const std::vector<int>& col_blocks, + std::vector<int>* ordering); // Find a fill reducing approximate minimum degree // ordering. ordering is expected to be large enough to hold the @@ -236,7 +236,7 @@ class SuiteSparse { // being conservative and choosing the next minor version where // things are stable. static bool IsConstrainedApproximateMinimumDegreeOrderingAvailable() { - return (SUITESPARSE_VERSION>4001); + return (SUITESPARSE_VERSION > 4001); } // Find a fill reducing approximate minimum degree @@ -260,15 +260,15 @@ class SuiteSparse { void Free(cholmod_dense* m) { cholmod_free_dense(&m, &cc_); } void Free(cholmod_factor* m) { cholmod_free_factor(&m, &cc_); } - void Print(cholmod_sparse* m, const string& name) { + void Print(cholmod_sparse* m, const std::string& name) { cholmod_print_sparse(m, const_cast<char*>(name.c_str()), &cc_); } - void Print(cholmod_dense* m, const string& name) { + void Print(cholmod_dense* m, const std::string& name) { cholmod_print_dense(m, const_cast<char*>(name.c_str()), &cc_); } - void Print(cholmod_triplet* m, const string& name) { + void Print(cholmod_triplet* m, const std::string& name) { cholmod_print_triplet(m, const_cast<char*>(name.c_str()), &cc_); } @@ -298,7 +298,7 @@ class SuiteSparse { return false; } - void Free(void*) {}; + void Free(void* arg) {} }; #endif // CERES_NO_SUITESPARSE diff --git a/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.cc b/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.cc index 824b123bc28..8df405ca115 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -128,7 +128,7 @@ void TripletSparseMatrix::Reserve(int new_max_num_nonzeros) { } void TripletSparseMatrix::SetZero() { - fill(values_.get(), values_.get() + max_num_nonzeros_, 0.0); + std::fill(values_.get(), values_.get() + max_num_nonzeros_, 0.0); num_nonzeros_ = 0; } @@ -136,7 +136,7 @@ void TripletSparseMatrix::set_num_nonzeros(int num_nonzeros) { CHECK_GE(num_nonzeros, 0); CHECK_LE(num_nonzeros, max_num_nonzeros_); num_nonzeros_ = num_nonzeros; -}; +} void TripletSparseMatrix::AllocateMemory() { rows_.reset(new int[max_num_nonzeros_]); diff --git a/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.h b/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.h index 4d7cde7fe9c..f3f5370df6f 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.h +++ b/extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.cc b/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.cc index 926bced6226..d654d0867f1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -31,8 +31,8 @@ #include "ceres/trust_region_minimizer.h" #include <algorithm> -#include <cstdlib> #include <cmath> +#include <cstdlib> #include <cstring> #include <limits> #include <string> @@ -85,22 +85,14 @@ LineSearch::Summary DoLineSearch(const Minimizer::Options& options, options.max_line_search_step_expansion; line_search_options.function = &line_search_function; - string message; - scoped_ptr<LineSearch> - line_search(CHECK_NOTNULL( - LineSearch::Create(ceres::ARMIJO, - line_search_options, - &message))); + std::string message; + scoped_ptr<LineSearch> line_search( + CHECK_NOTNULL(LineSearch::Create(ceres::ARMIJO, + line_search_options, + &message))); LineSearch::Summary summary; line_search_function.Init(x, delta); - // Try the trust region step. line_search->Search(1.0, cost, gradient.dot(delta), &summary); - if (!summary.success) { - // If that was not successful, try the negative gradient as a - // search direction. - line_search_function.Init(x, -gradient); - line_search->Search(1.0, cost, -gradient.squaredNorm(), &summary); - } return summary; } @@ -148,6 +140,7 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, summary->termination_type = NO_CONVERGENCE; summary->num_successful_steps = 0; summary->num_unsuccessful_steps = 0; + summary->is_constrained = options.is_constrained; const int num_parameters = evaluator->NumParameters(); const int num_effective_parameters = evaluator->NumEffectiveParameters(); @@ -231,6 +224,15 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, options_.gradient_tolerance); summary->termination_type = CONVERGENCE; VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message; + + // Ensure that there is an iteration summary object for iteration + // 0 in Summary::iterations. + iteration_summary.iteration_time_in_seconds = + WallTimeInSeconds() - iteration_start_time; + iteration_summary.cumulative_time_in_seconds = + WallTimeInSeconds() - start_time + + summary->preprocessor_time_in_seconds; + summary->iterations.push_back(iteration_summary); return; } @@ -390,6 +392,16 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, if (use_line_search) { const LineSearch::Summary line_search_summary = DoLineSearch(options, x, gradient, cost, delta, evaluator); + + summary->line_search_cost_evaluation_time_in_seconds += + line_search_summary.cost_evaluation_time_in_seconds; + summary->line_search_gradient_evaluation_time_in_seconds += + line_search_summary.gradient_evaluation_time_in_seconds; + summary->line_search_polynomial_minimization_time_in_seconds += + line_search_summary.polynomial_minimization_time_in_seconds; + summary->line_search_total_time_in_seconds += + line_search_summary.total_time_in_seconds; + if (line_search_summary.success) { delta *= line_search_summary.optimal_step_size; } @@ -398,17 +410,19 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, double new_cost = std::numeric_limits<double>::max(); if (evaluator->Plus(x.data(), delta.data(), x_plus_delta.data())) { if (!evaluator->Evaluate(x_plus_delta.data(), - &new_cost, - NULL, - NULL, - NULL)) { - LOG(WARNING) << "Step failed to evaluate. " - << "Treating it as a step with infinite cost"; - new_cost = numeric_limits<double>::max(); + &new_cost, + NULL, + NULL, + NULL)) { + LOG_IF(WARNING, is_not_silent) + << "Step failed to evaluate. " + << "Treating it as a step with infinite cost"; + new_cost = std::numeric_limits<double>::max(); } } else { - LOG(WARNING) << "x_plus_delta = Plus(x, delta) failed. " - << "Treating it as a step with infinite cost"; + LOG_IF(WARNING, is_not_silent) + << "x_plus_delta = Plus(x, delta) failed. " + << "Treating it as a step with infinite cost"; } if (new_cost < std::numeric_limits<double>::max()) { @@ -475,7 +489,7 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, iteration_summary.cost_change = cost - new_cost; const double absolute_function_tolerance = options_.function_tolerance * cost; - if (fabs(iteration_summary.cost_change) < absolute_function_tolerance) { + if (fabs(iteration_summary.cost_change) <= absolute_function_tolerance) { summary->message = StringPrintf("Function tolerance reached. " "|cost_change|/cost: %e <= %e", @@ -507,7 +521,7 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, // reference iteration, allowing for non-monotonic steps. iteration_summary.relative_decrease = options.use_nonmonotonic_steps - ? max(relative_decrease, historical_relative_decrease) + ? std::max(relative_decrease, historical_relative_decrease) : relative_decrease; // Normally, the quality of a trust region step is measured by @@ -598,19 +612,9 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, } iteration_summary.gradient_max_norm = - (x - projected_gradient_step).lpNorm<Eigen::Infinity>(); + (x - projected_gradient_step).lpNorm<Eigen::Infinity>(); iteration_summary.gradient_norm = (x - projected_gradient_step).norm(); - if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) { - summary->message = StringPrintf("Gradient tolerance reached. " - "Gradient max norm: %e <= %e", - iteration_summary.gradient_max_norm, - options_.gradient_tolerance); - summary->termination_type = CONVERGENCE; - VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message; - return; - } - if (options_.jacobi_scaling) { jacobian->ScaleColumns(scale.data()); } @@ -668,20 +672,42 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options, iteration_summary.cost = cost + summary->fixed_cost; iteration_summary.trust_region_radius = strategy->Radius(); - if (iteration_summary.trust_region_radius < - options_.min_trust_region_radius) { - summary->message = "Termination. Minimum trust region radius reached."; - summary->termination_type = CONVERGENCE; - VLOG_IF(1, is_not_silent) << summary->message; - return; - } - iteration_summary.iteration_time_in_seconds = WallTimeInSeconds() - iteration_start_time; iteration_summary.cumulative_time_in_seconds = WallTimeInSeconds() - start_time + summary->preprocessor_time_in_seconds; summary->iterations.push_back(iteration_summary); + + // If the step was successful, check for the gradient norm + // collapsing to zero, and if the step is unsuccessful then check + // if the trust region radius has collapsed to zero. + // + // For correctness (Number of IterationSummary objects, correct + // final cost, and state update) these convergence tests need to + // be performed at the end of the iteration. + if (iteration_summary.step_is_successful) { + // Gradient norm can only go down in successful steps. + if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) { + summary->message = StringPrintf("Gradient tolerance reached. " + "Gradient max norm: %e <= %e", + iteration_summary.gradient_max_norm, + options_.gradient_tolerance); + summary->termination_type = CONVERGENCE; + VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message; + return; + } + } else { + // Trust region radius can only go down if the step if + // unsuccessful. + if (iteration_summary.trust_region_radius < + options_.min_trust_region_radius) { + summary->message = "Termination. Minimum trust region radius reached."; + summary->termination_type = CONVERGENCE; + VLOG_IF(1, is_not_silent) << summary->message; + return; + } + } } } diff --git a/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.h b/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.h index 9a022843233..ed52c2642d1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.h +++ b/extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.cc b/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.cc index 22ea1ec8c80..4020e4ca115 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -48,12 +48,16 @@ namespace ceres { namespace internal { + +using std::vector; + namespace { ParameterBlockOrdering* CreateDefaultLinearSolverOrdering( const Program& program) { ParameterBlockOrdering* ordering = new ParameterBlockOrdering; - const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks(); + const vector<ParameterBlock*>& parameter_blocks = + program.parameter_blocks(); for (int i = 0; i < parameter_blocks.size(); ++i) { ordering->AddElementToGroup( const_cast<double*>(parameter_blocks[i]->user_state()), 0); @@ -63,7 +67,7 @@ ParameterBlockOrdering* CreateDefaultLinearSolverOrdering( // Check if all the user supplied values in the parameter blocks are // sane or not, and if the program is feasible or not. -bool IsProgramValid(const Program& program, string* error) { +bool IsProgramValid(const Program& program, std::string* error) { return (program.ParameterBlocksAreFinite(error) && program.IsFeasible(error)); } @@ -80,7 +84,7 @@ void AlternateLinearSolverAndPreconditionerForSchurTypeLinearSolver( options->linear_solver_type = LinearSolver::LinearSolverForZeroEBlocks( linear_solver_type_given); - string message; + std::string message; if (linear_solver_type_given == ITERATIVE_SCHUR) { options->preconditioner_type = Preconditioner::PreconditionerForZeroEBlocks( preconditioner_type_given); diff --git a/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.h b/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.h index ba70ff92e73..a6631ab3d40 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.h +++ b/extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.cc b/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.cc index c68269d0449..2db6a6c899b 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012, 2013 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: diff --git a/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.h b/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.h index 998514fbfa5..9560e67459a 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.h +++ b/extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -98,7 +98,7 @@ class TrustRegionStrategy { // name starting with dump_filename_base. If dump_format_type is // CONSOLE then dump_filename_base will be ignored and the linear // system will be written to the standard error. - string dump_filename_base; + std::string dump_filename_base; DumpFormatType dump_format_type; }; diff --git a/extern/libmv/third_party/ceres/internal/ceres/types.cc b/extern/libmv/third_party/ceres/internal/ceres/types.cc index 47102616ee8..f86fb78eb8c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/types.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/types.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -36,6 +36,8 @@ namespace ceres { +using std::string; + #define CASESTR(x) case x: return #x #define STRENUM(x) if (value == #x) { *type = x; return true;} @@ -97,6 +99,7 @@ const char* SparseLinearAlgebraLibraryTypeToString( CASESTR(SUITE_SPARSE); CASESTR(CX_SPARSE); CASESTR(EIGEN_SPARSE); + CASESTR(NO_SPARSE); default: return "UNKNOWN"; } @@ -109,6 +112,7 @@ bool StringToSparseLinearAlgebraLibraryType( STRENUM(SUITE_SPARSE); STRENUM(CX_SPARSE); STRENUM(EIGEN_SPARSE); + STRENUM(NO_SPARSE); return false; } @@ -280,6 +284,27 @@ bool StringToCovarianceAlgorithmType( return false; } +const char* NumericDiffMethodTypeToString( + NumericDiffMethodType type) { + switch (type) { + CASESTR(CENTRAL); + CASESTR(FORWARD); + CASESTR(RIDDERS); + default: + return "UNKNOWN"; + } +} + +bool StringToNumericDiffMethodType( + string value, + NumericDiffMethodType* type) { + UpperCase(&value); + STRENUM(CENTRAL); + STRENUM(FORWARD); + STRENUM(RIDDERS); + return false; +} + const char* VisibilityClusteringTypeToString( VisibilityClusteringType type) { switch (type) { @@ -338,6 +363,14 @@ bool IsSparseLinearAlgebraLibraryTypeAvailable( #endif } + if (type == EIGEN_SPARSE) { +#ifdef CERES_USE_EIGEN_SPARSE + return true; +#else + return false; +#endif + } + LOG(WARNING) << "Unknown sparse linear algebra library " << type; return false; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/visibility.cc b/extern/libmv/third_party/ceres/internal/ceres/visibility.cc index da8beedc663..55b5322aee6 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/visibility.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/visibility.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -49,6 +49,12 @@ namespace ceres { namespace internal { +using std::make_pair; +using std::max; +using std::pair; +using std::set; +using std::vector; + void ComputeVisibility(const CompressedRowBlockStructure& block_structure, const int num_eliminate_blocks, vector< set<int> >* visibility) { diff --git a/extern/libmv/third_party/ceres/internal/ceres/visibility.h b/extern/libmv/third_party/ceres/internal/ceres/visibility.h index 322efe9bea4..142eb2838a1 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/visibility.h +++ b/extern/libmv/third_party/ceres/internal/ceres/visibility.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -59,7 +59,7 @@ struct CompressedRowBlockStructure; // points and f_blocks correspond to cameras. void ComputeVisibility(const CompressedRowBlockStructure& block_structure, int num_eliminate_blocks, - vector<set<int> >* visibility); + std::vector<std::set<int> >* visibility); // Given f_block visibility as computed by the ComputeVisibility // function above, construct and return a graph whose vertices are @@ -75,7 +75,7 @@ void ComputeVisibility(const CompressedRowBlockStructure& block_structure, // Caller acquires ownership of the returned WeightedGraph pointer // (heap-allocated). WeightedGraph<int>* CreateSchurComplementGraph( - const vector<set<int> >& visibility); + const std::vector<std::set<int> >& visibility); } // namespace internal } // namespace ceres diff --git a/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.cc b/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.cc index c7ed0493d8c..b0000cdb1fd 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -58,6 +58,12 @@ namespace ceres { namespace internal { +using std::make_pair; +using std::pair; +using std::set; +using std::swap; +using std::vector; + // TODO(sameeragarwal): Currently these are magic weights for the // preconditioner construction. Move these higher up into the Options // struct and provide some guidelines for choosing them. @@ -399,7 +405,7 @@ bool VisibilityBasedPreconditioner::UpdateImpl(const BlockSparseMatrix& A, // matrix. Scaling these off-diagonal entries by 1/2 forces this // matrix to be positive definite. void VisibilityBasedPreconditioner::ScaleOffDiagonalCells() { - for (set< pair<int, int> >::const_iterator it = block_pairs_.begin(); + for (set<pair<int, int> >::const_iterator it = block_pairs_.begin(); it != block_pairs_.end(); ++it) { const int block1 = it->first; @@ -439,7 +445,7 @@ LinearSolverTerminationType VisibilityBasedPreconditioner::Factorize() { lhs->stype = 1; // TODO(sameeragarwal): Refactor to pipe this up and out. - string status; + std::string status; // Symbolic factorization is computed if we don't already have one handy. if (factor_ == NULL) { @@ -464,7 +470,7 @@ void VisibilityBasedPreconditioner::RightMultiply(const double* x, const int num_rows = m_->num_rows(); memcpy(CHECK_NOTNULL(tmp_rhs_)->x, x, m_->num_rows() * sizeof(*x)); // TODO(sameeragarwal): Better error handling. - string status; + std::string status; cholmod_dense* solution = CHECK_NOTNULL(ss->Solve(factor_, tmp_rhs_, &status)); memcpy(y, solution->x, sizeof(*y) * num_rows); @@ -484,7 +490,7 @@ bool VisibilityBasedPreconditioner::IsBlockPairInPreconditioner( int cluster1 = cluster_membership_[block1]; int cluster2 = cluster_membership_[block2]; if (cluster1 > cluster2) { - std::swap(cluster1, cluster2); + swap(cluster1, cluster2); } return (cluster_pairs_.count(make_pair(cluster1, cluster2)) > 0); } diff --git a/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.h b/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.h index 2f6922dce54..a627c13523c 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.h +++ b/extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2010, 2011, 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -151,15 +151,16 @@ class VisibilityBasedPreconditioner : public BlockSparseMatrixPreconditioner { LinearSolverTerminationType Factorize(); void ScaleOffDiagonalCells(); - void ClusterCameras(const vector< set<int> >& visibility); + void ClusterCameras(const std::vector<std::set<int> >& visibility); void FlattenMembershipMap(const HashMap<int, int>& membership_map, - vector<int>* membership_vector) const; - void ComputeClusterVisibility(const vector<set<int> >& visibility, - vector<set<int> >* cluster_visibility) const; + std::vector<int>* membership_vector) const; + void ComputeClusterVisibility( + const std::vector<std::set<int> >& visibility, + std::vector<std::set<int> >* cluster_visibility) const; WeightedGraph<int>* CreateClusterGraph( - const vector<set<int> >& visibility) const; + const std::vector<std::set<int> >& visibility) const; void ForestToClusterPairs(const WeightedGraph<int>& forest, - HashSet<pair<int, int> >* cluster_pairs) const; + HashSet<std::pair<int, int> >* cluster_pairs) const; void ComputeBlockPairsInPreconditioner(const CompressedRowBlockStructure& bs); bool IsBlockPairInPreconditioner(int block1, int block2) const; bool IsBlockPairOffDiagonal(int block1, int block2) const; @@ -171,19 +172,19 @@ class VisibilityBasedPreconditioner : public BlockSparseMatrixPreconditioner { int num_clusters_; // Sizes of the blocks in the schur complement. - vector<int> block_size_; + std::vector<int> block_size_; // Mapping from cameras to clusters. - vector<int> cluster_membership_; + std::vector<int> cluster_membership_; // Non-zero camera pairs from the schur complement matrix that are // present in the preconditioner, sorted by row (first element of // each pair), then column (second). - set<pair<int, int> > block_pairs_; + std::set<std::pair<int, int> > block_pairs_; // Set of cluster pairs (including self pairs (i,i)) in the // preconditioner. - HashSet<pair<int, int> > cluster_pairs_; + HashSet<std::pair<int, int> > cluster_pairs_; scoped_ptr<SchurEliminatorBase> eliminator_; // Preconditioner matrix. diff --git a/extern/libmv/third_party/ceres/internal/ceres/wall_time.cc b/extern/libmv/third_party/ceres/internal/ceres/wall_time.cc index 85c4417552d..c353973cc3e 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/wall_time.cc +++ b/extern/libmv/third_party/ceres/internal/ceres/wall_time.cc @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -59,7 +59,7 @@ double WallTimeInSeconds() { #endif } -EventLogger::EventLogger(const string& logger_name) +EventLogger::EventLogger(const std::string& logger_name) : start_time_(WallTimeInSeconds()), last_event_time_(start_time_), events_("") { @@ -75,7 +75,7 @@ EventLogger::~EventLogger() { } } -void EventLogger::AddEvent(const string& event_name) { +void EventLogger::AddEvent(const std::string& event_name) { if (!VLOG_IS_ON(3)) { return; } diff --git a/extern/libmv/third_party/ceres/internal/ceres/wall_time.h b/extern/libmv/third_party/ceres/internal/ceres/wall_time.h index 37f5568a125..966aa67cab6 100644 --- a/extern/libmv/third_party/ceres/internal/ceres/wall_time.h +++ b/extern/libmv/third_party/ceres/internal/ceres/wall_time.h @@ -1,6 +1,6 @@ // Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 Google Inc. All rights reserved. -// http://code.google.com/p/ceres-solver/ +// Copyright 2015 Google Inc. All rights reserved. +// http://ceres-solver.org/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -72,14 +72,14 @@ double WallTimeInSeconds(); // Total: time3 time1 + time2 + time3; class EventLogger { public: - explicit EventLogger(const string& logger_name); + explicit EventLogger(const std::string& logger_name); ~EventLogger(); - void AddEvent(const string& event_name); + void AddEvent(const std::string& event_name); private: const double start_time_; double last_event_time_; - string events_; + std::string events_; }; } // namespace internal |