intersection_tools.h

Go to the documentation of this file.

/*
 * intersection_tools.h
 *
 *  Created on: Apr 17, 2016
 *      Author: Thiago Milanetto Schlittler
 */

#ifndef COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_TOOLS_H_
#define COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_TOOLS_H_

#include "carl_headers.h"
#include "mesh_tables.h"

namespace carl
{

// ************************
// Intersection_Tools class
// ************************

class   Intersection_Tools
{
protected:

    // Nef polyhedrons
    Nef_Polyhedron m_nef_A;     
    Nef_Polyhedron m_nef_B;
    Nef_Polyhedron m_nef_I;
    Nef_Polyhedron m_nef_C;

    Nef_Polyhedron m_nef_I_AC;

    // Exact point vectors
    std::vector<ExactPoint_3> m_exact_points_A; 
    std::vector<ExactPoint_3> m_exact_points_B;
    std::vector<ExactPoint_3> m_exact_points_C;

    ExactPolyhedron m_dummyPoly; 

    CGAL::Convex_hull_traits_3<ExactKernel> ExactHullTraits; 

    // CGAL Kernel converters
    Kernel_to_ExactKernel ConvertInexactToExact;    
    ExactKernel_to_Kernel ConvertExactToInexact;    

    // Dummy exact tetrahedron and triangle
    ExactTetrahedron    m_test_tetra;
    ExactTriangle_3     m_test_triangle;

    double m_Min_Inter_Volume;  

    // Perflog and debug variables
    bool MASTER_bPerfLog_intersection_tools; 
    libMesh::PerfLog m_perf_log;             

    // Data structures
    /*
     *      CGAL's "do_intersect" methods only works with tetrahedrons and triangles, at most.
     *  The vectors below map an TET or HEX element to its decomposition with tetrahedrons and
     *  triangles (which is trivial for the TET elements).
     */
    std::vector<std::vector<unsigned int> > m_TET_tetrahedrons; 
    std::vector<std::vector<unsigned int> > m_TET_triangles;    
    std::vector<std::vector<unsigned int> > m_TET_edges;        

    std::vector<std::vector<unsigned int> > m_HEX_tetrahedrons; 
    std::vector<std::vector<unsigned int> > m_HEX_triangles;    
    std::vector<std::vector<unsigned int> > m_HEX_edges;        

    std::vector<std::vector<unsigned int> > * m_elem_C_tetrahedrons;    
    std::vector<std::vector<unsigned int> > * m_elem_C_triangles;       

    // PROTECTED methods
    void set_element_indexes();

    bool elements_do_intersect(
            std::vector<ExactPoint_3> & elem_C_points,
            std::vector<std::vector<unsigned int> > & elem_C_tetras,
            std::vector<std::vector<unsigned int> > & elem_C_triangles,
            std::vector<ExactPoint_3> & elem_D_points,
            std::vector<std::vector<unsigned int> > & elem_D_tetras,
            std::vector<std::vector<unsigned int> > & elem_D_triangles);

public:

    // Constructors
    Intersection_Tools(const libMesh::Elem * elem_C, double Min_Inter_Volume = 1E-21, bool bDoPerf_log = false) :
        m_Min_Inter_Volume { Min_Inter_Volume },
        MASTER_bPerfLog_intersection_tools {bDoPerf_log},
        m_perf_log { libMesh::PerfLog("Intersection tools", MASTER_bPerfLog_intersection_tools) }
    {
        m_exact_points_A.resize(8);
        m_exact_points_B.resize(8);
        m_exact_points_C.resize(8);

        m_dummyPoly.reserve(8,18,12);

        this->libmesh_set_coupling_nef_polyhedron(elem_C);

        this->set_element_indexes();

        m_elem_C_tetrahedrons = NULL;
        m_elem_C_triangles = NULL;
    };

    Intersection_Tools(double Min_Inter_Volume = 1E-21, bool bDoPerf_log = false) :
        m_Min_Inter_Volume { Min_Inter_Volume },
        MASTER_bPerfLog_intersection_tools {bDoPerf_log},
        m_perf_log { libMesh::PerfLog("Intersection tools", MASTER_bPerfLog_intersection_tools) }
    {
        m_exact_points_A.resize(8);
        m_exact_points_B.resize(8);
        m_exact_points_C.resize(8);

        m_dummyPoly.reserve(8,18,12);

        m_nef_C.clear(Nef_Polyhedron::EMPTY);

        this->set_element_indexes();

        m_elem_C_tetrahedrons = NULL;
        m_elem_C_triangles = NULL;
    };

    // PUBLIC methods
    const libMesh::Elem * FindFirstIntersection(    const libMesh::Elem * Query_elem,
                                std::unique_ptr<libMesh::PointLocatorBase> & point_locator,
                                bool                bGuaranteeQueryIsInMesh = false);

    bool FindAllIntersection(   const libMesh::Elem * Query_elem,
                                std::unique_ptr<libMesh::PointLocatorBase> & point_locator,
                                std::set<unsigned int>  &   Intersecting_elems);

    bool libMesh_exact_do_intersect(const libMesh::Elem * elem_A,
                                    const libMesh::Elem * elem_B);

    bool libMesh_exact_intersection(const libMesh::Elem * elem_A,
                                    const libMesh::Elem * elem_B,
                                    std::set<Point_3> & points_out,
                                    bool bCreateNewNefForA = true,
                                    bool bConvertPoints = true,
                                    bool bTestNeeded = true);

    bool libMesh_exact_do_intersect_inside_coupling(const libMesh::Elem * elem_A,
                                                    const libMesh::Elem * elem_B,
                                                    bool bCreateNewNefForA = true);

    bool libMesh_exact_intersection_inside_coupling(const libMesh::Elem * elem_A,
                                                    const libMesh::Elem * elem_B,
                                                    std::set<libMesh::Point> & points_out,
                                                    bool bCreateNewNefForA = true,
                                                    bool bConvertPoints = true,
                                                    bool bTestNeeded = false);

    void libmesh_set_coupling_nef_polyhedron(const libMesh::Elem * elem_C);

    void convert_elem_to_exact_points(  const libMesh::Elem       * elem_input,
                                        std::vector<ExactPoint_3> & points_output);

    void convert_exact_points_to_Nef(std::vector<ExactPoint_3>::const_iterator it_begin,
                                     std::vector<ExactPoint_3>::const_iterator it_end,
                                     Nef_Polyhedron & nef_out);
};
}

#endif /* COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_TOOLS_H_ */