static_dynamic_function_fit.cpp File Reference

#include <random>
#include <unsupported/Eigen/Polynomials>
#include "g2o/core/base_binary_edge.h"
#include "g2o/core/base_dynamic_vertex.h"
#include "g2o/core/base_unary_edge.h"
#include "g2o/core/base_vertex.h"
#include "g2o/core/block_solver.h"
#include "g2o/core/optimization_algorithm_levenberg.h"
#include "g2o/core/sparse_optimizer.h"
#include "g2o/solvers/eigen/linear_solver_eigen.h"
#include "g2o/stuff/sampler.h"

Include dependency graph for static_dynamic_function_fit.cpp:

Go to the source code of this file.

Classes
class	FPolynomialCoefficientVertex
class	PPolynomialCoefficientVertex
struct	FunctionObservation
class	MultipleValueEdge

Functions
int	main (int argc, const char *argv[])

Function Documentation

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 172 of file static_dynamic_function_fit.cpp.

                                       {
  // Random number generator
  std::default_random_engine generator;
 
  // Create the coefficients for the f-polynomial (all drawn randomly)
  Eigen::Vector3d f;
  for (int i = 0; i < 3; ++i) {
    f[i] = g2o::sampleUniform(-1, 1);
  }
 
  // Number of dimensions of the polynomial; the default is 4
  int polynomialDimension = 4;
  if (argc > 1) {
    polynomialDimension = atoi(argv[1]);
  }
 
  // Create the coefficients for the polynomial (all drawn randomly)
  Eigen::VectorXd p(polynomialDimension);
  for (int i = 0; i < polynomialDimension; ++i) {
    p[i] = g2o::sampleUniform(-1, 1);
  }
 
  std::cout << "Ground truth vectors f=" << f.transpose()
            << "; p=" << p.transpose() << std::endl;
 
  // The number of observations in the polynomial; the defaultis 6
  int obs = 6;
  if (argc > 2) {
    obs = atoi(argv[2]);
  }
 
  // The number of observations will be randomly sampled each time.
 
  // Sample the observations. This is a set of function
  // observations. The cardinality of each observation set is random.
  double sigmaZ = 0.1;
  std::vector<FunctionObservation> observations(obs);
  std::uniform_int_distribution<int> cardinalitySampler(1, 5);
 
  for (int i = 0; i < obs; ++i) {
    FunctionObservation& fo = observations[i];
    int numObs = cardinalitySampler(generator);
    fo.x.resize(numObs);
    fo.z.resize(numObs);
    for (int o = 0; o < numObs; ++o) {
      fo.x[o] = g2o::sampleUniform(-5, 5);
      double x3 = pow(fo.x[o], 3);
      fo.z[o] = Eigen::poly_eval(f, fo.x[o]) +
                x3 * (Eigen::poly_eval(p, fo.x[o])) +
                sigmaZ * g2o::sampleGaussian();
    }
  }
 
  // Construct the graph and set up the solver and optimiser
  std::unique_ptr<g2o::BlockSolverX::LinearSolverType> linearSolver =
      std::make_unique<
          g2o::LinearSolverEigen<g2o::BlockSolverX::PoseMatrixType>>();
 
  // Set up the solver
  std::unique_ptr<g2o::BlockSolverX> blockSolver =
      std::make_unique<g2o::BlockSolverX>(std::move(linearSolver));
 
  // Set up the optimisation algorithm
  g2o::OptimizationAlgorithm* optimisationAlgorithm =
      new g2o::OptimizationAlgorithmLevenberg(std::move(blockSolver));
 
  // Create the graph and configure it
  std::unique_ptr<g2o::SparseOptimizer> optimizer =
      std::make_unique<g2o::SparseOptimizer>();
  optimizer->setVerbose(true);
  optimizer->setAlgorithm(optimisationAlgorithm);
 
  // Create the f vertex; its dimensions are known
  FPolynomialCoefficientVertex* pf = new FPolynomialCoefficientVertex();
  pf->setId(0);
  optimizer->addVertex(pf);
 
  // Create the vertex; note its dimension is currently is undefined
  PPolynomialCoefficientVertex* pv = new PPolynomialCoefficientVertex();
  pv->setId(1);
  optimizer->addVertex(pv);
 
  // Create the information matrix
  double omega = 1 / (sigmaZ * sigmaZ);
 
  // Create the edges
  for (int i = 0; i < obs; ++i) {
    MultipleValueEdge* mve = new MultipleValueEdge(observations[i], omega);
    mve->setVertex(0, pf);
    mve->setVertex(1, pv);
    optimizer->addEdge(mve);
  }
 
  // Now run the same optimization problem for different choices of
  // dimension of the polynomial vertex. This shows how we can
  // dynamically change the vertex dimensions in an alreacy
  // constructed graph. Note that you must call initializeOptimization
  // before you can optimize after a state dimension has changed.
  for (int testDimension = 1; testDimension <= polynomialDimension;
       ++testDimension) {
    pv->setDimension(testDimension);
    optimizer->initializeOptimization();
    optimizer->optimize(10);
    std::cout << "Computed parameters: f=" << pf->estimate().transpose()
              << "; p=" << pv->estimate().transpose() << std::endl;
  }
  for (int testDimension = polynomialDimension - 1; testDimension >= 1;
       --testDimension) {
    pv->setDimension(testDimension);
    optimizer->initializeOptimization();
    optimizer->optimize(10);
    std::cout << "Computed parameters: f= " << pf->estimate().transpose()
              << "; p=" << pv->estimate().transpose() << std::endl;
  }
}

References g2o::BaseVertex< D, T >::estimate(), g2o::sampleGaussian(), g2o::sampleUniform(), g2o::BaseDynamicVertex< T >::setDimension(), g2o::OptimizableGraph::Vertex::setId(), g2o::HyperGraph::Edge::setVertex(), FunctionObservation::x, and FunctionObservation::z.