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