GeoData.hpp

#ifndef LGL_GEODATA_HPP
#define LGL_GEODATA_HPP

#include <list>
#include <vector>
#include <iostream>
#include <fstream>
#include <string>

#include <gdal_priv.h>
//#include <cpl_string.h>
#include <ogr_spatialref.h>

#include <lgl/RasterBand.hpp>
#include <lgl/InfoBand.hpp>
#include <lgl/LandmarkBand.hpp>
#include <lgl/Attributes.hpp>


namespace jafar {
  namespace lgl {
   

    // the index of raster bands inside the data set 
    typedef enum {GEODATA_TFLAT_BAND=1,
                  GEODATA_TROUGH_BAND,
                  GEODATA_TRICLASSOBST_BAND,
                  GEODATA_LANDMARK_BAND,
            GEODATA_VISIBILITY_BAND,
            GEODATA_VISIBILITY_HEIGHT_BAND,
                  GEODATA_NMAX_BAND} GEODATA_BAND;

    typedef enum {ENTROPY_MAP=0,
                  POTENTIAL_MAP,
                  UTILITY_MAP} GEODATA_INTERNAL_MAP;

    class GeoData : public Raster
    { /*{{{*/ 
      public:

        static const double DEFAULT_DATA_VALUE() { return -1.0; };
        static const double GEODATA_DEFAULT_SCALE() { return 1.0; };
      
        //enum FUSION_METHOD // defined in RasterBand.hpp

        
        GeoData();

        GeoData(const std::string& _dsfilename, FUSION_METHOD _fmethod=MEAN);

        GeoData(int _xsize, int _ysize, double* _bufferedData, FUSION_METHOD _fmethod=MEAN);

        ~GeoData();

        bool loadBand(GEODATA_BAND band, const std::string& _dsfilename);
        bool loadInfoBand(const std::string& _dsfilename, GEODATA_BAND aband);
        bool loadLandmarkBand(const std::string& _dsfilename);

        int isInVirtualMemory;

        double* mapPotential;

        double* mapH;

        double* mapUtility;
        //------------------- getters

        GDALDataset* getDataset() const;

        void getAffineTransform(double& _utmXRoot, double& _utmYRoot, double& _cellXRes, double& _cellYRes); 

        int getxroot() const;
        int getyroot() const;
        int getxsize() const;
        int getysize() const;

        double getScale() const;

        double geoxroot() const;
        double geoyroot() const;
        double geoxend() const;
        double geoyend() const;
        double geoxres() const;
        double geoyres() const;

        double getValueFromBand(GEODATA_BAND _aband, int index);

        double getValueFromBand(GEODATA_BAND _aband, int xindex, int yindex);

        // get the value atr given raster cell (x,y)
        double getData(GEODATA_BAND band, const RasterCellIndex& cell) const;

        // fusion
        double getData(const RasterCellIndex& cell) const;
        
        // get the fusion value of all bands at cluster rect
        double getData(const RasterRect& rect) const;
        double getData(GEODATA_BAND band, const RasterRect& rect) const;
        
        GDRasterBand<double>* getBand(GEODATA_BAND band);
        
        double getInterpolatedValue(GEODATA_BAND _aband, double xNavLoc, double yNavLoc);
        //-------------- setters

        void setScale(double _scale);

        void setValueInBand(GEODATA_BAND _aband, int _index, double _val);

        void setFusingMethod(FUSION_METHOD _fmethod);

        //void setGeoTransform(double _utmXRoot, double _utmYRoot, double _cellXRes, double _cellYRes); 
        bool setData(double* bufferedData, double* bufferedOther, int _xsize, int _ysize, int _band = GEODATA_TFLAT_BAND);

        bool setData(int at_i, int at_j, Attributes inatt, bool internalTransfer=true);

        void setDecompositionLimit(double _dl);

        void setDecompositionType(HOMOGENEOUS_TYPE ht_);

        void setProbabilityLag(double probaLag_);

        void setSigmaFactor(double sigmaF_);

        void setSimulationProbaVisionLimit(double spvl_);

        //-------------- testers
        bool isHomogeneous(const RasterRect& rect) const;

        // same value at all bands
        bool sameValue(const RasterRect& rect);
        // same value at given band
        bool sameValue(GEODATA_BAND band, const RasterRect& rect);

        bool overlaps(GeoData* _toMerge);

        //---------------- smarters

        bool mergeStrict(GeoData* _toMerge, GEODATA_BAND _aband);

        void addDataset(GDALDataset *_dataset);

        void fuseData(GeoData *_geodata2, GEODATA_BAND _aband, const RasterRect& innerRect, const RasterRect& fusingRect);
        
        double calculateBandHomogeneityPercentage(GEODATA_BAND _aband);

        void printInfo(bool verbose = true) const;

        bool saveData(const std::string& outfile, const char* wFormat="GTIFF");

        void bufferToMem();

        void memToBuffer();

        bool saveTraversability(const std::string& outfile);

        void resetBands();

        bool createNewInfoBand(GDInfoBand** thatNewBand);

        bool initUtility();

        bool setMap(GEODATA_INTERNAL_MAP map2set,double v1_, int x1_, int y1_, double v2_, int x2_, int y2_);

        bool buildUtility();

        void resetUtility();

        bool saveUtility(const std::string& outfile);
        bool saveEntropy(const std::string& outfile);
        bool savePotential(const std::string& outfile);

        double euclideanDistance(double, double, double, double);

        bool setUTMProjection(GDALDataset* inputDataset, int utmZone);

        double getFootPrintEntropy(int, int);

        HOMOGENEOUS_TYPE getTraversabilityHomogeneousType();
        HOMOGENEOUS_TYPE getRoughHomogeneousType();
        double getTraversabilityProbabilityLag();
        double getRoughProbabilityLag();
        double getTraversabilitySigmaFactor();
        double getRoughSigmaFactor();
        double getSimulationProbaVisionLimit();


        bool isVisionTransparent(int atx, int aty, int atz=0);

        bool loadVisibility ( const std::string& _visibilityFileName );

      private:

        double decompositionLimit;

        std::string dsfilename;

        GDALDataset* dataset;   

        double refGeoTransform[6];

        CPLErr refGeoTransformRType;

        //------------- GDRasterBand s -------------//

        //GDRasterBand<double>* mainBand;

        GDInfoBand* traversabilityBand;
        GDLandmarkBand* landmarkBand;
        GDInfoBand* roughTerrainBand;
        GDInfoBand* visibilityBand;
        GDInfoBand* visibilityHeightBand;

        FUSION_METHOD fmethod;

        double simulationProbaVisionLimit;

        void info(std::ostream& info, bool verbose = true) const;
            
        friend std::ostream& operator<< (std::ostream& out, const GeoData& gd);

        bool loadData(const std::string& _dsfilename, GDALDataset* _useThisDataset=NULL);

        bool loadVisibilityData(const std::string& _visibilityFileName, GDALDataset* _useThisDataset);

        // Friendly class
        friend class NavGraph;
        friend class PositionMap;
        friend class Decomp; 

    }; /*}}} end of class GeoData*/

    inline std::ostream& operator<< (std::ostream& out, const GeoData& gd) {
      gd.info(out,true);
      return out;
    }
  } // namespace lgl
} // namespace jafar

#endif /* LGL_GEODATA_HPP */