Dummy.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/classification/Dummy.h
 
  \brief Dummy classifier (just for testing purposes).
*/
 
#ifndef __TERRALIB_CLASSIFICATION_INTERNAL_DUMMY_H
#define __TERRALIB_CLASSIFICATION_INTERNAL_DUMMY_H
 
// TerraLib
#include "../common/AbstractParameters.h"
#include "../geometry/Coord2D.h"
#include "../geometry/Envelope.h"
#include "../geometry/Point.h"
#include "../geometry/Polygon.h"
#include "../raster/Grid.h"
#include "Config.h"
#include "Exception.h"
 
// STL
#include <iostream>
#include <stdlib.h>
 
namespace te
{
  namespace cl
  {
    /*!
      \class Dummy
 
      \brief Dummy classifier (just for testing purposes).
    */
    template<class TTRAIN, class TCLASSIFY>
    class Dummy
    {
      public:
 
        /*!
          \class Parameters
 
          \brief Classifier Parameters
        */
        class Parameters : public te::common::AbstractParameters
        {
          public:
 
            unsigned int m_dummyParameter;  //!< A dummy parameter.
 
            Parameters();
 
            ~Parameters();
 
            //overload
            const Parameters& operator=(const Parameters& params);
 
            //overload
            void reset() throw(te::cl::Exception);
 
            //overload
            AbstractParameters* clone() const;
        };
 
      public:
 
        Dummy();
 
        ~Dummy();
 
        bool initialize(const Parameters& params) throw(te::cl::Exception);
 
        bool train(TTRAIN& itBegin, TTRAIN& itEnd,
                   const std::vector<unsigned int>& attributesIndices,
                   const std::vector<unsigned int>& labels,
                   const bool enableProgressInterface) throw(te::cl::Exception);
 
        bool classify(TCLASSIFY& itBegin, TCLASSIFY& itEnd,
                      const std::vector<unsigned int>& attributesIndices,
                      std::vector<unsigned int>& classification,
                      const bool enableProgressInterface) throw(te::cl::Exception);
      protected:
 
        bool m_isInitialized;                              //!< True if this instance is initialized.
        Parameters m_parameters;                           //!< Internal execution parameters.
    };
 
  }; // end namespace cl
};  // end namespace te
 
// class of Parameters
template <class TTRAIN, class TCLASSIFY>
te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters::Parameters()
{
  reset();
}
 
template <class TTRAIN, class TCLASSIFY>
te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters::~Parameters()
{
}
 
template <class TTRAIN, class TCLASSIFY>
const typename te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters& te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters::operator=(const typename te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters& rhs)
{
  reset();
 
  m_dummyParameter = rhs.m_dummyParameter;
 
  return *this;
}
 
template <class TTRAIN, class TCLASSIFY>
void te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters::reset() throw(te::cl::Exception)
{
  m_dummyParameter = 0;
}
 
template <class TTRAIN, class TCLASSIFY>
te::common::AbstractParameters* te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters::clone() const
{
  return new te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters(*this);
}
 
// class Dummy Strategy
template <class TTRAIN, class TCLASSIFY>
te::cl::Dummy<TTRAIN, TCLASSIFY>::Dummy()
{
  m_isInitialized = false;
}
 
template <class TTRAIN, class TCLASSIFY>
te::cl::Dummy<TTRAIN, TCLASSIFY>::~Dummy()
{
}
 
template <class TTRAIN, class TCLASSIFY>
bool te::cl::Dummy<TTRAIN, TCLASSIFY>::initialize(const typename te::cl::Dummy<TTRAIN, TCLASSIFY>::Parameters& params) throw(te::cl::Exception)
{
  m_isInitialized = false;
 
  m_parameters = params;
 
  if (m_parameters.m_dummyParameter < 2)
  {
    TE_TR("The value of dummy must be at least 2.");
    return false;
  }
 
  m_isInitialized = true;
 
  return true;
}
 
template<class TTRAIN, class TCLASSIFY>
bool te::cl::Dummy<TTRAIN, TCLASSIFY>::train(TTRAIN& itBegin, TTRAIN& itEnd,
                                             const std::vector<unsigned int>& attributesIndices,
                                             const std::vector<unsigned int>& labels,
                                             const bool enableProgressInterface) throw(te::cl::Exception)
{
  return true;
}
 
template<class TTRAIN, class TCLASSIFY>
bool te::cl::Dummy<TTRAIN, TCLASSIFY>::classify(TCLASSIFY& itBegin, TCLASSIFY& itEnd,
                                                const std::vector<unsigned int>& attributesIndices,
                                                std::vector<unsigned int>& classification,
                                                const bool enableProgressInterface) throw(te::cl::Exception)
{
  TCLASSIFY it = itBegin;
  while(it != itEnd)
  {
    classification.push_back(rand() % m_parameters.m_dummyParameter + 1);
 
    ++it;
  }
 
  return true;
}
 
#endif // __TERRALIB_CLASSIFICATION_INTERNAL_DUMMY_H