| /external/ceres-solver/internal/ceres/ |
| problem.cc | 32 #include "ceres/problem.h"
40 Problem::Problem() : problem_impl_(new internal::ProblemImpl) {}
41 Problem::Problem(const Problem::Options& options)
43 Problem::~Problem() {}
45 ResidualBlockId Problem::AddResidualBlock(
54 ResidualBlockId Problem::AddResidualBlock
[all...] |
| c_api.cc | 42 #include "ceres/problem.h"
47 using ceres::Problem;
57 return reinterpret_cast<ceres_problem_t*>(new Problem);
60 void ceres_free_problem(ceres_problem_t* problem) {
61 delete reinterpret_cast<Problem*>(problem);
142 ceres_problem_t* problem,
151 Problem* ceres_problem = reinterpret_cast<Problem*>(problem);
175 Problem* problem = reinterpret_cast<Problem*>(c_problem); local
[all...] |
| covariance.cc | 36 #include "ceres/problem.h"
50 Problem* problem) {
51 return impl_->Compute(covariance_blocks, problem->problem_impl_.get());
|
| problem_test.cc | 32 #include "ceres/problem.h"
119 TEST(Problem, AddResidualWithNullCostFunctionDies) {
122 Problem problem; local
123 problem.AddParameterBlock(x, 3);
124 problem.AddParameterBlock(y, 4);
125 problem.AddParameterBlock(z, 5);
127 EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(NULL, NULL, x),
131 TEST(Problem, AddResidualWithIncorrectNumberOfParameterBlocksDies) {
134 Problem problem local
148 Problem problem; local
159 Problem problem; local
172 Problem problem; local
187 Problem problem; local
200 Problem problem; local
223 Problem problem; local
251 Problem problem; local
274 Problem problem; local
330 Problem problem; local
349 Problem problem; local
473 scoped_ptr<ProblemImpl> problem; member in struct:ceres::internal::DynamicProblem
481 Problem problem; local
492 Problem problem; local
503 Problem problem; local
515 Problem problem; local
526 Problem problem; local
539 Problem problem; local
[all...] |
| solver_test.cc | 40 #include "ceres/problem.h"
90 Problem::Options problem_options;
92 Problem problem(problem_options);
93 problem.AddResidualBlock(cost_function.get(), NULL, &x);
106 Solve(options, &problem, &summary);
118 Solve(options, &problem, &summary);
163 Problem problem; local
167 Solve(options, &problem, &summary)
175 Problem problem; local
187 Problem problem; local
201 Problem problem; local
215 Problem problem; local
229 Problem problem; local
[all...] |
| covariance_impl.h | 56 ProblemImpl* problem);
64 ProblemImpl* problem);
78 Problem::EvaluateOptions evaluate_options_;
|
| problem_impl.h | 31 // This is the implementation of the public Problem API. The pointer to
36 // to always put a Problem object into a scoped pointer; this needlessly muddies
49 #include "ceres/problem.h"
70 explicit ProblemImpl(const Problem::Options& options);
74 // See the public problem.h file for description of these methods.
137 bool Evaluate(const Problem::EvaluateOptions& options,
193 const Problem::Options options_;
206 // problem to see if the cost/loss/parameterization is shared with other
|
| solver_impl_test.cc | 76 Problem::Options problem_options;
79 ProblemImpl problem(problem_options);
80 problem.AddResidualBlock(cost_function.get(), NULL, &x, &y, &z, &w);
81 problem.SetParameterBlockConstant(&x);
82 problem.SetParameterBlockConstant(&w);
88 SolverImpl::Solve(options, &problem, &summary);
98 EXPECT_EQ(&x, problem.program().parameter_blocks()[0]->state());
99 EXPECT_EQ(&y, problem.program().parameter_blocks()[1]->state());
100 EXPECT_EQ(&z, problem.program().parameter_blocks()[2]->state());
101 EXPECT_EQ(&w, problem.program().parameter_blocks()[3]->state())
[all...] |
| system_test.cc | 34 // scalar problem with 4 variables. The second problem is a bundle
35 // adjustment problem with 16 cameras and two thousand cameras. The
36 // first problem is to test the sanity test the factorization based
37 // solvers. The second problem is used to test the various
50 #include "ceres/problem.h"
121 // Problem* mutable_problem();
158 ->Evaluate(Problem::EvaluateOptions(),
172 // error prone to do so, since the same problem can have nearly
231 Problem* mutable_problem() { return &problem_;
[all...] |
| /external/ceres-solver/include/ceres/ |
| covariance.h | 43 class Problem;
57 // non-linear least squares problem and provides random access to its
66 // Let us consider the non-linear regression problem
73 // solution to the non-linear least squares problem:
96 // of y, then the maximum likelihood problem to be solved is
107 // scaled, e.g. in the above case the cost function for this problem
112 // non-linear least squares problem and provides random access to its
135 // Structural rank deficiency occurs when the problem contains
177 // Problem problem;
[all...] |
| problem.h | 32 // The Problem object is used to build and hold least squares problems.
66 // blocks from a Problem after adding them.
82 // example, in a structure from motion problem a residual
100 // The canonical example of a sparse least squares problem is
106 // To create a least squares problem, use the AddResidualBlock() and
108 // squares problem containing 3 parameter blocks of sizes 3, 4 and 5
115 // Problem problem;
117 // problem.AddResidualBlock(new MyUnaryCostFunction(...), x1);
118 // problem.AddResidualBlock(new MyBinaryCostFunction(...), x2, x3)
[all...] |
| solver.h | 47 class Problem;
60 // Default constructor that sets up a generic sparse problem.
141 // with a message describing the problem.
162 // is contracted and the model optimization problem is solved
191 // maximum rank. The best choice usually requires some problem
210 // performance for certain classes of problem, which is why it is disabled
212 // sensitivity of the problem to different parameters varies significantly,
236 // Solving the line search problem exactly is computationally
528 // If your problem does not have this property (or you do not know),
539 // e.g., consider the following regression problem
[all...] |
| /external/ceres-solver/examples/ |
| helloworld.cc | 41 using ceres::Problem;
64 // Build the problem.
65 Problem problem; local
71 problem.AddResidualBlock(cost_function, NULL, &x);
77 Solve(options, &problem, &summary);
|
| helloworld_analytic_diff.cc | 41 using ceres::Problem;
69 // For this simple problem it is overkill to check if jacobians[0]
89 // Build the problem.
90 Problem problem; local
94 problem.AddResidualBlock(cost_function, NULL, &x);
100 Solve(options, &problem, &summary);
|
| helloworld_numeric_diff.cc | 40 using ceres::Problem;
60 // Build the problem.
61 Problem problem; local
67 problem.AddResidualBlock(cost_function, NULL, &x);
73 Solve(options, &problem, &summary);
|
| circle_fit.cc | 47 // There are closed form solutions [1] to this problem which you may want to
64 using ceres::Problem;
128 Problem problem; local
143 problem.AddResidualBlock(cost, loss, &x, &y, &m);
149 // Build and solve the problem.
154 Solve(options, &problem, &summary);
|
| powell.cc | 54 using ceres::Problem;
110 Problem problem; local
111 // Add residual terms to the problem using the using the autodiff
114 problem.AddResidualBlock(new AutoDiffCostFunction<F1, 1, 1, 1>(new F1),
117 problem.AddResidualBlock(new AutoDiffCostFunction<F2, 1, 1, 1>(new F2),
120 problem.AddResidualBlock(new AutoDiffCostFunction<F3, 1, 1, 1>(new F3),
123 problem.AddResidualBlock(new AutoDiffCostFunction<F4, 1, 1, 1>(new F4),
145 Solve(options, &problem, &summary);
|
| denoising.cc | 88 // Creates a Fields of Experts MAP inference problem.
91 Problem* problem,
100 problem->AddResidualBlock(cost_function,
129 problem->AddResidualBlock(cost_function[alpha_index],
137 // Solves the FoE problem using Ceres and post-processes it to make sure the
139 void SolveProblem(Problem* problem, PGMImage<double>* solution) {
157 ceres::Solve(options, problem, &summary);
209 ceres::Problem problem local
[all...] |
| curve_fitting.cc | 36 using ceres::Problem;
143 Problem problem; local
145 problem.AddResidualBlock(
158 Solve(options, &problem, &summary);
|
| robot_pose_mle.cc | 51 // There are two types of residuals in this problem:
143 using ceres::Problem;
210 // conveniently add to a ceres problem.
287 ceres::Problem problem; local
296 problem.AddResidualBlock(range_cost_function, NULL, parameter_blocks);
300 problem.AddResidualBlock(OdometryConstraint::Create(odometry_values[i]),
310 Solve(solver_options, &problem, &summary);
|
| robust_curve_fitting.cc | 119 using ceres::Problem;
145 Problem problem; local
150 problem.AddResidualBlock(cost_function, NULL, &m, &c);
158 Solve(options, &problem, &summary);
|
| bundle_adjuster.cc | 31 // An example of solving a dynamically sized problem with various
39 // The problem being solved here is known as a Bundle Adjustment
40 // problem in computer vision. Given a set of 3d points X_1, ..., X_n,
50 // The problem used here comes from a collection of bundle adjustment
250 void BuildProblem(BALProblem* bal_problem, Problem* problem) {
289 problem->AddResidualBlock(cost_function,
295 problem->AddResidualBlock(cost_function, loss_function, camera, point);
303 problem->SetParameterization(cameras + camera_block_size * i,
311 Problem problem local
[all...] |
| simple_bundle_adjuster.cc | 190 // Create residuals for each observation in the bundle adjustment problem. The
192 ceres::Problem problem; local
201 problem.AddResidualBlock(cost_function,
215 ceres::Solve(options, &problem, &summary);
|
| more_garbow_hillstrom.cc | 50 // A problem is considered solved if of the log relative error of its
276 Problem problem; local
277 problem.AddResidualBlock(TestProblem::Create(), NULL, x);
279 problem.SetParameterLowerBound(x, i, TestProblem::lower_bounds[i]);
280 problem.SetParameterUpperBound(x, i, TestProblem::upper_bounds[i]);
290 Solve(options, &problem, &summary);
311 Problem problem; local
312 problem.AddResidualBlock(TestProblem::Create(), NULL, x)
[all...] |
| /external/bison/lib/ |
| argmatch.h | 57 ptrdiff_t problem);
61 # define invalid_arg(Context, Value, Problem) \
62 argmatch_invalid (Context, Value, Problem)
|
