VPPlanner.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP 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.
//
// MIP 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 MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------





#ifndef __VIEW_POINT_PLANNER_
#define __VIEW_POINT_PLANNER_


/* @{ */

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <fstream>
#include <iostream>

#include <vector>
#include <Spaces.h>
#include <assert.h>
#include <math.h>
#include <Scan.h>
// #include <TrajControl.h>
#include <algorithm>

#include <Types.h>

#include <Grid.h>

using namespace std;
using namespace MipBaselib;

enum VPPlanners{
 FRONTIER_BASED,
 RAND_FRONTIER_BASED,
 ORTHOGONAL_IG,
 LANDSCAPING_IG,
 GOAL_BASED,
 VP_PLANNERS_NUM
};

static const char* VPPlannersNames[VP_PLANNERS_NUM] = {
 "Frontier Based",
 "Random Frontier Based",
 "Orthogonal Information Gain",
 "Landscaping Information Gain",
 "Goal Based"
};

class VPPlanner{
 private:
  VPPlanners _type;
  Pose _nextVP;
  Position _goal;
 public:
  
  VPPlanner(){};

  
  VPPlanner(VPPlanners type){
   setType(type);
  }
  
  virtual bool findNextVP(Grid* grid)=0;
  
  void setNextVP(Pose nextVP){
   _nextVP=nextVP;
  
  }
  
  void setType(VPPlanners type){
   _type=type;
  }
  
  Pose nextVP(){
   return _nextVP;
  }
  
  VPPlanners type(){
   return _type;
  }
  void setGoal(Position goal){
   _goal=goal;
  }
  Position getGoal(){
   return _goal;
  }

  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   
   s<<"View Point Planner\t"<<VPPlannersNames[_type]<<endl;
   s<<"View Point\t\t"<<_nextVP.print()<<endl;
   
   
   return s.str();
  }
};

class FrontierBasedVPP:public VPPlanner{
 public:
  
  FrontierBasedVPP(){
   setType(FRONTIER_BASED);
//    cout<<"constructed "<<VPPlannersNames[FRONTIER_BASED]<<endl;
  }
  
  
  bool findNextVP(Grid* grid);
  
};

class RandomFrontierBasedVPP:public VPPlanner{
 public:
  
  RandomFrontierBasedVPP(){
   setType(RAND_FRONTIER_BASED);
  }
  
  bool findNextVP(Grid* grid);
};

class OrthogonalIGVPP:public VPPlanner{
 public:
  
  OrthogonalIGVPP(){
   setType(ORTHOGONAL_IG);
  }
  
  bool findNextVP(Grid* grid);
};

class LandscapingIGVPP:public VPPlanner{
 public:
  
  LandscapingIGVPP(){
   setType(LANDSCAPING_IG);
  }
  
  bool findNextVP(Grid* grid);
};





class GoalBasedVPP:public VPPlanner{
 public:
  
   GoalBasedVPP(Position goal){
    setGoal(goal);
  }
//   bool findNextVP(Grid* grid);
  bool findNextVP(Grid* grid);

};



#endif


/* @} */