VoxelOctree.hpp

Go to the documentation of this file.

#ifndef _VOXOMAP_VOXELOCTREE_HPP_
#define _VOXOMAP_VOXELOCTREE_HPP_
 
#include <type_traits>
#include "../octree/Octree.hpp"
#include "VoxelNode.hpp"
#include "../utils/BoundingBox.hpp"
 
namespace voxomap
{
 
template <class T_Container> class VoxelNode;
 
template <class T_Container>
class VoxelOctree : public Octree<VoxelNode<T_Container>>
{
public:
    using VoxelData = typename T_Container::VoxelData;
    using iterator = typename T_Container::iterator;
 
    VoxelOctree();
    VoxelOctree(VoxelOctree<T_Container> const& other);
    VoxelOctree(VoxelOctree<T_Container>&& other);
    virtual ~VoxelOctree() = default;
    VoxelOctree& operator=(VoxelOctree<T_Container> const& other);
    VoxelOctree& operator=(VoxelOctree<T_Container>&& other);
 
    VoxelNode<T_Container>*                  push(VoxelNode<T_Container>& node) override;
    std::unique_ptr<VoxelNode<T_Container>>  pop(VoxelNode<T_Container>& node) override;
    void                    clear() override;
    template <typename T>
    iterator                findVoxel(T x, T y, T z);
    template <typename T>
    VoxelNode<T_Container>* findVoxelNode(T x, T y, T z) const;
    
    template <typename T, typename... Args>
    std::pair<iterator, bool> addVoxel(T x, T y, T z, Args&&... args);
    template <typename T, typename... Args>
    iterator                updateVoxel(T x, T y, T z, Args&&... args);
    template <typename... Args>
    iterator                updateVoxel(iterator it, Args&&... args);
    template <typename T, typename... Args>
    iterator                putVoxel(T x, T y, T z, Args&&... args);
 
    template <typename T, typename... Args>
    bool                    removeVoxel(T x, T y, T z, Args&&... args);
    template <typename... Args>
    bool                    removeVoxel(iterator it, Args&&... args);
 
    unsigned int            getContainerSize() const;
 
    //void                    calculBoundingBox(Core::RectHitbox &hitbox) const;
    void                    removeOfCache(VoxelNode<T_Container> const& node);
 
    void                    exploreVoxel(std::function<void(iterator const&)> const& predicate) const;
    void                    exploreVoxelContainer(std::function<void(typename T_Container::VoxelContainer const&)> const& predicate) const;
    void                    exploreVoxelNode(std::function<void(VoxelNode<T_Container> const&)> const& predicate) const;
    void                    exploreBoundingBox(BoundingBox<int> const& bounding_box,
                                               std::function<void(VoxelNode<T_Container>&)> const& in_predicate,
                                               std::function<void(VoxelNode<T_Container>&)> const& out_predicate);
 
    unsigned int            getNbVoxels() const;
    void                    setNbVoxels(unsigned int nbVoxels);
 
    iterator                begin();
    iterator                end();
 
    void                    serialize(std::string& str) const;
    size_t                  unserialize(char const* str, size_t strsize);
 
private:
    iterator _findVoxel(int x, int y, int z);
    template <typename T>
    typename std::enable_if<std::is_floating_point<T>::value, iterator>::type _findVoxel(T x, T y, T z);
 
    VoxelNode<T_Container>*      _findVoxelNode(int x, int y, int z) const;
    template <typename T>
    typename std::enable_if<std::is_floating_point<T>::value, VoxelNode<T_Container>*>::type _findVoxelNode(T x, T y, T z) const;
 
protected:
    VoxelNode<T_Container>*      pushContainerNode(int x, int y, int z);
    template <typename T>
    typename std::enable_if<std::is_floating_point<T>::value, VoxelNode<T_Container>*>::type pushContainerNode(T x, T y, T z);
 
    mutable VoxelNode<T_Container>* _nodeCache = nullptr;   
    unsigned int                    _nbVoxels = 0;          
};
 
}
 
#include "VoxelOctree.ipp"
 
#endif // _VOXOMAP_VOXELOCTREE_HPP_