diff options
| author | Lukas Tönne <lukas.toenne@gmail.com> | 2016-04-20 17:45:29 +0300 |
|---|---|---|
| committer | Lukas Tönne <lukas.toenne@gmail.com> | 2016-04-20 17:45:29 +0300 |
| commit | aae0598aa233d43d0ffc81a070b2ce20d6871c1d (patch) | |
| tree | 378100f45cf1db972c671a6886496a5604f7ab29 /extern/libmv/third_party/ceres/include | |
| parent | 95d7d3c2a6aa91f1dcb33ff0cdfc751e2886d8cd (diff) | |
| parent | d7e4f920fd93a4ae5679e0eb6b228a349ab3b082 (diff) | |
Merge branch 'master' into temp_depsgraph_split_ubereval
Diffstat (limited to 'extern/libmv/third_party/ceres/include')
39 files changed, 0 insertions, 10084 deletions
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 deleted file mode 100644 index 7c0fa79ad0b..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/autodiff_cost_function.h +++ /dev/null @@ -1,227 +0,0 @@ -// 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/ -// -// 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) -// -// Create CostFunctions as needed by the least squares framework, with -// Jacobians computed via automatic differentiation. For more -// information on automatic differentation, see the wikipedia article -// at http://en.wikipedia.org/wiki/Automatic_differentiation -// -// To get an auto differentiated cost function, you must define a class with a -// templated operator() (a functor) that computes the cost function in terms of -// the template parameter T. The autodiff framework substitutes appropriate -// "jet" objects for T in order to compute the derivative when necessary, but -// this is hidden, and you should write the function as if T were a scalar type -// (e.g. a double-precision floating point number). -// -// The function must write the computed value in the last argument -// (the only non-const one) and return true to indicate -// success. Please see cost_function.h for details on how the return -// value maybe used to impose simple constraints on the parameter -// block. -// -// For example, consider a scalar error e = k - x'y, where both x and y are -// two-dimensional column vector parameters, the prime sign indicates -// transposition, and k is a constant. The form of this error, which is the -// difference between a constant and an expression, is a common pattern in least -// squares problems. For example, the value x'y might be the model expectation -// for a series of measurements, where there is an instance of the cost function -// for each measurement k. -// -// The actual cost added to the total problem is e^2, or (k - x'k)^2; however, -// the squaring is implicitly done by the optimization framework. -// -// To write an auto-differentiable cost function for the above model, first -// define the object -// -// class MyScalarCostFunctor { -// MyScalarCostFunctor(double k): k_(k) {} -// -// template <typename T> -// bool operator()(const T* const x , const T* const y, T* e) const { -// e[0] = T(k_) - x[0] * y[0] + x[1] * y[1]; -// return true; -// } -// -// private: -// double k_; -// }; -// -// Note that in the declaration of operator() the input parameters x and y come -// first, and are passed as const pointers to arrays of T. If there were three -// input parameters, then the third input parameter would come after y. The -// output is always the last parameter, and is also a pointer to an array. In -// the example above, e is a scalar, so only e[0] is set. -// -// Then given this class definition, the auto differentiated cost function for -// it can be constructed as follows. -// -// CostFunction* cost_function -// = new AutoDiffCostFunction<MyScalarCostFunctor, 1, 2, 2>( -// new MyScalarCostFunctor(1.0)); ^ ^ ^ -// | | | -// Dimension of residual -----+ | | -// Dimension of x ---------------+ | -// Dimension of y ------------------+ -// -// In this example, there is usually an instance for each measumerent of k. -// -// In the instantiation above, the template parameters following -// "MyScalarCostFunctor", "1, 2, 2", describe the functor as computing a -// 1-dimensional output from two arguments, both 2-dimensional. -// -// AutoDiffCostFunction also supports cost functions with a -// runtime-determined number of residuals. For example: -// -// CostFunction* cost_function -// = new AutoDiffCostFunction<MyScalarCostFunctor, DYNAMIC, 2, 2>( -// new CostFunctorWithDynamicNumResiduals(1.0), ^ ^ ^ -// runtime_number_of_residuals); <----+ | | | -// | | | | -// | | | | -// Actual number of residuals ------+ | | | -// Indicate dynamic number of residuals --------+ | | -// Dimension of x ------------------------------------+ | -// Dimension of y ---------------------------------------+ -// -// The framework can currently accommodate cost functions of up to 10 -// independent variables, and there is no limit on the dimensionality -// of each of them. -// -// WARNING #1: Since the functor will get instantiated with different types for -// T, you must to convert from other numeric types to T before mixing -// computations with other variables of type T. In the example above, this is -// seen where instead of using k_ directly, k_ is wrapped with T(k_). -// -// WARNING #2: A common beginner's error when first using autodiff cost -// functions is to get the sizing wrong. In particular, there is a tendency to -// set the template parameters to (dimension of residual, number of parameters) -// instead of passing a dimension parameter for *every parameter*. In the -// example above, that would be <MyScalarCostFunctor, 1, 2>, which is missing -// the last '2' argument. Please be careful when setting the size parameters. - -#ifndef CERES_PUBLIC_AUTODIFF_COST_FUNCTION_H_ -#define CERES_PUBLIC_AUTODIFF_COST_FUNCTION_H_ - -#include "ceres/internal/autodiff.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/sized_cost_function.h" -#include "ceres/types.h" -#include "glog/logging.h" - -namespace ceres { - -// A cost function which computes the derivative of the cost with respect to -// the parameters (a.k.a. the jacobian) using an autodifferentiation framework. -// The first template argument is the functor object, described in the header -// comment. The second argument is the dimension of the residual (or -// ceres::DYNAMIC to indicate it will be set at runtime), and subsequent -// arguments describe the size of the Nth parameter, one per parameter. -// -// The constructors take ownership of the cost functor. -// -// If the number of residuals (argument kNumResiduals below) is -// ceres::DYNAMIC, then the two-argument constructor must be used. The -// second constructor takes a number of residuals (in addition to the -// templated number of residuals). This allows for varying the number -// of residuals for a single autodiff cost function at runtime. -template <typename CostFunctor, - int kNumResiduals, // Number of residuals, or ceres::DYNAMIC. - int N0, // Number of parameters in block 0. - int N1 = 0, // Number of parameters in block 1. - int N2 = 0, // Number of parameters in block 2. - int N3 = 0, // Number of parameters in block 3. - int N4 = 0, // Number of parameters in block 4. - int N5 = 0, // Number of parameters in block 5. - int N6 = 0, // Number of parameters in block 6. - int N7 = 0, // Number of parameters in block 7. - int N8 = 0, // Number of parameters in block 8. - int N9 = 0> // Number of parameters in block 9. -class AutoDiffCostFunction : public SizedCostFunction<kNumResiduals, - N0, N1, N2, N3, N4, - N5, N6, N7, N8, N9> { - public: - // Takes ownership of functor. Uses the template-provided value for the - // number of residuals ("kNumResiduals"). - explicit AutoDiffCostFunction(CostFunctor* functor) - : functor_(functor) { - CHECK_NE(kNumResiduals, DYNAMIC) - << "Can't run the fixed-size constructor if the " - << "number of residuals is set to ceres::DYNAMIC."; - } - - // Takes ownership of functor. Ignores the template-provided - // kNumResiduals in favor of the "num_residuals" argument provided. - // - // This allows for having autodiff cost functions which return varying - // numbers of residuals at runtime. - AutoDiffCostFunction(CostFunctor* functor, int num_residuals) - : functor_(functor) { - CHECK_EQ(kNumResiduals, DYNAMIC) - << "Can't run the dynamic-size constructor if the " - << "number of residuals is not ceres::DYNAMIC."; - SizedCostFunction<kNumResiduals, - N0, N1, N2, N3, N4, - N5, N6, N7, N8, N9> - ::set_num_residuals(num_residuals); - } - - virtual ~AutoDiffCostFunction() {} - - // Implementation details follow; clients of the autodiff cost function should - // not have to examine below here. - // - // To handle varardic cost functions, some template magic is needed. It's - // mostly hidden inside autodiff.h. - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const { - if (!jacobians) { - return internal::VariadicEvaluate< - CostFunctor, double, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9> - ::Call(*functor_, parameters, residuals); - } - return internal::AutoDiff<CostFunctor, double, - N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>::Differentiate( - *functor_, - parameters, - SizedCostFunction<kNumResiduals, - N0, N1, N2, N3, N4, - N5, N6, N7, N8, N9>::num_residuals(), - residuals, - jacobians); - } - - private: - internal::scoped_ptr<CostFunctor> functor_; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_AUTODIFF_COST_FUNCTION_H_ 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 deleted file mode 100644 index c100d4825d2..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/autodiff_local_parameterization.h +++ /dev/null @@ -1,154 +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: sergey.vfx@gmail.com (Sergey Sharybin) -// mierle@gmail.com (Keir Mierle) -// sameeragarwal@google.com (Sameer Agarwal) - -#ifndef CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_ -#define CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_ - -#include "ceres/internal/autodiff.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/local_parameterization.h" - -namespace ceres { - -// Create local parameterization with Jacobians computed via automatic -// differentiation. For more information on local parameterizations, -// see include/ceres/local_parameterization.h -// -// To get an auto differentiated local parameterization, you must define -// a class with a templated operator() (a functor) that computes -// -// x_plus_delta = Plus(x, delta); -// -// the template parameter T. The autodiff framework substitutes appropriate -// "Jet" objects for T in order to compute the derivative when necessary, but -// this is hidden, and you should write the function as if T were a scalar type -// (e.g. a double-precision floating point number). -// -// The function must write the computed value in the last argument (the only -// non-const one) and return true to indicate success. -// -// For example, Quaternions have a three dimensional local -// parameterization. It's plus operation can be implemented as (taken -// from internal/ceres/auto_diff_local_parameterization_test.cc) -// -// struct QuaternionPlus { -// template<typename T> -// bool operator()(const T* x, const T* delta, T* x_plus_delta) const { -// const T squared_norm_delta = -// delta[0] * delta[0] + delta[1] * delta[1] + delta[2] * delta[2]; -// -// T q_delta[4]; -// if (squared_norm_delta > T(0.0)) { -// T norm_delta = sqrt(squared_norm_delta); -// const T sin_delta_by_delta = sin(norm_delta) / norm_delta; -// q_delta[0] = cos(norm_delta); -// q_delta[1] = sin_delta_by_delta * delta[0]; -// q_delta[2] = sin_delta_by_delta * delta[1]; -// q_delta[3] = sin_delta_by_delta * delta[2]; -// } else { -// // We do not just use q_delta = [1,0,0,0] here because that is a -// // constant and when used for automatic differentiation will -// // lead to a zero derivative. Instead we take a first order -// // approximation and evaluate it at zero. -// q_delta[0] = T(1.0); -// q_delta[1] = delta[0]; -// q_delta[2] = delta[1]; -// q_delta[3] = delta[2]; -// } -// -// QuaternionProduct(q_delta, x, x_plus_delta); -// return true; -// } -// }; -// -// Then given this struct, the auto differentiated local -// parameterization can now be constructed as -// -// LocalParameterization* local_parameterization = -// new AutoDiffLocalParameterization<QuaternionPlus, 4, 3>; -// | | -// Global Size ---------------+ | -// Local Size -------------------+ -// -// WARNING: Since the functor will get instantiated with different types for -// T, you must to convert from other numeric types to T before mixing -// computations with other variables of type T. In the example above, this is -// seen where instead of using k_ directly, k_ is wrapped with T(k_). - -template <typename Functor, int kGlobalSize, int kLocalSize> -class AutoDiffLocalParameterization : public LocalParameterization { - public: - AutoDiffLocalParameterization() : - functor_(new Functor()) {} - - // Takes ownership of functor. - explicit AutoDiffLocalParameterization(Functor* functor) : - functor_(functor) {} - - virtual ~AutoDiffLocalParameterization() {} - virtual bool Plus(const double* x, - const double* delta, - double* x_plus_delta) const { - return (*functor_)(x, delta, x_plus_delta); - } - - virtual bool ComputeJacobian(const double* x, double* jacobian) const { - double zero_delta[kLocalSize]; - for (int i = 0; i < kLocalSize; ++i) { - zero_delta[i] = 0.0; - } - - double x_plus_delta[kGlobalSize]; - for (int i = 0; i < kGlobalSize; ++i) { - x_plus_delta[i] = 0.0; - } - - const double* parameter_ptrs[2] = {x, zero_delta}; - double* jacobian_ptrs[2] = { NULL, jacobian }; - return internal::AutoDiff<Functor, double, kGlobalSize, kLocalSize> - ::Differentiate(*functor_, - parameter_ptrs, - kGlobalSize, - x_plus_delta, - jacobian_ptrs); - } - - virtual int GlobalSize() const { return kGlobalSize; } - virtual int LocalSize() const { return kLocalSize; } - - private: - internal::scoped_ptr<Functor> functor_; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/c_api.h b/extern/libmv/third_party/ceres/include/ceres/c_api.h deleted file mode 100644 index 71f41fd226b..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/c_api.h +++ /dev/null @@ -1,146 +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: mierle@gmail.com (Keir Mierle) - * - * A minimal C API for Ceres. Not all functionality is included. This API is - * not intended for clients of Ceres, but is instead intended for easing the - * process of binding Ceres to other languages. - * - * Currently this is a work in progress. - */ - -#ifndef CERES_PUBLIC_C_API_H_ -#define CERES_PUBLIC_C_API_H_ - -#include "ceres/internal/port.h" -#include "ceres/internal/disable_warnings.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* Init the Ceres private data. Must be called before anything else. */ -CERES_EXPORT void ceres_init(); - -/* Equivalent to CostFunction::Evaluate() in the C++ API. - * - * The user may keep private information inside the opaque user_data object. - * The pointer here is the same one passed in the ceres_add_residual_block(). - */ -typedef int (*ceres_cost_function_t)(void* user_data, - double** parameters, - double* residuals, - double** jacobians); - -/* Equivalent to LossFunction::Evaluate() from the C++ API. */ -typedef void (*ceres_loss_function_t)(void* user_data, - double squared_norm, - double out[3]); - -/* Create callback data for Ceres' stock loss functions. - * - * Ceres has several loss functions available by default, and these functions - * expose those to the C API. To use the stock loss functions, call - * ceres_create_*_loss_data(), which internally creates an instance of one of - * the stock loss functions (for example ceres::CauchyLoss), and pass the - * returned "loss_function_data" along with the ceres_stock_loss_function to - * ceres_add_residual_block(). - * - * For example: - * - * void* cauchy_loss_function_data = - * ceres_create_cauchy_loss_function_data(1.2, 0.0); - * ceres_problem_add_residual_block( - * problem, - * my_cost_function, - * my_cost_function_data, - * ceres_stock_loss_function, - * cauchy_loss_function_data, - * 1, - * 2, - * parameter_sizes, - * parameter_pointers); - * ... - * ceres_free_stock_loss_function_data(cauchy_loss_function_data); - * - * See loss_function.h for the details of each loss function. - */ -CERES_EXPORT void* ceres_create_huber_loss_function_data(double a); -CERES_EXPORT void* ceres_create_softl1_loss_function_data(double a); -CERES_EXPORT void* ceres_create_cauchy_loss_function_data(double a); -CERES_EXPORT void* ceres_create_arctan_loss_function_data(double a); -CERES_EXPORT void* ceres_create_tolerant_loss_function_data(double a, double b); - -/* Free the given stock loss function data. */ -CERES_EXPORT void ceres_free_stock_loss_function_data(void* loss_function_data); - -/* This is an implementation of ceres_loss_function_t contained within Ceres - * itself, intended as a way to access the various stock Ceres loss functions - * from the C API. This should be passed to ceres_add_residual() below, in - * combination with a user_data pointer generated by - * ceres_create_stock_loss_function() above. */ -CERES_EXPORT void ceres_stock_loss_function(void* user_data, - double squared_norm, - double out[3]); - -/* Equivalent to Problem from the C++ API. */ -struct ceres_problem_s; -typedef struct ceres_problem_s ceres_problem_t; - -struct ceres_residual_block_id_s; -typedef struct ceres_residual_block_id_s ceres_residual_block_id_t; - -/* Create and destroy a problem */ -/* TODO(keir): Add options for the problem. */ -CERES_EXPORT ceres_problem_t* ceres_create_problem(); -CERES_EXPORT void ceres_free_problem(ceres_problem_t* problem); - -/* Add a residual block. */ -CERES_EXPORT ceres_residual_block_id_t* ceres_problem_add_residual_block( - ceres_problem_t* problem, - ceres_cost_function_t cost_function, - void* cost_function_data, - ceres_loss_function_t loss_function, - void* loss_function_data, - int num_residuals, - int num_parameter_blocks, - int* parameter_block_sizes, - double** parameters); - -CERES_EXPORT void ceres_solve(ceres_problem_t* problem); - -/* TODO(keir): Figure out a way to pass a config in. */ - -#ifdef __cplusplus -} -#endif - -#include "ceres/internal/reenable_warnings.h" - -#endif /* CERES_PUBLIC_C_API_H_ */ diff --git a/extern/libmv/third_party/ceres/include/ceres/ceres.h b/extern/libmv/third_party/ceres/include/ceres/ceres.h deleted file mode 100644 index 7c8981e2994..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/ceres.h +++ /dev/null @@ -1,59 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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: keir@google.com (Keir Mierle) -// -// This is a forwarding header containing the public symbols exported from -// Ceres. Anything in the "ceres" namespace is available for use. - -#ifndef CERES_PUBLIC_CERES_H_ -#define CERES_PUBLIC_CERES_H_ - -#include "ceres/autodiff_cost_function.h" -#include "ceres/autodiff_local_parameterization.h" -#include "ceres/cost_function.h" -#include "ceres/cost_function_to_functor.h" -#include "ceres/covariance.h" -#include "ceres/crs_matrix.h" -#include "ceres/dynamic_autodiff_cost_function.h" -#include "ceres/dynamic_numeric_diff_cost_function.h" -#include "ceres/gradient_problem.h" -#include "ceres/gradient_problem_solver.h" -#include "ceres/iteration_callback.h" -#include "ceres/jet.h" -#include "ceres/local_parameterization.h" -#include "ceres/loss_function.h" -#include "ceres/numeric_diff_cost_function.h" -#include "ceres/ordered_groups.h" -#include "ceres/problem.h" -#include "ceres/sized_cost_function.h" -#include "ceres/solver.h" -#include "ceres/types.h" -#include "ceres/version.h" - -#endif // CERES_PUBLIC_CERES_H_ 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 deleted file mode 100644 index 3f0087c7815..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/conditioned_cost_function.h +++ /dev/null @@ -1,99 +0,0 @@ -// 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/ -// -// 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: wjr@google.com (William Rucklidge) -// -// This file contains a cost function that can apply a transformation to -// each residual value before they are square-summed. - -#ifndef CERES_PUBLIC_CONDITIONED_COST_FUNCTION_H_ -#define CERES_PUBLIC_CONDITIONED_COST_FUNCTION_H_ - -#include <vector> - -#include "ceres/cost_function.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// This class allows you to apply different conditioning to the residual -// values of a wrapped cost function. An example where this is useful is -// where you have an existing cost function that produces N values, but you -// want the total cost to be something other than just the sum of these -// squared values - maybe you want to apply a different scaling to some -// values, to change their contribution to the cost. -// -// Usage: -// -// // my_cost_function produces N residuals -// CostFunction* my_cost_function = ... -// CHECK_EQ(N, my_cost_function->num_residuals()); -// vector<CostFunction*> conditioners; -// -// // Make N 1x1 cost functions (1 parameter, 1 residual) -// CostFunction* f_1 = ... -// conditioners.push_back(f_1); -// ... -// CostFunction* f_N = ... -// conditioners.push_back(f_N); -// ConditionedCostFunction* ccf = -// new ConditionedCostFunction(my_cost_function, conditioners); -// -// Now ccf's residual i (i=0..N-1) will be passed though the i'th conditioner. -// -// ccf_residual[i] = f_i(my_cost_function_residual[i]) -// -// and the Jacobian will be affected appropriately. -class CERES_EXPORT ConditionedCostFunction : public CostFunction { - public: - // Builds a cost function based on a wrapped cost function, and a - // per-residual conditioner. Takes ownership of all of the wrapped cost - // 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, - Ownership ownership); - virtual ~ConditionedCostFunction(); - - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const; - - private: - internal::scoped_ptr<CostFunction> wrapped_cost_function_; - vector<CostFunction*> conditioners_; - Ownership ownership_; -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_CONDITIONED_COST_FUNCTION_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/cost_function.h b/extern/libmv/third_party/ceres/include/ceres/cost_function.h deleted file mode 100644 index fe8fc07d2ce..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/cost_function.h +++ /dev/null @@ -1,147 +0,0 @@ -// 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/ -// -// 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) -// keir@google.m (Keir Mierle) -// -// This is the interface through which the least squares solver accesses the -// residual and Jacobian of the least squares problem. Users are expected to -// subclass CostFunction to define their own terms in the least squares problem. -// -// It is recommended that users define templated residual functors for use as -// arguments for AutoDiffCostFunction (see autodiff_cost_function.h), instead of -// directly implementing the CostFunction interface. This often results in both -// shorter code and faster execution than hand-coded derivatives. However, -// specialized cases may demand direct implementation of the lower-level -// CostFunction interface; for example, this is true when calling legacy code -// which is not templated on numeric types. - -#ifndef CERES_PUBLIC_COST_FUNCTION_H_ -#define CERES_PUBLIC_COST_FUNCTION_H_ - -#include <vector> -#include "ceres/internal/macros.h" -#include "ceres/internal/port.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// This class implements the computation of the cost (a.k.a. residual) terms as -// a function of the input (control) variables, and is the interface for users -// to describe their least squares problem to Ceres. In other words, this is the -// modelling layer between users and the Ceres optimizer. The signature of the -// function (number and sizes of input parameter blocks and number of outputs) -// is stored in parameter_block_sizes_ and num_residuals_ respectively. User -// code inheriting from this class is expected to set these two members with the -// corresponding accessors. This information will be verified by the Problem -// when added with AddResidualBlock(). -class CERES_EXPORT CostFunction { - public: - CostFunction() : num_residuals_(0) {} - - virtual ~CostFunction() {} - - // Inputs: - // - // parameters is an array of pointers to arrays containing the - // various parameter blocks. parameters has the same number of - // elements as parameter_block_sizes_. Parameter blocks are in the - // same order as parameter_block_sizes_.i.e., - // - // parameters_[i] = double[parameter_block_sizes_[i]] - // - // Outputs: - // - // residuals is an array of size num_residuals_. - // - // jacobians is an array of size parameter_block_sizes_ containing - // pointers to storage for jacobian blocks corresponding to each - // parameter block. Jacobian blocks are in the same order as - // parameter_block_sizes, i.e. jacobians[i], is an - // array that contains num_residuals_* parameter_block_sizes_[i] - // elements. Each jacobian block is stored in row-major order, i.e., - // - // jacobians[i][r*parameter_block_size_[i] + c] = - // d residual[r] / d parameters[i][c] - // - // If jacobians is NULL, then no derivatives are returned; this is - // the case when computing cost only. If jacobians[i] is NULL, then - // the jacobian block corresponding to the i'th parameter block must - // not to be returned. - // - // The return value indicates whether the computation of the - // residuals and/or jacobians was successful or not. - // - // This can be used to communicate numerical failures in jacobian - // computations for instance. - // - // A more interesting and common use is to impose constraints on the - // parameters. If the initial values of the parameter blocks satisfy - // the constraints, then returning false whenever the constraints - // are not satisfied will prevent the solver from moving into the - // infeasible region. This is not a very sophisticated mechanism for - // enforcing constraints, but is often good enough. - // - // Note that it is important that the initial values of the - // parameter block must be feasible, otherwise the solver will - // declare a numerical problem at iteration 0. - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const = 0; - - const vector<int32>& parameter_block_sizes() const { - return parameter_block_sizes_; - } - - int num_residuals() const { - return num_residuals_; - } - - protected: - vector<int32>* mutable_parameter_block_sizes() { - return ¶meter_block_sizes_; - } - - void set_num_residuals(int num_residuals) { - num_residuals_ = num_residuals; - } - - private: - // Cost function signature metadata: number of inputs & their sizes, - // number of outputs (residuals). - vector<int32> parameter_block_sizes_; - int num_residuals_; - CERES_DISALLOW_COPY_AND_ASSIGN(CostFunction); -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_COST_FUNCTION_H_ 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 deleted file mode 100644 index b4a516e0ab1..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/cost_function_to_functor.h +++ /dev/null @@ -1,750 +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) -// -// CostFunctionToFunctor is an adapter class that allows users to use -// CostFunction objects in templated functors which are to be used for -// automatic differentiation. This allows the user to seamlessly mix -// analytic, numeric and automatic differentiation. -// -// For example, let us assume that -// -// class IntrinsicProjection : public SizedCostFunction<2, 5, 3> { -// public: -// IntrinsicProjection(const double* observations); -// 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. -// -// 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(const T* rotation, -// const T* translation, -// const T* point, -// T* result); -// -// Then we can now do the following, -// -// struct CameraProjection { -// CameraProjection(double* observation) { -// intrinsic_projection_.reset( -// new CostFunctionToFunctor<2, 5, 3>( -// new IntrinsicProjection(observation_))); -// } -// template <typename T> -// bool operator()(const T* rotation, -// const T* translation, -// const T* intrinsics, -// const T* point, -// T* residual) const { -// T transformed_point[3]; -// RotateAndTranslatePoint(rotation, translation, point, transformed_point); -// -// // Note that we call intrinsic_projection_, just like it was -// // any other templated functor. -// -// return (*intrinsic_projection_)(intrinsics, transformed_point, residual); -// } -// -// private: -// scoped_ptr<CostFunctionToFunctor<2,5,3> > intrinsic_projection_; -// }; - -#ifndef CERES_PUBLIC_COST_FUNCTION_TO_FUNCTOR_H_ -#define CERES_PUBLIC_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 { - -template <int kNumResiduals, - int N0, int N1 = 0, int N2 = 0, int N3 = 0, int N4 = 0, - int N5 = 0, int N6 = 0, int N7 = 0, int N8 = 0, int N9 = 0> -class CostFunctionToFunctor { - public: - explicit CostFunctionToFunctor(CostFunction* cost_function) - : cost_function_(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))) - << "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 = - cost_function->parameter_block_sizes(); - const int num_parameter_blocks = - (N0 > 0) + (N1 > 0) + (N2 > 0) + (N3 > 0) + (N4 > 0) + - (N5 > 0) + (N6 > 0) + (N7 > 0) + (N8 > 0) + (N9 > 0); - CHECK_EQ(parameter_block_sizes.size(), num_parameter_blocks); - - CHECK_EQ(N0, parameter_block_sizes[0]); - if (parameter_block_sizes.size() > 1) CHECK_EQ(N1, parameter_block_sizes[1]); // NOLINT - if (parameter_block_sizes.size() > 2) CHECK_EQ(N2, parameter_block_sizes[2]); // NOLINT - if (parameter_block_sizes.size() > 3) CHECK_EQ(N3, parameter_block_sizes[3]); // NOLINT - if (parameter_block_sizes.size() > 4) CHECK_EQ(N4, parameter_block_sizes[4]); // NOLINT - if (parameter_block_sizes.size() > 5) CHECK_EQ(N5, parameter_block_sizes[5]); // NOLINT - if (parameter_block_sizes.size() > 6) CHECK_EQ(N6, parameter_block_sizes[6]); // NOLINT - if (parameter_block_sizes.size() > 7) CHECK_EQ(N7, parameter_block_sizes[7]); // NOLINT - if (parameter_block_sizes.size() > 8) CHECK_EQ(N8, parameter_block_sizes[8]); // NOLINT - if (parameter_block_sizes.size() > 9) CHECK_EQ(N9, parameter_block_sizes[9]); // NOLINT - - CHECK_EQ(accumulate(parameter_block_sizes.begin(), - parameter_block_sizes.end(), 0), - N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9); - } - - bool operator()(const double* x0, double* residuals) const { - CHECK_NE(N0, 0); - CHECK_EQ(N1, 0); - CHECK_EQ(N2, 0); - CHECK_EQ(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - - return cost_function_->Evaluate(&x0, residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_EQ(N2, 0); - CHECK_EQ(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(2); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_EQ(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(3); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(4); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - const double* x4, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(5); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - parameter_blocks[4] = x4; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - const double* x4, - const double* x5, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(6); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - parameter_blocks[4] = x4; - parameter_blocks[5] = x5; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - const double* x4, - const double* x5, - const double* x6, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(7); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - parameter_blocks[4] = x4; - parameter_blocks[5] = x5; - parameter_blocks[6] = x6; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - const double* x4, - const double* x5, - const double* x6, - const double* x7, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_NE(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(8); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - parameter_blocks[4] = x4; - parameter_blocks[5] = x5; - parameter_blocks[6] = x6; - parameter_blocks[7] = x7; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - const double* x4, - const double* x5, - const double* x6, - const double* x7, - const double* x8, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_NE(N7, 0); - CHECK_NE(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const double*> parameter_blocks(9); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - parameter_blocks[4] = x4; - parameter_blocks[5] = x5; - parameter_blocks[6] = x6; - parameter_blocks[7] = x7; - parameter_blocks[8] = x8; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - bool operator()(const double* x0, - const double* x1, - const double* x2, - const double* x3, - const double* x4, - const double* x5, - const double* x6, - const double* x7, - const double* x8, - const double* x9, - double* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_NE(N7, 0); - CHECK_NE(N8, 0); - CHECK_NE(N9, 0); - internal::FixedArray<const double*> parameter_blocks(10); - parameter_blocks[0] = x0; - parameter_blocks[1] = x1; - parameter_blocks[2] = x2; - parameter_blocks[3] = x3; - parameter_blocks[4] = x4; - parameter_blocks[5] = x5; - parameter_blocks[6] = x6; - parameter_blocks[7] = x7; - parameter_blocks[8] = x8; - parameter_blocks[9] = x9; - return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL); - } - - template <typename JetT> - bool operator()(const JetT* x0, JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_EQ(N1, 0); - CHECK_EQ(N2, 0); - CHECK_EQ(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - return EvaluateWithJets(&x0, residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_EQ(N2, 0); - CHECK_EQ(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(2); - jets[0] = x0; - jets[1] = x1; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_EQ(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(3); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_EQ(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(4); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - const JetT* x4, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_EQ(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(5); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - jets[4] = x4; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - const JetT* x4, - const JetT* x5, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_EQ(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(6); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - jets[4] = x4; - jets[5] = x5; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - const JetT* x4, - const JetT* x5, - const JetT* x6, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_EQ(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(7); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - jets[4] = x4; - jets[5] = x5; - jets[6] = x6; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - const JetT* x4, - const JetT* x5, - const JetT* x6, - const JetT* x7, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_NE(N7, 0); - CHECK_EQ(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(8); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - jets[4] = x4; - jets[5] = x5; - jets[6] = x6; - jets[7] = x7; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - const JetT* x4, - const JetT* x5, - const JetT* x6, - const JetT* x7, - const JetT* x8, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_NE(N7, 0); - CHECK_NE(N8, 0); - CHECK_EQ(N9, 0); - internal::FixedArray<const JetT*> jets(9); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - jets[4] = x4; - jets[5] = x5; - jets[6] = x6; - jets[7] = x7; - jets[8] = x8; - return EvaluateWithJets(jets.get(), residuals); - } - - template <typename JetT> - bool operator()(const JetT* x0, - const JetT* x1, - const JetT* x2, - const JetT* x3, - const JetT* x4, - const JetT* x5, - const JetT* x6, - const JetT* x7, - const JetT* x8, - const JetT* x9, - JetT* residuals) const { - CHECK_NE(N0, 0); - CHECK_NE(N1, 0); - CHECK_NE(N2, 0); - CHECK_NE(N3, 0); - CHECK_NE(N4, 0); - CHECK_NE(N5, 0); - CHECK_NE(N6, 0); - CHECK_NE(N7, 0); - CHECK_NE(N8, 0); - CHECK_NE(N9, 0); - internal::FixedArray<const JetT*> jets(10); - jets[0] = x0; - jets[1] = x1; - jets[2] = x2; - jets[3] = x3; - jets[4] = x4; - jets[5] = x5; - jets[6] = x6; - jets[7] = x7; - jets[8] = x8; - jets[9] = x9; - return EvaluateWithJets(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_; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_COST_FUNCTION_TO_FUNCTOR_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/covariance.h b/extern/libmv/third_party/ceres/include/ceres/covariance.h deleted file mode 100644 index 35fde4de05d..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/covariance.h +++ /dev/null @@ -1,384 +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_PUBLIC_COVARIANCE_H_ -#define CERES_PUBLIC_COVARIANCE_H_ - -#include <utility> -#include <vector> -#include "ceres/internal/port.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -class Problem; - -namespace internal { -class CovarianceImpl; -} // namespace internal - -// WARNING -// ======= -// It is very easy to use this class incorrectly without understanding -// the underlying mathematics. Please read and understand the -// documentation completely before attempting to use this class. -// -// -// This class allows the user to evaluate the covariance for a -// non-linear least squares problem and provides random access to its -// blocks -// -// Background -// ========== -// One way to assess the quality of the solution returned by a -// non-linear least squares solve is to analyze the covariance of the -// solution. -// -// Let us consider the non-linear regression problem -// -// y = f(x) + N(0, I) -// -// i.e., the observation y is a random non-linear function of the -// independent variable x with mean f(x) and identity covariance. Then -// the maximum likelihood estimate of x given observations y is the -// solution to the non-linear least squares problem: -// -// x* = arg min_x |f(x)|^2 -// -// And the covariance of x* is given by -// -// C(x*) = inverse[J'(x*)J(x*)] -// -// Here J(x*) is the Jacobian of f at x*. The above formula assumes -// that J(x*) has full column rank. -// -// If J(x*) is rank deficient, then the covariance matrix C(x*) is -// also rank deficient and is given by -// -// C(x*) = pseudoinverse[J'(x*)J(x*)] -// -// Note that in the above, we assumed that the covariance -// matrix for y was identity. This is an important assumption. If this -// is not the case and we have -// -// y = f(x) + N(0, S) -// -// Where S is a positive semi-definite matrix denoting the covariance -// of y, then the maximum likelihood problem to be solved is -// -// x* = arg min_x f'(x) inverse[S] f(x) -// -// and the corresponding covariance estimate of x* is given by -// -// C(x*) = inverse[J'(x*) inverse[S] J(x*)] -// -// So, if it is the case that the observations being fitted to have a -// covariance matrix not equal to identity, then it is the user's -// responsibility that the corresponding cost functions are correctly -// scaled, e.g. in the above case the cost function for this problem -// should evaluate S^{-1/2} f(x) instead of just f(x), where S^{-1/2} -// is the inverse square root of the covariance matrix S. -// -// This class allows the user to evaluate the covariance for a -// non-linear least squares problem and provides random access to its -// blocks. The computation assumes that the CostFunctions compute -// residuals such that their covariance is identity. -// -// Since the computation of the covariance matrix requires computing -// the inverse of a potentially large matrix, this can involve a -// rather large amount of time and memory. However, it is usually the -// case that the user is only interested in a small part of the -// covariance matrix. Quite often just the block diagonal. This class -// allows the user to specify the parts of the covariance matrix that -// she is interested in and then uses this information to only compute -// and store those parts of the covariance matrix. -// -// Rank of the Jacobian -// -------------------- -// As we noted above, if the jacobian is rank deficient, then the -// inverse of J'J is not defined and instead a pseudo inverse needs to -// be computed. -// -// The rank deficiency in J can be structural -- columns which are -// always known to be zero or numerical -- depending on the exact -// values in the Jacobian. -// -// Structural rank deficiency occurs when the problem contains -// parameter blocks that are constant. This class correctly handles -// structural rank deficiency like that. -// -// Numerical rank deficiency, where the rank of the matrix cannot be -// predicted by its sparsity structure and requires looking at its -// numerical values is more complicated. Here again there are two -// cases. -// -// a. The rank deficiency arises from overparameterization. e.g., a -// four dimensional quaternion used to parameterize SO(3), which is -// a three dimensional manifold. In cases like this, the user should -// use an appropriate LocalParameterization. Not only will this lead -// to better numerical behaviour of the Solver, it will also expose -// the rank deficiency to the Covariance object so that it can -// handle it correctly. -// -// b. More general numerical rank deficiency in the Jacobian -// requires the computation of the so called Singular Value -// Decomposition (SVD) of J'J. We do not know how to do this for -// large sparse matrices efficiently. For small and moderate sized -// problems this is done using dense linear algebra. -// -// Gauge Invariance -// ---------------- -// In structure from motion (3D reconstruction) problems, the -// reconstruction is ambiguous upto a similarity transform. This is -// known as a Gauge Ambiguity. Handling Gauges correctly requires the -// use of SVD or custom inversion algorithms. For small problems the -// user can use the dense algorithm. For more details see -// -// Ken-ichi Kanatani, Daniel D. Morris: Gauges and gauge -// transformations for uncertainty description of geometric structure -// with indeterminacy. IEEE Transactions on Information Theory 47(5): -// 2017-2028 (2001) -// -// Example Usage -// ============= -// -// double x[3]; -// double y[2]; -// -// Problem problem; -// problem.AddParameterBlock(x, 3); -// problem.AddParameterBlock(y, 2); -// <Build Problem> -// <Solve Problem> -// -// Covariance::Options options; -// Covariance covariance(options); -// -// vector<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)); -// -// CHECK(covariance.Compute(covariance_blocks, &problem)); -// -// double covariance_xx[3 * 3]; -// double covariance_yy[2 * 2]; -// double covariance_xy[3 * 2]; -// covariance.GetCovarianceBlock(x, x, covariance_xx) -// covariance.GetCovarianceBlock(y, y, covariance_yy) -// covariance.GetCovarianceBlock(x, y, covariance_xy) -// -class CERES_EXPORT Covariance { - public: - struct CERES_EXPORT Options { - Options() -#ifndef CERES_NO_SUITESPARSE - : algorithm_type(SUITE_SPARSE_QR), -#else - : algorithm_type(EIGEN_SPARSE_QR), -#endif - min_reciprocal_condition_number(1e-14), - null_space_rank(0), - num_threads(1), - apply_loss_function(true) { - } - - // Ceres supports three different algorithms for covariance - // estimation, which represent different tradeoffs in speed, - // accuracy and reliability. - // - // 1. DENSE_SVD uses Eigen's JacobiSVD to perform the - // computations. It computes the singular value decomposition - // - // U * S * V' = J - // - // and then uses it to compute the pseudo inverse of J'J as - // - // pseudoinverse[J'J]^ = V * pseudoinverse[S] * V' - // - // It is an accurate but slow method and should only be used - // for small to moderate sized problems. It can handle - // full-rank as well as rank deficient Jacobians. - // - // 2. EIGEN_SPARSE_QR uses the sparse QR factorization algorithm - // in Eigen to compute the decomposition - // - // Q * R = J - // - // [J'J]^-1 = [R*R']^-1 - // - // It is a moderately fast algorithm for sparse matrices. - // - // 3. SUITE_SPARSE_QR uses the SuiteSparseQR sparse QR - // factorization algorithm. It uses dense linear algebra and is - // multi threaded, so for large sparse sparse matrices it is - // significantly faster than EIGEN_SPARSE_QR. - // - // Neither EIGEN_SPARSE_QR not SUITE_SPARSE_QR are capable of - // computing the covariance if the Jacobian is rank deficient. - CovarianceAlgorithmType algorithm_type; - - // If the Jacobian matrix is near singular, then inverting J'J - // will result in unreliable results, e.g, if - // - // J = [1.0 1.0 ] - // [1.0 1.0000001 ] - // - // which is essentially a rank deficient matrix, we have - // - // inv(J'J) = [ 2.0471e+14 -2.0471e+14] - // [-2.0471e+14 2.0471e+14] - // - // This is not a useful result. Therefore, by default - // Covariance::Compute will return false if a rank deficient - // Jacobian is encountered. How rank deficiency is detected - // depends on the algorithm being used. - // - // 1. DENSE_SVD - // - // min_sigma / max_sigma < sqrt(min_reciprocal_condition_number) - // - // where min_sigma and max_sigma are the minimum and maxiumum - // singular values of J respectively. - // - // 2. SUITE_SPARSE_QR and EIGEN_SPARSE_QR - // - // rank(J) < num_col(J) - // - // Here rank(J) is the estimate of the rank of J returned by the - // sparse QR factorization algorithm. It is a fairly reliable - // indication of rank deficiency. - // - double min_reciprocal_condition_number; - - // When using DENSE_SVD, the user has more control in dealing with - // singular and near singular covariance matrices. - // - // As mentioned above, when the covariance matrix is near - // singular, instead of computing the inverse of J'J, the - // Moore-Penrose pseudoinverse of J'J should be computed. - // - // If J'J has the eigen decomposition (lambda_i, e_i), where - // lambda_i is the i^th eigenvalue and e_i is the corresponding - // eigenvector, then the inverse of J'J is - // - // inverse[J'J] = sum_i e_i e_i' / lambda_i - // - // and computing the pseudo inverse involves dropping terms from - // this sum that correspond to small eigenvalues. - // - // How terms are dropped is controlled by - // min_reciprocal_condition_number and null_space_rank. - // - // If null_space_rank is non-negative, then the smallest - // null_space_rank eigenvalue/eigenvectors are dropped - // irrespective of the magnitude of lambda_i. If the ratio of the - // smallest non-zero eigenvalue to the largest eigenvalue in the - // truncated matrix is still below - // min_reciprocal_condition_number, then the Covariance::Compute() - // will fail and return false. - // - // Setting null_space_rank = -1 drops all terms for which - // - // lambda_i / lambda_max < min_reciprocal_condition_number. - // - // This option has no effect on the SUITE_SPARSE_QR and - // EIGEN_SPARSE_QR algorithms. - int null_space_rank; - - int num_threads; - - // Even though the residual blocks in the problem may contain loss - // functions, setting apply_loss_function to false will turn off - // the application of the loss function to the output of the cost - // function and in turn its effect on the covariance. - // - // TODO(sameergaarwal): Expand this based on Jim's experiments. - bool apply_loss_function; - }; - - explicit Covariance(const Options& options); - ~Covariance(); - - // Compute a part of the covariance matrix. - // - // The vector covariance_blocks, indexes into the covariance matrix - // block-wise using pairs of parameter blocks. This allows the - // covariance estimation algorithm to only compute and store these - // blocks. - // - // Since the covariance matrix is symmetric, if the user passes - // (block1, block2), then GetCovarianceBlock can be called with - // block1, block2 as well as block2, block1. - // - // covariance_blocks cannot contain duplicates. Bad things will - // happen if they do. - // - // Note that the list of covariance_blocks is only used to determine - // what parts of the covariance matrix are computed. The full - // Jacobian is used to do the computation, i.e. they do not have an - // impact on what part of the Jacobian is used for computation. - // - // The return value indicates the success or failure of the - // covariance computation. Please see the documentation for - // Covariance::Options for more on the conditions under which this - // function returns false. - bool Compute( - const vector<pair<const double*, const double*> >& covariance_blocks, - Problem* problem); - - // Return the block of the covariance matrix corresponding to - // parameter_block1 and parameter_block2. - // - // 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_size x parameter_block2_size matrix. The - // returned covariance will be a row-major matrix. - bool GetCovarianceBlock(const double* parameter_block1, - const double* parameter_block2, - double* covariance_block) const; - - private: - internal::scoped_ptr<internal::CovarianceImpl> impl_; -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_COVARIANCE_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h b/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h deleted file mode 100644 index d2d62894194..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/crs_matrix.h +++ /dev/null @@ -1,86 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 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_PUBLIC_CRS_MATRIX_H_ -#define CERES_PUBLIC_CRS_MATRIX_H_ - -#include <vector> -#include "ceres/internal/port.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// A compressed row sparse matrix used primarily for communicating the -// Jacobian matrix to the user. -struct CERES_EXPORT CRSMatrix { - CRSMatrix() : num_rows(0), num_cols(0) {} - - int num_rows; - int num_cols; - - // A compressed row matrix stores its contents in three arrays, - // rows, cols and values. - // - // rows is a num_rows + 1 sized array that points into the cols and - // values array. For each row i: - // - // cols[rows[i]] ... cols[rows[i + 1] - 1] are the indices of the - // non-zero columns of row i. - // - // values[rows[i]] .. values[rows[i + 1] - 1] are the values of the - // corresponding entries. - // - // cols and values contain as many entries as there are non-zeros in - // the matrix. - // - // e.g, consider the 3x4 sparse matrix - // - // [ 0 10 0 4 ] - // [ 0 2 -3 2 ] - // [ 1 2 0 0 ] - // - // The three arrays will be: - // - // - // -row0- ---row1--- -row2- - // rows = [ 0, 2, 5, 7] - // 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; -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_CRS_MATRIX_H_ 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 deleted file mode 100644 index f9342cdbab9..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/dynamic_autodiff_cost_function.h +++ /dev/null @@ -1,260 +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) -// mierle@gmail.com (Keir Mierle) -// -// This autodiff implementation differs from the one found in -// autodiff_cost_function.h by supporting autodiff on cost functions -// with variable numbers of parameters with variable sizes. With the -// other implementation, all the sizes (both the number of parameter -// blocks and the size of each block) must be fixed at compile time. -// -// The functor API differs slightly from the API for fixed size -// autodiff; the expected interface for the cost functors is: -// -// struct MyCostFunctor { -// template<typename T> -// bool operator()(T const* const* parameters, T* residuals) const { -// // Use parameters[i] to access the i'th parameter block. -// } -// } -// -// Since the sizing of the parameters is done at runtime, you must -// also specify the sizes after creating the dynamic autodiff cost -// function. For example: -// -// DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function( -// new MyCostFunctor()); -// cost_function.AddParameterBlock(5); -// cost_function.AddParameterBlock(10); -// cost_function.SetNumResiduals(21); -// -// Under the hood, the implementation evaluates the cost function -// multiple times, computing a small set of the derivatives (four by -// default, controlled by the Stride template parameter) with each -// pass. There is a tradeoff with the size of the passes; you may want -// to experiment with the stride. - -#ifndef CERES_PUBLIC_DYNAMIC_AUTODIFF_COST_FUNCTION_H_ -#define CERES_PUBLIC_DYNAMIC_AUTODIFF_COST_FUNCTION_H_ - -#include <cmath> -#include <numeric> -#include <vector> - -#include "ceres/cost_function.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/jet.h" -#include "glog/logging.h" - -namespace ceres { - -template <typename CostFunctor, int Stride = 4> -class DynamicAutoDiffCostFunction : public CostFunction { - public: - explicit DynamicAutoDiffCostFunction(CostFunctor* functor) - : functor_(functor) {} - - virtual ~DynamicAutoDiffCostFunction() {} - - void AddParameterBlock(int size) { - mutable_parameter_block_sizes()->push_back(size); - } - - void SetNumResiduals(int num_residuals) { - set_num_residuals(num_residuals); - } - - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const { - CHECK_GT(num_residuals(), 0) - << "You must call DynamicAutoDiffCostFunction::SetNumResiduals() " - << "before DynamicAutoDiffCostFunction::Evaluate()."; - - if (jacobians == NULL) { - return (*functor_)(parameters, residuals); - } - - // The difficulty with Jets, as implemented in Ceres, is that they were - // originally designed for strictly compile-sized use. At this point, there - // is a large body of code that assumes inside a cost functor it is - // acceptable to do e.g. T(1.5) and get an appropriately sized jet back. - // - // Unfortunately, it is impossible to communicate the expected size of a - // dynamically sized jet to the static instantiations that existing code - // depends on. - // - // To work around this issue, the solution here is to evaluate the - // jacobians in a series of passes, each one computing Stripe * - // num_residuals() derivatives. This is done with small, fixed-size jets. - const int num_parameter_blocks = parameter_block_sizes().size(); - const int num_parameters = std::accumulate(parameter_block_sizes().begin(), - parameter_block_sizes().end(), - 0); - - // Allocate scratch space for the strided evaluation. - vector<Jet<double, Stride> > input_jets(num_parameters); - 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, - 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; - bool in_derivative_section = false; - int parameter_cursor = 0; - - // Discover the derivative sections and set the parameter values. - for (int i = 0; i < num_parameter_blocks; ++i) { - jet_parameters[i] = &input_jets[parameter_cursor]; - - const int parameter_block_size = parameter_block_sizes()[i]; - if (jacobians[i] != NULL) { - if (!in_derivative_section) { - start_derivative_section.push_back(parameter_cursor); - in_derivative_section = true; - } - - num_active_parameters += parameter_block_size; - } else { - in_derivative_section = false; - } - - for (int j = 0; j < parameter_block_size; ++j, parameter_cursor++) { - input_jets[parameter_cursor].a = parameters[i][j]; - } - } - - // When `num_active_parameters % Stride != 0` then it can be the case - // that `active_parameter_count < Stride` while parameter_cursor is less - // than the total number of parameters and with no remaining non-constant - // parameter blocks. Pushing parameter_cursor (the total number of - // parameters) as a final entry to start_derivative_section is required - // because if a constant parameter block is encountered after the - // last non-constant block then current_derivative_section is incremented - // and would otherwise index an invalid position in - // start_derivative_section. Setting the final element to the total number - // of parameters means that this can only happen at most once in the loop - // below. - start_derivative_section.push_back(parameter_cursor); - - // Evaluate all of the strides. Each stride is a chunk of the derivative to - // evaluate, typically some size proportional to the size of the SIMD - // registers of the CPU. - int num_strides = static_cast<int>(ceil(num_active_parameters / - static_cast<float>(Stride))); - - int current_derivative_section = 0; - int current_derivative_section_cursor = 0; - - for (int pass = 0; pass < num_strides; ++pass) { - // Set most of the jet components to zero, except for - // non-constant #Stride parameters. - const int initial_derivative_section = current_derivative_section; - const int initial_derivative_section_cursor = - current_derivative_section_cursor; - - int active_parameter_count = 0; - parameter_cursor = 0; - - for (int i = 0; i < num_parameter_blocks; ++i) { - for (int j = 0; j < parameter_block_sizes()[i]; - ++j, parameter_cursor++) { - input_jets[parameter_cursor].v.setZero(); - if (active_parameter_count < Stride && - parameter_cursor >= ( - start_derivative_section[current_derivative_section] + - current_derivative_section_cursor)) { - if (jacobians[i] != NULL) { - input_jets[parameter_cursor].v[active_parameter_count] = 1.0; - ++active_parameter_count; - ++current_derivative_section_cursor; - } else { - ++current_derivative_section; - current_derivative_section_cursor = 0; - } - } - } - } - - if (!(*functor_)(&jet_parameters[0], &output_jets[0])) { - return false; - } - - // Copy the pieces of the jacobians into their final place. - active_parameter_count = 0; - - current_derivative_section = initial_derivative_section; - current_derivative_section_cursor = initial_derivative_section_cursor; - - for (int i = 0, parameter_cursor = 0; i < num_parameter_blocks; ++i) { - for (int j = 0; j < parameter_block_sizes()[i]; - ++j, parameter_cursor++) { - if (active_parameter_count < Stride && - parameter_cursor >= ( - start_derivative_section[current_derivative_section] + - current_derivative_section_cursor)) { - if (jacobians[i] != NULL) { - for (int k = 0; k < num_residuals(); ++k) { - jacobians[i][k * parameter_block_sizes()[i] + j] = - output_jets[k].v[active_parameter_count]; - } - ++active_parameter_count; - ++current_derivative_section_cursor; - } else { - ++current_derivative_section; - current_derivative_section_cursor = 0; - } - } - } - } - - // Only copy the residuals over once (even though we compute them on - // every loop). - if (pass == num_strides - 1) { - for (int k = 0; k < num_residuals(); ++k) { - residuals[k] = output_jets[k].a; - } - } - } - return true; - } - - private: - internal::scoped_ptr<CostFunctor> functor_; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_DYNAMIC_AUTODIFF_COST_FUNCTION_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 deleted file mode 100644 index 2b6e8260286..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/dynamic_numeric_diff_cost_function.h +++ /dev/null @@ -1,265 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 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: mierle@gmail.com (Keir Mierle) -// sameeragarwal@google.com (Sameer Agarwal) -// thadh@gmail.com (Thad Hughes) -// -// This numeric diff implementation differs from the one found in -// numeric_diff_cost_function.h by supporting numericdiff on cost -// functions with variable numbers of parameters with variable -// sizes. With the other implementation, all the sizes (both the -// number of parameter blocks and the size of each block) must be -// fixed at compile time. -// -// The functor API differs slightly from the API for fixed size -// 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. -// } -// } -// -// Since the sizing of the parameters is done at runtime, you must -// also specify the sizes after creating the -// DynamicNumericDiffCostFunction. For example: -// -// DynamicAutoDiffCostFunction<MyCostFunctor, CENTRAL> cost_function( -// new MyCostFunctor()); -// cost_function.AddParameterBlock(5); -// cost_function.AddParameterBlock(10); -// cost_function.SetNumResiduals(21); - -#ifndef CERES_PUBLIC_DYNAMIC_NUMERIC_DIFF_COST_FUNCTION_H_ -#define CERES_PUBLIC_DYNAMIC_NUMERIC_DIFF_COST_FUNCTION_H_ - -#include <cmath> -#include <numeric> -#include <vector> - -#include "ceres/cost_function.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/internal/eigen.h" -#include "ceres/internal/numeric_diff.h" -#include "glog/logging.h" - -namespace ceres { - -template <typename CostFunctor, NumericDiffMethod method = CENTRAL> -class DynamicNumericDiffCostFunction : public CostFunction { - public: - explicit DynamicNumericDiffCostFunction(const CostFunctor* functor, - Ownership ownership = TAKE_OWNERSHIP, - double relative_step_size = 1e-6) - : functor_(functor), - ownership_(ownership), - relative_step_size_(relative_step_size) { - } - - virtual ~DynamicNumericDiffCostFunction() { - if (ownership_ != TAKE_OWNERSHIP) { - functor_.release(); - } - } - - void AddParameterBlock(int size) { - mutable_parameter_block_sizes()->push_back(size); - } - - void SetNumResiduals(int num_residuals) { - set_num_residuals(num_residuals); - } - - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const { - CHECK_GT(num_residuals(), 0) - << "You must call DynamicNumericDiffCostFunction::SetNumResiduals() " - << "before DynamicNumericDiffCostFunction::Evaluate()."; - - const vector<int32>& block_sizes = parameter_block_sizes(); - CHECK(!block_sizes.empty()) - << "You must call DynamicNumericDiffCostFunction::AddParameterBlock() " - << "before DynamicNumericDiffCostFunction::Evaluate()."; - - const bool status = EvaluateCostFunctor(parameters, residuals); - if (jacobians == NULL || !status) { - return status; - } - - // 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()); - 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] - + block_sizes[block - 1]; - } - - // Copy the parameters into the local temp space. - for (int block = 0; block < block_sizes.size(); ++block) { - memcpy(parameters_references_copy[block], - parameters[block], - block_sizes[block] * sizeof(*parameters[block])); - } - - for (int block = 0; block < block_sizes.size(); ++block) { - if (jacobians[block] != NULL && - !EvaluateJacobianForParameterBlock(block_sizes[block], - block, - relative_step_size_, - residuals, - ¶meters_references_copy[0], - jacobians)) { - return false; - } - } - return true; - } - - 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(), - parameters, - residuals, - functor_.get()); - } - - // Helper templates to allow evaluation of a functor or a - // CostFunction. - bool EvaluateCostFunctorImpl(const CostFunctor* functor, - double const* const* parameters, - double* residuals, - const void* /* NOT USED */) const { - return (*functor)(parameters, residuals); - } - - bool EvaluateCostFunctorImpl(const CostFunctor* functor, - double const* const* parameters, - double* residuals, - const CostFunction* /* NOT USED */) const { - return functor->Evaluate(parameters, residuals, NULL); - } - - internal::scoped_ptr<const CostFunctor> functor_; - Ownership ownership_; - const double relative_step_size_; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_DYNAMIC_AUTODIFF_COST_FUNCTION_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/fpclassify.h b/extern/libmv/third_party/ceres/include/ceres/fpclassify.h deleted file mode 100644 index da8a4d086b8..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/fpclassify.h +++ /dev/null @@ -1,87 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 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: keir@google.com (Keir Mierle) -// -// Portable floating point classification. The names are picked such that they -// do not collide with macros. For example, "isnan" in C99 is a macro and hence -// does not respect namespaces. -// -// TODO(keir): Finish porting! - -#ifndef CERES_PUBLIC_FPCLASSIFY_H_ -#define CERES_PUBLIC_FPCLASSIFY_H_ - -#if defined(_MSC_VER) -#include <float.h> -#endif - -#include <limits> - -namespace ceres { - -#if defined(_MSC_VER) - -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); -} - -# else - -// These definitions are for the normal Unix suspects. -inline bool IsFinite (double x) { return std::isfinite(x); } -inline bool IsInfinite(double x) { return std::isinf(x); } -inline bool IsNaN (double x) { return std::isnan(x); } -inline bool IsNormal (double x) { return std::isnormal(x); } - -#endif - -} // namespace ceres - -#endif // CERES_PUBLIC_FPCLASSIFY_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h b/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h deleted file mode 100644 index 79ebae5f13e..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/gradient_checker.h +++ /dev/null @@ -1,222 +0,0 @@ -// 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/ -// -// 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. -// Copyright 2007 Google Inc. All Rights Reserved. -// -// Author: wjr@google.com (William Rucklidge) -// -// This file contains a class that exercises a cost function, to make sure -// that it is computing reasonable derivatives. It compares the Jacobians -// computed by the cost function with those obtained by finite -// differences. - -#ifndef CERES_PUBLIC_GRADIENT_CHECKER_H_ -#define CERES_PUBLIC_GRADIENT_CHECKER_H_ - -#include <cstddef> -#include <algorithm> -#include <vector> - -#include "ceres/internal/eigen.h" -#include "ceres/internal/fixed_array.h" -#include "ceres/internal/macros.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/numeric_diff_cost_function.h" -#include "glog/logging.h" - -namespace ceres { - -// An object that exercises a cost function, to compare the answers that it -// gives with derivatives estimated using finite differencing. -// -// The only likely usage of this is for testing. -// -// How to use: Fill in an array of pointers to parameter blocks for your -// CostFunction, and then call Probe(). Check that the return value is -// 'true'. See prober_test.cc for an example. -// -// This is templated similarly to NumericDiffCostFunction, as it internally -// uses that. -template <typename CostFunctionToProbe, - int M = 0, int N0 = 0, int N1 = 0, int N2 = 0, int N3 = 0, int N4 = 0> -class GradientChecker { - public: - // Here we stash some results from the probe, for later - // inspection. - struct GradientCheckResults { - // Computed cost. - Vector cost; - - // The sizes of these matrices are dictated by the cost function's - // parameter and residual block sizes. Each vector's length will - // term->parameter_block_sizes().size(), and each matrix is the - // Jacobian of the residual with respect to the corresponding parameter - // block. - - // Derivatives as computed by the cost function. - vector<Matrix> term_jacobians; - - // Derivatives as computed by finite differencing. - vector<Matrix> finite_difference_jacobians; - - // Infinity-norm of term_jacobians - finite_difference_jacobians. - double error_jacobians; - }; - - // Checks the Jacobian computed by a cost function. - // - // probe_point: The parameter values at which to probe. - // error_tolerance: A threshold for the infinity-norm difference - // between the Jacobians. If the Jacobians differ by more than - // this amount, then the probe fails. - // - // term: The cost function to test. Not retained after this call returns. - // - // results: On return, the two Jacobians (and other information) - // will be stored here. May be NULL. - // - // Returns true if no problems are detected and the difference between the - // Jacobians is less than error_tolerance. - static bool Probe(double const* const* probe_point, - double error_tolerance, - CostFunctionToProbe *term, - GradientCheckResults* results) { - CHECK_NOTNULL(probe_point); - CHECK_NOTNULL(term); - LOG(INFO) << "-------------------- Starting Probe() --------------------"; - - // We need a GradientCheckeresults, whether or not they supplied one. - internal::scoped_ptr<GradientCheckResults> owned_results; - if (results == NULL) { - owned_results.reset(new GradientCheckResults); - results = owned_results.get(); - } - - // 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 int num_blocks = block_sizes.size(); - - CHECK_LE(num_blocks, 5) << "Unable to test functions that take more " - << "than 5 parameter blocks"; - if (N0) { - CHECK_EQ(N0, block_sizes[0]); - CHECK_GE(num_blocks, 1); - } else { - CHECK_LT(num_blocks, 1); - } - if (N1) { - CHECK_EQ(N1, block_sizes[1]); - CHECK_GE(num_blocks, 2); - } else { - CHECK_LT(num_blocks, 2); - } - if (N2) { - CHECK_EQ(N2, block_sizes[2]); - CHECK_GE(num_blocks, 3); - } else { - CHECK_LT(num_blocks, 3); - } - if (N3) { - CHECK_EQ(N3, block_sizes[3]); - CHECK_GE(num_blocks, 4); - } else { - CHECK_LT(num_blocks, 4); - } - if (N4) { - CHECK_EQ(N4, block_sizes[4]); - CHECK_GE(num_blocks, 5); - } else { - CHECK_LT(num_blocks, 5); - } - - results->term_jacobians.clear(); - results->term_jacobians.resize(num_blocks); - results->finite_difference_jacobians.clear(); - results->finite_difference_jacobians.resize(num_blocks); - - internal::FixedArray<double*> term_jacobian_pointers(num_blocks); - internal::FixedArray<double*> - finite_difference_jacobian_pointers(num_blocks); - for (int i = 0; i < num_blocks; i++) { - results->term_jacobians[i].resize(num_residuals, block_sizes[i]); - term_jacobian_pointers[i] = results->term_jacobians[i].data(); - results->finite_difference_jacobians[i].resize( - num_residuals, block_sizes[i]); - finite_difference_jacobian_pointers[i] = - results->finite_difference_jacobians[i].data(); - } - results->cost.resize(num_residuals, 1); - - CHECK(term->Evaluate(probe_point, results->cost.data(), - term_jacobian_pointers.get())); - NumericDiffCostFunction<CostFunctionToProbe, CENTRAL, M, N0, N1, N2, N3, N4> - numeric_term(term, DO_NOT_TAKE_OWNERSHIP); - CHECK(numeric_term.Evaluate(probe_point, results->cost.data(), - finite_difference_jacobian_pointers.get())); - - results->error_jacobians = 0; - for (int i = 0; i < num_blocks; i++) { - Matrix jacobian_difference = results->term_jacobians[i] - - results->finite_difference_jacobians[i]; - results->error_jacobians = - std::max(results->error_jacobians, - jacobian_difference.lpNorm<Eigen::Infinity>()); - } - - LOG(INFO) << "========== term-computed derivatives =========="; - for (int i = 0; i < num_blocks; i++) { - LOG(INFO) << "term_computed block " << i; - LOG(INFO) << "\n" << results->term_jacobians[i]; - } - - LOG(INFO) << "========== finite-difference derivatives =========="; - for (int i = 0; i < num_blocks; i++) { - LOG(INFO) << "finite_difference block " << i; - LOG(INFO) << "\n" << results->finite_difference_jacobians[i]; - } - - LOG(INFO) << "========== difference =========="; - for (int i = 0; i < num_blocks; i++) { - LOG(INFO) << "difference block " << i; - LOG(INFO) << (results->term_jacobians[i] - - results->finite_difference_jacobians[i]); - } - - LOG(INFO) << "||difference|| = " << results->error_jacobians; - - return results->error_jacobians < error_tolerance; - } - - private: - CERES_DISALLOW_IMPLICIT_CONSTRUCTORS(GradientChecker); -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_GRADIENT_CHECKER_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h b/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h deleted file mode 100644 index 55a8be1df09..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/gradient_problem.h +++ /dev/null @@ -1,127 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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_PUBLIC_GRADIENT_PROBLEM_H_ -#define CERES_PUBLIC_GRADIENT_PROBLEM_H_ - -#include "ceres/internal/macros.h" -#include "ceres/internal/port.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/local_parameterization.h" - -namespace ceres { - -class FirstOrderFunction; - -// Instances of GradientProblem represent general non-linear -// optimization problems that must be solved using just the value of -// the objective function and its gradient. Unlike the Problem class, -// which can only be used to model non-linear least squares problems, -// instances of GradientProblem not restricted in the form of the -// objective function. -// -// Structurally GradientProblem is a composition of a -// FirstOrderFunction and optionally a LocalParameterization. -// -// The FirstOrderFunction is responsible for evaluating the cost and -// gradient of the objective function. -// -// The LocalParameterization is responsible for going back and forth -// between the ambient space and the local tangent space. (See -// local_parameterization.h for more details). When a -// LocalParameterization is not provided, then the tangent space is -// assumed to coincide with the ambient Euclidean space that the -// gradient vector lives in. -// -// Example usage: -// -// The following demonstrate the problem construction for Rosenbrock's function -// -// f(x,y) = (1-x)^2 + 100(y - x^2)^2; -// -// class Rosenbrock : public ceres::FirstOrderFunction { -// public: -// virtual ~Rosenbrock() {} -// -// virtual bool Evaluate(const double* parameters, -// double* cost, -// double* gradient) const { -// const double x = parameters[0]; -// const double y = parameters[1]; -// -// cost[0] = (1.0 - x) * (1.0 - x) + 100.0 * (y - x * x) * (y - x * x); -// if (gradient != NULL) { -// gradient[0] = -2.0 * (1.0 - x) - 200.0 * (y - x * x) * 2.0 * x; -// gradient[1] = 200.0 * (y - x * x); -// } -// return true; -// }; -// -// virtual int NumParameters() const { return 2; }; -// }; -// -// ceres::GradientProblem problem(new Rosenbrock()); -class CERES_EXPORT GradientProblem { - public: - // Takes ownership of the function. - explicit GradientProblem(FirstOrderFunction* function); - - // Takes ownership of the function and the parameterization. - GradientProblem(FirstOrderFunction* function, - LocalParameterization* parameterization); - - int NumParameters() const; - int NumLocalParameters() const; - - // This call is not thread safe. - bool Evaluate(const double* parameters, double* cost, double* gradient) const; - bool Plus(const double* x, const double* delta, double* x_plus_delta) const; - - private: - internal::scoped_ptr<FirstOrderFunction> function_; - internal::scoped_ptr<LocalParameterization> parameterization_; - internal::scoped_array<double> scratch_; -}; - -// A FirstOrderFunction object implements the evaluation of a function -// and its gradient. -class CERES_EXPORT FirstOrderFunction { - public: - virtual ~FirstOrderFunction() {} - // cost is never NULL. gradient may be null. - virtual bool Evaluate(const double* const parameters, - double* cost, - double* gradient) const = 0; - virtual int NumParameters() const = 0; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_GRADIENT_PROBLEM_H_ 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 deleted file mode 100644 index db706f7dbaf..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/gradient_problem_solver.h +++ /dev/null @@ -1,353 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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_PUBLIC_GRADIENT_PROBLEM_SOLVER_H_ -#define CERES_PUBLIC_GRADIENT_PROBLEM_SOLVER_H_ - -#include <cmath> -#include <string> -#include <vector> -#include "ceres/internal/macros.h" -#include "ceres/internal/port.h" -#include "ceres/iteration_callback.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -class GradientProblem; - -class CERES_EXPORT GradientProblemSolver { - public: - virtual ~GradientProblemSolver(); - - // The options structure contains, not surprisingly, options that control how - // the solver operates. The defaults should be suitable for a wide range of - // problems; however, better performance is often obtainable with tweaking. - // - // The constants are defined inside types.h - struct CERES_EXPORT Options { - // Default constructor that sets up a generic sparse problem. - Options() { - line_search_direction_type = LBFGS; - line_search_type = WOLFE; - nonlinear_conjugate_gradient_type = FLETCHER_REEVES; - max_lbfgs_rank = 20; - use_approximate_eigenvalue_bfgs_scaling = false; - line_search_interpolation_type = CUBIC; - min_line_search_step_size = 1e-9; - line_search_sufficient_function_decrease = 1e-4; - max_line_search_step_contraction = 1e-3; - min_line_search_step_contraction = 0.6; - max_num_line_search_step_size_iterations = 20; - max_num_line_search_direction_restarts = 5; - line_search_sufficient_curvature_decrease = 0.9; - max_line_search_step_expansion = 10.0; - max_num_iterations = 50; - max_solver_time_in_seconds = 1e9; - function_tolerance = 1e-6; - gradient_tolerance = 1e-10; - logging_type = PER_MINIMIZER_ITERATION; - minimizer_progress_to_stdout = false; - } - - // 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; - - // Minimizer options ---------------------------------------- - LineSearchDirectionType line_search_direction_type; - LineSearchType line_search_type; - NonlinearConjugateGradientType nonlinear_conjugate_gradient_type; - - // The LBFGS hessian approximation is a low rank approximation to - // the inverse of the Hessian matrix. The rank of the - // approximation determines (linearly) the space and time - // complexity of using the approximation. Higher the rank, the - // better is the quality of the approximation. The increase in - // quality is however is bounded for a number of reasons. - // - // 1. The method only uses secant information and not actual - // derivatives. - // - // 2. The Hessian approximation is constrained to be positive - // definite. - // - // So increasing this rank to a large number will cost time and - // space complexity without the corresponding increase in solution - // quality. There are no hard and fast rules for choosing the - // maximum rank. The best choice usually requires some problem - // specific experimentation. - // - // For more theoretical and implementation details of the LBFGS - // method, please see: - // - // Nocedal, J. (1980). "Updating Quasi-Newton Matrices with - // Limited Storage". Mathematics of Computation 35 (151): 773–782. - int max_lbfgs_rank; - - // As part of the (L)BFGS update step (BFGS) / right-multiply step (L-BFGS), - // the initial inverse Hessian approximation is taken to be the Identity. - // However, Oren showed that using instead I * \gamma, where \gamma is - // chosen to approximate an eigenvalue of the true inverse Hessian can - // result in improved convergence in a wide variety of cases. Setting - // use_approximate_eigenvalue_bfgs_scaling to true enables this scaling. - // - // It is important to note that approximate eigenvalue scaling does not - // always improve convergence, and that it can in fact significantly degrade - // performance for certain classes of problem, which is why it is disabled - // by default. In particular it can degrade performance when the - // sensitivity of the problem to different parameters varies significantly, - // as in this case a single scalar factor fails to capture this variation - // and detrimentally downscales parts of the jacobian approximation which - // correspond to low-sensitivity parameters. It can also reduce the - // robustness of the solution to errors in the jacobians. - // - // Oren S.S., Self-scaling variable metric (SSVM) algorithms - // Part II: Implementation and experiments, Management Science, - // 20(5), 863-874, 1974. - bool use_approximate_eigenvalue_bfgs_scaling; - - // Degree of the polynomial used to approximate the objective - // function. Valid values are BISECTION, QUADRATIC and CUBIC. - // - // BISECTION corresponds to pure backtracking search with no - // interpolation. - LineSearchInterpolationType line_search_interpolation_type; - - // If during the line search, the step_size falls below this - // value, it is truncated to zero. - double min_line_search_step_size; - - // Line search parameters. - - // Solving the line search problem exactly is computationally - // prohibitive. Fortunately, line search based optimization - // algorithms can still guarantee convergence if instead of an - // exact solution, the line search algorithm returns a solution - // which decreases the value of the objective function - // sufficiently. More precisely, we are looking for a step_size - // s.t. - // - // f(step_size) <= f(0) + sufficient_decrease * f'(0) * step_size - // - double line_search_sufficient_function_decrease; - - // In each iteration of the line search, - // - // new_step_size >= max_line_search_step_contraction * step_size - // - // Note that by definition, for contraction: - // - // 0 < max_step_contraction < min_step_contraction < 1 - // - double max_line_search_step_contraction; - - // In each iteration of the line search, - // - // new_step_size <= min_line_search_step_contraction * step_size - // - // Note that by definition, for contraction: - // - // 0 < max_step_contraction < min_step_contraction < 1 - // - double min_line_search_step_contraction; - - // Maximum number of trial step size iterations during each line search, - // if a step size satisfying the search conditions cannot be found within - // this number of trials, the line search will terminate. - int max_num_line_search_step_size_iterations; - - // Maximum number of restarts of the line search direction algorithm before - // terminating the optimization. Restarts of the line search direction - // algorithm occur when the current algorithm fails to produce a new descent - // direction. This typically indicates a numerical failure, or a breakdown - // in the validity of the approximations used. - int max_num_line_search_direction_restarts; - - // The strong Wolfe conditions consist of the Armijo sufficient - // decrease condition, and an additional requirement that the - // step-size be chosen s.t. the _magnitude_ ('strong' Wolfe - // conditions) of the gradient along the search direction - // decreases sufficiently. Precisely, this second condition - // is that we seek a step_size s.t. - // - // |f'(step_size)| <= sufficient_curvature_decrease * |f'(0)| - // - // Where f() is the line search objective and f'() is the derivative - // of f w.r.t step_size (d f / d step_size). - double line_search_sufficient_curvature_decrease; - - // During the bracketing phase of the Wolfe search, the step size is - // increased until either a point satisfying the Wolfe conditions is - // found, or an upper bound for a bracket containing a point satisfying - // the conditions is found. Precisely, at each iteration of the - // expansion: - // - // new_step_size <= max_step_expansion * step_size. - // - // By definition for expansion, max_step_expansion > 1.0. - double max_line_search_step_expansion; - - // Maximum number of iterations for the minimizer to run for. - int max_num_iterations; - - // Maximum time for which the minimizer should run for. - double max_solver_time_in_seconds; - - // Minimizer terminates when - // - // (new_cost - old_cost) < function_tolerance * old_cost; - // - double function_tolerance; - - // Minimizer terminates when - // - // max_i |x - Project(Plus(x, -g(x))| < gradient_tolerance - // - // This value should typically be 1e-4 * function_tolerance. - double gradient_tolerance; - - // Logging options --------------------------------------------------------- - - LoggingType logging_type; - - // By default the Minimizer progress is logged to VLOG(1), which - // is sent to STDERR depending on the vlog level. If this flag is - // set to true, and logging_type is not SILENT, the logging output - // is sent to STDOUT. - bool minimizer_progress_to_stdout; - - // Callbacks that are executed at the end of each iteration of the - // Minimizer. An iteration may terminate midway, either due to - // numerical failures or because one of the convergence tests has - // been satisfied. In this case none of the callbacks are - // executed. - - // Callbacks are executed in the order that they are specified in - // this vector. By default, parameter blocks are updated only at - // the end of the optimization, i.e when the Minimizer - // terminates. This behaviour is controlled by - // update_state_every_variable. If the user wishes to have access - // to the update parameter blocks when his/her callbacks are - // executed, then set update_state_every_iteration to true. - // - // The solver does NOT take ownership of these pointers. - vector<IterationCallback*> callbacks; - }; - - struct CERES_EXPORT Summary { - Summary(); - - // A brief one line description of the state of the solver after - // termination. - string BriefReport() const; - - // A full multiline description of the state of the solver after - // termination. - string FullReport() const; - - bool IsSolutionUsable() const; - - // Minimizer summary ------------------------------------------------- - TerminationType termination_type; - - // Reason why the solver terminated. - string message; - - // Cost of the problem (value of the objective function) before - // the optimization. - double initial_cost; - - // Cost of the problem (value of the objective function) after the - // optimization. - double final_cost; - - // IterationSummary for each minimizer iteration in order. - vector<IterationSummary> iterations; - - // Sum total of all time spent inside Ceres when Solve is called. - double total_time_in_seconds; - - // Time (in seconds) spent evaluating the cost. - double cost_evaluation_time_in_seconds; - - // Time (in seconds) spent evaluating the gradient. - double gradient_evaluation_time_in_seconds; - - // Number of parameters in the probem. - int num_parameters; - - // Dimension of the tangent space of the problem. - int num_local_parameters; - - // Type of line search direction used. - LineSearchDirectionType line_search_direction_type; - - // Type of the line search algorithm used. - LineSearchType line_search_type; - - // When performing line search, the degree of the polynomial used - // to approximate the objective function. - LineSearchInterpolationType line_search_interpolation_type; - - // If the line search direction is NONLINEAR_CONJUGATE_GRADIENT, - // then this indicates the particular variant of non-linear - // conjugate gradient used. - NonlinearConjugateGradientType nonlinear_conjugate_gradient_type; - - // If the type of the line search direction is LBFGS, then this - // indicates the rank of the Hessian approximation. - int max_lbfgs_rank; - }; - - // Once a least squares problem has been built, this function takes - // the problem and optimizes it based on the values of the options - // parameters. Upon return, a detailed summary of the work performed - // by the preprocessor, the non-linear minmizer and the linear - // solver are reported in the summary object. - virtual void Solve(const GradientProblemSolver::Options& options, - const GradientProblem& problem, - double* parameters, - GradientProblemSolver::Summary* summary); -}; - -// Helper function which avoids going through the interface. -CERES_EXPORT void Solve(const GradientProblemSolver::Options& options, - const GradientProblem& problem, - double* parameters, - GradientProblemSolver::Summary* summary); - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_GRADIENT_PROBLEM_SOLVER_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h b/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h deleted file mode 100644 index 3a96625e3fd..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h +++ /dev/null @@ -1,317 +0,0 @@ -// 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/ -// -// 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: keir@google.com (Keir Mierle) -// -// Computation of the Jacobian matrix for vector-valued functions of multiple -// variables, using automatic differentiation based on the implementation of -// dual numbers in jet.h. Before reading the rest of this file, it is adivsable -// to read jet.h's header comment in detail. -// -// The helper wrapper AutoDiff::Differentiate() computes the jacobian of -// functors with templated operator() taking this form: -// -// struct F { -// template<typename T> -// bool operator()(const T *x, const T *y, ..., T *z) { -// // Compute z[] based on x[], y[], ... -// // return true if computation succeeded, false otherwise. -// } -// }; -// -// All inputs and outputs may be vector-valued. -// -// To understand how jets are used to compute the jacobian, a -// picture may help. Consider a vector-valued function, F, returning 3 -// dimensions and taking a vector-valued parameter of 4 dimensions: -// -// y x -// [ * ] F [ * ] -// [ * ] <--- [ * ] -// [ * ] [ * ] -// [ * ] -// -// Similar to the 2-parameter example for f described in jet.h, computing the -// jacobian dy/dx is done by substutiting a suitable jet object for x and all -// intermediate steps of the computation of F. Since x is has 4 dimensions, use -// a Jet<double, 4>. -// -// Before substituting a jet object for x, the dual components are set -// appropriately for each dimension of x: -// -// y x -// [ * | * * * * ] f [ * | 1 0 0 0 ] x0 -// [ * | * * * * ] <--- [ * | 0 1 0 0 ] x1 -// [ * | * * * * ] [ * | 0 0 1 0 ] x2 -// ---+--- [ * | 0 0 0 1 ] x3 -// | ^ ^ ^ ^ -// dy/dx | | | +----- infinitesimal for x3 -// | | +------- infinitesimal for x2 -// | +--------- infinitesimal for x1 -// +----------- infinitesimal for x0 -// -// The reason to set the internal 4x4 submatrix to the identity is that we wish -// to take the derivative of y separately with respect to each dimension of x. -// Each column of the 4x4 identity is therefore for a single component of the -// independent variable x. -// -// Then the jacobian of the mapping, dy/dx, is the 3x4 sub-matrix of the -// extended y vector, indicated in the above diagram. -// -// Functors with multiple parameters -// --------------------------------- -// In practice, it is often convenient to use a function f of two or more -// vector-valued parameters, for example, x[3] and z[6]. Unfortunately, the jet -// framework is designed for a single-parameter vector-valued input. The wrapper -// in this file addresses this issue adding support for functions with one or -// more parameter vectors. -// -// To support multiple parameters, all the parameter vectors are concatenated -// into one and treated as a single parameter vector, except that since the -// functor expects different inputs, we need to construct the jets as if they -// were part of a single parameter vector. The extended jets are passed -// separately for each parameter. -// -// For example, consider a functor F taking two vector parameters, p[2] and -// q[3], and producing an output y[4]: -// -// struct F { -// template<typename T> -// bool operator()(const T *p, const T *q, T *z) { -// // ... -// } -// }; -// -// In this case, the necessary jet type is Jet<double, 5>. Here is a -// visualization of the jet objects in this case: -// -// Dual components for p ----+ -// | -// -+- -// y [ * | 1 0 | 0 0 0 ] --- p[0] -// [ * | 0 1 | 0 0 0 ] --- p[1] -// [ * | . . | + + + ] | -// [ * | . . | + + + ] v -// [ * | . . | + + + ] <--- F(p, q) -// [ * | . . | + + + ] ^ -// ^^^ ^^^^^ | -// dy/dp dy/dq [ * | 0 0 | 1 0 0 ] --- q[0] -// [ * | 0 0 | 0 1 0 ] --- q[1] -// [ * | 0 0 | 0 0 1 ] --- q[2] -// --+-- -// | -// Dual components for q --------------+ -// -// where the 4x2 submatrix (marked with ".") and 4x3 submatrix (marked with "+" -// of y in the above diagram are the derivatives of y with respect to p and q -// respectively. This is how autodiff works for functors taking multiple vector -// valued arguments (up to 6). -// -// Jacobian NULL pointers -// ---------------------- -// In general, the functions below will accept NULL pointers for all or some of -// the Jacobian parameters, meaning that those Jacobians will not be computed. - -#ifndef CERES_PUBLIC_INTERNAL_AUTODIFF_H_ -#define CERES_PUBLIC_INTERNAL_AUTODIFF_H_ - -#include <stddef.h> - -#include "ceres/jet.h" -#include "ceres/internal/eigen.h" -#include "ceres/internal/fixed_array.h" -#include "ceres/internal/variadic_evaluate.h" -#include "glog/logging.h" - -namespace ceres { -namespace internal { - -// Extends src by a 1st order pertubation for every dimension and puts it in -// dst. The size of src is N. Since this is also used for perturbations in -// blocked arrays, offset is used to shift which part of the jet the -// perturbation occurs. This is used to set up the extended x augmented by an -// identity matrix. The JetT type should be a Jet type, and T should be a -// numeric type (e.g. double). For example, -// -// 0 1 2 3 4 5 6 7 8 -// dst[0] [ * | . . | 1 0 0 | . . . ] -// dst[1] [ * | . . | 0 1 0 | . . . ] -// dst[2] [ * | . . | 0 0 1 | . . . ] -// -// is what would get put in dst if N was 3, offset was 3, and the jet type JetT -// was 8-dimensional. -template <typename JetT, typename T, int N> -inline void Make1stOrderPerturbation(int offset, const T* src, JetT* dst) { - DCHECK(src); - DCHECK(dst); - for (int j = 0; j < N; ++j) { - dst[j].a = src[j]; - dst[j].v.setZero(); - dst[j].v[offset + j] = T(1.0); - } -} - -// Takes the 0th order part of src, assumed to be a Jet type, and puts it in -// dst. This is used to pick out the "vector" part of the extended y. -template <typename JetT, typename T> -inline void Take0thOrderPart(int M, const JetT *src, T dst) { - DCHECK(src); - for (int i = 0; i < M; ++i) { - dst[i] = src[i].a; - } -} - -// Takes N 1st order parts, starting at index N0, and puts them in the M x N -// matrix 'dst'. This is used to pick out the "matrix" parts of the extended y. -template <typename JetT, typename T, int N0, int N> -inline void Take1stOrderPart(const int M, const JetT *src, T *dst) { - DCHECK(src); - DCHECK(dst); - for (int i = 0; i < M; ++i) { - Eigen::Map<Eigen::Matrix<T, N, 1> >(dst + N * i, N) = - src[i].v.template segment<N>(N0); - } -} - -// This is in a struct because default template parameters on a -// function are not supported in C++03 (though it is available in -// C++0x). N0 through N5 are the dimension of the input arguments to -// the user supplied functor. -template <typename Functor, typename T, - int N0 = 0, int N1 = 0, int N2 = 0, int N3 = 0, int N4 = 0, - int N5 = 0, int N6 = 0, int N7 = 0, int N8 = 0, int N9 = 0> -struct AutoDiff { - static bool Differentiate(const Functor& functor, - T const *const *parameters, - int num_outputs, - T *function_value, - T **jacobians) { - // 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))) - << "Zero block cannot precede a non-zero block. Block sizes are " - << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", " - << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", " - << N8 << ", " << N9; - - typedef Jet<T, N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9> JetT; - FixedArray<JetT, (256 * 7) / sizeof(JetT)> x( - N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9 + num_outputs); - - // These are the positions of the respective jets in the fixed array x. - const int jet0 = 0; - const int jet1 = N0; - const int jet2 = N0 + N1; - const int jet3 = N0 + N1 + N2; - const int jet4 = N0 + N1 + N2 + N3; - const int jet5 = N0 + N1 + N2 + N3 + N4; - const int jet6 = N0 + N1 + N2 + N3 + N4 + N5; - const int jet7 = N0 + N1 + N2 + N3 + N4 + N5 + N6; - const int jet8 = N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7; - const int jet9 = N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8; - - const JetT *unpacked_parameters[10] = { - x.get() + jet0, - x.get() + jet1, - x.get() + jet2, - x.get() + jet3, - x.get() + jet4, - x.get() + jet5, - x.get() + jet6, - x.get() + jet7, - x.get() + jet8, - x.get() + jet9, - }; - - JetT* output = x.get() + N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9; - -#define CERES_MAKE_1ST_ORDER_PERTURBATION(i) \ - if (N ## i) { \ - internal::Make1stOrderPerturbation<JetT, T, N ## i>( \ - jet ## i, \ - parameters[i], \ - x.get() + jet ## i); \ - } - CERES_MAKE_1ST_ORDER_PERTURBATION(0); - CERES_MAKE_1ST_ORDER_PERTURBATION(1); - CERES_MAKE_1ST_ORDER_PERTURBATION(2); - CERES_MAKE_1ST_ORDER_PERTURBATION(3); - CERES_MAKE_1ST_ORDER_PERTURBATION(4); - CERES_MAKE_1ST_ORDER_PERTURBATION(5); - CERES_MAKE_1ST_ORDER_PERTURBATION(6); - CERES_MAKE_1ST_ORDER_PERTURBATION(7); - CERES_MAKE_1ST_ORDER_PERTURBATION(8); - CERES_MAKE_1ST_ORDER_PERTURBATION(9); -#undef CERES_MAKE_1ST_ORDER_PERTURBATION - - if (!VariadicEvaluate<Functor, JetT, - N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>::Call( - functor, unpacked_parameters, output)) { - return false; - } - - internal::Take0thOrderPart(num_outputs, output, function_value); - -#define CERES_TAKE_1ST_ORDER_PERTURBATION(i) \ - if (N ## i) { \ - if (jacobians[i]) { \ - internal::Take1stOrderPart<JetT, T, \ - jet ## i, \ - N ## i>(num_outputs, \ - output, \ - jacobians[i]); \ - } \ - } - CERES_TAKE_1ST_ORDER_PERTURBATION(0); - CERES_TAKE_1ST_ORDER_PERTURBATION(1); - CERES_TAKE_1ST_ORDER_PERTURBATION(2); - CERES_TAKE_1ST_ORDER_PERTURBATION(3); - CERES_TAKE_1ST_ORDER_PERTURBATION(4); - CERES_TAKE_1ST_ORDER_PERTURBATION(5); - CERES_TAKE_1ST_ORDER_PERTURBATION(6); - CERES_TAKE_1ST_ORDER_PERTURBATION(7); - CERES_TAKE_1ST_ORDER_PERTURBATION(8); - CERES_TAKE_1ST_ORDER_PERTURBATION(9); -#undef CERES_TAKE_1ST_ORDER_PERTURBATION - return true; - } -}; - -} // namespace internal -} // namespace ceres - -#endif // CERES_PUBLIC_INTERNAL_AUTODIFF_H_ 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 deleted file mode 100644 index 78924de1346..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/disable_warnings.h +++ /dev/null @@ -1,44 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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. -// -// This file has the sole purpose to silence warnings when including Ceres. - -// This is not your usual header guard. The macro CERES_WARNINGS_DISABLED -// shows up again in reenable_warnings.h. -#ifndef CERES_WARNINGS_DISABLED -#define CERES_WARNINGS_DISABLED - -#ifdef _MSC_VER -#pragma warning( push ) -// Disable the warning C4251 which is trigerred by stl classes in -// Ceres' public interface. To quote MSDN: "C4251 can be ignored " -// "if you are deriving from a type in the Standard C++ Library" -#pragma warning( disable : 4251 ) -#endif - -#endif // CERES_WARNINGS_DISABLED diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h b/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h deleted file mode 100644 index 85df54b8f99..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/eigen.h +++ /dev/null @@ -1,93 +0,0 @@ -// 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/ -// -// 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_EIGEN_H_ -#define CERES_INTERNAL_EIGEN_H_ - -#include "Eigen/Core" - -namespace ceres { - -typedef Eigen::Matrix<double, Eigen::Dynamic, 1> Vector; -typedef Eigen::Matrix<double, - Eigen::Dynamic, - Eigen::Dynamic, - Eigen::RowMajor> Matrix; -typedef Eigen::Map<Vector> VectorRef; -typedef Eigen::Map<Matrix> MatrixRef; -typedef Eigen::Map<const Vector> ConstVectorRef; -typedef Eigen::Map<const Matrix> ConstMatrixRef; - -// Column major matrices for DenseSparseMatrix/DenseQRSolver -typedef Eigen::Matrix<double, - Eigen::Dynamic, - Eigen::Dynamic, - Eigen::ColMajor> ColMajorMatrix; - -typedef Eigen::Map<ColMajorMatrix, 0, - Eigen::Stride<Eigen::Dynamic, 1> > ColMajorMatrixRef; - -typedef Eigen::Map<const ColMajorMatrix, - 0, - Eigen::Stride<Eigen::Dynamic, 1> > ConstColMajorMatrixRef; - - - -// C++ does not support templated typdefs, thus the need for this -// struct so that we can support statically sized Matrix and Maps. -template <int num_rows = Eigen::Dynamic, int num_cols = Eigen::Dynamic> -struct EigenTypes { - typedef Eigen::Matrix <double, num_rows, num_cols, Eigen::RowMajor> - Matrix; - - typedef Eigen::Map< - Eigen::Matrix<double, num_rows, num_cols, Eigen::RowMajor> > - MatrixRef; - - typedef Eigen::Matrix <double, num_rows, 1> - Vector; - - typedef Eigen::Map < - Eigen::Matrix<double, num_rows, 1> > - VectorRef; - - - typedef Eigen::Map< - const Eigen::Matrix<double, num_rows, num_cols, Eigen::RowMajor> > - ConstMatrixRef; - - typedef Eigen::Map < - const Eigen::Matrix<double, num_rows, 1> > - ConstVectorRef; -}; - -} // namespace ceres - -#endif // CERES_INTERNAL_EIGEN_H_ 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 deleted file mode 100644 index 694070b228c..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/fixed_array.h +++ /dev/null @@ -1,191 +0,0 @@ -// 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/ -// -// 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: rennie@google.com (Jeffrey Rennie) -// Author: sanjay@google.com (Sanjay Ghemawat) -- renamed to FixedArray - -#ifndef CERES_PUBLIC_INTERNAL_FIXED_ARRAY_H_ -#define CERES_PUBLIC_INTERNAL_FIXED_ARRAY_H_ - -#include <cstddef> -#include "Eigen/Core" -#include "ceres/internal/macros.h" -#include "ceres/internal/manual_constructor.h" -#include "glog/logging.h" - -namespace ceres { -namespace internal { - -// A FixedArray<T> represents a non-resizable array of T where the -// length of the array does not need to be a compile time constant. -// -// FixedArray allocates small arrays inline, and large arrays on -// the heap. It is a good replacement for non-standard and deprecated -// uses of alloca() and variable length arrays (a GCC extension). -// -// FixedArray keeps performance fast for small arrays, because it -// avoids heap operations. It also helps reduce the chances of -// accidentally overflowing your stack if large input is passed to -// your function. -// -// Also, FixedArray is useful for writing portable code. Not all -// compilers support arrays of dynamic size. - -// Most users should not specify an inline_elements argument and let -// FixedArray<> automatically determine the number of elements -// to store inline based on sizeof(T). -// -// If inline_elements is specified, the FixedArray<> implementation -// will store arrays of length <= inline_elements inline. -// -// Finally note that unlike vector<T> FixedArray<T> will not zero-initialize -// simple types like int, double, bool, etc. -// -// Non-POD types will be default-initialized just like regular vectors or -// arrays. - -#if defined(_WIN64) - typedef __int64 ssize_t; -#elif defined(_WIN32) - typedef __int32 ssize_t; -#endif - -template <typename T, ssize_t inline_elements = -1> -class FixedArray { - public: - // For playing nicely with stl: - typedef T value_type; - typedef T* iterator; - typedef T const* const_iterator; - typedef T& reference; - typedef T const& const_reference; - typedef T* pointer; - typedef std::ptrdiff_t difference_type; - typedef size_t size_type; - - // REQUIRES: n >= 0 - // Creates an array object that can store "n" elements. - // - // FixedArray<T> will not zero-initialiaze POD (simple) types like int, - // double, bool, etc. - // Non-POD types will be default-initialized just like regular vectors or - // arrays. - explicit FixedArray(size_type n); - - // Releases any resources. - ~FixedArray(); - - // Returns the length of the array. - inline size_type size() const { return size_; } - - // Returns the memory size of the array in bytes. - inline size_t memsize() const { return size_ * sizeof(T); } - - // Returns a pointer to the underlying element array. - inline const T* get() const { return &array_[0].element; } - inline T* get() { return &array_[0].element; } - - // REQUIRES: 0 <= i < size() - // Returns a reference to the "i"th element. - inline T& operator[](size_type i) { - DCHECK_LT(i, size_); - return array_[i].element; - } - - // REQUIRES: 0 <= i < size() - // Returns a reference to the "i"th element. - inline const T& operator[](size_type i) const { - DCHECK_LT(i, size_); - return array_[i].element; - } - - inline iterator begin() { return &array_[0].element; } - inline iterator end() { return &array_[size_].element; } - - inline const_iterator begin() const { return &array_[0].element; } - inline const_iterator end() const { return &array_[size_].element; } - - private: - // Container to hold elements of type T. This is necessary to handle - // the case where T is a a (C-style) array. The size of InnerContainer - // and T must be the same, otherwise callers' assumptions about use - // of this code will be broken. - struct InnerContainer { - T element; - }; - - // How many elements should we store inline? - // a. If not specified, use a default of 256 bytes (256 bytes - // seems small enough to not cause stack overflow or unnecessary - // stack pollution, while still allowing stack allocation for - // reasonably long character arrays. - // b. Never use 0 length arrays (not ISO C++) - static const size_type S1 = ((inline_elements < 0) - ? (256/sizeof(T)) : inline_elements); - static const size_type S2 = (S1 <= 0) ? 1 : S1; - static const size_type kInlineElements = S2; - - size_type const size_; - InnerContainer* const array_; - - // Allocate some space, not an array of elements of type T, so that we can - // skip calling the T constructors and destructors for space we never use. - ManualConstructor<InnerContainer> inline_space_[kInlineElements]; -}; - -// Implementation details follow - -template <class T, ssize_t S> -inline FixedArray<T, S>::FixedArray(typename FixedArray<T, S>::size_type n) - : size_(n), - array_((n <= kInlineElements - ? reinterpret_cast<InnerContainer*>(inline_space_) - : new InnerContainer[n])) { - // Construct only the elements actually used. - if (array_ == reinterpret_cast<InnerContainer*>(inline_space_)) { - for (size_t i = 0; i != size_; ++i) { - inline_space_[i].Init(); - } - } -} - -template <class T, ssize_t S> -inline FixedArray<T, S>::~FixedArray() { - if (array_ != reinterpret_cast<InnerContainer*>(inline_space_)) { - delete[] array_; - } else { - for (size_t i = 0; i != size_; ++i) { - inline_space_[i].Destroy(); - } - } -} - -} // namespace internal -} // namespace ceres - -#endif // CERES_PUBLIC_INTERNAL_FIXED_ARRAY_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/macros.h b/extern/libmv/third_party/ceres/include/ceres/internal/macros.h deleted file mode 100644 index 1ed55be6e03..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/macros.h +++ /dev/null @@ -1,170 +0,0 @@ -// 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/ -// -// 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. -// -// -// Various Google-specific macros. -// -// This code is compiled directly on many platforms, including client -// platforms like Windows, Mac, and embedded systems. Before making -// any changes here, make sure that you're not breaking any platforms. - -#ifndef CERES_PUBLIC_INTERNAL_MACROS_H_ -#define CERES_PUBLIC_INTERNAL_MACROS_H_ - -#include <cstddef> // For size_t. - -// A macro to disallow the copy constructor and operator= functions -// This should be used in the private: declarations for a class -// -// For disallowing only assign or copy, write the code directly, but declare -// the intend in a comment, for example: -// -// void operator=(const TypeName&); // _DISALLOW_ASSIGN - -// Note, that most uses of CERES_DISALLOW_ASSIGN and CERES_DISALLOW_COPY -// are broken semantically, one should either use disallow both or -// neither. Try to avoid these in new code. -#define CERES_DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&); \ - void operator=(const TypeName&) - -// A macro to disallow all the implicit constructors, namely the -// default constructor, copy constructor and operator= functions. -// -// This should be used in the private: declarations for a class -// that wants to prevent anyone from instantiating it. This is -// especially useful for classes containing only static methods. -#define CERES_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ - TypeName(); \ - CERES_DISALLOW_COPY_AND_ASSIGN(TypeName) - -// The arraysize(arr) macro returns the # of elements in an array arr. -// The expression is a compile-time constant, and therefore can be -// used in defining new arrays, for example. If you use arraysize on -// a pointer by mistake, you will get a compile-time error. -// -// One caveat is that arraysize() doesn't accept any array of an -// anonymous type or a type defined inside a function. In these rare -// cases, you have to use the unsafe ARRAYSIZE() macro below. This is -// due to a limitation in C++'s template system. The limitation might -// eventually be removed, but it hasn't happened yet. - -// This template function declaration is used in defining arraysize. -// Note that the function doesn't need an implementation, as we only -// use its type. -template <typename T, size_t N> -char (&ArraySizeHelper(T (&array)[N]))[N]; - -// That gcc wants both of these prototypes seems mysterious. VC, for -// its part, can't decide which to use (another mystery). Matching of -// template overloads: the final frontier. -#ifndef _WIN32 -template <typename T, size_t N> -char (&ArraySizeHelper(const T (&array)[N]))[N]; -#endif - -#define arraysize(array) (sizeof(ArraySizeHelper(array))) - -// ARRAYSIZE performs essentially the same calculation as arraysize, -// but can be used on anonymous types or types defined inside -// functions. It's less safe than arraysize as it accepts some -// (although not all) pointers. Therefore, you should use arraysize -// whenever possible. -// -// The expression ARRAYSIZE(a) is a compile-time constant of type -// size_t. -// -// ARRAYSIZE catches a few type errors. If you see a compiler error -// -// "warning: division by zero in ..." -// -// when using ARRAYSIZE, you are (wrongfully) giving it a pointer. -// You should only use ARRAYSIZE on statically allocated arrays. -// -// The following comments are on the implementation details, and can -// be ignored by the users. -// -// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in -// the array) and sizeof(*(arr)) (the # of bytes in one array -// element). If the former is divisible by the latter, perhaps arr is -// indeed an array, in which case the division result is the # of -// elements in the array. Otherwise, arr cannot possibly be an array, -// and we generate a compiler error to prevent the code from -// compiling. -// -// Since the size of bool is implementation-defined, we need to cast -// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final -// result has type size_t. -// -// This macro is not perfect as it wrongfully accepts certain -// pointers, namely where the pointer size is divisible by the pointee -// size. Since all our code has to go through a 32-bit compiler, -// where a pointer is 4 bytes, this means all pointers to a type whose -// size is 3 or greater than 4 will be (righteously) rejected. -// -// Kudos to Jorg Brown for this simple and elegant implementation. -// -// - wan 2005-11-16 -// -// Starting with Visual C++ 2005, WinNT.h includes ARRAYSIZE. However, -// the definition comes from the over-broad windows.h header that -// introduces a macro, ERROR, that conflicts with the logging framework -// that Ceres uses. Instead, rename ARRAYSIZE to CERES_ARRAYSIZE. -#define CERES_ARRAYSIZE(a) \ - ((sizeof(a) / sizeof(*(a))) / \ - static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) - -// Tell the compiler to warn about unused return values for functions -// declared with this macro. The macro should be used on function -// declarations following the argument list: -// -// Sprocket* AllocateSprocket() MUST_USE_RESULT; -// -#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \ - && !defined(COMPILER_ICC) -#define CERES_MUST_USE_RESULT __attribute__ ((warn_unused_result)) -#else -#define CERES_MUST_USE_RESULT -#endif - -// Platform independent macros to get aligned memory allocations. -// For example -// -// MyFoo my_foo CERES_ALIGN_ATTRIBUTE(16); -// -// Gives us an instance of MyFoo which is aligned at a 16 byte -// boundary. -#if defined(_MSC_VER) -#define CERES_ALIGN_ATTRIBUTE(n) __declspec(align(n)) -#define CERES_ALIGN_OF(T) __alignof(T) -#elif defined(__GNUC__) -#define CERES_ALIGN_ATTRIBUTE(n) __attribute__((aligned(n))) -#define CERES_ALIGN_OF(T) __alignof(T) -#endif - -#endif // CERES_PUBLIC_INTERNAL_MACROS_H_ 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 deleted file mode 100644 index 7ea723d2a83..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/manual_constructor.h +++ /dev/null @@ -1,208 +0,0 @@ -// 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/ -// -// 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: kenton@google.com (Kenton Varda) -// -// ManualConstructor statically-allocates space in which to store some -// object, but does not initialize it. You can then call the constructor -// and destructor for the object yourself as you see fit. This is useful -// for memory management optimizations, where you want to initialize and -// destroy an object multiple times but only allocate it once. -// -// (When I say ManualConstructor statically allocates space, I mean that -// the ManualConstructor object itself is forced to be the right size.) - -#ifndef CERES_PUBLIC_INTERNAL_MANUAL_CONSTRUCTOR_H_ -#define CERES_PUBLIC_INTERNAL_MANUAL_CONSTRUCTOR_H_ - -#include <new> - -namespace ceres { -namespace internal { - -// ------- Define CERES_ALIGNED_CHAR_ARRAY -------------------------------- - -#ifndef CERES_ALIGNED_CHAR_ARRAY - -// Because MSVC and older GCCs require that the argument to their alignment -// construct to be a literal constant integer, we use a template instantiated -// at all the possible powers of two. -template<int alignment, int size> struct AlignType { }; -template<int size> struct AlignType<0, size> { typedef char result[size]; }; - -#if !defined(CERES_ALIGN_ATTRIBUTE) -#define CERES_ALIGNED_CHAR_ARRAY you_must_define_CERES_ALIGNED_CHAR_ARRAY_for_your_compiler -#else // !defined(CERES_ALIGN_ATTRIBUTE) - -#define CERES_ALIGN_TYPE_TEMPLATE(X) \ - template<int size> struct AlignType<X, size> { \ - typedef CERES_ALIGN_ATTRIBUTE(X) char result[size]; \ - } - -CERES_ALIGN_TYPE_TEMPLATE(1); -CERES_ALIGN_TYPE_TEMPLATE(2); -CERES_ALIGN_TYPE_TEMPLATE(4); -CERES_ALIGN_TYPE_TEMPLATE(8); -CERES_ALIGN_TYPE_TEMPLATE(16); -CERES_ALIGN_TYPE_TEMPLATE(32); -CERES_ALIGN_TYPE_TEMPLATE(64); -CERES_ALIGN_TYPE_TEMPLATE(128); -CERES_ALIGN_TYPE_TEMPLATE(256); -CERES_ALIGN_TYPE_TEMPLATE(512); -CERES_ALIGN_TYPE_TEMPLATE(1024); -CERES_ALIGN_TYPE_TEMPLATE(2048); -CERES_ALIGN_TYPE_TEMPLATE(4096); -CERES_ALIGN_TYPE_TEMPLATE(8192); -// Any larger and MSVC++ will complain. - -#undef CERES_ALIGN_TYPE_TEMPLATE - -#define CERES_ALIGNED_CHAR_ARRAY(T, Size) \ - typename AlignType<CERES_ALIGN_OF(T), sizeof(T) * Size>::result - -#endif // !defined(CERES_ALIGN_ATTRIBUTE) - -#endif // CERES_ALIGNED_CHAR_ARRAY - -template <typename Type> -class ManualConstructor { - public: - // No constructor or destructor because one of the most useful uses of - // this class is as part of a union, and members of a union cannot have - // constructors or destructors. And, anyway, the whole point of this - // class is to bypass these. - - inline Type* get() { - return reinterpret_cast<Type*>(space_); - } - inline const Type* get() const { - return reinterpret_cast<const Type*>(space_); - } - - inline Type* operator->() { return get(); } - inline const Type* operator->() const { return get(); } - - inline Type& operator*() { return *get(); } - inline const Type& operator*() const { return *get(); } - - // This is needed to get around the strict aliasing warning GCC generates. - inline void* space() { - return reinterpret_cast<void*>(space_); - } - - // You can pass up to four constructor arguments as arguments of Init(). - inline void Init() { - new(space()) Type; - } - - template <typename T1> - inline void Init(const T1& p1) { - new(space()) Type(p1); - } - - template <typename T1, typename T2> - inline void Init(const T1& p1, const T2& p2) { - new(space()) Type(p1, p2); - } - - template <typename T1, typename T2, typename T3> - inline void Init(const T1& p1, const T2& p2, const T3& p3) { - new(space()) Type(p1, p2, p3); - } - - template <typename T1, typename T2, typename T3, typename T4> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4) { - new(space()) Type(p1, p2, p3, p4); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5) { - new(space()) Type(p1, p2, p3, p4, p5); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5, - typename T6> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5, const T6& p6) { - new(space()) Type(p1, p2, p3, p4, p5, p6); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5, - typename T6, typename T7> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5, const T6& p6, const T7& p7) { - new(space()) Type(p1, p2, p3, p4, p5, p6, p7); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5, - typename T6, typename T7, typename T8> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5, const T6& p6, const T7& p7, const T8& p8) { - new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5, - typename T6, typename T7, typename T8, typename T9> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5, const T6& p6, const T7& p7, const T8& p8, - const T9& p9) { - new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8, p9); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5, - typename T6, typename T7, typename T8, typename T9, typename T10> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5, const T6& p6, const T7& p7, const T8& p8, - const T9& p9, const T10& p10) { - new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); - } - - template <typename T1, typename T2, typename T3, typename T4, typename T5, - typename T6, typename T7, typename T8, typename T9, typename T10, - typename T11> - inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4, - const T5& p5, const T6& p6, const T7& p7, const T8& p8, - const T9& p9, const T10& p10, const T11& p11) { - new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); - } - - inline void Destroy() { - get()->~Type(); - } - - private: - CERES_ALIGNED_CHAR_ARRAY(Type, 1) space_; -}; - -#undef CERES_ALIGNED_CHAR_ARRAY - -} // namespace internal -} // namespace ceres - -#endif // CERES_PUBLIC_INTERNAL_MANUAL_CONSTRUCTOR_H_ 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 deleted file mode 100644 index 3b264b45af3..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/numeric_diff.h +++ /dev/null @@ -1,208 +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) -// mierle@gmail.com (Keir Mierle) -// -// Finite differencing routine used by NumericDiffCostFunction. - -#ifndef CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_ -#define CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_ - -#include <cstring> - -#include "Eigen/Dense" -#include "ceres/cost_function.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/internal/variadic_evaluate.h" -#include "ceres/types.h" -#include "glog/logging.h" - - -namespace ceres { -namespace internal { - -// Helper templates that allow evaluation of a variadic functor or a -// CostFunction object. -template <typename CostFunctor, - int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7, int N8, int N9 > -bool EvaluateImpl(const CostFunctor* functor, - double const* const* parameters, - double* residuals, - const void* /* NOT USED */) { - return VariadicEvaluate<CostFunctor, - double, - N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>::Call( - *functor, - parameters, - residuals); -} - -template <typename CostFunctor, - int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7, int N8, int N9 > -bool EvaluateImpl(const CostFunctor* functor, - double const* const* parameters, - double* residuals, - const CostFunction* /* NOT USED */) { - return functor->Evaluate(parameters, residuals, NULL); -} - -// This is split from the main class because C++ doesn't allow partial template -// specializations for member functions. The alternative is to repeat the main -// class for differing numbers of parameters, which is also unfortunate. -template <typename CostFunctor, - NumericDiffMethod kMethod, - int kNumResiduals, - int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7, int N8, int N9, - int kParameterBlock, - int kParameterBlockSize> -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, - int num_residuals, - double **parameters, - double *jacobian) { - using Eigen::Map; - using Eigen::Matrix; - using Eigen::RowMajor; - using Eigen::ColMajor; - - const int NUM_RESIDUALS = - (kNumResiduals != ceres::DYNAMIC ? kNumResiduals : num_residuals); - - typedef Matrix<double, kNumResiduals, 1> ResidualVector; - typedef Matrix<double, kParameterBlockSize, 1> ParameterVector; - - // The convoluted reasoning for choosing the Row/Column major - // ordering of the matrix is an artifact of the restrictions in - // Eigen that prevent it from creating RowMajor matrices with a - // single column. In these cases, we ask for a ColMajor matrix. - typedef Matrix<double, - kNumResiduals, - kParameterBlockSize, - (kParameterBlockSize == 1) ? ColMajor : RowMajor> - JacobianMatrix; - - Map<JacobianMatrix> parameter_jacobian(jacobian, - NUM_RESIDUALS, - kParameterBlockSize); - - // Mutate 1 element at a time and then restore. - Map<ParameterVector> x_plus_delta(parameters[kParameterBlock], - kParameterBlockSize); - ParameterVector x(x_plus_delta); - ParameterVector step_size = x.array().abs() * relative_step_size; - - // 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 each parameter in the parameter block, use finite differences to - // compute the derivative for that parameter. - - 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); - - x_plus_delta(j) = x(j) + 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. - parameter_jacobian.col(j) = 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; - - if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>( - functor, parameters, residuals.data(), functor)) { - return false; - } - - 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); - } - x_plus_delta(j) = x(j); // Restore x_plus_delta. - - // Divide out the run to get slope. - parameter_jacobian.col(j) *= one_over_delta; - } - return true; - } -}; - -template <typename CostFunctor, - NumericDiffMethod kMethod, - int kNumResiduals, - int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7, int N8, int N9, - int kParameterBlock> -struct NumericDiff<CostFunctor, kMethod, kNumResiduals, - N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, - kParameterBlock, 0> { - // 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 int num_residuals, - double **parameters, - double *jacobian) { - LOG(FATAL) << "Control should never reach here."; - return true; - } -}; - -} // namespace internal -} // namespace ceres - -#endif // CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/internal/port.h b/extern/libmv/third_party/ceres/include/ceres/internal/port.h deleted file mode 100644 index e38eb713aa8..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/port.h +++ /dev/null @@ -1,88 +0,0 @@ -// 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/ -// -// 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: keir@google.com (Keir Mierle) - -#ifndef CERES_PUBLIC_INTERNAL_PORT_H_ -#define CERES_PUBLIC_INTERNAL_PORT_H_ - -// This file needs to compile as c code. -#ifdef __cplusplus - -#include <string> - -#include "ceres/internal/config.h" - -#if defined(CERES_TR1_MEMORY_HEADER) -#include <tr1/memory> -#else -#include <memory> -#endif - -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 -using std::shared_ptr; -#endif - -} // namespace ceres - -#endif // __cplusplus - -// A macro to signal which functions and classes are exported when -// building a DLL with MSVC. -// -// Note that the ordering here is important, CERES_BUILDING_SHARED_LIBRARY -// is only defined locally when Ceres is compiled, it is never exported to -// users. However, in order that we do not have to configure config.h -// separately for building vs installing, if we are using MSVC and building -// a shared library, then both CERES_BUILDING_SHARED_LIBRARY and -// CERES_USING_SHARED_LIBRARY will be defined when Ceres is compiled. -// Hence it is important that the check for CERES_BUILDING_SHARED_LIBRARY -// happens first. -#if defined(_MSC_VER) && defined(CERES_BUILDING_SHARED_LIBRARY) -# define CERES_EXPORT __declspec(dllexport) -#elif defined(_MSC_VER) && defined(CERES_USING_SHARED_LIBRARY) -# define CERES_EXPORT __declspec(dllimport) -#else -# define CERES_EXPORT -#endif - -#endif // CERES_PUBLIC_INTERNAL_PORT_H_ 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 deleted file mode 100644 index 1f477d8d2ac..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/reenable_warnings.h +++ /dev/null @@ -1,38 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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. -// - -// This is not your usual header guard. See disable_warnings.h -#ifdef CERES_WARNINGS_DISABLED -#undef CERES_WARNINGS_DISABLED - -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - -#endif // CERES_WARNINGS_DISABLED 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 deleted file mode 100644 index 5dfb551243c..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/scoped_ptr.h +++ /dev/null @@ -1,310 +0,0 @@ -// 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/ -// -// 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: jorg@google.com (Jorg Brown) -// -// This is an implementation designed to match the anticipated future TR2 -// implementation of the scoped_ptr class, and its closely-related brethren, -// scoped_array, scoped_ptr_malloc, and make_scoped_ptr. - -#ifndef CERES_PUBLIC_INTERNAL_SCOPED_PTR_H_ -#define CERES_PUBLIC_INTERNAL_SCOPED_PTR_H_ - -#include <assert.h> -#include <stdlib.h> -#include <cstddef> -#include <algorithm> - -namespace ceres { -namespace internal { - -template <class C> class scoped_ptr; -template <class C, class Free> class scoped_ptr_malloc; -template <class C> class scoped_array; - -template <class C> -scoped_ptr<C> make_scoped_ptr(C *); - -// A scoped_ptr<T> is like a T*, except that the destructor of -// scoped_ptr<T> automatically deletes the pointer it holds (if -// any). That is, scoped_ptr<T> owns the T object that it points -// to. Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to -// a T object. Also like T*, scoped_ptr<T> is thread-compatible, and -// once you dereference it, you get the threadsafety guarantees of T. -// -// The size of a scoped_ptr is small: sizeof(scoped_ptr<C>) == sizeof(C*) -template <class C> -class scoped_ptr { - public: - // The element type - typedef C element_type; - - // Constructor. Defaults to intializing with NULL. - // There is no way to create an uninitialized scoped_ptr. - // The input parameter must be allocated with new. - explicit scoped_ptr(C* p = NULL) : ptr_(p) { } - - // Destructor. If there is a C object, delete it. - // We don't need to test ptr_ == NULL because C++ does that for us. - ~scoped_ptr() { - enum { type_must_be_complete = sizeof(C) }; - delete ptr_; - } - - // Reset. Deletes the current owned object, if any. - // Then takes ownership of a new object, if given. - // this->reset(this->get()) works. - void reset(C* p = NULL) { - if (p != ptr_) { - enum { type_must_be_complete = sizeof(C) }; - delete ptr_; - ptr_ = p; - } - } - - // Accessors to get the owned object. - // operator* and operator-> will assert() if there is no current object. - C& operator*() const { - assert(ptr_ != NULL); - return *ptr_; - } - C* operator->() const { - assert(ptr_ != NULL); - return ptr_; - } - C* get() const { return ptr_; } - - // Comparison operators. - // These return whether a scoped_ptr and a raw pointer refer to - // the same object, not just to two different but equal objects. - bool operator==(const C* p) const { return ptr_ == p; } - bool operator!=(const C* p) const { return ptr_ != p; } - - // Swap two scoped pointers. - void swap(scoped_ptr& p2) { - C* tmp = ptr_; - ptr_ = p2.ptr_; - p2.ptr_ = tmp; - } - - // Release a pointer. - // The return value is the current pointer held by this object. - // If this object holds a NULL pointer, the return value is NULL. - // After this operation, this object will hold a NULL pointer, - // and will not own the object any more. - C* release() { - C* retVal = ptr_; - ptr_ = NULL; - return retVal; - } - - private: - C* ptr_; - - // google3 friend class that can access copy ctor (although if it actually - // calls a copy ctor, there will be a problem) see below - friend scoped_ptr<C> make_scoped_ptr<C>(C *p); - - // Forbid comparison of scoped_ptr types. If C2 != C, it totally doesn't - // make sense, and if C2 == C, it still doesn't make sense because you should - // never have the same object owned by two different scoped_ptrs. - template <class C2> bool operator==(scoped_ptr<C2> const& p2) const; - template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const; - - // Disallow evil constructors - scoped_ptr(const scoped_ptr&); - void operator=(const scoped_ptr&); -}; - -// Free functions -template <class C> -inline void swap(scoped_ptr<C>& p1, scoped_ptr<C>& p2) { - p1.swap(p2); -} - -template <class C> -inline bool operator==(const C* p1, const scoped_ptr<C>& p2) { - return p1 == p2.get(); -} - -template <class C> -inline bool operator==(const C* p1, const scoped_ptr<const C>& p2) { - return p1 == p2.get(); -} - -template <class C> -inline bool operator!=(const C* p1, const scoped_ptr<C>& p2) { - return p1 != p2.get(); -} - -template <class C> -inline bool operator!=(const C* p1, const scoped_ptr<const C>& p2) { - return p1 != p2.get(); -} - -template <class C> -scoped_ptr<C> make_scoped_ptr(C *p) { - // This does nothing but to return a scoped_ptr of the type that the passed - // pointer is of. (This eliminates the need to specify the name of T when - // making a scoped_ptr that is used anonymously/temporarily.) From an - // access control point of view, we construct an unnamed scoped_ptr here - // which we return and thus copy-construct. Hence, we need to have access - // to scoped_ptr::scoped_ptr(scoped_ptr const &). However, it is guaranteed - // that we never actually call the copy constructor, which is a good thing - // as we would call the temporary's object destructor (and thus delete p) - // if we actually did copy some object, here. - return scoped_ptr<C>(p); -} - -// scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate -// with new [] and the destructor deletes objects with delete []. -// -// As with scoped_ptr<C>, a scoped_array<C> either points to an object -// or is NULL. A scoped_array<C> owns the object that it points to. -// scoped_array<T> is thread-compatible, and once you index into it, -// the returned objects have only the threadsafety guarantees of T. -// -// Size: sizeof(scoped_array<C>) == sizeof(C*) -template <class C> -class scoped_array { - public: - // The element type - typedef C element_type; - - // Constructor. Defaults to intializing with NULL. - // There is no way to create an uninitialized scoped_array. - // The input parameter must be allocated with new []. - explicit scoped_array(C* p = NULL) : array_(p) { } - - // Destructor. If there is a C object, delete it. - // We don't need to test ptr_ == NULL because C++ does that for us. - ~scoped_array() { - enum { type_must_be_complete = sizeof(C) }; - delete[] array_; - } - - // Reset. Deletes the current owned object, if any. - // Then takes ownership of a new object, if given. - // this->reset(this->get()) works. - void reset(C* p = NULL) { - if (p != array_) { - enum { type_must_be_complete = sizeof(C) }; - delete[] array_; - array_ = p; - } - } - - // Get one element of the current object. - // Will assert() if there is no current object, or index i is negative. - C& operator[](std::ptrdiff_t i) const { - assert(i >= 0); - assert(array_ != NULL); - return array_[i]; - } - - // Get a pointer to the zeroth element of the current object. - // If there is no current object, return NULL. - C* get() const { - return array_; - } - - // Comparison operators. - // These return whether a scoped_array and a raw pointer refer to - // the same array, not just to two different but equal arrays. - bool operator==(const C* p) const { return array_ == p; } - bool operator!=(const C* p) const { return array_ != p; } - - // Swap two scoped arrays. - void swap(scoped_array& p2) { - C* tmp = array_; - array_ = p2.array_; - p2.array_ = tmp; - } - - // Release an array. - // The return value is the current pointer held by this object. - // If this object holds a NULL pointer, the return value is NULL. - // After this operation, this object will hold a NULL pointer, - // and will not own the object any more. - C* release() { - C* retVal = array_; - array_ = NULL; - return retVal; - } - - private: - C* array_; - - // Forbid comparison of different scoped_array types. - template <class C2> bool operator==(scoped_array<C2> const& p2) const; - template <class C2> bool operator!=(scoped_array<C2> const& p2) const; - - // Disallow evil constructors - scoped_array(const scoped_array&); - void operator=(const scoped_array&); -}; - -// Free functions -template <class C> -inline void swap(scoped_array<C>& p1, scoped_array<C>& p2) { - p1.swap(p2); -} - -template <class C> -inline bool operator==(const C* p1, const scoped_array<C>& p2) { - return p1 == p2.get(); -} - -template <class C> -inline bool operator==(const C* p1, const scoped_array<const C>& p2) { - return p1 == p2.get(); -} - -template <class C> -inline bool operator!=(const C* p1, const scoped_array<C>& p2) { - return p1 != p2.get(); -} - -template <class C> -inline bool operator!=(const C* p1, const scoped_array<const C>& p2) { - return p1 != p2.get(); -} - -// This class wraps the c library function free() in a class that can be -// passed as a template argument to scoped_ptr_malloc below. -class ScopedPtrMallocFree { - public: - inline void operator()(void* x) const { - free(x); - } -}; - -} // namespace internal -} // namespace ceres - -#endif // CERES_PUBLIC_INTERNAL_SCOPED_PTR_H_ 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 deleted file mode 100644 index 9a473d5b25c..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/internal/variadic_evaluate.h +++ /dev/null @@ -1,182 +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) -// mierle@gmail.com (Keir Mierle) - -#ifndef CERES_PUBLIC_INTERNAL_VARIADIC_EVALUATE_H_ -#define CERES_PUBLIC_INTERNAL_VARIADIC_EVALUATE_H_ - -#include <stddef.h> - -#include "ceres/jet.h" -#include "ceres/internal/eigen.h" -#include "ceres/internal/fixed_array.h" -#include "glog/logging.h" - -namespace ceres { -namespace internal { - -// This block of quasi-repeated code calls the user-supplied functor, which may -// take a variable number of arguments. This is accomplished by specializing the -// struct based on the size of the trailing parameters; parameters with 0 size -// are assumed missing. -template<typename Functor, typename T, int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7, int N8, int N9> -struct VariadicEvaluate { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - input[4], - input[5], - input[6], - input[7], - input[8], - input[9], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7, int N8> -struct VariadicEvaluate<Functor, T, N0, N1, N2, N3, N4, N5, N6, N7, N8, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - input[4], - input[5], - input[6], - input[7], - input[8], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2, int N3, int N4, - int N5, int N6, int N7> -struct VariadicEvaluate<Functor, T, N0, N1, N2, N3, N4, N5, N6, N7, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - input[4], - input[5], - input[6], - input[7], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2, int N3, int N4, - int N5, int N6> -struct VariadicEvaluate<Functor, T, N0, N1, N2, N3, N4, N5, N6, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - input[4], - input[5], - input[6], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2, int N3, int N4, - int N5> -struct VariadicEvaluate<Functor, T, N0, N1, N2, N3, N4, N5, 0, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - input[4], - input[5], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2, int N3, int N4> -struct VariadicEvaluate<Functor, T, N0, N1, N2, N3, N4, 0, 0, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - input[4], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2, int N3> -struct VariadicEvaluate<Functor, T, N0, N1, N2, N3, 0, 0, 0, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - input[3], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1, int N2> -struct VariadicEvaluate<Functor, T, N0, N1, N2, 0, 0, 0, 0, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - input[2], - output); - } -}; - -template<typename Functor, typename T, int N0, int N1> -struct VariadicEvaluate<Functor, T, N0, N1, 0, 0, 0, 0, 0, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - input[1], - output); - } -}; - -template<typename Functor, typename T, int N0> -struct VariadicEvaluate<Functor, T, N0, 0, 0, 0, 0, 0, 0, 0, 0, 0> { - static bool Call(const Functor& functor, T const *const *input, T* output) { - return functor(input[0], - output); - } -}; - -} // namespace internal -} // namespace ceres - -#endif // CERES_PUBLIC_INTERNAL_VARIADIC_EVALUATE_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h b/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h deleted file mode 100644 index 237ada6e0c9..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/iteration_callback.h +++ /dev/null @@ -1,225 +0,0 @@ -// 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/ -// -// 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) -// -// When an iteration callback is specified, Ceres calls the callback -// after each minimizer step (if the minimizer has not converged) and -// passes it an IterationSummary object, defined below. - -#ifndef CERES_PUBLIC_ITERATION_CALLBACK_H_ -#define CERES_PUBLIC_ITERATION_CALLBACK_H_ - -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// This struct describes the state of the optimizer after each -// iteration of the minimization. -struct CERES_EXPORT IterationSummary { - IterationSummary() - : iteration(0), - step_is_valid(false), - step_is_nonmonotonic(false), - step_is_successful(false), - cost(0.0), - cost_change(0.0), - gradient_max_norm(0.0), - gradient_norm(0.0), - step_norm(0.0), - eta(0.0), - step_size(0.0), - line_search_function_evaluations(0), - line_search_gradient_evaluations(0), - line_search_iterations(0), - linear_solver_iterations(0), - iteration_time_in_seconds(0.0), - step_solver_time_in_seconds(0.0), - cumulative_time_in_seconds(0.0) {} - - // Current iteration number. - int32 iteration; - - // Step was numerically valid, i.e., all values are finite and the - // step reduces the value of the linearized model. - // - // Note: step_is_valid is false when iteration = 0. - bool step_is_valid; - - // Step did not reduce the value of the objective function - // sufficiently, but it was accepted because of the relaxed - // acceptance criterion used by the non-monotonic trust region - // algorithm. - // - // Note: step_is_nonmonotonic is false when iteration = 0; - bool step_is_nonmonotonic; - - // Whether or not the minimizer accepted this step or not. If the - // ordinary trust region algorithm is used, this means that the - // relative reduction in the objective function value was greater - // than Solver::Options::min_relative_decrease. However, if the - // non-monotonic trust region algorithm is used - // (Solver::Options:use_nonmonotonic_steps = true), then even if the - // relative decrease is not sufficient, the algorithm may accept the - // step and the step is declared successful. - // - // Note: step_is_successful is false when iteration = 0. - bool step_is_successful; - - // Value of the objective function. - double cost; - - // Change in the value of the objective function in this - // iteration. This can be positive or negative. - double cost_change; - - // Infinity norm of the gradient vector. - double gradient_max_norm; - - // 2-norm of the gradient vector. - double gradient_norm; - - // 2-norm of the size of the step computed by the optimization - // algorithm. - double step_norm; - - // For trust region algorithms, the ratio of the actual change in - // cost and the change in the cost of the linearized approximation. - double relative_decrease; - - // Size of the trust region at the end of the current iteration. For - // the Levenberg-Marquardt algorithm, the regularization parameter - // mu = 1.0 / trust_region_radius. - double trust_region_radius; - - // For the inexact step Levenberg-Marquardt algorithm, this is the - // relative accuracy with which the Newton(LM) step is solved. This - // number affects only the iterative solvers capable of solving - // linear systems inexactly. Factorization-based exact solvers - // ignore it. - double eta; - - // Step sized computed by the line search algorithm. - double step_size; - - // Number of function value evaluations used by the line search algorithm. - int line_search_function_evaluations; - - // Number of function gradient evaluations used by the line search algorithm. - int line_search_gradient_evaluations; - - // Number of iterations taken by the line search algorithm. - int line_search_iterations; - - // Number of iterations taken by the linear solver to solve for the - // Newton step. - int linear_solver_iterations; - - // All times reported below are wall times. - - // Time (in seconds) spent inside the minimizer loop in the current - // iteration. - double iteration_time_in_seconds; - - // Time (in seconds) spent inside the trust region step solver. - double step_solver_time_in_seconds; - - // Time (in seconds) since the user called Solve(). - double cumulative_time_in_seconds; -}; - -// Interface for specifying callbacks that are executed at the end of -// each iteration of the Minimizer. The solver uses the return value -// of operator() to decide whether to continue solving or to -// terminate. The user can return three values. -// -// SOLVER_ABORT indicates that the callback detected an abnormal -// situation. The solver returns without updating the parameter blocks -// (unless Solver::Options::update_state_every_iteration is set -// true). Solver returns with Solver::Summary::termination_type set to -// USER_ABORT. -// -// SOLVER_TERMINATE_SUCCESSFULLY indicates that there is no need to -// optimize anymore (some user specified termination criterion has -// been met). Solver returns with Solver::Summary::termination_type -// set to USER_SUCCESS. -// -// SOLVER_CONTINUE indicates that the solver should continue -// optimizing. -// -// For example, the following Callback is used internally by Ceres to -// log the progress of the optimization. -// -// Callback for logging the state of the minimizer to STDERR or STDOUT -// depending on the user's preferences and logging level. -// -// class LoggingCallback : public IterationCallback { -// public: -// explicit LoggingCallback(bool log_to_stdout) -// : log_to_stdout_(log_to_stdout) {} -// -// ~LoggingCallback() {} -// -// CallbackReturnType operator()(const IterationSummary& summary) { -// const char* kReportRowFormat = -// "% 4d: f:% 8e d:% 3.2e g:% 3.2e h:% 3.2e " -// "rho:% 3.2e mu:% 3.2e eta:% 3.2e li:% 3d"; -// string 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.eta, -// summary.linear_solver_iterations); -// if (log_to_stdout_) { -// cout << output << endl; -// } else { -// VLOG(1) << output; -// } -// return SOLVER_CONTINUE; -// } -// -// private: -// const bool log_to_stdout_; -// }; -// -class CERES_EXPORT IterationCallback { - public: - virtual ~IterationCallback() {} - virtual CallbackReturnType operator()(const IterationSummary& summary) = 0; -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_ITERATION_CALLBACK_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/jet.h b/extern/libmv/third_party/ceres/include/ceres/jet.h deleted file mode 100644 index 74ce1e9dd53..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/jet.h +++ /dev/null @@ -1,670 +0,0 @@ -// 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/ -// -// 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: keir@google.com (Keir Mierle) -// -// A simple implementation of N-dimensional dual numbers, for automatically -// computing exact derivatives of functions. -// -// While a complete treatment of the mechanics of automatic differentation is -// beyond the scope of this header (see -// http://en.wikipedia.org/wiki/Automatic_differentiation for details), the -// basic idea is to extend normal arithmetic with an extra element, "e," often -// denoted with the greek symbol epsilon, such that e != 0 but e^2 = 0. Dual -// numbers are extensions of the real numbers analogous to complex numbers: -// whereas complex numbers augment the reals by introducing an imaginary unit i -// such that i^2 = -1, dual numbers introduce an "infinitesimal" unit e such -// that e^2 = 0. Dual numbers have two components: the "real" component and the -// "infinitesimal" component, generally written as x + y*e. Surprisingly, this -// leads to a convenient method for computing exact derivatives without needing -// to manipulate complicated symbolic expressions. -// -// For example, consider the function -// -// f(x) = x^2 , -// -// evaluated at 10. Using normal arithmetic, f(10) = 100, and df/dx(10) = 20. -// Next, augument 10 with an infinitesimal to get: -// -// f(10 + e) = (10 + e)^2 -// = 100 + 2 * 10 * e + e^2 -// = 100 + 20 * e -+- -// -- | -// | +--- This is zero, since e^2 = 0 -// | -// +----------------- This is df/dx! -// -// Note that the derivative of f with respect to x is simply the infinitesimal -// component of the value of f(x + e). So, in order to take the derivative of -// any function, it is only necessary to replace the numeric "object" used in -// the function with one extended with infinitesimals. The class Jet, defined in -// this header, is one such example of this, where substitution is done with -// templates. -// -// To handle derivatives of functions taking multiple arguments, different -// infinitesimals are used, one for each variable to take the derivative of. For -// example, consider a scalar function of two scalar parameters x and y: -// -// f(x, y) = x^2 + x * y -// -// Following the technique above, to compute the derivatives df/dx and df/dy for -// f(1, 3) involves doing two evaluations of f, the first time replacing x with -// x + e, the second time replacing y with y + e. -// -// For df/dx: -// -// f(1 + e, y) = (1 + e)^2 + (1 + e) * 3 -// = 1 + 2 * e + 3 + 3 * e -// = 4 + 5 * e -// -// --> df/dx = 5 -// -// For df/dy: -// -// f(1, 3 + e) = 1^2 + 1 * (3 + e) -// = 1 + 3 + e -// = 4 + e -// -// --> df/dy = 1 -// -// To take the gradient of f with the implementation of dual numbers ("jets") in -// this file, it is necessary to create a single jet type which has components -// for the derivative in x and y, and passing them to a templated version of f: -// -// template<typename T> -// T f(const T &x, const T &y) { -// return x * x + x * y; -// } -// -// // The "2" means there should be 2 dual number components. -// Jet<double, 2> x(0); // Pick the 0th dual number for x. -// 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]; -// -// Most users should not use Jet objects directly; a wrapper around Jet objects, -// which makes computing the derivative, gradient, or jacobian of templated -// functors simple, is in autodiff.h. Even autodiff.h should not be used -// directly; instead autodiff_cost_function.h is typically the file of interest. -// -// For the more mathematically inclined, this file implements first-order -// "jets". A 1st order jet is an element of the ring -// -// T[N] = T[t_1, ..., t_N] / (t_1, ..., t_N)^2 -// -// which essentially means that each jet consists of a "scalar" value 'a' from T -// and a 1st order perturbation vector 'v' of length N: -// -// x = a + \sum_i v[i] t_i -// -// A shorthand is to write an element as x = a + u, where u is the pertubation. -// Then, the main point about the arithmetic of jets is that the product of -// perturbations is zero: -// -// (a + u) * (b + v) = ab + av + bu + uv -// = ab + (av + bu) + 0 -// -// which is what operator* implements below. Addition is simpler: -// -// (a + u) + (b + v) = (a + b) + (u + v). -// -// The only remaining question is how to evaluate the function of a jet, for -// which we use the chain rule: -// -// f(a + u) = f(a) + f'(a) u -// -// where f'(a) is the (scalar) derivative of f at a. -// -// By pushing these things through sufficiently and suitably templated -// functions, we can do automatic differentiation. Just be sure to turn on -// function inlining and common-subexpression elimination, or it will be very -// slow! -// -// WARNING: Most Ceres users should not directly include this file or know the -// details of how jets work. Instead the suggested method for automatic -// derivatives is to use autodiff_cost_function.h, which is a wrapper around -// both jets.h and autodiff.h to make taking derivatives of cost functions for -// use in Ceres easier. - -#ifndef CERES_PUBLIC_JET_H_ -#define CERES_PUBLIC_JET_H_ - -#include <cmath> -#include <iosfwd> -#include <iostream> // NOLINT -#include <limits> -#include <string> - -#include "Eigen/Core" -#include "ceres/fpclassify.h" - -namespace ceres { - -template <typename T, int N> -struct Jet { - enum { DIMENSION = N }; - - // Default-construct "a" because otherwise this can lead to false errors about - // uninitialized uses when other classes relying on default constructed T - // (where T is a Jet<T, N>). This usually only happens in opt mode. Note that - // the C++ standard mandates that e.g. default constructed doubles are - // initialized to 0.0; see sections 8.5 of the C++03 standard. - Jet() : a() { - v.setZero(); - } - - // Constructor from scalar: a + 0. - explicit Jet(const T& value) { - a = value; - v.setZero(); - } - - // Constructor from scalar plus variable: a + t_i. - Jet(const T& value, int k) { - a = value; - v.setZero(); - v[k] = T(1.0); - } - - // Constructor from scalar and vector part - // The use of Eigen::DenseBase allows Eigen expressions - // to be passed in without being fully evaluated until - // they are assigned to v - template<typename Derived> - EIGEN_STRONG_INLINE Jet(const T& a, const Eigen::DenseBase<Derived> &v) - : a(a), v(v) { - } - - // Compound operators - Jet<T, N>& operator+=(const Jet<T, N> &y) { - *this = *this + y; - return *this; - } - - Jet<T, N>& operator-=(const Jet<T, N> &y) { - *this = *this - y; - return *this; - } - - Jet<T, N>& operator*=(const Jet<T, N> &y) { - *this = *this * y; - return *this; - } - - Jet<T, N>& operator/=(const Jet<T, N> &y) { - *this = *this / y; - return *this; - } - - // The scalar part. - T a; - - // The infinitesimal part. - // - // Note the Eigen::DontAlign bit is needed here because this object - // gets allocated on the stack and as part of other arrays and - // structs. Forcing the right alignment there is the source of much - // pain and suffering. Even if that works, passing Jets around to - // functions by value has problems because the C++ ABI does not - // guarantee alignment for function arguments. - // - // Setting the DontAlign bit prevents Eigen from using SSE for the - // various operations on Jets. This is a small performance penalty - // since the AutoDiff code will still expose much of the code as - // statically sized loops to the compiler. But given the subtle - // issues that arise due to alignment, especially when dealing with - // multiple platforms, it seems to be a trade off worth making. - Eigen::Matrix<T, N, 1, Eigen::DontAlign> v; -}; - -// Unary + -template<typename T, int N> inline -Jet<T, N> const& operator+(const Jet<T, N>& f) { - return f; -} - -// TODO(keir): Try adding __attribute__((always_inline)) to these functions to -// see if it causes a performance increase. - -// Unary - -template<typename T, int N> inline -Jet<T, N> operator-(const Jet<T, N>&f) { - return Jet<T, N>(-f.a, -f.v); -} - -// Binary + -template<typename T, int N> inline -Jet<T, N> operator+(const Jet<T, N>& f, - const Jet<T, N>& g) { - return Jet<T, N>(f.a + g.a, f.v + g.v); -} - -// Binary + with a scalar: x + s -template<typename T, int N> inline -Jet<T, N> operator+(const Jet<T, N>& f, T s) { - return Jet<T, N>(f.a + s, f.v); -} - -// Binary + with a scalar: s + x -template<typename T, int N> inline -Jet<T, N> operator+(T s, const Jet<T, N>& f) { - return Jet<T, N>(f.a + s, f.v); -} - -// Binary - -template<typename T, int N> inline -Jet<T, N> operator-(const Jet<T, N>& f, - const Jet<T, N>& g) { - return Jet<T, N>(f.a - g.a, f.v - g.v); -} - -// Binary - with a scalar: x - s -template<typename T, int N> inline -Jet<T, N> operator-(const Jet<T, N>& f, T s) { - return Jet<T, N>(f.a - s, f.v); -} - -// Binary - with a scalar: s - x -template<typename T, int N> inline -Jet<T, N> operator-(T s, const Jet<T, N>& f) { - return Jet<T, N>(s - f.a, -f.v); -} - -// Binary * -template<typename T, int N> inline -Jet<T, N> operator*(const Jet<T, N>& f, - const Jet<T, N>& g) { - return Jet<T, N>(f.a * g.a, f.a * g.v + f.v * g.a); -} - -// Binary * with a scalar: x * s -template<typename T, int N> inline -Jet<T, N> operator*(const Jet<T, N>& f, T s) { - return Jet<T, N>(f.a * s, f.v * s); -} - -// Binary * with a scalar: s * x -template<typename T, int N> inline -Jet<T, N> operator*(T s, const Jet<T, N>& f) { - return Jet<T, N>(f.a * s, f.v * s); -} - -// Binary / -template<typename T, int N> inline -Jet<T, N> operator/(const Jet<T, N>& f, - const Jet<T, N>& g) { - // This uses: - // - // a + u (a + u)(b - v) (a + u)(b - v) - // ----- = -------------- = -------------- - // b + v (b + v)(b - v) b^2 - // - // which holds because v*v = 0. - const T g_a_inverse = T(1.0) / g.a; - const T f_a_by_g_a = f.a * g_a_inverse; - return Jet<T, N>(f.a * g_a_inverse, (f.v - f_a_by_g_a * g.v) * g_a_inverse); -} - -// Binary / with a scalar: s / x -template<typename T, int N> inline -Jet<T, N> operator/(T s, const Jet<T, N>& g) { - const T minus_s_g_a_inverse2 = -s / (g.a * g.a); - return Jet<T, N>(s / g.a, g.v * minus_s_g_a_inverse2); -} - -// Binary / with a scalar: x / s -template<typename T, int N> inline -Jet<T, N> operator/(const Jet<T, N>& f, T s) { - const T s_inverse = 1.0 / s; - return Jet<T, N>(f.a * s_inverse, f.v * s_inverse); -} - -// Binary comparison operators for both scalars and jets. -#define CERES_DEFINE_JET_COMPARISON_OPERATOR(op) \ -template<typename T, int N> inline \ -bool operator op(const Jet<T, N>& f, const Jet<T, N>& g) { \ - return f.a op g.a; \ -} \ -template<typename T, int N> inline \ -bool operator op(const T& s, const Jet<T, N>& g) { \ - return s op g.a; \ -} \ -template<typename T, int N> inline \ -bool operator op(const Jet<T, N>& f, const T& s) { \ - return f.a op s; \ -} -CERES_DEFINE_JET_COMPARISON_OPERATOR( < ) // NOLINT -CERES_DEFINE_JET_COMPARISON_OPERATOR( <= ) // NOLINT -CERES_DEFINE_JET_COMPARISON_OPERATOR( > ) // NOLINT -CERES_DEFINE_JET_COMPARISON_OPERATOR( >= ) // NOLINT -CERES_DEFINE_JET_COMPARISON_OPERATOR( == ) // NOLINT -CERES_DEFINE_JET_COMPARISON_OPERATOR( != ) // NOLINT -#undef CERES_DEFINE_JET_COMPARISON_OPERATOR - -// Pull some functions from namespace std. -// -// This is necessary because we want to use the same name (e.g. 'sqrt') for -// double-valued and Jet-valued functions, but we are not allowed to put -// Jet-valued functions inside namespace std. -// -// TODO(keir): Switch to "using". -inline double abs (double x) { return std::abs(x); } -inline double log (double x) { return std::log(x); } -inline double exp (double x) { return std::exp(x); } -inline double sqrt (double x) { return std::sqrt(x); } -inline double cos (double x) { return std::cos(x); } -inline double acos (double x) { return std::acos(x); } -inline double sin (double x) { return std::sin(x); } -inline double asin (double x) { return std::asin(x); } -inline double tan (double x) { return std::tan(x); } -inline double atan (double x) { return std::atan(x); } -inline double sinh (double x) { return std::sinh(x); } -inline double cosh (double x) { return std::cosh(x); } -inline double tanh (double x) { return std::tanh(x); } -inline double pow (double x, double y) { return std::pow(x, y); } -inline double atan2(double y, double x) { return std::atan2(y, x); } - -// In general, f(a + h) ~= f(a) + f'(a) h, via the chain rule. - -// abs(x + h) ~= x + h or -(x + h) -template <typename T, int N> inline -Jet<T, N> abs(const Jet<T, N>& f) { - return f.a < T(0.0) ? -f : f; -} - -// log(a + h) ~= log(a) + h / a -template <typename T, int N> inline -Jet<T, N> log(const Jet<T, N>& f) { - const T a_inverse = T(1.0) / f.a; - return Jet<T, N>(log(f.a), f.v * a_inverse); -} - -// exp(a + h) ~= exp(a) + exp(a) h -template <typename T, int N> inline -Jet<T, N> exp(const Jet<T, N>& f) { - const T tmp = exp(f.a); - return Jet<T, N>(tmp, tmp * f.v); -} - -// sqrt(a + h) ~= sqrt(a) + h / (2 sqrt(a)) -template <typename T, int N> inline -Jet<T, N> sqrt(const Jet<T, N>& f) { - const T tmp = sqrt(f.a); - const T two_a_inverse = T(1.0) / (T(2.0) * tmp); - return Jet<T, N>(tmp, f.v * two_a_inverse); -} - -// cos(a + h) ~= cos(a) - sin(a) h -template <typename T, int N> inline -Jet<T, N> cos(const Jet<T, N>& f) { - return Jet<T, N>(cos(f.a), - sin(f.a) * f.v); -} - -// acos(a + h) ~= acos(a) - 1 / sqrt(1 - a^2) h -template <typename T, int N> inline -Jet<T, N> acos(const Jet<T, N>& f) { - const T tmp = - T(1.0) / sqrt(T(1.0) - f.a * f.a); - return Jet<T, N>(acos(f.a), tmp * f.v); -} - -// sin(a + h) ~= sin(a) + cos(a) h -template <typename T, int N> inline -Jet<T, N> sin(const Jet<T, N>& f) { - return Jet<T, N>(sin(f.a), cos(f.a) * f.v); -} - -// asin(a + h) ~= asin(a) + 1 / sqrt(1 - a^2) h -template <typename T, int N> inline -Jet<T, N> asin(const Jet<T, N>& f) { - const T tmp = T(1.0) / sqrt(T(1.0) - f.a * f.a); - return Jet<T, N>(asin(f.a), tmp * f.v); -} - -// tan(a + h) ~= tan(a) + (1 + tan(a)^2) h -template <typename T, int N> inline -Jet<T, N> tan(const Jet<T, N>& f) { - const T tan_a = tan(f.a); - const T tmp = T(1.0) + tan_a * tan_a; - return Jet<T, N>(tan_a, tmp * f.v); -} - -// atan(a + h) ~= atan(a) + 1 / (1 + a^2) h -template <typename T, int N> inline -Jet<T, N> atan(const Jet<T, N>& f) { - const T tmp = T(1.0) / (T(1.0) + f.a * f.a); - return Jet<T, N>(atan(f.a), tmp * f.v); -} - -// sinh(a + h) ~= sinh(a) + cosh(a) h -template <typename T, int N> inline -Jet<T, N> sinh(const Jet<T, N>& f) { - return Jet<T, N>(sinh(f.a), cosh(f.a) * f.v); -} - -// cosh(a + h) ~= cosh(a) + sinh(a) h -template <typename T, int N> inline -Jet<T, N> cosh(const Jet<T, N>& f) { - return Jet<T, N>(cosh(f.a), sinh(f.a) * f.v); -} - -// tanh(a + h) ~= tanh(a) + (1 - tanh(a)^2) h -template <typename T, int N> inline -Jet<T, N> tanh(const Jet<T, N>& f) { - const T tanh_a = tanh(f.a); - const T tmp = T(1.0) - tanh_a * tanh_a; - return Jet<T, N>(tanh_a, tmp * 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 -// to be finite (or normal). For IsNaN and IsInfinite, the answer is less -// clear. This takes a "any" approach for IsNaN and IsInfinite such that if any -// part of a jet is nan or inf, then the entire jet is nan or inf. This leads -// to strange situations like a jet can be both IsInfinite and IsNaN, but in -// practice the "any" semantics are the most useful for e.g. checking that -// derivatives are sane. - -// The jet is finite if all parts of the jet are finite. -template <typename T, int N> inline -bool IsFinite(const Jet<T, N>& f) { - if (!IsFinite(f.a)) { - return false; - } - for (int i = 0; i < N; ++i) { - if (!IsFinite(f.v[i])) { - return false; - } - } - return true; -} - -// The jet is infinite if any part of the jet is infinite. -template <typename T, int N> inline -bool IsInfinite(const Jet<T, N>& f) { - if (IsInfinite(f.a)) { - return true; - } - for (int i = 0; i < N; i++) { - if (IsInfinite(f.v[i])) { - return true; - } - } - return false; -} - -// The jet is NaN if any part of the jet is NaN. -template <typename T, int N> inline -bool IsNaN(const Jet<T, N>& f) { - if (IsNaN(f.a)) { - return true; - } - for (int i = 0; i < N; ++i) { - if (IsNaN(f.v[i])) { - return true; - } - } - return false; -} - -// The jet is normal if all parts of the jet are normal. -template <typename T, int N> inline -bool IsNormal(const Jet<T, N>& f) { - if (!IsNormal(f.a)) { - return false; - } - for (int i = 0; i < N; ++i) { - if (!IsNormal(f.v[i])) { - return false; - } - } - return true; -} - -// atan2(b + db, a + da) ~= atan2(b, a) + (- b da + a db) / (a^2 + b^2) -// -// In words: the rate of change of theta is 1/r times the rate of -// change of (x, y) in the positive angular direction. -template <typename T, int N> inline -Jet<T, N> atan2(const Jet<T, N>& g, const Jet<T, N>& f) { - // Note order of arguments: - // - // f = a + da - // g = b + db - - T const tmp = T(1.0) / (f.a * f.a + g.a * g.a); - return Jet<T, N>(atan2(g.a, f.a), tmp * (- g.a * f.v + f.a * g.v)); -} - - -// pow -- base is a differentiable function, exponent is a constant. -// (a+da)^p ~= a^p + p*a^(p-1) da -template <typename T, int N> inline -Jet<T, N> pow(const Jet<T, N>& f, double g) { - T const tmp = g * pow(f.a, g - T(1.0)); - return Jet<T, N>(pow(f.a, g), tmp * f.v); -} - -// pow -- base is a constant, exponent is a differentiable function. -// (a)^(p+dp) ~= a^p + a^p log(a) dp -template <typename T, int N> inline -Jet<T, N> pow(double f, const Jet<T, N>& g) { - 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. -// (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) { - 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); -} - -// Define the helper functions Eigen needs to embed Jet types. -// -// NOTE(keir): machine_epsilon() and precision() are missing, because they don't -// work with nested template types (e.g. where the scalar is itself templated). -// Among other things, this means that decompositions of Jet's does not work, -// for example -// -// Matrix<Jet<T, N> ... > A, x, b; -// ... -// A.solve(b, &x) -// -// does not work and will fail with a strange compiler error. -// -// TODO(keir): This is an Eigen 2.0 limitation that is lifted in 3.0. When we -// switch to 3.0, also add the rest of the specialization functionality. -template<typename T, int N> inline const Jet<T, N>& ei_conj(const Jet<T, N>& x) { return x; } // NOLINT -template<typename T, int N> inline const Jet<T, N>& ei_real(const Jet<T, N>& x) { return x; } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_imag(const Jet<T, N>& ) { return Jet<T, N>(0.0); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_abs (const Jet<T, N>& x) { return fabs(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_abs2(const Jet<T, N>& x) { return x * x; } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_sqrt(const Jet<T, N>& x) { return sqrt(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_exp (const Jet<T, N>& x) { return exp(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_log (const Jet<T, N>& x) { return log(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_sin (const Jet<T, N>& x) { return sin(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_cos (const Jet<T, N>& x) { return cos(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_tan (const Jet<T, N>& x) { return tan(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_atan(const Jet<T, N>& x) { return atan(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_sinh(const Jet<T, N>& x) { return sinh(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_cosh(const Jet<T, N>& x) { return cosh(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_tanh(const Jet<T, N>& x) { return tanh(x); } // NOLINT -template<typename T, int N> inline Jet<T, N> ei_pow (const Jet<T, N>& x, Jet<T, N> y) { return pow(x, y); } // NOLINT - -// Note: This has to be in the ceres namespace for argument dependent lookup to -// function correctly. Otherwise statements like CHECK_LE(x, 2.0) fail with -// strange compile errors. -template <typename T, int N> -inline std::ostream &operator<<(std::ostream &s, const Jet<T, N>& z) { - return s << "[" << z.a << " ; " << z.v.transpose() << "]"; -} - -} // namespace ceres - -namespace Eigen { - -// Creating a specialization of NumTraits enables placing Jet objects inside -// Eigen arrays, getting all the goodness of Eigen combined with autodiff. -template<typename T, int N> -struct NumTraits<ceres::Jet<T, N> > { - typedef ceres::Jet<T, N> Real; - typedef ceres::Jet<T, N> NonInteger; - typedef ceres::Jet<T, N> Nested; - - static typename ceres::Jet<T, N> dummy_precision() { - return ceres::Jet<T, N>(1e-12); - } - - static inline Real epsilon() { - return Real(std::numeric_limits<T>::epsilon()); - } - - enum { - IsComplex = 0, - IsInteger = 0, - IsSigned, - ReadCost = 1, - AddCost = 1, - // For Jet types, multiplication is more expensive than addition. - MulCost = 3, - HasFloatingPoint = 1, - RequireInitialization = 1 - }; -}; - -} // namespace Eigen - -#endif // CERES_PUBLIC_JET_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h b/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h deleted file mode 100644 index 656c4d46662..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/local_parameterization.h +++ /dev/null @@ -1,217 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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: keir@google.com (Keir Mierle) -// sameeragarwal@google.com (Sameer Agarwal) - -#ifndef CERES_PUBLIC_LOCAL_PARAMETERIZATION_H_ -#define CERES_PUBLIC_LOCAL_PARAMETERIZATION_H_ - -#include <vector> -#include "ceres/internal/port.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// Purpose: Sometimes parameter blocks x can overparameterize a problem -// -// min f(x) -// x -// -// In that case it is desirable to choose a parameterization for the -// block itself to remove the null directions of the cost. More -// generally, if x lies on a manifold of a smaller dimension than the -// ambient space that it is embedded in, then it is numerically and -// computationally more effective to optimize it using a -// parameterization that lives in the tangent space of that manifold -// at each point. -// -// For example, a sphere in three dimensions is a 2 dimensional -// manifold, embedded in a three dimensional space. At each point on -// the sphere, the plane tangent to it defines a two dimensional -// tangent space. For a cost function defined on this sphere, given a -// point x, moving in the direction normal to the sphere at that point -// is not useful. Thus a better way to do a local optimization is to -// optimize over two dimensional vector delta in the tangent space at -// that point and then "move" to the point x + delta, where the move -// operation involves projecting back onto the sphere. Doing so -// removes a redundent dimension from the optimization, making it -// numerically more robust and efficient. -// -// More generally we can define a function -// -// x_plus_delta = Plus(x, delta), -// -// where x_plus_delta has the same size as x, and delta is of size -// less than or equal to x. The function Plus, generalizes the -// definition of vector addition. Thus it satisfies the identify -// -// Plus(x, 0) = x, for all x. -// -// A trivial version of Plus is when delta is of the same size as x -// and -// -// Plus(x, delta) = x + delta -// -// A more interesting case if x is two dimensional vector, and the -// user wishes to hold the first coordinate constant. Then, delta is a -// scalar and Plus is defined as -// -// Plus(x, delta) = x + [0] * delta -// [1] -// -// An example that occurs commonly in Structure from Motion problems -// is when camera rotations are parameterized using Quaternion. There, -// it is useful only make updates orthogonal to that 4-vector defining -// the quaternion. One way to do this is to let delta be a 3 -// dimensional vector and define Plus to be -// -// Plus(x, delta) = [cos(|delta|), sin(|delta|) delta / |delta|] * x -// -// The multiplication between the two 4-vectors on the RHS is the -// standard quaternion product. -// -// Given g and a point x, optimizing f can now be restated as -// -// min f(Plus(x, delta)) -// delta -// -// Given a solution delta to this problem, the optimal value is then -// given by -// -// x* = Plus(x, delta) -// -// The class LocalParameterization defines the function Plus and its -// Jacobian which is needed to compute the Jacobian of f w.r.t delta. -class CERES_EXPORT LocalParameterization { - public: - virtual ~LocalParameterization(); - - // Generalization of the addition operation, - // - // x_plus_delta = Plus(x, delta) - // - // with the condition that Plus(x, 0) = x. - virtual bool Plus(const double* x, - const double* delta, - double* x_plus_delta) const = 0; - - // The jacobian of Plus(x, delta) w.r.t delta at delta = 0. - // - // jacobian is a row-major GlobalSize() x LocalSize() matrix. - virtual bool ComputeJacobian(const double* x, double* jacobian) const = 0; - - // local_matrix = global_matrix * jacobian - // - // global_matrix is a num_rows x GlobalSize row major matrix. - // local_matrix is a num_rows x LocalSize row major matrix. - // jacobian(x) is the matrix returned by ComputeJacobian at x. - // - // This is only used by GradientProblem. For most normal uses, it is - // okay to use the default implementation. - virtual bool MultiplyByJacobian(const double* x, - const int num_rows, - const double* global_matrix, - double* local_matrix) const; - - // Size of x. - virtual int GlobalSize() const = 0; - - // Size of delta. - virtual int LocalSize() const = 0; -}; - -// Some basic parameterizations - -// Identity Parameterization: Plus(x, delta) = x + delta -class CERES_EXPORT IdentityParameterization : public LocalParameterization { - public: - explicit IdentityParameterization(int size); - virtual ~IdentityParameterization() {} - virtual bool Plus(const double* x, - const double* delta, - double* x_plus_delta) const; - virtual bool ComputeJacobian(const double* x, - double* jacobian) const; - virtual bool MultiplyByJacobian(const double* x, - const int num_cols, - const double* global_matrix, - double* local_matrix) const; - virtual int GlobalSize() const { return size_; } - virtual int LocalSize() const { return size_; } - - private: - const int size_; -}; - -// Hold a subset of the parameters inside a parameter block constant. -class CERES_EXPORT SubsetParameterization : public LocalParameterization { - public: - explicit SubsetParameterization(int size, - const vector<int>& constant_parameters); - virtual ~SubsetParameterization() {} - virtual bool Plus(const double* x, - const double* delta, - double* x_plus_delta) const; - virtual bool ComputeJacobian(const double* x, - double* jacobian) const; - virtual bool MultiplyByJacobian(const double* x, - const int num_cols, - const double* global_matrix, - double* local_matrix) const; - virtual int GlobalSize() const { - return static_cast<int>(constancy_mask_.size()); - } - virtual int LocalSize() const { return local_size_; } - - private: - const int local_size_; - vector<int> constancy_mask_; -}; - -// Plus(x, delta) = [cos(|delta|), sin(|delta|) delta / |delta|] * x -// with * being the quaternion multiplication operator. Here we assume -// that the first element of the quaternion vector is the real (cos -// theta) part. -class CERES_EXPORT QuaternionParameterization : public LocalParameterization { - public: - virtual ~QuaternionParameterization() {} - 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 4; } - virtual int LocalSize() const { return 3; } -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_LOCAL_PARAMETERIZATION_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 deleted file mode 100644 index 2c585009990..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/loss_function.h +++ /dev/null @@ -1,401 +0,0 @@ -// 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/ -// -// 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) -// -// The LossFunction interface is the way users describe how residuals -// are converted to cost terms for the overall problem cost function. -// For the exact manner in which loss functions are converted to the -// overall cost for a problem, see problem.h. -// -// For least squares problem where there are no outliers and standard -// squared loss is expected, it is not necessary to create a loss -// function; instead passing a NULL to the problem when adding -// residuals implies a standard squared loss. -// -// For least squares problems where the minimization may encounter -// input terms that contain outliers, that is, completely bogus -// measurements, it is important to use a loss function that reduces -// their associated penalty. -// -// Consider a structure from motion problem. The unknowns are 3D -// points and camera parameters, and the measurements are image -// coordinates describing the expected reprojected position for a -// point in a camera. For example, we want to model the geometry of a -// street scene with fire hydrants and cars, observed by a moving -// camera with unknown parameters, and the only 3D points we care -// about are the pointy tippy-tops of the fire hydrants. Our magic -// image processing algorithm, which is responsible for producing the -// measurements that are input to Ceres, has found and matched all -// such tippy-tops in all image frames, except that in one of the -// frame it mistook a car's headlight for a hydrant. If we didn't do -// anything special (i.e. if we used a basic quadratic loss), the -// residual for the erroneous measurement will result in extreme error -// due to the quadratic nature of squared loss. This results in the -// entire solution getting pulled away from the optimimum to reduce -// the large error that would otherwise be attributed to the wrong -// measurement. -// -// Using a robust loss function, the cost for large residuals is -// reduced. In the example above, this leads to outlier terms getting -// downweighted so they do not overly influence the final solution. -// -// What cost function is best? -// -// In general, there isn't a principled way to select a robust loss -// function. The authors suggest starting with a non-robust cost, then -// only experimenting with robust loss functions if standard squared -// loss doesn't work. - -#ifndef CERES_PUBLIC_LOSS_FUNCTION_H_ -#define CERES_PUBLIC_LOSS_FUNCTION_H_ - -#include "glog/logging.h" -#include "ceres/internal/macros.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -class CERES_EXPORT LossFunction { - public: - virtual ~LossFunction() {} - - // For a residual vector with squared 2-norm 'sq_norm', this method - // is required to fill in the value and derivatives of the loss - // function (rho in this example): - // - // out[0] = rho(sq_norm), - // out[1] = rho'(sq_norm), - // out[2] = rho''(sq_norm), - // - // Here the convention is that the contribution of a term to the - // cost function is given by 1/2 rho(s), where - // - // s = ||residuals||^2. - // - // Calling the method with a negative value of 's' is an error and - // the implementations are not required to handle that case. - // - // Most sane choices of rho() satisfy: - // - // rho(0) = 0, - // rho'(0) = 1, - // rho'(s) < 1 in outlier region, - // rho''(s) < 0 in outlier region, - // - // so that they mimic the least squares cost for small residuals. - virtual void Evaluate(double sq_norm, double out[3]) const = 0; -}; - -// Some common implementations follow below. -// -// Note: in the region of interest (i.e. s < 3) we have: -// TrivialLoss >= HuberLoss >= SoftLOneLoss >= CauchyLoss - - -// This corresponds to no robustification. -// -// rho(s) = s -// -// At s = 0: rho = [0, 1, 0]. -// -// It is not normally necessary to use this, as passing NULL for the -// loss function when building the problem accomplishes the same -// thing. -class CERES_EXPORT TrivialLoss : public LossFunction { - public: - virtual void Evaluate(double, double*) const; -}; - -// Scaling -// ------- -// Given one robustifier -// s -> rho(s) -// one can change the length scale at which robustification takes -// place, by adding a scale factor 'a' as follows: -// -// s -> a^2 rho(s / a^2). -// -// The first and second derivatives are: -// -// s -> rho'(s / a^2), -// s -> (1 / a^2) rho''(s / a^2), -// -// but the behaviour near s = 0 is the same as the original function, -// i.e. -// -// rho(s) = s + higher order terms, -// a^2 rho(s / a^2) = s + higher order terms. -// -// The scalar 'a' should be positive. -// -// The reason for the appearance of squaring is that 'a' is in the -// units of the residual vector norm whereas 's' is a squared -// norm. For applications it is more convenient to specify 'a' than -// its square. The commonly used robustifiers below are described in -// un-scaled format (a = 1) but their implementations work for any -// non-zero value of 'a'. - -// Huber. -// -// rho(s) = s for s <= 1, -// rho(s) = 2 sqrt(s) - 1 for s >= 1. -// -// At s = 0: rho = [0, 1, 0]. -// -// The scaling parameter 'a' corresponds to 'delta' on this page: -// http://en.wikipedia.org/wiki/Huber_Loss_Function -class CERES_EXPORT HuberLoss : public LossFunction { - public: - explicit HuberLoss(double a) : a_(a), b_(a * a) { } - virtual void Evaluate(double, double*) const; - - private: - const double a_; - // b = a^2. - const double b_; -}; - -// Soft L1, similar to Huber but smooth. -// -// rho(s) = 2 (sqrt(1 + s) - 1). -// -// At s = 0: rho = [0, 1, -1/2]. -class CERES_EXPORT SoftLOneLoss : public LossFunction { - public: - explicit SoftLOneLoss(double a) : b_(a * a), c_(1 / b_) { } - virtual void Evaluate(double, double*) const; - - private: - // b = a^2. - const double b_; - // c = 1 / a^2. - const double c_; -}; - -// Inspired by the Cauchy distribution -// -// rho(s) = log(1 + s). -// -// At s = 0: rho = [0, 1, -1]. -class CERES_EXPORT CauchyLoss : public LossFunction { - public: - explicit CauchyLoss(double a) : b_(a * a), c_(1 / b_) { } - virtual void Evaluate(double, double*) const; - - private: - // b = a^2. - const double b_; - // c = 1 / a^2. - const double c_; -}; - -// Loss that is capped beyond a certain level using the arc-tangent function. -// The scaling parameter 'a' determines the level where falloff occurs. -// For costs much smaller than 'a', the loss function is linear and behaves like -// TrivialLoss, and for values much larger than 'a' the value asymptotically -// approaches the constant value of a * PI / 2. -// -// rho(s) = a atan(s / a). -// -// At s = 0: rho = [0, 1, 0]. -class CERES_EXPORT ArctanLoss : public LossFunction { - public: - explicit ArctanLoss(double a) : a_(a), b_(1 / (a * a)) { } - virtual void Evaluate(double, double*) const; - - private: - const double a_; - // b = 1 / a^2. - const double b_; -}; - -// Loss function that maps to approximately zero cost in a range around the -// origin, and reverts to linear in error (quadratic in cost) beyond this range. -// The tolerance parameter 'a' sets the nominal point at which the -// transition occurs, and the transition size parameter 'b' sets the nominal -// distance over which most of the transition occurs. Both a and b must be -// greater than zero, and typically b will be set to a fraction of a. -// The slope rho'[s] varies smoothly from about 0 at s <= a - b to -// about 1 at s >= a + b. -// -// The term is computed as: -// -// rho(s) = b log(1 + exp((s - a) / b)) - c0. -// -// where c0 is chosen so that rho(0) == 0 -// -// c0 = b log(1 + exp(-a / b) -// -// This has the following useful properties: -// -// rho(s) == 0 for s = 0 -// rho'(s) ~= 0 for s << a - b -// rho'(s) ~= 1 for s >> a + b -// rho''(s) > 0 for all s -// -// In addition, all derivatives are continuous, and the curvature is -// concentrated in the range a - b to a + b. -// -// At s = 0: rho = [0, ~0, ~0]. -class CERES_EXPORT TolerantLoss : public LossFunction { - public: - explicit TolerantLoss(double a, double b); - virtual void Evaluate(double, double*) const; - - private: - const double a_, b_, c_; -}; - -// 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 { - public: - explicit ComposedLoss(const LossFunction* f, Ownership ownership_f, - const LossFunction* g, Ownership ownership_g); - virtual ~ComposedLoss(); - virtual void Evaluate(double, double*) const; - - private: - internal::scoped_ptr<const LossFunction> f_, g_; - const Ownership ownership_f_, ownership_g_; -}; - -// The discussion above has to do with length scaling: it affects the space -// in which s is measured. Sometimes you want to simply scale the output -// value of the robustifier. For example, you might want to weight -// different error terms differently (e.g., weight pixel reprojection -// errors differently from terrain errors). -// -// If rho is the wrapped robustifier, then this simply outputs -// s -> a * rho(s) -// -// The first and second derivatives are, not surprisingly -// s -> a * rho'(s) -// s -> a * rho''(s) -// -// Since we treat the a NULL Loss function as the Identity loss -// function, rho = NULL is a valid input and will result in the input -// being scaled by a. This provides a simple way of implementing a -// scaled ResidualBlock. -class CERES_EXPORT ScaledLoss : public LossFunction { - public: - // Constructs a ScaledLoss wrapping another loss function. Takes - // ownership of the wrapped loss function or not depending on the - // ownership parameter. - ScaledLoss(const LossFunction* rho, double a, Ownership ownership) : - rho_(rho), a_(a), ownership_(ownership) { } - - virtual ~ScaledLoss() { - if (ownership_ == DO_NOT_TAKE_OWNERSHIP) { - rho_.release(); - } - } - virtual void Evaluate(double, double*) const; - - private: - internal::scoped_ptr<const LossFunction> rho_; - const double a_; - const Ownership ownership_; - CERES_DISALLOW_COPY_AND_ASSIGN(ScaledLoss); -}; - -// Sometimes after the optimization problem has been constructed, we -// wish to mutate the scale of the loss function. For example, when -// performing estimation from data which has substantial outliers, -// convergence can be improved by starting out with a large scale, -// optimizing the problem and then reducing the scale. This can have -// better convergence behaviour than just using a loss function with a -// small scale. -// -// This templated class allows the user to implement a loss function -// whose scale can be mutated after an optimization problem has been -// constructed. -// -// Example usage -// -// Problem problem; -// -// // Add parameter blocks -// -// CostFunction* cost_function = -// new AutoDiffCostFunction < UW_Camera_Mapper, 2, 9, 3>( -// new UW_Camera_Mapper(feature_x, feature_y)); -// -// LossFunctionWrapper* loss_function(new HuberLoss(1.0), TAKE_OWNERSHIP); -// -// problem.AddResidualBlock(cost_function, loss_function, parameters); -// -// Solver::Options options; -// Solger::Summary summary; -// -// Solve(options, &problem, &summary) -// -// loss_function->Reset(new HuberLoss(1.0), TAKE_OWNERSHIP); -// -// Solve(options, &problem, &summary) -// -class CERES_EXPORT LossFunctionWrapper : public LossFunction { - public: - LossFunctionWrapper(LossFunction* rho, Ownership ownership) - : rho_(rho), ownership_(ownership) { - } - - virtual ~LossFunctionWrapper() { - if (ownership_ == DO_NOT_TAKE_OWNERSHIP) { - rho_.release(); - } - } - - virtual void Evaluate(double sq_norm, double out[3]) const { - CHECK_NOTNULL(rho_.get()); - rho_->Evaluate(sq_norm, out); - } - - void Reset(LossFunction* rho, Ownership ownership) { - if (ownership_ == DO_NOT_TAKE_OWNERSHIP) { - rho_.release(); - } - rho_.reset(rho); - ownership_ = ownership; - } - - private: - internal::scoped_ptr<const LossFunction> rho_; - Ownership ownership_; - CERES_DISALLOW_COPY_AND_ASSIGN(LossFunctionWrapper); -}; - -} // namespace ceres - -#include "ceres/internal/disable_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 deleted file mode 100644 index df665054530..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/normal_prior.h +++ /dev/null @@ -1,78 +0,0 @@ -// 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/ -// -// 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) -// -// Cost term that implements a prior on a parameter block using a -// normal distribution. - -#ifndef CERES_PUBLIC_NORMAL_PRIOR_H_ -#define CERES_PUBLIC_NORMAL_PRIOR_H_ - -#include "ceres/cost_function.h" -#include "ceres/internal/eigen.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// Implements a cost function of the form -// -// cost(x) = ||A(x - b)||^2 -// -// where, the matrix A and the vector b are fixed and x is the -// variable. In case the user is interested in implementing a cost -// function of the form -// -// cost(x) = (x - mu)^T S^{-1} (x - mu) -// -// where, mu is a vector and S is a covariance matrix, then, A = -// S^{-1/2}, i.e the matrix A is the square root of the inverse of the -// covariance, also known as the stiffness matrix. There are however -// no restrictions on the shape of A. It is free to be rectangular, -// which would be the case if the covariance matrix S is rank -// deficient. - -class CERES_EXPORT NormalPrior: public CostFunction { - public: - // Check that the number of rows in the vector b are the same as the - // number of columns in the matrix A, crash otherwise. - NormalPrior(const Matrix& A, const Vector& b); - - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const; - private: - Matrix A_; - Vector b_; -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_NORMAL_PRIOR_H_ 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 deleted file mode 100644 index de6b74ad552..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/numeric_diff_cost_function.h +++ /dev/null @@ -1,315 +0,0 @@ -// 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/ -// -// 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: keir@google.com (Keir Mierle) -// sameeragarwal@google.com (Sameer Agarwal) -// -// Create CostFunctions as needed by the least squares framework with jacobians -// computed via numeric (a.k.a. finite) differentiation. For more details see -// http://en.wikipedia.org/wiki/Numerical_differentiation. -// -// To get an numerically differentiated cost function, you must define -// a class with a operator() (a functor) that computes the residuals. -// -// The function must write the computed value in the last argument -// (the only non-const one) and return true to indicate success. -// Please see cost_function.h for details on how the return value -// maybe used to impose simple constraints on the parameter block. -// -// For example, consider a scalar error e = k - x'y, where both x and y are -// two-dimensional column vector parameters, the prime sign indicates -// transposition, and k is a constant. The form of this error, which is the -// difference between a constant and an expression, is a common pattern in least -// squares problems. For example, the value x'y might be the model expectation -// for a series of measurements, where there is an instance of the cost function -// for each measurement k. -// -// The actual cost added to the total problem is e^2, or (k - x'k)^2; however, -// the squaring is implicitly done by the optimization framework. -// -// To write an numerically-differentiable cost function for the above model, first -// define the object -// -// class MyScalarCostFunctor { -// MyScalarCostFunctor(double k): k_(k) {} -// -// bool operator()(const double* const x, -// const double* const y, -// double* residuals) const { -// residuals[0] = k_ - x[0] * y[0] + x[1] * y[1]; -// return true; -// } -// -// private: -// double k_; -// }; -// -// Note that in the declaration of operator() the input parameters x -// and y come first, and are passed as const pointers to arrays of -// doubles. If there were three input parameters, then the third input -// parameter would come after y. The output is always the last -// parameter, and is also a pointer to an array. In the example above, -// the residual is a scalar, so only residuals[0] is set. -// -// Then given this class definition, the numerically differentiated -// cost function with central differences used for computing the -// derivative can be constructed as follows. -// -// CostFunction* cost_function -// = new NumericDiffCostFunction<MyScalarCostFunctor, CENTRAL, 1, 2, 2>( -// new MyScalarCostFunctor(1.0)); ^ ^ ^ ^ -// | | | | -// Finite Differencing Scheme -+ | | | -// Dimension of residual ------------+ | | -// Dimension of x ----------------------+ | -// Dimension of y -------------------------+ -// -// In this example, there is usually an instance for each measurement of k. -// -// In the instantiation above, the template parameters following -// "MyScalarCostFunctor", "1, 2, 2", describe the functor as computing -// a 1-dimensional output from two arguments, both 2-dimensional. -// -// NumericDiffCostFunction also supports cost functions with a -// runtime-determined number of residuals. For example: -// -// CostFunction* cost_function -// = new NumericDiffCostFunction<MyScalarCostFunctor, CENTRAL, DYNAMIC, 2, 2>( -// new CostFunctorWithDynamicNumResiduals(1.0), ^ ^ ^ -// TAKE_OWNERSHIP, | | | -// runtime_number_of_residuals); <----+ | | | -// | | | | -// | | | | -// Actual number of residuals ------+ | | | -// Indicate dynamic number of residuals --------------------+ | | -// Dimension of x ------------------------------------------------+ | -// Dimension of y ---------------------------------------------------+ -// -// The framework can currently accommodate cost functions of up to 10 -// independent variables, and there is no limit on the dimensionality -// of each of them. -// -// The central difference method is considerably more accurate at the cost of -// twice as many function evaluations than forward difference. Consider using -// central differences begin with, and only after that works, trying forward -// difference to improve performance. -// -// WARNING #1: A common beginner's error when first using -// NumericDiffCostFunction is to get the sizing wrong. In particular, -// there is a tendency to set the template parameters to (dimension of -// residual, number of parameters) instead of passing a dimension -// parameter for *every parameter*. In the example above, that would -// be <MyScalarCostFunctor, 1, 2>, which is missing the last '2' -// argument. Please be careful when setting the size parameters. -// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -// -// ALTERNATE INTERFACE -// -// For a variety of reason, including compatibility with legacy code, -// NumericDiffCostFunction can also take CostFunction objects as -// input. The following describes how. -// -// To get a numerically differentiated cost function, define a -// subclass of CostFunction such that the Evaluate() function ignores -// the jacobian parameter. The numeric differentiation wrapper will -// fill in the jacobian parameter if necessary by repeatedly calling -// the Evaluate() function with small changes to the appropriate -// parameters, and computing the slope. For performance, the numeric -// differentiation wrapper class is templated on the concrete cost -// function, even though it could be implemented only in terms of the -// virtual CostFunction interface. -// -// The numerically differentiated version of a cost function for a cost function -// can be constructed as follows: -// -// CostFunction* cost_function -// = new NumericDiffCostFunction<MyCostFunction, CENTRAL, 1, 4, 8>( -// new MyCostFunction(...), TAKE_OWNERSHIP); -// -// where MyCostFunction has 1 residual and 2 parameter blocks with sizes 4 and 8 -// respectively. Look at the tests for a more detailed example. -// -// TODO(keir): Characterize accuracy; mention pitfalls; provide alternatives. - -#ifndef CERES_PUBLIC_NUMERIC_DIFF_COST_FUNCTION_H_ -#define CERES_PUBLIC_NUMERIC_DIFF_COST_FUNCTION_H_ - -#include "Eigen/Dense" -#include "ceres/cost_function.h" -#include "ceres/internal/numeric_diff.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/sized_cost_function.h" -#include "ceres/types.h" -#include "glog/logging.h" - -namespace ceres { - -template <typename CostFunctor, - NumericDiffMethod 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. - int N2 = 0, // Number of parameters in block 2. - int N3 = 0, // Number of parameters in block 3. - int N4 = 0, // Number of parameters in block 4. - int N5 = 0, // Number of parameters in block 5. - int N6 = 0, // Number of parameters in block 6. - int N7 = 0, // Number of parameters in block 7. - int N8 = 0, // Number of parameters in block 8. - int N9 = 0> // Number of parameters in block 9. -class NumericDiffCostFunction - : public SizedCostFunction<kNumResiduals, - N0, N1, N2, N3, N4, - N5, N6, N7, N8, N9> { - public: - NumericDiffCostFunction(CostFunctor* functor, - Ownership ownership = TAKE_OWNERSHIP, - int num_residuals = kNumResiduals, - const double relative_step_size = 1e-6) - :functor_(functor), - ownership_(ownership), - relative_step_size_(relative_step_size) { - if (kNumResiduals == DYNAMIC) { - SizedCostFunction<kNumResiduals, - N0, N1, N2, N3, N4, - N5, N6, N7, N8, N9> - ::set_num_residuals(num_residuals); - } - } - - ~NumericDiffCostFunction() { - if (ownership_ != TAKE_OWNERSHIP) { - functor_.release(); - } - } - - virtual bool Evaluate(double const* const* parameters, - double* residuals, - double** jacobians) const { - using internal::FixedArray; - using internal::NumericDiff; - - const int kNumParameters = N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9; - const int kNumParameterBlocks = - (N0 > 0) + (N1 > 0) + (N2 > 0) + (N3 > 0) + (N4 > 0) + - (N5 > 0) + (N6 > 0) + (N7 > 0) + (N8 > 0) + (N9 > 0); - - // Get the function value (residuals) at the the point to evaluate. - if (!internal::EvaluateImpl<CostFunctor, - N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>( - functor_.get(), - parameters, - residuals, - functor_.get())) { - return false; - } - - if (jacobians == NULL) { - return true; - } - - // Create a copy of the parameters which will get mutated. - FixedArray<double> parameters_copy(kNumParameters); - FixedArray<double*> parameters_reference_copy(kNumParameterBlocks); - - parameters_reference_copy[0] = parameters_copy.get(); - if (N1) parameters_reference_copy[1] = parameters_reference_copy[0] + N0; - if (N2) parameters_reference_copy[2] = parameters_reference_copy[1] + N1; - if (N3) parameters_reference_copy[3] = parameters_reference_copy[2] + N2; - if (N4) parameters_reference_copy[4] = parameters_reference_copy[3] + N3; - if (N5) parameters_reference_copy[5] = parameters_reference_copy[4] + N4; - if (N6) parameters_reference_copy[6] = parameters_reference_copy[5] + N5; - if (N7) parameters_reference_copy[7] = parameters_reference_copy[6] + N6; - 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) \ - 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); - -#undef COPY_PARAMETER_BLOCK - -#define EVALUATE_JACOBIAN_FOR_BLOCK(block) \ - if (N ## block && jacobians[block] != NULL) { \ - if (!NumericDiff<CostFunctor, \ - method, \ - kNumResiduals, \ - N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, \ - block, \ - N ## block >::EvaluateJacobianForParameterBlock( \ - functor_.get(), \ - residuals, \ - relative_step_size_, \ - SizedCostFunction<kNumResiduals, \ - N0, N1, N2, N3, N4, \ - N5, N6, N7, N8, N9>::num_residuals(), \ - 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); - -#undef EVALUATE_JACOBIAN_FOR_BLOCK - - return true; - } - - private: - internal::scoped_ptr<CostFunctor> functor_; - Ownership ownership_; - const double relative_step_size_; -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_NUMERIC_DIFF_COST_FUNCTION_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 deleted file mode 100644 index c316d712e97..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/ordered_groups.h +++ /dev/null @@ -1,201 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2012 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_PUBLIC_ORDERED_GROUPS_H_ -#define CERES_PUBLIC_ORDERED_GROUPS_H_ - -#include <map> -#include <set> -#include <vector> -#include "ceres/internal/port.h" -#include "glog/logging.h" - -namespace ceres { - -// A class for storing and manipulating an ordered collection of -// groups/sets with the following semantics: -// -// Group ids are non-negative integer values. Elements are any type -// that can serve as a key in a map or an element of a set. -// -// An element can only belong to one group at a time. A group may -// contain an arbitrary number of elements. -// -// Groups are ordered by their group id. -template <typename T> -class OrderedGroups { - public: - // Add an element to a group. If a group with this id does not - // exist, one is created. This method can be called any number of - // times for the same element. Group ids should be non-negative - // numbers. - // - // Return value indicates if adding the element was a success. - bool AddElementToGroup(const T element, const int group) { - if (group < 0) { - return false; - } - - typename 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. - return true; - } - - group_to_elements_[it->second].erase(element); - if (group_to_elements_[it->second].size() == 0) { - group_to_elements_.erase(it->second); - } - } - - element_to_group_[element] = group; - group_to_elements_[group].insert(element); - return true; - } - - void Clear() { - group_to_elements_.clear(); - element_to_group_.clear(); - } - - // Remove the element, no matter what group it is in. Return value - // indicates if the element was actually removed. - bool Remove(const T element) { - const int current_group = GroupId(element); - if (current_group < 0) { - return false; - } - - group_to_elements_[current_group].erase(element); - - if (group_to_elements_[current_group].size() == 0) { - // If the group is empty, then get rid of it. - group_to_elements_.erase(current_group); - } - - element_to_group_.erase(element); - return true; - } - - // Bulk remove elements. The return value indicates the number of - // elements successfully removed. - int Remove(const vector<T>& elements) { - if (NumElements() == 0 || elements.size() == 0) { - return 0; - } - - int num_removed = 0; - for (int i = 0; i < elements.size(); ++i) { - num_removed += Remove(elements[i]); - } - return num_removed; - } - - // Reverse the order of the groups in place. - void Reverse() { - typename map<int, set<T> >::reverse_iterator it = - group_to_elements_.rbegin(); - map<int, 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(); - element_it != it->second.end(); - ++element_it) { - element_to_group_[*element_it] = new_group_id; - } - new_group_to_elements[new_group_id] = it->second; - new_group_id++; - } - - group_to_elements_.swap(new_group_to_elements); - } - - // 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); - if (it == element_to_group_.end()) { - return -1; - } - return it->second; - } - - bool IsMember(const T element) const { - typename 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 = - group_to_elements_.find(group); - return (it == group_to_elements_.end()) ? 0 : it->second.size(); - } - - int NumElements() const { - return element_to_group_.size(); - } - - // Number of groups with one or more elements. - int NumGroups() const { - return group_to_elements_.size(); - } - - // The first group with one or more elements. Calling this when - // there are no groups with non-zero elements will result in a - // crash. - int MinNonZeroGroup() const { - CHECK_NE(NumGroups(), 0); - return group_to_elements_.begin()->first; - } - - const map<int, set<T> >& group_to_elements() const { - return group_to_elements_; - } - - const 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_; -}; - -// Typedef for the most commonly used version of OrderedGroups. -typedef OrderedGroups<double*> ParameterBlockOrdering; - -} // namespace ceres - -#endif // CERES_PUBLIC_ORDERED_GROUP_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/problem.h b/extern/libmv/third_party/ceres/include/ceres/problem.h deleted file mode 100644 index f75ede3a5c6..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/problem.h +++ /dev/null @@ -1,481 +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) -// keir@google.com (Keir Mierle) -// -// The Problem object is used to build and hold least squares problems. - -#ifndef CERES_PUBLIC_PROBLEM_H_ -#define CERES_PUBLIC_PROBLEM_H_ - -#include <cstddef> -#include <map> -#include <set> -#include <vector> - -#include "glog/logging.h" -#include "ceres/internal/macros.h" -#include "ceres/internal/port.h" -#include "ceres/internal/scoped_ptr.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - - -namespace ceres { - -class CostFunction; -class LossFunction; -class LocalParameterization; -class Solver; -struct CRSMatrix; - -namespace internal { -class Preprocessor; -class ProblemImpl; -class ParameterBlock; -class ResidualBlock; -} // namespace internal - -// A ResidualBlockId is an opaque handle clients can use to remove residual -// blocks from a Problem after adding them. -typedef internal::ResidualBlock* ResidualBlockId; - -// A class to represent non-linear least squares problems. Such -// problems have a cost function that is a sum of error terms (known -// as "residuals"), where each residual is a function of some subset -// of the parameters. The cost function takes the form -// -// N 1 -// SUM --- loss( || r_i1, r_i2,..., r_ik ||^2 ), -// i=1 2 -// -// where -// -// r_ij is residual number i, component j; the residual is a -// function of some subset of the parameters x1...xk. For -// example, in a structure from motion problem a residual -// might be the difference between a measured point in an -// image and the reprojected position for the matching -// camera, point pair. The residual would have two -// components, error in x and error in y. -// -// loss(y) is the loss function; for example, squared error or -// Huber L1 loss. If loss(y) = y, then the cost function is -// non-robustified least squares. -// -// This class is specifically designed to address the important subset -// of "sparse" least squares problems, where each component of the -// residual depends only on a small number number of parameters, even -// though the total number of residuals and parameters may be very -// large. This property affords tremendous gains in scale, allowing -// efficient solving of large problems that are otherwise -// inaccessible. -// -// The canonical example of a sparse least squares problem is -// "structure-from-motion" (SFM), where the parameters are points and -// cameras, and residuals are reprojection errors. Typically a single -// residual will depend only on 9 parameters (3 for the point, 6 for -// the camera). -// -// To create a least squares problem, use the AddResidualBlock() and -// AddParameterBlock() methods, documented below. Here is an example least -// squares problem containing 3 parameter blocks of sizes 3, 4 and 5 -// respectively and two residual terms of size 2 and 6: -// -// double x1[] = { 1.0, 2.0, 3.0 }; -// double x2[] = { 1.0, 2.0, 3.0, 5.0 }; -// double x3[] = { 1.0, 2.0, 3.0, 6.0, 7.0 }; -// -// Problem problem; -// -// problem.AddResidualBlock(new MyUnaryCostFunction(...), x1); -// problem.AddResidualBlock(new MyBinaryCostFunction(...), x2, x3); -// -// Please see cost_function.h for details of the CostFunction object. -class CERES_EXPORT Problem { - public: - struct CERES_EXPORT Options { - Options() - : cost_function_ownership(TAKE_OWNERSHIP), - loss_function_ownership(TAKE_OWNERSHIP), - local_parameterization_ownership(TAKE_OWNERSHIP), - enable_fast_removal(false), - disable_all_safety_checks(false) {} - - // These flags control whether the Problem object owns the cost - // functions, loss functions, and parameterizations passed into - // the Problem. If set to TAKE_OWNERSHIP, then the problem object - // will delete the corresponding cost or loss functions on - // destruction. The destructor is careful to delete the pointers - // only once, since sharing cost/loss/parameterizations is - // allowed. - Ownership cost_function_ownership; - Ownership loss_function_ownership; - Ownership local_parameterization_ownership; - - // If true, trades memory for faster RemoveResidualBlock() and - // RemoveParameterBlock() operations. - // - // By default, RemoveParameterBlock() and RemoveResidualBlock() take time - // proportional to the size of the entire problem. If you only ever remove - // parameters or residuals from the problem occassionally, this might be - // acceptable. However, if you have memory to spare, enable this option to - // make RemoveParameterBlock() take time proportional to the number of - // residual blocks that depend on it, and RemoveResidualBlock() take (on - // average) constant time. - // - // The increase in memory usage is twofold: an additonal hash set per - // parameter block containing all the residuals that depend on the parameter - // block; and a hash set in the problem containing all residuals. - bool enable_fast_removal; - - // By default, Ceres performs a variety of safety checks when constructing - // the problem. There is a small but measurable performance penalty to - // these checks, typically around 5% of construction time. If you are sure - // your problem construction is correct, and 5% of the problem construction - // time is truly an overhead you want to avoid, then you can set - // disable_all_safety_checks to true. - // - // WARNING: Do not set this to true, unless you are absolutely sure of what - // you are doing. - bool disable_all_safety_checks; - }; - - // The default constructor is equivalent to the - // invocation Problem(Problem::Options()). - Problem(); - explicit Problem(const Options& options); - - ~Problem(); - - // Add a residual block to the overall cost function. The cost - // function carries with it information about the sizes of the - // parameter blocks it expects. The function checks that these match - // the sizes of the parameter blocks listed in parameter_blocks. The - // program aborts if a mismatch is detected. loss_function can be - // NULL, in which case the cost of the term is just the squared norm - // of the residuals. - // - // The user has the option of explicitly adding the parameter blocks - // using AddParameterBlock. This causes additional correctness - // checking; however, AddResidualBlock implicitly adds the parameter - // blocks if they are not present, so calling AddParameterBlock - // explicitly is not required. - // - // The Problem object by default takes ownership of the - // cost_function and loss_function pointers. These objects remain - // live for the life of the Problem object. If the user wishes to - // keep control over the destruction of these objects, then they can - // do this by setting the corresponding enums in the Options struct. - // - // Note: Even though the Problem takes ownership of cost_function - // and loss_function, it does not preclude the user from re-using - // them in another residual block. The destructor takes care to call - // delete on each cost_function or loss_function pointer only once, - // regardless of how many residual blocks refer to them. - // - // Example usage: - // - // double x1[] = {1.0, 2.0, 3.0}; - // double x2[] = {1.0, 2.0, 5.0, 6.0}; - // double x3[] = {3.0, 6.0, 2.0, 5.0, 1.0}; - // - // Problem 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); - - // Convenience methods for adding residuals with a small number of - // parameters. This is the common case. Instead of specifying the - // parameter block arguments as a vector, list them as pointers. - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3, double* x4); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3, double* x4, double* x5); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3, double* x4, double* x5, - double* x6); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3, double* x4, double* x5, - double* x6, double* x7); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3, double* x4, double* x5, - double* x6, double* x7, double* x8); - ResidualBlockId AddResidualBlock(CostFunction* cost_function, - LossFunction* loss_function, - double* x0, double* x1, double* x2, - double* x3, double* x4, double* x5, - double* x6, double* x7, double* x8, - double* x9); - - // Add a parameter block with appropriate size to the problem. - // Repeated calls with the same arguments are ignored. Repeated - // calls with the same double pointer but a different size results - // in undefined behaviour. - void AddParameterBlock(double* values, int size); - - // Add a parameter block with appropriate size and parameterization - // to the problem. Repeated calls with the same arguments are - // ignored. Repeated calls with the same double pointer but a - // different size results in undefined behaviour. - void AddParameterBlock(double* values, - int size, - LocalParameterization* local_parameterization); - - // Remove a parameter block from the problem. The parameterization of the - // parameter block, if it exists, will persist until the deletion of the - // problem (similar to cost/loss functions in residual block removal). Any - // residual blocks that depend on the parameter are also removed, as - // described above in RemoveResidualBlock(). - // - // If Problem::Options::enable_fast_removal is true, then the - // removal is fast (almost constant time). Otherwise, removing a parameter - // block will incur a scan of the entire Problem object. - // - // WARNING: Removing a residual or parameter block will destroy the implicit - // ordering, rendering the jacobian or residuals returned from the solver - // uninterpretable. If you depend on the evaluated jacobian, do not use - // remove! This may change in a future release. - void RemoveParameterBlock(double* values); - - // Remove a residual block from the problem. Any parameters that the residual - // block depends on are not removed. The cost and loss functions for the - // residual block will not get deleted immediately; won't happen until the - // problem itself is deleted. - // - // WARNING: Removing a residual or parameter block will destroy the implicit - // ordering, rendering the jacobian or residuals returned from the solver - // uninterpretable. If you depend on the evaluated jacobian, do not use - // remove! This may change in a future release. - void RemoveResidualBlock(ResidualBlockId residual_block); - - // Hold the indicated parameter block constant during optimization. - void SetParameterBlockConstant(double* values); - - // Allow the indicated parameter block to vary during optimization. - void SetParameterBlockVariable(double* values); - - // Set the local parameterization for one of the parameter blocks. - // The local_parameterization is owned by the Problem by default. It - // is acceptable to set the same parameterization for multiple - // parameters; the destructor is careful to delete local - // parameterizations only once. The local parameterization can only - // be set once per parameter, and cannot be changed once set. - void SetParameterization(double* values, - LocalParameterization* local_parameterization); - - // Get the local parameterization object associated with this - // parameter block. If there is no parameterization object - // associated then NULL is returned. - const LocalParameterization* GetParameterization(double* values) const; - - // Set the lower/upper bound for the parameter with position "index". - void SetParameterLowerBound(double* values, int index, double lower_bound); - void SetParameterUpperBound(double* values, int index, double upper_bound); - - // Number of parameter blocks in the problem. Always equals - // parameter_blocks().size() and parameter_block_sizes().size(). - int NumParameterBlocks() const; - - // The size of the parameter vector obtained by summing over the - // sizes of all the parameter blocks. - int NumParameters() const; - - // Number of residual blocks in the problem. Always equals - // residual_blocks().size(). - int NumResidualBlocks() const; - - // The size of the residual vector obtained by summing over the - // sizes of all of the residual blocks. - int NumResiduals() const; - - // The size of the parameter block. - int ParameterBlockSize(const double* values) const; - - // The size of local parameterization for the parameter block. If - // there is no local parameterization associated with this parameter - // block, then ParameterBlockLocalSize = ParameterBlockSize. - int ParameterBlockLocalSize(const double* values) const; - - // Is the given parameter block present in this problem or not? - bool HasParameterBlock(const double* values) const; - - // 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; - - // 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; - - // Get all the parameter blocks that depend on the given residual block. - void GetParameterBlocksForResidualBlock( - const ResidualBlockId residual_block, - vector<double*>* parameter_blocks) const; - - // Get the CostFunction for the given residual block. - const CostFunction* GetCostFunctionForResidualBlock( - const ResidualBlockId residual_block) const; - - // Get the LossFunction for the given residual block. Returns NULL - // if no loss function is associated with this residual block. - const LossFunction* GetLossFunctionForResidualBlock( - const ResidualBlockId residual_block) const; - - // Get all the residual blocks that depend on the given parameter block. - // - // If Problem::Options::enable_fast_removal is true, then - // getting the residual blocks is fast and depends only on the number of - // residual blocks. Otherwise, getting the residual blocks for a parameter - // block will incur a scan of the entire Problem object. - void GetResidualBlocksForParameterBlock( - const double* values, - vector<ResidualBlockId>* residual_blocks) const; - - // Options struct to control Problem::Evaluate. - struct EvaluateOptions { - EvaluateOptions() - : apply_loss_function(true), - num_threads(1) { - } - - // The set of parameter blocks for which evaluation should be - // performed. This vector determines the order that parameter - // blocks occur in the gradient vector and in the columns of the - // jacobian matrix. If parameter_blocks is empty, then it is - // assumed to be equal to vector containing ALL the parameter - // blocks. Generally speaking the parameter blocks will occur in - // the order in which they were added to the problem. But, this - // may change if the user removes any parameter blocks from the - // problem. - // - // NOTE: This vector should contain the same pointers as the ones - // 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; - - // 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; - - // Even though the residual blocks in the problem may contain loss - // functions, setting apply_loss_function to false will turn off - // the application of the loss function to the output of the cost - // function. This is of use for example if the user wishes to - // analyse the solution quality by studying the distribution of - // residuals before and after the solve. - bool apply_loss_function; - - int num_threads; - }; - - // Evaluate Problem. Any of the output pointers can be NULL. Which - // residual blocks and parameter blocks are used is controlled by - // the EvaluateOptions struct above. - // - // Note 1: The evaluation will use the values stored in the memory - // locations pointed to by the parameter block pointers used at the - // time of the construction of the problem. i.e., - // - // Problem problem; - // double x = 1; - // problem.AddResidualBlock(new MyCostFunction, NULL, &x); - // - // double cost = 0.0; - // problem.Evaluate(Problem::EvaluateOptions(), &cost, NULL, NULL, NULL); - // - // The cost is evaluated at x = 1. If you wish to evaluate the - // problem at x = 2, then - // - // x = 2; - // problem.Evaluate(Problem::EvaluateOptions(), &cost, NULL, NULL, NULL); - // - // is the way to do so. - // - // Note 2: If no local parameterizations are used, then the size of - // the gradient vector (and the number of columns in the jacobian) - // is the sum of the sizes of all the parameter blocks. If a - // parameter block has a local parameterization, then it contributes - // "LocalSize" entries to the gradient vector (and the number of - // columns in the jacobian). - bool Evaluate(const EvaluateOptions& options, - double* cost, - vector<double>* residuals, - vector<double>* gradient, - CRSMatrix* jacobian); - - private: - friend class Solver; - friend class Covariance; - internal::scoped_ptr<internal::ProblemImpl> problem_impl_; - CERES_DISALLOW_COPY_AND_ASSIGN(Problem); -}; - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_PROBLEM_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/rotation.h b/extern/libmv/third_party/ceres/include/ceres/rotation.h deleted file mode 100644 index e3dbfe84a5a..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/rotation.h +++ /dev/null @@ -1,645 +0,0 @@ -// 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/ -// -// 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: keir@google.com (Keir Mierle) -// sameeragarwal@google.com (Sameer Agarwal) -// -// Templated functions for manipulating rotations. The templated -// functions are useful when implementing functors for automatic -// differentiation. -// -// In the following, the Quaternions are laid out as 4-vectors, thus: -// -// q[0] scalar part. -// q[1] coefficient of i. -// q[2] coefficient of j. -// q[3] coefficient of k. -// -// where: i*i = j*j = k*k = -1 and i*j = k, j*k = i, k*i = j. - -#ifndef CERES_PUBLIC_ROTATION_H_ -#define CERES_PUBLIC_ROTATION_H_ - -#include <algorithm> -#include <cmath> -#include "glog/logging.h" - -namespace ceres { - -// Trivial wrapper to index linear arrays as matrices, given a fixed -// column and row stride. When an array "T* array" is wrapped by a -// -// (const) MatrixAdapter<T, row_stride, col_stride> M" -// -// the expression M(i, j) is equivalent to -// -// arrary[i * row_stride + j * col_stride] -// -// Conversion functions to and from rotation matrices accept -// MatrixAdapters to permit using row-major and column-major layouts, -// and rotation matrices embedded in larger matrices (such as a 3x4 -// projection matrix). -template <typename T, int row_stride, int col_stride> -struct MatrixAdapter; - -// Convenience functions to create a MatrixAdapter that treats the -// array pointed to by "pointer" as a 3x3 (contiguous) column-major or -// row-major matrix. -template <typename T> -MatrixAdapter<T, 1, 3> ColumnMajorAdapter3x3(T* pointer); - -template <typename T> -MatrixAdapter<T, 3, 1> RowMajorAdapter3x3(T* pointer); - -// Convert a value in combined axis-angle representation to a quaternion. -// The value angle_axis is a triple whose norm is an angle in radians, -// and whose direction is aligned with the axis of rotation, -// and quaternion is a 4-tuple that will contain the resulting quaternion. -// The implementation may be used with auto-differentiation up to the first -// derivative, higher derivatives may have unexpected results near the origin. -template<typename T> -void AngleAxisToQuaternion(const T* angle_axis, T* quaternion); - -// Convert a quaternion to the equivalent combined axis-angle representation. -// The value quaternion must be a unit quaternion - it is not normalized first, -// and angle_axis will be filled with a value whose norm is the angle of -// rotation in radians, and whose direction is the axis of rotation. -// The implemention may be used with auto-differentiation up to the first -// derivative, higher derivatives may have unexpected results near the origin. -template<typename T> -void QuaternionToAngleAxis(const T* quaternion, T* angle_axis); - -// Conversions between 3x3 rotation matrix (in column major order) and -// axis-angle rotation representations. Templated for use with -// autodifferentiation. -template <typename T> -void RotationMatrixToAngleAxis(const T* R, T* angle_axis); - -template <typename T, int row_stride, int col_stride> -void RotationMatrixToAngleAxis( - const MatrixAdapter<const T, row_stride, col_stride>& R, - T* angle_axis); - -template <typename T> -void AngleAxisToRotationMatrix(const T* angle_axis, T* R); - -template <typename T, int row_stride, int col_stride> -void AngleAxisToRotationMatrix( - const T* angle_axis, - const MatrixAdapter<T, row_stride, col_stride>& R); - -// Conversions between 3x3 rotation matrix (in row major order) and -// Euler angle (in degrees) rotation representations. -// -// The {pitch,roll,yaw} Euler angles are rotations around the {x,y,z} -// axes, respectively. They are applied in that same order, so the -// total rotation R is Rz * Ry * Rx. -template <typename T> -void EulerAnglesToRotationMatrix(const T* euler, int row_stride, T* R); - -template <typename T, int row_stride, int col_stride> -void EulerAnglesToRotationMatrix( - const T* euler, - const MatrixAdapter<T, row_stride, col_stride>& R); - -// Convert a 4-vector to a 3x3 scaled rotation matrix. -// -// The choice of rotation is such that the quaternion [1 0 0 0] goes to an -// identity matrix and for small a, b, c the quaternion [1 a b c] goes to -// the matrix -// -// [ 0 -c b ] -// I + 2 [ c 0 -a ] + higher order terms -// [ -b a 0 ] -// -// which corresponds to a Rodrigues approximation, the last matrix being -// 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 -template <typename T> inline -void QuaternionToScaledRotation(const T q[4], T R[3 * 3]); - -template <typename T, int row_stride, int col_stride> inline -void QuaternionToScaledRotation( - const T q[4], - const MatrixAdapter<T, row_stride, col_stride>& R); - -// Same as above except that the rotation matrix is normalized by the -// Frobenius norm, so that R * R' = I (and det(R) = 1). -template <typename T> inline -void QuaternionToRotation(const T q[4], T R[3 * 3]); - -template <typename T, int row_stride, int col_stride> inline -void QuaternionToRotation( - const T q[4], - const MatrixAdapter<T, row_stride, col_stride>& R); - -// Rotates a point pt by a quaternion q: -// -// result = R(q) * pt -// -// Assumes the quaternion is unit norm. This assumption allows us to -// write the transform as (something)*pt + pt, as is clear from the -// formula below. If you pass in a quaternion with |q|^2 = 2 then you -// WILL NOT get back 2 times the result you get for a unit quaternion. -template <typename T> inline -void UnitQuaternionRotatePoint(const T q[4], const T pt[3], T result[3]); - -// With this function you do not need to assume that q has unit norm. -// It does assume that the norm is non-zero. -template <typename T> inline -void QuaternionRotatePoint(const T q[4], const T pt[3], T result[3]); - -// zw = z * w, where * is the Quaternion product between 4 vectors. -template<typename T> inline -void QuaternionProduct(const T z[4], const T w[4], T zw[4]); - -// xy = x cross y; -template<typename T> inline -void CrossProduct(const T x[3], const T y[3], T x_cross_y[3]); - -template<typename T> inline -T DotProduct(const T x[3], const T y[3]); - -// y = R(angle_axis) * x; -template<typename T> inline -void AngleAxisRotatePoint(const T angle_axis[3], const T pt[3], T result[3]); - -// --- IMPLEMENTATION - -template<typename T, int row_stride, int col_stride> -struct MatrixAdapter { - T* pointer_; - explicit MatrixAdapter(T* pointer) - : pointer_(pointer) - {} - - T& operator()(int r, int c) const { - return pointer_[r * row_stride + c * col_stride]; - } -}; - -template <typename T> -MatrixAdapter<T, 1, 3> ColumnMajorAdapter3x3(T* pointer) { - return MatrixAdapter<T, 1, 3>(pointer); -} - -template <typename T> -MatrixAdapter<T, 3, 1> RowMajorAdapter3x3(T* pointer) { - return MatrixAdapter<T, 3, 1>(pointer); -} - -template<typename T> -inline void AngleAxisToQuaternion(const T* angle_axis, T* quaternion) { - const T& a0 = angle_axis[0]; - const T& a1 = angle_axis[1]; - const T& a2 = angle_axis[2]; - const T theta_squared = a0 * a0 + a1 * a1 + a2 * a2; - - // For points not at the origin, the full conversion is numerically stable. - if (theta_squared > T(0.0)) { - const T theta = sqrt(theta_squared); - const T half_theta = theta * T(0.5); - const T k = sin(half_theta) / theta; - quaternion[0] = cos(half_theta); - quaternion[1] = a0 * k; - quaternion[2] = a1 * k; - quaternion[3] = a2 * k; - } else { - // At the origin, sqrt() will produce NaN in the derivative since - // the argument is zero. By approximating with a Taylor series, - // and truncating at one term, the value and first derivatives will be - // computed correctly when Jets are used. - const T k(0.5); - quaternion[0] = T(1.0); - quaternion[1] = a0 * k; - quaternion[2] = a1 * k; - quaternion[3] = a2 * k; - } -} - -template<typename T> -inline void QuaternionToAngleAxis(const T* quaternion, T* angle_axis) { - const T& q1 = quaternion[1]; - const T& q2 = quaternion[2]; - const T& q3 = quaternion[3]; - const T sin_squared_theta = q1 * q1 + q2 * q2 + q3 * q3; - - // For quaternions representing non-zero rotation, the conversion - // is numerically stable. - if (sin_squared_theta > T(0.0)) { - const T sin_theta = sqrt(sin_squared_theta); - const T& cos_theta = quaternion[0]; - - // If cos_theta is negative, theta is greater than pi/2, which - // means that angle for the angle_axis vector which is 2 * theta - // would be greater than pi. - // - // While this will result in the correct rotation, it does not - // result in a normalized angle-axis vector. - // - // In that case we observe that 2 * theta ~ 2 * theta - 2 * pi, - // which is equivalent saying - // - // theta - pi = atan(sin(theta - pi), cos(theta - pi)) - // = atan(-sin(theta), -cos(theta)) - // - const T two_theta = - T(2.0) * ((cos_theta < 0.0) - ? atan2(-sin_theta, -cos_theta) - : atan2(sin_theta, cos_theta)); - const T k = two_theta / sin_theta; - angle_axis[0] = q1 * k; - angle_axis[1] = q2 * k; - angle_axis[2] = q3 * k; - } else { - // For zero rotation, sqrt() will produce NaN in the derivative since - // the argument is zero. By approximating with a Taylor series, - // and truncating at one term, the value and first derivatives will be - // computed correctly when Jets are used. - const T k(2.0); - angle_axis[0] = q1 * k; - angle_axis[1] = q2 * k; - angle_axis[2] = q3 * k; - } -} - -// 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 -// occurs and deals with them by taking code paths that are guaranteed -// to not perform division by a small number. -template <typename T> -inline void RotationMatrixToAngleAxis(const T* R, T* angle_axis) { - RotationMatrixToAngleAxis(ColumnMajorAdapter3x3(R), angle_axis); -} - -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]; - } - } -} - -template <typename T> -inline void AngleAxisToRotationMatrix(const T* angle_axis, T* R) { - AngleAxisToRotationMatrix(angle_axis, ColumnMajorAdapter3x3(R)); -} - -template <typename T, int row_stride, int col_stride> -void AngleAxisToRotationMatrix( - const T* angle_axis, - const MatrixAdapter<T, row_stride, col_stride>& R) { - static const T kOne = T(1.0); - const T theta2 = DotProduct(angle_axis, angle_axis); - if (theta2 > T(std::numeric_limits<double>::epsilon())) { - // We want to be careful to only evaluate the square root if the - // norm of the angle_axis vector is greater than zero. Otherwise - // we get a division by zero. - const T theta = sqrt(theta2); - const T wx = angle_axis[0] / theta; - const T wy = angle_axis[1] / theta; - const T wz = angle_axis[2] / theta; - - const T costheta = cos(theta); - const T sintheta = sin(theta); - - R(0, 0) = costheta + wx*wx*(kOne - costheta); - R(1, 0) = wz*sintheta + wx*wy*(kOne - costheta); - R(2, 0) = -wy*sintheta + wx*wz*(kOne - costheta); - R(0, 1) = wx*wy*(kOne - costheta) - wz*sintheta; - R(1, 1) = costheta + wy*wy*(kOne - costheta); - R(2, 1) = wx*sintheta + wy*wz*(kOne - costheta); - R(0, 2) = wy*sintheta + wx*wz*(kOne - costheta); - R(1, 2) = -wx*sintheta + wy*wz*(kOne - costheta); - R(2, 2) = costheta + wz*wz*(kOne - costheta); - } else { - // Near zero, we switch to using the first order Taylor expansion. - R(0, 0) = kOne; - R(1, 0) = angle_axis[2]; - R(2, 0) = -angle_axis[1]; - R(0, 1) = -angle_axis[2]; - R(1, 1) = kOne; - R(2, 1) = angle_axis[0]; - R(0, 2) = angle_axis[1]; - R(1, 2) = -angle_axis[0]; - R(2, 2) = kOne; - } -} - -template <typename T> -inline void EulerAnglesToRotationMatrix(const T* euler, - const int row_stride_parameter, - T* R) { - CHECK_EQ(row_stride_parameter, 3); - EulerAnglesToRotationMatrix(euler, RowMajorAdapter3x3(R)); -} - -template <typename T, int row_stride, int col_stride> -void EulerAnglesToRotationMatrix( - const T* euler, - const MatrixAdapter<T, row_stride, col_stride>& R) { - const double kPi = 3.14159265358979323846; - const T degrees_to_radians(kPi / 180.0); - - const T pitch(euler[0] * degrees_to_radians); - const T roll(euler[1] * degrees_to_radians); - const T yaw(euler[2] * degrees_to_radians); - - const T c1 = cos(yaw); - const T s1 = sin(yaw); - const T c2 = cos(roll); - const T s2 = sin(roll); - const T c3 = cos(pitch); - const T s3 = sin(pitch); - - R(0, 0) = c1*c2; - R(0, 1) = -s1*c3 + c1*s2*s3; - R(0, 2) = s1*s3 + c1*s2*c3; - - R(1, 0) = s1*c2; - R(1, 1) = c1*c3 + s1*s2*s3; - R(1, 2) = -c1*s3 + s1*s2*c3; - - R(2, 0) = -s2; - R(2, 1) = c2*s3; - R(2, 2) = c2*c3; -} - -template <typename T> inline -void QuaternionToScaledRotation(const T q[4], T R[3 * 3]) { - QuaternionToScaledRotation(q, RowMajorAdapter3x3(R)); -} - -template <typename T, int row_stride, int col_stride> inline -void QuaternionToScaledRotation( - const T q[4], - const MatrixAdapter<T, row_stride, col_stride>& R) { - // Make convenient names for elements of q. - T a = q[0]; - T b = q[1]; - T c = q[2]; - T d = q[3]; - // This is not to eliminate common sub-expression, but to - // make the lines shorter so that they fit in 80 columns! - T aa = a * a; - T ab = a * b; - T ac = a * c; - T ad = a * d; - T bb = b * b; - T bc = b * c; - T bd = b * d; - T cc = c * c; - T cd = c * d; - T dd = d * d; - - R(0, 0) = aa + bb - cc - dd; R(0, 1) = T(2) * (bc - ad); R(0, 2) = T(2) * (ac + bd); // NOLINT - R(1, 0) = T(2) * (ad + bc); R(1, 1) = aa - bb + cc - dd; R(1, 2) = T(2) * (cd - ab); // NOLINT - R(2, 0) = T(2) * (bd - ac); R(2, 1) = T(2) * (ab + cd); R(2, 2) = aa - bb - cc + dd; // NOLINT -} - -template <typename T> inline -void QuaternionToRotation(const T q[4], T R[3 * 3]) { - QuaternionToRotation(q, RowMajorAdapter3x3(R)); -} - -template <typename T, int row_stride, int col_stride> inline -void QuaternionToRotation(const T q[4], - const MatrixAdapter<T, row_stride, col_stride>& R) { - QuaternionToScaledRotation(q, R); - - T normalizer = q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]; - CHECK_NE(normalizer, T(0)); - normalizer = T(1) / normalizer; - - for (int i = 0; i < 3; ++i) { - for (int j = 0; j < 3; ++j) { - R(i, j) *= normalizer; - } - } -} - -template <typename T> inline -void UnitQuaternionRotatePoint(const T q[4], const T pt[3], T result[3]) { - const T t2 = q[0] * q[1]; - const T t3 = q[0] * q[2]; - const T t4 = q[0] * q[3]; - const T t5 = -q[1] * q[1]; - const T t6 = q[1] * q[2]; - const T t7 = q[1] * q[3]; - const T t8 = -q[2] * q[2]; - const T t9 = q[2] * q[3]; - const T t1 = -q[3] * q[3]; - result[0] = T(2) * ((t8 + t1) * pt[0] + (t6 - t4) * pt[1] + (t3 + t7) * pt[2]) + pt[0]; // NOLINT - result[1] = T(2) * ((t4 + t6) * pt[0] + (t5 + t1) * pt[1] + (t9 - t2) * pt[2]) + pt[1]; // NOLINT - result[2] = T(2) * ((t7 - t3) * pt[0] + (t2 + t9) * pt[1] + (t5 + t8) * pt[2]) + pt[2]; // NOLINT -} - -template <typename T> inline -void QuaternionRotatePoint(const T q[4], const T pt[3], T result[3]) { - // 'scale' is 1 / norm(q). - const T scale = T(1) / sqrt(q[0] * q[0] + - q[1] * q[1] + - q[2] * q[2] + - q[3] * q[3]); - - // Make unit-norm version of q. - const T unit[4] = { - scale * q[0], - scale * q[1], - scale * q[2], - scale * q[3], - }; - - UnitQuaternionRotatePoint(unit, pt, result); -} - -template<typename T> inline -void QuaternionProduct(const T z[4], const T w[4], T zw[4]) { - zw[0] = z[0] * w[0] - z[1] * w[1] - z[2] * w[2] - z[3] * w[3]; - zw[1] = z[0] * w[1] + z[1] * w[0] + z[2] * w[3] - z[3] * w[2]; - zw[2] = z[0] * w[2] - z[1] * w[3] + z[2] * w[0] + z[3] * w[1]; - zw[3] = z[0] * w[3] + z[1] * w[2] - z[2] * w[1] + z[3] * w[0]; -} - -// xy = x cross y; -template<typename T> inline -void CrossProduct(const T x[3], const T y[3], T x_cross_y[3]) { - x_cross_y[0] = x[1] * y[2] - x[2] * y[1]; - x_cross_y[1] = x[2] * y[0] - x[0] * y[2]; - x_cross_y[2] = x[0] * y[1] - x[1] * y[0]; -} - -template<typename T> inline -T DotProduct(const T x[3], const T y[3]) { - return (x[0] * y[0] + x[1] * y[1] + x[2] * y[2]); -} - -template<typename T> inline -void AngleAxisRotatePoint(const T angle_axis[3], const T pt[3], T result[3]) { - const T theta2 = DotProduct(angle_axis, angle_axis); - if (theta2 > T(std::numeric_limits<double>::epsilon())) { - // Away from zero, use the rodriguez formula - // - // result = pt costheta + - // (w x pt) * sintheta + - // w (w . pt) (1 - costheta) - // - // We want to be careful to only evaluate the square root if the - // norm of the angle_axis vector is greater than zero. Otherwise - // we get a division by zero. - // - const T theta = sqrt(theta2); - const T costheta = cos(theta); - const T sintheta = sin(theta); - const T theta_inverse = 1.0 / theta; - - const T w[3] = { angle_axis[0] * theta_inverse, - angle_axis[1] * theta_inverse, - angle_axis[2] * theta_inverse }; - - // Explicitly inlined evaluation of the cross product for - // performance reasons. - const T w_cross_pt[3] = { w[1] * pt[2] - w[2] * pt[1], - w[2] * pt[0] - w[0] * pt[2], - w[0] * pt[1] - w[1] * pt[0] }; - const T tmp = - (w[0] * pt[0] + w[1] * pt[1] + w[2] * pt[2]) * (T(1.0) - costheta); - - result[0] = pt[0] * costheta + w_cross_pt[0] * sintheta + w[0] * tmp; - result[1] = pt[1] * costheta + w_cross_pt[1] * sintheta + w[1] * tmp; - result[2] = pt[2] * costheta + w_cross_pt[2] * sintheta + w[2] * tmp; - } else { - // Near zero, the first order Taylor approximation of the rotation - // matrix R corresponding to a vector w and angle w is - // - // R = I + hat(w) * sin(theta) - // - // But sintheta ~ theta and theta * w = angle_axis, which gives us - // - // R = I + hat(w) - // - // and actually performing multiplication with the point pt, gives us - // R * pt = pt + w x pt. - // - // Switching to the Taylor expansion near zero provides meaningful - // derivatives when evaluated using Jets. - // - // Explicitly inlined evaluation of the cross product for - // performance reasons. - const T w_cross_pt[3] = { angle_axis[1] * pt[2] - angle_axis[2] * pt[1], - angle_axis[2] * pt[0] - angle_axis[0] * pt[2], - angle_axis[0] * pt[1] - angle_axis[1] * pt[0] }; - - result[0] = pt[0] + w_cross_pt[0]; - result[1] = pt[1] + w_cross_pt[1]; - result[2] = pt[2] + w_cross_pt[2]; - } -} - -} // namespace ceres - -#endif // CERES_PUBLIC_ROTATION_H_ 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 deleted file mode 100644 index 4f98d4eb95c..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/sized_cost_function.h +++ /dev/null @@ -1,96 +0,0 @@ -// 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/ -// -// 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: keir@google.com (Keir Mierle) -// -// A convenience class for cost functions which are statically sized. -// Compared to the dynamically-sized base class, this reduces boilerplate. -// -// The kNumResiduals template parameter can be a constant such as 2 or 5, or it -// can be ceres::DYNAMIC. If kNumResiduals is ceres::DYNAMIC, then subclasses -// are responsible for calling set_num_residuals() at runtime. - -#ifndef CERES_PUBLIC_SIZED_COST_FUNCTION_H_ -#define CERES_PUBLIC_SIZED_COST_FUNCTION_H_ - -#include "ceres/types.h" -#include "ceres/cost_function.h" -#include "glog/logging.h" - -namespace ceres { - -template<int kNumResiduals, - int N0 = 0, int N1 = 0, int N2 = 0, int N3 = 0, int N4 = 0, - int N5 = 0, int N6 = 0, int N7 = 0, int N8 = 0, int N9 = 0> -class SizedCostFunction : public CostFunction { - public: - SizedCostFunction() { - CHECK(kNumResiduals > 0 || kNumResiduals == DYNAMIC) - << "Cost functions must have at least one residual block."; - - // 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))) - << "Zero block cannot precede a non-zero block. Block sizes are " - << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", " - << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", " - << N8 << ", " << N9; - - set_num_residuals(kNumResiduals); - -#define 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 - } - - virtual ~SizedCostFunction() { } - - // Subclasses must implement Evaluate(). -}; - -} // namespace ceres - -#endif // CERES_PUBLIC_SIZED_COST_FUNCTION_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/solver.h b/extern/libmv/third_party/ceres/include/ceres/solver.h deleted file mode 100644 index a5efa2a3915..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/solver.h +++ /dev/null @@ -1,1004 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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_PUBLIC_SOLVER_H_ -#define CERES_PUBLIC_SOLVER_H_ - -#include <cmath> -#include <string> -#include <vector> -#include "ceres/crs_matrix.h" -#include "ceres/internal/macros.h" -#include "ceres/internal/port.h" -#include "ceres/iteration_callback.h" -#include "ceres/ordered_groups.h" -#include "ceres/types.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -class Problem; - -// Interface for non-linear least squares solvers. -class CERES_EXPORT Solver { - public: - virtual ~Solver(); - - // The options structure contains, not surprisingly, options that control how - // the solver operates. The defaults should be suitable for a wide range of - // problems; however, better performance is often obtainable with tweaking. - // - // The constants are defined inside types.h - struct CERES_EXPORT Options { - // Default constructor that sets up a generic sparse problem. - Options() { - minimizer_type = TRUST_REGION; - line_search_direction_type = LBFGS; - line_search_type = WOLFE; - nonlinear_conjugate_gradient_type = FLETCHER_REEVES; - max_lbfgs_rank = 20; - use_approximate_eigenvalue_bfgs_scaling = false; - line_search_interpolation_type = CUBIC; - min_line_search_step_size = 1e-9; - line_search_sufficient_function_decrease = 1e-4; - max_line_search_step_contraction = 1e-3; - min_line_search_step_contraction = 0.6; - max_num_line_search_step_size_iterations = 20; - max_num_line_search_direction_restarts = 5; - line_search_sufficient_curvature_decrease = 0.9; - max_line_search_step_expansion = 10.0; - trust_region_strategy_type = LEVENBERG_MARQUARDT; - dogleg_type = TRADITIONAL_DOGLEG; - use_nonmonotonic_steps = false; - max_consecutive_nonmonotonic_steps = 5; - max_num_iterations = 50; - max_solver_time_in_seconds = 1e9; - num_threads = 1; - initial_trust_region_radius = 1e4; - max_trust_region_radius = 1e16; - min_trust_region_radius = 1e-32; - min_relative_decrease = 1e-3; - min_lm_diagonal = 1e-6; - max_lm_diagonal = 1e32; - max_num_consecutive_invalid_steps = 5; - function_tolerance = 1e-6; - gradient_tolerance = 1e-10; - parameter_tolerance = 1e-8; - -#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE) - linear_solver_type = DENSE_QR; -#else - linear_solver_type = SPARSE_NORMAL_CHOLESKY; -#endif - - preconditioner_type = JACOBI; - visibility_clustering_type = CANONICAL_VIEWS; - dense_linear_algebra_library_type = EIGEN; - - // Choose a default sparse linear algebra library in the order: - // - // SUITE_SPARSE > CX_SPARSE > EIGEN_SPARSE -#if !defined(CERES_NO_SUITESPARSE) - sparse_linear_algebra_library_type = SUITE_SPARSE; -#else - #if !defined(CERES_NO_CXSPARSE) - sparse_linear_algebra_library_type = CX_SPARSE; - #else - #if defined(CERES_USE_EIGEN_SPARSE) - sparse_linear_algebra_library_type = EIGEN_SPARSE; - #endif - #endif -#endif - - num_linear_solver_threads = 1; - use_explicit_schur_complement = false; - use_postordering = false; - dynamic_sparsity = false; - min_linear_solver_iterations = 0; - max_linear_solver_iterations = 500; - eta = 1e-1; - jacobi_scaling = true; - use_inner_iterations = false; - inner_iteration_tolerance = 1e-3; - logging_type = PER_MINIMIZER_ITERATION; - minimizer_progress_to_stdout = false; - trust_region_problem_dump_directory = "/tmp"; - trust_region_problem_dump_format_type = TEXTFILE; - check_gradients = false; - gradient_check_relative_precision = 1e-8; - numeric_derivative_relative_step_size = 1e-6; - update_state_every_iteration = false; - } - - // 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; - - // Minimizer options ---------------------------------------- - - // Ceres supports the two major families of optimization strategies - - // Trust Region and Line Search. - // - // 1. The line search approach first finds a descent direction - // along which the objective function will be reduced and then - // computes a step size that decides how far should move along - // that direction. The descent direction can be computed by - // various methods, such as gradient descent, Newton's method and - // Quasi-Newton method. The step size can be determined either - // exactly or inexactly. - // - // 2. The trust region approach approximates the objective - // function using using a model function (often a quadratic) over - // a subset of the search space known as the trust region. If the - // model function succeeds in minimizing the true objective - // function the trust region is expanded; conversely, otherwise it - // is contracted and the model optimization problem is solved - // again. - // - // Trust region methods are in some sense dual to line search methods: - // trust region methods first choose a step size (the size of the - // trust region) and then a step direction while line search methods - // first choose a step direction and then a step size. - MinimizerType minimizer_type; - - LineSearchDirectionType line_search_direction_type; - LineSearchType line_search_type; - NonlinearConjugateGradientType nonlinear_conjugate_gradient_type; - - // The LBFGS hessian approximation is a low rank approximation to - // the inverse of the Hessian matrix. The rank of the - // approximation determines (linearly) the space and time - // complexity of using the approximation. Higher the rank, the - // better is the quality of the approximation. The increase in - // quality is however is bounded for a number of reasons. - // - // 1. The method only uses secant information and not actual - // derivatives. - // - // 2. The Hessian approximation is constrained to be positive - // definite. - // - // So increasing this rank to a large number will cost time and - // space complexity without the corresponding increase in solution - // quality. There are no hard and fast rules for choosing the - // maximum rank. The best choice usually requires some problem - // specific experimentation. - // - // For more theoretical and implementation details of the LBFGS - // method, please see: - // - // Nocedal, J. (1980). "Updating Quasi-Newton Matrices with - // Limited Storage". Mathematics of Computation 35 (151): 773–782. - int max_lbfgs_rank; - - // As part of the (L)BFGS update step (BFGS) / right-multiply step (L-BFGS), - // the initial inverse Hessian approximation is taken to be the Identity. - // However, Oren showed that using instead I * \gamma, where \gamma is - // chosen to approximate an eigenvalue of the true inverse Hessian can - // result in improved convergence in a wide variety of cases. Setting - // use_approximate_eigenvalue_bfgs_scaling to true enables this scaling. - // - // It is important to note that approximate eigenvalue scaling does not - // always improve convergence, and that it can in fact significantly degrade - // performance for certain classes of problem, which is why it is disabled - // by default. In particular it can degrade performance when the - // sensitivity of the problem to different parameters varies significantly, - // as in this case a single scalar factor fails to capture this variation - // and detrimentally downscales parts of the jacobian approximation which - // correspond to low-sensitivity parameters. It can also reduce the - // robustness of the solution to errors in the jacobians. - // - // Oren S.S., Self-scaling variable metric (SSVM) algorithms - // Part II: Implementation and experiments, Management Science, - // 20(5), 863-874, 1974. - bool use_approximate_eigenvalue_bfgs_scaling; - - // Degree of the polynomial used to approximate the objective - // function. Valid values are BISECTION, QUADRATIC and CUBIC. - // - // BISECTION corresponds to pure backtracking search with no - // interpolation. - LineSearchInterpolationType line_search_interpolation_type; - - // If during the line search, the step_size falls below this - // value, it is truncated to zero. - double min_line_search_step_size; - - // Line search parameters. - - // Solving the line search problem exactly is computationally - // prohibitive. Fortunately, line search based optimization - // algorithms can still guarantee convergence if instead of an - // exact solution, the line search algorithm returns a solution - // which decreases the value of the objective function - // sufficiently. More precisely, we are looking for a step_size - // s.t. - // - // f(step_size) <= f(0) + sufficient_decrease * f'(0) * step_size - // - double line_search_sufficient_function_decrease; - - // In each iteration of the line search, - // - // new_step_size >= max_line_search_step_contraction * step_size - // - // Note that by definition, for contraction: - // - // 0 < max_step_contraction < min_step_contraction < 1 - // - double max_line_search_step_contraction; - - // In each iteration of the line search, - // - // new_step_size <= min_line_search_step_contraction * step_size - // - // Note that by definition, for contraction: - // - // 0 < max_step_contraction < min_step_contraction < 1 - // - double min_line_search_step_contraction; - - // Maximum number of trial step size iterations during each line search, - // if a step size satisfying the search conditions cannot be found within - // this number of trials, the line search will terminate. - int max_num_line_search_step_size_iterations; - - // Maximum number of restarts of the line search direction algorithm before - // terminating the optimization. Restarts of the line search direction - // algorithm occur when the current algorithm fails to produce a new descent - // direction. This typically indicates a numerical failure, or a breakdown - // in the validity of the approximations used. - int max_num_line_search_direction_restarts; - - // The strong Wolfe conditions consist of the Armijo sufficient - // decrease condition, and an additional requirement that the - // step-size be chosen s.t. the _magnitude_ ('strong' Wolfe - // conditions) of the gradient along the search direction - // decreases sufficiently. Precisely, this second condition - // is that we seek a step_size s.t. - // - // |f'(step_size)| <= sufficient_curvature_decrease * |f'(0)| - // - // Where f() is the line search objective and f'() is the derivative - // of f w.r.t step_size (d f / d step_size). - double line_search_sufficient_curvature_decrease; - - // During the bracketing phase of the Wolfe search, the step size is - // increased until either a point satisfying the Wolfe conditions is - // found, or an upper bound for a bracket containing a point satisfying - // the conditions is found. Precisely, at each iteration of the - // expansion: - // - // new_step_size <= max_step_expansion * step_size. - // - // By definition for expansion, max_step_expansion > 1.0. - double max_line_search_step_expansion; - - TrustRegionStrategyType trust_region_strategy_type; - - // Type of dogleg strategy to use. - DoglegType dogleg_type; - - // The classical trust region methods are descent methods, in that - // they only accept a point if it strictly reduces the value of - // the objective function. - // - // Relaxing this requirement allows the algorithm to be more - // efficient in the long term at the cost of some local increase - // in the value of the objective function. - // - // This is because allowing for non-decreasing objective function - // values in a princpled manner allows the algorithm to "jump over - // boulders" as the method is not restricted to move into narrow - // valleys while preserving its convergence properties. - // - // Setting use_nonmonotonic_steps to true enables the - // non-monotonic trust region algorithm as described by Conn, - // Gould & Toint in "Trust Region Methods", Section 10.1. - // - // The parameter max_consecutive_nonmonotonic_steps controls the - // window size used by the step selection algorithm to accept - // non-monotonic steps. - // - // Even though the value of the objective function may be larger - // than the minimum value encountered over the course of the - // optimization, the final parameters returned to the user are the - // ones corresponding to the minimum cost over all iterations. - bool use_nonmonotonic_steps; - int max_consecutive_nonmonotonic_steps; - - // Maximum number of iterations for the minimizer to run for. - int max_num_iterations; - - // Maximum time for which the minimizer should run for. - double max_solver_time_in_seconds; - - // Number of threads used by Ceres for evaluating the cost and - // jacobians. - int num_threads; - - // Trust region minimizer settings. - double initial_trust_region_radius; - double max_trust_region_radius; - - // Minimizer terminates when the trust region radius becomes - // smaller than this value. - double min_trust_region_radius; - - // Lower bound for the relative decrease before a step is - // accepted. - double min_relative_decrease; - - // For the Levenberg-Marquadt algorithm, the scaled diagonal of - // the normal equations J'J is used to control the size of the - // trust region. Extremely small and large values along the - // diagonal can make this regularization scheme - // fail. max_lm_diagonal and min_lm_diagonal, clamp the values of - // diag(J'J) from above and below. In the normal course of - // operation, the user should not have to modify these parameters. - double min_lm_diagonal; - double max_lm_diagonal; - - // Sometimes due to numerical conditioning problems or linear - // solver flakiness, the trust region strategy may return a - // numerically invalid step that can be fixed by reducing the - // trust region size. So the TrustRegionMinimizer allows for a few - // successive invalid steps before it declares NUMERICAL_FAILURE. - int max_num_consecutive_invalid_steps; - - // Minimizer terminates when - // - // (new_cost - old_cost) < function_tolerance * old_cost; - // - double function_tolerance; - - // Minimizer terminates when - // - // max_i |x - Project(Plus(x, -g(x))| < gradient_tolerance - // - // This value should typically be 1e-4 * function_tolerance. - double gradient_tolerance; - - // Minimizer terminates when - // - // |step|_2 <= parameter_tolerance * ( |x|_2 + parameter_tolerance) - // - double parameter_tolerance; - - // Linear least squares solver options ------------------------------------- - - LinearSolverType linear_solver_type; - - // Type of preconditioner to use with the iterative linear solvers. - PreconditionerType preconditioner_type; - - // Type of clustering algorithm to use for visibility based - // preconditioning. This option is used only when the - // preconditioner_type is CLUSTER_JACOBI or CLUSTER_TRIDIAGONAL. - VisibilityClusteringType visibility_clustering_type; - - // Ceres supports using multiple dense linear algebra libraries - // for dense matrix factorizations. Currently EIGEN and LAPACK are - // the valid choices. EIGEN is always available, LAPACK refers to - // the system BLAS + LAPACK library which may or may not be - // available. - // - // This setting affects the DENSE_QR, DENSE_NORMAL_CHOLESKY and - // DENSE_SCHUR solvers. For small to moderate sized probem EIGEN - // is a fine choice but for large problems, an optimized LAPACK + - // BLAS implementation can make a substantial difference in - // performance. - DenseLinearAlgebraLibraryType dense_linear_algebra_library_type; - - // Ceres supports using multiple sparse linear algebra libraries - // for sparse matrix ordering and factorizations. Currently, - // SUITE_SPARSE and CX_SPARSE are the valid choices, depending on - // whether they are linked into Ceres at build time. - SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type; - - // Number of threads used by Ceres to solve the Newton - // step. Currently only the SPARSE_SCHUR solver is capable of - // using this setting. - int num_linear_solver_threads; - - // The order in which variables are eliminated in a linear solver - // can have a significant of impact on the efficiency and accuracy - // of the method. e.g., when doing sparse Cholesky factorization, - // there are matrices for which a good ordering will give a - // Cholesky factor with O(n) storage, where as a bad ordering will - // result in an completely dense factor. - // - // Ceres allows the user to provide varying amounts of hints to - // the solver about the variable elimination ordering to use. This - // can range from no hints, where the solver is free to decide the - // best possible ordering based on the user's choices like the - // linear solver being used, to an exact order in which the - // variables should be eliminated, and a variety of possibilities - // in between. - // - // Instances of the ParameterBlockOrdering class are used to - // communicate this information to Ceres. - // - // Formally an ordering is an ordered partitioning of the - // parameter blocks, i.e, each parameter block belongs to exactly - // one group, and each group has a unique non-negative integer - // associated with it, that determines its order in the set of - // groups. - // - // Given such an ordering, Ceres ensures that the parameter blocks in - // the lowest numbered group are eliminated first, and then the - // parmeter blocks in the next lowest numbered group and so on. Within - // each group, Ceres is free to order the parameter blocks as it - // chooses. - // - // If NULL, then all parameter blocks are assumed to be in the - // same group and the solver is free to decide the best - // ordering. - // - // e.g. Consider the linear system - // - // x + y = 3 - // 2x + 3y = 7 - // - // There are two ways in which it can be solved. First eliminating x - // from the two equations, solving for y and then back substituting - // for x, or first eliminating y, solving for x and back substituting - // for y. The user can construct three orderings here. - // - // {0: x}, {1: y} - eliminate x first. - // {0: y}, {1: x} - eliminate y first. - // {0: x, y} - Solver gets to decide the elimination order. - // - // Thus, to have Ceres determine the ordering automatically using - // heuristics, put all the variables in group 0 and to control the - // ordering for every variable, create groups 0..N-1, one per - // variable, in the desired order. - // - // Bundle Adjustment - // ----------------- - // - // A particular case of interest is bundle adjustment, where the user - // has two options. The default is to not specify an ordering at all, - // the solver will see that the user wants to use a Schur type solver - // and figure out the right elimination ordering. - // - // But if the user already knows what parameter blocks are points and - // what are cameras, they can save preprocessing time by partitioning - // the parameter blocks into two groups, one for the points and one - // for the cameras, where the group containing the points has an id - // smaller than the group containing cameras. - shared_ptr<ParameterBlockOrdering> linear_solver_ordering; - - // Use an explicitly computed Schur complement matrix with - // ITERATIVE_SCHUR. - // - // By default this option is disabled and ITERATIVE_SCHUR - // evaluates evaluates matrix-vector products between the Schur - // complement and a vector implicitly by exploiting the algebraic - // expression for the Schur complement. - // - // The 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. - // - // Enabling this option tells ITERATIVE_SCHUR to use an explicitly - // computed Schur complement. - // - // NOTE: This option can only be used with the SCHUR_JACOBI - // preconditioner. - bool use_explicit_schur_complement; - - // Sparse Cholesky factorization algorithms use a fill-reducing - // ordering to permute the columns of the Jacobian matrix. There - // are two ways of doing this. - - // 1. Compute the Jacobian matrix in some order and then have the - // factorization algorithm permute the columns of the Jacobian. - - // 2. Compute the Jacobian with its columns already permuted. - - // The first option incurs a significant memory penalty. The - // factorization algorithm has to make a copy of the permuted - // Jacobian matrix, thus Ceres pre-permutes the columns of the - // Jacobian matrix and generally speaking, there is no performance - // penalty for doing so. - - // In some rare cases, it is worth using a more complicated - // reordering algorithm which has slightly better runtime - // performance at the expense of an extra copy of the Jacobian - // matrix. Setting use_postordering to true enables this tradeoff. - bool use_postordering; - - // Some non-linear least squares problems are symbolically dense but - // numerically sparse. i.e. at any given state only a small number - // of jacobian entries are non-zero, but the position and number of - // non-zeros is different depending on the state. For these problems - // it can be useful to factorize the sparse jacobian at each solver - // iteration instead of including all of the zero entries in a single - // general factorization. - // - // If your problem does not have this property (or you do not know), - // then it is probably best to keep this false, otherwise it will - // likely lead to worse performance. - - // This settings affects the SPARSE_NORMAL_CHOLESKY solver. - bool dynamic_sparsity; - - // Some non-linear least squares problems have additional - // structure in the way the parameter blocks interact that it is - // beneficial to modify the way the trust region step is computed. - // - // e.g., consider the following regression problem - // - // y = a_1 exp(b_1 x) + a_2 exp(b_3 x^2 + c_1) - // - // Given a set of pairs{(x_i, y_i)}, the user wishes to estimate - // a_1, a_2, b_1, b_2, and c_1. - // - // Notice here that the expression on the left is linear in a_1 - // and a_2, and given any value for b_1, b_2 and c_1, it is - // possible to use linear regression to estimate the optimal - // values of a_1 and a_2. Indeed, its possible to analytically - // eliminate the variables a_1 and a_2 from the problem all - // together. Problems like these are known as separable least - // squares problem and the most famous algorithm for solving them - // is the Variable Projection algorithm invented by Golub & - // Pereyra. - // - // Similar structure can be found in the matrix factorization with - // missing data problem. There the corresponding algorithm is - // known as Wiberg's algorithm. - // - // Ruhe & Wedin (Algorithms for Separable Nonlinear Least Squares - // Problems, SIAM Reviews, 22(3), 1980) present an analyis of - // various algorithms for solving separable non-linear least - // squares problems and refer to "Variable Projection" as - // Algorithm I in their paper. - // - // Implementing Variable Projection is tedious and expensive, and - // they present a simpler algorithm, which they refer to as - // Algorithm II, where once the Newton/Trust Region step has been - // computed for the whole problem (a_1, a_2, b_1, b_2, c_1) and - // additional optimization step is performed to estimate a_1 and - // a_2 exactly. - // - // This idea can be generalized to cases where the residual is not - // linear in a_1 and a_2, i.e., Solve for the trust region step - // for the full problem, and then use it as the starting point to - // further optimize just a_1 and a_2. For the linear case, this - // amounts to doing a single linear least squares solve. For - // non-linear problems, any method for solving the a_1 and a_2 - // optimization problems will do. The only constraint on a_1 and - // a_2 is that they do not co-occur in any residual block. - // - // This idea can be further generalized, by not just optimizing - // (a_1, a_2), but decomposing the graph corresponding to the - // Hessian matrix's sparsity structure in a collection of - // non-overlapping independent sets and optimizing each of them. - // - // Setting "use_inner_iterations" to true enables the use of this - // non-linear generalization of Ruhe & Wedin's Algorithm II. This - // version of Ceres has a higher iteration complexity, but also - // displays better convergence behaviour per iteration. Setting - // Solver::Options::num_threads to the maximum number possible is - // highly recommended. - bool use_inner_iterations; - - // If inner_iterations is true, then the user has two choices. - // - // 1. Let the solver heuristically decide which parameter blocks - // to optimize in each inner iteration. To do this leave - // Solver::Options::inner_iteration_ordering untouched. - // - // 2. Specify a collection of of ordered independent sets. Where - // the lower numbered groups are optimized before the higher - // number groups. Each group must be an independent set. Not - // all parameter blocks need to be present in the ordering. - shared_ptr<ParameterBlockOrdering> inner_iteration_ordering; - - // Generally speaking, inner iterations make significant progress - // in the early stages of the solve and then their contribution - // drops down sharply, at which point the time spent doing inner - // iterations is not worth it. - // - // Once the relative decrease in the objective function due to - // inner iterations drops below inner_iteration_tolerance, the use - // of inner iterations in subsequent trust region minimizer - // iterations is disabled. - double inner_iteration_tolerance; - - // Minimum number of iterations for which the linear solver should - // run, even if the convergence criterion is satisfied. - int min_linear_solver_iterations; - - // Maximum number of iterations for which the linear solver should - // run. If the solver does not converge in less than - // max_linear_solver_iterations, then it returns MAX_ITERATIONS, - // as its termination type. - int max_linear_solver_iterations; - - // Forcing sequence parameter. The truncated Newton solver uses - // this number to control the relative accuracy with which the - // Newton step is computed. - // - // This constant is passed to ConjugateGradientsSolver which uses - // it to terminate the iterations when - // - // (Q_i - Q_{i-1})/Q_i < eta/i - double eta; - - // Normalize the jacobian using Jacobi scaling before calling - // the linear least squares solver. - bool jacobi_scaling; - - // Logging options --------------------------------------------------------- - - LoggingType logging_type; - - // By default the Minimizer progress is logged to VLOG(1), which - // is sent to STDERR depending on the vlog level. If this flag is - // set to true, and logging_type is not SILENT, the logging output - // is sent to STDOUT. - bool minimizer_progress_to_stdout; - - // 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; - - // 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; - DumpFormatType trust_region_problem_dump_format_type; - - // Finite differences options ---------------------------------------------- - - // Check all jacobians computed by each residual block with finite - // differences. This is expensive since it involves computing the - // derivative by normal means (e.g. user specified, autodiff, - // etc), then also computing it using finite differences. The - // results are compared, and if they differ substantially, details - // are printed to the log. - bool check_gradients; - - // Relative precision to check for in the gradient checker. If the - // relative difference between an element in a jacobian exceeds - // this number, then the jacobian for that cost term is dumped. - double gradient_check_relative_precision; - - // Relative shift used for taking numeric derivatives. For finite - // differencing, each dimension is evaluated at slightly shifted - // values; for the case of central difference, this is what gets - // evaluated: - // - // delta = numeric_derivative_relative_step_size; - // f_initial = f(x) - // f_forward = f((1 + delta) * x) - // f_backward = f((1 - delta) * x) - // - // The finite differencing is done along each dimension. The - // reason to use a relative (rather than absolute) step size is - // that this way, numeric differentation works for functions where - // the arguments are typically large (e.g. 1e9) and when the - // values are small (e.g. 1e-5). It is possible to construct - // "torture cases" which break this finite difference heuristic, - // but they do not come up often in practice. - // - // TODO(keir): Pick a smarter number than the default above! In - // theory a good choice is sqrt(eps) * x, which for doubles means - // about 1e-8 * x. However, I have found this number too - // optimistic. This number should be exposed for users to change. - double numeric_derivative_relative_step_size; - - // If true, the user's parameter blocks are updated at the end of - // every Minimizer iteration, otherwise they are updated when the - // Minimizer terminates. This is useful if, for example, the user - // wishes to visualize the state of the optimization every - // iteration. - bool update_state_every_iteration; - - // Callbacks that are executed at the end of each iteration of the - // Minimizer. An iteration may terminate midway, either due to - // numerical failures or because one of the convergence tests has - // been satisfied. In this case none of the callbacks are - // executed. - - // Callbacks are executed in the order that they are specified in - // this vector. By default, parameter blocks are updated only at - // the end of the optimization, i.e when the Minimizer - // terminates. This behaviour is controlled by - // update_state_every_variable. If the user wishes to have access - // to the update parameter blocks when his/her callbacks are - // executed, then set update_state_every_iteration to true. - // - // The solver does NOT take ownership of these pointers. - vector<IterationCallback*> callbacks; - }; - - struct CERES_EXPORT Summary { - Summary(); - - // A brief one line description of the state of the solver after - // termination. - string BriefReport() const; - - // A full multiline description of the state of the solver after - // termination. - string FullReport() const; - - bool IsSolutionUsable() const; - - // Minimizer summary ------------------------------------------------- - MinimizerType minimizer_type; - - TerminationType termination_type; - - // Reason why the solver terminated. - string message; - - // Cost of the problem (value of the objective function) before - // the optimization. - double initial_cost; - - // Cost of the problem (value of the objective function) after the - // optimization. - double final_cost; - - // The part of the total cost that comes from residual blocks that - // were held fixed by the preprocessor because all the parameter - // blocks that they depend on were fixed. - double fixed_cost; - - // IterationSummary for each minimizer iteration in order. - vector<IterationSummary> iterations; - - // Number of minimizer iterations in which the step was - // accepted. Unless use_non_monotonic_steps is true this is also - // the number of steps in which the objective function value/cost - // went down. - int num_successful_steps; - - // Number of minimizer iterations in which the step was rejected - // either because it did not reduce the cost enough or the step - // was not numerically valid. - int num_unsuccessful_steps; - - // Number of times inner iterations were performed. - int num_inner_iteration_steps; - - // All times reported below are wall times. - - // When the user calls Solve, before the actual optimization - // occurs, Ceres performs a number of preprocessing steps. These - // include error checks, memory allocations, and reorderings. This - // time is accounted for as preprocessing time. - double preprocessor_time_in_seconds; - - // Time spent in the TrustRegionMinimizer. - double minimizer_time_in_seconds; - - // After the Minimizer is finished, some time is spent in - // re-evaluating residuals etc. This time is accounted for in the - // postprocessor time. - double postprocessor_time_in_seconds; - - // Some total of all time spent inside Ceres when Solve is called. - double total_time_in_seconds; - - // Time (in seconds) spent in the linear solver computing the - // trust region step. - double linear_solver_time_in_seconds; - - // Time (in seconds) spent evaluating the residual vector. - double residual_evaluation_time_in_seconds; - - // Time (in seconds) spent evaluating the jacobian matrix. - double jacobian_evaluation_time_in_seconds; - - // Time (in seconds) spent doing inner iterations. - double inner_iteration_time_in_seconds; - - // Number of parameter blocks in the problem. - int num_parameter_blocks; - - // Number of parameters in the probem. - int num_parameters; - - // Dimension of the tangent space of the problem (or the number of - // columns in the Jacobian for the problem). This is different - // from num_parameters if a parameter block is associated with a - // LocalParameterization - int num_effective_parameters; - - // Number of residual blocks in the problem. - int num_residual_blocks; - - // Number of residuals in the problem. - int num_residuals; - - // Number of parameter blocks in the problem after the inactive - // and constant parameter blocks have been removed. A parameter - // block is inactive if no residual block refers to it. - int num_parameter_blocks_reduced; - - // Number of parameters in the reduced problem. - int num_parameters_reduced; - - // Dimension of the tangent space of the reduced problem (or the - // number of columns in the Jacobian for the reduced - // problem). This is different from num_parameters_reduced if a - // parameter block in the reduced problem is associated with a - // LocalParameterization. - int num_effective_parameters_reduced; - - // Number of residual blocks in the reduced problem. - int num_residual_blocks_reduced; - - // Number of residuals in the reduced problem. - int num_residuals_reduced; - - // Number of threads specified by the user for Jacobian and - // residual evaluation. - int num_threads_given; - - // Number of threads actually used by the solver for Jacobian and - // residual evaluation. This number is not equal to - // num_threads_given if OpenMP is not available. - int num_threads_used; - - // Number of threads specified by the user for solving the trust - // region problem. - int num_linear_solver_threads_given; - - // Number of threads actually used by the solver for solving the - // trust region problem. This number is not equal to - // num_threads_given if OpenMP is not available. - int num_linear_solver_threads_used; - - // Type of the linear solver requested by the user. - LinearSolverType linear_solver_type_given; - - // Type of the linear solver actually used. This may be different - // from linear_solver_type_given if Ceres determines that the - // problem structure is not compatible with the linear solver - // requested or if the linear solver requested by the user is not - // available, e.g. The user requested SPARSE_NORMAL_CHOLESKY but - // no sparse linear algebra library was available. - LinearSolverType linear_solver_type_used; - - // Size of the elimination groups given by the user as hints to - // the linear solver. - 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 - // linear_solver_ordering_given if the user left - // 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; - - // True if the user asked for inner iterations to be used as part - // of the optimization. - bool inner_iterations_given; - - // True if the user asked for inner iterations to be used as part - // of the optimization and the problem structure was such that - // they were actually performed. e.g., in a problem with just one - // parameter block, inner iterations are not performed. - bool inner_iterations_used; - - // Size of the parameter groups given by the user for performing - // inner iterations. - vector<int> inner_iteration_ordering_given; - - // Size of the parameter groups given used by the solver for - // performing inner iterations. This maybe different from - // inner_iteration_ordering_given if the user left - // 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; - - // Type of the preconditioner requested by the user. - PreconditionerType preconditioner_type_given; - - // Type of the preconditioner actually used. This may be different - // from linear_solver_type_given if Ceres determines that the - // problem structure is not compatible with the linear solver - // requested or if the linear solver requested by the user is not - // available. - PreconditionerType preconditioner_type_used; - - // Type of clustering algorithm used for visibility based - // preconditioning. Only meaningful when the preconditioner_type - // is CLUSTER_JACOBI or CLUSTER_TRIDIAGONAL. - VisibilityClusteringType visibility_clustering_type; - - // Type of trust region strategy. - TrustRegionStrategyType trust_region_strategy_type; - - // Type of dogleg strategy used for solving the trust region - // problem. - DoglegType dogleg_type; - - // Type of the dense linear algebra library used. - DenseLinearAlgebraLibraryType dense_linear_algebra_library_type; - - // Type of the sparse linear algebra library used. - SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type; - - // Type of line search direction used. - LineSearchDirectionType line_search_direction_type; - - // Type of the line search algorithm used. - LineSearchType line_search_type; - - // When performing line search, the degree of the polynomial used - // to approximate the objective function. - LineSearchInterpolationType line_search_interpolation_type; - - // If the line search direction is NONLINEAR_CONJUGATE_GRADIENT, - // then this indicates the particular variant of non-linear - // conjugate gradient used. - NonlinearConjugateGradientType nonlinear_conjugate_gradient_type; - - // If the type of the line search direction is LBFGS, then this - // indicates the rank of the Hessian approximation. - int max_lbfgs_rank; - }; - - // Once a least squares problem has been built, this function takes - // the problem and optimizes it based on the values of the options - // parameters. Upon return, a detailed summary of the work performed - // by the preprocessor, the non-linear minmizer and the linear - // solver are reported in the summary object. - virtual void Solve(const Options& options, - Problem* problem, - Solver::Summary* summary); -}; - -// Helper function which avoids going through the interface. -CERES_EXPORT void Solve(const Solver::Options& options, - Problem* problem, - Solver::Summary* summary); - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_SOLVER_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/types.h b/extern/libmv/third_party/ceres/include/ceres/types.h deleted file mode 100644 index a07c8933e64..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/types.h +++ /dev/null @@ -1,487 +0,0 @@ -// 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/ -// -// 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) -// -// Enums and other top level class definitions. -// -// Note: internal/types.cc defines stringification routines for some -// of these enums. Please update those routines if you extend or -// remove enums from here. - -#ifndef CERES_PUBLIC_TYPES_H_ -#define CERES_PUBLIC_TYPES_H_ - -#include <string> - -#include "ceres/internal/port.h" -#include "ceres/internal/disable_warnings.h" - -namespace ceres { - -// Basic integer types. These typedefs are in the Ceres namespace to avoid -// conflicts with other packages having similar typedefs. -typedef int int32; - -// Argument type used in interfaces that can optionally take ownership -// of a passed in argument. If TAKE_OWNERSHIP is passed, the called -// object takes ownership of the pointer argument, and will call -// delete on it upon completion. -enum Ownership { - DO_NOT_TAKE_OWNERSHIP, - TAKE_OWNERSHIP -}; - -// TODO(keir): Considerably expand the explanations of each solver type. -enum LinearSolverType { - // These solvers are for general rectangular systems formed from the - // normal equations A'A x = A'b. They are direct solvers and do not - // assume any special problem structure. - - // Solve the normal equations using a dense Cholesky solver; based - // on Eigen. - DENSE_NORMAL_CHOLESKY, - - // Solve the normal equations using a dense QR solver; based on - // Eigen. - DENSE_QR, - - // Solve the normal equations using a sparse cholesky solver; requires - // SuiteSparse or CXSparse. - SPARSE_NORMAL_CHOLESKY, - - // Specialized solvers, specific to problems with a generalized - // bi-partitite structure. - - // Solves the reduced linear system using a dense Cholesky solver; - // based on Eigen. - DENSE_SCHUR, - - // Solves the reduced linear system using a sparse Cholesky solver; - // based on CHOLMOD. - SPARSE_SCHUR, - - // Solves the reduced linear system using Conjugate Gradients, based - // on a new Ceres implementation. Suitable for large scale - // problems. - ITERATIVE_SCHUR, - - // Conjugate gradients on the normal equations. - CGNR -}; - -enum PreconditionerType { - // Trivial preconditioner - the identity matrix. - IDENTITY, - - // Block diagonal of the Gauss-Newton Hessian. - JACOBI, - - // Note: The following three preconditioners can only be used with - // the ITERATIVE_SCHUR solver. They are well suited for Structure - // from Motion problems. - - // Block diagonal of the Schur complement. This preconditioner may - // only be used with the ITERATIVE_SCHUR solver. - SCHUR_JACOBI, - - // Visibility clustering based preconditioners. - // - // The following two preconditioners use the visibility structure of - // the scene to determine the sparsity structure of the - // preconditioner. This is done using a clustering algorithm. The - // available visibility clustering algorithms are described below. - // - // Note: Requires SuiteSparse. - CLUSTER_JACOBI, - CLUSTER_TRIDIAGONAL -}; - -enum VisibilityClusteringType { - // Canonical views algorithm as described in - // - // "Scene Summarization for Online Image Collections", Ian Simon, Noah - // Snavely, Steven M. Seitz, ICCV 2007. - // - // This clustering algorithm can be quite slow, but gives high - // quality clusters. The original visibility based clustering paper - // used this algorithm. - CANONICAL_VIEWS, - - // The classic single linkage algorithm. It is extremely fast as - // compared to CANONICAL_VIEWS, but can give slightly poorer - // results. For problems with large number of cameras though, this - // is generally a pretty good option. - // - // If you are using SCHUR_JACOBI preconditioner and have SuiteSparse - // available, CLUSTER_JACOBI and CLUSTER_TRIDIAGONAL in combination - // with the SINGLE_LINKAGE algorithm will generally give better - // results. - SINGLE_LINKAGE -}; - -enum SparseLinearAlgebraLibraryType { - // High performance sparse Cholesky factorization and approximate - // minimum degree ordering. - SUITE_SPARSE, - - // A lightweight replacment for SuiteSparse, which does not require - // a LAPACK/BLAS implementation. Consequently, its performance is - // also a bit lower than SuiteSparse. - CX_SPARSE, - - // Eigen's sparse linear algebra routines. In particular Ceres uses - // the Simplicial LDLT routines. - EIGEN_SPARSE -}; - -enum DenseLinearAlgebraLibraryType { - EIGEN, - LAPACK -}; - -// Logging options -// The options get progressively noisier. -enum LoggingType { - SILENT, - PER_MINIMIZER_ITERATION -}; - -enum MinimizerType { - LINE_SEARCH, - TRUST_REGION -}; - -enum LineSearchDirectionType { - // Negative of the gradient. - STEEPEST_DESCENT, - - // A generalization of the Conjugate Gradient method to non-linear - // functions. The generalization can be performed in a number of - // different ways, resulting in a variety of search directions. The - // precise choice of the non-linear conjugate gradient algorithm - // used is determined by NonlinerConjuateGradientType. - NONLINEAR_CONJUGATE_GRADIENT, - - // BFGS, and it's limited memory approximation L-BFGS, are quasi-Newton - // algorithms that approximate the Hessian matrix by iteratively refining - // an initial estimate with rank-one updates using the gradient at each - // iteration. They are a generalisation of the Secant method and satisfy - // the Secant equation. The Secant equation has an infinium of solutions - // in multiple dimensions, as there are N*(N+1)/2 degrees of freedom in a - // symmetric matrix but only N conditions are specified by the Secant - // equation. The requirement that the Hessian approximation be positive - // definite imposes another N additional constraints, but that still leaves - // remaining degrees-of-freedom. (L)BFGS methods uniquely deteremine the - // approximate Hessian by imposing the additional constraints that the - // approximation at the next iteration must be the 'closest' to the current - // approximation (the nature of how this proximity is measured is actually - // the defining difference between a family of quasi-Newton methods including - // (L)BFGS & DFP). (L)BFGS is currently regarded as being the best known - // general quasi-Newton method. - // - // The principal difference between BFGS and L-BFGS is that whilst BFGS - // maintains a full, dense approximation to the (inverse) Hessian, L-BFGS - // maintains only a window of the last M observations of the parameters and - // gradients. Using this observation history, the calculation of the next - // search direction can be computed without requiring the construction of the - // full dense inverse Hessian approximation. This is particularly important - // for problems with a large number of parameters, where storage of an N-by-N - // matrix in memory would be prohibitive. - // - // For more details on BFGS see: - // - // Broyden, C.G., "The Convergence of a Class of Double-rank Minimization - // Algorithms,"; J. Inst. Maths. Applics., Vol. 6, pp 76–90, 1970. - // - // Fletcher, R., "A New Approach to Variable Metric Algorithms," - // Computer Journal, Vol. 13, pp 317–322, 1970. - // - // Goldfarb, D., "A Family of Variable Metric Updates Derived by Variational - // Means," Mathematics of Computing, Vol. 24, pp 23–26, 1970. - // - // Shanno, D.F., "Conditioning of Quasi-Newton Methods for Function - // Minimization," Mathematics of Computing, Vol. 24, pp 647–656, 1970. - // - // For more details on L-BFGS see: - // - // Nocedal, J. (1980). "Updating Quasi-Newton Matrices with Limited - // Storage". Mathematics of Computation 35 (151): 773–782. - // - // Byrd, R. H.; Nocedal, J.; Schnabel, R. B. (1994). - // "Representations of Quasi-Newton Matrices and their use in - // Limited Memory Methods". Mathematical Programming 63 (4): - // 129–156. - // - // A general reference for both methods: - // - // Nocedal J., Wright S., Numerical Optimization, 2nd Ed. Springer, 1999. - LBFGS, - BFGS, -}; - -// Nonliner conjugate gradient methods are a generalization of the -// method of Conjugate Gradients for linear systems. The -// generalization can be carried out in a number of different ways -// leading to number of different rules for computing the search -// direction. Ceres provides a number of different variants. For more -// details see Numerical Optimization by Nocedal & Wright. -enum NonlinearConjugateGradientType { - FLETCHER_REEVES, - POLAK_RIBIERE, - HESTENES_STIEFEL, -}; - -enum LineSearchType { - // Backtracking line search with polynomial interpolation or - // bisection. - ARMIJO, - WOLFE, -}; - -// Ceres supports different strategies for computing the trust region -// step. -enum TrustRegionStrategyType { - // The default trust region strategy is to use the step computation - // used in the Levenberg-Marquardt algorithm. For more details see - // levenberg_marquardt_strategy.h - LEVENBERG_MARQUARDT, - - // Powell's dogleg algorithm interpolates between the Cauchy point - // and the Gauss-Newton step. It is particularly useful if the - // LEVENBERG_MARQUARDT algorithm is making a large number of - // unsuccessful steps. For more details see dogleg_strategy.h. - // - // NOTES: - // - // 1. This strategy has not been experimented with or tested as - // extensively as LEVENBERG_MARQUARDT, and therefore it should be - // considered EXPERIMENTAL for now. - // - // 2. For now this strategy should only be used with exact - // factorization based linear solvers, i.e., SPARSE_SCHUR, - // DENSE_SCHUR, DENSE_QR and SPARSE_NORMAL_CHOLESKY. - DOGLEG -}; - -// Ceres supports two different dogleg strategies. -// The "traditional" dogleg method by Powell and the -// "subspace" method described in -// R. H. Byrd, R. B. Schnabel, and G. A. Shultz, -// "Approximate solution of the trust region problem by minimization -// over two-dimensional subspaces", Mathematical Programming, -// 40 (1988), pp. 247--263 -enum DoglegType { - // The traditional approach constructs a dogleg path - // consisting of two line segments and finds the furthest - // point on that path that is still inside the trust region. - TRADITIONAL_DOGLEG, - - // The subspace approach finds the exact minimum of the model - // constrained to the subspace spanned by the dogleg path. - SUBSPACE_DOGLEG -}; - -enum TerminationType { - // Minimizer terminated because one of the convergence criterion set - // by the user was satisfied. - // - // 1. (new_cost - old_cost) < function_tolerance * old_cost; - // 2. max_i |gradient_i| < gradient_tolerance - // 3. |step|_2 <= parameter_tolerance * ( |x|_2 + parameter_tolerance) - // - // The user's parameter blocks will be updated with the solution. - CONVERGENCE, - - // The solver ran for maximum number of iterations or maximum amount - // of time specified by the user, but none of the convergence - // criterion specified by the user were met. The user's parameter - // blocks will be updated with the solution found so far. - NO_CONVERGENCE, - - // The minimizer terminated because of an error. The user's - // parameter blocks will not be updated. - FAILURE, - - // Using an IterationCallback object, user code can control the - // minimizer. The following enums indicate that the user code was - // responsible for termination. - // - // Minimizer terminated successfully because a user - // IterationCallback returned SOLVER_TERMINATE_SUCCESSFULLY. - // - // The user's parameter blocks will be updated with the solution. - USER_SUCCESS, - - // Minimizer terminated because because a user IterationCallback - // returned SOLVER_ABORT. - // - // The user's parameter blocks will not be updated. - USER_FAILURE -}; - -// Enums used by the IterationCallback instances to indicate to the -// solver whether it should continue solving, the user detected an -// error or the solution is good enough and the solver should -// terminate. -enum CallbackReturnType { - // Continue solving to next iteration. - SOLVER_CONTINUE, - - // Terminate solver, and do not update the parameter blocks upon - // return. Unless the user has set - // Solver:Options:::update_state_every_iteration, in which case the - // state would have been updated every iteration - // anyways. Solver::Summary::termination_type is set to USER_ABORT. - SOLVER_ABORT, - - // Terminate solver, update state and - // return. Solver::Summary::termination_type is set to USER_SUCCESS. - SOLVER_TERMINATE_SUCCESSFULLY -}; - -// The format in which linear least squares problems should be logged -// when Solver::Options::lsqp_iterations_to_dump is non-empty. -enum DumpFormatType { - // Print the linear least squares problem in a human readable format - // to stderr. The Jacobian is printed as a dense matrix. The vectors - // D, x and f are printed as dense vectors. This should only be used - // for small problems. - CONSOLE, - - // Write out the linear least squares problem to the directory - // pointed to by Solver::Options::lsqp_dump_directory as text files - // which can be read into MATLAB/Octave. The Jacobian is dumped as a - // text file containing (i,j,s) triplets, the vectors D, x and f are - // dumped as text files containing a list of their values. - // - // A MATLAB/octave script called lm_iteration_???.m is also output, - // which can be used to parse and load the problem into memory. - TEXTFILE -}; - -// For SizedCostFunction and AutoDiffCostFunction, DYNAMIC can be -// specified for the number of residuals. If specified, then the -// number of residuas for that cost function can vary at runtime. -enum DimensionType { - DYNAMIC = -1 -}; - -enum NumericDiffMethod { - CENTRAL, - FORWARD -}; - -enum LineSearchInterpolationType { - BISECTION, - QUADRATIC, - CUBIC -}; - -enum CovarianceAlgorithmType { - DENSE_SVD, - SUITE_SPARSE_QR, - EIGEN_SPARSE_QR -}; - -CERES_EXPORT const char* LinearSolverTypeToString( - LinearSolverType type); -CERES_EXPORT bool StringToLinearSolverType(string value, - LinearSolverType* type); - -CERES_EXPORT const char* PreconditionerTypeToString(PreconditionerType type); -CERES_EXPORT bool StringToPreconditionerType(string value, - PreconditionerType* type); - -CERES_EXPORT const char* VisibilityClusteringTypeToString( - VisibilityClusteringType type); -CERES_EXPORT bool StringToVisibilityClusteringType(string value, - VisibilityClusteringType* type); - -CERES_EXPORT const char* SparseLinearAlgebraLibraryTypeToString( - SparseLinearAlgebraLibraryType type); -CERES_EXPORT bool StringToSparseLinearAlgebraLibraryType( - string value, - SparseLinearAlgebraLibraryType* type); - -CERES_EXPORT const char* DenseLinearAlgebraLibraryTypeToString( - DenseLinearAlgebraLibraryType type); -CERES_EXPORT bool StringToDenseLinearAlgebraLibraryType( - string value, - DenseLinearAlgebraLibraryType* type); - -CERES_EXPORT const char* TrustRegionStrategyTypeToString( - TrustRegionStrategyType type); -CERES_EXPORT bool StringToTrustRegionStrategyType(string value, - TrustRegionStrategyType* type); - -CERES_EXPORT const char* DoglegTypeToString(DoglegType type); -CERES_EXPORT bool StringToDoglegType(string value, DoglegType* type); - -CERES_EXPORT const char* MinimizerTypeToString(MinimizerType type); -CERES_EXPORT bool StringToMinimizerType(string value, MinimizerType* type); - -CERES_EXPORT const char* LineSearchDirectionTypeToString( - LineSearchDirectionType type); -CERES_EXPORT bool StringToLineSearchDirectionType(string value, - LineSearchDirectionType* type); - -CERES_EXPORT const char* LineSearchTypeToString(LineSearchType type); -CERES_EXPORT bool StringToLineSearchType(string value, LineSearchType* type); - -CERES_EXPORT const char* NonlinearConjugateGradientTypeToString( - NonlinearConjugateGradientType type); -CERES_EXPORT bool StringToNonlinearConjugateGradientType( - string value, - NonlinearConjugateGradientType* type); - -CERES_EXPORT const char* LineSearchInterpolationTypeToString( - LineSearchInterpolationType type); -CERES_EXPORT bool StringToLineSearchInterpolationType( - string value, - LineSearchInterpolationType* type); - -CERES_EXPORT const char* CovarianceAlgorithmTypeToString( - CovarianceAlgorithmType type); -CERES_EXPORT bool StringToCovarianceAlgorithmType( - string value, - CovarianceAlgorithmType* type); - -CERES_EXPORT const char* TerminationTypeToString(TerminationType type); - -CERES_EXPORT bool IsSchurType(LinearSolverType type); -CERES_EXPORT bool IsSparseLinearAlgebraLibraryTypeAvailable( - SparseLinearAlgebraLibraryType type); -CERES_EXPORT bool IsDenseLinearAlgebraLibraryTypeAvailable( - DenseLinearAlgebraLibraryType type); - -} // namespace ceres - -#include "ceres/internal/reenable_warnings.h" - -#endif // CERES_PUBLIC_TYPES_H_ diff --git a/extern/libmv/third_party/ceres/include/ceres/version.h b/extern/libmv/third_party/ceres/include/ceres/version.h deleted file mode 100644 index 370b08af73e..00000000000 --- a/extern/libmv/third_party/ceres/include/ceres/version.h +++ /dev/null @@ -1,49 +0,0 @@ -// Ceres Solver - A fast non-linear least squares minimizer -// Copyright 2014 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: mierle@gmail.com (Keir Mierle) - -#ifndef CERES_PUBLIC_VERSION_H_ -#define CERES_PUBLIC_VERSION_H_ - -#define CERES_VERSION_MAJOR 1 -#define CERES_VERSION_MINOR 10 -#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. -#define CERES_TO_STRING_HELPER(x) #x -#define CERES_TO_STRING(x) CERES_TO_STRING_HELPER(x) - -// The Ceres version as a string; for example "1.9.0". -#define CERES_VERSION_STRING CERES_TO_STRING(CERES_VERSION_MAJOR) "." \ - CERES_TO_STRING(CERES_VERSION_MINOR) "." \ - CERES_TO_STRING(CERES_VERSION_REVISION) - -#endif // CERES_PUBLIC_VERSION_H_ |