Grid.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 __LOCAL_GRID_H
// #define __LOCAL_GRID_H
// 
// #include <assert.h>
// #include <Spaces.h>
// #include <vector>
// #include <math.h>
// #include "localPlanner.h"
// 
// 
// #define INFINITY -1
// 
// using namespace std;
// 
// typedef struct indexes{
// unsigned int i;
// unsigned int j;
// }IndexPoint;

// class Cell{
//  private:
//   
//   Position      _p;   /**<cell position in meters w.r.t. the center cell*/
//   IndexPoint _inp; /**<cell indeces in matricial rapresentation*/
//   
//   Decimal _side; /**<side size of the cell in meters*/
// 
//   bool _isLRR;    /**<flag; denotes that cell belongs to the LRR*/
//   bool _isFrontier; /**<flag; denotes that cell belongs to the Frontier*/
//   bool _isLSR;    /**<flag; denotes that cell belongs to the LSR*/
//   bool _isPrevExpl; /**<flag; denotes that cell does not belong to the LSR but has already been explored*/
//   bool _isObstacle; /**<flag; denotes that cell is bounded by an obstacle*/
//   /// allowed cells combinations:
//   ///  _isLRR  _isFrontier  _isLSR(CurrExplored)  isPrevExplored  _isObstacle
//   ///1  true   false     true        false       false
//   ///2  false   true     true        false       false
//   ///3  false   false     true        false       false
//   ///4  false   false     true        false       true
//   ///5  false   false     false        true        false 
//   bool _integrity();   /**<check the integrity of flags*/
//   
//   unsigned int _cone; /**<sensor's perception cone the cell belongs to*/
// 
//   Decimal _distVP;       /**<distance from ViewPoint (center) in meters*/
//   Decimal _distLSRBound; /**<distance from closest LSR boundary*/
// 
//   
//  public:
//     
//     ///default constr should be not allowed
//   Cell();
//   ///Decimal constructor
//   Cell(Decimal);
//   ///Copy constructor
//   Cell(const Cell& c);
//   ///= operator
//   Cell operator=(const Cell& c);
//   /*Cell(Position,IndexPoint);*/
//   
// /***************************************************************************************************
// ***********************************        SET FUNCTIONS         ***********************************
// ***************************************************************************************************/
//   
//   ///\brief sets cell position in meters w.r.t. the center cell
//   void setPoint(Position point){
//    _p=point;
//   }
//   
//   ///\brief sets cell indeces in matricial rapresentation
//   void setIndexPoint(IndexPoint index){
//    _inp=index;
//   }
//   
//   ///\brief sets cell side in meters
//   void setSide(Decimal value){
//    _side=value;
//   }
//   
//   ///\brief sets _isLRR flag 
//   void setIsLRR(){
//    _isLRR=true;
//   }
//   
//   ///\brief unset _isFrontier flag 
//   void setIsFrontier(){
//    _isFrontier=true;
//   }
//   
//   ///\brief sets _isLSR flag 
//   void setIsLSR(){
//    _isLSR=true;
//   }
//   
//   ///\brief sets _isPrevExpl flag 
//   void setIsPrevExpl(){
//    _isPrevExpl=true;
//   }
//   
//   ///\brief sets _isObstacle flag 
//   void setIsObstacle(){
//    _isObstacle=true;
//   }
//   
//   ///\brief set appartenence cone
//   void setCone (unsigned int value){
//    _cone=value;
//   }
//   
//   ///\brief sets distance from ViewPoint (center) in meters
//   void setDistVP(Decimal value){
//    _distVP=value;
//   }
//   
//   ///\brief sets distance from closest LSR boundary
//   void  setDistLSRBound(Decimal value){
//    _distLSRBound=value;
//   }
//   
//   
//   ///\brief unset the flag _isLRR
//   void unsetLRR(){
//    _isLRR=false;
//   }
//   
//   ///\brief unset the flag _isFrontier
//   void unsetFrontier(){
//    _isFrontier=false;
//   }
//   
//   ///\brief unset the flag _isLSR
//   void unsetLSR(){
//    _isLSR=false;
//   }
//   
//   ///\brief unset the flag _isPrevExpl
//   void unsetIsPrevExpl(){
//    _isPrevExpl=false;
//   }
//   
//   ///\brief unset the flag _isObstacle
//   void unsetIsObstacle(){
//    _isObstacle=false;
//   }
//   
// /***************************************************************************************************
// ***********************************        GET FUNCTIONS         ***********************************
// ***************************************************************************************************/
//   
//   ///\brief return cell position in meters w.r.t. the center cell
//   Position point(void){
//    return _p;
//   }
//   
//   ///\brief return cell indeces in matricial rapresentation
//   IndexPoint indexPoint(){
//    return _inp;
//   }
//   
//   ///\brief return cell side in meters
//   Decimal side(){
//    return _side;
//   }
//   
//   ///\brief return _isLRR flag 
//   bool isLRR(){
//    return _isLRR;
//   }
//   
//   ///\brief return _isFrontier flag 
//   bool isFrontier(){
//    return _isFrontier;
//   }
//   
//   ///\brief return isLRSR flag 
//   bool isLSR(){
//    return _isLSR;
//   }
//   
//   ///\brief return _isPrevExpl flag 
//   bool isPrevExpl(){
//    return _isPrevExpl;
//   }
//   
//   ///\brief return _isObstacle flag 
//   bool isObstacle(){
//    return _isObstacle;
//   }
//   
//   ///\brief return integrity flag
//   bool integrity(){
//    return ( (_isLRR  && !_isFrontier  && _isLSR  && !_isPrevExpl && !_isObstacle) ||
//      (!_isLRR && _isFrontier   && _isLSR  && !_isPrevExpl && !_isObstacle)||
//      (!_isLRR && !_isFrontier  && _isLSR  && !_isPrevExpl && !_isObstacle) ||
//      (!_isLRR && !_isFrontier  && _isLSR  && !_isPrevExpl && _isObstacle)  ||
//      (!_isLRR && !_isFrontier  && !_isLSR && _isPrevExpl  && !_isObstacle) ||
//      (!_isLRR && !_isFrontier  && !_isLSR && !_isPrevExpl && !_isObstacle) );
//   }
//   
//   ///\brief return appartenence cone
//   unsigned int cone (){
//    return _cone;
//   }
//   
//   ///\brief return distance of current cell from ViewPoint (center) in meters
//   Decimal distVP(){
//    return _distVP;
//   }
//   
//   ///\brief return distance of current cell from closest LSR boundary
//   Decimal distLSRBound(){
//    return _distLSRBound;
//   }
// };

// class LocalGrid {
//  private:
//   Decimal _resolution;    /**<cells side size in meters*/
//   Decimal _width;         /**<grid width in meters*/
//   Decimal _height;        /**<grid height in meters*/
//   unsigned int _columns; /**<number of grid columns (odds)*/
//   unsigned int _rows;    /**<number of grid rows (odds)*/
//   Position  _center;        /**<center cell coordinates w.r.t. the absolute frame*/
//   Position  _lowCorner;     /**<lower left cell coordinates w.r.t. the absolute frame*/
// 
//   vector<Cell> _board; /**<matricial rapresentation of the grid*/
//   
//   bool _firstUpdate;
//   bool _firstBound;
// 
//   ///\brief computes the number of columns in the grid
//   ///@param wid grid width in meters
//   ///@param res cells side size in meters
//   void compCol(Decimal wid, Decimal res);
//   
//   ///\brief computes the number of rows in the grid
//   ///@param hei grid height in meters
//   ///@param res cells side size in meters
//   void compRow(Decimal hei, Decimal res);
// 
//   ///\brief update the matricial rapresentation of the grid
//   ///@param lsr Local Safe Region
//   void updateBoard(LSR lsr);
// 
//   ///\brief finds the appartenence cone of a cell
//   void findCone();
// 
//   ///\brief
//   void mountLSR(LSR, Cell);
//   
//   ///\brief updates local frontier and sets properly cells' flags
//   void updateFrontier(Frontier front);//FIXME
//   
//   ///\brief finds the Local Reachable Region and sets properly cells' flags
//   void findLRR();
//   
//   ///\brief
//   void evaluateCell(LSR, Cell);
// 
//   ///\brief
//   Decimal compDistLSRBound(Decimal d, LSR lsr);
//   
//   ///\brief returns the cell selected by its indeces
//   Cell selectCell (IndexPoint);
//   
// //   void setLSRcells(int);
// //   void setFrontierCells(int);
// //   void setLRRcells(int);
// 
//   
// 
//  public:
//   ///default constructor
//   LocalGrid();
//   
//   ///destructor
//   ~LocalGrid();
//   
//   void printGrid();
// /***************************************************************************************************
// ***********************************        SET FUNCTIONS         ***********************************
// ***************************************************************************************************/
//   ///\brief sets board's resolution (equal to cell side size)
//   ///@param value board's resolution to set
//   void setResolution(int value){
//    _resolution=value;
//   }
//   
//   ///\brief sets board's width
//   ///@param value board's width to set
//   void setWidth(int value){
//    _width=value;
//   }
//   
//   ///\brief sets board's height
//   ///@param value board's height to set
//   void setHeight(int value){
//    _height=value;
//   }
// 
//   ///\brief sets board's columns
//   ///@param value board's columns to set
//   void setColumns(int value){
//    _columns=value;
//   }
//   
//   ///\brief sets board's rows
//   ///@param value board's rows to set
//   void setRows(int value){
//    _rows=value;
//   }
//   
//   ///\brief sets board's center
//   ///@param value board's center to set
//   void setCenter(Position value){
//    _center=value;
//   }
//   
//   ///\brief sets board's lowCorner
//   ///@param value board's lowCorner to set
//   void setLowCorner(Position value){
//    _lowCorner=value;
//   }
//   
//   ///\brief sets _firstUpdate flag
//   void setFirstUpdate(){
//    _firstUpdate=true;
//   }
//   
//   ///\brief sets _firstBound flag
//   void setFirstBound(){
//    _firstBound=true;
//   }
//   
//   ///\brief unsets _firstUpdate flag
//   void unsetFirstUpdate(){
//    _firstUpdate=false;
//   }
//   
//   ///\brief unsets _firstBound flag
//   void unsetFirstBound(){
//    _firstBound=false;
//   }
// /***************************************************************************************************
// ***********************************        GET FUNCTIONS         ***********************************
// ***************************************************************************************************/
//   ///\brief return board's resolution (equal to cell side size)
//   int resolution(){
//    return _resolution;
//   }
//   
//   ///\brief return board's width
//   ///@param value board's width to set
//   int width(){
//    return _width;
//   }
//   
//   ///\brief return board's height
//   ///@param value board's height to set
//   int height(){
//    return _height;
//   }
// 
//   ///\brief return board's columns
//   ///@param value board's columns to set
//   int columns(){
//    return _columns;
//   }
//   
//   ///\brief return board's rows
//   ///@param value board's rows to set
//   int rows(){
//    return _rows;
//   }
//   
//   ///\brief return center cell coordinates
//   Position center(){
//    return _center;
//   }
//   
//   ///\brief return lower left cell coordinates
//   Position lowCorner(){
//    return _lowCorner;
//   }
//   
//   ///\brief return _firstUpdate flag
//   bool firstUpdate(){
//    return _firstUpdate;
//   }
//   
//   ///\brief return _firstBound flag
//   bool firstBound(){
//    return _firstBound;
//   }
// };


// class LRR{
//  private:
// 
//   LRR();
//   vector<Cell*> lrr;
// 
//   void inizializeLRR ();
//   void resetLRR();
// 
//   void insertCell (Position);
//   void deleteCell (Position);
// 
//   void printLRR (); /**<prints LSR on a file*/
// };

// class FrontierArc{
//  private:
// 
//   vector<Cell*> arc;
//   
// //   IndexPoint startCell;
// //   IndexPoint endCell;
// //   Position meanCell;
//   /**< number of cells of the arc */
// 
//   int i;
// 
//  public:
//   
//   FrontierArc();
//   ~FrontierArc();
// 
//   int size(void);
//   Cell* first(void);
//   Cell* next(void);
//   void append(Cell* cell);
//   void cancel(Cell*, int pos);
// };

// class FrontierArc : vector<Cell*> {
//   int i;
// 
//  public:
//   
//   Cell* next(void);
//   void cancel(Cell*, int pos);
// };



// class Frontier{
//  private:
// 
//   vector<FrontierArc*> frontier;
//   bool first;
//   int frontierSize(void);
//   void update(LSR);
//   void clusterize();
// };



// #endif