Adaptors.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/Adaptors.h
 
  \brief Classifiers adaptors.
*/
 
#ifndef __TERRALIB_CLASSIFICATION_INTERNAL_ADAPTORS_H
#define __TERRALIB_CLASSIFICATION_INTERNAL_ADAPTORS_H
 
#include "Config.h"
#include "Exception.h"
 
#include <cstddef>
#include <vector>
 
namespace te
{
  namespace cl
  {
    /*!
      \class InputAdaptor
      \brief Classifiers input data adaptor.
 
    */
    template<typename DataType>
    class InputAdaptor
    {
      public:
 
        InputAdaptor() {};
 
        ~InputAdaptor() {};
 
        /*!
          \brief Returns one feature value.
          \param elementIndex Element index..
          \param featureIndex Feature index.
          \param featureValue The returned feature value.
        */
        virtual void getFeature(const unsigned int& elementIndex,
          const unsigned int& featureIndex, DataType& featureValue ) const = 0;
 
        /*!
          \brief Returns the total elements number.
        */
        virtual unsigned int getElementsCount() const = 0;
 
        /*!
          \brief Returns the total features per element number.
        */
        virtual unsigned int getFeaturesCount() const = 0;
    };
 
    /*!
      \class OutputAdaptor
      \brief Classifiers output data adaptor.
 
    */
    template<typename DataType>
    class OutputAdaptor
    {
      public:
 
        OutputAdaptor() {};
 
        ~OutputAdaptor() {};
 
        /*!
          \brief Set one feature value.
          \param elementIndex Element index..
          \param featureIndex Feature index.
        */
        virtual void setFeature(const unsigned int& elementIndex,
          const unsigned int& featureIndex, const DataType& value ) = 0;
 
        /*!
          \brief Returns the total elements number.
        */
        virtual unsigned int getElementsCount() const = 0;
 
        /*!
          \brief Returns the total features per element number.
        */
        virtual unsigned int getFeaturesCount() const = 0;
    };
 
    /*!
      \class InputOutputAdaptor
      \brief Classifiers input and output data adaptor.
 
    */
    template<typename DataType>
    class InputOutputAdaptor
    {
      public:
 
        InputOutputAdaptor() {};
 
        ~InputOutputAdaptor() {};
 
        /*!
          \brief Returns one feature value.
          \param elementIndex Element index..
          \param featureIndex Feature index.
          \param featureValue The returned feature value.
        */
        virtual void getFeature(const unsigned int& elementIndex,
          const unsigned int& featureIndex, DataType& featureValue ) const = 0;
 
        /*!
          \brief Set one feature value.
          \param elementIndex Element index..
          \param featureIndex Feature index.
        */
        virtual void setFeature(const unsigned int& elementIndex,
          const unsigned int& featureIndex, const DataType& value ) = 0;
 
        /*!
          \brief Returns the total elements number.
        */
        virtual unsigned int getElementsCount() const = 0;
 
        /*!
          \brief Returns the total features per element number.
        */
        virtual unsigned int getFeaturesCount() const = 0;
    };
 
 
    /*!
      \class ContainerInputAdaptor
      \brief Classifiers container input data adaptor.
 
    */
    template<typename DataType>
    class VectorOfVectorsInputAdaptor : public InputAdaptor< DataType >
    {
      public:
 
        VectorOfVectorsInputAdaptor( const std::vector< std::vector< DataType > >& container )
        : m_container( container )
        {
          // Checking consistency
 
          if( !container.empty() )
          {
            typename std::vector< std::vector< DataType > >::const_iterator it = container.begin();
            const typename std::vector< std::vector< DataType > >::const_iterator itEnd = container.end();
            const std::size_t baseFeaturesCount = container[ 0 ].size();
 
            while( it != itEnd )
            {
              if( it->size() != baseFeaturesCount )
              {
                throw Exception( "Features count inconsistency" );
              }
 
              ++it;
            }
          }
        };
 
        ~VectorOfVectorsInputAdaptor() {};
 
        // overload
        void getFeature(const unsigned int& elementIndex, const unsigned int& featureIndex,
          DataType& featureValue ) const
        {
          featureValue = m_container[ elementIndex ][ featureIndex ];
        };
 
        // overload
        unsigned int getElementsCount() const
        {
          return static_cast<unsigned int>(m_container.size());
        };
 
        // overload
        unsigned int getFeaturesCount() const
        {
          if( m_container.empty() )
          {
            return 0;
          }
          else
          {
            return static_cast<unsigned int>(m_container[0].size());
          }
        };
 
      protected :
 
        /*!
          \brief Internal container reference.
        */
        const std::vector< std::vector< DataType > >& m_container;
    };
 
    /*!
      \class VectorOutputAdaptor
      \brief Classifiers vector container output data adaptor.
 
    */
    template< typename DataType >
    class VectorOutputAdaptor : public te::cl::OutputAdaptor< DataType >
    {
      public:
        explicit VectorOutputAdaptor( std::vector< DataType >& container )
        : m_container( container )
        {
        };
 
        ~VectorOutputAdaptor() {}
 
        // overload
        void setFeature(const unsigned int& elementIndex,
          const unsigned int&, const DataType& value )
        {
          m_container[ elementIndex ] = value;
        }
 
        // overload
        unsigned int getElementsCount() const
        {
          return m_container.size();
        }
 
        // overload
        unsigned int getFeaturesCount() const
        {
          return 1;
        }
 
      protected :
 
        /*!
          \brief Internal container reference.
        */
        std::vector< DataType >& m_container;
    };
 
  } // end namespace cl
}  // end namespace te
 
#endif // __TERRALIB_CLASSIFICATION_INTERNAL_MAP_H