1 files changed, 30 insertions, 12 deletions

diff --git a/internal/ceres/dogleg_strategy.cc b/internal/ceres/dogleg_strategy.cc
index 668fa54..c85c8e5 100644
--- a/internal/ceres/dogleg_strategy.cc
+++ b/internal/ceres/dogleg_strategy.cc
@@ -34,8 +34,9 @@
 #include "Eigen/Dense"
 #include "ceres/array_utils.h"
 #include "ceres/internal/eigen.h"
+#include "ceres/linear_least_squares_problems.h"
 #include "ceres/linear_solver.h"
-#include "ceres/polynomial_solver.h"
+#include "ceres/polynomial.h"
 #include "ceres/sparse_matrix.h"
 #include "ceres/trust_region_strategy.h"
 #include "ceres/types.h"
@@ -52,8 +53,8 @@ DoglegStrategy::DoglegStrategy(const TrustRegionStrategy::Options& options)
     : linear_solver_(options.linear_solver),
       radius_(options.initial_radius),
       max_radius_(options.max_radius),
-      min_diagonal_(options.lm_min_diagonal),
-      max_diagonal_(options.lm_max_diagonal),
+      min_diagonal_(options.min_lm_diagonal),
+      max_diagonal_(options.max_lm_diagonal),
       mu_(kMinMu),
       min_mu_(kMinMu),
       max_mu_(kMaxMu),
@@ -87,7 +88,7 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
     // Gauss-Newton and gradient vectors are always available, only a
     // new interpolant need to be computed. For the subspace case,
     // the subspace and the two-dimensional model are also still valid.
-    switch(dogleg_type_) {
+    switch (dogleg_type_) {
       case TRADITIONAL_DOGLEG:
         ComputeTraditionalDoglegStep(step);
         break;
@@ -127,7 +128,7 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
   ComputeCauchyPoint(jacobian);
 
   LinearSolver::Summary linear_solver_summary =
-      ComputeGaussNewtonStep(jacobian, residuals);
+      ComputeGaussNewtonStep(per_solve_options, jacobian, residuals);
 
   TrustRegionStrategy::Summary summary;
   summary.residual_norm = linear_solver_summary.residual_norm;
@@ -135,7 +136,7 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
   summary.termination_type = linear_solver_summary.termination_type;
 
   if (linear_solver_summary.termination_type != FAILURE) {
-    switch(dogleg_type_) {
+    switch (dogleg_type_) {
       // Interpolate the Cauchy point and the Gauss-Newton step.
       case TRADITIONAL_DOGLEG:
         ComputeTraditionalDoglegStep(step);
@@ -415,15 +416,15 @@ Vector DoglegStrategy::MakePolynomialForBoundaryConstrainedProblem() const {
   const double trB = subspace_B_.trace();
   const double r2 = radius_ * radius_;
   Matrix2d B_adj;
-  B_adj <<  subspace_B_(1,1) , -subspace_B_(0,1),
-            -subspace_B_(1,0) ,  subspace_B_(0,0);
+  B_adj <<  subspace_B_(1, 1) , -subspace_B_(0, 1),
+            -subspace_B_(1, 0) ,  subspace_B_(0, 0);
 
   Vector polynomial(5);
   polynomial(0) = r2;
   polynomial(1) = 2.0 * r2 * trB;
-  polynomial(2) = r2 * ( trB * trB + 2.0 * detB ) - subspace_g_.squaredNorm();
-  polynomial(3) = -2.0 * ( subspace_g_.transpose() * B_adj * subspace_g_
-      - r2 * detB * trB );
+  polynomial(2) = r2 * (trB * trB + 2.0 * detB) - subspace_g_.squaredNorm();
+  polynomial(3) = -2.0 * (subspace_g_.transpose() * B_adj * subspace_g_
+      - r2 * detB * trB);
   polynomial(4) = r2 * detB * detB - (B_adj * subspace_g_).squaredNorm();
 
   return polynomial;
@@ -507,6 +508,7 @@ bool DoglegStrategy::FindMinimumOnTrustRegionBoundary(Vector2d* minimum) const {
 }
 
 LinearSolver::Summary DoglegStrategy::ComputeGaussNewtonStep(
+    const PerSolveOptions& per_solve_options,
     SparseMatrix* jacobian,
     const double* residuals) {
   const int n = jacobian->num_cols();
@@ -561,6 +563,22 @@ LinearSolver::Summary DoglegStrategy::ComputeGaussNewtonStep(
                                                   solve_options,
                                                   gauss_newton_step_.data());
 
+    if (per_solve_options.dump_format_type == CONSOLE ||
+        (per_solve_options.dump_format_type != CONSOLE &&
+         !per_solve_options.dump_filename_base.empty())) {
+      if (!DumpLinearLeastSquaresProblem(per_solve_options.dump_filename_base,
+                                         per_solve_options.dump_format_type,
+                                         jacobian,
+                                         solve_options.D,
+                                         residuals,
+                                         gauss_newton_step_.data(),
+                                         0)) {
+        LOG(ERROR) << "Unable to dump trust region problem."
+                   << " Filename base: "
+                   << per_solve_options.dump_filename_base;
+      }
+    }
+
     if (linear_solver_summary.termination_type == FAILURE ||
         !IsArrayValid(n, gauss_newton_step_.data())) {
       mu_ *= mu_increase_factor_;
@@ -598,7 +616,7 @@ void DoglegStrategy::StepAccepted(double step_quality) {
   // Reduce the regularization multiplier, in the hope that whatever
   // was causing the rank deficiency has gone away and we can return
   // to doing a pure Gauss-Newton solve.
-  mu_ = max(min_mu_, 2.0 * mu_ / mu_increase_factor_ );
+  mu_ = max(min_mu_, 2.0 * mu_ / mu_increase_factor_);
   reuse_ = false;
 }