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