← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to extern/libmv/third_party/ceres/internal/ceres/minimizer.h

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/libmv/third_party/ceres/internal/ceres/minimizer.h
 
1
// Ceres Solver - A fast non-linear least squares minimizer
 
2
// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
 
3
// http://code.google.com/p/ceres-solver/
 
4
//
 
5
// Redistribution and use in source and binary forms, with or without
 
6
// modification, are permitted provided that the following conditions are met:
 
7
//
 
8
// * Redistributions of source code must retain the above copyright notice,
 
9
//   this list of conditions and the following disclaimer.
 
10
// * Redistributions in binary form must reproduce the above copyright notice,
 
11
//   this list of conditions and the following disclaimer in the documentation
 
12
//   and/or other materials provided with the distribution.
 
13
// * Neither the name of Google Inc. nor the names of its contributors may be
 
14
//   used to endorse or promote products derived from this software without
 
15
//   specific prior written permission.
 
16
//
 
17
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 
18
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
19
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
20
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 
21
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
22
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 
23
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 
24
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 
25
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
26
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
27
// POSSIBILITY OF SUCH DAMAGE.
 
28
//
 
29
// Author: sameeragarwal@google.com (Sameer Agarwal)
 
30
 
 
31
#ifndef CERES_INTERNAL_MINIMIZER_H_
 
32
#define CERES_INTERNAL_MINIMIZER_H_
 
33
 
 
34
#include <vector>
 
35
#include "ceres/solver.h"
 
36
#include "ceres/iteration_callback.h"
 
37
 
 
38
namespace ceres {
 
39
namespace internal {
 
40
 
 
41
class Evaluator;
 
42
class LinearSolver;
 
43
class SparseMatrix;
 
44
class TrustRegionStrategy;
 
45
 
 
46
// Interface for non-linear least squares solvers.
 
47
class Minimizer {
 
48
 public:
 
49
  // Options struct to control the behaviour of the Minimizer. Please
 
50
  // see solver.h for detailed information about the meaning and
 
51
  // default values of each of these parameters.
 
52
  struct Options {
 
53
    Options() {
 
54
      Init(Solver::Options());
 
55
    }
 
56
 
 
57
    explicit Options(const Solver::Options& options) {
 
58
      Init(options);
 
59
    }
 
60
 
 
61
    void Init(const Solver::Options& options) {
 
62
      max_num_iterations = options.max_num_iterations;
 
63
      max_solver_time_in_seconds = options.max_solver_time_in_seconds;
 
64
      max_step_solver_retries = 5;
 
65
      gradient_tolerance = options.gradient_tolerance;
 
66
      parameter_tolerance = options.parameter_tolerance;
 
67
      function_tolerance = options.function_tolerance;
 
68
      min_relative_decrease = options.min_relative_decrease;
 
69
      eta = options.eta;
 
70
      jacobi_scaling = options.jacobi_scaling;
 
71
      use_nonmonotonic_steps = options.use_nonmonotonic_steps;
 
72
      max_consecutive_nonmonotonic_steps =
 
73
          options.max_consecutive_nonmonotonic_steps;
 
74
      lsqp_dump_directory = options.lsqp_dump_directory;
 
75
      lsqp_iterations_to_dump = options.lsqp_iterations_to_dump;
 
76
      lsqp_dump_format_type = options.lsqp_dump_format_type;
 
77
      num_eliminate_blocks = options.num_eliminate_blocks;
 
78
      max_num_consecutive_invalid_steps =
 
79
          options.max_num_consecutive_invalid_steps;
 
80
      min_trust_region_radius = options.min_trust_region_radius;
 
81
      evaluator = NULL;
 
82
      trust_region_strategy = NULL;
 
83
      jacobian = NULL;
 
84
      callbacks = options.callbacks;
 
85
    }
 
86
 
 
87
    int max_num_iterations;
 
88
    double max_solver_time_in_seconds;
 
89
 
 
90
    // Number of times the linear solver should be retried in case of
 
91
    // numerical failure. The retries are done by exponentially scaling up
 
92
    // mu at each retry. This leads to stronger and stronger
 
93
    // regularization making the linear least squares problem better
 
94
    // conditioned at each retry.
 
95
    int max_step_solver_retries;
 
96
    double gradient_tolerance;
 
97
    double parameter_tolerance;
 
98
    double function_tolerance;
 
99
    double min_relative_decrease;
 
100
    double eta;
 
101
    bool jacobi_scaling;
 
102
    bool use_nonmonotonic_steps;
 
103
    int max_consecutive_nonmonotonic_steps;
 
104
    vector<int> lsqp_iterations_to_dump;
 
105
    DumpFormatType lsqp_dump_format_type;
 
106
    string lsqp_dump_directory;
 
107
    int num_eliminate_blocks;
 
108
    int max_num_consecutive_invalid_steps;
 
109
    int min_trust_region_radius;
 
110
 
 
111
    // List of callbacks that are executed by the Minimizer at the end
 
112
    // of each iteration.
 
113
    //
 
114
    // The Options struct does not own these pointers.
 
115
    vector<IterationCallback*> callbacks;
 
116
 
 
117
    // Object responsible for evaluating the cost, residuals and
 
118
    // Jacobian matrix. The Options struct does not own this pointer.
 
119
    Evaluator* evaluator;
 
120
 
 
121
    // Object responsible for actually computing the trust region
 
122
    // step, and sizing the trust region radius. The Options struct
 
123
    // does not own this pointer.
 
124
    TrustRegionStrategy* trust_region_strategy;
 
125
 
 
126
    // Object holding the Jacobian matrix. It is assumed that the
 
127
    // sparsity structure of the matrix has already been initialized
 
128
    // and will remain constant for the life time of the
 
129
    // optimization. The Options struct does not own this pointer.
 
130
    SparseMatrix* jacobian;
 
131
  };
 
132
 
 
133
  virtual ~Minimizer() {}
 
134
 
 
135
  // Note: The minimizer is expected to update the state of the
 
136
  // parameters array every iteration. This is required for the
 
137
  // StateUpdatingCallback to work.
 
138
  virtual void Minimize(const Options& options,
 
139
                        double* parameters,
 
140
                        Solver::Summary* summary) = 0;
 
141
};
 
142
 
 
143
}  // namespace internal
 
144
}  // namespace ceres
 
145
 
 
146
#endif  // CERES_INTERNAL_MINIMIZER_H_