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 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