ClassifierDummyStrategy.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/ClassifierDummyStrategy.cpp

  \brief Dummy strategy (just for testing purposes).
*/

// TerraLib
#include "../geometry/Coord2D.h"
#include "../geometry/Envelope.h"
#include "../geometry/Point.h"
#include "../geometry/Polygon.h"
#include "../raster/Grid.h"
#include "ClassifierDummyStrategy.h"
#include "Functions.h"
#include "Macros.h"

// STL
#include <iostream>
#include <stdlib.h>

namespace
{
  static te::rp::ClassifierDummyStrategyFactory classifierDummyStrategyFactoryInstance;
}

te::rp::ClassifierDummyStrategy::Parameters::Parameters()
{
  reset();
}

te::rp::ClassifierDummyStrategy::Parameters::~Parameters() = default;

const te::rp::ClassifierDummyStrategy::Parameters& te::rp::ClassifierDummyStrategy::Parameters::operator=(const te::rp::ClassifierDummyStrategy::Parameters& rhs)
{
  reset();

  m_dummyParameter = rhs.m_dummyParameter;

  return *this;
}

void te::rp::ClassifierDummyStrategy::Parameters::reset() throw(te::rp::Exception)
{
  m_dummyParameter = 0;
}

te::common::AbstractParameters* te::rp::ClassifierDummyStrategy::Parameters::clone() const
{
  return new te::rp::ClassifierDummyStrategy::Parameters( *this );
}

te::rp::ClassifierDummyStrategy::ClassifierDummyStrategy()
{
  m_isInitialized = false;
}

te::rp::ClassifierDummyStrategy::~ClassifierDummyStrategy() = default;

bool te::rp::ClassifierDummyStrategy::initialize(te::rp::ClassifierStrategyParameters const* const strategyParams) throw(te::rp::Exception)
{
  m_isInitialized = false;

  te::rp::ClassifierDummyStrategy::Parameters const* paramsPtr = dynamic_cast<te::rp::ClassifierDummyStrategy::Parameters const*>(strategyParams);

  if(!paramsPtr)
    return false;

  m_parameters = *(paramsPtr);

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(m_parameters.m_dummyParameter > 1, TE_TR("The value of dummy must be at least 2."))

  m_isInitialized = true;

  return true;
}

bool te::rp::ClassifierDummyStrategy::execute() throw(te::rp::Exception)
{
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(m_isInitialized, TE_TR("Instance not initialized"))

  // Creating the output raster

  {
    std::vector< int > dt;
    dt.push_back( te::dt::UINT32_TYPE );

    std::vector< double > noDataValues;
    noDataValues.push_back( 0 );

    TERP_INSTANCE_TRUE_OR_RETURN_FALSE( createOutputRaster( dt, noDataValues ),
      "Output raster creation error" );

    // no-data fill

    const double outNoDataValue = m_outputRasterPtr->getBand( 0 )->getProperty()->m_noDataValue;
    const unsigned int nCols = m_outputRasterPtr->getNumberOfColumns();
    const unsigned int nRows = m_outputRasterPtr->getNumberOfRows();
    unsigned int col = 0;
    te::rst::Band& outBand = *m_outputRasterPtr->getBand( 0 );

    for( unsigned int row = 0 ; row < nRows ; ++row )
    {
      for( col = 0 ; col < nCols ; ++col )
      {
        outBand.setValue( col, row, outNoDataValue );
      }
    }
  }

// check if OBIA method is employed (raster + polygons)

  unsigned int c;
  unsigned int r;
  unsigned int pattern;
  te::gm::Point* point;
  unsigned int outputRasterPaletteSize = 0;

  if(
      ( m_inputPolygonsPtr != nullptr )
      &&
      ( m_inputPolygonsPtr->size() > 0)
    )
  {
// iterate over geometries
    for (unsigned i = 0; i < m_inputPolygonsPtr->size(); i++)
    {
      te::gm::Polygon* polygon = m_inputPolygonsPtr->operator[]( i );

      te::gm::Coord2D ll = polygon->getMBR()->getLowerLeft();
      te::gm::Coord2D ur = polygon->getMBR()->getUpperRight();

      te::gm::Coord2D startGridCoord = m_outputRasterPtr->getGrid()->geoToGrid(ll.x, ur.y);
      te::gm::Coord2D endGridCoord = m_outputRasterPtr->getGrid()->geoToGrid(ur.x, ll.y);

      pattern = rand() % 5 + 1;

      for(r = (unsigned) startGridCoord.y; r < endGridCoord.y; r++)
        for(c = (unsigned) startGridCoord.x; c < endGridCoord.x; c++)
        {
          te::gm::Coord2D geoCoord = m_outputRasterPtr->getGrid()->gridToGeo(c, r);
          point = new te::gm::Point(geoCoord.x, geoCoord.y);

          if (polygon->intersects(point))
            m_outputRasterPtr->setValue(c, r, pattern, 0);

          delete point;
        }

      outputRasterPaletteSize = std::max( outputRasterPaletteSize, pattern );
    }
  }
  else
  {
    const unsigned int nrows = m_outputRasterPtr->getNumberOfRows();
    const unsigned int ncols = m_outputRasterPtr->getNumberOfColumns();

    for(r = 0; r < nrows; r++)
    {
      for(c = 0; c < ncols; c++)
      {
// generate random classification with 5 classes
        pattern = rand() % 5 + 1;

        m_outputRasterPtr->setValue(c, r, pattern, 0);

        outputRasterPaletteSize = std::max( outputRasterPaletteSize, pattern );
      }
    }
  }

  // Configure the output raster palette

  ++outputRasterPaletteSize;

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( setOutputRasterPalette( outputRasterPaletteSize ),
    "Output raster palette creation error" );

  return true;
}

te::rp::ClassifierDummyStrategyFactory::ClassifierDummyStrategyFactory()
  : te::rp::ClassifierStrategyFactory("dummy")
{
}

te::rp::ClassifierDummyStrategyFactory::~ClassifierDummyStrategyFactory() =
    default;

te::rp::ClassifierStrategy* te::rp::ClassifierDummyStrategyFactory::build()
{
  return new te::rp::ClassifierDummyStrategy();
}