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.
            };            
            
            /*! \enum EqType The method used to define the rasters processing order.*/
            enum RasterSortingMethod
            {
              InvalidRSMethod = 0,  //!< Invalid method.
              FixedMosaicCenterSMethod = 1,       //!< A method based on the fixed global mosaic center.
              BlendedRCenterSMethod = 2   //!< A method based on a blended rasters dynamic center.
            };            
            
            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).
            
            RasterSortingMethod m_rasterOrdermethod; //!< The method used to define the rasters processing order.
 
            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 ProcessedRasterInfosDataT Processed raster info type definition.
         */   
        class ProcessedRasterInfosDataT
        {
          public:
            enum ProcStatus
            {
              Invalid = 0,
              NotProcessed = 1,
              UnderProcessing = 2,
              Skipped = 3,
              Blended = 4
            };                        
            
            ProcStatus m_procStatus;
            std::unique_ptr< te::gm::Polygon > m_bBoxPolPtr; // under mosaic SRID
            std::unique_ptr< te::gm::Polygon > m_validDataAreaPolPtr;
            std::unique_ptr< te::gm::MultiPolygon > m_validDataAreaMultiPolPtr;
            std::vector< double > m_bandsMeans;
            std::vector< double > m_bandsStdDevs;
            
            ProcessedRasterInfosDataT()
            : m_procStatus( Invalid )
              {};
        }; 
        
        /*!
          \typedef ProcessedRastersInfosT Processed rasters info container type definition.
          \note Key:raster index
         */   
        typedef std::vector< ProcessedRasterInfosDataT > ProcessedRastersInfosT;
        
        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 inRaster Input raster.
          \param inRasterIndex Input raster index.
          \param inputRastersBands Input raster bands to use.
          \param processedRastersInfos Current processed rasters info.
          \param blendedRastersInfosTree A tree indexing blendedRastersInfos.
          \param validAreaDelimiterPolPtr A pointer (or a null pointer) to the current input raster valid data area.
          \param mosaicRaster The mosaic raster reference.
          \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.
          \param mosaicCenterRasterIdx The index of the first blended raster at the mosaic center.
         */
        bool getEqualizationParams( 
          const te::rst::Raster& inRaster,
          const unsigned int inRasterIndex,
          const std::vector< unsigned int >& inputRastersBands,
          ProcessedRastersInfosT&  processedRastersInfos,
          const te::sam::rtree::Index< unsigned int >& blendedRastersInfosTree,
          te::gm::MultiPolygon const * const  validAreaDelimiterPolPtr,
          const te::rst::Raster& mosaicRaster,
          const unsigned int mosaicCenterRasterIdx,
          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;
          
        /*!
          \brief Find the index of the next raster to process.
          \param globalMosaicCenterX Global mosaic center X.
          \param globalMosaicCenterY Global mosaic center Y.
          \param procRastersInfos Global processed rasters infos.
          \param mosaicValidAreasUnionPtr Current blended rasters area union geometry.
          \param mextRasterIndex The found next raster index to process.
          \param mextRasterWasFound True if the next raster was found.
          \return true if OK, false on errors.
         */
        bool getNextRasterIndex2Process(
          const double& globalMosaicCenterX,
          const double& globalMosaicCenterY,
          ProcessedRastersInfosT& procRastersInfos,
          te::gm::MultiPolygon const* const mosaicValidAreasUnionPtr,
          bool& mextRasterWasFound,
          unsigned int& mextRasterIndex );
          
        /*!
          \brief Returns the given raster valid data area
          \param inputRaster Input Raster to process.
          \param inputRasterIdx Input raster index.
          \param vAreaPolygon Data valid area in a polygon form.
          \param vAreaMultiPolygon Data valid area in a multi-polygon form.
          \return true if OK, false on errors.
         */
        bool getRasterDataValidArea( 
          const te::rst::Raster& inputRaster,
          const unsigned int inputRasterIdx,
          std::unique_ptr< te::gm::Polygon >& vAreaPolygon,
          std::unique_ptr< te::gm::MultiPolygon >& vAreaMultiPolygon );
 
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif