optimizer.h

Go to the documentation of this file.

#ifndef __INC_OPTIMIZER
#define __INC_OPTIMIZER

#include <log.h>
#include <frame.h>
#include <configuration.h>
#include <datapairs.h>
#include <value_setter.h>
#include <optimizer_goal.h>
#include <optimizer_goal_global_position.h>
#include <optimizer_goal_global_orientation.h>
#include <optimizer_goal_orientation.h>
#include <optimizer_goal_position.h>
#include <optimizer_container.h>

namespace robotLibPbD {

class COptimizerResult
{
 public:
  std::vector<std::vector<std::pair<std::string, CMatrix> > > timelineOfPoses;
  
  std::vector<std::pair<std::string, CMatrix> > allPoses; 
  std::vector<std::pair<std::string, CMatrix> > optimizedPoses;
  std::vector<double> values;
  double result;

  void clear();
};

class COptimizer
{
 protected:
  std::vector<ValueSetter> valueSetters; 
  std::vector<double> result;

  std::vector<OptimizerContainer> data;
  std::vector<OptimizerGoalGlobal*> globalFunctions;
  std::vector<OptimizerGoal*> functions;
  CFrameContainer frames; 
  DataPairs information;
  //unsigned int trimming;
  std::vector<std::vector<double> > examples;
  std::vector<double> distances;
  unsigned int counter;
  double trim;
  unsigned int examplesMax, iterations;
  unsigned int dofs;
  unsigned int counterMod, trimming;
  bool useRandom, useShowResult, doQuit;
  double resultValue, epsilon;

  void setValue(double *x);
  bool writeToFile(std::string filename, std::string buffer);
  std::string readFromFile(std::string filename);
  void setData(std::vector<double> &values);
  void callback(int nparam, double *x, double *fj);
  
  bool isEqual(std::vector<double> &first, std::vector<double> &second, double eps = 0.1);
  
  void loadData(std::string filename, unsigned int startId = 0);
  void loadDofs(std::string filename);
  void loadGoals(std::string filename);
  void loadValueSetters(std::string filename);
  
  int getValue(TiXmlElement *node, std::string item);
  void reset();
  
 public:
 COptimizer() : counter(0), trim(0.0), examplesMax(100000),dofs(0),counterMod(10000),useRandom(false),useShowResult(false),doQuit(false),epsilon(1.0e-8) {}
  
  static void rosenbrockCallback(int nparam, double *x, double *fj, void *extraparams);
  
  void load(std::string cfg, std::string data, unsigned int start = 0);
  
  virtual std::string generateOutput(); 
  
  void run(const std::vector<double> &initialValues);
  
  void setEpsilon(double eps) { this->epsilon = eps; }
  void setTrimming(double trim) { this->trim = trim; }
  void setIterations(unsigned int iterations) { this->iterations = iterations; }
  void setRandomStart(bool useRandom) { this->useRandom = useRandom; }
  void setQuit(bool doQuit) { this->doQuit = doQuit; }
  void setDataMax(unsigned int examplesMax) { this->examplesMax = examplesMax; }
  void setShowResult(bool useShowResult) { this->useShowResult = useShowResult; }
  void setShowModulo(unsigned int counterMod) { this->counterMod = counterMod; }

  bool getResult(COptimizerResult &out);
};

};

#endif