AlgorithmSelector.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009 by Ulrich Friedrich Klank <klank@in.tum.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/************************************************************************
                        AlgorithmSelector.h - Copyright klank


**************************************************************************/


#ifndef ALGORITHMSELECTOR_H
#define ALGORITHMSELECTOR_H

#include <string>
#include <vector>

#include "AlgorithmEval.h"
#include "Signature.h"
#ifdef LOGFILE
#include "LogFile.h"
#define STD_LOGFILENAME "AlgActions.log"
#endif /*LOGFILE*/

#include <ANN/ANN.h>

typedef double Probability_1D_t; /* < Type for storing Probability of a location to occur*/


namespace cop
{

  typedef std::vector<std::pair<RelPose*, Probability_1D_t> > PossibleLocations_t;/* < Type for a list of relposes with their a-priori probability */
  typedef std::vector<std::pair<RelPose*, Signature*> > SignatureLocations_t;

  /***/

  #define XML_NODE_ALGORITHMSELECTOR "AlgorithmSelector"

  template<typename T>
  class AlgorithmSelector : public Evaluator
  {
  public:
    // Constructors/Destructors
    //
      AlgorithmSelector(
  #ifdef LOGFILE
          LogFile& log
  #endif /*LOGFILE*/
          )  :
          m_tree(NULL),
          m_paLength(0),
          m_paAllocatedLength(0),
          m_paDim(4)
#ifdef LOGFILE
          ,m_logfile(log)
  #endif /*LOGFILE*/
          {
            m_mutexAlgEval = new boost::mutex();
          }
    AlgorithmSelector (XMLTag* node
  #ifdef LOGFILE
          , LogFile& log
  #endif /*LOGFILE*/
          );
    ~AlgorithmSelector ( ){delete m_mutexAlgEval;}
    int AddAlgorithm(Algorithm<T>* alg, int nType, double dEval, double dTime);

    XMLTag* Save(std::string name = "");
    virtual Algorithm<T>* BestAlgorithm(int type, const Signature& sig, const std::vector<Sensor*> &sensors);
    std::vector<Algorithm<T>*> BestAlgorithmList(int type, const Signature &sig, const std::vector<Sensor*> &sensors);

    int CountAlgorithms(){return m_algorithmlist.size();}
    const std::vector<AlgorithmEval<T> >& GetAlgorithmList() const {return m_algorithmlist;};
    virtual void EvalAlgorithm(Evaluable* alg, double eval, double time, Signature* relatedElemg);
    void ReevaluatePose(Algorithm<T>* alg, RelPose*& pose);


  protected:
    int InsertInList(AlgorithmEval<T> eval);

    bool CheckTypeCompatibility(int listedType, int askedType);

    double ReEvalKernel(double val);


    std::vector<AlgorithmEval<T> >& GetAlgorithmList(std::vector<AlgorithmEval<T> >* eval = NULL) ;

    Algorithm<T>* getAlgorithm(int index);

  private:
    std::vector<AlgorithmEval<T> > m_algorithmlist;

      ANNkd_tree    *m_tree;
      ANNpointArray m_pointArray;
      double        *m_pointEval;
      int           m_paLength;
      int           m_paAllocatedLength;
      int           m_paDim;

      typedef boost::mutex::scoped_lock lock;
      boost::mutex  *m_mutexAlgEval;    

  public:
  #ifdef LOGFILE
      LogFile& m_logfile;
  #endif /*LOGFILE*/
  };
}
#endif // ALGORITHMSELECTOR_H