E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeRasterParams.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_RASTERPARAMS_H
#define  __TERRALIB_INTERNAL_RASTERPARAMS_H

#include "TeProjection.h"
#include "TeBox.h"
#include "TeDataTypes.h"
#include "TeTime.h"

#include <string>
#include <list>
#include <vector>

using namespace std;

class TeDatabase;


class TL_DLL TeRasterParams
{
public:

  typedef std::pair< std::string, std::string > DecoderParamT;

           enum TeRasterInterLeavingMode
           {          
                      TePerPixel, // BIP - Band Interleaved by Pixel
                      TePerLine, // BIL - Band Interleaved by Line
                      TePerBand  // BSQ - Band Sequential
           };
           
           enum TeRasterPhotometricInterpretation
           { TeUnknown, TePallete, TeMultiBand, TeRGB };
           
           enum TeRasterStatus
           { TeNotReady, TeReadyToRead, TeReadyToWrite };

           enum TeRasterCompressionMode
           { TeNoCompression, TeZLib, TeJpeg, TeTiffCompression };
           
           enum TeRasterTilingType
           {  TeExpansible=1, TeNoExpansible=2 };
           

           TeRasterParams () :
                      nlines_(0),
                      ncols_(0),
                      resx_(1),
                      resy_(1),
                      swap_(false),
                      useDummy_(false),
                      mode_('r'),
                      status_(TeRasterParams::TeNotReady),
                      resolution_(1),
                      subBand_(0),
                      offset_(0),
                      tiling_type_(TeRasterParams::TeExpansible),
                      blockHeight_(0),
                      blockWidth_(0),
                      nTilesInMemory_(0),
                      blockId_(""),         
                      decoderIdentifier_(""),          
                      database_ (0),
                      layerId_(-1),
                      objectId_(""),
                      interleaving_(TeRasterParams::TePerPixel),
                      lutName_(""),
                      dxJ_(0.0),
                      dxI_(0.0),
                      dyJ_(0.0),
                      dyI_(0.0),
                      x0_(0.0),
                      y0_(0.0),
                      box_(TeBox()),
                      projection_(0)
           {
                      nbands_= 1;
                      nbitsperPixel_.resize(nbands_);
                      vmin_.resize(nbands_);
                      vmax_.resize(nbands_);
                      bands_.resize(nbands_);
                      bandName_.resize(nbands_);
                      photometric_.resize(nbands_);
                      dataType_.resize(nbands_);
                      dummy_.resize(nbands_);
                      compression_.resize(nbands_);
                      for (int i=0; i<nbands_; i++)
                      {
                                 bands_[i] = i;
                                 vmin_[i] = TeMAXFLOAT;
                                 vmax_[i] = -TeMAXFLOAT;
                                 dataType_[i] = TeUNSIGNEDCHAR;
                                 photometric_[i] = TeRasterParams::TeMultiBand;
                                 dummy_[i] = 255;
                      }
                      hasSetDummy_ = false;
           }

           TeRasterParams(const TeRasterParams& other);

           TeRasterParams& operator=(const TeRasterParams& rhs);

           virtual ~TeRasterParams()
           {
                      bands_.clear();
                      bandName_.clear();
                      vmin_.clear();
                      vmax_.clear();
                      if (!lutr_.empty())
                      {
                                 lutr_.clear();
                                 lutg_.clear();
                                 lutb_.clear();
                                 lutClassName_.clear();
                      }
                      photometric_.clear();
                      dataType_.clear();
                      dummy_.clear();
                      compression_.clear();
                      if (projection_)
                                 delete projection_;
                      hasSetDummy_ = false;
           }
           

           const TeBox& box() const
           { return box_; }

           TeBox boundingBox() const;

           /*
                      This methods recalculates the number of lines and columns and box accordingly to 
                      an input bounding box and X and Y resolutions
                      \param x1 bounding box lower left point X coordinate 
                      \param y1 bounding box lower left point Y coordinate 
                      \param x2 bounding box upper right point X coordinate
                      \param y2 bounding box upper right point Y coordinate
                      \param resx X resolution
                      \param resy Y resolution
                      \param lock corner of the bounding box that should be preserved
           */
           void boundingBoxResolution (double x1, double y1, double x2, double y2, 
                                            double resx, double resy, TeBox::TeBoxCorner lock = TeBox::TeUPPERLEFT);

           /*
                      This methods recalculates the resolutions and box accordingly to 
                      a given bounding box and number of lines and columns
                      \param x1 bounding box lower left point X coordinate 
                      \param y1 bounding box lower left point Y coordinate 
                      \param x2 bounding box upper right point X coordinate
                      \param y2 bounding box upper right point Y coordinate
                      \param nlines  number of lines
                      \param ncols number of columns
                      \param lock corner of the bounding box that should be preserved
           */
           void boundingBoxLinesColumns (double x1, double y1, double x2, double y2, 
                                                int nlines, int ncols, TeBox::TeBoxCorner lock = TeBox::TeUPPERLEFT);

           /*
                      This methods recalculates the number of lines and columns and box accordingly to 
                      a given box and X and Y resolutions
                      \param x1 box lower left point X coordinate 
                      \param y1 box lower left point Y coordinate 
                      \param x2 box upper right point X coordinate
                      \param y2 box upper right point Y coordinate
                      \param resx X resolution
                      \param resy Y resolution
                      \param lock corner of the bounding box that should be preserved
           */
           void boxResolution (double x1, double y1, double x2, double y2, 
                                      double resx, double resy, TeBox::TeBoxCorner lock = TeBox::TeUPPERLEFT);

           /*
                      This methods recalculates the resolutions and box accordingly to 
                      a given box and number of lines and columns
                      \param x1 box lower left point X coordinate 
                      \param y1 box lower left point Y coordinate 
                      \param x2 box upper right point X coordinate
                      \param y2 box upper right point Y coordinate
                      \param nlines  number of lines
                      \param ncols number of columns
                      \par Calculates X resolution and Y resolution 
                      \param lock corner of the bounding box that should be preserved
           */
           void boxLinesColumns (double x1, double y1, double x2, double y2, 
                                        int nlines, int ncols, TeBox::TeBoxCorner lock = TeBox::TeUPPERLEFT);

           /*
                      \param left lower left point X coordinate 
                      \param top  upper right point Y coordinate
                      \param resx X resolution
                      \param resy Y resolution
                      \param nlines  number of lines
                      \param ncols number of columns
                      \param coordIsCentrePixel flag to indicate that top left coordinate is centre of pixel
           */
           void topLeftResolutionSize (double left, double top, double resx, double resy, int ncol, int nlin, bool coordIsCentrePixel=true);
                      
           /*
                      \param left lower left point X coordinate 
                      \param lower lower left point Y coordinate
                      \param resx X resolution
                      \param resy Y resolution
                      \param nlines  number of lines
                      \param ncols number of columns
                      \param coordIsCentrePixel flag to indicate that top left coordinate is centre of pixel
           */
           void lowerLeftResolutionSize (double left, double lower, double resx, double resy, int ncol, int nlin, bool coordIsCentrePixel=true);

           /* 
                      Sets a valid bouding box, considering a resolution of 1x1 and
                      that the coordinate of the center of lower-left element is (0.5,0.5)
                      \param nlines  number of lines
                      \param ncols number of columns
           */
           void setNLinesNColumns(int nlines, int ncolumns);


           void resizeToTiling(TeBox& bb, int bWidth, int bHeight);

           /*
                      \param n number of bands
                      \note If the required number of bands is greater than the 
                      current number of bands, the last band characteristics 
                      will be copied to the new defined bands.
           */
           void nBands(int n);

           /*
                      \param proj a pointer to a terralib projection instance
                      A new instance of projection is created according to the parameters described by proj.
           */
           void projection(TeProjection* proj);

           TeProjection* projection()
           {          return projection_; }
           

           TeCoord2D coord2Index (const TeCoord2D& pt) const;

           TeCoord2D index2Coord (const TeCoord2D& pt) const;


           int nlines_;                                
           int ncols_;                                 

           double     resx_,                           
                      resy_;                           

           bool swap_;                                 
           bool useDummy_;                             
           char       mode_;                           
           TeRasterStatus        status_;   
           TeTime                           date_; 
           std::vector< DecoderParamT > decoderParams_; 
           
           vector<int>           nbitsperPixel_;                  
           vector<double>        vmin_;                           
           vector<double>        vmax_;                           
           vector<int>           bands_;                          
           vector<double>        dummy_;                          
           vector<string> bandName_;                   
           vector<TeRasterPhotometricInterpretation>   photometric_;         
           vector<TeRasterCompressionMode>  compression_;         
           vector<TeDataType>               dataType_; 

           /*
                      \param type the computational data type
                      \param band number of the band. Default: all bands 
           */
           void setDataType(TeDataType type, int band=-1);

           int elementSize(int band=0);

           /*
                      \param photom the photometric interpretation
                      \param band number of the band. Default: all bands 
           */
           void setPhotometric(TeRasterPhotometricInterpretation photom, int band=-1);

           /*
                      \param cmode the compression mode
                      \param band number of the band. Default: all bands 
           */
           void setCompressionMode(TeRasterCompressionMode cmode, int band=-1);

           /*
                      \param dummy dummy value
                      \param band number of the band. Default: all bands 
           */
           void setDummy(double dummy, int band=-1);

           /*
                      \param name band name
                      \param band number of the band. No default value
           */
           void setBandName(string name, int band);

           int resolution_;                 
           int subBand_;                               


           string     fileName_;            
           int offset_;                                

                      
           TeRasterTilingType    tiling_type_; 
           int blockHeight_;                
           int blockWidth_;                 
           int nTilesInMemory_;             
           string blockId_;                 


           string     decoderIdentifier_;   
           
           const string& decName() const 
           { return decoderIdentifier_; }
                      
           TeDatabase*           database_; 
           int                   layerId_;  
           string                objectId_; 


           TeRasterInterLeavingMode interleaving_;     

           string     lutName_;             
           vector<unsigned short> lutr_;    
           vector<unsigned short> lutg_;    
           vector<unsigned short> lutb_;    
           vector<string> lutClassName_;    

           const string& lutName() 
           { return lutName_; }

           double dxJ_;          
           double dxI_;          
           double dyJ_;          
           double dyI_;          
           double x0_;                      
           double y0_;                      

           void setNavigationParameters(const vector<double>& nwf);

           void getNavigationParameters(vector<double>& nwf);

           int nBands() const
           { return nbands_; }
           
           void writeParametersFile();
           
           void readParametersFile();

           string errorMessage_;
           
private:
           int        nbands_;              
           TeBox      box_;                            
           TeProjection* projection_;       
           bool hasSetDummy_;
};

#endif