VisibilityMap.hpp

Go to the documentation of this file.

#ifndef LGL_VISIBILITYMAP_HPP
#define LGL_VISIBILITYMAP_HPP

#include <lgl/GeoData.hpp>
#include <lgl/VisibleArea.hpp>

#include <vector>
#include <set>
#include <map>

#ifndef DEFAULT_VIEW_LENGTH
#define DEFAULT_VIEW_LENGTH 10.0 // in term of "pixel" (in GEODATA_VISIBILITY_(HEIGHT_)BAND resolution)
#endif

// NB : Note on the scale
//    in the bitmap, a value is between 0 and 255
//    in geodata, a value is between 0 and 1
//    In both case, maximal value (255 and 1) is = MAX_HEIGHT (here, DEFAULT_MAX_HEIGHT) 
#ifndef DEFAULT_SENSORS_HEIGHT
#define DEFAULT_SENSORS_HEIGHT 1.0 // meter(s)
#endif

#ifndef DEFAULT_MAX_HEIGHT
#define DEFAULT_MAX_HEIGHT 5.0 // meters
#endif

// a cell must have a minimal visibility value
// (remind you that 0 < visibility_value < 1 in geodata VISIBILITY_Band
#ifndef MIN_VISIBILITY_VALUE
#define MIN_VISIBILITY_VALUE 0.3
#endif

#ifndef PI
#define PI 3.14159265
#endif

// NOTA BENE :
// this class compute visibility over a bitmap map
// BUT this uses discrete cells (of course) and discrete rays (line of view ; not a disk)
// so there may be some special case with few odd results
// (as a non visible cell surrounded by visible cells, 
// or a ligne a visible cells surronded by non-visible cells)
//
// This cannot be avoid by now, though it could be limited by increasing
// the resolution (size of cells and number of rays).
// But beware of computation and memory ressources needed...
//
// The problem of continuity could probably be handled through Morphology.
// But it has not been implemented yet... (TODO)
//
// Cyril Robin - may 2011

namespace jafar { //namespace jafar
  namespace lgl { //namespace lgl

    class CellRay {
      public :
        unsigned int id;
        double dist;

        CellRay(){}

        CellRay(int _id, double _dist ) :
            id(_id),
            dist(_dist)
        {}

        ~CellRay(){}  
    } ; 

    class PatternPoint {
      public :
        int x;
        int y;
        std::vector< CellRay > rays ; // rays number (first) and related distance (second)

        PatternPoint(){}

        PatternPoint(int _x, int _y, std::vector<CellRay > _rays ) :
            x(_x),
            y(_y),
            rays(_rays)
        {}

        ~PatternPoint(){} 
    } ;


    class VisibilityMap {
      private :

        // Input Data
        GeoData * pt_Geodata;           // Pointer for the currently used geodata.

        int viewLength ;            // Max length for the field of view (pixels)

        double sensorsHeight ;          // Height of the sensors ; impact the visibility
        
        int maxHeight ;             // Maximal Height in the map
                            // such that 255 in the bitmap (=1 in Geodata) = maxHeight in reality
            
        // size of environment
        unsigned long int xsize ; // 2N+1 : vertices
        unsigned long int ysize ; // 2N+1 : vertices

        // visibleArea matrix
        std::vector<VisibleArea> visibilityMap; 
        
        // Pattern for visibility computing
        std::vector<PatternPoint> currentPattern ;

        // visibleArea matrix for computation "on demand"
        std::vector< std::pair<bool, VisibleArea> > od_visibilityMap; 
        
        // number of rays use for visibility computing
        int n ;

        // angular step between rays
        double alpha ;

        void computePattern(); 

        void findVisibleCells(const int i, const int j, std::vector<RasterCellIndex> &cellList, std::vector<double> &raysRatio ); 

        PatternPoint computeCurrentPoint(const int i, const int j);

        double computeAngle( const int i, const int j);
        
        double computeDistance( const int i1, const int j1,
                    const int i2, const int j2,
                    const int i3, const int j3,
                    const double a3, 
                    const int r
                    );
        
        bool findIntersection( double &x, double &y, const int i1, const int j1, const int i2, const int j2, const double angle);


      public:

        VisibilityMap() :   pt_Geodata (NULL),
                  viewLength (DEFAULT_VIEW_LENGTH),
                  sensorsHeight ( (DEFAULT_SENSORS_HEIGHT  * 255 ) / DEFAULT_MAX_HEIGHT),
                  maxHeight(DEFAULT_MAX_HEIGHT),
                  xsize(0),
                  ysize(0)
        {
          visibilityMap.clear() ;

          od_visibilityMap.clear();
        }


        VisibilityMap(  GeoData * _pt_Geodata = NULL,
              int _viewLength = DEFAULT_VIEW_LENGTH,
              double _sensorsHeight = DEFAULT_SENSORS_HEIGHT,
              int _maxHeight = DEFAULT_MAX_HEIGHT
               );

        ~VisibilityMap();

        bool computeWholeVisibility() ; 

        bool clearVisibility() ;  

        bool computePartialVisibility(std::map<Cell_ID,VisibleArea> &partialVisibilityMap, const std::set<Cell_ID> &cellSet) ;  

        bool computeVisibilityOnDemand(std::map<Cell_ID,VisibleArea> &partialVisibilityMap, const std::set<Cell_ID> &cellSet) ; 
        
        /* idem as above, with pointers */
        bool computeVisibilityOnDemand(std::map<Cell_ID,const VisibleArea*> &partialVisibilityMap, const std::set<Cell_ID> &cellSet) ;  

        /* Return a copy of the visible Area of the node (i,j)
         */
        VisibleArea getVisibility(int i, int j) const ;

        /* idem as above, with pointers */
        const VisibleArea* getPtVisibility(int i, int j) const ;

        /* idem as above, with pointers, but use the "On Demand" features 
         * (ie compute the visibility if it has not been pre-computed already) 
         * BEWARE : this is NOT a const function !
         */
        const VisibleArea* getPtVisibilityOnDemand(Cell_ID cell) ;

        /* get the visibility for a set of position, using visibilityMap
         * NB: if visibilityMap has not been computed yet, compute visibilityMap.
         */
        bool getPrecomputedVisibility(std::map<Cell_ID,VisibleArea> &partialVisibilityMap, const std::set<Cell_ID> &cellSet) ;  

        /* idem as above, with pointers */
        bool getPrecomputedVisibility(std::map<Cell_ID, const VisibleArea*> &partialVisibilityMap, const std::set<Cell_ID> &cellSet) ;  

        /* tell is a cell is visible or not  (ie if its VISIBILITY_BAND value is above the MIN_VALUE*/
        bool isVisible(const Cell_ID cell) const;

        int getxsize() const;
        int getysize() const;

        int getviewLength() const;

        int getn() const;
        double getalpha() const;
          
    }; 

//    std::ostream& operator<<(std::ostream& out, const VisibilityMap &_visibilityMap);
  
  } // end of namespace lgl
} // end of namespace jafar

#endif /* LGL_VISIBILITYMAP_HPP */