MajorityFilter.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/MajorityFilter.h
  \brief This file contains a class that represents the method to remove pixels from classified image.
 */
 
#ifndef __TERRALIB_RP_INTERNAL_MAJORITYFILTER_H
#define __TERRALIB_RP_INTERNAL_MAJORITYFILTER_H
 
#include "Algorithm.h"
#include "../raster/Raster.h"
 
// STL
#include <vector>
 
namespace te
{
  namespace rp
  {
    /*!
      \class MajorityFilter
      \brief This file contains a class that represents the method to remove pixels from classified image.
      \ingroup rp_enh
     */
    class TERPEXPORT MajorityFilter : public Algorithm
    {
      public:
 
        /*!
          \class InputParameters
          \brief Majority Filter input parameters
         */
        class TERPEXPORT InputParameters : public AlgorithmInputParameters
        {
          public:
 
            /*! \enum The majority filter type.*/
            enum MajorityFilterType
            {
              InvalidFilterT = 0,
              SimpleFilterT = 1,     
              FullFilterT = 2       
            };
 
            MajorityFilterType m_filterType; //!< The majority filter type.
 
            te::rst::Raster const* m_inRasterPtr; //!< Input raster.
 
            std::vector< unsigned int > m_inRasterBands; //!< Bands to be used from the input raster.
 
            unsigned int m_npixels; //!< Number of pixels
 
            unsigned int m_neighbors; //!< Number of neighbors
 
            /*! \enum Replacement threshold*/
            enum MajorityFilterThreshold
            {
              InvalidThreshold = 0,
              MajorityThreshold = 1,
              HalfThreshold = 2
            };
 
            MajorityFilterThreshold m_threshold; //!< Replacement threshold
 
            bool m_enableProgress; //!< Enable/Disable the progress interface (default:false).
 
            InputParameters();
 
            InputParameters( const InputParameters& );
 
            ~InputParameters();
 
            //overload
            void reset() _NOEXCEPT_OP(false);
 
            //overload
            const  InputParameters& operator=( const InputParameters& params );
 
            //overload
            AbstractParameters* clone() const;
        };
 
        /*!
          \class OutputParameters
          \brief Majority Filter 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 raster (as described in te::raster::RasterFactory).
 
            std::unique_ptr< te::rst::Raster > m_outputRasterPtr; //!< A pointer the ge generated output raster (label image).
 
            OutputParameters();
 
            OutputParameters( const OutputParameters& );
 
            ~OutputParameters();
 
            //overload
            void reset() _NOEXCEPT_OP(false);
 
            //overload
            const  OutputParameters& operator=( const OutputParameters& params );
 
            //overload
            AbstractParameters* clone() const;
        };
 
        MajorityFilter();
 
        ~MajorityFilter();
 
        //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:
 
        bool m_isInitialized; //!< Is this instance already initialized?
 
        MajorityFilter::InputParameters m_inputParameters; //!< Input parameters.
 
        te::rst::Raster* m_outputRaster; //!< Output raster
 
        /*!
          \brief Apply the simple majority filter over the source raster band.
          \param srcRaster Source raster.
          \param srcBandIdx Source raster band index.
          \param dstBandIdx Destination raster band index.
          \param useProgress if true, the progress interface must be used.
         */
         bool SimpleFilter(const te::rst::Raster& srcRaster, const unsigned int srcBandIdx,
           const unsigned int dstBandIdx, const bool useProgress);
 
         /*!
          \brief Apply the full majority filter over the source raster band.
          \param srcRaster Source raster.
          \param srcBandIdx Source raster band index.
          \param dstBandIdx Destination raster band index.
          \param useProgress if true, the progress interface must be used.
         */
         bool FullFilter(const te::rst::Raster& srcRaster, const unsigned int srcBandIdx,
           const unsigned int dstBandIdx, const bool useProgress);
 
         /*!
          \brief Find the neighbors (right, down, left and up) of the pixel located in a given column and row. This function is used in the simple filter.
          \param dstBand Output raster band.
          \param lcol Column of the current pixel
          \param lrow Row of the current pixel
          \param col Column of the neighbor pixel
          \param row Row of the neighbor pixel
          \param index Index from vector of columns and rows
          \param totalPixel Total pixels found with same class as the current pixel
          \param contClass Used to store the frequency of the classes
          \param veccol Vector to store the columns of the pixels to change the class
          \param vecrow Vector to store the rows of the pixels to change the class
         */
         void findNeighbors(te::rst::Band& dstBand, unsigned int lcol, unsigned int lrow, unsigned int col, unsigned int row,
           int& index, int& totalPixel, int* contClass, std::vector<int>& veccol, std::vector<int>& vecrow);
 
         /*!
          \brief Find the neighbors (right, down, left and up) of the pixel located in a given column and row. This function is used in the full filter.
          \param dstBand Output raster band.
          \param col Column of the current pixel
          \param row Row of the current pixel
          \param contClass Used to store the frequency of the classes
         */
         void find4Neighbors(te::rst::Band& dstBand, unsigned int col, unsigned int row, int* contClass);
 
         /*!
          \brief Find the eight neighbors of the pixel located in a given column and row. This function is used in the full filter.
          \param dstBand Output raster band.
          \param col Column of the current pixel
          \param row Row of the current pixel
          \param contClass Used to store the frequency of the classes
         */
         void find8Neighbors(te::rst::Band& dstBand, unsigned int col, unsigned int row, int* contClass);
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif