VoxelSpace.hpp

/* $Id$ */

#include <kernel/jafarMacro.hpp>
#include <geom/Atom.hpp>
#include <map>
#include <climits>

namespace jafar {
  namespace geom {
    template<int _dimension_, class _T_, int _level_ = _dimension_>
    class VoxelMultiDimensionStorage {
        typedef boost::numeric::ublas::bounded_vector<int, _dimension_> IndexVec;
        typedef std::map<int, VoxelMultiDimensionStorage<_dimension_, _T_, _level_ - 1> > MapVMD;
        typedef typename MapVMD::iterator MapVMD_it;
        typedef typename MapVMD::const_iterator MapVMD_cit;
      public:
        VoxelMultiDimensionStorage() : m_firstIndex( INT_MAX ), m_lastIndex( INT_MIN )
        {
        }
        inline _T_& operator[]( IndexVec index )
        {
          return m_storage[ index(_level_ - 1) ][ index ] ;
        }
        template<class _TFunctor_>
        inline void iterateCreateVoxels( IndexVec _firstIndex, IndexVec _lastIndex, _TFunctor_* _functor)
        {
          // Update the first index and last index
          int firstIndex_ = _firstIndex( _level_ - 1);
          int lastIndex_ = _lastIndex( _level_  - 1 );
          if( firstIndex_ < m_firstIndex ) m_firstIndex = firstIndex_;
          if( lastIndex_ > m_lastIndex ) m_lastIndex = lastIndex_;
          // Iterate and create voxels as needed
          for(int i = firstIndex_; i <= lastIndex_; ++i)
          {
            m_storage[i].iterateCreateVoxels(_firstIndex, _lastIndex, _functor);
          }
        }
        template<class _TFunctor_>
        inline void iterateVoxels( IndexVec _firstIndex, IndexVec _lastIndex, _TFunctor_* _functor) const
        {
          int firstIndex_ = _firstIndex(_level_ - 1);
          if( firstIndex_ < m_firstIndex ) firstIndex_ = m_firstIndex;
          int lastIndex_ = _lastIndex( _level_  - 1 );
          for(MapVMD_cit it = m_storage.find( firstIndex_ ); it->first <= lastIndex_ and it != m_storage.end(); ++it)
          {
            it->second.iterateVoxels<_TFunctor_>( _firstIndex, _lastIndex, _functor );
          }
        }
        template<class _TFunctor_>
        inline void iterateAllVoxels( _TFunctor_* _functor) const
        {
          for(MapVMD_cit it = m_storage.begin(); it != m_storage.end(); ++it)
          {
            it->second.iterateAllVoxels<_TFunctor_>( _functor );
          }
        }
        template<class _TFunctor_>
        inline void iterateAllVoxels( _TFunctor_* _functor)
        {
          for(MapVMD_it it = m_storage.begin(); it != m_storage.end(); ++it)
          {
            it->second.iterateAllVoxels<_TFunctor_>( _functor );
          }
        }
      private:
        int m_firstIndex;
        int m_lastIndex;
        MapVMD m_storage;
    };
    // Specialization of VoxelMultiDimensionStorage to stop recursions
    template< int _dimension_, class _T_>
    class VoxelMultiDimensionStorage<_dimension_, _T_, 1> {
        typedef boost::numeric::ublas::bounded_vector<int, _dimension_> IndexVec;
        typedef std::map<int, _T_ > MapObject;
        typedef typename MapObject::iterator MapObject_it;
        typedef typename MapObject::const_iterator MapObject_cit;
      public:
        VoxelMultiDimensionStorage<_dimension_, _T_, 1>() : m_firstIndex( INT_MAX ), m_lastIndex( INT_MIN )
        {
        }
        _T_& operator[]( IndexVec index ) { return storage(index(0)); }
        template<class _TFunctor_>
        inline void iterateCreateVoxels( IndexVec _firstIndex, IndexVec _lastIndex, _TFunctor_* _functor)
        {
          // Update the first index and last index
          int firstIndex_ = _firstIndex( 0);
          int lastIndex_ = _lastIndex( 0 );
          if( firstIndex_ < m_firstIndex ) m_firstIndex = firstIndex_;
          if( lastIndex_ > m_lastIndex ) m_lastIndex = lastIndex_;
          for(int i = firstIndex_; i <= lastIndex_; ++i)
          {
            _functor->apply( &storage[i] );
          }
        }
        template<class _TFunctor_>
        inline void iterateVoxels( IndexVec _firstIndex, IndexVec _lastIndex, _TFunctor_* _functor) const
        {
          int firstIndex_ = _firstIndex( 0 );
          if( firstIndex_ < m_firstIndex ) firstIndex_ = m_firstIndex;
          int lastIndex_ = _lastIndex( 0 );
          for(MapObject_cit it = storage.find(firstIndex_); it->first <= lastIndex_ and it != storage.end(); ++it)
          {
            _functor->apply( &it->second );
          }
        }
        template<class _TFunctor_>
        inline void iterateAllVoxels( _TFunctor_* functor)
        {
          for(MapObject_it it = storage.begin(); it != storage.end(); ++it)
          {
            functor->apply( &it->second );
          }
        }
        template<class _TFunctor_>
        inline void iterateAllVoxels( _TFunctor_* functor) const
        {
          for(MapObject_cit it = storage.begin(); it != storage.end(); ++it)
          {
            functor->apply( &it->second );
          }
        }
      private:
        int m_firstIndex;
        int m_lastIndex;
        MapObject storage;
    };
    template<int _dimension_, class _TObject_>
    struct AtomBoundingBoxGetter {
      public:
        inline static BoundingBox<_dimension_> boundingBox( const _TObject_* obj)
        {
          return obj->atom().boundingBox();
        }
    };
    template<int _dimension_, class _TObject_, class _BoundingBoxGetter_>
    class VoxelSpace;
    template<int _dimension_, class _TObject_, class _BoundingBoxGetter_>
    std::ostream& operator<<(std::ostream& s, const VoxelSpace<_dimension_, _TObject_, _BoundingBoxGetter_>&);
    template<int _dimension_, class _TObject_, class _BoundingBoxGetter_>
    class VoxelSpace {
      friend std::ostream& operator<<<>(std::ostream& s, const VoxelSpace<_dimension_, _TObject_, _BoundingBoxGetter_>&);

      typedef geom::BoundingBox<_dimension_> BoundingBoxD;
      typedef typename Atom<_dimension_>::HomogenousVecD HomogenousVecD;
      typedef boost::numeric::ublas::bounded_vector<int, _dimension_> IndexVec;
      typedef std::list<_TObject_*> ObjectsList;
      typedef typename ObjectsList::iterator ObjectsList_it;
      typedef typename ObjectsList::const_iterator ObjectsList_cit;
    private:
    struct InsertFunctor;
    struct RemoveFunctor;
      public:
        class Voxel {
          friend class VoxelSpace<_dimension_, _TObject_, _BoundingBoxGetter_>;
          friend struct VoxelSpace<_dimension_, _TObject_, _BoundingBoxGetter_>::InsertFunctor;
          friend struct VoxelSpace<_dimension_, _TObject_, _BoundingBoxGetter_>::RemoveFunctor;
          public:
            Voxel()
            {
            }
            const std::list<_TObject_*>& objects() const { return m_objects; }
          private:
            void insertObject(_TObject_* object) { m_objects.push_back( object); }
            void removeObject(_TObject_* object) { m_objects.remove( object); }
          private:
            ObjectsList m_objects;
        };
      public:
        VoxelSpace(double voxelSize_);
        ~VoxelSpace();
      public:
        void insertObject(_TObject_* object);
        void removeObject(_TObject_* object);
        std::list<const Voxel*> voxelsCountaining( const _TObject_* object) const;
        std::list<_TObject_*> objectsIn( const BoundingBoxD&) const;
      private:
        IndexVec indexFor(const HomogenousVecD& v ) const;
      private:
        JFR_DEFINE_PARAM_RO(double, voxelSize)
      private:
        VoxelMultiDimensionStorage<_dimension_, Voxel> m_voxels;
      private:
        // Functors
        struct RemoveFunctor {
          _TObject_* object;
          void apply( Voxel* v)
          {
            v->removeObject( object );
          }
        };
        struct InsertFunctor {
          _TObject_* object;
          void apply( Voxel* v)
          {
            v->insertObject( object );
          }
        };
        struct FindVoxelsFunctor {
          std::list< const Voxel*> voxels;
          void apply( const Voxel* v)
          {
            voxels.push_back( v);
          }
        };
        struct FindObjectsFunctor {
          std::list< _TObject_*> objects;
          BoundingBoxD boundingBox;
          void apply( const Voxel* v)
          {
            for( ObjectsList_cit it = v->objects().begin();
                 it != v->objects().end(); ++it)
            {
              if( std::find(objects.begin(), objects.end(), *it) == objects.end())
              {
                if( _BoundingBoxGetter_::boundingBox( *it ).overlap( boundingBox ) )
                {
                  objects.push_back( *it );
                }
              }
            }
          }
        };
        struct StreamFunctor {
          StreamFunctor(std::ostream& _stream) : stream(_stream) {}
          std::ostream& stream;
          void apply( const Voxel* v)
          {
            stream << "Voxel : { ";
            for( ObjectsList_cit it = v->objects().begin();
                 it != v->objects().end(); ++it)
            {
              if( it != v->objects().begin()) stream << " , ";
              stream << "( " << *it << " " << _BoundingBoxGetter_::boundingBox( *it ) << " " << **it << " )";
            }
            stream << " } ";
          }
        };
    };
  }
}

#include "geom/VoxelSpaceImpl.hpp"