Home | History | Annotate | Download | only in ceres 
      1 // Ceres Solver - A fast non-linear least squares minimizer
      2 // Copyright 2013 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 (at) google.com (Sameer Agarwal)
     30 //         keir (at) google.com (Keir Mierle)
     31 
     32 #include "ceres/problem.h"
     33 
     34 #include <vector>
     35 #include "ceres/crs_matrix.h"
     36 #include "ceres/problem_impl.h"
     37 
     38 namespace ceres {
     39 
     40 Problem::Problem() : problem_impl_(new internal::ProblemImpl) {}
     41 Problem::Problem(const Problem::Options& options)
     42     : problem_impl_(new internal::ProblemImpl(options)) {}
     43 Problem::~Problem() {}
     44 
     45 ResidualBlockId Problem::AddResidualBlock(
     46     CostFunction* cost_function,
     47     LossFunction* loss_function,
     48     const vector<double*>& parameter_blocks) {
     49   return problem_impl_->AddResidualBlock(cost_function,
     50                                          loss_function,
     51                                          parameter_blocks);
     52 }
     53 
     54 ResidualBlockId Problem::AddResidualBlock(
     55     CostFunction* cost_function,
     56     LossFunction* loss_function,
     57     double* x0) {
     58   return problem_impl_->AddResidualBlock(cost_function,
     59                                          loss_function,
     60                                          x0);
     61 }
     62 
     63 ResidualBlockId Problem::AddResidualBlock(
     64     CostFunction* cost_function,
     65     LossFunction* loss_function,
     66     double* x0, double* x1) {
     67   return problem_impl_->AddResidualBlock(cost_function,
     68                                          loss_function,
     69                                          x0, x1);
     70 }
     71 
     72 ResidualBlockId Problem::AddResidualBlock(
     73     CostFunction* cost_function,
     74     LossFunction* loss_function,
     75     double* x0, double* x1, double* x2) {
     76   return problem_impl_->AddResidualBlock(cost_function,
     77                                          loss_function,
     78                                          x0, x1, x2);
     79 }
     80 
     81 ResidualBlockId Problem::AddResidualBlock(
     82     CostFunction* cost_function,
     83     LossFunction* loss_function,
     84     double* x0, double* x1, double* x2, double* x3) {
     85   return problem_impl_->AddResidualBlock(cost_function,
     86                                          loss_function,
     87                                          x0, x1, x2, x3);
     88 }
     89 
     90 ResidualBlockId Problem::AddResidualBlock(
     91     CostFunction* cost_function,
     92     LossFunction* loss_function,
     93     double* x0, double* x1, double* x2, double* x3, double* x4) {
     94   return problem_impl_->AddResidualBlock(cost_function,
     95                                          loss_function,
     96                                          x0, x1, x2, x3, x4);
     97 }
     98 
     99 ResidualBlockId Problem::AddResidualBlock(
    100     CostFunction* cost_function,
    101     LossFunction* loss_function,
    102     double* x0, double* x1, double* x2, double* x3, double* x4, double* x5) {
    103   return problem_impl_->AddResidualBlock(cost_function,
    104                                          loss_function,
    105                                          x0, x1, x2, x3, x4, x5);
    106 }
    107 
    108 ResidualBlockId Problem::AddResidualBlock(
    109     CostFunction* cost_function,
    110     LossFunction* loss_function,
    111     double* x0, double* x1, double* x2, double* x3, double* x4, double* x5,
    112     double* x6) {
    113   return problem_impl_->AddResidualBlock(cost_function,
    114                                          loss_function,
    115                                          x0, x1, x2, x3, x4, x5, x6);
    116 }
    117 
    118 ResidualBlockId Problem::AddResidualBlock(
    119     CostFunction* cost_function,
    120     LossFunction* loss_function,
    121     double* x0, double* x1, double* x2, double* x3, double* x4, double* x5,
    122     double* x6, double* x7) {
    123   return problem_impl_->AddResidualBlock(cost_function,
    124                                          loss_function,
    125                                          x0, x1, x2, x3, x4, x5, x6, x7);
    126 }
    127 
    128 ResidualBlockId Problem::AddResidualBlock(
    129     CostFunction* cost_function,
    130     LossFunction* loss_function,
    131     double* x0, double* x1, double* x2, double* x3, double* x4, double* x5,
    132     double* x6, double* x7, double* x8) {
    133   return problem_impl_->AddResidualBlock(cost_function,
    134                                          loss_function,
    135                                          x0, x1, x2, x3, x4, x5, x6, x7, x8);
    136 }
    137 
    138 ResidualBlockId Problem::AddResidualBlock(
    139     CostFunction* cost_function,
    140     LossFunction* loss_function,
    141     double* x0, double* x1, double* x2, double* x3, double* x4, double* x5,
    142     double* x6, double* x7, double* x8, double* x9) {
    143   return problem_impl_->AddResidualBlock(
    144       cost_function,
    145       loss_function,
    146       x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
    147 }
    148 
    149 void Problem::AddParameterBlock(double* values, int size) {
    150   problem_impl_->AddParameterBlock(values, size);
    151 }
    152 
    153 void Problem::AddParameterBlock(double* values,
    154                                 int size,
    155                                 LocalParameterization* local_parameterization) {
    156   problem_impl_->AddParameterBlock(values, size, local_parameterization);
    157 }
    158 
    159 void Problem::RemoveResidualBlock(ResidualBlockId residual_block) {
    160   problem_impl_->RemoveResidualBlock(residual_block);
    161 }
    162 
    163 void Problem::RemoveParameterBlock(double* values) {
    164   problem_impl_->RemoveParameterBlock(values);
    165 }
    166 
    167 void Problem::SetParameterBlockConstant(double* values) {
    168   problem_impl_->SetParameterBlockConstant(values);
    169 }
    170 
    171 void Problem::SetParameterBlockVariable(double* values) {
    172   problem_impl_->SetParameterBlockVariable(values);
    173 }
    174 
    175 void Problem::SetParameterization(
    176     double* values,
    177     LocalParameterization* local_parameterization) {
    178   problem_impl_->SetParameterization(values, local_parameterization);
    179 }
    180 
    181 const LocalParameterization* Problem::GetParameterization(
    182     double* values) const {
    183   return problem_impl_->GetParameterization(values);
    184 }
    185 
    186 void Problem::SetParameterLowerBound(double* values,
    187                                      int index,
    188                                      double lower_bound) {
    189   problem_impl_->SetParameterLowerBound(values, index, lower_bound);
    190 }
    191 
    192 void Problem::SetParameterUpperBound(double* values,
    193                                      int index,
    194                                      double upper_bound) {
    195   problem_impl_->SetParameterUpperBound(values, index, upper_bound);
    196 }
    197 
    198 bool Problem::Evaluate(const EvaluateOptions& evaluate_options,
    199                        double* cost,
    200                        vector<double>* residuals,
    201                        vector<double>* gradient,
    202                        CRSMatrix* jacobian) {
    203   return problem_impl_->Evaluate(evaluate_options,
    204                                  cost,
    205                                  residuals,
    206                                  gradient,
    207                                  jacobian);
    208 }
    209 
    210 int Problem::NumParameterBlocks() const {
    211   return problem_impl_->NumParameterBlocks();
    212 }
    213 
    214 int Problem::NumParameters() const {
    215   return problem_impl_->NumParameters();
    216 }
    217 
    218 int Problem::NumResidualBlocks() const {
    219   return problem_impl_->NumResidualBlocks();
    220 }
    221 
    222 int Problem::NumResiduals() const {
    223   return problem_impl_->NumResiduals();
    224 }
    225 
    226 int Problem::ParameterBlockSize(const double* parameter_block) const {
    227   return problem_impl_->ParameterBlockSize(parameter_block);
    228 };
    229 
    230 int Problem::ParameterBlockLocalSize(const double* parameter_block) const {
    231   return problem_impl_->ParameterBlockLocalSize(parameter_block);
    232 };
    233 
    234 bool Problem::HasParameterBlock(const double* values) const {
    235   return problem_impl_->HasParameterBlock(values);
    236 }
    237 
    238 void Problem::GetParameterBlocks(vector<double*>* parameter_blocks) const {
    239   problem_impl_->GetParameterBlocks(parameter_blocks);
    240 }
    241 
    242 void Problem::GetResidualBlocks(
    243     vector<ResidualBlockId>* residual_blocks) const {
    244   problem_impl_->GetResidualBlocks(residual_blocks);
    245 }
    246 
    247 void Problem::GetParameterBlocksForResidualBlock(
    248     const ResidualBlockId residual_block,
    249     vector<double*>* parameter_blocks) const {
    250   problem_impl_->GetParameterBlocksForResidualBlock(residual_block,
    251                                                     parameter_blocks);
    252 }
    253 
    254 void Problem::GetResidualBlocksForParameterBlock(
    255     const double* values,
    256     vector<ResidualBlockId>* residual_blocks) const {
    257   problem_impl_->GetResidualBlocksForParameterBlock(values,
    258                                                     residual_blocks);
    259 }
    260 
    261 }  // namespace ceres
    262