// Ceres Solver - A fast non-linear least squares minimizer // Copyright 2010, 2011, 2012 Google Inc. All rights reserved. // http://code.google.com/p/ceres-solver/ // // 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: keir@google.com (Keir Mierle) // // This is the implementation of the public Problem API. The pointer to // implementation (PIMPL) idiom makes it possible for Ceres internal code to // refer to the private data members without needing to exposing it to the // world. An alternative to PIMPL is to have a factory which returns instances // of a virtual base class; while that approach would work, it requires clients // to always put a Problem object into a scoped pointer; this needlessly muddies // client code for little benefit. Therefore, the PIMPL comprise was chosen. #ifndef CERES_PUBLIC_PROBLEM_IMPL_H_ #define CERES_PUBLIC_PROBLEM_IMPL_H_ #include #include #include "ceres/internal/macros.h" #include "ceres/internal/port.h" #include "ceres/internal/scoped_ptr.h" #include "ceres/collections_port.h" #include "ceres/problem.h" #include "ceres/types.h" namespace ceres { class CostFunction; class LossFunction; class LocalParameterization; struct CRSMatrix; namespace internal { class Program; class ResidualBlock; class ProblemImpl { public: typedef map ParameterMap; typedef HashSet ResidualBlockSet; ProblemImpl(); explicit ProblemImpl(const Problem::Options& options); ~ProblemImpl(); // See the public problem.h file for description of these methods. ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, const vector& parameter_blocks); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1, double* x2); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1, double* x2, double* x3); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1, double* x2, double* x3, double* x4); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1, double* x2, double* x3, double* x4, double* x5); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1, double* x2, double* x3, double* x4, double* x5, double* x6); ResidualBlockId AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, double* x0, double* x1, double* x2, double* x3, double* x4, double* x5, double* x6, double* x7); ResidualBlockId 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); ResidualBlockId 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); void AddParameterBlock(double* values, int size); void AddParameterBlock(double* values, int size, LocalParameterization* local_parameterization); void RemoveResidualBlock(ResidualBlock* residual_block); void RemoveParameterBlock(double* values); void SetParameterBlockConstant(double* values); void SetParameterBlockVariable(double* values); void SetParameterization(double* values, LocalParameterization* local_parameterization); const LocalParameterization* GetParameterization(double* values) const; void SetParameterLowerBound(double* values, int index, double lower_bound); void SetParameterUpperBound(double* values, int index, double upper_bound); bool Evaluate(const Problem::EvaluateOptions& options, double* cost, vector* residuals, vector* gradient, CRSMatrix* jacobian); int NumParameterBlocks() const; int NumParameters() const; int NumResidualBlocks() const; int NumResiduals() const; int ParameterBlockSize(const double* parameter_block) const; int ParameterBlockLocalSize(const double* parameter_block) const; bool HasParameterBlock(const double* parameter_block) const; void GetParameterBlocks(vector* parameter_blocks) const; void GetResidualBlocks(vector* residual_blocks) const; void GetParameterBlocksForResidualBlock( const ResidualBlockId residual_block, vector* parameter_blocks) const; void GetResidualBlocksForParameterBlock( const double* values, vector* residual_blocks) const; const Program& program() const { return *program_; } Program* mutable_program() { return program_.get(); } const ParameterMap& parameter_map() const { return parameter_block_map_; } const ResidualBlockSet& residual_block_set() const { CHECK(options_.enable_fast_removal) << "Fast removal not enabled, residual_block_set is not maintained."; return residual_block_set_; } private: ParameterBlock* InternalAddParameterBlock(double* values, int size); void InternalRemoveResidualBlock(ResidualBlock* residual_block); bool InternalEvaluate(Program* program, double* cost, vector* residuals, vector* gradient, CRSMatrix* jacobian); // Delete the arguments in question. These differ from the Remove* functions // in that they do not clean up references to the block to delete; they // merely delete them. template void DeleteBlockInVector(vector* mutable_blocks, Block* block_to_remove); void DeleteBlock(ResidualBlock* residual_block); void DeleteBlock(ParameterBlock* parameter_block); const Problem::Options options_; // The mapping from user pointers to parameter blocks. map parameter_block_map_; // Iff enable_fast_removal is enabled, contains the current residual blocks. ResidualBlockSet residual_block_set_; // The actual parameter and residual blocks. internal::scoped_ptr program_; // When removing residual and parameter blocks, cost/loss functions and // parameterizations have ambiguous ownership. Instead of scanning the entire // problem to see if the cost/loss/parameterization is shared with other // residual or parameter blocks, buffer them until destruction. // // TODO(keir): See if it makes sense to use sets instead. vector cost_functions_to_delete_; vector loss_functions_to_delete_; vector local_parameterizations_to_delete_; CERES_DISALLOW_COPY_AND_ASSIGN(ProblemImpl); }; } // namespace internal } // namespace ceres #endif // CERES_PUBLIC_PROBLEM_IMPL_H_