GeoData.hpp

#ifndef GRAMER_GEODATA_HPP
#define GRAMER_GEODATA_HPP

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

#include <boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>

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

#include <gramer/Attributes.hpp>

#define MAX_NUMBER_OF_BANDDEFINITIONS 4
#define MAX_NUMBER_OF_BANDCONDITIONS  4


        //void bufferToMem();
        //void memToBuffer();
        
        //HOMOGENEOUS_TYPE getTraversabilityHomogeneousType();

        //HOMOGENEOUS_TYPE getRoughHomogeneousType();

        //bool createNewInfoBand(GDInfoBand** thatNewBand);

        //bool buildUtility();
        //void resetUtility();

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

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

        // same value at all bands
        //bool sameValue(const RasterCell& rect);

        //bool sameValue(GEODATA_BAND band, const RasterCell& rect);

        //double getFootPrintEntropy(int, int);

        //double calculateBandHomogeneityPercentage(BandDefinition _aband);

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


namespace jafar {
  namespace gramer {
   

    typedef enum {  FUSION_OVERWRITE=0,
            FUSION_MEAN
          } FUSION_METHOD;

    typedef enum {  HT_NONE=-1,
            HT_SIMPLE,
            HT_NEARLY,
            HT_SIGMA
          } HOMOGENEOUS_TYPE;
      
    static const std::string prefixedBandDefinitions[MAX_NUMBER_OF_BANDDEFINITIONS] =
    { "TRA", "VIS", "LOC", "COM" };

    static const std::string prefixedBandConditions[MAX_NUMBER_OF_BANDCONDITIONS] =
    { "AIR", "GROUND", "SURFACE", "UNDERWATER"};

    // To define points and rectangular areas
    typedef struct RasterCell {
      // Coordinate calculated buffer
      int x; 
      int y; 
      // Size in pixels
      int xsize;
      int ysize;
      RasterCell()
      {
        x = 0;
        y = 0;
        xsize = 0;
        ysize = 0;
      }

      RasterCell(int x_, int y_, int xs_=1, int ys_=1)
      {
        x = x_;
        y = y_;
        xsize = xs_;
        ysize = ys_;
      }

      // - Geographical information depends on the data Band
      // - Resolution depends on the data band
    } RasterCell;

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

        static const double DEFAULT_DATA_VALUE() { return -1.0; };

        static const double GEODATA_DEFAULT_SCALE() { return 1.0; };
      
        typedef struct BandDefinition {
          std::string confFileSource;
          std::string sourceFile;
          std::string name;
          int bandNumber;
          std::string geoUtmZone;
          float geoRefX;
          float geoRefY;
          float geoRefZ;
          float geoPixelSizeX;
          float geoPixelSizeY;
          float geoPixelSizeZ;
          std::vector<std::string> otherInfo;
        } BandDefinition;
        
        GeoData();

        GeoData(const std::string& _conffilename, FUSION_METHOD _fmethod=FUSION_MEAN);

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

        ~GeoData();

        bool loadBand(BandDefinition band, const std::string& _dsfilename);

        bool loadConfigurationFile(const std::string& conffile);

        int isInVirtualMemory;

        //------------------- getters

        GDALDataset* getDataset() const;

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

        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 getSigmaFactor();

        double getProbabilityLag();

        // TODO
        //double getValueFromBand(BandDefinition _aband, int index);

        bool getValueFromBand(BandDefinition _aband, int xindex, int yindex, double& readValue);

        // get the fusion value of all bands at given cell
        double getData(const RasterCell& rect) const;

        // get the band value at given cell
        double getData(const BandDefinition& bandDef, const RasterCell& rect) const;
        
        // TODO
        //GDRasterBand<double>* getBand(BandDefinition band);
        
        // TODO
        //double getInterpolatedValue(GEODATA_BAND _aband, double xNavLoc, double yNavLoc);

        //-------------- setters

        void setScale(double _scale);

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

        void setFusingMethod(FUSION_METHOD _fmethod);

        //void setGeoTransform(double _utmXRoot, double _utmYRoot, double _cellXRes, double _cellYRes); 
        // TODO reimplement

        // TODO
        // 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 RasterCell& rect) const;


        bool overlaps(GeoData* _toMerge);

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

        bool loadData(const std::string& _dsfilename);

        bool setBandTag(int iband, BandDefinition& bandDef);

        bool addBandToDataset(BandDefinition& inputinfo);

        void addDataset(GDALDataset *_dataset);

        //bool mergeStrict(GeoData* _toMerge, GEODATA_BAND _aband);

        //void fuseData(GeoData *_geodata2, GEODATA_BAND _aband, const RasterCell& innerRect, const RasterCell& fusingRect);
        
        void printInfo(bool verbose = true) const;

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

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

        void resetBands();

        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);


// TODO
        //double getTraversabilityProbabilityLag();
        //double getRoughProbabilityLag();
        //double getTraversabilitySigmaFactor();
        //double getRoughSigmaFactor();
        double getSimulationProbaVisionLimit();


      private:

        std::string conffilename;

        std::string dsfilename;

        GDALDataset* dataset;   

        double refGeoTransform[6];

        CPLErr refGeoTransformRType;

        RasterCell rootCell;

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

        FUSION_METHOD fmethod;

        HOMOGENEOUS_TYPE htype;

        double decompositionLimit;

        double sigmaFactor;

        double probabilityLag;

        double simulationProbaVisionLimit;

        std::vector<BandDefinition> geoBands;

        //--------------- private functions -----------------//

        void info(std::ostream& info, bool verbose = true) const;

        friend std::ostream& operator<< (std::ostream& out, const GeoData& gd);

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

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

#endif /* GRAMER_GEODATA_HPP */