PostClassification.cpp

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/PostClassification.cpp
\brief Raster post classification.
*/

#include "PostClassification.h"
#include "Macros.h"
#include "Functions.h"
//#include "../statistics/core/SummaryFunctions.h"
#include "../raster/RasterFactory.h"
#include "../raster/BandProperty.h"
#include "../raster/Grid.h"
#include "../raster/Band.h"
//#include "../raster/BandIterator.h"
//#include "../raster/BandIteratorWindow.h"
//#include "../common/progress/TaskProgress.h"

#include <memory>
//#include <cmath>

namespace te
{
  namespace rp
  {

    PostClassification::InputParameters::InputParameters()
    {
      reset();
    }

    PostClassification::InputParameters::InputParameters(const InputParameters& other)
    {
      reset();
      operator=(other);
    }

    PostClassification::InputParameters::~InputParameters()
    {
      reset();
    }

    void PostClassification::InputParameters::reset() _NOEXCEPT_OP(false)
    {
      m_inRasterPtr = nullptr;
      m_weight = 0;
      m_threshold = 0;
    }

    const PostClassification::InputParameters& PostClassification::InputParameters::operator=(
      const PostClassification::InputParameters& params)
    {
      reset();

      m_inRasterPtr = params.m_inRasterPtr;
      m_weight = params.m_weight;
      m_threshold = params.m_threshold;

      return *this;
    }

    te::common::AbstractParameters* PostClassification::InputParameters::clone() const
    {
      return new InputParameters(*this);
    }

    PostClassification::OutputParameters::OutputParameters()
    {
      reset();
    }

    PostClassification::OutputParameters::OutputParameters(const OutputParameters& other)
    {
      reset();
      operator=(other);
    }

    PostClassification::OutputParameters::~OutputParameters()
    {
      reset();
    }

    void PostClassification::OutputParameters::reset() _NOEXCEPT_OP(false)
    {
      m_rType.clear();
      m_rInfo.clear();
      m_outputRasterPtr.reset();
    }

    const PostClassification::OutputParameters& PostClassification::OutputParameters::operator=(
      const PostClassification::OutputParameters& params)
    {
      reset();

      m_rType = params.m_rType;
      m_rInfo = params.m_rInfo;

      return *this;
    }

    te::common::AbstractParameters* PostClassification::OutputParameters::clone() const
    {
      return new OutputParameters(*this);
    }

    PostClassification::PostClassification()
    {
      reset();
    }

    PostClassification::~PostClassification() = default;

    bool PostClassification::execute(AlgorithmOutputParameters& outputParams) _NOEXCEPT_OP(false)
    {
      if (!m_isInitialized) return false;

      PostClassification::OutputParameters* outputParamsPtr = dynamic_cast<
        PostClassification::OutputParameters* >(&outputParams);
      TERP_TRUE_OR_THROW(outputParamsPtr, "Invalid paramters");

      // Initializing the output rasters

      std::vector<te::rst::BandProperty*> bandsProperties;
      te::rst::BandProperty* bprop = new te::rst::BandProperty(*m_inputParameters.m_inRasterPtr->getBand(0)->getProperty());
      bandsProperties.push_back(bprop);

      te::rst::Grid* newgrid = new te::rst::Grid(*(m_inputParameters.m_inRasterPtr->getGrid()));

      outputParamsPtr->m_outputRasterPtr.reset(
        te::rst::RasterFactory::make(outputParamsPtr->m_rType, newgrid, bandsProperties, outputParamsPtr->m_rInfo, nullptr, nullptr));
      TERP_INSTANCE_TRUE_OR_RETURN_FALSE(outputParamsPtr->m_outputRasterPtr.get(),
        "Output raster creation error");

      te::rst::Copy(*m_inputParameters.m_inRasterPtr, *outputParamsPtr->m_outputRasterPtr);

      const te::rst::Band& bout = *outputParamsPtr->m_outputRasterPtr->getBand(0);

      for (unsigned int row = 0; row < (outputParamsPtr->m_outputRasterPtr->getNumberOfRows() - 2); row++)
      {
        for (unsigned int col = 0; col < (outputParamsPtr->m_outputRasterPtr->getNumberOfColumns() - 2); col++)
        {
          double pixels[3][3];//pixels[col][row]

          for (int i = 0; i < 3; i++)
          {
            pixels[i][0] = 0;
            pixels[i][1] = 0;
            pixels[i][2] = 0;
          }

          std::map<int, int> freq; //<class, frequence>
          freq.clear();

          bout.getValue(col + 1, row + 1, pixels[1][1]);

          int freqvcenter = 0; //frequence of central pixel

          for (int c = 0; c < 3; c++)
          {
            for (int r = 0; r < 3; r++)
            {
              bout.getValue(col + static_cast<unsigned int>(c), row + static_cast<unsigned int>(r), pixels[c][r]);

              if (pixels[c][r] == pixels[1][1])
              {
                freqvcenter++;
                continue;
              }

              std::map<int, int>::iterator itFreq = freq.find(static_cast<int>(pixels[c][r]));

              if (itFreq != freq.end())
                itFreq->second++;
              else
                freq.insert(std::map<int, int>::value_type(static_cast<int>(pixels[c][r]), 1));
            }
          }

          if (freq.size() == 0)
            continue;

          freqvcenter += m_inputParameters.m_weight - 1;

          //Compare central pixel frequence with neighbors pixels
          std::map<int, int>::iterator itFreq = freq.begin();

          int bestClass = itFreq->first;
          int bestFreq = itFreq->second;
          itFreq++;

          while (itFreq != freq.end())
          {
            if (itFreq->second > bestFreq)
            {
              bestClass = itFreq->first;
              bestFreq = itFreq->second;
            }

            itFreq++;
          }

          //Gets frequence nearest to threshold
          itFreq = freq.begin();
          while (itFreq != freq.end())
          {
            if ((itFreq->second > static_cast<int>(m_inputParameters.m_threshold)) && (itFreq->second > bestFreq))
            {
              bestFreq = itFreq->second;
              bestClass = itFreq->first;
            }

            itFreq++;
          }

          if ((bestFreq > static_cast<int>(m_inputParameters.m_threshold)) && (bestFreq > freqvcenter))
            outputParamsPtr->m_outputRasterPtr->setValue(col + 1, row + 1, static_cast<double>(bestClass));

          freq.clear();
        }
      }

      return true;
    }

    void PostClassification::reset() _NOEXCEPT_OP(false)
    {
      Algorithm::reset();
      
      m_isInitialized = false;
      m_inputParameters.reset();
    }

    bool PostClassification::initialize(const AlgorithmInputParameters& inputParams) _NOEXCEPT_OP(false)
    {
      reset();

      PostClassification::InputParameters const* inputParamsPtr = dynamic_cast<
        PostClassification::InputParameters const* >(&inputParams);
      TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr, TE_TR("Invalid parameters"));

      TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr->m_inRasterPtr,
        TE_TR("Invalid raster pointer"));
      TERP_INSTANCE_TRUE_OR_RETURN_FALSE(
        inputParamsPtr->m_inRasterPtr->getAccessPolicy() & te::common::RAccess,
        TE_TR("Invalid raster"));

      TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr->m_weight > 0,
        TE_TR("Invalid weight value"));

      TERP_INSTANCE_TRUE_OR_RETURN_FALSE((inputParamsPtr->m_threshold > 0),
        TE_TR("Invalid threshold value"));

      m_inputParameters = *inputParamsPtr;
      
      m_isInitialized = true;

      return true;
    }

    bool PostClassification::isInitialized() const
    {
      return m_isInitialized;
    }

    bool PostClassification::runPostClassification(const te::rst::Raster& srcRaster, te::rst::Raster& dstRaster,
      unsigned int weight, unsigned int threshold)
    {
      te::rst::Copy(srcRaster, dstRaster);

      const te::rst::Band& bout = *dstRaster.getBand(0);

      for (unsigned int row = 0; row < (dstRaster.getNumberOfRows() - 2); row++)
      {
        for (unsigned int col = 0; col < (dstRaster.getNumberOfColumns() - 2); col++)
        {
          double pixels[3][3];//pixels[col][row]

          for (int i = 0; i < 3; i++)
          {
            pixels[i][0] = 0;
            pixels[i][1] = 0;
            pixels[i][2] = 0;
          }

          std::map<int, int> freq; //<class, frequence>
          freq.clear();

          bout.getValue(col + 1, row + 1, pixels[1][1]);

          int freqvcenter = 0; //frequence of central pixel

          for (int c = 0; c < 3; c++)
          {
            for (int r = 0; r < 3; r++)
            {
              bout.getValue(col + static_cast<unsigned int>(c), row + static_cast<unsigned int>(r), pixels[c][r]);

              if (pixels[c][r] == pixels[1][1])
              {
                freqvcenter++;
                continue;
              }

              std::map<int, int>::iterator itFreq = freq.find(static_cast<int>(pixels[c][r]));

              if (itFreq != freq.end())
                itFreq->second++;
              else
                freq.insert(std::map<int, int>::value_type(static_cast<int>(pixels[c][r]), 1));
            }
          }

          if (freq.size() == 0)
            continue;

          freqvcenter += weight - 1;

          //  Compare central pixel frequence with neighbors pixels
          std::map<int, int>::iterator itFreq = freq.begin();

          int bestClass = itFreq->first;
          int bestFreq = itFreq->second;
          itFreq++;

          while (itFreq != freq.end())
          {
            if (itFreq->second > bestFreq)
            {
              bestClass = itFreq->first;
              bestFreq = itFreq->second;
            }

            itFreq++;
          }

          //Gets frequence nearest to threshold
          itFreq = freq.begin();
          while (itFreq != freq.end())
          {
            if ((itFreq->second > static_cast<int>(threshold)) && (itFreq->second > bestFreq))
            {
              bestFreq = itFreq->second;
              bestClass = itFreq->first;
            }

            itFreq++;
          }

          if ((bestFreq > static_cast<int>(threshold)) && (bestFreq > freqvcenter))
            dstRaster.setIValue(col + 1, row + 1, static_cast<double>(bestClass));

          freq.clear();
        }
      }

      return true;
    }

  } // end namespace rp
}   // end namespace te