Sphere.hpp

Go to the documentation of this file.

#ifndef SPHERE_HPP
#define SPHERE_HPP
 
#include <boost/fusion/sequence/intrinsic/at_c.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/fusion/include/vector_fwd.hpp>
#include "boost/multi_array.hpp"
#include "Point.hpp"
 
 
template<unsigned int dim ,typename T> class Sphere
{
    public:
 
    typedef boost::fusion::vector<T[dim],T> type;
 
    type data;
 
    static const unsigned int x = 0;
    static const unsigned int r = 1;
 
    __device__ __host__ T center(unsigned int i)
    {
        return boost::fusion::at_c<x>(data)[i];
    }
 
    __device__ __host__ Sphere(const Sphere<dim,T> & sph)
    {
        // Copy the center
        for (int i = 0 ;  i < dim ; i++)
        {
            boost::fusion::at_c<x>(data)[i] = boost::fusion::at_c<x>(sph.data)[i];
        }
 
        boost::fusion::at_c<r>(data) = boost::fusion::at_c<r>(sph.data);
    }
 
    template<unsigned int k>
    Sphere(boost::fusion::vector<T[k]> & c, T radius)
    {
        // Copy the center
        for (int i = 0 ;  i < dim ; i++)
        {
            boost::fusion::at_c<x>(data)[i] = boost::fusion::at_c<x>(c)[i];
        }
 
        boost::fusion::at_c<r>(data) = radius;
    }
 
    Sphere(Point<dim,double> & c, T radius)
    {
        // Copy the center
        for (int i = 0 ;  i < dim ; i++)
        {
            boost::fusion::at_c<x>(data)[i] = c.get(i);
        }
 
        boost::fusion::at_c<r>(data) = radius;
    }
 
    __device__ __host__ T radius() const
    {
        return boost::fusion::at_c<r>(data);
    }
 
    __device__ __host__ bool isInside(Point<dim,T> p) const
    {
        T dist = 0.0;
 
        // calculate the distance of the center from the point
 
        for (int i = 0; i < dim ; i++)
        {
            dist += (boost::fusion::at_c<x>(data)[i] - p.get(i) )*(boost::fusion::at_c<x>(data)[i] - p.get(i) );
        }
 
        // Check if the distance is smaller than the radius
 
        if (dist <= boost::fusion::at_c<r>(data)*boost::fusion::at_c<r>(data))
        {return true;}
 
 
        return false;
    }
 
    template<typename Distance>
    __device__ __host__ bool isInside(Point<dim,T> p) const
    {
        T dist = 0.0;
 
        // Object to calculate distances
        Distance d;
 
        // calculate the distance of the center from the point
 
        for (int i = 0; i < dim ; i++)
        {
            dist += d.accum_dist(boost::fusion::at_c<x>(data)[i],p.get(i) );
        }
 
        // Check if the distance is smaller than the radius
 
        if (dist <= boost::fusion::at_c<r>(data))
        {return true;}
 
 
        return false;
    }
 
    template<typename Distance> bool
    __device__ __host__ isInside(float * pnt) const
    {
        T dist = 0.0;
 
        // Object to calculate distances
        Distance d;
 
        // calculate the distance of the center from the point
 
        for (int i = 0; i < dim ; i++)
        {
            dist += d.accum_dist(boost::fusion::at_c<x>(data)[i],pnt[i],i);
        }
 
        // Check if the distance is smaller than the radius
 
        if (dist <= boost::fusion::at_c<r>(data))
        {return true;}
 
        return false;
    }
 
    __device__ __host__ T distance(Point<dim,T> & p) const
    {
        T dist = 0.0;
 
        // calculate the distance of the center from the point
 
        for (int i = 0; i < dim ; i++)
        {
            dist += (boost::fusion::at_c<x>(data)[i] - p.get(i))*(boost::fusion::at_c<x>(data)[i] - p.get(i));
        }
 
        return sqrt(dist) - radius();
    }
};
 
#endif