GeoMosaic.h

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.
 
    This file is part of the TerraLib - a Framework for building GIS enabled applications.
 
    TerraLib 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 3 of the License,
    or (at your option) any later version.
 
    TerraLib is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */
 
/*!
  \file terralib/rp/GeoMosaic.h
  \brief Create a mosaic from a set of geo-referenced rasters.
 */
 
#ifndef __TERRALIB_RP_INTERNAL_GEOMOSAIC_H
#define __TERRALIB_RP_INTERNAL_GEOMOSAIC_H
 
#include "Algorithm.h"
#include "FeedersRaster.h"
#include "Blender.h"
#include "../raster/Interpolator.h"
#include "../geometry/MultiPolygon.h"
#include "../sam/rtree/Index.h"
 
#include <vector>
#include <string>
#include <map>
#include <memory>
#include <utility>
#include <tuple>
 
namespace te
{
  namespace rp
  {
    class GeoComposition;
    
    /*!
      \class GeoMosaic
      \brief Create a mosaic from a set of geo-referenced rasters.
      \ingroup rp_mos
     */
    class TERPEXPORT GeoMosaic : public Algorithm
    {
      public:
        
        /*!
          \class InputParameters
          \brief GeoMosaic input parameters
         */        
        class TERPEXPORT InputParameters : public AlgorithmInputParameters
        {
          public:
            
            friend class GeoMosaic;
            friend class GeoComposition;
            
            /*! \enum EqType The mosaic equalization type.*/
            enum EqType
            {
              InvalidEqType = 0,  //!< Invalid equalization type.
              NoEqType = 1,       //!< No equalization performed.
              CenterEqType = 2,   //!< Mosaic will be equalized following the center raster.
              TargetEqtype = 3,   //!< Mosaic will be equalized following the supplied target means (m_mosaicTargetMeans) and std devs (m_mosaicTargetStdDevs).
              LocalEqType = 4,     //!< Mosaic will be equalized following a local strategy using adjacent rasters.
              OverLapEqType = 5   //!< Mosaic will be equalized following a local strategy using adjacent rasters.
            };            
            
            FeederConstRaster* m_feederRasterPtr; //!< Input rasters feeder.
            
            std::vector< std::vector< unsigned int > > m_inputRastersBands; //!< Bands to process for each input raster.
            
            te::rst::Interpolator::Method m_interpMethod; //!< The raster interpolator method (default:NearestNeighbor).
            
            double m_noDataValue; //!< The pixel value used where no raster data is avaliable (defaul:0).
            
            bool m_forceInputNoDataValue; //!< If true, m_noDataValue will be used as the no-data value for input rasters (defalt:false).
            
            te::rp::Blender::BlendMethod m_blendMethod; //!< The pixel blending method (default: NoBlendMethod).
            
            EqType m_equalizationType; //!< Equalization type (default:CenterEqType ).
            
            bool m_useRasterCache; //!< Enable(true) or disable the use of raster caching (default:true).
            
            bool m_enableProgress; //!< Enable/Disable the progress interface (default:false).
            
            bool m_enableMultiThread; //!< Enable/disable the use of threads (default:true).
            
            bool m_enableAutoValidAreaDetect; //!< Enable/disable the auto-detection of raster valid area pixels (this option allows better mosaic result for rasters with no-data pixels on borders. Default:true).
            
            std::vector< double > m_mosaicTargetMeans; //!< An empty vector for automatic mosaic target means calcule or a vector of target means for each mosaic baind.
            
            std::vector< double > m_mosaicTargetStdDevs; //!< An empty vector for automatic mosaic target standart deviation values calcule or a vector of target standart deviantion values for each mosaic baind.
            
            bool m_abortOnFirstError; //!< if true the processing will be stopped on the first error, if false the processing of the next rasters will continue on the event of an error (default: true).
            
            bool m_skipInsideRasters; //!< Rasters covering mosaic areas already covered by other rasters will be skipped (default: false).
 
            InputParameters();
            
            InputParameters( const InputParameters& );
            
            ~InputParameters();
            
            //overload
            void reset() _NOEXCEPT_OP(false);
            
            //overload
            const  InputParameters& operator=( const InputParameters& params );
            
            //overload
            AbstractParameters* clone() const;
 
            //overload
            bool serialize ( AlgorithmParametersSerializer& serializer ) const;
            
            /*!
              \brief Returns all current supported equalization type infos.
              \param eqTypesInfo current supported equalization type infos.
             */                    
            static void getEqTypesInfo( std::vector< std::pair< EqType, std::string > >& eqTypesInfo  );
            
          protected :
            
            BlenderRule const * m_blenderRulePtr;
        };
        
        /*!
          \class OutputParameters
          \brief GeoMosaic output parameters
         */        
        class TERPEXPORT OutputParameters : public AlgorithmOutputParameters
        {
          public:
            
            std::string m_rType; //!< Output raster data source type (as described in te::raster::RasterFactory ).
            
            std::map< std::string, std::string > m_rInfo; //!< The necessary information to create the output rasters (as described in te::raster::RasterFactory). 
            
            std::unique_ptr< te::rst::Raster > m_outputRasterPtr; //!< The generated output mosaic raster (A 1024x1024 blocked raster will be created if the choosen output driver supports blocking scheme).
            
            OutputParameters();
            
            OutputParameters( const OutputParameters& );
            
            ~OutputParameters();
            
            //overload
            void reset() _NOEXCEPT_OP(false);
            
            //overload
            const  OutputParameters& operator=( const OutputParameters& params );
            
            //overload
            AbstractParameters* clone() const;
        };        
 
        GeoMosaic();
        
        ~GeoMosaic();
       
        //overload
        bool execute( AlgorithmOutputParameters& outputParams ) _NOEXCEPT_OP(false);
        
        //overload
        void reset() _NOEXCEPT_OP(false);
        
        //overload
        bool initialize( const AlgorithmInputParameters& inputParams ) _NOEXCEPT_OP(false);
        
        // overload
        bool isInitialized() const;
 
      protected:
        
        /*!
          \typedef BlendedRasterInfosDataT Blended raster info type definition.
          \brief GeoMosaic output parameters
         */   
        typedef std::tuple< 
          std::shared_ptr< te::gm::MultiPolygon >,  // valid data area
          std::vector< double >,  // means
          std::vector< double > > // std devs
          BlendedRasterInfosDataT;
        
        /*!
          \typedef BlendedRastersInfosT Blended rasters info container type definition.
          \brief GeoMosaic output parameters
         */   
        typedef std::vector< BlendedRasterInfosDataT > BlendedRastersInfosT;
        
        GeoMosaic::InputParameters m_inputParameters; //!< Input execution parameters.
        
        bool m_isInitialized; //!< Tells if this instance is initialized.
        
        /*!
          \brief Calcule of raster statistics.
          \param inputRastersBands Input raster bands to use.
          \param validAreaDelimiterPolPtr A pointer to a valid geometry where the raster valid data is or a null pointer to processe the entire raster.
          \param rasterMeans Output means values
          \param rasterStdDevs Output standart deviation values
         */
        bool getRasterStats(
          const te::rst::Raster& inRaster,
          const std::vector< unsigned int >& inputRastersBands,
          te::gm::MultiPolygon const * const  validAreaDelimiterPolPtr,
          std::vector< double >& rasterMeans,
          std::vector< double >& rasterStdDevs ) const;
        
        /*!
          \brief Calcule of input raster equalization parameters.
          \param inputRastersBands Input raster bands to use.
          \param blendedRastersInfos Infos about rasters that already were blended into the mosaic.
          \param blendedRastersInfosTree A tree indexing blendedRastersInfos.
          \param validAreaDelimiterPolPtr A pointer (or a null pointer) to the current input raster valid data area.
          \param mosaicValidAreaDelimiterPolPtr A pointer (or a null pointer) to the current mosaic raster valid data area.
          \param rasterMeans InRaster calculated original means values.
          \param rasterStdDevs InRaster calculated original standart deviation values.
          \param offsets InRaster calculated offsets to mosaic.
          \param scales InRaster calculated scales to mosaic.
          \param newRasterMeans InRaster calculated new means values after merging into the mosaic.
          \param newRasterStdDevs InRaster calculated new standart deviation values after merging into the mosaic.
         */
        bool getEqualizationParams( 
          const te::rst::Raster& inRaster,
          const std::vector< unsigned int >& inputRastersBands,
          const BlendedRastersInfosT&  blendedRastersInfos,
          const te::sam::rtree::Index< std::size_t >& blendedRastersInfosTree,
          te::gm::MultiPolygon const * const  validAreaDelimiterPolPtr,
          const te::rst::Raster& mosaicRaster,
          te::gm::MultiPolygon const * const  mosaicValidAreaDelimiterPolPtr,
          std::vector< double >& rasterMeans,
          std::vector< double >& rasterStdDevs,
          std::vector< double >& offsets,
          std::vector< double >& scales,
          std::vector< double >& newRasterMeans,
          std::vector< double >& newRasterStdDevs ) const;
          
 
 
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif