E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeRaster.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright � 2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_RASTER_H
#define  __TERRALIB_INTERNAL_RASTER_H

#include "TeDecoder.h"
#include "TeDataTypes.h"
#include "TeCoord2D.h"
#include "TeAttribute.h"
#include "TeGeometry.h"
#include "TeGeometryAlgorithms.h"

class TeRasterTransform;

#include <map>

enum TeStrategicIterator
{          TeBoxPixelIn,                               
           TeBBoxPixelInters,               
           TeBoxPixelOut,                              
           TeBBoxPixelNotInters  
};

TL_DLL TeCoordPairVect applyStrategic(double& y, double ymin, double xmin, 
                                    TeStrategicIterator st, TeRaster* raster, const TePolygon& poly);

/*
           \par A Raster Geometry is made of a matrix of ncolumns x nlines elements
           with nBands dimension. Each element, or pixel, of the raster its is
           indexed by a column, line and band and has a double value associated.
           \par Each Raster geometry has a decoder associated to it. Its decoder 
           knows how to get return the value (as a double) of each pixel.
           \par All information about the data is stored in a TeRasterParams structure
           that is duplicated in its decoder.
           \sa TeDecoder TeRasterParams
*/
class TL_DLL TeRaster : public TeGeometry
{
           TeRasterParams  params_;         
           TeDecoder             *decoder_; 

public:

           TeRaster(const string& filename, const char& mode = 'r');


           TeRaster(TeRasterParams& pars);

           /*
                      This method creates a raste data in memory, using only the most basic
                      parameters:
                      \par ncols number of columns
                      \par nlines number of lines
                      \par nbands number of bands
                      \par elemType size of each element
           */
           TeRaster(int ncols, int nlines, int nbands, TeDataType elemType);

           TeRaster() : decoder_(0) {}

           ~TeRaster ();

  const TeRasterParams& params() const;

           TeRasterParams& params();
           
           int nBands();


           void updateParams(TeRasterParams& par);

           TeGeomRep elemType();


           void setDecoder(TeDecoder* dec);

           /*
                      \return true if raster is ready to be read or written and false otherwise
           */
           bool status();

           TeDecoder* decoder();

           TeProjection* projection(); 


           bool setElement (int col, int lin, double val, int band=0);


           bool getElement (int col, int lin, double& val, int band=0);

           /*
                      \param dstRaster destination raster
                      \param transf pixel evaluator to be used
                      \param bestRes flag to indicate that it should use the best resolution available
           */
           bool fillRaster (TeRaster* dstRaster, TeRasterTransform* transf=0, bool bestRes = true);


           bool init();


           bool init(TeRasterParams& pars);
  
           void clear();

           TeCoord2D index2Coord(TeCoord2D pt);

           TeCoord2D coord2Index(TeCoord2D pt);

           //----------------

           class TL_DLL iterator
           {
                      public:

                                 iterator(int c0=0, int l0=0, int nc=0, int nl=0, int nb=0, TeRaster* pt=0) : 
                                 linCurrent_(l0),
                                 colCurrent_(c0),
                                 nLines_(nl),
                                 nCols_(nc),
                                 nBands_(nb),
                                 raster_(pt)
                                 {}
                                 
                                 virtual ~iterator()
                                 {}

                                 virtual void moveForward();

                                 iterator& operator++();
                      
                                 iterator operator++(int);

                                 int currentLine();

                                 int currentColumn();

                                 int nBands(void);


                                 vector<double> operator*();
                                 
                                 double operator*(int band);

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

                                 bool operator!=(const iterator& rhs) const;

                      protected:
                                 int linCurrent_, colCurrent_;
                                 int nLines_, nCols_;
                                 int nBands_;
                                 TeRaster* raster_;
                      };   

           // ---------------------  End of class raster Iterator

           //----------------

           class TL_DLL iteratorPoly : public iterator
           {
                      public:

                                 iteratorPoly(int colCurr, int linCurr, int nc, int nl, int nb, TeRaster* pt, const TePolygon& poly,
                                                                   TeStrategicIterator str, double linMin=0.0, double linMax=0.0, double colMin=0.0, 
                                                                   double colMax=0.0, TeCoordPairVect seg=TeCoordPairVect(),  
                                                                   int posSeg=0, int nlInPoly=0, int nColsInPoly=0, bool e=true, double minLinCM=0.0, int band = 0):
                                            iterator(colCurr,linCurr,nc,nl,nb,pt),
                                            linMin_(linMin),
                                            linMax_(linMax),
                                            colMin_(colMin),
                                            colMax_(colMax),
                                            segments_(seg),
                                            posSegments_(posSeg),
                                            poly_(poly),
                                            end_(e),
                                            strategy_(str),
                                            nLinesInPoly_(nlInPoly),
                                            nColsInPoly_(nColsInPoly),
                                            linMinCM_(minLinCM),
                                            band_(band)
                                            {}
                                 
                                 iteratorPoly(TeRaster* raster = 0): 
                                            iterator(0,0,0,0,0,raster),
                                            linMin_(0.0),
                                            linMax_(0.0),
                                            colMin_(0.0), 
                                            colMax_(0.0),
                                            posSegments_(0),
                                            end_(true),
                                            nLinesInPoly_(0),
                                            nColsInPoly_(0),
                                            band_(0)
                                            {}

                                 virtual ~iteratorPoly() {}

                                 void moveForward();
                                 
                                 iteratorPoly& operator++();

                                 iteratorPoly operator++(int);


                                 double operator*(); 

                                 double operator*(int band);
                      

                                 bool getProperty(TeProperty& prop);

                                 bool end();

                                 int nLinesInPoly();

                                 int nColsInPoly();

                      private:

                                 void getNewSegment(int linCurr);

                                 double                                      linMin_, linMax_;  
                                 double                                      colMin_, colMax_;
                                 TeCoordPairVect                  segments_;
                                 int                                                    posSegments_;
                                 TePolygon                        poly_;
                                 bool                                        end_;
                                 TeStrategicIterator strategy_;
                                 int                                                    nLinesInPoly_, nColsInPoly_;
                                 double                                      linMinCM_; //minimal line in world coordinates 
                                 int                                                    band_;                // band restriction
           };

           iterator begin();


           iteratorPoly begin(const TePolygon& poly, TeStrategicIterator st, int band=0);

    iterator end() ;

           iteratorPoly end(const TePolygon& poly, TeStrategicIterator st, int band=0); 

           bool selectBlocks(TeBox& bb, int resFac, TeRasterParams& parBlock);

           int numberOfSelectedBlocks();

           bool fetchRasterBlock(TeDecoderMemory* memDec);

           void clearBlockSelection();

           /*
                      This method should be used only to set the values of images with 3 bands associated
                      respectively to the three colour channes Red, Green and Blue
                      \param col column of the image
                      \param lin line of the image
                      \param Rval the value associated to the band 0 (associated to the R colour Channel)
                      \param Gval the value associated to the band 1 (associated to the G colour Channel)
                      \param Bval the value associated to the band 2 (associated to the B colour Channel)
                      \param transp an optional transparency degree, with a range of 0 (totally transparent) to 255 (totally opaque)
                      \return true if if succeed and false otherwise
           */
           bool setElement(int col, int lin, double Rval, double Gval, double Bval, unsigned int /*transp*/ = 255);

           const string& errorMessage() const;
           
  private :
  
             TeRaster( const TeRaster& ) : TeGeometry()
             {}

             const TeRaster& operator=( const TeRaster& ) { return *this; }; 

};

inline const TeRasterParams& TeRaster::params() const
{ return params_; }
           
inline TeRasterParams& TeRaster::params()
{ return params_; }

inline int TeRaster::nBands()
{ return params_.nBands(); }

inline TeGeomRep TeRaster::elemType() 
{ return TeRASTER; }

inline bool TeRaster::status()
{          return params_.status_ != TeRasterParams::TeNotReady; }

inline TeDecoder* TeRaster::decoder()
{ return decoder_; }

inline TeProjection* TeRaster::projection() 
{ return params_.projection(); }

inline TeCoord2D TeRaster::index2Coord(TeCoord2D pt)
{ return decoder_->index2Coord(pt); }

inline TeCoord2D TeRaster::coord2Index(TeCoord2D pt)
{ return decoder_->coord2Index(pt); }

           
inline const string& TeRaster::errorMessage() const
{          return params_.errorMessage_; }

inline int TeRaster::iterator::currentLine()
{ return linCurrent_;}

inline int TeRaster::iterator::currentColumn()
{return colCurrent_; }

inline int TeRaster::iterator::nBands(void)
{          return nBands_; }

inline bool TeRaster::iteratorPoly::end()
{          return end_; }

inline int TeRaster::iteratorPoly::nLinesInPoly()
{ return nLinesInPoly_;}

inline int TeRaster::iteratorPoly::nColsInPoly()
{ return nColsInPoly_;}

TL_DLL TeRaster*
TeRasterClipping(TeRaster* whole, TePolygonSet& mask, TeProjection* geomProj, const string& clipName, double background, const string& decId="");


#endif