Decomp.hpp

Go to the documentation of this file.

#ifndef LGL_DECOMPOSITION_HPP
#define LGL_DECOMPOSITION_HPP

#include <vector>

#include <lgl/FlexGrid.hpp>
#include <lgl/Location.hpp>
#include <lgl/GeoData.hpp>
#include <lgl/Attributes.hpp>

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


    //typedef struct DecompCluster {
    class DecompCluster { //{{{
      private:
        GeoData* raster;
        Attributes* att;
      public:
        int xsize;
        int ysize;
        
        DecompCluster(GeoData* _rast=NULL);

        DecompCluster(int _xsize,int _ysize, GeoData* _rast=NULL, int tlx=-1, int tly=-1);
          
        ~DecompCluster();
          
        void set(int _xsize, int _ysize) {
          xsize=_xsize;
          ysize=_ysize;
        }
        
        bool valid() { return ((xsize != 0) && (ysize != 0)); }
        
        bool isNegative() { return ((xsize < 0) && (ysize < 0)); }

        bool operator==(const  DecompCluster &rhs) const;

        DecompCluster& operator=(const DecompCluster& rdc);

        //==================== Attributes
        Attributes* getAttributes()
        {//{{{
          return att;
        }//}}}

                bool hasBeenSet(attributeKey at_)
                { //{{{
          if (att == NULL) { return false; }
                    return att->hasbeenset[at_];
                } //}}}

                bool setCertainty(attributeKey at_, double value_, bool reset_=true)
                { //{{{
          if (att == NULL) { return false; }
                    att->set(at_, value_, reset_);
          return true;
                } //}}}

                double getEntropy(attributeClass _ac) const
                { //{{{
          if (att == NULL) { return -1.0; }
                    return att->infotropy[_ac];
                } //}}}

                double getCertainty(attributeKey _at) const
                { //{{{
          if (att == NULL) { return -1.0; }
                    return att->certainty[_at];
                } //}}}


    //} DecompCluster;
    }; //}}}

    class Decomp {

      public:
          
        typedef FlexGrid<DecompCluster*> DecompT;

        enum SIDE { CLUSTER_TOP_SIDE, CLUSTER_RIGHT_SIDE, CLUSTER_BOTTOM_SIDE, CLUSTER_LEFT_SIDE };
          
        Decomp(GeoData* _raster);

        ~Decomp();

        int xbegin() const;
        int ybegin() const;
        int xend() const;
        int yend() const;
        int xsize() const;
        int ysize() const;

        int getNbClusters() const;

        DecompCluster* at(int i, int j);

        bool setCluster(const RasterRect& rect);
        bool setLeafCluster(const RasterRect& rect);
          
        // set the uniform cluster for the raster
        // rect.xsize must be divisible by raster.xsize rect.ysize must be divisible by raster.ysize
        bool setUniformClusters(const RasterRect& rect);
          
        bool getInOutPoints(const RasterCellIndex& root_cell, std::vector<NavLocation>& inout) const;

        bool consistancyCheck() const;
          
      private :
          
        // the raster ..
        GeoData* raster;
          
        DecompT decomp;

        bool clearCluster(const RasterRect& rect);

        bool clear();
            
        friend class Decomp_iterator;
        friend class NavGraph;
          
    };

    std::ostream& operator<<(std::ostream& out, const Decomp& decomp);

    class Decomp_iterator 
    {
      private:
        Decomp* data;
        int i,j;
          

        void increment();
        void incrementNextCluster();

      public:
        Decomp_iterator(const Decomp* _data);

        Decomp_iterator(const Decomp_iterator& _it);

        void begin();
          
        bool at_end() const;
        bool at_begin() const;

        // return the value for the iterator
        DecompCluster* operator*() const;
          
        // prefix increment the iterator pointer to the next cluster
        Decomp_iterator& operator++();

        // postfix increment the iterator pointer to the next cluster
        Decomp_iterator operator++(int);

        void getIndex(int& _i, int& _j) const;

    };


  }
}

#endif /* LGL_DECOMPOSITION_HPP */