AdaptiveCylinderCone.hpp

#ifndef ADAPTIVE_CONE_HPP_
#define ADAPTIVE_CONE_HPP_
 
#include <boost/fusion/include/mpl.hpp>
#include "Space/Shape/Box.hpp"
#include "Space/Shape/Point.hpp"
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/for_each.hpp>
 
template<typename S>
struct copy_acc
{
    const S * ptr;
 
    copy_acc(const S * ptr)
    :ptr(ptr){};
 
    template<typename T>
    void operator()(T& t) const
    {
        t = ptr[t];
    }
};
 
template<unsigned int dim , typename T>
class AdaptiveCylinderCone
{
    typedef Point<dim,T> PointA;
 
    public:
 
    typedef boost::fusion::vector<T[dim]> type;
 
    type data;
 
    static const unsigned int p1 = 0;
 
    template <typename distance>  bool Intersect(Box<dim,T> b)
    {
//      std::cout << "Intersection between" << "\n";
/*      for (int i = 0 ; i < dim ; i++)
        {
                std::cout << "Box: " << boost::fusion::at_c<0>(b.data)[i] << "     " << boost::fusion::at_c<1>(b.data)[i] << "\n";
        }*/
 
        // We have to check if the upper-base of the box intersect the shape, if not we have done
 
        // we get the upper base that is a box of dimension dim-1
        Box<dim-1,T> upBase = b.getSubBox();
 
        // Get the up level
        T up = b.template getBase<Base::UP>(dim-1);
 
        // we get the circle of dimension n-1 at the same level of the upper base of the box
 
        // this is the radius of the circle
        T r_p = 0;
 
        // if the plane is at lower level than the point r_p is the cylinder radius
        // otherwise is the cone cut
 
        if (b.template getBase<Base::UP>(dim-1) < boost::fusion::at_c<PointA::x>(data)[dim-1] )
        {
            r_p = boost::fusion::at_c<PointA::x>(data)[dim-1];
        }
        else
        {
            // r_p is the cone cut (plane of base box cutting the cone)
 
            r_p = b.template getBase<Base::UP>(dim-1);
        }
 
        // Create the cone-cylinder cut with the plane of the base
        Sphere<dim-1,T> acon(data,up);
 
        return upBase.Intersect<distance>(acon);
    }
 
    template <typename distance>  bool Intersect(Box<dim,T> b, int div, T * dists, T & minsqdistance)
    {
        // we simply ignore all the optimization parameters we just check that
        // the box intersect the adaptive cone
 
        return Intersect<distance>(b);
    }
 
 
    AdaptiveCylinderCone(const T * pt)
    {
        // for all components from the pt and fill the center point of the
        // Adaptive Cylinder Cone
 
        for (int i = 0 ; i < dim ; i++)
        {
            boost::fusion::at_c<0>(data)[i] = pt[i];
        }
    }
 
    template<typename Distance> bool isInside(Point<dim,T> pnt)
    {
        // Check if the point is inside the Adaptive cone
 
        // get the radius
 
        T r = pnt.get(dim-1);
 
        // create a sphere
 
        Sphere<dim-1,T> sphere(data,r);
 
        sphere.isInside<Distance>(pnt.getSubPoint(dim-1));
    }
 
    template<typename Distance> bool isInside(float * pnt)
    {
        // Check if the point is inside the Adaptive cone
 
        // get the radius
 
        T r = pnt[dim-1];
 
        // create a sphere
 
        Sphere<dim-1,T> sphere(data,r);
 
        sphere.isInside<Distance>(pnt);
    }
};
 
#endif