VoxelNode.hpp

Go to the documentation of this file.

#ifndef _VOXOMAP_VOXELNODE_HPP_
#define _VOXOMAP_VOXELNODE_HPP_
 
#include <cstdint>
#include <map>
#include <memory>
#include <functional>
#include "../octree/Node.hpp"
#include "../utils/BoundingBox.hpp"
 
namespace voxomap
{
 
template <class T_Container> class VoxelOctree;
 
template <class T_Container>
class VoxelNode : public Node<VoxelNode<T_Container>>
{
public:
    using Container = T_Container;
    using VoxelData = typename T_Container::VoxelData;
    using iterator = typename T_Container::iterator;
    using P_Node = Node<VoxelNode<T_Container>>;
 
    struct NeighborAreaCache
    {
        NeighborAreaCache();
 
        std::map<Vector3I, VoxelNode<T_Container>*> nodes;   
        std::pair<VoxelNode<T_Container>*, bool> neighbor_nodes[3][3][3]; 
    };
 
    VoxelNode(int x, int y, int z, int size);
    VoxelNode(VoxelNode const& other);
    virtual ~VoxelNode() = default;
 
    iterator                begin();
    iterator                end();
 
    unsigned int            getNbVoxel() const;
    bool                    hasVoxel() const;
    T_Container*            getVoxelContainer();
    T_Container const*      getVoxelContainer() const;
    std::shared_ptr<T_Container>    getSharedVoxelContainer();
    void                    setVoxelContainer(std::shared_ptr<T_Container> container);
    iterator                findVoxel(int x, int y, int z);
    bool                    findVoxel(iterator& it);
    iterator                findRelativeVoxel(int x, int y, int z) const;
    iterator                findRelativeVoxel(NeighborAreaCache& neighbor_cache, int x, int y, int z) const;
    template <typename... Args>
    bool                    addVoxel(iterator& it, Args&&... args);
    template <typename... Args>
    bool                    updateVoxel(iterator& it, Args&&... args);
    template <typename... Args>
    void                    putVoxel(iterator& it, Args&&... args);
    template <typename... Args>
    bool                    removeVoxel(iterator const& it, Args&&... args);
 
    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 const&)> const& predicate) const;
    void                    exploreVoxelNode(std::function<void(VoxelNode&)> const& predicate);
    void                    exploreBoundingBox(BoundingBox<int> const& bounding_box,
                                               std::function<void(VoxelNode&)> const& in_predicate,
                                               std::function<void(VoxelNode&)> const& out_predicate);
 
    void                    copyOnWrite();
    void                    merge(VoxelNode& node);
    bool                    empty() const;
    void                    serialize(std::string& str) const;
    size_t                  unserialize(char const* str, size_t strsize);
 
private:
    uint32_t                serializeNode(std::string& str) const;
    
    std::shared_ptr<T_Container> _container;  
    friend T_Container;
 
public:
    inline static int       findContainerPosition(int src, int container_id);
    inline static int       findVoxelPosition(int src);
};
 
}
 
#include "VoxelNode.ipp"
 
#endif // _VOXOMAP_VOXELNODE_HPP_