CommonDataStructures.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/vp/CommonDataStructures.h
 
   \brief Utility classes, structures and definitions for Vector Processing.
 */
 
#ifndef __TERRALIB_VP_INTERNAL_COMMONDATASTRCTURES_H
#define __TERRALIB_VP_INTERNAL_COMMONDATASTRCTURES_H
 
//Terralib include files
#include "Config.h"
 
#include "../common/STLUtils.h"
#include "../geometry/Coord2D.h"
#include "../geometry/Envelope.h"
 
//STL include files
#include <set>
#include <vector>
 
namespace te
{
  namespace dt
  {
    class AbstractData;
  }
 
  namespace gm
  {
    class Geometry;
  }
 
  namespace vp
  {
    //!< Defines an alias for a geometry vector
    struct SegmentInfoImpl;
    struct GeometryInfoImpl;
 
    /*!
      \class RTreeIndexData
 
      \brief Represents a data to be indexed by the RTree Index
 
      \ingroup vp
 
      \sa CoordinateSnapper
    */
    template<class T>
    class IndexData
    {
    public:
 
      T m_data; //!< The templated data
      std::size_t m_dataIndex; //!< The index of the data inside the data vector
 
      //<! Constructor
      IndexData(const T& data, std::size_t dataIndex)
        : m_data(data)
        , m_dataIndex(dataIndex)
      {
 
      }
    };
 
    template<class T>
    class IndexContainer
    {
    public:
 
      IndexContainer() {}
 
      ~IndexContainer()
      {
        clear();
      }
 
      void clear()
      {
        te::common::FreeContents(m_vecData);
 
        m_vecData.clear();
        m_freeIndexes.clear();
      }
 
      std::size_t insert(const T& data)
      {
        std::size_t position = 0;
        if (m_freeIndexes.empty() == true)
        {
          //we must add to the end of the list
          position = m_vecData.size();
          te::vp::IndexData<T>* indexData = new te::vp::IndexData<T>(data, position);
          m_vecData.push_back(indexData);
        }
        else
        {
          //we can get an avaialble position to avoid the vector to grow forever
          position = *m_freeIndexes.begin();
          m_freeIndexes.erase(m_freeIndexes.begin());
 
          te::vp::IndexData<T>* indexData = new te::vp::IndexData<T>(data, position);
          m_vecData[position] = indexData;
        }
 
        return position;
      }
 
      void remove(std::size_t dataIndex)
      {
        m_freeIndexes.insert(dataIndex);
 
        delete m_vecData.at(dataIndex);
        m_vecData.at(dataIndex) = nullptr;
      }
 
      te::vp::IndexData<T>* getData(std::size_t dataIndex) const
      {
        return m_vecData.at(dataIndex);
      }
 
      std::vector<std::size_t> getValidIndexes() const
      {
        std::vector<std::size_t> vecValidIndexes;
        vecValidIndexes.reserve(m_vecData.size());
 
        for (std::size_t i = 0; i < m_vecData.size(); ++i)
        {
          if (m_vecData.at(i) != nullptr)
          {
            vecValidIndexes.push_back(i);
          }
        }
 
        return vecValidIndexes;
      }
 
      std::vector<std::size_t> getValidIndexes(const std::vector<std::size_t>& vecIndexes) const
      {
        if (m_freeIndexes.empty() == true)
        {
          return vecIndexes;
        }
 
        std::vector<std::size_t> vecValidIndexes;
        vecValidIndexes.reserve(vecIndexes.size());
 
        std::size_t limit = m_vecData.size();
 
        for (std::size_t i = 0; i < vecIndexes.size(); ++i)
        {
          std::size_t index = vecIndexes.at(i);
          if (index < limit)
          {
            if (m_vecData.at(index) != nullptr)
            {
              vecValidIndexes.push_back(index);
            }
          }
        }
 
        return vecValidIndexes;
      }
 
    private:
      std::set<std::size_t> m_freeIndexes; //!< Stores the list of removed indexes
      std::vector< IndexData<T>* > m_vecData; //!< The actual data stored
    };
 
    template<class T>
    class IndexReport
    {
    public:
 
      IndexReport(const IndexContainer<T>* indexContainer, const std::vector<std::size_t>& vecFilter)
        : m_indexContainer(indexContainer)
        , m_vecFilter(vecFilter)
      {
 
      }
 
      std::size_t size() const
      {
        return m_vecFilter.size();
      }
 
      te::vp::IndexData<T>* getData(std::size_t dataIndex) const
      {
        std::size_t position = m_vecFilter.at(dataIndex);
        return m_indexContainer->getData(position);
      }
 
      std::vector<T> getAllData() const
      {
        std::vector<T> vecAllData;
        vecAllData.reserve(m_vecFilter.size());
 
        for (std::size_t i = 0; i < m_vecFilter.size(); ++i)
        {
          std::size_t position = m_vecFilter.at(i);
          vecAllData.push_back(m_indexContainer->getData(position)->m_data);
        }
 
        return vecAllData;
      }
 
    private:
      const IndexContainer<T>* m_indexContainer;
      std::vector<std::size_t> m_vecFilter;
    };
 
    class TEVPEXPORT SegmentInfo
    {
    public:
 
      /*!
        * \brief Constructor
        *
        * \param coord1 The segment start coordinate
        * \param coord2 The segment end coordinate
        * \param evenlope The segment envelope
        * \param polygonIndex The index of the polygon from which this segment came from
      */
      SegmentInfo(const te::gm::Coord2D& coord1, const te::gm::Coord2D& coord2, const te::gm::Envelope& envelope, std::size_t geometryIndex);
 
      //!< Destructor
      virtual ~SegmentInfo();
 
      //!< Clones the SegmentInfo
      SegmentInfo* clone() const;
 
      //!< Gets the segment start coordinate
      const te::gm::Coord2D& getCoord1() const;
 
      //!< Gets the segment end coordinate
      const te::gm::Coord2D& getCoord2() const;
 
      //!< Gets the segment envelope
      const te::gm::Envelope& getEnvelope() const;
 
      //!< Gets the geometry index
      std::size_t getGeometryIndex() const;
 
      //!< Sets the geometry index 
      void setGeometryIndex(std::size_t geometryIndex);
 
    private:
      te::gm::Coord2D m_coord1; //! The segment start coordinate
      te::gm::Coord2D m_coord2; //! The segment end coordinate
      te::gm::Envelope m_envelope; //! The segment envelope
      std::size_t m_geometryIndex; //! The index of the geometry from which this segment came from
    };
 
    class TEVPEXPORT GeometryInfo
    {
      public:
        /*!
        * \brief Constructor
        *
        * \param geometrIndex The index of this geometry in a vector. Can be zero if it is not added to a vector
        * \param geometry The geometry to be fragmented
        */
        GeometryInfo(std::size_t geometryIndex, te::gm::Geometry* geometry);
 
        /*!
        * \brief Constructor
        *
        * \param geometrIndex The index of this geometry in a vector. Can be zero if it is not added to a vector
        * \param geometry The geometry to be fragmented
        * \param filter The enveope to be used as filter. Only segments intercepting the filter will be fragmented and indexed
        */
        GeometryInfo(std::size_t geometryIndex, te::gm::Geometry* geometry, const te::gm::Envelope& filter);
 
        //!< Destructor
        virtual ~GeometryInfo();
 
        //!< Searches the segments that interscepts the given filter
        std::size_t search(const te::gm::Envelope& filter, std::vector<SegmentInfo>& vecResult) const;
 
        //!< Gets the list of all segments of the geometry
        std::vector<SegmentInfo> getAllSegments() const;
 
        //!< Gets the geometry
        const te::gm::Geometry* getGeometry() const;
 
        //!< Sets the geometry. This will cause the old geometry to be deleted and the index to be recreated
        void setGeometry(te::gm::Geometry* geometry);
 
      private:
 
        //!< Initializes the index
        void init(const te::gm::Envelope& filter);
 
      protected:
        GeometryInfoImpl* m_impl; //!< A internal pointer to the implementation of the class. This is used to avoid exporting dependencies
    };
  }
}
 
#endif //__TERRALIB_VP_INTERNAL_COMMONDATASTRCTURES_H