MC_grid_index_spatial_hashing.cpp

Go to the documentation of this file.

#include <MC_grid_index_spatial_hashing.hpp>

namespace mesh_conv
{
    MC_grid_index_spatial_hashing::MC_grid_index_spatial_hashing(){}
    MC_grid_index_spatial_hashing::MC_grid_index_spatial_hashing(const MC_int_vector& grid_size)
    {
        index_grid=MC_grid_3d<std::set<int> >(grid_size);
    }
    MC_int_vector MC_grid_index_spatial_hashing::size() const
    {
        return index_grid.size();
    }

    void MC_grid_index_spatial_hashing::add_index(const MC_int_vector& X,const int index)
    {
        index_grid.get(X).insert(index);
    }
    void MC_grid_index_spatial_hashing::delete_index(const MC_int_vector& X,const int index)
    {
        index_grid.get(X).erase(index);
    }
    std::set<int>& MC_grid_index_spatial_hashing::get(const MC_int_vector& X)
    {
        return index_grid.get(X);
    }
    const std::set<int>& MC_grid_index_spatial_hashing::get(const MC_int_vector& X) const
    {
        return index_grid.get(X);
    }

    void MC_grid_index_spatial_hashing::add_sphere(const MC_v3d& center,const double& radius,const int& id)
    {
        MC_int_vector_vector voxel=get_voxel_within_sphere(center,radius);

        for(unsigned int k=0,N=voxel.size();k<N;++k)
            add_index(voxel[k],id);
    }
    std::set<int> MC_grid_index_spatial_hashing::neighboors_index_in_radius(const MC_v3d& center,const double& radius) const
    {
        MC_int_vector_vector voxel=get_voxel_within_sphere(center,radius);

        std::set<int> index_neighbors;
        for(unsigned int k=0,N=voxel.size();k<N;++k)
        {
            std::set<int> current_index=get(MC_int_vector(voxel[k]));
            for(std::set<int>::const_iterator it=current_index.begin(),it_end=current_index.end();it!=it_end;++it)
                index_neighbors.insert(*it);
        }
        return index_neighbors;
    }

    MC_int_vector_vector MC_grid_index_spatial_hashing::get_voxel_within_sphere(const MC_v3d& center,const double& radius) const
    {
        MC_int_vector_vector v_voxel;

        MC_int_vector X0=MC_int_vector(
                static_cast<int>(center[0]),
                static_cast<int>(center[1]),
                static_cast<int>(center[2])
                );


        int radius_int=static_cast<int>(radius+1.0);

        for(int k_x=-radius_int;k_x<=radius_int;++k_x)
        {
            for(int k_y=-radius_int;k_y<=radius_int;++k_y)
            {
                for(int k_z=-radius_int;k_z<=radius_int;++k_z)
                {
                    if( (k_x*k_x+k_y*k_y+k_z*k_z)<=radius_int*radius_int )
                    {
                        MC_int_vector y=X0+MC_int_vector(k_x,k_y,k_z);
                        if(is_in_bound(y))
                            v_voxel.add(y);
                    }
                }
            }
        }

        return v_voxel;

    }

    void MC_grid_index_spatial_hashing::clear()
    {
        index_grid.fill(MC_int_vector().to_set());
    }

    bool MC_grid_index_spatial_hashing::is_in_bound(const MC_int_vector& position) const
    {
        const MC_int_vector& dim=size();
        if(position[0]>=0 && position[0]<dim[0])
            if(position[1]>=0 && position[1]<dim[1])
                if(position[2]>=0 && position[2]<dim[2])
                    return true;
        return false;
    }

}