| // Ceres Solver - A fast non-linear least squares minimizer |
| // Copyright 2015 Google Inc. All rights reserved. |
| // http://ceres-solver.org/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // * Redistributions of source code must retain the above copyright notice, |
| // this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // * Neither the name of Google Inc. nor the names of its contributors may be |
| // used to endorse or promote products derived from this software without |
| // specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| // POSSIBILITY OF SUCH DAMAGE. |
| // |
| // Author: sameeragarwal@google.com (Sameer Agarwal) |
| // keir@google.com (Keir Mierle) |
| |
| #include "ceres/problem.h" |
| |
| #include <vector> |
| #include "ceres/crs_matrix.h" |
| #include "ceres/problem_impl.h" |
| |
| namespace ceres { |
| |
| using std::vector; |
| |
| Problem::Problem() : problem_impl_(new internal::ProblemImpl) {} |
| Problem::Problem(const Problem::Options& options) |
| : problem_impl_(new internal::ProblemImpl(options)) {} |
| Problem::~Problem() {} |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| const vector<double*>& parameter_blocks) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| parameter_blocks); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1, double* x2) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1, double* x2, double* x3) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2, x3); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1, double* x2, double* x3, double* x4) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2, x3, x4); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1, double* x2, double* x3, double* x4, double* x5) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2, x3, x4, x5); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1, double* x2, double* x3, double* x4, double* x5, |
| double* x6) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2, x3, x4, x5, x6); |
| } |
| |
| ResidualBlockId Problem::AddResidualBlock( |
| CostFunction* cost_function, |
| LossFunction* loss_function, |
| double* x0, double* x1, double* x2, double* x3, double* x4, double* x5, |
| double* x6, double* x7) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2, x3, x4, x5, x6, x7); |
| } |
| |
| ResidualBlockId Problem::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) { |
| return problem_impl_->AddResidualBlock(cost_function, |
| loss_function, |
| x0, x1, x2, x3, x4, x5, x6, x7, x8); |
| } |
| |
| ResidualBlockId Problem::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) { |
| return problem_impl_->AddResidualBlock( |
| cost_function, |
| loss_function, |
| x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); |
| } |
| |
| void Problem::AddParameterBlock(double* values, int size) { |
| problem_impl_->AddParameterBlock(values, size); |
| } |
| |
| void Problem::AddParameterBlock(double* values, |
| int size, |
| LocalParameterization* local_parameterization) { |
| problem_impl_->AddParameterBlock(values, size, local_parameterization); |
| } |
| |
| void Problem::RemoveResidualBlock(ResidualBlockId residual_block) { |
| problem_impl_->RemoveResidualBlock(residual_block); |
| } |
| |
| void Problem::RemoveParameterBlock(double* values) { |
| problem_impl_->RemoveParameterBlock(values); |
| } |
| |
| void Problem::SetParameterBlockConstant(double* values) { |
| problem_impl_->SetParameterBlockConstant(values); |
| } |
| |
| void Problem::SetParameterBlockVariable(double* values) { |
| problem_impl_->SetParameterBlockVariable(values); |
| } |
| |
| bool Problem::IsParameterBlockConstant(double* values) const { |
| return problem_impl_->IsParameterBlockConstant(values); |
| } |
| |
| void Problem::SetParameterization( |
| double* values, |
| LocalParameterization* local_parameterization) { |
| problem_impl_->SetParameterization(values, local_parameterization); |
| } |
| |
| const LocalParameterization* Problem::GetParameterization( |
| double* values) const { |
| return problem_impl_->GetParameterization(values); |
| } |
| |
| void Problem::SetParameterLowerBound(double* values, |
| int index, |
| double lower_bound) { |
| problem_impl_->SetParameterLowerBound(values, index, lower_bound); |
| } |
| |
| void Problem::SetParameterUpperBound(double* values, |
| int index, |
| double upper_bound) { |
| problem_impl_->SetParameterUpperBound(values, index, upper_bound); |
| } |
| |
| bool Problem::Evaluate(const EvaluateOptions& evaluate_options, |
| double* cost, |
| vector<double>* residuals, |
| vector<double>* gradient, |
| CRSMatrix* jacobian) { |
| return problem_impl_->Evaluate(evaluate_options, |
| cost, |
| residuals, |
| gradient, |
| jacobian); |
| } |
| |
| int Problem::NumParameterBlocks() const { |
| return problem_impl_->NumParameterBlocks(); |
| } |
| |
| int Problem::NumParameters() const { |
| return problem_impl_->NumParameters(); |
| } |
| |
| int Problem::NumResidualBlocks() const { |
| return problem_impl_->NumResidualBlocks(); |
| } |
| |
| int Problem::NumResiduals() const { |
| return problem_impl_->NumResiduals(); |
| } |
| |
| int Problem::ParameterBlockSize(const double* parameter_block) const { |
| return problem_impl_->ParameterBlockSize(parameter_block); |
| } |
| |
| int Problem::ParameterBlockLocalSize(const double* parameter_block) const { |
| return problem_impl_->ParameterBlockLocalSize(parameter_block); |
| } |
| |
| bool Problem::HasParameterBlock(const double* values) const { |
| return problem_impl_->HasParameterBlock(values); |
| } |
| |
| void Problem::GetParameterBlocks(vector<double*>* parameter_blocks) const { |
| problem_impl_->GetParameterBlocks(parameter_blocks); |
| } |
| |
| void Problem::GetResidualBlocks( |
| vector<ResidualBlockId>* residual_blocks) const { |
| problem_impl_->GetResidualBlocks(residual_blocks); |
| } |
| |
| void Problem::GetParameterBlocksForResidualBlock( |
| const ResidualBlockId residual_block, |
| vector<double*>* parameter_blocks) const { |
| problem_impl_->GetParameterBlocksForResidualBlock(residual_block, |
| parameter_blocks); |
| } |
| |
| const CostFunction* Problem::GetCostFunctionForResidualBlock( |
| const ResidualBlockId residual_block) const { |
| return problem_impl_->GetCostFunctionForResidualBlock(residual_block); |
| } |
| |
| const LossFunction* Problem::GetLossFunctionForResidualBlock( |
| const ResidualBlockId residual_block) const { |
| return problem_impl_->GetLossFunctionForResidualBlock(residual_block); |
| } |
| |
| void Problem::GetResidualBlocksForParameterBlock( |
| const double* values, |
| vector<ResidualBlockId>* residual_blocks) const { |
| problem_impl_->GetResidualBlocksForParameterBlock(values, |
| residual_blocks); |
| } |
| |
| } // namespace ceres |
