Raster.hpp

Go to the documentation of this file.

#ifndef LGL_RASTER_HPP
#define LGL_RASTER_HPP

#include <iostream>
#include <algorithm>


namespace jafar {
  namespace lgl {
 
    struct RasterPoint {
      int x; 
      int y;

      RasterPoint():x(0),y(0) {}
      RasterPoint(int _x,int _y):x(_x),y(_y) {}

      void set(int _x, int _y) {x=_x;y=_y;}

      bool operator==(const  RasterPoint &rhs) const
      {
        return (x == rhs.x) && (y == rhs.y);
      }  

      bool operator!=(const  RasterPoint &rhs) const
      {
        return (x != rhs.x) || (y != rhs.y);
      }  

    };

    struct RasterCellIndex {

      int i; 
      int j;

      RasterCellIndex():i(0),j(0) {}
      RasterCellIndex(int _i,int _j):i(_i),j(_j) {}

      void set(int _i, int _j) {i=_i;j=_j;}

      bool operator==(const  RasterCellIndex &rhs) const
      {
        return (i == rhs.i) && (j == rhs.j);
      }  

      bool operator!=(const  RasterCellIndex &rhs) const
      {
        return (i != rhs.i) || (j != rhs.j);
      }  

    };

    std::ostream& operator<< (std::ostream& out, const RasterCellIndex& cell);

    class RasterRect { /* {{{ */
      public:

        RasterRect();
        RasterRect( int _xroot, int _yroot, int _xsize, int _ysize );

        bool  isValid() const;

        int &rLeft();
        int &rTop();
        int &rRight();
        int &rBottom();

        // Next functions do the same as left() top() right() and bottom()
        int   xroot()const;
        int   yroot()const;
        int   xend()const;
        int   yend()const;

        void   setXTopLeft( int pos );
        void   setYTopLeft( int pos );
        void   setXBottomRight( int pos );
        void   setYBottomRight( int pos );
        void   setX( int x );
        void   setY( int y );

        RasterPoint topLeft() const;
        RasterPoint bottomRight() const;
        RasterPoint topRight() const;
        RasterPoint bottomLeft() const;
        RasterPoint center() const;

        void rect( int& _xtopleft, int& _ytopleft, int& _xsize, int& _ysize ) const;
        void coords( int& xtopleft, int& ytopleft, int& xbottomright, int& ybottomright ) const;

        void setRect( int x, int y, int w, int h );
        void setCoords( int xtopleft, int ytopleft, int xbottomright, int ybottomright );

        int size()const;

        int xsize() const { return xpsize; }

        int ysize() const { return ypsize; }

        RasterRect&  operator=(const RasterRect &rect);

        bool contains( const RasterCellIndex& cell, bool inside=true) const;

        bool contains( const RasterRect &r, bool inside=true ) const;

        bool intersects( const RasterRect &r, RasterRect &result ) const;

        friend bool operator==( const RasterRect &, const RasterRect & );
        friend bool operator!=( const RasterRect &, const RasterRect & );
        friend std::ostream& operator<<(std::ostream&, const RasterRect &);
          
        int xtopleft;
        int ytopleft;
        int xbottomright;
        int ybottomright;

        int xpsize;
        int ypsize;

    }; /* }}} */

    bool operator==( const RasterRect &, const RasterRect & );
    bool operator!=( const RasterRect &, const RasterRect & );

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

        enum CLUSTERING_FUNCTION {CF_EQUALITY, CF_STD_DEV};

        Raster(CLUSTERING_FUNCTION cf=CF_EQUALITY):
          clusteringF(cf)
        {}

        virtual ~Raster() {}

        void setClusteringF(CLUSTERING_FUNCTION cf);
        CLUSTERING_FUNCTION getClusteringF();

        void setClusteringThres(double _cfthreshold);
        double getClusteringThres();

        RasterRect getRasterRect() const;

        bool inside(const RasterRect& rect);

        bool validIndex(const RasterCellIndex& index) const;

        /* do not forget =0 in virtual method */
        /****
        virtual int getxroot() const = 0;
        virtual int getyroot() const = 0;
        virtual int getysize() const = 0;
        virtual int getxsize() const = 0;

        // get the scale of the raster 
        virtual double getScale() const=0;
        virtual void setScale(double _scale)=0;
        *****/

        //virtual bool isHomogeneous(const RasterRect& rect) const = 0;   

      protected:

        CLUSTERING_FUNCTION clusteringF;
        double  cfthreshold;

        int xroot;
        int yroot;
        int xsize;
        int ysize;



    }; /*}}}*/
  }
}

#endif /* LGL_RASTER_HPP */