igl::copyleft::cgal Namespace Reference

Namespaces
namespace	points_inside_component_helper

Classes
class	BinaryWindingNumberOperations
class	BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_INTERSECT >
class	BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_MINUS >
class	BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_RESOLVE >
class	BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_UNION >
class	BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_XOR >
class	CSGTree
struct	RemeshSelfIntersectionsParam
class	SelfIntersectMesh
class	WindingNumberFilter
class	WindingNumberFilter< KEEP_ALL >
class	WindingNumberFilter< KEEP_INSIDE >

Typedefs
typedef BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_UNION >	BinaryUnion
typedef BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_INTERSECT >	BinaryIntersect
typedef BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_MINUS >	BinaryMinus
typedef BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_XOR >	BinaryXor
typedef BinaryWindingNumberOperations< MESH_BOOLEAN_TYPE_RESOLVE >	BinaryResolve
typedef WindingNumberFilter< KEEP_INSIDE >	KeepInside
typedef WindingNumberFilter< KEEP_ALL >	KeepAll

Enumerations
enum	KeeperType { KEEP_INSIDE , KEEP_ALL }

Functions
template<typename DerivedC , typename DerivedD >
IGL_INLINE void	assign (const Eigen::MatrixBase< DerivedC > &C, Eigen::PlainObjectBase< DerivedD > &D)
template<typename ReturnScalar , typename DerivedC >
IGL_INLINE Eigen::Matrix< ReturnScalar, DerivedC::RowsAtCompileTime, DerivedC::ColsAtCompileTime, 1, DerivedC::MaxRowsAtCompileTime, DerivedC::MaxColsAtCompileTime >	assign (const Eigen::MatrixBase< DerivedC > &C)
IGL_INLINE void	assign_scalar (const CGAL::Epeck::FT &cgal, CGAL::Epeck::FT &d)
IGL_INLINE void	assign_scalar (const CGAL::Epeck::FT &cgal, double &d)
IGL_INLINE void	assign_scalar (const CGAL::Epeck::FT &cgal, float &d)
IGL_INLINE void	assign_scalar (const double &c, double &d)
IGL_INLINE void	assign_scalar (const float &c, float &d)
IGL_INLINE void	assign_scalar (const float &c, double &d)
IGL_INLINE void	assign_scalar (const CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &cgal, CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &d)
IGL_INLINE void	assign_scalar (const CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &cgal, double &d)
IGL_INLINE void	assign_scalar (const CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &cgal, float &d)
IGL_INLINE void	assign_scalar (const CGAL::Simple_cartesian< mpq_class >::FT &cgal, CGAL::Simple_cartesian< mpq_class >::FT &d)
IGL_INLINE void	assign_scalar (const CGAL::Simple_cartesian< mpq_class >::FT &cgal, double &d)
IGL_INLINE void	assign_scalar (const CGAL::Simple_cartesian< mpq_class >::FT &cgal, float &d)
template<typename DerivedC >
IGL_INLINE void	cell_adjacency (const Eigen::PlainObjectBase< DerivedC > &per_patch_cells, const size_t num_cells, std::vector< std::set< std::tuple< typename DerivedC::Scalar, bool, size_t > > > &adjacency_list)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedP , typename uE2EType , typename DerivedEMAP , typename DerivedR , typename DerivedS >
IGL_INLINE void	closest_facet (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, const Eigen::PlainObjectBase< DerivedP > &P, const std::vector< std::vector< uE2EType > > &uE2E, const Eigen::PlainObjectBase< DerivedEMAP > &EMAP, Eigen::PlainObjectBase< DerivedR > &R, Eigen::PlainObjectBase< DerivedS > &S)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename uE2EType , typename DerivedEMAP , typename DerivedR , typename DerivedS >
IGL_INLINE void	closest_facet (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedP > &P, const std::vector< std::vector< uE2EType > > &uE2E, const Eigen::PlainObjectBase< DerivedEMAP > &EMAP, Eigen::PlainObjectBase< DerivedR > &R, Eigen::PlainObjectBase< DerivedS > &S)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedP , typename uE2EType , typename DerivedEMAP , typename Kernel , typename DerivedR , typename DerivedS >
IGL_INLINE void	closest_facet (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, const Eigen::PlainObjectBase< DerivedP > &P, const std::vector< std::vector< uE2EType > > &uE2E, const Eigen::PlainObjectBase< DerivedEMAP > &EMAP, const std::vector< std::vector< size_t > > &VF, const std::vector< std::vector< size_t > > &VFi, const CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< typename Kernel::Triangle_3 >::iterator > > > &tree, const std::vector< typename Kernel::Triangle_3 > &triangles, const std::vector< bool > &in_I, Eigen::PlainObjectBase< DerivedR > &R, Eigen::PlainObjectBase< DerivedS > &S)
template<typename Tr , typename DerivedV , typename DerivedF >
IGL_INLINE bool	complex_to_mesh (const CGAL::Complex_2_in_triangulation_3< Tr > &c2t3, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedV , typename DerivedF , typename DerivedI >
IGL_INLINE bool	component_inside_component (const Eigen::PlainObjectBase< DerivedV > &V1, const Eigen::PlainObjectBase< DerivedF > &F1, const Eigen::PlainObjectBase< DerivedI > &I1, const Eigen::PlainObjectBase< DerivedV > &V2, const Eigen::PlainObjectBase< DerivedF > &F2, const Eigen::PlainObjectBase< DerivedI > &I2)
template<typename DerivedV , typename DerivedF >
IGL_INLINE bool	component_inside_component (const Eigen::PlainObjectBase< DerivedV > &V1, const Eigen::PlainObjectBase< DerivedF > &F1, const Eigen::PlainObjectBase< DerivedV > &V2, const Eigen::PlainObjectBase< DerivedF > &F2)
template<typename DerivedV , typename DerivedW , typename DerivedG >
IGL_INLINE void	convex_hull (const Eigen::MatrixBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedW > &W, Eigen::PlainObjectBase< DerivedG > &G)
template<typename DerivedV , typename DerivedF >
IGL_INLINE void	convex_hull (const Eigen::MatrixBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedV , typename DerivedF >
IGL_INLINE void	delaunay_triangulation (const Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedV , typename DerivedF , typename DerivedC >
IGL_INLINE size_t	extract_cells (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedC > &cells)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedE , typename DeriveduE , typename uE2EType , typename DerivedEMAP , typename DerivedC >
IGL_INLINE size_t	extract_cells (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DerivedE > &E, const Eigen::PlainObjectBase< DeriveduE > &uE, const std::vector< std::vector< uE2EType > > &uE2E, const Eigen::PlainObjectBase< DerivedEMAP > &EMAP, Eigen::PlainObjectBase< DerivedC > &cells)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename DeriveduE , typename uE2EType , typename DerivedEMAP , typename DerivedC >
IGL_INLINE size_t	extract_cells_single_component (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DeriveduE > &uE, const std::vector< std::vector< uE2EType > > &uE2E, const Eigen::PlainObjectBase< DerivedEMAP > &EMAP, Eigen::PlainObjectBase< DerivedC > &cells)
template<typename DerivedV , typename DerivedF , typename DerivedE >
IGL_INLINE void	extract_feature (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const double tol, Eigen::PlainObjectBase< DerivedE > &feature_edges)
template<typename DerivedV , typename DerivedF , typename DerivedE >
IGL_INLINE void	extract_feature (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const double tol, const Eigen::PlainObjectBase< DerivedE > &E, const Eigen::PlainObjectBase< DerivedE > &uE, const std::vector< std::vector< typename DerivedE::Scalar > > &uE2E, Eigen::PlainObjectBase< DerivedE > &feature_edges)
template<typename DerivedP , typename DerivedN , typename DerivedQ , typename BetaType , typename DerivedWN >
IGL_INLINE void	fast_winding_number (const Eigen::MatrixBase< DerivedP > &P, const Eigen::MatrixBase< DerivedN > &N, const Eigen::MatrixBase< DerivedQ > &Q, const int expansion_order, const BetaType beta, Eigen::PlainObjectBase< DerivedWN > &WN)
template<typename DerivedP , typename DerivedN , typename DerivedQ , typename DerivedWN >
IGL_INLINE void	fast_winding_number (const Eigen::MatrixBase< DerivedP > &P, const Eigen::MatrixBase< DerivedN > &N, const Eigen::MatrixBase< DerivedQ > &Q, Eigen::PlainObjectBase< DerivedWN > &WN)
template<typename DerivedV >
IGL_INLINE void	half_space_box (const CGAL::Plane_3< CGAL::Epeck > &P, const Eigen::MatrixBase< DerivedV > &V, Eigen::Matrix< CGAL::Epeck::FT, 8, 3 > &BV, Eigen::Matrix< int, 12, 3 > &BF)
template<typename Derivedp , typename Derivedn , typename DerivedV >
IGL_INLINE void	half_space_box (const Eigen::MatrixBase< Derivedp > &p, const Eigen::MatrixBase< Derivedn > &n, const Eigen::MatrixBase< DerivedV > &V, Eigen::Matrix< CGAL::Epeck::FT, 8, 3 > &BV, Eigen::Matrix< int, 12, 3 > &BF)
template<typename Derivedequ , typename DerivedV >
IGL_INLINE void	half_space_box (const Eigen::MatrixBase< Derivedequ > &equ, const Eigen::MatrixBase< DerivedV > &V, Eigen::Matrix< CGAL::Epeck::FT, 8, 3 > &BV, Eigen::Matrix< int, 12, 3 > &BF)
template<typename DerivedV , typename Kernel , typename Scalar >
IGL_INLINE void	hausdorff (const Eigen::MatrixBase< DerivedV > &V, const CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< CGAL::Triangle_3< Kernel > >::iterator > > > &treeB, const std::vector< CGAL::Triangle_3< Kernel > > &TB, Scalar &l, Scalar &u)
template<typename Scalar >
IGL_INLINE short	incircle (const Scalar pa[2], const Scalar pb[2], const Scalar pc[2], const Scalar pd[2])
template<typename Kernel >
IGL_INLINE void	insert_into_cdt (const CGAL::Object &obj, const CGAL::Plane_3< Kernel > &P, CGAL::Constrained_triangulation_plus_2< CGAL::Constrained_Delaunay_triangulation_2< Kernel, CGAL::Triangulation_data_structure_2< CGAL::Triangulation_vertex_base_2< Kernel >, CGAL::Constrained_triangulation_face_base_2< Kernel > >, CGAL::Exact_intersections_tag > > &cdt)
template<typename Scalar >
IGL_INLINE short	insphere (const Scalar pa[3], const Scalar pb[3], const Scalar pc[3], const Scalar pd[3], const Scalar pe[3])
template<typename DerivedF >
static IGL_INLINE void	push_result (const Eigen::PlainObjectBase< DerivedF > &F, const int f, const int f_other, const CGAL::Object &result, std::map< typename DerivedF::Index, std::vector< std::pair< typename DerivedF::Index, CGAL::Object > > > &offending)
template<typename Kernel , typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedIF , typename DerivedVVAB , typename DerivedFFAB , typename DerivedJAB , typename DerivedIMAB >
static IGL_INLINE bool	intersect_other_helper (const Eigen::PlainObjectBase< DerivedVA > &VA, const Eigen::PlainObjectBase< DerivedFA > &FA, const Eigen::PlainObjectBase< DerivedVB > &VB, const Eigen::PlainObjectBase< DerivedFB > &FB, const RemeshSelfIntersectionsParam &params, Eigen::PlainObjectBase< DerivedIF > &IF, Eigen::PlainObjectBase< DerivedVVAB > &VVAB, Eigen::PlainObjectBase< DerivedFFAB > &FFAB, Eigen::PlainObjectBase< DerivedJAB > &JAB, Eigen::PlainObjectBase< DerivedIMAB > &IMAB)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedIF , typename DerivedVVAB , typename DerivedFFAB , typename DerivedJAB , typename DerivedIMAB >
IGL_INLINE bool	intersect_other (const Eigen::PlainObjectBase< DerivedVA > &VA, const Eigen::PlainObjectBase< DerivedFA > &FA, const Eigen::PlainObjectBase< DerivedVB > &VB, const Eigen::PlainObjectBase< DerivedFB > &FB, const RemeshSelfIntersectionsParam &params, Eigen::PlainObjectBase< DerivedIF > &IF, Eigen::PlainObjectBase< DerivedVVAB > &VVAB, Eigen::PlainObjectBase< DerivedFFAB > &FFAB, Eigen::PlainObjectBase< DerivedJAB > &JAB, Eigen::PlainObjectBase< DerivedIMAB > &IMAB)
IGL_INLINE bool	intersect_other (const Eigen::MatrixXd &VA, const Eigen::MatrixXi &FA, const Eigen::MatrixXd &VB, const Eigen::MatrixXi &FB, const bool first_only, Eigen::MatrixXi &IF)
template<typename DerivedV , typename DerivedF , typename Derivedp , typename Derivedn , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	intersect_with_half_space (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, const Eigen::MatrixBase< Derivedp > &p, const Eigen::MatrixBase< Derivedn > &n, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedV , typename DerivedF , typename Derivedequ , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	intersect_with_half_space (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, const Eigen::MatrixBase< Derivedequ > &equ, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedV , typename DerivedF , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	intersect_with_half_space (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, const CGAL::Plane_3< CGAL::Epeck > &P, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedP , typename DerivedF >
IGL_INLINE void	lexicographic_triangulation (const Eigen::PlainObjectBase< DerivedP > &P, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	mesh_boolean (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::MatrixBase< DerivedVB > &VB, const Eigen::MatrixBase< DerivedFB > &FB, const MeshBooleanType &type, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	mesh_boolean (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::MatrixBase< DerivedVB > &VB, const Eigen::MatrixBase< DerivedFB > &FB, const std::string &type_str, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	mesh_boolean (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::MatrixBase< DerivedVB > &VB, const Eigen::MatrixBase< DerivedFB > &FB, const std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &wind_num_op, const std::function< int(const int, const int)> &keep, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedV , typename DerivedF , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	mesh_boolean (const std::vector< DerivedV > &Vlist, const std::vector< DerivedF > &Flist, const std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &wind_num_op, const std::function< int(const int, const int)> &keep, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedV , typename DerivedF , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	mesh_boolean (const std::vector< DerivedV > &Vlist, const std::vector< DerivedF > &Flist, const MeshBooleanType &type, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedVV , typename DerivedFF , typename Derivedsizes , typename DerivedVC , typename DerivedFC , typename DerivedJ >
IGL_INLINE bool	mesh_boolean (const Eigen::MatrixBase< DerivedVV > &VV, const Eigen::MatrixBase< DerivedFF > &FF, const Eigen::MatrixBase< Derivedsizes > &sizes, const std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &wind_num_op, const std::function< int(const int, const int)> &keep, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC >
IGL_INLINE bool	mesh_boolean (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::MatrixBase< DerivedVB > &VB, const Eigen::MatrixBase< DerivedFB > &FB, const MeshBooleanType &type, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC)
IGL_INLINE void	mesh_boolean_type_to_funcs (const MeshBooleanType &type, std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &wind_num_op, std::function< int(const int, const int)> &keep)
template<typename DerivedV , typename DerivedF , typename Kernel >
IGL_INLINE void	mesh_to_cgal_triangle_list (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, std::vector< CGAL::Triangle_3< Kernel > > &T)
template<typename Polyhedron >
IGL_INLINE bool	mesh_to_polyhedron (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, Polyhedron &poly)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedW , typename DerivedG , typename DerivedJ >
IGL_INLINE void	minkowski_sum (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::MatrixBase< DerivedVB > &VB, const Eigen::MatrixBase< DerivedFB > &FB, const bool resolve_overlaps, Eigen::PlainObjectBase< DerivedW > &W, Eigen::PlainObjectBase< DerivedG > &G, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedVA , typename DerivedFA , typename sType , int sCols, int sOptions, typename dType , int dCols, int dOptions, typename DerivedW , typename DerivedG , typename DerivedJ >
IGL_INLINE void	minkowski_sum (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::Matrix< sType, 1, sCols, sOptions > &s, const Eigen::Matrix< dType, 1, dCols, dOptions > &d, const bool resolve_overlaps, Eigen::PlainObjectBase< DerivedW > &W, Eigen::PlainObjectBase< DerivedG > &G, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedVA , typename DerivedFA , typename sType , int sCols, int sOptions, typename dType , int dCols, int dOptions, typename DerivedW , typename DerivedG , typename DerivedJ >
IGL_INLINE void	minkowski_sum (const Eigen::MatrixBase< DerivedVA > &VA, const Eigen::MatrixBase< DerivedFA > &FA, const Eigen::Matrix< sType, 1, sCols, sOptions > &s, const Eigen::Matrix< dType, 1, dCols, dOptions > &d, Eigen::PlainObjectBase< DerivedW > &W, Eigen::PlainObjectBase< DerivedG > &G, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedV , typename DerivedF , typename DerivedI >
IGL_INLINE void	order_facets_around_edge (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, size_t s, size_t d, const std::vector< int > &adj_faces, Eigen::PlainObjectBase< DerivedI > &order, bool debug=false)
template<typename DerivedV , typename DerivedF , typename DerivedI >
IGL_INLINE void	order_facets_around_edge (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, size_t s, size_t d, const std::vector< int > &adj_faces, const Eigen::PlainObjectBase< DerivedV > &pivot_point, Eigen::PlainObjectBase< DerivedI > &order)
template<typename DerivedV , typename DerivedF , typename DerivedN , typename DeriveduE , typename uE2EType , typename uE2oEType , typename uE2CType >
IGL_INLINE std::enable_if<!std::is_same< typenameDerivedV::Scalar, typenameCGAL::Exact_predicates_exact_constructions_kernel::FT >::value, void >::type	order_facets_around_edges (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedN > &N, const Eigen::PlainObjectBase< DeriveduE > &uE, const std::vector< std::vector< uE2EType > > &uE2E, std::vector< std::vector< uE2oEType > > &uE2oE, std::vector< std::vector< uE2CType > > &uE2C)
template<typename DerivedV , typename DerivedF , typename DerivedN , typename DeriveduE , typename uE2EType , typename uE2oEType , typename uE2CType >
IGL_INLINE std::enable_if< std::is_same< typenameDerivedV::Scalar, typenameCGAL::Exact_predicates_exact_constructions_kernel::FT >::value, void >::type	order_facets_around_edges (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedN > &N, const Eigen::PlainObjectBase< DeriveduE > &uE, const std::vector< std::vector< uE2EType > > &uE2E, std::vector< std::vector< uE2oEType > > &uE2oE, std::vector< std::vector< uE2CType > > &uE2C)
template<typename DerivedV , typename DerivedF , typename DeriveduE , typename uE2EType , typename uE2oEType , typename uE2CType >
IGL_INLINE void	order_facets_around_edges (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DeriveduE > &uE, const std::vector< std::vector< uE2EType > > &uE2E, std::vector< std::vector< uE2oEType > > &uE2oE, std::vector< std::vector< uE2CType > > &uE2C)
template<typename Scalar >
IGL_INLINE short	orient2D (const Scalar pa[2], const Scalar pb[2], const Scalar pc[2])
template<typename Scalar >
IGL_INLINE short	orient3D (const Scalar pa[3], const Scalar pb[3], const Scalar pc[3], const Scalar pd[3])
template<typename DerivedV , typename DerivedF , typename DerivedI , typename IndexType , typename DerivedA >
IGL_INLINE void	outer_vertex (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, IndexType &v_index, Eigen::PlainObjectBase< DerivedA > &A)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename IndexType , typename DerivedA >
IGL_INLINE void	outer_edge (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, IndexType &v1, IndexType &v2, Eigen::PlainObjectBase< DerivedA > &A)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename IndexType >
IGL_INLINE void	outer_facet (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, IndexType &f, bool &flipped)
template<typename DerivedV , typename DerivedF , typename DerivedN , typename DerivedI , typename IndexType >
IGL_INLINE void	outer_facet (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedN > &N, const Eigen::PlainObjectBase< DerivedI > &I, IndexType &f, bool &flipped)
template<typename DerivedV , typename DerivedF , typename DerivedHV , typename DerivedHF , typename DerivedJ , typename Derivedflip >
IGL_INLINE void	outer_hull (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedHV > &HV, Eigen::PlainObjectBase< DerivedHF > &HF, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< Derivedflip > &flip)
template<typename DerivedV , typename DerivedF , typename DerivedG , typename DerivedJ , typename Derivedflip >
IGL_INLINE void	outer_hull_legacy (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedG > &G, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< Derivedflip > &flip)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename Derivedflip >
IGL_INLINE size_t	peel_outer_hull_layers (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedI > &I, Eigen::PlainObjectBase< Derivedflip > &flip)
template<typename DerivedV , typename DerivedF , typename DerivedW >
IGL_INLINE size_t	peel_winding_number_layers (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedW > &W)
template<typename DerivedV , typename DerivedF >
IGL_INLINE bool	piecewise_constant_winding_number (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedP , typename DerivedI , typename DerivedN , typename DerivedA >
IGL_INLINE void	point_areas (const Eigen::MatrixBase< DerivedP > &P, const Eigen::MatrixBase< DerivedI > &I, const Eigen::MatrixBase< DerivedN > &N, Eigen::PlainObjectBase< DerivedA > &A)
template<typename DerivedP , typename DerivedI , typename DerivedN , typename DerivedA , typename DerivedT >
IGL_INLINE void	point_areas (const Eigen::MatrixBase< DerivedP > &P, const Eigen::MatrixBase< DerivedI > &I, const Eigen::MatrixBase< DerivedN > &N, Eigen::PlainObjectBase< DerivedA > &A, Eigen::PlainObjectBase< DerivedT > &T)
template<typename Kernel , typename DerivedP , typename DerivedV , typename DerivedF , typename DerivedsqrD , typename DerivedI , typename DerivedC >
IGL_INLINE void	point_mesh_squared_distance (const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedsqrD > &sqrD, Eigen::PlainObjectBase< DerivedI > &I, Eigen::PlainObjectBase< DerivedC > &C)
template<typename Kernel , typename DerivedV , typename DerivedF >
IGL_INLINE void	point_mesh_squared_distance_precompute (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< CGAL::Triangle_3< Kernel > >::iterator > > > &tree, std::vector< CGAL::Triangle_3< Kernel > > &T)
template<typename Kernel , typename DerivedP , typename DerivedsqrD , typename DerivedI , typename DerivedC >
IGL_INLINE void	point_mesh_squared_distance (const Eigen::PlainObjectBase< DerivedP > &P, const CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< CGAL::Triangle_3< Kernel > >::iterator > > > &tree, const std::vector< CGAL::Triangle_3< Kernel > > &T, Eigen::PlainObjectBase< DerivedsqrD > &sqrD, Eigen::PlainObjectBase< DerivedI > &I, Eigen::PlainObjectBase< DerivedC > &C)
template<typename Kernel >
IGL_INLINE void	point_segment_squared_distance (const CGAL::Point_3< Kernel > &P1, const CGAL::Segment_3< Kernel > &S2, CGAL::Point_3< Kernel > &P2, typename Kernel::FT &d)
template<typename DerivedQ , typename DerivedVB , typename DerivedFB , typename DerivedD >
IGL_INLINE void	point_solid_signed_squared_distance (const Eigen::PlainObjectBase< DerivedQ > &Q, const Eigen::PlainObjectBase< DerivedVB > &VB, const Eigen::PlainObjectBase< DerivedFB > &FB, Eigen::PlainObjectBase< DerivedD > &D)
template<typename Kernel >
IGL_INLINE void	point_triangle_squared_distance (const CGAL::Point_3< Kernel > &P1, const CGAL::Triangle_3< Kernel > &T2, CGAL::Point_3< Kernel > &P2, typename Kernel::FT &d)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedP , typename DerivedB >
IGL_INLINE void	points_inside_component (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, const Eigen::PlainObjectBase< DerivedP > &P, Eigen::PlainObjectBase< DerivedB > &inside)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedB >
IGL_INLINE void	points_inside_component (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedP > &P, Eigen::PlainObjectBase< DerivedB > &inside)
template<typename Polyhedron , typename DerivedV , typename DerivedF >
IGL_INLINE void	polyhedron_to_mesh (const Polyhedron &poly, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename Kernel , typename Index >
IGL_INLINE void	projected_cdt (const std::vector< CGAL::Object > &objects, const CGAL::Plane_3< Kernel > &P, std::vector< CGAL::Point_3< Kernel > > &vertices, std::vector< std::vector< Index > > &faces)
template<typename Kernel , typename DerivedV , typename DerivedF >
IGL_INLINE void	projected_cdt (const std::vector< CGAL::Object > &objects, const CGAL::Plane_3< Kernel > &P, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename Kernel >
IGL_INLINE void	projected_delaunay (const CGAL::Triangle_3< Kernel > &A, const std::vector< CGAL::Object > &A_objects_3, CGAL::Constrained_triangulation_plus_2< CGAL::Constrained_Delaunay_triangulation_2< Kernel, CGAL::Triangulation_data_structure_2< CGAL::Triangulation_vertex_base_2< Kernel >, CGAL::Constrained_triangulation_face_base_2< Kernel > >, CGAL::Exact_intersections_tag > > &cdt)
template<typename DerivedV , typename DerivedF , typename DerivedL , typename DerivedW >
IGL_INLINE bool	propagate_winding_numbers (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedL > &labels, Eigen::PlainObjectBase< DerivedW > &W)
template<typename DerivedV , typename DerivedF , typename DeriveduE , typename uE2EType , typename DerivedP , typename DerivedC , typename DerivedL , typename DerivedW >
IGL_INLINE bool	propagate_winding_numbers (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DeriveduE > &uE, const std::vector< std::vector< uE2EType > > &uE2E, const size_t num_patches, const Eigen::PlainObjectBase< DerivedP > &P, const size_t num_cells, const Eigen::PlainObjectBase< DerivedC > &C, const Eigen::PlainObjectBase< DerivedL > &labels, Eigen::PlainObjectBase< DerivedW > &W)
template<typename DerivedV , typename DerivedF >
IGL_INLINE bool	read_triangle_mesh (const std::string str, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedC , typename FT , typename DerivedW >
IGL_INLINE void	relabel_small_immersed_cells (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const size_t num_patches, const Eigen::PlainObjectBase< DerivedP > &P, const size_t num_cells, const Eigen::PlainObjectBase< DerivedC > &C, const FT vol_threashold, Eigen::PlainObjectBase< DerivedW > &W)
template<typename DerivedV , typename DerivedF , typename Kernel , typename DerivedVV , typename DerivedFF , typename DerivedJ , typename DerivedIM >
IGL_INLINE void	remesh_intersections (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, const std::vector< CGAL::Triangle_3< Kernel > > &T, const std::map< typename DerivedF::Index, std::vector< std::pair< typename DerivedF::Index, CGAL::Object > > > &offending, bool stitch_all, Eigen::PlainObjectBase< DerivedVV > &VV, Eigen::PlainObjectBase< DerivedFF > &FF, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< DerivedIM > &IM)
template<typename DerivedV , typename DerivedF , typename Kernel , typename DerivedVV , typename DerivedFF , typename DerivedJ , typename DerivedIM >
IGL_INLINE void	remesh_intersections (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, const std::vector< CGAL::Triangle_3< Kernel > > &T, const std::map< typename DerivedF::Index, std::vector< std::pair< typename DerivedF::Index, CGAL::Object > > > &offending, Eigen::PlainObjectBase< DerivedVV > &VV, Eigen::PlainObjectBase< DerivedFF > &FF, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< DerivedIM > &IM)
template<typename DerivedV , typename DerivedF , typename DerivedVV , typename DerivedFF , typename DerivedIF , typename DerivedJ , typename DerivedIM >
IGL_INLINE void	remesh_self_intersections (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F, const RemeshSelfIntersectionsParam &params, Eigen::PlainObjectBase< DerivedVV > &VV, Eigen::PlainObjectBase< DerivedFF > &FF, Eigen::PlainObjectBase< DerivedIF > &IF, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< DerivedIM > &IM)
template<typename DerivedV , typename DerivedE , typename DerivedVI , typename DerivedEI , typename DerivedJ , typename DerivedIM >
IGL_INLINE void	resolve_intersections (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedE > &E, Eigen::PlainObjectBase< DerivedVI > &VI, Eigen::PlainObjectBase< DerivedEI > &EI, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< DerivedIM > &IM)
template<typename Kernel , typename DerivedV >
IGL_INLINE CGAL::Point_2< Kernel >	row_to_point (const Eigen::PlainObjectBase< DerivedV > &V, const typename DerivedV::Index &i)
template<typename Kernel >
IGL_INLINE bool	segment_segment_squared_distance (const CGAL::Segment_3< Kernel > &S1, const CGAL::Segment_3< Kernel > &S2, CGAL::Point_3< Kernel > &P1, CGAL::Point_3< Kernel > &P2, typename Kernel::FT &d)
IGL_INLINE bool	signed_distance_isosurface (const Eigen::MatrixXd &IV, const Eigen::MatrixXi &IF, const double level, const double angle_bound, const double radius_bound, const double distance_bound, const SignedDistanceType sign_type, Eigen::MatrixXd &V, Eigen::MatrixXi &F)
template<typename DerivedV , typename DerivedE , typename DerivedVI , typename DerivedEI , typename DerivedJ >
IGL_INLINE void	snap_rounding (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedE > &E, Eigen::PlainObjectBase< DerivedVI > &VI, Eigen::PlainObjectBase< DerivedEI > &EI, Eigen::PlainObjectBase< DerivedJ > &J)
IGL_INLINE bool	string_to_mesh_boolean_type (const std::string &s, MeshBooleanType &type)
IGL_INLINE MeshBooleanType	string_to_mesh_boolean_type (const std::string &s)
template<typename DerivedV , typename DerivedE , typename Kernel , typename DerivedVI , typename DerivedEI , typename DerivedJ , typename DerivedIM >
IGL_INLINE void	subdivide_segments (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedE > &E, const std::vector< std::vector< CGAL::Point_2< Kernel > > > &steiner, Eigen::PlainObjectBase< DerivedVI > &VI, Eigen::PlainObjectBase< DerivedEI > &EI, Eigen::PlainObjectBase< DerivedJ > &J, Eigen::PlainObjectBase< DerivedIM > &IM)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename Kernel >
IGL_INLINE void	submesh_aabb_tree (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedI > &I, CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< typename Kernel::Triangle_3 >::iterator > > > &tree, std::vector< typename Kernel::Triangle_3 > &triangles, std::vector< bool > &in_I)
template<typename Kernel >
IGL_INLINE bool	triangle_triangle_squared_distance (const CGAL::Triangle_3< Kernel > &T1, const CGAL::Triangle_3< Kernel > &T2, CGAL::Point_3< Kernel > &P1, CGAL::Point_3< Kernel > &P2, typename Kernel::FT &d)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedV , typename DerivedF , typename DerivedD , typename DerivedJ >
IGL_INLINE void	trim_with_solid (const Eigen::PlainObjectBase< DerivedVA > &VA, const Eigen::PlainObjectBase< DerivedFA > &FA, const Eigen::PlainObjectBase< DerivedVB > &VB, const Eigen::PlainObjectBase< DerivedFB > &FB, Eigen::PlainObjectBase< DerivedV > &Vd, Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedD > &D, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedWV , typename DerivedWE , typename DerivedV , typename DerivedF , typename DerivedJ >
IGL_INLINE void	wire_mesh (const Eigen::MatrixBase< DerivedWV > &WV, const Eigen::MatrixBase< DerivedWE > &WE, const double th, const int poly_size, const bool solid, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedWV , typename DerivedWE , typename DerivedV , typename DerivedF , typename DerivedJ >
IGL_INLINE void	wire_mesh (const Eigen::MatrixBase< DerivedWV > &WV, const Eigen::MatrixBase< DerivedWE > &WE, const double th, const int poly_size, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedJ > &J)

Typedef Documentation

BinaryIntersect

typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_INTERSECT> igl::copyleft::cgal::BinaryIntersect

BinaryMinus

typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_MINUS> igl::copyleft::cgal::BinaryMinus

BinaryResolve

typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_RESOLVE> igl::copyleft::cgal::BinaryResolve

BinaryUnion

typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_UNION> igl::copyleft::cgal::BinaryUnion

BinaryXor

typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_XOR> igl::copyleft::cgal::BinaryXor

KeepAll

typedef WindingNumberFilter<KEEP_ALL> igl::copyleft::cgal::KeepAll

KeepInside

typedef WindingNumberFilter<KEEP_INSIDE> igl::copyleft::cgal::KeepInside

Enumeration Type Documentation

KeeperType

enum igl::copyleft::cgal::KeeperType

Enumerator
KEEP_INSIDE
KEEP_ALL

                      {
        KEEP_INSIDE,
        KEEP_ALL
      };

Function Documentation

assign() [1/2]

template<typename ReturnScalar , typename DerivedC >

IGL_INLINE Eigen::Matrix< ReturnScalar, DerivedC::RowsAtCompileTime, DerivedC::ColsAtCompileTime, 1, DerivedC::MaxRowsAtCompileTime, DerivedC::MaxColsAtCompileTime > igl::copyleft::cgal::assign

(

const Eigen::MatrixBase< DerivedC > &

C

)

{
  Eigen::Matrix<
    ReturnScalar,
    DerivedC::RowsAtCompileTime, 
    DerivedC::ColsAtCompileTime, 
    1,
    DerivedC::MaxRowsAtCompileTime, 
    DerivedC::MaxColsAtCompileTime> D;
  assign(C,D);
  return D;
}

References assign().

Here is the call graph for this function:

assign() [2/2]

template<typename DerivedC , typename DerivedD >

IGL_INLINE void igl::copyleft::cgal::assign	(	const Eigen::MatrixBase< DerivedC > &	C,
		Eigen::PlainObjectBase< DerivedD > &	D
	)

{
  D.resizeLike(C);
  for(int i = 0;i<C.rows();i++)
  {
    for(int j = 0;j<C.cols();j++)
    {
      assign_scalar(C(i,j),D(i,j));
    }
  }
}

References assign_scalar(), and Eigen::PlainObjectBase< Derived >::resizeLike().

Referenced by assign(), mesh_to_cgal_triangle_list(), outer_hull(), propagate_winding_numbers(), read_triangle_mesh(), relabel_small_immersed_cells(), and trim_with_solid().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_scalar() [1/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Epeck::FT &	cgal,
		CGAL::Epeck::FT &	d
	)

{
  d = cgal;
}

Referenced by assign(), igl::copyleft::cgal::points_inside_component_helper::determine_point_edge_orientation(), half_space_box(), point_mesh_squared_distance(), projected_cdt(), remesh_intersections(), and subdivide_segments().

Here is the caller graph for this function:

assign_scalar() [2/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Epeck::FT &	cgal,
		double &	d
	)

{
  // FORCE evaluation of the exact type otherwise interval might be huge.
  const CGAL::Epeck::FT cgal = _cgal.exact();
  const auto interval = CGAL::to_interval(cgal);
  d = interval.first;
  do {
      const double next = nextafter(d, interval.second);
      if (CGAL::abs(cgal-d) < CGAL::abs(cgal-next)) break;
      d = next;
  } while (d < interval.second);
}

assign_scalar() [3/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Epeck::FT &	cgal,
		float &	d
	)

{
  // FORCE evaluation of the exact type otherwise interval might be huge.
  const CGAL::Epeck::FT cgal = _cgal.exact();
  const auto interval = CGAL::to_interval(cgal);
  d = interval.first;
  do {
      const float next = nextafter(d, float(interval.second));
      if (CGAL::abs(cgal-d) < CGAL::abs(cgal-next)) break;
      d = next;
  } while (d < float(interval.second));
}

assign_scalar() [4/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &	cgal,
		CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &	d
	)

{
  d = cgal;
}

assign_scalar() [5/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &	cgal,
		double &	d
	)

{
  const auto interval = CGAL::to_interval(cgal);
  d = interval.first;
  do {
      const double next = nextafter(d, interval.second);
      if (CGAL::abs(cgal-d) < CGAL::abs(cgal-next)) break;
      d = next;
  } while (d < interval.second);
}

assign_scalar() [6/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt::FT &	cgal,
		float &	d
	)

{
  const auto interval = CGAL::to_interval(cgal);
  d = interval.first;
  do {
      const float next = nextafter(d, float(interval.second));
      if (CGAL::abs(cgal-d) < CGAL::abs(cgal-next)) break;
      d = next;
  } while (d < float(interval.second));
}

assign_scalar() [7/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Simple_cartesian< mpq_class >::FT &	cgal,
		CGAL::Simple_cartesian< mpq_class >::FT &	d
	)

{
  d = cgal;
}

assign_scalar() [8/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Simple_cartesian< mpq_class >::FT &	cgal,
		double &	d
	)

{
  const auto interval = CGAL::to_interval(cgal);
  d = interval.first;
  do {
      const double next = nextafter(d, interval.second);
      if (CGAL::abs(cgal-d) < CGAL::abs(cgal-next)) break;
      d = next;
  } while (d < interval.second);
}

assign_scalar() [9/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const CGAL::Simple_cartesian< mpq_class >::FT &	cgal,
		float &	d
	)

{
  const auto interval = CGAL::to_interval(cgal);
  d = interval.first;
  do {
      const float next = nextafter(d, float(interval.second));
      if (CGAL::abs(cgal-d) < CGAL::abs(cgal-next)) break;
      d = next;
  } while (d < float(interval.second));
}

assign_scalar() [10/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const double &	c,
		double &	d
	)

{
  d = c;
}

assign_scalar() [11/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const float &	c,
		double &	d
	)

{
  d = c;
}

assign_scalar() [12/12]

IGL_INLINE void igl::copyleft::cgal::assign_scalar	(	const float &	c,
		float &	d
	)

{
  d = c;
}

cell_adjacency()

template<typename DerivedC >

IGL_INLINE void igl::copyleft::cgal::cell_adjacency	(	const Eigen::PlainObjectBase< DerivedC > &	per_patch_cells,
		const size_t	num_cells,
		std::vector< std::set< std::tuple< typename DerivedC::Scalar, bool, size_t > > > &	adjacency_list
	)

                    {
 
  const size_t num_patches = per_patch_cells.rows();
  adjacency_list.resize(num_cells);
  for (size_t i=0; i<num_patches; i++) {
    const int positive_cell = per_patch_cells(i,0);
    const int negative_cell = per_patch_cells(i,1);
    adjacency_list[positive_cell].emplace(negative_cell, false, i);
    adjacency_list[negative_cell].emplace(positive_cell, true, i);
  }
}

References igl::adjacency_list(), and Eigen::PlainObjectBase< Derived >::rows().

Referenced by propagate_winding_numbers(), and relabel_small_immersed_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_facet() [1/3]

template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedP , typename uE2EType , typename DerivedEMAP , typename Kernel , typename DerivedR , typename DerivedS >

IGL_INLINE void igl::copyleft::cgal::closest_facet	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		const Eigen::PlainObjectBase< DerivedEMAP > &	EMAP,
		const std::vector< std::vector< size_t > > &	VF,
		const std::vector< std::vector< size_t > > &	VFi,
		const CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< typename Kernel::Triangle_3 >::iterator > > > &	tree,
		const std::vector< typename Kernel::Triangle_3 > &	triangles,
		const std::vector< bool > &	in_I,
		Eigen::PlainObjectBase< DerivedR > &	R,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

{
  typedef typename Kernel::Point_3 Point_3;
  typedef typename Kernel::Plane_3 Plane_3;
  typedef typename Kernel::Segment_3 Segment_3;
  typedef typename Kernel::Triangle_3 Triangle;
  typedef typename std::vector<Triangle>::iterator Iterator;
  typedef typename CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
  typedef typename CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef typename CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
  const size_t num_faces = I.rows();
  if (F.rows() <= 0 || I.rows() <= 0) {
    throw std::runtime_error(
        "Closest facet cannot be computed on empty mesh.");
  }
 
  auto on_the_positive_side = [&](size_t fid, const Point_3& p) -> bool
  {
    const auto& f = F.row(fid).eval();
    Point_3 v0(V(f[0], 0), V(f[0], 1), V(f[0], 2));
    Point_3 v1(V(f[1], 0), V(f[1], 1), V(f[1], 2));
    Point_3 v2(V(f[2], 0), V(f[2], 1), V(f[2], 2));
    auto ori = CGAL::orientation(v0, v1, v2, p);
    switch (ori) {
      case CGAL::POSITIVE:
        return true;
      case CGAL::NEGATIVE:
        return false;
      case CGAL::COPLANAR:
        // Warning:
        // This can only happen if fid contains a boundary edge.
        // Categorized this ambiguous case as negative side.
        return false;
      default:
        throw std::runtime_error("Unknown CGAL state.");
    }
    return false;
  };
 
  auto get_orientation = [&](size_t fid, size_t s, size_t d) -> bool 
  {
    const auto& f = F.row(fid);
    if      ((size_t)f[0] == s && (size_t)f[1] == d) return false;
    else if ((size_t)f[1] == s && (size_t)f[2] == d) return false;
    else if ((size_t)f[2] == s && (size_t)f[0] == d) return false;
    else if ((size_t)f[0] == d && (size_t)f[1] == s) return true;
    else if ((size_t)f[1] == d && (size_t)f[2] == s) return true;
    else if ((size_t)f[2] == d && (size_t)f[0] == s) return true;
    else {
      throw std::runtime_error(
          "Cannot compute orientation due to incorrect connectivity");
      return false;
    }
  };
  auto index_to_signed_index = [&](size_t index, bool ori) -> int{
    return (index+1) * (ori? 1:-1);
  };
  //auto signed_index_to_index = [&](int signed_index) -> size_t {
  //    return abs(signed_index) - 1;
  //};
 
  enum ElementType { VERTEX, EDGE, FACE };
  auto determine_element_type = [&](const Point_3& p, const size_t fid,
      size_t& element_index) -> ElementType {
    const auto& tri = triangles[fid];
    const Point_3 p0 = tri[0];
    const Point_3 p1 = tri[1];
    const Point_3 p2 = tri[2];
 
    if (p == p0) { element_index = 0; return VERTEX; }
    if (p == p1) { element_index = 1; return VERTEX; }
    if (p == p2) { element_index = 2; return VERTEX; }
    if (CGAL::collinear(p0, p1, p)) { element_index = 2; return EDGE; }
    if (CGAL::collinear(p1, p2, p)) { element_index = 0; return EDGE; }
    if (CGAL::collinear(p2, p0, p)) { element_index = 1; return EDGE; }
 
    element_index = 0;
    return FACE;
  };
 
  auto process_edge_case = [&](
      size_t query_idx,
      const size_t s, const size_t d,
      size_t preferred_facet,
      bool& orientation) -> size_t 
  {
    Point_3 query_point(
      P(query_idx, 0),
      P(query_idx, 1),
      P(query_idx, 2));
 
    size_t corner_idx = std::numeric_limits<size_t>::max();
    if ((s == F(preferred_facet, 0) && d == F(preferred_facet, 1)) ||
        (s == F(preferred_facet, 1) && d == F(preferred_facet, 0))) 
    {
      corner_idx = 2;
    } else if ((s == F(preferred_facet, 0) && d == F(preferred_facet, 2)) ||
        (s == F(preferred_facet, 2) && d == F(preferred_facet, 0))) 
    {
      corner_idx = 1;
    } else if ((s == F(preferred_facet, 1) && d == F(preferred_facet, 2)) ||
        (s == F(preferred_facet, 2) && d == F(preferred_facet, 1))) 
    {
      corner_idx = 0;
    } else 
    {
      std::cerr << "s: " << s << "\t d:" << d << std::endl;
      std::cerr << F.row(preferred_facet) << std::endl;
      throw std::runtime_error(
          "Invalid connectivity, edge does not belong to facet");
    }
 
    auto ueid = EMAP(preferred_facet + corner_idx * F.rows());
    auto eids = uE2E[ueid];
    std::vector<size_t> intersected_face_indices;
    for (auto eid : eids) 
    {
      const size_t fid = eid % F.rows();
      if (in_I[fid]) 
      {
        intersected_face_indices.push_back(fid);
      }
    }
 
    const size_t num_intersected_faces = intersected_face_indices.size();
    std::vector<int> intersected_face_signed_indices(num_intersected_faces);
    std::transform(
        intersected_face_indices.begin(),
        intersected_face_indices.end(),
        intersected_face_signed_indices.begin(),
        [&](size_t index) {
        return index_to_signed_index(
          index, get_orientation(index, s,d));
        });
 
    assert(num_intersected_faces >= 1);
    if (num_intersected_faces == 1) 
    {
      // The edge must be a boundary edge.  Thus, the orientation can be
      // simply determined by checking if the query point is on the
      // positive side of the facet.
      const size_t fid = intersected_face_indices[0];
      orientation = on_the_positive_side(fid, query_point);
      return fid;
    }
 
    Eigen::VectorXi order;
    DerivedP pivot = P.row(query_idx).eval();
    igl::copyleft::cgal::order_facets_around_edge(V, F, s, d,
      intersected_face_signed_indices,
      pivot, order);
 
    // Although first and last are equivalent, make the choice based on
    // preferred_facet.
    const size_t first = order[0];
    const size_t last = order[num_intersected_faces-1];
    if (intersected_face_indices[first] == preferred_facet) {
      orientation = intersected_face_signed_indices[first] < 0;
      return intersected_face_indices[first];
    } else if (intersected_face_indices[last] == preferred_facet) {
      orientation = intersected_face_signed_indices[last] > 0;
      return intersected_face_indices[last];
    } else {
      orientation = intersected_face_signed_indices[order[0]] < 0;
      return intersected_face_indices[order[0]];
    }
  };
 
  auto process_face_case = [&](
      const size_t query_idx, const Point_3& closest_point,
      const size_t fid, bool& orientation) -> size_t {
    const auto& f = F.row(I(fid, 0));
    return process_edge_case(query_idx, f[0], f[1], I(fid, 0), orientation);
  };
 
  // Given that the closest point to query point P(query_idx,:) on (V,F(I,:))
  // is the vertex at V(s,:) which is incident at least on triangle
  // F(preferred_facet,:), determine a facet incident on V(s,:) that is
  // _exposed_ to the query point and determine whether that facet is facing
  // _toward_ or _away_ from the query point.
  //
  // Inputs:
  //   query_idx  index into P of query point
  //   s  index into V of closest point at vertex
  //   preferred_facet  facet incident on s
  // Outputs:
  //   orientation  whether returned face is facing toward or away from
  //     query (parity unclear)
  // Returns face guaranteed to be "exposed" to P(query_idx,:)
  auto process_vertex_case = [&](
    const size_t query_idx, 
    size_t s,
    size_t preferred_facet, 
    bool& orientation) -> size_t
  {
    const Point_3 query_point(
        P(query_idx, 0), P(query_idx, 1), P(query_idx, 2));
    const Point_3 closest_point(V(s, 0), V(s, 1), V(s, 2));
    std::vector<size_t> adj_faces;
    std::vector<size_t> adj_face_corners;
    {
      // Gather adj faces to s within I.
      const auto& all_adj_faces = VF[s];
      const auto& all_adj_face_corners = VFi[s];
      const size_t num_all_adj_faces = all_adj_faces.size();
      for (size_t i=0; i<num_all_adj_faces; i++) 
      {
        const size_t fid = all_adj_faces[i];
        // Shouldn't this always be true if I is a full connected component?
        if (in_I[fid]) 
        {
          adj_faces.push_back(fid);
          adj_face_corners.push_back(all_adj_face_corners[i]);
        }
      }
    }
    const size_t num_adj_faces = adj_faces.size();
    assert(num_adj_faces > 0);
 
    std::set<size_t> adj_vertices_set;
    std::unordered_multimap<size_t, size_t> v2f;
    for (size_t i=0; i<num_adj_faces; i++) 
    {
      const size_t fid = adj_faces[i];
      const size_t cid = adj_face_corners[i];
      const auto& f = F.row(adj_faces[i]);
      const size_t next = f[(cid+1)%3];
      const size_t prev = f[(cid+2)%3];
      adj_vertices_set.insert(next);
      adj_vertices_set.insert(prev);
      v2f.insert({{next, fid}, {prev, fid}});
    }
    const size_t num_adj_vertices = adj_vertices_set.size();
    std::vector<size_t> adj_vertices(num_adj_vertices);
    std::copy(adj_vertices_set.begin(), adj_vertices_set.end(),
        adj_vertices.begin());
 
    std::vector<Point_3> adj_points;
    for (size_t vid : adj_vertices) 
    {
      adj_points.emplace_back(V(vid,0), V(vid,1), V(vid,2));
    }
 
    // A plane is on the exterior if all adj_points lies on or to
    // one side of the plane.
    auto is_on_exterior = [&](const Plane_3& separator) -> bool{
      size_t positive=0;
      size_t negative=0;
      size_t coplanar=0;
      for (const auto& point : adj_points) {
        switch(separator.oriented_side(point)) {
          case CGAL::ON_POSITIVE_SIDE:
            positive++;
            break;
          case CGAL::ON_NEGATIVE_SIDE:
            negative++;
            break;
          case CGAL::ON_ORIENTED_BOUNDARY:
            coplanar++;
            break;
          default:
            throw "Unknown plane-point orientation";
        }
      }
      auto query_orientation = separator.oriented_side(query_point);
      if (query_orientation == CGAL::ON_ORIENTED_BOUNDARY &&
          (positive == 0 && negative == 0)) {
        // All adj vertices and query point are coplanar.
        // In this case, all separators are equally valid.
        return true;
      } else {
        bool r = (positive == 0 && query_orientation == CGAL::POSITIVE)
          || (negative == 0 && query_orientation == CGAL::NEGATIVE);
        return r;
      }
    };
 
    size_t d = std::numeric_limits<size_t>::max();
    for (size_t i=0; i<num_adj_vertices; i++) {
      const size_t vi = adj_vertices[i];
      for (size_t j=i+1; j<num_adj_vertices; j++) {
        Plane_3 separator(closest_point, adj_points[i], adj_points[j]);
        if (separator.is_degenerate()) {
          continue;
        }
        if (is_on_exterior(separator)) {
          if (!CGAL::collinear(
                query_point, adj_points[i], closest_point)) {
            d = vi;
            break;
          } else {
            d = adj_vertices[j];
            assert(!CGAL::collinear(
                  query_point, adj_points[j], closest_point));
            break;
          }
        }
      }
    }
    if (d == std::numeric_limits<size_t>::max()) {
      Eigen::MatrixXd tmp_vertices(V.rows(), V.cols());
      for (size_t i=0; i<V.rows(); i++) {
        for (size_t j=0; j<V.cols(); j++) {
          tmp_vertices(i,j) = CGAL::to_double(V(i,j));
        }
      }
      Eigen::MatrixXi tmp_faces(adj_faces.size(), 3);
      for (size_t i=0; i<adj_faces.size(); i++) {
        tmp_faces.row(i) = F.row(adj_faces[i]);
      }
      //igl::writePLY("debug.ply", tmp_vertices, tmp_faces, false);
      throw std::runtime_error("Invalid vertex neighborhood");
    }
    const auto itr = v2f.equal_range(d);
    assert(itr.first != itr.second);
 
    return process_edge_case(query_idx, s, d, itr.first->second, orientation);
  };
 
  const size_t num_queries = P.rows();
  R.resize(num_queries, 1);
  S.resize(num_queries, 1);
  for (size_t i=0; i<num_queries; i++) {
    const Point_3 query(P(i,0), P(i,1), P(i,2));
    auto projection = tree.closest_point_and_primitive(query);
    const Point_3 closest_point = projection.first;
    size_t fid = projection.second - triangles.begin();
    bool fid_ori = false;
 
    // Gether all facets sharing the closest point.
    typename std::vector<typename Tree::Primitive_id> intersected_faces;
    tree.all_intersected_primitives(Segment_3(closest_point, query),
        std::back_inserter(intersected_faces));
    const size_t num_intersected_faces = intersected_faces.size();
    std::vector<size_t> intersected_face_indices(num_intersected_faces);
    std::transform(intersected_faces.begin(),
        intersected_faces.end(),
        intersected_face_indices.begin(),
        [&](const typename Tree::Primitive_id& itr) -> size_t
        { return I(itr-triangles.begin(), 0); });
 
    size_t element_index;
    auto element_type = determine_element_type(closest_point, fid,
        element_index);
    switch(element_type) {
      case VERTEX:
        {
          const auto& f = F.row(I(fid, 0));
          const size_t s = f[element_index];
          fid = process_vertex_case(i, s, I(fid, 0), fid_ori);
        }
        break;
      case EDGE:
        {
          const auto& f = F.row(I(fid, 0));
          const size_t s = f[(element_index+1)%3];
          const size_t d = f[(element_index+2)%3];
          fid = process_edge_case(i, s, d, I(fid, 0), fid_ori);
        }
        break;
      case FACE:
        {
          fid = process_face_case(i, closest_point, fid, fid_ori);
        }
        break;
      default:
        throw std::runtime_error("Unknown element type.");
    }
 
 
    R(i,0) = fid;
    S(i,0) = fid_ori;
  }
}

References Eigen::PlainObjectBase< Derived >::cols(), order_facets_around_edge(), Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

closest_facet() [2/3]

template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedP , typename uE2EType , typename DerivedEMAP , typename DerivedR , typename DerivedS >

IGL_INLINE void igl::copyleft::cgal::closest_facet	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		const Eigen::PlainObjectBase< DerivedEMAP > &	EMAP,
		Eigen::PlainObjectBase< DerivedR > &	R,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

{
 
  typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
  typedef Kernel::Point_3 Point_3;
  typedef Kernel::Plane_3 Plane_3;
  typedef Kernel::Segment_3 Segment_3;
  typedef Kernel::Triangle_3 Triangle;
  typedef std::vector<Triangle>::iterator Iterator;
  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
  if (F.rows() <= 0 || I.rows() <= 0) {
    throw std::runtime_error(
        "Closest facet cannot be computed on empty mesh.");
  }
 
  std::vector<std::vector<size_t> > VF, VFi;
  igl::vertex_triangle_adjacency(V.rows(), F, VF, VFi);
  std::vector<bool> in_I;
  std::vector<Triangle> triangles;
  Tree tree;
  submesh_aabb_tree(V,F,I,tree,triangles,in_I);
 
  return closest_facet(
    V,F,I,P,uE2E,EMAP,VF,VFi,tree,triangles,in_I,R,S);
}

References closest_facet(), Eigen::PlainObjectBase< Derived >::rows(), submesh_aabb_tree(), and igl::vertex_triangle_adjacency().

Referenced by closest_facet(), closest_facet(), and extract_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_facet() [3/3]

template<typename DerivedV , typename DerivedF , typename DerivedP , typename uE2EType , typename DerivedEMAP , typename DerivedR , typename DerivedS >

IGL_INLINE void igl::copyleft::cgal::closest_facet	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		const Eigen::PlainObjectBase< DerivedEMAP > &	EMAP,
		Eigen::PlainObjectBase< DerivedR > &	R,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

                                       {
  const size_t num_faces = F.rows();
  Eigen::VectorXi I = igl::LinSpaced<Eigen::VectorXi>(num_faces, 0, num_faces-1);
  igl::copyleft::cgal::closest_facet(V, F, I, P, uE2E, EMAP, R, S);
}

References closest_facet().

Here is the call graph for this function:

complex_to_mesh()

template<typename Tr , typename DerivedV , typename DerivedF >

IGL_INLINE bool igl::copyleft::cgal::complex_to_mesh	(	const CGAL::Complex_2_in_triangulation_3< Tr > &	c2t3,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  using namespace Eigen;
  // CGAL/IO/Complex_2_in_triangulation_3_file_writer.h
  using CGAL::Surface_mesher::number_of_facets_on_surface;
 
  typedef typename CGAL::Complex_2_in_triangulation_3<Tr> C2t3;
  typedef typename Tr::Finite_facets_iterator Finite_facets_iterator;
  typedef typename Tr::Finite_vertices_iterator Finite_vertices_iterator;
  typedef typename Tr::Facet Facet;
  typedef typename Tr::Edge Edge;
  typedef typename Tr::Vertex_handle Vertex_handle;
 
  // Header.
  const Tr& tr = c2t3.triangulation();
 
  bool success = true;
 
  const int n = tr.number_of_vertices();
  const int m = c2t3.number_of_facets();
 
  assert(m == number_of_facets_on_surface(tr));
  
  // Finite vertices coordinates.
  std::map<Vertex_handle, int> v2i;
  V.resize(n,3);
  {
    int v = 0;
    for(Finite_vertices_iterator vit = tr.finite_vertices_begin();
        vit != tr.finite_vertices_end();
        ++vit)
    {
      V(v,0) = vit->point().x(); 
      V(v,1) = vit->point().y(); 
      V(v,2) = vit->point().z(); 
      v2i[vit] = v++;
    }
  }
 
  {
    Finite_facets_iterator fit = tr.finite_facets_begin();
    std::set<Facet> oriented_set;
    std::stack<Facet> stack;
 
    while ((int)oriented_set.size() != m) 
    {
      while ( fit->first->is_facet_on_surface(fit->second) == false ||
        oriented_set.find(*fit) != oriented_set.end() ||
        oriented_set.find(c2t3.opposite_facet(*fit)) !=
        oriented_set.end() ) 
      {
        ++fit;
      }
      oriented_set.insert(*fit);
      stack.push(*fit);
      while(! stack.empty() )
      {
        Facet f = stack.top();
        stack.pop();
        for(int ih = 0 ; ih < 3 ; ++ih)
        {
          const int i1  = tr.vertex_triple_index(f.second, tr. cw(ih));
          const int i2  = tr.vertex_triple_index(f.second, tr.ccw(ih));
 
          const typename C2t3::Face_status face_status
            = c2t3.face_status(Edge(f.first, i1, i2));
          if(face_status == C2t3::REGULAR) 
          {
            Facet fn = c2t3.neighbor(f, ih);
            if (oriented_set.find(fn) == oriented_set.end())
            {
              if(oriented_set.find(c2t3.opposite_facet(fn)) == oriented_set.end())
              {
                oriented_set.insert(fn);
                stack.push(fn);
              }else {
                success = false; // non-orientable
              }
            }
          }else if(face_status != C2t3::BOUNDARY)
          {
            success = false; // non manifold, thus non-orientable
          }
        } // end "for each neighbor of f"
      } // end "stack non empty"
    } // end "oriented_set not full"
 
    F.resize(m,3);
    int f = 0;
    for(typename std::set<Facet>::const_iterator fit = 
        oriented_set.begin();
        fit != oriented_set.end();
        ++fit)
    {
      const typename Tr::Cell_handle cell = fit->first;
      const int& index = fit->second;
      const int index1 = v2i[cell->vertex(tr.vertex_triple_index(index, 0))];
      const int index2 = v2i[cell->vertex(tr.vertex_triple_index(index, 1))];
      const int index3 = v2i[cell->vertex(tr.vertex_triple_index(index, 2))];
      // This order is flipped
      F(f,0) = index1;
      F(f,1) = index2;
      F(f,2) = index3;
      f++;
    }
    assert(f == m);
  } // end if(facets must be oriented)
 
  // This CGAL code seems to randomly assign the global orientation
  // Flip based on the signed volume.
  Eigen::Vector3d cen;
  double vol;
  igl::centroid(V,F,cen,vol);
  if(vol < 0)
  {
    // Flip
    F = F.rowwise().reverse().eval();
  }
 
  // CGAL code somehow can end up with unreferenced vertices
  {
    VectorXi _1;
    remove_unreferenced( MatrixXd(V), MatrixXi(F), V,F,_1);
  }
 
  return success;
}

References igl::centroid(), igl::remove_unreferenced(), and Eigen::PlainObjectBase< Derived >::resize().

Referenced by signed_distance_isosurface().

Here is the call graph for this function:

Here is the caller graph for this function:

component_inside_component() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedI >

IGL_INLINE bool igl::copyleft::cgal::component_inside_component	(	const Eigen::PlainObjectBase< DerivedV > &	V1,
		const Eigen::PlainObjectBase< DerivedF > &	F1,
		const Eigen::PlainObjectBase< DerivedI > &	I1,
		const Eigen::PlainObjectBase< DerivedV > &	V2,
		const Eigen::PlainObjectBase< DerivedF > &	F2,
		const Eigen::PlainObjectBase< DerivedI > &	I2
	)

                                                  {
    if (F1.rows() <= 0 || I1.rows() <= 0 || F2.rows() <= 0 || I2.rows() <= 0) {
        throw "Component inside test cannot be done on empty component!";
    }
 
    const Eigen::Vector3i& f = F1.row(I1(0, 0));
    const Eigen::Matrix<typename DerivedV::Scalar, 1, 3> query(
            (V1(f[0],0) + V1(f[1],0) + V1(f[2],0))/3.0,
            (V1(f[0],1) + V1(f[1],1) + V1(f[2],1))/3.0,
            (V1(f[0],2) + V1(f[1],2) + V1(f[2],2))/3.0);
    Eigen::VectorXi inside;
    igl::copyleft::cgal::points_inside_component(V2, F2, I2, query, inside);
    assert(inside.size() == 1);
    return inside[0];
}

References points_inside_component(), and Eigen::PlainObjectBase< Derived >::rows().

Referenced by component_inside_component().

Here is the call graph for this function:

Here is the caller graph for this function:

component_inside_component() [2/2]

template<typename DerivedV , typename DerivedF >

IGL_INLINE bool igl::copyleft::cgal::component_inside_component	(	const Eigen::PlainObjectBase< DerivedV > &	V1,
		const Eigen::PlainObjectBase< DerivedF > &	F1,
		const Eigen::PlainObjectBase< DerivedV > &	V2,
		const Eigen::PlainObjectBase< DerivedF > &	F2
	)

                                                  {
    if (F1.rows() <= 0 || F2.rows() <= 0) {
        throw "Component inside test cannot be done on empty component!";
    }
    Eigen::VectorXi I1(F1.rows()), I2(F2.rows());
    I1 = igl::LinSpaced<Eigen::VectorXi>(F1.rows(), 0, F1.rows()-1);
    I2 = igl::LinSpaced<Eigen::VectorXi>(F2.rows(), 0, F2.rows()-1);
    return igl::copyleft::cgal::component_inside_component(V1, F1, I1, V2, F2, I2);
}

References component_inside_component(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

convex_hull() [1/2]

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cgal::convex_hull	(	const Eigen::MatrixBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic> W;
  Eigen::Matrix<typename DerivedF::Scalar, Eigen::Dynamic, Eigen::Dynamic> G;
  convex_hull(V,W,G);
  // This is a lazy way to reindex into the original mesh
  Eigen::Matrix<bool,Eigen::Dynamic,1> I;
  Eigen::VectorXi J;
  igl::ismember_rows(W,V,I,J);
  assert(I.all() && "Should find all W in V");
  F.resizeLike(G);
  for(int f = 0;f<G.rows();f++)
  {
    for(int c = 0;c<3;c++)
    {
      F(f,c) = J(G(f,c));
    }
  }
}

References convex_hull(), igl::ismember_rows(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

convex_hull() [2/2]

template<typename DerivedV , typename DerivedW , typename DerivedG >

IGL_INLINE void igl::copyleft::cgal::convex_hull	(	const Eigen::MatrixBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedW > &	W,
		Eigen::PlainObjectBase< DerivedG > &	G
	)

{
  typedef CGAL::Exact_predicates_inexact_constructions_kernel      K;
  typedef K::Point_3                                              Point_3;
  //typedef CGAL::Delaunay_triangulation_3<K>                       Delaunay;
  //typedef Delaunay::Vertex_handle                                 Vertex_handle;
  //typedef CGAL::Surface_mesh<Point_3>                             Surface_mesh;
  typedef CGAL::Polyhedron_3<K>                             Polyhedron_3;
  std::vector<Point_3> points(V.rows());
  for(int i = 0;i<V.rows();i++)
  {
    points[i] = Point_3(V(i,0),V(i,1),V(i,2));
  }
  Polyhedron_3 poly;
  CGAL::convex_hull_3(points.begin(),points.end(),poly);
  assert(poly.is_pure_triangle() && "Assuming CGAL outputs a triangle mesh");
  polyhedron_to_mesh(poly,W,G);
}

References polyhedron_to_mesh().

Referenced by convex_hull(), and wire_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

delaunay_triangulation()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cgal::delaunay_triangulation	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  typedef typename DerivedV::Scalar Scalar;
  igl::delaunay_triangulation(V, orient2D<Scalar>, incircle<Scalar>, F);
  // This function really exists to test our igl::delaunay_triangulation
  // 
  // It's currently much faster to call cgal's native Delaunay routine
  //
//#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
//#include <CGAL/Delaunay_triangulation_2.h>
//#include <CGAL/Triangulation_vertex_base_with_info_2.h>
//#include <vector>
//  const auto delaunay = 
//    [&](const Eigen::MatrixXd & V,Eigen::MatrixXi & F)
//  {
//    typedef CGAL::Exact_predicates_inexact_constructions_kernel            Kernel;
//    typedef CGAL::Triangulation_vertex_base_with_info_2<unsigned int, Kernel> Vb;
//    typedef CGAL::Triangulation_data_structure_2<Vb>                       Tds;
//    typedef CGAL::Delaunay_triangulation_2<Kernel, Tds>                    Delaunay;
//    typedef Kernel::Point_2                                                Point;
//    std::vector< std::pair<Point,unsigned> > points(V.rows());
//    for(int i = 0;i<V.rows();i++)
//    {
//      points[i] = std::make_pair(Point(V(i,0),V(i,1)),i);
//    }
//    Delaunay triangulation;
//    triangulation.insert(points.begin(),points.end());
//    F.resize(triangulation.number_of_faces(),3);
//    {
//      int j = 0;
//      for(Delaunay::Finite_faces_iterator fit = triangulation.finite_faces_begin();
//          fit != triangulation.finite_faces_end(); ++fit) 
//      {
//        Delaunay::Face_handle face = fit;
//        F(j,0) = face->vertex(0)->info();
//        F(j,1) = face->vertex(1)->info();
//        F(j,2) = face->vertex(2)->info();
//        j++;
//      }
//    }
//  };
}

References igl::delaunay_triangulation().

Referenced by remesh_intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_cells() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedE , typename DeriveduE , typename uE2EType , typename DerivedEMAP , typename DerivedC >

IGL_INLINE size_t igl::copyleft::cgal::extract_cells	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DerivedE > &	E,
		const Eigen::PlainObjectBase< DeriveduE > &	uE,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		const Eigen::PlainObjectBase< DerivedEMAP > &	EMAP,
		Eigen::PlainObjectBase< DerivedC > &	cells
	)

{
  // Trivial base case
  if(P.size() == 0)
  {
    assert(F.size() == 0);
    cells.resize(0,2);
    return 0;
  }
 
  typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
  typedef Kernel::Point_3 Point_3;
  typedef Kernel::Plane_3 Plane_3;
  typedef Kernel::Segment_3 Segment_3;
  typedef Kernel::Triangle_3 Triangle;
  typedef std::vector<Triangle>::iterator Iterator;
  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
#ifdef EXTRACT_CELLS_DEBUG
  const auto & tictoc = []() -> double
  {
    static double t_start = igl::get_seconds();
    double diff = igl::get_seconds()-t_start;
    t_start += diff;
    return diff;
  };
  const auto log_time = [&](const std::string& label) -> void {
    std::cout << "extract_cells." << label << ": "
      << tictoc() << std::endl;
  };
  tictoc();
#else
  // no-op
  const auto log_time = [](const std::string){};
#endif
  const size_t num_faces = F.rows();
  typedef typename DerivedF::Scalar Index;
  assert(P.size() > 0);
  const size_t num_patches = P.maxCoeff()+1;
 
  // Extract all cells...
  DerivedC raw_cells;
  const size_t num_raw_cells =
    extract_cells_single_component(V,F,P,uE,uE2E,EMAP,raw_cells);
  log_time("extract_single_component_cells");
 
  // Compute triangle-triangle adjacency data-structure
  std::vector<std::vector<std::vector<Index > > > TT,_1;
  igl::triangle_triangle_adjacency(E, EMAP, uE2E, false, TT, _1);
  log_time("compute_face_adjacency");
 
  // Compute connected components of the mesh
  Eigen::VectorXi C, counts;
  igl::facet_components(TT, C, counts);
  log_time("form_components");
 
  const size_t num_components = counts.size();
  // components[c] --> list of face indices into F of faces in component c
  std::vector<std::vector<size_t> > components(num_components);
  // Loop over all faces
  for (size_t i=0; i<num_faces; i++) 
  {
    components[C[i]].push_back(i);
  }
  // Convert vector lists to Eigen lists...
  // and precompute data-structures for each component
  std::vector<std::vector<size_t> > VF,VFi;
  igl::vertex_triangle_adjacency(V.rows(), F, VF, VFi);
  std::vector<Eigen::VectorXi> Is(num_components);
  std::vector<
    CGAL::AABB_tree<
      CGAL::AABB_traits<
        Kernel, 
        CGAL::AABB_triangle_primitive<
          Kernel, std::vector<
            Kernel::Triangle_3 >::iterator > > > > trees(num_components);
  std::vector< std::vector<Kernel::Triangle_3 > > 
    triangle_lists(num_components);
  std::vector<std::vector<bool> > in_Is(num_components);
 
  // Find outer facets, their orientations and cells for each component
  Eigen::VectorXi outer_facets(num_components);
  Eigen::VectorXi outer_facet_orientation(num_components);
  Eigen::VectorXi outer_cells(num_components);
  for (size_t i=0; i<num_components; i++)
  {
    Is[i].resize(components[i].size());
    std::copy(components[i].begin(), components[i].end(),Is[i].data());
    bool flipped;
    igl::copyleft::cgal::outer_facet(V, F, Is[i], outer_facets[i], flipped);
    outer_facet_orientation[i] = flipped?1:0;
    outer_cells[i] = raw_cells(P[outer_facets[i]], outer_facet_orientation[i]);
  }
#ifdef EXTRACT_CELLS_DEBUG
  log_time("outer_facet_per_component");
#endif
 
  // Compute barycenter of a triangle in mesh (V,F)
  //
  // Inputs:
  //   fid  index into F
  // Returns row-vector of barycenter coordinates
  const auto get_triangle_center = [&V,&F](const size_t fid) 
  {
    return ((V.row(F(fid,0))+V.row(F(fid,1))+V.row(F(fid,2)))/3.0).eval();
  };
  std::vector<std::vector<size_t> > nested_cells(num_raw_cells);
  std::vector<std::vector<size_t> > ambient_cells(num_raw_cells);
  std::vector<std::vector<size_t> > ambient_comps(num_components);
  // Only bother if there's more than one component
  if(num_components > 1) 
  {
    // construct bounding boxes for each component
    DerivedV bbox_min(num_components, 3);
    DerivedV bbox_max(num_components, 3);
    // Assuming our mesh (in exact numbers) fits in the range of double.
    bbox_min.setConstant(std::numeric_limits<double>::max());
    bbox_max.setConstant(std::numeric_limits<double>::min());
    // Loop over faces
    for (size_t i=0; i<num_faces; i++)
    {
      // component of this face
      const auto comp_id = C[i];
      const auto& f = F.row(i);
      for (size_t j=0; j<3; j++) 
      {
        for(size_t d=0;d<3;d++)
        {
          bbox_min(comp_id,d) = std::min(bbox_min(comp_id,d), V(f[j],d));
          bbox_max(comp_id,d) = std::max(bbox_max(comp_id,d), V(f[j],d));
        }
      }
    }
    // Return true if box of component ci intersects that of cj
    const auto bbox_intersects = [&bbox_max,&bbox_min](size_t ci, size_t cj)
    {
      return !(
        bbox_max(ci,0) < bbox_min(cj,0) ||
        bbox_max(ci,1) < bbox_min(cj,1) ||
        bbox_max(ci,2) < bbox_min(cj,2) ||
        bbox_max(cj,0) < bbox_min(ci,0) ||
        bbox_max(cj,1) < bbox_min(ci,1) ||
        bbox_max(cj,2) < bbox_min(ci,2));
    };
    
    // Loop over components. This section is O(m²)
    for (size_t i=0; i<num_components; i++)
    {
      // List of components that could overlap with component i
      std::vector<size_t> candidate_comps;
      candidate_comps.reserve(num_components);
      // Loop over components
      for (size_t j=0; j<num_components; j++) 
      {
        if (i == j) continue;
        if (bbox_intersects(i,j)) candidate_comps.push_back(j);
      }
 
      const size_t num_candidate_comps = candidate_comps.size();
      if (num_candidate_comps == 0) continue;
 
      // Build aabb tree for this component.
      submesh_aabb_tree(V,F,Is[i],trees[i],triangle_lists[i],in_Is[i]);
 
      // Get query points on each candidate component: barycenter of
      // outer-facet 
      DerivedV queries(num_candidate_comps, 3);
      for (size_t j=0; j<num_candidate_comps; j++)
      {
        const size_t index = candidate_comps[j];
        queries.row(j) = get_triangle_center(outer_facets[index]);
      }
 
      // Gather closest facets in ith component to each query point and their
      // orientations
      const auto& I = Is[i];
      const auto& tree = trees[i];
      const auto& in_I = in_Is[i];
      const auto& triangles = triangle_lists[i];
 
      Eigen::VectorXi closest_facets, closest_facet_orientations;
      closest_facet(
        V,
        F, 
        I, 
        queries,
        uE2E, 
        EMAP, 
        VF,
        VFi,
        tree,
        triangles,
        in_I,
        closest_facets, 
        closest_facet_orientations);
      // Loop over all candidates
      for (size_t j=0; j<num_candidate_comps; j++)
      {
        const size_t index = candidate_comps[j];
        const size_t closest_patch = P[closest_facets[j]];
        const size_t closest_patch_side = closest_facet_orientations[j] ? 0:1;
        // The cell id of the closest patch
        const size_t ambient_cell =
          raw_cells(closest_patch,closest_patch_side);
        if (ambient_cell != (size_t)outer_cells[i])
        {
          // ---> component index inside component i, because the cell of the
          // closest facet on i to component index is **not** the same as the
          // "outer cell" of component i: component index is **not** outside of
          // component i (therefore it's inside).
          nested_cells[ambient_cell].push_back(outer_cells[index]);
          ambient_cells[outer_cells[index]].push_back(ambient_cell);
          ambient_comps[index].push_back(i);
        }
      }
    }
  }
 
#ifdef EXTRACT_CELLS_DEBUG
    log_time("nested_relationship");
#endif
 
    const size_t INVALID = std::numeric_limits<size_t>::max();
    const size_t INFINITE_CELL = num_raw_cells;
    std::vector<size_t> embedded_cells(num_raw_cells, INVALID);
    for (size_t i=0; i<num_components; i++) {
        const size_t outer_cell = outer_cells[i];
        const auto& ambient_comps_i = ambient_comps[i];
        const auto& ambient_cells_i = ambient_cells[outer_cell];
        const size_t num_ambient_comps = ambient_comps_i.size();
        assert(num_ambient_comps == ambient_cells_i.size());
        if (num_ambient_comps > 0) {
            size_t embedded_comp = INVALID;
            size_t embedded_cell = INVALID;
            for (size_t j=0; j<num_ambient_comps; j++) {
                if (ambient_comps[ambient_comps_i[j]].size() ==
                        num_ambient_comps-1) {
                    embedded_comp = ambient_comps_i[j];
                    embedded_cell = ambient_cells_i[j];
                    break;
                }
            }
            assert(embedded_comp != INVALID);
            assert(embedded_cell != INVALID);
            embedded_cells[outer_cell] = embedded_cell;
        } else {
            embedded_cells[outer_cell] = INFINITE_CELL;
        }
    }
    for (size_t i=0; i<num_patches; i++) {
        if (embedded_cells[raw_cells(i,0)] != INVALID) {
            raw_cells(i,0) = embedded_cells[raw_cells(i, 0)];
        }
        if (embedded_cells[raw_cells(i,1)] != INVALID) {
            raw_cells(i,1) = embedded_cells[raw_cells(i, 1)];
        }
    }
 
    size_t count = 0;
    std::vector<size_t> mapped_indices(num_raw_cells+1, INVALID);
    // Always map infinite cell to index 0.
    mapped_indices[INFINITE_CELL] = count;
    count++;
 
    for (size_t i=0; i<num_patches; i++) {
        const size_t old_positive_cell_id = raw_cells(i, 0);
        const size_t old_negative_cell_id = raw_cells(i, 1);
        size_t positive_cell_id, negative_cell_id;
        if (mapped_indices[old_positive_cell_id] == INVALID) {
            mapped_indices[old_positive_cell_id] = count;
            positive_cell_id = count;
            count++;
        } else {
            positive_cell_id = mapped_indices[old_positive_cell_id];
        }
        if (mapped_indices[old_negative_cell_id] == INVALID) {
            mapped_indices[old_negative_cell_id] = count;
            negative_cell_id = count;
            count++;
        } else {
            negative_cell_id = mapped_indices[old_negative_cell_id];
        }
        raw_cells(i, 0) = positive_cell_id;
        raw_cells(i, 1) = negative_cell_id;
    }
    cells = raw_cells;
#ifdef EXTRACT_CELLS_DEBUG
    log_time("finalize");
#endif
    return count;
}

References closest_facet(), igl::components(), igl::count(), extract_cells_single_component(), igl::facet_components(), igl::get_seconds(), outer_facet(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), submesh_aabb_tree(), igl::triangle_triangle_adjacency(), and igl::vertex_triangle_adjacency().

Here is the call graph for this function:

extract_cells() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedC >

IGL_INLINE size_t igl::copyleft::cgal::extract_cells	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedC > &	cells
	)

{
  const size_t num_faces = F.rows();
  // Construct edge adjacency
  Eigen::MatrixXi E, uE;
  Eigen::VectorXi EMAP;
  std::vector<std::vector<size_t> > uE2E;
  igl::unique_edge_map(F, E, uE, EMAP, uE2E);
  // Cluster into manifold patches
  Eigen::VectorXi P;
  igl::extract_manifold_patches(F, EMAP, uE2E, P);
  // Extract cells
  DerivedC per_patch_cells;
  const size_t num_cells =
    igl::copyleft::cgal::extract_cells(V,F,P,E,uE,uE2E,EMAP,per_patch_cells);
  // Distribute per-patch cell information to each face
  cells.resize(num_faces, 2);
  for (size_t i=0; i<num_faces; i++) 
  {
    cells.row(i) = per_patch_cells.row(P[i]);
  }
  return num_cells;
}

References extract_cells(), igl::extract_manifold_patches(), Eigen::PlainObjectBase< Derived >::resize(), and igl::unique_edge_map().

Referenced by extract_cells(), mesh_boolean(), outer_hull(), and propagate_winding_numbers().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_cells_single_component()

template<typename DerivedV , typename DerivedF , typename DerivedP , typename DeriveduE , typename uE2EType , typename DerivedEMAP , typename DerivedC >

IGL_INLINE size_t igl::copyleft::cgal::extract_cells_single_component	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DeriveduE > &	uE,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		const Eigen::PlainObjectBase< DerivedEMAP > &	EMAP,
		Eigen::PlainObjectBase< DerivedC > &	cells
	)

{
  const size_t num_faces = F.rows();
  // Input:
  //   index  index into #F*3 list of undirect edges
  // Returns index into face
  const auto edge_index_to_face_index = [&num_faces](size_t index)
  {
    return index % num_faces;
  };
  // Determine if a face (containing undirected edge {s,d} is consistently
  // oriented with directed edge {s,d} (or otherwise it is with {d,s})
  // 
  // Inputs:
  //   fid  face index into F
  //   s  source index of edge
  //   d  destination index of edge
  // Returns true if face F(fid,:) is consistent with {s,d}
  const auto is_consistent = 
    [&F](const size_t fid, const size_t s, const size_t d) -> bool
  {
    if ((size_t)F(fid, 0) == s && (size_t)F(fid, 1) == d) return false;
    if ((size_t)F(fid, 1) == s && (size_t)F(fid, 2) == d) return false;
    if ((size_t)F(fid, 2) == s && (size_t)F(fid, 0) == d) return false;
 
    if ((size_t)F(fid, 0) == d && (size_t)F(fid, 1) == s) return true;
    if ((size_t)F(fid, 1) == d && (size_t)F(fid, 2) == s) return true;
    if ((size_t)F(fid, 2) == d && (size_t)F(fid, 0) == s) return true;
    throw "Invalid face!";
    return false;
  };
 
  const size_t num_unique_edges = uE.rows();
  const size_t num_patches = P.maxCoeff() + 1;
 
  // Build patch-patch adjacency list.
  std::vector<std::map<size_t, size_t> > patch_adj(num_patches);
  for (size_t i=0; i<num_unique_edges; i++) {
    const size_t s = uE(i,0);
    const size_t d = uE(i,1);
    const auto adj_faces = uE2E[i];
    const size_t num_adj_faces = adj_faces.size();
    if (num_adj_faces > 2) {
      for (size_t j=0; j<num_adj_faces; j++) {
        const size_t patch_j = P[edge_index_to_face_index(adj_faces[j])];
        for (size_t k=j+1; k<num_adj_faces; k++) {
          const size_t patch_k = P[edge_index_to_face_index(adj_faces[k])];
          if (patch_adj[patch_j].find(patch_k) == patch_adj[patch_j].end()) {
            patch_adj[patch_j].insert({patch_k, i});
          }
          if (patch_adj[patch_k].find(patch_j) == patch_adj[patch_k].end()) {
            patch_adj[patch_k].insert({patch_j, i});
          }
        }
      }
    }
  }
 
 
  const int INVALID = std::numeric_limits<int>::max();
  std::vector<size_t> cell_labels(num_patches * 2);
  for (size_t i=0; i<num_patches; i++) cell_labels[i] = i;
  std::vector<std::set<size_t> > equivalent_cells(num_patches*2);
  std::vector<bool> processed(num_unique_edges, false);
 
  size_t label_count=0;
  for (size_t i=0; i<num_patches; i++) {
    for (const auto& entry : patch_adj[i]) {
      const size_t neighbor_patch = entry.first;
      const size_t uei = entry.second;
      if (processed[uei]) continue;
      processed[uei] = true;
 
      const auto& adj_faces = uE2E[uei];
      const size_t num_adj_faces = adj_faces.size();
      assert(num_adj_faces > 2);
 
      const size_t s = uE(uei,0);
      const size_t d = uE(uei,1);
 
      std::vector<int> signed_adj_faces;
      for (auto ej : adj_faces)
      {
        const size_t fid = edge_index_to_face_index(ej);
        bool cons = is_consistent(fid, s, d);
        signed_adj_faces.push_back((fid+1)*(cons ? 1:-1));
      }
      {
        // Sort adjacent faces cyclically around {s,d}
        Eigen::VectorXi order;
        // order[f] will reveal the order of face f in signed_adj_faces
        order_facets_around_edge(V, F, s, d, signed_adj_faces, order);
        for (size_t j=0; j<num_adj_faces; j++) {
          const size_t curr_idx = j;
          const size_t next_idx = (j+1)%num_adj_faces;
          const size_t curr_patch_idx =
            P[edge_index_to_face_index(adj_faces[order[curr_idx]])];
          const size_t next_patch_idx =
            P[edge_index_to_face_index(adj_faces[order[next_idx]])];
          const bool curr_cons = signed_adj_faces[order[curr_idx]] > 0;
          const bool next_cons = signed_adj_faces[order[next_idx]] > 0;
          const size_t curr_cell_idx = curr_patch_idx*2 + (curr_cons?0:1);
          const size_t next_cell_idx = next_patch_idx*2 + (next_cons?1:0);
          equivalent_cells[curr_cell_idx].insert(next_cell_idx);
          equivalent_cells[next_cell_idx].insert(curr_cell_idx);
        }
      }
    }
  }
 
  size_t count=0;
  cells.resize(num_patches, 2);
  cells.setConstant(INVALID);
  const auto extract_equivalent_cells = [&](size_t i) {
    if (cells(i/2, i%2) != INVALID) return;
    std::queue<size_t> Q;
    Q.push(i);
    cells(i/2, i%2) = count;
    while (!Q.empty()) {
      const size_t index = Q.front();
      Q.pop();
      for (const auto j : equivalent_cells[index]) {
        if (cells(j/2, j%2) == INVALID) {
          cells(j/2, j%2) = count;
          Q.push(j);
        }
      }
    }
    count++;
  };
  for (size_t i=0; i<num_patches; i++) {
    extract_equivalent_cells(i*2);
    extract_equivalent_cells(i*2+1);
  }
 
  assert((cells.array() != INVALID).all());
  return count;
}

References igl::count(), igl::find(), order_facets_around_edge(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), and Eigen::PlainObjectBase< Derived >::setConstant().

Referenced by extract_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_feature() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedE >

IGL_INLINE void igl::copyleft::cgal::extract_feature	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const double	tol,
		const Eigen::PlainObjectBase< DerivedE > &	E,
		const Eigen::PlainObjectBase< DerivedE > &	uE,
		const std::vector< std::vector< typename DerivedE::Scalar > > &	uE2E,
		Eigen::PlainObjectBase< DerivedE > &	feature_edges
	)

                                                   {
 
  assert(V.cols() == 3);
  assert(F.cols() == 3);
  using Scalar = typename DerivedV::Scalar;
  using IndexType = typename DerivedE::Scalar;
  using Vertex = Eigen::Matrix<Scalar, 3, 1>;
  using Kernel = typename CGAL::Exact_predicates_exact_constructions_kernel;
  using Point = typename Kernel::Point_3;
 
  const size_t num_unique_edges = uE.rows();
  const size_t num_faces = F.rows();
  // NOTE: CGAL's definition of dihedral angle measures the angle between two
  // facets instead of facet normals.
  const double cos_tol = cos(igl::PI - tol);
  std::vector<size_t> result; // Indices into uE
 
  auto is_non_manifold = [&uE2E](size_t ei) -> bool {
    return uE2E[ei].size() > 2;
  };
 
  auto is_boundary = [&uE2E](size_t ei) -> bool {
    return uE2E[ei].size() == 1;
  };
 
  auto opposite_vertex = [&uE, &F](size_t ei, size_t fi) -> IndexType {
    const size_t v0 = uE(ei, 0);
    const size_t v1 = uE(ei, 1);
    for (size_t i=0; i<3; i++) {
      const size_t v = F(fi, i);
      if (v != v0 && v != v1) { return v; }
    }
    throw "Input face must be topologically degenerate!";
  };
 
  auto is_feature = [&V, &F, &uE, &uE2E, &opposite_vertex, num_faces](
      size_t ei, double cos_tol) -> bool {
    auto adj_faces = uE2E[ei];
    assert(adj_faces.size() == 2);
    const Vertex v0 = V.row(uE(ei, 0));
    const Vertex v1 = V.row(uE(ei, 1));
    const Vertex v2 = V.row(opposite_vertex(ei, adj_faces[0] % num_faces));
    const Vertex v3 = V.row(opposite_vertex(ei, adj_faces[1] % num_faces));
    const Point p0(v0[0], v0[1], v0[2]);
    const Point p1(v1[0], v1[1], v1[2]);
    const Point p2(v2[0], v2[1], v2[2]);
    const Point p3(v3[0], v3[1], v3[2]);
    const auto ori = CGAL::orientation(p0, p1, p2, p3);
    switch (ori) {
      case CGAL::POSITIVE:
        return CGAL::compare_dihedral_angle(p0, p1, p2, p3, cos_tol) ==
          CGAL::SMALLER;
      case CGAL::NEGATIVE:
        return CGAL::compare_dihedral_angle(p0, p1, p3, p2, cos_tol) ==
          CGAL::SMALLER;
      case CGAL::COPLANAR:
        if (!CGAL::collinear(p0, p1, p2) && !CGAL::collinear(p0, p1, p3)) {
          return CGAL::compare_dihedral_angle(p0, p1, p2, p3, cos_tol) ==
            CGAL::SMALLER;
        } else {
          throw "Dihedral angle (and feature edge) is not well defined for"
              " degenerate triangles!";
        }
      default:
        throw "Unknown CGAL orientation";
    }
  };
 
  for (size_t i=0; i<num_unique_edges; i++) {
    if (is_boundary(i) || is_non_manifold(i) || is_feature(i, cos_tol)) {
      result.push_back(i);
    }
  }
 
  const size_t num_feature_edges = result.size();
  feature_edges.resize(num_feature_edges, 2);
  for (size_t i=0; i<num_feature_edges; i++) {
    feature_edges.row(i) = uE.row(result[i]);
  }
}

References Eigen::PlainObjectBase< Derived >::cols(), cos(), igl::PI, Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

extract_feature() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedE >

IGL_INLINE void igl::copyleft::cgal::extract_feature	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const double	tol,
		Eigen::PlainObjectBase< DerivedE > &	feature_edges
	)

                                                   {
 
  using IndexType = typename DerivedE::Scalar;
  DerivedE E, uE;
  Eigen::VectorXi EMAP;
  std::vector<std::vector<IndexType> > uE2E;
  igl::unique_edge_map(F, E, uE, EMAP, uE2E);
 
  igl::copyleft::cgal::extract_feature(V, F, tol, E, uE, uE2E, feature_edges);
}

References extract_feature(), and igl::unique_edge_map().

Referenced by extract_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

fast_winding_number() [1/2]

template<typename DerivedP , typename DerivedN , typename DerivedQ , typename BetaType , typename DerivedWN >

IGL_INLINE void igl::copyleft::cgal::fast_winding_number	(	const Eigen::MatrixBase< DerivedP > &	P,
		const Eigen::MatrixBase< DerivedN > &	N,
		const Eigen::MatrixBase< DerivedQ > &	Q,
		const int	expansion_order,
		const BetaType	beta,
		Eigen::PlainObjectBase< DerivedWN > &	WN
	)

                                           {
        typedef typename DerivedWN::Scalar real;
        typedef typename Eigen::Matrix<real,Eigen::Dynamic,Eigen::Dynamic>
                                                                  RealMatrix;
        
        std::vector<std::vector<int> > point_indices;
        Eigen::Matrix<int,Eigen::Dynamic,8> CH;
        Eigen::Matrix<real,Eigen::Dynamic,3> CN;
        Eigen::Matrix<real,Eigen::Dynamic,1> W;
        Eigen::MatrixXi I;
        Eigen::Matrix<real,Eigen::Dynamic,1> A;
        
        octree(P,point_indices,CH,CN,W);
        knn(P,21,point_indices,CH,CN,W,I);
        point_areas(P,I,N,A);
        
        Eigen::Matrix<real,Eigen::Dynamic,Eigen::Dynamic> EC;
        Eigen::Matrix<real,Eigen::Dynamic,3> CM;
        Eigen::Matrix<real,Eigen::Dynamic,1> R;
        
        igl::fast_winding_number(P,N,A,point_indices,CH,
                                 expansion_order,CM,R,EC);
        igl::fast_winding_number(P,N,A,point_indices,CH,
                                 CM,R,EC,Q,beta,WN);
      }

References igl::fast_winding_number(), igl::knn(), igl::octree(), point_areas(), and real().

Referenced by fast_winding_number().

Here is the call graph for this function:

Here is the caller graph for this function:

fast_winding_number() [2/2]

template<typename DerivedP , typename DerivedN , typename DerivedQ , typename DerivedWN >

IGL_INLINE void igl::copyleft::cgal::fast_winding_number	(	const Eigen::MatrixBase< DerivedP > &	P,
		const Eigen::MatrixBase< DerivedN > &	N,
		const Eigen::MatrixBase< DerivedQ > &	Q,
		Eigen::PlainObjectBase< DerivedWN > &	WN
	)

                                           {
        fast_winding_number(P,N,Q,2,2.0,WN);
      }

References fast_winding_number().

Here is the call graph for this function:

half_space_box() [1/3]

template<typename DerivedV >

IGL_INLINE void igl::copyleft::cgal::half_space_box	(	const CGAL::Plane_3< CGAL::Epeck > &	P,
		const Eigen::MatrixBase< DerivedV > &	V,
		Eigen::Matrix< CGAL::Epeck::FT, 8, 3 > &	BV,
		Eigen::Matrix< int, 12, 3 > &	BF
	)

{
  typedef CGAL::Plane_3<CGAL::Epeck> Plane;
  typedef CGAL::Point_3<CGAL::Epeck> Point;
  typedef CGAL::Vector_3<CGAL::Epeck> Vector;
  typedef CGAL::Epeck::FT EScalar;
  Eigen::Matrix<typename DerivedV::Scalar,1,3> avg(0,0,0);
  for(int v = 0;v<V.rows();v++) for(int c = 0;c<V.cols();c++) avg(c) += V(v,c);
  avg /= V.rows();
 
  Point o3(avg(0),avg(1),avg(2));
  Point o2 = P.projection(o3);
  Vector u;
  EScalar max_sqrd = -1;
  for(int v = 0;v<V.rows();v++)
  {
    Vector v2 = P.projection(Point(V(v,0),V(v,1),V(v,2))) - o2;
    const EScalar sqrd = v2.squared_length();
    if(max_sqrd<0 || sqrd < max_sqrd)
    {
      u = v2;
      max_sqrd = sqrd;
    }
  }
  // L1 bbd 
  const EScalar bbd = 
    (EScalar(V.col(0).maxCoeff())- EScalar(V.col(0).minCoeff())) + 
    (EScalar(V.col(1).maxCoeff())- EScalar(V.col(1).minCoeff())) + 
    (EScalar(V.col(2).maxCoeff())- EScalar(V.col(2).minCoeff()));
  Vector n = P.orthogonal_vector();
  // now we have a center o2 and a vector u to the farthest point on the plane 
  std::vector<Point> vBV;vBV.reserve(8);
  Vector v = CGAL::cross_product(u,n);
  // Scale u,v,n to be longer than bbd
  const auto & longer_than = [](const EScalar min_sqr, Vector & x)
  {
    assert(x.squared_length() > 0);
    while(x.squared_length() < min_sqr)
    {
      x = 2.*x;
    }
  };
  longer_than(bbd*bbd,u);
  longer_than(bbd*bbd,v);
  longer_than(bbd*bbd,n);
  vBV.emplace_back( o2 + u + v);
  vBV.emplace_back( o2 - u + v);
  vBV.emplace_back( o2 - u - v);
  vBV.emplace_back( o2 + u - v);
  vBV.emplace_back( o2 + u + v - n);
  vBV.emplace_back( o2 - u + v - n);
  vBV.emplace_back( o2 - u - v - n);
  vBV.emplace_back( o2 + u - v - n);
  BV.resize(8,3);
  for(int b = 0;b<8;b++)
  {
    igl::copyleft::cgal::assign_scalar(vBV[b].x(),BV(b,0));
    igl::copyleft::cgal::assign_scalar(vBV[b].y(),BV(b,1));
    igl::copyleft::cgal::assign_scalar(vBV[b].z(),BV(b,2));
  }
  BF.resize(12,3);
  BF<<
    1,0,2,
    2,0,3,
    4,5,6,
    4,6,7,
    0,1,4,
    4,1,5,
    1,2,5,
    5,2,6,
    2,3,6,
    6,3,7,
    3,0,7,
    7,0,4;
}

References assign_scalar(), Eigen::DenseBase< Derived >::maxCoeff(), Eigen::DenseBase< Derived >::minCoeff(), and Eigen::PlainObjectBase< Derived >::resize().

Referenced by half_space_box(), half_space_box(), and intersect_with_half_space().

Here is the call graph for this function:

Here is the caller graph for this function:

half_space_box() [2/3]

template<typename Derivedequ , typename DerivedV >

IGL_INLINE void igl::copyleft::cgal::half_space_box	(	const Eigen::MatrixBase< Derivedequ > &	equ,
		const Eigen::MatrixBase< DerivedV > &	V,
		Eigen::Matrix< CGAL::Epeck::FT, 8, 3 > &	BV,
		Eigen::Matrix< int, 12, 3 > &	BF
	)

{
  typedef CGAL::Plane_3<CGAL::Epeck> Plane;
  Plane P(equ(0),equ(1),equ(2),equ(3));
  return half_space_box(P,V,BV,BF);
}

References half_space_box().

Here is the call graph for this function:

half_space_box() [3/3]

template<typename Derivedp , typename Derivedn , typename DerivedV >

IGL_INLINE void igl::copyleft::cgal::half_space_box	(	const Eigen::MatrixBase< Derivedp > &	p,
		const Eigen::MatrixBase< Derivedn > &	n,
		const Eigen::MatrixBase< DerivedV > &	V,
		Eigen::Matrix< CGAL::Epeck::FT, 8, 3 > &	BV,
		Eigen::Matrix< int, 12, 3 > &	BF
	)

{
  typedef CGAL::Plane_3<CGAL::Epeck> Plane;
  typedef CGAL::Point_3<CGAL::Epeck> Point;
  typedef CGAL::Vector_3<CGAL::Epeck> Vector;
  Plane P(Point(p(0),p(1),p(2)),Vector(n(0),n(1),n(2)));
  return half_space_box(P,V,BV,BF);
}

References half_space_box().

Here is the call graph for this function:

hausdorff()

template<typename DerivedV , typename Kernel , typename Scalar >

IGL_INLINE void igl::copyleft::cgal::hausdorff	(	const Eigen::MatrixBase< DerivedV > &	V,
		const CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< CGAL::Triangle_3< Kernel > >::iterator > > > &	treeB,
		const std::vector< CGAL::Triangle_3< Kernel > > &	TB,
		Scalar &	l,
		Scalar &	u
	)

{
  // Not sure why using `auto` here doesn't work with the `hausdorff` function
  // parameter but explicitly naming the type does...
  const std::function<double(const double &,const double &,const double &)> 
    dist_to_B = [&treeB](
    const double & x, const double & y, const double & z)->double
  {
    CGAL::Point_3<Kernel> query(x,y,z);
    typename CGAL::AABB_tree<
      CGAL::AABB_traits<Kernel, 
        CGAL::AABB_triangle_primitive<Kernel, 
          typename std::vector<CGAL::Triangle_3<Kernel> >::iterator
        >
      >
    >::Point_and_primitive_id pp = treeB.closest_point_and_primitive(query);
    return std::sqrt((query-pp.first).squared_length());
  };
  return igl::hausdorff(V,dist_to_B,l,u);
}

References igl::hausdorff().

Here is the call graph for this function:

incircle()

template<typename Scalar >

IGL_INLINE short igl::copyleft::cgal::incircle	(	const Scalar	pa[2],
		const Scalar	pb[2],
		const Scalar	pc[2],
		const Scalar	pd[2]
	)

{
  typedef CGAL::Exact_predicates_exact_constructions_kernel Epeck;
  typedef CGAL::Exact_predicates_inexact_constructions_kernel Epick;
  typedef typename std::conditional<std::is_same<Scalar, Epeck::FT>::value,
          Epeck, Epick>::type Kernel;
 
  switch(CGAL::side_of_oriented_circle(
        typename Kernel::Point_2(pa[0], pa[1]),
        typename Kernel::Point_2(pb[0], pb[1]),
        typename Kernel::Point_2(pc[0], pc[1]),
        typename Kernel::Point_2(pd[0], pd[1]))) {
    case CGAL::ON_POSITIVE_SIDE:
      return 1;
    case CGAL::ON_NEGATIVE_SIDE:
      return -1;
    case CGAL::ON_ORIENTED_BOUNDARY:
      return 0;
    default:
      throw "Invalid incircle result";
  }
}

insert_into_cdt()

template<typename Kernel >

IGL_INLINE void igl::copyleft::cgal::insert_into_cdt	(	const CGAL::Object &	obj,
		const CGAL::Plane_3< Kernel > &	P,
		CGAL::Constrained_triangulation_plus_2< CGAL::Constrained_Delaunay_triangulation_2< Kernel, CGAL::Triangulation_data_structure_2< CGAL::Triangulation_vertex_base_2< Kernel >, CGAL::Constrained_triangulation_face_base_2< Kernel > >, CGAL::Exact_intersections_tag > > &	cdt
	)

{
  typedef CGAL::Point_3<Kernel>    Point_3;
  typedef CGAL::Segment_3<Kernel>  Segment_3;
  typedef CGAL::Triangle_3<Kernel> Triangle_3;
 
  if(const Segment_3 *iseg = CGAL::object_cast<Segment_3 >(&obj))
  {
    // Add segment constraint
    cdt.insert_constraint( P.to_2d(iseg->vertex(0)),P.to_2d(iseg->vertex(1)));
  }else if(const Point_3 *ipoint = CGAL::object_cast<Point_3 >(&obj))
  {
    // Add point
    cdt.insert(P.to_2d(*ipoint));
  } else if(const Triangle_3 *itri = CGAL::object_cast<Triangle_3 >(&obj))
  {
    // Add 3 segment constraints
    cdt.insert_constraint( P.to_2d(itri->vertex(0)),P.to_2d(itri->vertex(1)));
    cdt.insert_constraint( P.to_2d(itri->vertex(1)),P.to_2d(itri->vertex(2)));
    cdt.insert_constraint( P.to_2d(itri->vertex(2)),P.to_2d(itri->vertex(0)));
  } else if(const std::vector<Point_3 > *polyp =
      CGAL::object_cast< std::vector<Point_3 > >(&obj))
  {
    const std::vector<Point_3 > & poly = *polyp;
    const size_t m = poly.size();
    assert(m>=2);
    for(size_t p = 0;p<m;p++)
    {
      const size_t np = (p+1)%m;
      cdt.insert_constraint(P.to_2d(poly[p]),P.to_2d(poly[np]));
    }
  }else {
    throw std::runtime_error("Unknown intersection object!");
  }
}

Referenced by projected_cdt().

Here is the caller graph for this function:

insphere()

template<typename Scalar >

IGL_INLINE short igl::copyleft::cgal::insphere	(	const Scalar	pa[3],
		const Scalar	pb[3],
		const Scalar	pc[3],
		const Scalar	pd[3],
		const Scalar	pe[3]
	)

{
  typedef CGAL::Exact_predicates_exact_constructions_kernel Epeck;
  typedef CGAL::Exact_predicates_inexact_constructions_kernel Epick;
  typedef typename std::conditional<std::is_same<Scalar, Epeck::FT>::value,
          Epeck, Epick>::type Kernel;
 
  switch(CGAL::side_of_oriented_sphere(
        typename Kernel::Point_3(pa[0], pa[1], pa[2]),
        typename Kernel::Point_3(pb[0], pb[1], pb[2]),
        typename Kernel::Point_3(pc[0], pc[1], pc[2]),
        typename Kernel::Point_3(pd[0], pd[1], pd[2]),
        typename Kernel::Point_3(pe[0], pe[1], pe[2]))) {
    case CGAL::ON_POSITIVE_SIDE:
      return 1;
    case CGAL::ON_NEGATIVE_SIDE:
      return -1;
    case CGAL::ON_ORIENTED_BOUNDARY:
      return 0;
    default:
      throw "Invalid incircle result";
  }
}

intersect_other() [1/2]

IGL_INLINE bool igl::copyleft::cgal::intersect_other	(	const Eigen::MatrixXd &	VA,
		const Eigen::MatrixXi &	FA,
		const Eigen::MatrixXd &	VB,
		const Eigen::MatrixXi &	FB,
		const bool	first_only,
		Eigen::MatrixXi &	IF
	)

{
  Eigen::MatrixXd VVAB;
  Eigen::MatrixXi FFAB;
  Eigen::VectorXi JAB,IMAB;
  return intersect_other(
    VA,FA,VB,FB,{true,first_only},IF,VVAB,FFAB,JAB,IMAB);
}

References intersect_other().

Here is the call graph for this function:

intersect_other() [2/2]

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedIF , typename DerivedVVAB , typename DerivedFFAB , typename DerivedJAB , typename DerivedIMAB >

IGL_INLINE bool igl::copyleft::cgal::intersect_other	(	const Eigen::PlainObjectBase< DerivedVA > &	VA,
		const Eigen::PlainObjectBase< DerivedFA > &	FA,
		const Eigen::PlainObjectBase< DerivedVB > &	VB,
		const Eigen::PlainObjectBase< DerivedFB > &	FB,
		const RemeshSelfIntersectionsParam &	params,
		Eigen::PlainObjectBase< DerivedIF > &	IF,
		Eigen::PlainObjectBase< DerivedVVAB > &	VVAB,
		Eigen::PlainObjectBase< DerivedFFAB > &	FFAB,
		Eigen::PlainObjectBase< DerivedJAB > &	JAB,
		Eigen::PlainObjectBase< DerivedIMAB > &	IMAB
	)

{
  if(params.detect_only)
  {
    return intersect_other_helper<CGAL::Epick>
      (VA,FA,VB,FB,params,IF,VVAB,FFAB,JAB,IMAB);
  }else
  {
    return intersect_other_helper<CGAL::Epeck>
      (VA,FA,VB,FB,params,IF,VVAB,FFAB,JAB,IMAB);
  }
}

References igl::copyleft::cgal::RemeshSelfIntersectionsParam::detect_only.

Referenced by intersect_other(), and trim_with_solid().

Here is the caller graph for this function:

intersect_other_helper()

template<typename Kernel , typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedIF , typename DerivedVVAB , typename DerivedFFAB , typename DerivedJAB , typename DerivedIMAB >

static IGL_INLINE bool igl::copyleft::cgal::intersect_other_helper ( const Eigen::PlainObjectBase< DerivedVA > &  VA, const Eigen::PlainObjectBase< DerivedFA > &  FA, const Eigen::PlainObjectBase< DerivedVB > &  VB, const Eigen::PlainObjectBase< DerivedFB > &  FB, const RemeshSelfIntersectionsParam &  params, Eigen::PlainObjectBase< DerivedIF > &  IF, Eigen::PlainObjectBase< DerivedVVAB > &  VVAB, Eigen::PlainObjectBase< DerivedFFAB > &  FFAB, Eigen::PlainObjectBase< DerivedJAB > &  JAB, Eigen::PlainObjectBase< DerivedIMAB > &  IMAB  )

static

      {
 
        using namespace std;
        using namespace Eigen;
 
        typedef typename DerivedFA::Index Index;
        // 3D Primitives
        typedef CGAL::Point_3<Kernel>    Point_3;
        typedef CGAL::Segment_3<Kernel>  Segment_3; 
        typedef CGAL::Triangle_3<Kernel> Triangle_3; 
        typedef CGAL::Plane_3<Kernel>    Plane_3;
        typedef CGAL::Tetrahedron_3<Kernel> Tetrahedron_3; 
        // 2D Primitives
        typedef CGAL::Point_2<Kernel>    Point_2;
        typedef CGAL::Segment_2<Kernel>  Segment_2; 
        typedef CGAL::Triangle_2<Kernel> Triangle_2; 
        // 2D Constrained Delaunay Triangulation types
        typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
        typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTAB_2;
        typedef CGAL::Triangulation_data_structure_2<TVB_2,CTAB_2> TDS_2;
        typedef CGAL::Exact_intersections_tag Itag;
        // Axis-align boxes for all-pairs self-intersection detection
        typedef std::vector<Triangle_3> Triangles;
        typedef typename Triangles::iterator TrianglesIterator;
        typedef typename Triangles::const_iterator TrianglesConstIterator;
        typedef 
          CGAL::Box_intersection_d::Box_with_handle_d<double,3,TrianglesIterator> 
          Box;
        typedef 
          std::map<Index,std::vector<std::pair<Index,CGAL::Object> > > 
          OffendingMap;
        typedef std::map<std::pair<Index,Index>,std::vector<Index> >  EdgeMap;
        typedef std::pair<Index,Index> EMK;
 
        Triangles TA,TB;
        // Compute and process self intersections
        mesh_to_cgal_triangle_list(VA,FA,TA);
        mesh_to_cgal_triangle_list(VB,FB,TB);
        // http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Box_intersection_d/Chapter_main.html#Section_63.5 
        // Create the corresponding vector of bounding boxes
        std::vector<Box> A_boxes,B_boxes;
        const auto box_up = [](Triangles & T, std::vector<Box> & boxes) -> void
        {
          boxes.reserve(T.size());
          for ( 
            TrianglesIterator tit = T.begin(); 
            tit != T.end(); 
            ++tit)
          {
            boxes.push_back(Box(tit->bbox(), tit));
          }
        };
        box_up(TA,A_boxes);
        box_up(TB,B_boxes);
        OffendingMap offendingA,offendingB;
        //EdgeMap edge2facesA,edge2facesB;
 
        std::list<int> lIF;
        const auto cb = [&](const Box &a, const Box &b) -> void
        {
          using namespace std;
          // index in F and T
          int fa = a.handle()-TA.begin();
          int fb = b.handle()-TB.begin();
          const Triangle_3 & A = *a.handle();
          const Triangle_3 & B = *b.handle();
          if(CGAL::do_intersect(A,B))
          {
            // There was an intersection
            lIF.push_back(fa);
            lIF.push_back(fb);
            if(params.first_only)
            {
              throw IGL_FIRST_HIT_EXCEPTION;
            }
            if(!params.detect_only)
            {
              CGAL::Object result = CGAL::intersection(A,B);
 
              push_result(FA,fa,fb,result,offendingA);
              push_result(FB,fb,fa,result,offendingB);
            }
          }
        };
        try{
          CGAL::box_intersection_d(
            A_boxes.begin(), A_boxes.end(),
            B_boxes.begin(), B_boxes.end(),
            cb);
        }catch(int e)
        {
          // Rethrow if not FIRST_HIT_EXCEPTION
          if(e != IGL_FIRST_HIT_EXCEPTION)
          {
            throw e;
          }
          // Otherwise just fall through
        }
 
        // Convert lIF to Eigen matrix
        assert(lIF.size()%2 == 0);
        IF.resize(lIF.size()/2,2);
        {
          int i=0;
          for(
            list<int>::const_iterator ifit = lIF.begin();
            ifit!=lIF.end();
            )
          {
            IF(i,0) = (*ifit);
            ifit++; 
            IF(i,1) = (*ifit);
            ifit++;
            i++;
          }
        }
        if(!params.detect_only)
        {
          // Obsolete, now remesh_intersections expects a single mesh
          // remesh_intersections(VA,FA,TA,offendingA,VVA,FFA,JA,IMA);
          // remesh_intersections(VB,FB,TB,offendingB,VVB,FFB,JB,IMB);
          // Combine mesh and offending maps
          DerivedVA VAB(VA.rows()+VB.rows(),3);
          VAB<<VA,VB;
          DerivedFA FAB(FA.rows()+FB.rows(),3);
          FAB<<FA,(FB.array()+VA.rows());
          Triangles TAB;
          TAB.reserve(TA.size()+TB.size());
          TAB.insert(TAB.end(),TA.begin(),TA.end());
          TAB.insert(TAB.end(),TB.begin(),TB.end());
          OffendingMap offending;
          //offending.reserve(offendingA.size() + offendingB.size());
          for (const auto itr : offendingA)
          {
            // Remap offenders in FB to FAB
            auto offenders = itr.second;
            for(auto & offender : offenders)
            {
              offender.first += FA.rows();
            }
            offending[itr.first] = offenders;
          }
          for (const auto itr : offendingB)
          {
            // Store offenders for FB according to place in FAB
            offending[FA.rows() + itr.first] = itr.second;
          }
 
          remesh_intersections(
            VAB,FAB,TAB,offending,params.stitch_all,VVAB,FFAB,JAB,IMAB);
        }
 
        return IF.rows() > 0;
      }

References igl::copyleft::cgal::RemeshSelfIntersectionsParam::detect_only, igl::copyleft::cgal::RemeshSelfIntersectionsParam::first_only, IGL_FIRST_HIT_EXCEPTION, mesh_to_cgal_triangle_list(), push_result(), remesh_intersections(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), and igl::copyleft::cgal::RemeshSelfIntersectionsParam::stitch_all.

Here is the call graph for this function:

intersect_with_half_space() [1/3]

template<typename DerivedV , typename DerivedF , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::intersect_with_half_space	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		const CGAL::Plane_3< CGAL::Epeck > &	P,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  Eigen::Matrix<CGAL::Epeck::FT,8,3> BV;
  Eigen::Matrix<int,12,3> BF;
  half_space_box(P,V,BV,BF);
  // Disturbingly, (BV,BF) must be first argument
  const bool ret = mesh_boolean(BV,BF,V,F,MESH_BOOLEAN_TYPE_INTERSECT,VC,FC,J);
  // But now J is wrong...
  std::for_each(
    J.data(),
    J.data()+J.size(),
    [&BF,&F](typename DerivedJ::Scalar & j)
      {j = (j<BF.rows()?F.rows()+j:j-BF.rows());}
    );
  return ret;
}

References Eigen::PlainObjectBase< Derived >::data(), half_space_box(), mesh_boolean(), and igl::MESH_BOOLEAN_TYPE_INTERSECT.

Here is the call graph for this function:

intersect_with_half_space() [2/3]

template<typename DerivedV , typename DerivedF , typename Derivedequ , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::intersect_with_half_space	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		const Eigen::MatrixBase< Derivedequ > &	equ,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  typedef CGAL::Plane_3<CGAL::Epeck> Plane;
  Plane P(equ(0),equ(1),equ(2),equ(3));
  return intersect_with_half_space(V,F,P,VC,FC,J);
}

References intersect_with_half_space().

Here is the call graph for this function:

intersect_with_half_space() [3/3]

template<typename DerivedV , typename DerivedF , typename Derivedp , typename Derivedn , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::intersect_with_half_space	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		const Eigen::MatrixBase< Derivedp > &	p,
		const Eigen::MatrixBase< Derivedn > &	n,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  typedef CGAL::Plane_3<CGAL::Epeck> Plane;
  typedef CGAL::Point_3<CGAL::Epeck> Point;
  typedef CGAL::Vector_3<CGAL::Epeck> Vector;
  Plane P(Point(p(0),p(1),p(2)),Vector(n(0),n(1),n(2)));
  return intersect_with_half_space(V,F,P,VC,FC,J);
}

References intersect_with_half_space().

Referenced by intersect_with_half_space(), and intersect_with_half_space().

Here is the call graph for this function:

Here is the caller graph for this function:

lexicographic_triangulation()

template<typename DerivedP , typename DerivedF >

IGL_INLINE void igl::copyleft::cgal::lexicographic_triangulation	(	const Eigen::PlainObjectBase< DerivedP > &	P,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  typedef typename DerivedP::Scalar Scalar;
  igl::lexicographic_triangulation(P, orient2D<Scalar>, F);
}

References igl::lexicographic_triangulation().

Here is the call graph for this function:

mesh_boolean() [1/7]

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::MatrixBase< DerivedVB > &	VB,
		const Eigen::MatrixBase< DerivedFB > &	FB,
		const MeshBooleanType &	type,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC
	)

{
  Eigen::Matrix<typename DerivedFC::Index, Eigen::Dynamic,1> J;
  return igl::copyleft::cgal::mesh_boolean(VA,FA,VB,FB,type,VC,FC,J);
}

References mesh_boolean().

Here is the call graph for this function:

mesh_boolean() [2/7]

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::MatrixBase< DerivedVB > &	VB,
		const Eigen::MatrixBase< DerivedFB > &	FB,
		const MeshBooleanType &	type,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  std::function<int(const int, const int)> keep;
  std::function<int(const Eigen::Matrix<int,1,Eigen::Dynamic>) > wind_num_op;
  mesh_boolean_type_to_funcs(type,wind_num_op,keep);
  return mesh_boolean(VA,FA,VB,FB,wind_num_op,keep,VC,FC,J);
}

References mesh_boolean(), and mesh_boolean_type_to_funcs().

Referenced by igl::copyleft::cgal::CSGTree::CSGTree(), intersect_with_half_space(), mesh_boolean(), mesh_boolean(), mesh_boolean(), mesh_boolean(), mesh_boolean(), mesh_boolean(), minkowski_sum(), minkowski_sum(), Slic3r::MeshBoolean::minus(), Slic3r::MeshBoolean::self_union(), and wire_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_boolean() [3/7]

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::MatrixBase< DerivedVB > &	VB,
		const Eigen::MatrixBase< DerivedFB > &	FB,
		const std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &	wind_num_op,
		const std::function< int(const int, const int)> &	keep,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  // Generate combined mesh (VA,FA,VB,FB) -> (V,F)
  Eigen::Matrix<size_t,2,1> sizes(FA.rows(),FB.rows());
  // TODO: This is a precision template **bug** that results in failure to
  // compile. If DerivedVA::Scalar is double and DerivedVB::Scalar is
  // CGAL::Epeck::FT then the following assignment will not compile. This
  // implies that VA must have the trumping precision (and a valid assignment
  // operator from VB's type).
  Eigen::Matrix<typename DerivedVA::Scalar,Eigen::Dynamic,3> VV(VA.rows() + VB.rows(), 3);
  DerivedFC FF(FA.rows() + FB.rows(), 3);
  // Can't use comma initializer
  for(int a = 0;a<VA.rows();a++)
  {
    for(int d = 0;d<3;d++) VV(a,d) = VA(a,d);
  }
  for(int b = 0;b<VB.rows();b++)
  {
    for(int d = 0;d<3;d++) VV(VA.rows()+b,d) = VB(b,d);
  }
  FF.block(0, 0, FA.rows(), 3) = FA;
  // Eigen struggles to assign nothing to nothing and will assert if FB is empty
  if(FB.rows() > 0)
  {
    FF.block(FA.rows(), 0, FB.rows(), 3) = FB.array() + VA.rows();
  }
  return mesh_boolean(VV,FF,sizes,wind_num_op,keep,VC,FC,J);
}

References Eigen::MatrixBase< Derived >::array(), and mesh_boolean().

Here is the call graph for this function:

mesh_boolean() [4/7]

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::MatrixBase< DerivedVB > &	VB,
		const Eigen::MatrixBase< DerivedFB > &	FB,
		const std::string &	type_str,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  return mesh_boolean(
    VA,FA,VB,FB,string_to_mesh_boolean_type(type_str),VC,FC,J);
}

References mesh_boolean(), and string_to_mesh_boolean_type().

Here is the call graph for this function:

mesh_boolean() [5/7]

template<typename DerivedVV , typename DerivedFF , typename Derivedsizes , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const Eigen::MatrixBase< DerivedVV > &	VV,
		const Eigen::MatrixBase< DerivedFF > &	FF,
		const Eigen::MatrixBase< Derivedsizes > &	sizes,
		const std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &	wind_num_op,
		const std::function< int(const int, const int)> &	keep,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
#ifdef MESH_BOOLEAN_TIMING
  const auto & tictoc = []() -> double
  {
    static double t_start = igl::get_seconds();
    double diff = igl::get_seconds()-t_start;
    t_start += diff;
    return diff;
  };
  const auto log_time = [&](const std::string& label) -> void {
    std::cout << "mesh_boolean." << label << ": "
      << tictoc() << std::endl;
  };
  tictoc();
#endif
  typedef typename DerivedVC::Scalar Scalar;
  typedef CGAL::Epeck Kernel;
  typedef Kernel::FT ExactScalar;
  typedef Eigen::Matrix<Scalar,Eigen::Dynamic,3> MatrixX3S;
  typedef Eigen::Matrix<typename DerivedJ::Scalar,Eigen::Dynamic,1> VectorXJ;
  typedef Eigen::Matrix<
    ExactScalar,
    Eigen::Dynamic,
    Eigen::Dynamic,
    DerivedVC::IsRowMajor> MatrixXES;
  MatrixXES V;
  DerivedFC F;
  VectorXJ  CJ;
  {
    Eigen::VectorXi I;
    igl::copyleft::cgal::RemeshSelfIntersectionsParam params;
    params.stitch_all = true;
    MatrixXES Vr;
    DerivedFC Fr;
    Eigen::MatrixXi IF;
    igl::copyleft::cgal::remesh_self_intersections(
        VV, FF, params, Vr, Fr, IF, CJ, I);
    assert(I.size() == Vr.rows());
    // Merge coinciding vertices into non-manifold vertices.
    std::for_each(Fr.data(), Fr.data()+Fr.size(),
          [&I](typename DerivedFC::Scalar& a) { a=I[a]; });
      // Remove unreferenced vertices.
      Eigen::VectorXi UIM;
      igl::remove_unreferenced(Vr, Fr, V, F, UIM);
   }
#ifdef MESH_BOOLEAN_TIMING
  log_time("resolve_self_intersection");
#endif
 
  // Compute edges of (F) --> (E,uE,EMAP,uE2E)
  Eigen::MatrixXi E, uE;
  Eigen::VectorXi EMAP;
  std::vector<std::vector<size_t> > uE2E;
  igl::unique_edge_map(F, E, uE, EMAP, uE2E);
 
  // Compute patches (F,EMAP,uE2E) --> (P)
  Eigen::VectorXi P;
  const size_t num_patches = igl::extract_manifold_patches(F, EMAP, uE2E, P);
#ifdef MESH_BOOLEAN_TIMING
  log_time("patch_extraction");
#endif
 
  // Compute cells (V,F,P,E,uE,EMAP) -> (per_patch_cells)
  Eigen::MatrixXi per_patch_cells;
  const size_t num_cells =
    igl::copyleft::cgal::extract_cells(
        V, F, P, E, uE, uE2E, EMAP, per_patch_cells);
#ifdef MESH_BOOLEAN_TIMING
  log_time("cell_extraction");
#endif
 
  // Compute winding numbers on each side of each facet.
  const size_t num_faces = F.rows();
  // W(f,:) --> [w1out,w1in,w2out,w2in, ... wnout,wnint] winding numbers above
  // and below each face w.r.t. each input mesh, so that W(f,2*i) is the
  // winding number above face f w.r.t. input i, and W(f,2*i+1) is the winding
  // number below face f w.r.t. input i.
  Eigen::MatrixXi W;
  // labels(f) = i means that face f comes from mesh i
  Eigen::VectorXi labels(num_faces);
  // cumulative sizes
  Derivedsizes cumsizes;
  igl::cumsum(sizes,1,cumsizes);
  const size_t num_inputs = sizes.size();
  std::transform(
    CJ.data(), 
    CJ.data()+CJ.size(), 
    labels.data(),
    // Determine which input mesh birth face i comes from
    [&num_inputs,&cumsizes](int i)->int
    { 
      for(int k = 0;k<num_inputs;k++)
      {
        if(i<cumsizes(k)) return k;
      }
      assert(false && "Birth parent index out of range");
      return -1;
    });
  bool valid = true;
  if (num_faces > 0) 
  {
    valid = valid & 
      igl::copyleft::cgal::propagate_winding_numbers(
          V, F, uE, uE2E, num_patches, P, num_cells, per_patch_cells, labels, W);
  } else 
  {
    W.resize(0, 2*num_inputs);
  }
  assert((size_t)W.rows() == num_faces);
  // If W doesn't have enough columns, pad with zeros
  if (W.cols() <= 2*num_inputs) 
  {
    const int old_ncols = W.cols();
    W.conservativeResize(num_faces,2*num_inputs);
    W.rightCols(2*num_inputs-old_ncols).setConstant(0);
  }
  assert((size_t)W.cols() == 2*num_inputs);
#ifdef MESH_BOOLEAN_TIMING
  log_time("propagate_input_winding_number");
#endif
 
  // Compute resulting winding number.
  Eigen::MatrixXi Wr(num_faces, 2);
  for (size_t i=0; i<num_faces; i++) 
  {
    // Winding number vectors above and below
    Eigen::RowVectorXi w_out(1,num_inputs), w_in(1,num_inputs);
    for(size_t k =0;k<num_inputs;k++)
    {
      w_out(k) = W(i,2*k+0);
      w_in(k) = W(i,2*k+1);
    }
    Wr(i,0) = wind_num_op(w_out);
    Wr(i,1) = wind_num_op(w_in);
  }
#ifdef MESH_BOOLEAN_TIMING
  log_time("compute_output_winding_number");
#endif
 
#ifdef SMALL_CELL_REMOVAL
  igl::copyleft::cgal::relabel_small_immersed_cells(
    V, F, num_patches, P, num_cells, per_patch_cells, 1e-3, Wr);
#endif
 
  // Extract boundary separating inside from outside.
  auto index_to_signed_index = [&](size_t i, bool ori) -> int
  {
    return (i+1)*(ori?1:-1);
  };
  //auto signed_index_to_index = [&](int i) -> size_t {
  //    return abs(i) - 1;
  //};
  std::vector<int> selected;
  for(size_t i=0; i<num_faces; i++) 
  {
    auto should_keep = keep(Wr(i,0), Wr(i,1));
    if (should_keep > 0) 
    {
      selected.push_back(index_to_signed_index(i, true));
    } else if (should_keep < 0) 
    {
      selected.push_back(index_to_signed_index(i, false));
    }
  }
 
  const size_t num_selected = selected.size();
  DerivedFC kept_faces(num_selected, 3);
  DerivedJ  kept_face_indices(num_selected, 1);
  for (size_t i=0; i<num_selected; i++) 
  {
    size_t idx = abs(selected[i]) - 1;
    if (selected[i] > 0) 
    {
      kept_faces.row(i) = F.row(idx);
    } else 
    {
      kept_faces.row(i) = F.row(idx).reverse();
    }
    kept_face_indices(i, 0) = CJ[idx];
  }
#ifdef MESH_BOOLEAN_TIMING
  log_time("extract_output");
#endif
 
  // Finally, remove duplicated faces and unreferenced vertices.
  {
    DerivedFC G;
    DerivedJ JJ;
    igl::resolve_duplicated_faces(kept_faces, G, JJ);
    igl::slice(kept_face_indices, JJ, 1, J);
 
#ifdef DOUBLE_CHECK_EXACT_OUTPUT
    {
      // Sanity check on exact output.
      igl::copyleft::cgal::RemeshSelfIntersectionsParam params;
      params.detect_only = true;
      params.first_only = true;
      MatrixXES dummy_VV;
      DerivedFC dummy_FF, dummy_IF;
      Eigen::VectorXi dummy_J, dummy_IM;
      igl::copyleft::cgal::SelfIntersectMesh<
        Kernel,
        MatrixXES, DerivedFC,
        MatrixXES, DerivedFC,
        DerivedFC,
        Eigen::VectorXi,
        Eigen::VectorXi
      > checker(V, G, params,
          dummy_VV, dummy_FF, dummy_IF, dummy_J, dummy_IM);
      if (checker.count != 0) 
      {
        throw "Self-intersection not fully resolved.";
      }
    }
#endif
 
    MatrixX3S Vs;
    assign(V,Vs);
    Eigen::VectorXi newIM;
    igl::remove_unreferenced(Vs,G,VC,FC,newIM);
  }
#ifdef MESH_BOOLEAN_TIMING
  log_time("clean_up");
#endif
  return valid;
}

References igl::cumsum(), Eigen::Dynamic, extract_cells(), igl::extract_manifold_patches(), igl::get_seconds(), remesh_self_intersections(), igl::remove_unreferenced(), igl::copyleft::cgal::RemeshSelfIntersectionsParam::stitch_all, and igl::unique_edge_map().

Here is the call graph for this function:

mesh_boolean() [6/7]

template<typename DerivedV , typename DerivedF , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const std::vector< DerivedV > &	Vlist,
		const std::vector< DerivedF > &	Flist,
		const MeshBooleanType &	type,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  DerivedV VV;
  DerivedF FF;
  Eigen::Matrix<size_t,Eigen::Dynamic,1> Vsizes,Fsizes;
  igl::combine(Vlist,Flist,VV,FF,Vsizes,Fsizes);
  std::function<int(const int, const int)> keep;
  std::function<int(const Eigen::Matrix<int,1,Eigen::Dynamic>) > wind_num_op;
  mesh_boolean_type_to_funcs(type,wind_num_op,keep);
  return mesh_boolean(VV,FF,Fsizes,wind_num_op,keep,VC,FC,J);
}

References igl::combine(), mesh_boolean(), and mesh_boolean_type_to_funcs().

Here is the call graph for this function:

mesh_boolean() [7/7]

template<typename DerivedV , typename DerivedF , typename DerivedVC , typename DerivedFC , typename DerivedJ >

IGL_INLINE bool igl::copyleft::cgal::mesh_boolean	(	const std::vector< DerivedV > &	Vlist,
		const std::vector< DerivedF > &	Flist,
		const std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &	wind_num_op,
		const std::function< int(const int, const int)> &	keep,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  DerivedV VV;
  DerivedF FF;
  Eigen::Matrix<size_t,Eigen::Dynamic,1> Vsizes,Fsizes;
  igl::combine(Vlist,Flist,VV,FF,Vsizes,Fsizes);
  return mesh_boolean(VV,FF,Fsizes,wind_num_op,keep,VC,FC,J);
}

References igl::combine(), and mesh_boolean().

Here is the call graph for this function:

mesh_boolean_type_to_funcs()

IGL_INLINE void igl::copyleft::cgal::mesh_boolean_type_to_funcs	(	const MeshBooleanType &	type,
		std::function< int(const Eigen::Matrix< int, 1, Eigen::Dynamic >) > &	wind_num_op,
		std::function< int(const int, const int)> &	keep
	)

{
  switch (type) 
  {
    case MESH_BOOLEAN_TYPE_UNION:
      wind_num_op = BinaryUnion();
      keep = KeepInside();
      return;
    case MESH_BOOLEAN_TYPE_INTERSECT:
      wind_num_op = BinaryIntersect();
      keep = KeepInside();
      return;
    case MESH_BOOLEAN_TYPE_MINUS:
      wind_num_op = BinaryMinus();
      keep = KeepInside();
      return;
    case MESH_BOOLEAN_TYPE_XOR:
      wind_num_op = BinaryXor();
      keep = KeepInside();
      return;
    case MESH_BOOLEAN_TYPE_RESOLVE:
      wind_num_op = BinaryResolve();
      keep = KeepAll();
      return;
    default:
      assert(false && "Unsupported boolean type.");
      return;
  }
}

References igl::MESH_BOOLEAN_TYPE_INTERSECT, igl::MESH_BOOLEAN_TYPE_MINUS, igl::MESH_BOOLEAN_TYPE_RESOLVE, igl::MESH_BOOLEAN_TYPE_UNION, and igl::MESH_BOOLEAN_TYPE_XOR.

Referenced by mesh_boolean(), and mesh_boolean().

Here is the caller graph for this function:

mesh_to_cgal_triangle_list()

template<typename DerivedV , typename DerivedF , typename Kernel >

IGL_INLINE void igl::copyleft::cgal::mesh_to_cgal_triangle_list	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		std::vector< CGAL::Triangle_3< Kernel > > &	T
	)

{
  typedef CGAL::Point_3<Kernel>    Point_3;
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  // Must be 3D
  assert(V.cols() == 3);
  // **Copy** to convert to output type (this is especially/only needed if the
  // input type DerivedV::Scalar is CGAL::Epeck
  Eigen::Matrix<
    typename Kernel::FT,
    DerivedV::RowsAtCompileTime,
    DerivedV::ColsAtCompileTime> 
    KV(V.rows(),V.cols());
  assign(V,KV);
  // Must be triangles
  assert(F.cols() == 3);
  T.reserve(F.rows());
  // Loop over faces
  for(int f = 0;f<(int)F.rows();f++)
  {
    T.push_back(
      Triangle_3(
        Point_3( KV(F(f,0),0), KV(F(f,0),1), KV(F(f,0),2)),
        Point_3( KV(F(f,1),0), KV(F(f,1),1), KV(F(f,1),2)),
        Point_3( KV(F(f,2),0), KV(F(f,2),1), KV(F(f,2),2))));
  }
}

References assign().

Referenced by igl::copyleft::cgal::SelfIntersectMesh< Kernel, DerivedV, DerivedF, DerivedVV, DerivedFF, DerivedIF, DerivedJ, DerivedIM >::SelfIntersectMesh(), intersect_other_helper(), and point_mesh_squared_distance_precompute().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_to_polyhedron()

template<typename Polyhedron >

IGL_INLINE bool igl::copyleft::cgal::mesh_to_polyhedron	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F,
		Polyhedron &	poly
	)

{
  typedef typename Polyhedron::HalfedgeDS HalfedgeDS;
  // Postcondition: hds is a valid polyhedral surface.
  CGAL::Polyhedron_incremental_builder_3<HalfedgeDS> B(poly.hds());
  B.begin_surface(V.rows(),F.rows());
  typedef typename HalfedgeDS::Vertex   Vertex;
  typedef typename Vertex::Point Point;
  assert(V.cols() == 3 && "V must be #V by 3");
  for(int v = 0;v<V.rows();v++)
  {
    B.add_vertex(Point(V(v,0),V(v,1),V(v,2)));
  }
  assert(F.cols() == 3 && "F must be #F by 3");
  for(int f=0;f<F.rows();f++)
  {
    B.begin_facet();
    for(int c = 0;c<3;c++)
    {
      B.add_vertex_to_facet(F(f,c));
    }
    B.end_facet();
  }
  if(B.error())
  {
    B.rollback();
    return false;
  }
  B.end_surface();
  return poly.is_valid();
}

minkowski_sum() [1/3]

template<typename DerivedVA , typename DerivedFA , typename sType , int sCols, int sOptions, typename dType , int dCols, int dOptions, typename DerivedW , typename DerivedG , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::minkowski_sum	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::Matrix< sType, 1, sCols, sOptions > &	s,
		const Eigen::Matrix< dType, 1, dCols, dOptions > &	d,
		const bool	resolve_overlaps,
		Eigen::PlainObjectBase< DerivedW > &	W,
		Eigen::PlainObjectBase< DerivedG > &	G,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  using namespace Eigen;
  using namespace std;
  assert(s.cols() == 3 && "s should be a 3d point");
  assert(d.cols() == 3 && "d should be a 3d point");
  // silly base case
  if(FA.size() == 0)
  {
    W.resize(0,3);
    G.resize(0,3);
    return;
  }
  const int dim = VA.cols();
  assert(dim == 3 && "dim must be 3D");
  assert(s.size() == 3 && "s must be 3D point");
  assert(d.size() == 3 && "d must be 3D point");
  // segment vector
  const CGAL::Vector_3<CGAL::Epeck> v(d(0)-s(0),d(1)-s(1),d(2)-s(2));
  // number of vertices
  const int n = VA.rows();
  // duplicate vertices at s and d, we'll remove unreferernced later
  W.resize(2*n,dim);
  for(int i = 0;i<n;i++)
  {
    for(int j = 0;j<dim;j++)
    {
      W  (i,j) = VA(i,j) + s(j);
      W(i+n,j) = VA(i,j) + d(j);
    }
  }
  // number of faces
  const int m = FA.rows();
  // Nevermind, actually P = !N
  Matrix<bool,Dynamic,1> P(m,1),N(m,1);
  // loop over faces
  int mp = 0,mn = 0;
  for(int f = 0;f<m;f++)
  {
    const CGAL::Plane_3<CGAL::Epeck> plane(
      CGAL::Point_3<CGAL::Epeck>(VA(FA(f,0),0),VA(FA(f,0),1),VA(FA(f,0),2)),
      CGAL::Point_3<CGAL::Epeck>(VA(FA(f,1),0),VA(FA(f,1),1),VA(FA(f,1),2)),
      CGAL::Point_3<CGAL::Epeck>(VA(FA(f,2),0),VA(FA(f,2),1),VA(FA(f,2),2)));
    const auto normal = plane.orthogonal_vector();
    const auto dt = normal * v;
    if(dt > 0)
    {
      P(f) = true;
      N(f) = false;
      mp++;
    }else
    //}else if(dt < 0)
    {
      P(f) = false;
      N(f) = true;
      mn++;
    //}else
    //{
    //  P(f) = false;
    //  N(f) = false;
    }
  }
 
  typedef Matrix<typename DerivedG::Scalar,Dynamic,Dynamic> MatrixXI;
  typedef Matrix<typename DerivedG::Scalar,Dynamic,1> VectorXI;
  MatrixXI GT(mp+mn,3);
  GT<< slice_mask(FA,N,1), slice_mask((FA.array()+n).eval(),P,1);
  // J indexes FA for parts at s and m+FA for parts at d
  J.derived() = igl::LinSpaced<DerivedJ >(m,0,m-1);
  DerivedJ JT(mp+mn);
  JT << slice_mask(J,P,1), slice_mask(J,N,1);
  JT.block(mp,0,mn,1).array()+=m;
 
  // Original non-co-planar faces with positively oriented reversed
  MatrixXI BA(mp+mn,3);
  BA << slice_mask(FA,P,1).rowwise().reverse(), slice_mask(FA,N,1);
  // Quads along **all** sides
  MatrixXI GQ((mp+mn)*3,4);
  GQ<< 
    BA.col(1), BA.col(0), BA.col(0).array()+n, BA.col(1).array()+n,
    BA.col(2), BA.col(1), BA.col(1).array()+n, BA.col(2).array()+n,
    BA.col(0), BA.col(2), BA.col(2).array()+n, BA.col(0).array()+n;
 
  MatrixXI uGQ;
  VectorXI S,sI,sJ;
  // Inputs:
  //   F  #F by d list of polygons
  // Outputs:
  //   S  #uF list of signed incidences for each unique face
  //  uF  #uF by d list of unique faces
  //   I  #uF index vector so that uF = sort(F,2)(I,:)
  //   J  #F index vector so that sort(F,2) = uF(J,:)
  [](
      const MatrixXI & F,
      VectorXI & S,
      MatrixXI & uF,
      VectorXI & I,
      VectorXI & J)
  {
    const int m = F.rows();
    const int d = F.cols();
    MatrixXI sF = F;
    const auto MN = sF.rowwise().minCoeff().eval();
    // rotate until smallest index is first
    for(int p = 0;p<d;p++)
    {
      for(int f = 0;f<m;f++)
      {
        if(sF(f,0) != MN(f))
        {
          for(int r = 0;r<d-1;r++)
          {
            std::swap(sF(f,r),sF(f,r+1));
          }
        }
      }
    }
    // swap orienation so that last index is greater than first
    for(int f = 0;f<m;f++)
    {
      if(sF(f,d-1) < sF(f,1))
      {
        sF.block(f,1,1,d-1) = sF.block(f,1,1,d-1).reverse().eval();
      }
    }
    Matrix<bool,Dynamic,1> M = Matrix<bool,Dynamic,1>::Zero(m,1);
    {
      VectorXI P = igl::LinSpaced<VectorXI >(d,0,d-1);
      for(int p = 0;p<d;p++)
      {
        for(int f = 0;f<m;f++)
        {
          bool all = true;
          for(int r = 0;r<d;r++)
          {
            all = all && (sF(f,P(r)) == F(f,r));
          }
          M(f) = M(f) || all;
        }
        for(int r = 0;r<d-1;r++)
        {
          std::swap(P(r),P(r+1));
        }
      }
    }
    unique_rows(sF,uF,I,J);
    S = VectorXI::Zero(uF.rows(),1);
    assert(m == J.rows());
    for(int f = 0;f<m;f++)
    {
      S(J(f)) += M(f) ? 1 : -1;
    }
  }(MatrixXI(GQ),S,uGQ,sI,sJ);
  assert(S.rows() == uGQ.rows());
  const int nq = (S.array().abs()==2).count();
  GQ.resize(nq,4);
  {
    int k = 0;
    for(int q = 0;q<uGQ.rows();q++)
    {
      switch(S(q))
      {
        case -2:
          GQ.row(k++) = uGQ.row(q).reverse().eval();
          break;
        case 2:
          GQ.row(k++) = uGQ.row(q);
          break;
        default:
        // do not add
          break;
      }
    }
    assert(nq == k);
  }
 
  G.resize(GT.rows()+2*GQ.rows(),3);
  G<< 
    GT,
    GQ.col(0), GQ.col(1), GQ.col(2), 
    GQ.col(0), GQ.col(2), GQ.col(3);
  J.resize(JT.rows()+2*GQ.rows(),1);
  J<<JT,DerivedJ::Constant(2*GQ.rows(),1,2*m+1);
  if(resolve_overlaps)
  {
    Eigen::Matrix<typename DerivedJ::Scalar, Eigen::Dynamic,1> SJ;
    mesh_boolean(
      DerivedW(W),DerivedG(G),
      Matrix<typename DerivedVA::Scalar,Dynamic,Dynamic>(),MatrixXI(),
      MESH_BOOLEAN_TYPE_UNION,
      W,G,SJ);
    J.derived() = slice(DerivedJ(J),SJ,1);
  }
}

References igl::all(), Eigen::MatrixBase< Derived >::array(), Eigen::PlainObjectBase< Derived >::cols(), igl::count(), GT, mesh_boolean(), igl::MESH_BOOLEAN_TYPE_UNION, Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), igl::slice(), igl::slice_mask(), and igl::unique_rows().

Here is the call graph for this function:

minkowski_sum() [2/3]

template<typename DerivedVA , typename DerivedFA , typename sType , int sCols, int sOptions, typename dType , int dCols, int dOptions, typename DerivedW , typename DerivedG , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::minkowski_sum	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::Matrix< sType, 1, sCols, sOptions > &	s,
		const Eigen::Matrix< dType, 1, dCols, dOptions > &	d,
		Eigen::PlainObjectBase< DerivedW > &	W,
		Eigen::PlainObjectBase< DerivedG > &	G,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  return minkowski_sum(VA,FA,s,d,true,W,G,J);
}

References minkowski_sum().

Here is the call graph for this function:

minkowski_sum() [3/3]

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedW , typename DerivedG , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::minkowski_sum	(	const Eigen::MatrixBase< DerivedVA > &	VA,
		const Eigen::MatrixBase< DerivedFA > &	FA,
		const Eigen::MatrixBase< DerivedVB > &	VB,
		const Eigen::MatrixBase< DerivedFB > &	FB,
		const bool	resolve_overlaps,
		Eigen::PlainObjectBase< DerivedW > &	W,
		Eigen::PlainObjectBase< DerivedG > &	G,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  using namespace std;
  using namespace Eigen;
  assert(FA.cols() == 3 && "FA must contain a closed triangle mesh");
  assert(FB.cols() <= FA.cols() && 
    "FB must contain lower diemnsional simplices than FA");
  const auto tictoc = []()->double
  {
    static double t_start;
    double now = igl::get_seconds();
    double interval = now-t_start;
    t_start = now;
    return interval;
  };
  tictoc();
  Matrix<typename DerivedFB::Scalar,Dynamic,2> EB;
  edges(FB,EB);
  Matrix<typename DerivedFA::Scalar,Dynamic,2> EA(0,2);
  if(FB.cols() == 3)
  {
    edges(FA,EA);
  }
  // number of copies of A along edges of B
  const int n_ab = EB.rows();
  // number of copies of B along edges of A
  const int n_ba = EA.rows();
 
  vector<DerivedW> vW(n_ab + n_ba);
  vector<DerivedG> vG(n_ab + n_ba);
  vector<DerivedJ> vJ(n_ab + n_ba);
  vector<int> offsets(n_ab + n_ba + 1);
  offsets[0] = 0;
  // sweep A along edges of B
  for(int e = 0;e<n_ab;e++)
  {
    Matrix<typename DerivedJ::Scalar,Dynamic,1> eJ;
    minkowski_sum(
      VA,
      FA,
      VB.row(EB(e,0)).eval(),
      VB.row(EB(e,1)).eval(),
      false,
      vW[e],
      vG[e],
      eJ);
    assert(vG[e].rows() == eJ.rows());
    assert(eJ.cols() == 1);
    vJ[e].resize(vG[e].rows(),2);
    vJ[e].col(0) = eJ;
    vJ[e].col(1).setConstant(e);
    offsets[e+1] = offsets[e] + vW[e].rows();
  }
  // sweep B along edges of A
  for(int e = 0;e<n_ba;e++)
  {
    Matrix<typename DerivedJ::Scalar,Dynamic,1> eJ;
    const int ee = n_ab+e;
    minkowski_sum(
      VB,
      FB,
      VA.row(EA(e,0)).eval(),
      VA.row(EA(e,1)).eval(),
      false,
      vW[ee],
      vG[ee],
      eJ);
    vJ[ee].resize(vG[ee].rows(),2);
    vJ[ee].col(0) = eJ.array() + (FA.rows()+1);
    vJ[ee].col(1).setConstant(ee);
    offsets[ee+1] = offsets[ee] + vW[ee].rows();
  }
  // Combine meshes
  int n=0,m=0;
  for_each(vW.begin(),vW.end(),[&n](const DerivedW & w){n+=w.rows();});
  for_each(vG.begin(),vG.end(),[&m](const DerivedG & g){m+=g.rows();});
  assert(n == offsets.back());
 
  W.resize(n,3);
  G.resize(m,3);
  J.resize(m,2);
  {
    int m_off = 0,n_off = 0;
    for(int i = 0;i<vG.size();i++)
    {
      W.block(n_off,0,vW[i].rows(),3) = vW[i];
      G.block(m_off,0,vG[i].rows(),3) = vG[i].array()+offsets[i];
      J.block(m_off,0,vJ[i].rows(),2) = vJ[i];
      n_off += vW[i].rows();
      m_off += vG[i].rows();
    }
    assert(n == n_off);
    assert(m == m_off);
  }
  if(resolve_overlaps)
  {
    Eigen::Matrix<typename DerivedJ::Scalar, Eigen::Dynamic,1> SJ;
    mesh_boolean(
      DerivedW(W),
      DerivedG(G),
      Matrix<typename DerivedW::Scalar,Dynamic,Dynamic>(),
      Matrix<typename DerivedG::Scalar,Dynamic,Dynamic>(),
      MESH_BOOLEAN_TYPE_UNION,
      W,
      G,
      SJ);
    slice(DerivedJ(J),SJ,1,J);
  }
}

References Eigen::PlainObjectBase< Derived >::cols(), igl::edges(), igl::for_each(), igl::get_seconds(), mesh_boolean(), igl::MESH_BOOLEAN_TYPE_UNION, minkowski_sum(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::PlainObjectBase< Derived >::setConstant(), and igl::slice().

Referenced by minkowski_sum(), and minkowski_sum().

Here is the call graph for this function:

Here is the caller graph for this function:

order_facets_around_edge() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedI >

IGL_INLINE void igl::copyleft::cgal::order_facets_around_edge	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		size_t	s,
		size_t	d,
		const std::vector< int > &	adj_faces,
		const Eigen::PlainObjectBase< DerivedV > &	pivot_point,
		Eigen::PlainObjectBase< DerivedI > &	order
	)

{
  assert(V.cols() == 3);
  assert(F.cols() == 3);
  assert(pivot_point.cols() == 3);
  auto signed_index_to_index = [&](int signed_idx)
  {
      return abs(signed_idx) -1;
  };
  auto get_opposite_vertex_index = [&](size_t fid) -> typename DerivedF::Scalar
  {
      typedef typename DerivedF::Scalar Index;
      if (F(fid, 0) != (Index)s && F(fid, 0) != (Index)d) return F(fid, 0);
      if (F(fid, 1) != (Index)s && F(fid, 1) != (Index)d) return F(fid, 1);
      if (F(fid, 2) != (Index)s && F(fid, 2) != (Index)d) return F(fid, 2);
      assert(false);
      // avoid warning
      return -1;
  };
 
  {
    // Check if s, d and pivot are collinear.
    typedef CGAL::Exact_predicates_exact_constructions_kernel K;
    K::Point_3 ps(V(s,0), V(s,1), V(s,2));
    K::Point_3 pd(V(d,0), V(d,1), V(d,2));
    K::Point_3 pp(pivot_point(0,0), pivot_point(0,1), pivot_point(0,2));
    if (CGAL::collinear(ps, pd, pp)) {
        throw std::runtime_error(
                "Pivot point is collinear with the outer edge!");
    }
  }
 
  const size_t N = adj_faces.size();
  const size_t num_faces = N + 1; // N adj faces + 1 pivot face
 
  // Because face indices are used for tie breaking, the original face indices
  // in the new faces array must be ascending.
  auto comp = [&](int i, int j) 
  {
    return signed_index_to_index(adj_faces[i]) <
      signed_index_to_index(adj_faces[j]);
  };
  std::vector<size_t> adj_order(N);
  for (size_t i=0; i<N; i++) adj_order[i] = i;
  std::sort(adj_order.begin(), adj_order.end(), comp);
 
  DerivedV vertices(num_faces + 2, 3);
  for (size_t i=0; i<N; i++) 
  {
    const size_t fid = signed_index_to_index(adj_faces[adj_order[i]]);
    vertices.row(i) = V.row(get_opposite_vertex_index(fid));
  }
  vertices.row(N  ) = pivot_point;
  vertices.row(N+1) = V.row(s);
  vertices.row(N+2) = V.row(d);
 
  DerivedF faces(num_faces, 3);
  for (size_t i=0; i<N; i++)
  {
    if (adj_faces[adj_order[i]] < 0) 
    {
      faces(i,0) = N+1; // s
      faces(i,1) = N+2; // d
      faces(i,2) = i  ;
    } else 
    {
      faces(i,0) = N+2; // d
      faces(i,1) = N+1; // s
      faces(i,2) = i  ;
    }
  }
  // Last face is the pivot face.
  faces(N, 0) = N+1;
  faces(N, 1) = N+2;
  faces(N, 2) = N;
 
  std::vector<int> adj_faces_with_pivot(num_faces);
  for (size_t i=0; i<num_faces; i++)
  {
    if ((size_t)faces(i,0) == N+1 && (size_t)faces(i,1) == N+2)
    {
        adj_faces_with_pivot[i] = int(i+1) * -1;
    } else
    {
        adj_faces_with_pivot[i] = int(i+1);
    }
  }
 
  DerivedI order_with_pivot;
  order_facets_around_edge(
    vertices, faces, N+1, N+2, adj_faces_with_pivot, order_with_pivot);
 
  assert((size_t)order_with_pivot.size() == num_faces);
  order.resize(N);
  size_t pivot_index = num_faces + 1;
  for (size_t i=0; i<num_faces; i++)
  {
    if ((size_t)order_with_pivot[i] == N)
    {
      pivot_index = i;
      break;
    }
  }
  assert(pivot_index < num_faces);
 
  for (size_t i=0; i<N; i++)
  {
    order[i] = adj_order[order_with_pivot[(pivot_index+i+1)%num_faces]];
  }
}

References Eigen::PlainObjectBase< Derived >::cols(), order_facets_around_edge(), and Eigen::PlainObjectBase< Derived >::resize().

Here is the call graph for this function:

order_facets_around_edge() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedI >

IGL_INLINE void igl::copyleft::cgal::order_facets_around_edge	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		size_t	s,
		size_t	d,
		const std::vector< int > &	adj_faces,
		Eigen::PlainObjectBase< DerivedI > &	order,
		bool	debug = false
	)

Referenced by closest_facet(), igl::copyleft::cgal::points_inside_component_helper::determine_point_edge_orientation(), extract_cells_single_component(), order_facets_around_edge(), order_facets_around_edges(), and outer_facet().

Here is the caller graph for this function:

order_facets_around_edges() [1/3]

template<typename DerivedV , typename DerivedF , typename DerivedN , typename DeriveduE , typename uE2EType , typename uE2oEType , typename uE2CType >

IGL_INLINE std::enable_if<!std::is_same< typenameDerivedV::Scalar, typenameCGAL::Exact_predicates_exact_constructions_kernel::FT >::value, void >::type igl::copyleft::cgal::order_facets_around_edges	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const Eigen::PlainObjectBase< DeriveduE > &	uE,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		std::vector< std::vector< uE2oEType > > &	uE2oE,
		std::vector< std::vector< uE2CType > > &	uE2C
	)

                                                 {
 
    typedef Eigen::Matrix<typename DerivedN::Scalar, 3, 1> Vector3F;
    const typename DerivedV::Scalar EPS = 1e-12;
    const size_t num_faces = F.rows();
    const size_t num_undirected_edges = uE.rows();
 
    auto edge_index_to_face_index = [&](size_t ei) { return ei % num_faces; };
    auto edge_index_to_corner_index = [&](size_t ei) { return ei / num_faces; };
 
    uE2oE.resize(num_undirected_edges);
    uE2C.resize(num_undirected_edges);
 
    for(size_t ui = 0;ui<num_undirected_edges;ui++)
    {
        const auto& adj_edges = uE2E[ui];
        const size_t edge_valance = adj_edges.size();
        assert(edge_valance > 0);
 
        const auto ref_edge = adj_edges[0];
        const auto ref_face = edge_index_to_face_index(ref_edge);
        Vector3F ref_normal = N.row(ref_face);
 
        const auto ref_corner_o = edge_index_to_corner_index(ref_edge);
        const auto ref_corner_s = (ref_corner_o+1)%3;
        const auto ref_corner_d = (ref_corner_o+2)%3;
 
        const typename DerivedF::Scalar o = F(ref_face, ref_corner_o);
        const typename DerivedF::Scalar s = F(ref_face, ref_corner_s);
        const typename DerivedF::Scalar d = F(ref_face, ref_corner_d);
 
        Vector3F edge = V.row(d) - V.row(s);
        auto edge_len = edge.norm();
        bool degenerated = edge_len < EPS;
        if (degenerated) {
            if (edge_valance <= 2) {
                // There is only one way to order 2 or less faces.
                edge.setZero();
            } else {
                edge.setZero();
                Eigen::Matrix<typename DerivedN::Scalar, Eigen::Dynamic, 3>
                    normals(edge_valance, 3);
                for (size_t fei=0; fei<edge_valance; fei++) {
                    const auto fe = adj_edges[fei];
                    const auto f = edge_index_to_face_index(fe);
                    normals.row(fei) = N.row(f);
                }
                for (size_t i=0; i<edge_valance; i++) {
                    size_t j = (i+1) % edge_valance;
                    Vector3F ni = normals.row(i);
                    Vector3F nj = normals.row(j);
                    edge = ni.cross(nj);
                    edge_len = edge.norm();
                    if (edge_len >= EPS) {
                        edge.normalize();
                        break;
                    }
                }
 
                // Ensure edge direction are consistent with reference face.
                Vector3F in_face_vec = V.row(o) - V.row(s);
                if (edge.cross(in_face_vec).dot(ref_normal) < 0) {
                    edge *= -1;
                }
 
                if (edge.norm() < EPS) {
                    std::cerr << "=====================================" << std::endl;
                    std::cerr << "  ui: " << ui << std::endl;
                    std::cerr << "edge: " << ref_edge << std::endl;
                    std::cerr << "face: " << ref_face << std::endl;
                    std::cerr << "  vs: " << V.row(s) << std::endl;
                    std::cerr << "  vd: " << V.row(d) << std::endl;
                    std::cerr << "adj face normals: " << std::endl;
                    std::cerr << normals << std::endl;
                    std::cerr << "Very degenerated case detected:" << std::endl;
                    std::cerr << "Near zero edge surrounded by "
                        << edge_valance << " neearly colinear faces" <<
                        std::endl;
                    std::cerr << "=====================================" << std::endl;
                }
            }
        } else {
            edge.normalize();
        }
 
        Eigen::MatrixXd angle_data(edge_valance, 3);
        std::vector<bool> cons(edge_valance);
 
        for (size_t fei=0; fei<edge_valance; fei++) {
            const auto fe = adj_edges[fei];
            const auto f = edge_index_to_face_index(fe);
            const auto c = edge_index_to_corner_index(fe);
            cons[fei] = (d == F(f, (c+1)%3));
            assert( cons[fei] ||  (d == F(f,(c+2)%3)));
            assert(!cons[fei] || (s == F(f,(c+2)%3)));
            assert(!cons[fei] || (d == F(f,(c+1)%3)));
            Vector3F n = N.row(f);
            angle_data(fei, 0) = ref_normal.cross(n).dot(edge);
            angle_data(fei, 1) = ref_normal.dot(n);
            if (cons[fei]) {
                angle_data(fei, 0) *= -1;
                angle_data(fei, 1) *= -1;
            }
            angle_data(fei, 0) *= -1; // Sort clockwise.
            angle_data(fei, 2) = (cons[fei]?1.:-1.)*(f+1);
        }
 
        Eigen::VectorXi order;
        igl::sort_angles(angle_data, order);
 
        auto& ordered_edges = uE2oE[ui];
        auto& consistency = uE2C[ui];
 
        ordered_edges.resize(edge_valance);
        consistency.resize(edge_valance);
        for (size_t fei=0; fei<edge_valance; fei++) {
            ordered_edges[fei] = adj_edges[order[fei]];
            consistency[fei] = cons[order[fei]];
        }
    }
}

References igl::EPS(), Eigen::PlainObjectBase< Derived >::rows(), and igl::sort_angles().

Referenced by outer_hull_legacy().

Here is the call graph for this function:

Here is the caller graph for this function:

order_facets_around_edges() [2/3]

template<typename DerivedV , typename DerivedF , typename DerivedN , typename DeriveduE , typename uE2EType , typename uE2oEType , typename uE2CType >

IGL_INLINE std::enable_if< std::is_same< typenameDerivedV::Scalar, typenameCGAL::Exact_predicates_exact_constructions_kernel::FT >::value, void >::type igl::copyleft::cgal::order_facets_around_edges	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const Eigen::PlainObjectBase< DeriveduE > &	uE,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		std::vector< std::vector< uE2oEType > > &	uE2oE,
		std::vector< std::vector< uE2CType > > &	uE2C
	)

                                                 {
 
    typedef Eigen::Matrix<typename DerivedN::Scalar, 3, 1> Vector3F;
    typedef Eigen::Matrix<typename DerivedV::Scalar, 3, 1> Vector3E;
    const typename DerivedV::Scalar EPS = 1e-12;
    const size_t num_faces = F.rows();
    const size_t num_undirected_edges = uE.rows();
 
    auto edge_index_to_face_index = [&](size_t ei) { return ei % num_faces; };
    auto edge_index_to_corner_index = [&](size_t ei) { return ei / num_faces; };
 
    uE2oE.resize(num_undirected_edges);
    uE2C.resize(num_undirected_edges);
 
    for(size_t ui = 0;ui<num_undirected_edges;ui++)
    {
        const auto& adj_edges = uE2E[ui];
        const size_t edge_valance = adj_edges.size();
        assert(edge_valance > 0);
 
        const auto ref_edge = adj_edges[0];
        const auto ref_face = edge_index_to_face_index(ref_edge);
        Vector3F ref_normal = N.row(ref_face);
 
        const auto ref_corner_o = edge_index_to_corner_index(ref_edge);
        const auto ref_corner_s = (ref_corner_o+1)%3;
        const auto ref_corner_d = (ref_corner_o+2)%3;
 
        const typename DerivedF::Scalar o = F(ref_face, ref_corner_o);
        const typename DerivedF::Scalar s = F(ref_face, ref_corner_s);
        const typename DerivedF::Scalar d = F(ref_face, ref_corner_d);
 
        Vector3E exact_edge = V.row(d) - V.row(s);
        exact_edge.array() /= exact_edge.squaredNorm();
        Vector3F edge(
                CGAL::to_double(exact_edge[0]),
                CGAL::to_double(exact_edge[1]),
                CGAL::to_double(exact_edge[2]));
        edge.normalize();
 
        Eigen::MatrixXd angle_data(edge_valance, 3);
        std::vector<bool> cons(edge_valance);
 
        for (size_t fei=0; fei<edge_valance; fei++) {
            const auto fe = adj_edges[fei];
            const auto f = edge_index_to_face_index(fe);
            const auto c = edge_index_to_corner_index(fe);
            cons[fei] = (d == F(f, (c+1)%3));
            assert( cons[fei] ||  (d == F(f,(c+2)%3)));
            assert(!cons[fei] || (s == F(f,(c+2)%3)));
            assert(!cons[fei] || (d == F(f,(c+1)%3)));
            Vector3F n = N.row(f);
            angle_data(fei, 0) = ref_normal.cross(n).dot(edge);
            angle_data(fei, 1) = ref_normal.dot(n);
            if (cons[fei]) {
                angle_data(fei, 0) *= -1;
                angle_data(fei, 1) *= -1;
            }
            angle_data(fei, 0) *= -1; // Sort clockwise.
            angle_data(fei, 2) = (cons[fei]?1.:-1.)*(f+1);
        }
 
        Eigen::VectorXi order;
        igl::sort_angles(angle_data, order);
 
        auto& ordered_edges = uE2oE[ui];
        auto& consistency = uE2C[ui];
 
        ordered_edges.resize(edge_valance);
        consistency.resize(edge_valance);
        for (size_t fei=0; fei<edge_valance; fei++) {
            ordered_edges[fei] = adj_edges[order[fei]];
            consistency[fei] = cons[order[fei]];
        }
    }
}

References igl::EPS(), Eigen::PlainObjectBase< Derived >::rows(), and igl::sort_angles().

Here is the call graph for this function:

order_facets_around_edges() [3/3]

template<typename DerivedV , typename DerivedF , typename DeriveduE , typename uE2EType , typename uE2oEType , typename uE2CType >

IGL_INLINE void igl::copyleft::cgal::order_facets_around_edges	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DeriveduE > &	uE,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		std::vector< std::vector< uE2oEType > > &	uE2oE,
		std::vector< std::vector< uE2CType > > &	uE2C
	)

                                                 {
 
    //typedef Eigen::Matrix<typename DerivedV::Scalar, 3, 1> Vector3E;
    const size_t num_faces = F.rows();
    const size_t num_undirected_edges = uE.rows();
 
    auto edge_index_to_face_index = [&](size_t ei) { return ei % num_faces; };
    auto edge_index_to_corner_index = [&](size_t ei) { return ei / num_faces; };
 
    uE2oE.resize(num_undirected_edges);
    uE2C.resize(num_undirected_edges);
 
    for(size_t ui = 0;ui<num_undirected_edges;ui++)
    {
        const auto& adj_edges = uE2E[ui];
        const size_t edge_valance = adj_edges.size();
        assert(edge_valance > 0);
 
        const auto ref_edge = adj_edges[0];
        const auto ref_face = edge_index_to_face_index(ref_edge);
 
        const auto ref_corner_o = edge_index_to_corner_index(ref_edge);
        const auto ref_corner_s = (ref_corner_o+1)%3;
        const auto ref_corner_d = (ref_corner_o+2)%3;
 
        //const typename DerivedF::Scalar o = F(ref_face, ref_corner_o);
        const typename DerivedF::Scalar s = F(ref_face, ref_corner_s);
        const typename DerivedF::Scalar d = F(ref_face, ref_corner_d);
 
        std::vector<bool> cons(edge_valance);
        std::vector<int> adj_faces(edge_valance);
        for (size_t fei=0; fei<edge_valance; fei++) {
            const auto fe = adj_edges[fei];
            const auto f = edge_index_to_face_index(fe);
            const auto c = edge_index_to_corner_index(fe);
            cons[fei] = (d == F(f, (c+1)%3));
            adj_faces[fei] = (f+1) * (cons[fei] ? 1:-1);
 
            assert( cons[fei] ||  (d == F(f,(c+2)%3)));
            assert(!cons[fei] || (s == F(f,(c+2)%3)));
            assert(!cons[fei] || (d == F(f,(c+1)%3)));
        }
 
        Eigen::VectorXi order;
        order_facets_around_edge(V, F, s, d, adj_faces, order);
        assert((size_t)order.size() == edge_valance);
 
        auto& ordered_edges = uE2oE[ui];
        auto& consistency = uE2C[ui];
 
        ordered_edges.resize(edge_valance);
        consistency.resize(edge_valance);
        for (size_t fei=0; fei<edge_valance; fei++) {
            ordered_edges[fei] = adj_edges[order[fei]];
            consistency[fei] = cons[order[fei]];
        }
    }
}

References order_facets_around_edge(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

orient2D()

template<typename Scalar >

IGL_INLINE short igl::copyleft::cgal::orient2D	(	const Scalar	pa[2],
		const Scalar	pb[2],
		const Scalar	pc[2]
	)

{
  typedef CGAL::Exact_predicates_exact_constructions_kernel Epeck;
  typedef CGAL::Exact_predicates_inexact_constructions_kernel Epick;
  typedef typename std::conditional<std::is_same<Scalar, Epeck::FT>::value,
          Epeck, Epick>::type Kernel;
 
  switch(CGAL::orientation(
        typename Kernel::Point_2(pa[0], pa[1]),
        typename Kernel::Point_2(pb[0], pb[1]),
        typename Kernel::Point_2(pc[0], pc[1]))) {
    case CGAL::LEFT_TURN:
      return 1;
    case CGAL::RIGHT_TURN:
      return -1;
    case CGAL::COLLINEAR:
      return 0;
    default:
      throw "Invalid orientation";
  }
}

orient3D()

template<typename Scalar >

IGL_INLINE short igl::copyleft::cgal::orient3D	(	const Scalar	pa[3],
		const Scalar	pb[3],
		const Scalar	pc[3],
		const Scalar	pd[3]
	)

{
  typedef CGAL::Exact_predicates_exact_constructions_kernel Epeck;
  typedef CGAL::Exact_predicates_inexact_constructions_kernel Epick;
  typedef typename std::conditional<std::is_same<Scalar, Epeck::FT>::value,
          Epeck, Epick>::type Kernel;
 
  switch(CGAL::orientation(
        typename Kernel::Point_3(pa[0], pa[1], pa[2]),
        typename Kernel::Point_3(pb[0], pb[1], pb[2]),
        typename Kernel::Point_3(pc[0], pc[1], pc[2]),
        typename Kernel::Point_3(pd[0], pd[1], pd[2]))) {
    case CGAL::POSITIVE:
      return 1;
    case CGAL::NEGATIVE:
      return -1;
    case CGAL::COPLANAR:
      return 0;
    default:
      throw "Invalid orientation";
  }
}

outer_edge()

template<typename DerivedV , typename DerivedF , typename DerivedI , typename IndexType , typename DerivedA >

IGL_INLINE void igl::copyleft::cgal::outer_edge	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		IndexType &	v1,
		IndexType &	v2,
		Eigen::PlainObjectBase< DerivedA > &	A
	)

                                            {
    // Algorithm:
    //    Find an outer vertex first.
    //    Find the incident edge with largest abs slope when projected onto XY plane.
    //    If there is a tie, check the signed slope and use the positive one.
    //    If there is still a tie, break it using the projected slope onto ZX plane.
    //    If there is still a tie, again check the signed slope and use the positive one.
    //    If there is still a tie, then there are multiple overlapping edges,
    //    which violates the precondition.
    typedef typename DerivedV::Scalar Scalar;
    typedef typename DerivedV::Index Index;
    typedef typename Eigen::Matrix<Scalar, 3, 1> ScalarArray3;
    typedef typename Eigen::Matrix<typename DerivedF::Scalar, 3, 1> IndexArray3;
    const Index INVALID = std::numeric_limits<Index>::max();
 
    Index outer_vid;
    Eigen::Matrix<Index,Eigen::Dynamic,1> candidate_faces;
    outer_vertex(V, F, I, outer_vid, candidate_faces);
    const ScalarArray3& outer_v = V.row(outer_vid);
    assert(candidate_faces.size() > 0);
 
    auto get_vertex_index = [&](const IndexArray3& f, Index vid) -> Index
    {
        if (f[0] == vid) return 0;
        if (f[1] == vid) return 1;
        if (f[2] == vid) return 2;
        assert(false);
        return -1;
    };
 
    auto unsigned_value = [](Scalar v) -> Scalar {
        if (v < 0) return v * -1;
        else return v;
    };
 
    Scalar outer_slope_YX = 0;
    Scalar outer_slope_ZX = 0;
    Index outer_opp_vid = INVALID;
    bool infinite_slope_detected = false;
    std::vector<Index> incident_faces;
    auto check_and_update_outer_edge = [&](Index opp_vid, Index fid) -> void {
        if (opp_vid == outer_opp_vid)
        {
            incident_faces.push_back(fid);
            return;
        }
 
        const ScalarArray3 opp_v = V.row(opp_vid);
        if (!infinite_slope_detected && outer_v[0] != opp_v[0])
        {
            // Finite slope
            const ScalarArray3 diff = opp_v - outer_v;
            const Scalar slope_YX = diff[1] / diff[0];
            const Scalar slope_ZX = diff[2] / diff[0];
            const Scalar u_slope_YX = unsigned_value(slope_YX);
            const Scalar u_slope_ZX = unsigned_value(slope_ZX);
            bool update = false;
            if (outer_opp_vid == INVALID) {
                update = true;
            } else {
                const Scalar u_outer_slope_YX = unsigned_value(outer_slope_YX);
                if (u_slope_YX > u_outer_slope_YX) {
                    update = true;
                } else if (u_slope_YX == u_outer_slope_YX &&
                        slope_YX > outer_slope_YX) {
                    update = true;
                } else if (slope_YX == outer_slope_YX) {
                    const Scalar u_outer_slope_ZX =
                        unsigned_value(outer_slope_ZX);
                    if (u_slope_ZX > u_outer_slope_ZX) {
                        update = true;
                    } else if (u_slope_ZX == u_outer_slope_ZX &&
                            slope_ZX > outer_slope_ZX) {
                        update = true;
                    } else if (slope_ZX == u_outer_slope_ZX) {
                        assert(false);
                    }
                }
            }
 
            if (update) {
                outer_opp_vid = opp_vid;
                outer_slope_YX = slope_YX;
                outer_slope_ZX = slope_ZX;
                incident_faces = {fid};
            }
        } else if (!infinite_slope_detected)
        {
            // Infinite slope
            outer_opp_vid = opp_vid;
            infinite_slope_detected = true;
            incident_faces = {fid};
        }
    };
 
    const size_t num_candidate_faces = candidate_faces.size();
    for (size_t i=0; i<num_candidate_faces; i++)
    {
        const Index fid = candidate_faces(i);
        const IndexArray3& f = F.row(fid);
        size_t id = get_vertex_index(f, outer_vid);
        Index next_vid = f((id+1)%3);
        Index prev_vid = f((id+2)%3);
        check_and_update_outer_edge(next_vid, fid);
        check_and_update_outer_edge(prev_vid, fid);
    }
 
    v1 = outer_vid;
    v2 = outer_opp_vid;
    A.resize(incident_faces.size());
    std::copy(incident_faces.begin(), incident_faces.end(), A.data());
}

References Eigen::PlainObjectBase< Derived >::data(), outer_vertex(), and Eigen::PlainObjectBase< Derived >::resize().

Referenced by outer_facet(), and outer_facet().

Here is the call graph for this function:

Here is the caller graph for this function:

outer_facet() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedI , typename IndexType >

IGL_INLINE void igl::copyleft::cgal::outer_facet	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		IndexType &	f,
		bool &	flipped
	)

                        {
 
    // Algorithm:
    //
    //    1. Find an outer edge (s, d).
    //
    //    2. Order adjacent facets around this edge. Because the edge is an
    //    outer edge, there exists a plane passing through it such that all its
    //    adjacent facets lie on the same side. The implementation of
    //    order_facets_around_edge() will find a natural start facet such that
    //    The first and last facets according to this order are on the outside.
    //
    //    3. Because the vertex s is an outer vertex by construction (see
    //    implemnetation of outer_edge()). The first adjacent facet is facing
    //    outside (i.e. flipped=false) if it has positive X normal component.
    //    If it has zero normal component, it is facing outside if it contains
    //    directed edge (s, d).  
 
    //typedef typename DerivedV::Scalar Scalar;
    typedef typename DerivedV::Index Index;
 
    Index s,d;
    Eigen::Matrix<Index,Eigen::Dynamic,1> incident_faces;
    outer_edge(V, F, I, s, d, incident_faces);
    assert(incident_faces.size() > 0);
 
    auto convert_to_signed_index = [&](size_t fid) -> int{
        if ((F(fid, 0) == s && F(fid, 1) == d) ||
            (F(fid, 1) == s && F(fid, 2) == d) ||
            (F(fid, 2) == s && F(fid, 0) == d) ) {
            return int(fid+1) * -1;
        } else {
            return int(fid+1);
        }
    };
 
    auto signed_index_to_index = [&](int signed_id) -> size_t {
        return size_t(abs(signed_id) - 1);
    };
 
    std::vector<int> adj_faces(incident_faces.size());
    std::transform(incident_faces.data(),
            incident_faces.data() + incident_faces.size(),
            adj_faces.begin(),
            convert_to_signed_index);
 
    DerivedV pivot_point = V.row(s);
    pivot_point(0, 0) += 1.0;
 
    Eigen::VectorXi order;
    order_facets_around_edge(V, F, s, d, adj_faces, pivot_point, order);
 
    f = signed_index_to_index(adj_faces[order[0]]);
    flipped = adj_faces[order[0]] > 0;
}

References Eigen::PlainObjectBase< Derived >::data(), order_facets_around_edge(), and outer_edge().

Referenced by extract_cells(), outer_hull_legacy(), and propagate_winding_numbers().

Here is the call graph for this function:

Here is the caller graph for this function:

outer_facet() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedN , typename DerivedI , typename IndexType >

IGL_INLINE void igl::copyleft::cgal::outer_facet	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		IndexType &	f,
		bool &	flipped
	)

                        {
    // Algorithm:
    //    Find an outer edge.
    //    Find the incident facet with the largest absolute X normal component.
    //    If there is a tie, keep the one with positive X component.
    //    If there is still a tie, pick the face with the larger signed index
    //    (flipped face has negative index).
    typedef typename DerivedV::Scalar Scalar;
    typedef typename DerivedV::Index Index;
    const size_t INVALID = std::numeric_limits<size_t>::max();
 
    Index v1,v2;
    Eigen::Matrix<Index,Eigen::Dynamic,1> incident_faces;
    outer_edge(V, F, I, v1, v2, incident_faces);
    assert(incident_faces.size() > 0);
 
    auto generic_fabs = [&](const Scalar& val) -> const Scalar {
        if (val >= 0) return val;
        else return -val;
    };
 
    Scalar max_nx = 0;
    size_t outer_fid = INVALID;
    const size_t num_incident_faces = incident_faces.size();
    for (size_t i=0; i<num_incident_faces; i++) 
    {
        const auto& fid = incident_faces(i);
        const Scalar nx = N(fid, 0);
        if (outer_fid == INVALID) {
            max_nx = nx;
            outer_fid = fid;
        } else {
            if (generic_fabs(nx) > generic_fabs(max_nx)) {
                max_nx = nx;
                outer_fid = fid;
            } else if (nx == -max_nx && nx > 0) {
                max_nx = nx;
                outer_fid = fid;
            } else if (nx == max_nx) {
                if ((max_nx >= 0 && outer_fid < fid) ||
                    (max_nx <  0 && outer_fid > fid)) {
                    max_nx = nx;
                    outer_fid = fid;
                }
            }
        }
    }
 
    assert(outer_fid != INVALID);
    f = outer_fid;
    flipped = max_nx < 0;
}

References outer_edge().

Here is the call graph for this function:

outer_hull()

template<typename DerivedV , typename DerivedF , typename DerivedHV , typename DerivedHF , typename DerivedJ , typename Derivedflip >

IGL_INLINE void igl::copyleft::cgal::outer_hull	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedHV > &	HV,
		Eigen::PlainObjectBase< DerivedHF > &	HF,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< Derivedflip > &	flip
	)

{
  // Exact types
  typedef CGAL::Epeck Kernel;
  typedef Kernel::FT ExactScalar;
  typedef
    Eigen::Matrix<
    ExactScalar,
    Eigen::Dynamic,
    Eigen::Dynamic,
    DerivedHV::IsRowMajor>
      MatrixXES;
  // Remesh self-intersections
  MatrixXES Vr;
  DerivedHF Fr;
  DerivedJ Jr;
  {
    RemeshSelfIntersectionsParam params;
    params.stitch_all = true;
    Eigen::VectorXi I;
    Eigen::MatrixXi IF;
    remesh_self_intersections(V, F, params, Vr, Fr, IF, Jr, I);
    // Merge coinciding vertices into non-manifold vertices.
    std::for_each(Fr.data(), Fr.data()+Fr.size(),
      [&I](typename DerivedHF::Scalar& a) { a=I[a]; });
      // Remove unreferenced vertices.
    Eigen::VectorXi UIM;
    remove_unreferenced(MatrixXES(Vr),DerivedHF(Fr), Vr, Fr, UIM);
  }
  // Extract cells for each face
  Eigen::MatrixXi C;
  extract_cells(Vr,Fr,C);
  // Extract faces on ambient cell
  int num_outer = 0;
  for(int i = 0;i<C.rows();i++)
  {
    num_outer += ( C(i,0) == 0 || C(i,1) == 0 ) ? 1 : 0;
  }
  HF.resize(num_outer,3);
  J.resize(num_outer,1);
  flip.resize(num_outer,1);
  {
    int h = 0;
    for(int i = 0;i<C.rows();i++)
    {
      if(C(i,0)==0)
      {
        HF.row(h) = Fr.row(i);
        J(h) = Jr(i);
        flip(h) = false;
        h++;
      }else if(C(i,1) == 0)
      {
        HF.row(h) = Fr.row(i).reverse();
        J(h) = Jr(i);
        flip(h) = true;
        h++;
      }
    }
    assert(h == num_outer);
  }
  // Remove unreferenced vertices and re-index faces
  {
    // Cast to output type
    DerivedHV Vr_cast;
    assign(Vr,Vr_cast);
    Eigen::VectorXi I;
    remove_unreferenced(Vr_cast,DerivedHF(HF),HV,HF,I);
  }
}

References assign(), Eigen::Dynamic, extract_cells(), remesh_self_intersections(), igl::remove_unreferenced(), Eigen::PlainObjectBase< Derived >::resize(), and igl::copyleft::cgal::RemeshSelfIntersectionsParam::stitch_all.

Here is the call graph for this function:

outer_hull_legacy()

template<typename DerivedV , typename DerivedF , typename DerivedG , typename DerivedJ , typename Derivedflip >

IGL_INLINE void igl::copyleft::cgal::outer_hull_legacy	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedG > &	G,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< Derivedflip > &	flip
	)

{
#ifdef IGL_OUTER_HULL_DEBUG
  std::cerr << "Extracting outer hull" << std::endl;
#endif
  using namespace Eigen;
  using namespace std;
  typedef typename DerivedF::Index Index;
  Matrix<Index,DerivedF::RowsAtCompileTime,1> C;
  typedef Matrix<typename DerivedV::Scalar,Dynamic,DerivedV::ColsAtCompileTime> MatrixXV;
  //typedef Matrix<typename DerivedF::Scalar,Dynamic,DerivedF::ColsAtCompileTime> MatrixXF;
  typedef Matrix<typename DerivedG::Scalar,Dynamic,DerivedG::ColsAtCompileTime> MatrixXG;
  typedef Matrix<typename DerivedJ::Scalar,Dynamic,DerivedJ::ColsAtCompileTime> MatrixXJ;
  const Index m = F.rows();
 
  // UNUSED:
  //const auto & duplicate_simplex = [&F](const int f, const int g)->bool
  //{
  //  return
  //    (F(f,0) == F(g,0) && F(f,1) == F(g,1) && F(f,2) == F(g,2)) ||
  //    (F(f,1) == F(g,0) && F(f,2) == F(g,1) && F(f,0) == F(g,2)) ||
  //    (F(f,2) == F(g,0) && F(f,0) == F(g,1) && F(f,1) == F(g,2)) ||
  //    (F(f,0) == F(g,2) && F(f,1) == F(g,1) && F(f,2) == F(g,0)) ||
  //    (F(f,1) == F(g,2) && F(f,2) == F(g,1) && F(f,0) == F(g,0)) ||
  //    (F(f,2) == F(g,2) && F(f,0) == F(g,1) && F(f,1) == F(g,0));
  //};
 
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"outer hull..."<<endl;
#endif
 
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"edge map..."<<endl;
#endif
  typedef Matrix<typename DerivedF::Scalar,Dynamic,2> MatrixX2I;
  typedef Matrix<typename DerivedF::Index,Dynamic,1> VectorXI;
  //typedef Matrix<typename DerivedV::Scalar, 3, 1> Vector3F;
  MatrixX2I E,uE;
  VectorXI EMAP;
  vector<vector<typename DerivedF::Index> > uE2E;
  unique_edge_map(F,E,uE,EMAP,uE2E);
#ifdef IGL_OUTER_HULL_DEBUG
  for (size_t ui=0; ui<uE.rows(); ui++) {
      std::cout << ui << ": " << uE2E[ui].size() << " -- (";
      for (size_t i=0; i<uE2E[ui].size(); i++) {
          std::cout << uE2E[ui][i] << ", ";
      }
      std::cout << ")" << std::endl;
  }
#endif
 
  std::vector<std::vector<typename DerivedF::Index> > uE2oE;
  std::vector<std::vector<bool> > uE2C;
  order_facets_around_edges(V, F, uE, uE2E, uE2oE, uE2C);
  uE2E = uE2oE;
  VectorXI diIM(3*m);
  for (auto ue : uE2E) {
      for (size_t i=0; i<ue.size(); i++) {
          auto fe = ue[i];
          diIM[fe] = i;
      }
  }
 
  vector<vector<vector<Index > > > TT,_1;
  triangle_triangle_adjacency(E,EMAP,uE2E,false,TT,_1);
  VectorXI counts;
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"facet components..."<<endl;
#endif
  facet_components(TT,C,counts);
  assert(C.maxCoeff()+1 == counts.rows());
  const size_t ncc = counts.rows();
  G.resize(0,F.cols());
  J.resize(0,1);
  flip.setConstant(m,1,false);
 
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"reindex..."<<endl;
#endif
  // H contains list of faces on outer hull;
  vector<bool> FH(m,false);
  vector<bool> EH(3*m,false);
  vector<MatrixXG> vG(ncc);
  vector<MatrixXJ> vJ(ncc);
  vector<MatrixXJ> vIM(ncc);
  //size_t face_count = 0;
  for(size_t id = 0;id<ncc;id++)
  {
    vIM[id].resize(counts[id],1);
  }
  // current index into each IM
  vector<size_t> g(ncc,0);
  // place order of each face in its respective component
  for(Index f = 0;f<m;f++)
  {
    vIM[C(f)](g[C(f)]++) = f;
  }
 
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"barycenters..."<<endl;
#endif
  // assumes that "resolve" has handled any coplanar cases correctly and nearly
  // coplanar cases can be sorted based on barycenter.
  MatrixXV BC;
  barycenter(V,F,BC);
 
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"loop over CCs (="<<ncc<<")..."<<endl;
#endif
  for(Index id = 0;id<(Index)ncc;id++)
  {
    auto & IM = vIM[id];
    // starting face that's guaranteed to be on the outer hull and in this
    // component
    int f;
    bool f_flip;
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"outer facet..."<<endl;
#endif
  igl::copyleft::cgal::outer_facet(V,F,IM,f,f_flip);
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"outer facet: "<<f<<endl;
  //cout << V.row(F(f, 0)) << std::endl;
  //cout << V.row(F(f, 1)) << std::endl;
  //cout << V.row(F(f, 2)) << std::endl;
#endif
    int FHcount = 1;
    FH[f] = true;
    // Q contains list of face edges to continue traversing upong
    queue<int> Q;
    Q.push(f+0*m);
    Q.push(f+1*m);
    Q.push(f+2*m);
    flip(f) = f_flip;
    //std::cout << "face " << face_count++ << ": " << f << std::endl;
    //std::cout << "f " << F.row(f).array()+1 << std::endl;
    //cout<<"flip("<<f<<") = "<<(flip(f)?"true":"false")<<endl;
#ifdef IGL_OUTER_HULL_DEBUG
  cout<<"BFS..."<<endl;
#endif
    while(!Q.empty())
    {
      // face-edge
      const int e = Q.front();
      Q.pop();
      // face
      const int f = e%m;
      // corner
      const int c = e/m;
#ifdef IGL_OUTER_HULL_DEBUG
      std::cout << "edge: " << e << ", ue: " << EMAP(e) << std::endl;
      std::cout << "face: " << f << std::endl;
      std::cout << "corner: " << c << std::endl;
      std::cout << "consistent: " << uE2C[EMAP(e)][diIM[e]] << std::endl;
#endif
      // Should never see edge again...
      if(EH[e] == true)
      {
        continue;
      }
      EH[e] = true;
      // source of edge according to f
      const int fs = flip(f)?F(f,(c+2)%3):F(f,(c+1)%3);
      // destination of edge according to f
      const int fd = flip(f)?F(f,(c+1)%3):F(f,(c+2)%3);
      // edge valence
      const size_t val = uE2E[EMAP(e)].size();
#ifdef IGL_OUTER_HULL_DEBUG
      //std::cout << "vd: " << V.row(fd) << std::endl;
      //std::cout << "vs: " << V.row(fs) << std::endl;
      //std::cout << "edge: " << V.row(fd) - V.row(fs) << std::endl;
      for (size_t i=0; i<val; i++) {
          if (i == diIM(e)) {
              std::cout << "* ";
          } else {
              std::cout << "  ";
          }
          std::cout << i << ": "
              << " (e: " << uE2E[EMAP(e)][i] << ", f: "
              << uE2E[EMAP(e)][i] % m * (uE2C[EMAP(e)][i] ? 1:-1) << ")" << std::endl;
      }
#endif
 
      // is edge consistent with edge of face used for sorting
      const int e_cons = (uE2C[EMAP(e)][diIM(e)] ? 1: -1);
      int nfei = -1;
      // Loop once around trying to find suitable next face
      for(size_t step = 1; step<val+2;step++)
      {
        const int nfei_new = (diIM(e) + 2*val + e_cons*step*(flip(f)?-1:1))%val;
        const int nf = uE2E[EMAP(e)][nfei_new] % m;
        {
#ifdef IGL_OUTER_HULL_DEBUG
        //cout<<"Next facet: "<<(f+1)<<" --> "<<(nf+1)<<", |"<<
        //  di[EMAP(e)][diIM(e)]<<" - "<<di[EMAP(e)][nfei_new]<<"| = "<<
        //    abs(di[EMAP(e)][diIM(e)] - di[EMAP(e)][nfei_new])
        //    <<endl;
#endif
 
 
 
          // Only use this face if not already seen
          if(!FH[nf])
          {
            nfei = nfei_new;
          //} else {
          //    std::cout << "skipping face " << nfei_new << " because it is seen before"
          //        << std::endl;
          }
          break;
        //} else {
        //    std::cout << di[EMAP(e)][diIM(e)].transpose() << std::endl;
        //    std::cout << di[EMAP(e)][diIM(nfei_new)].transpose() << std::endl;
        //    std::cout << "skipping face " << nfei_new << " with identical dihedral angle"
        //        << std::endl;
        }
//#ifdef IGL_OUTER_HULL_DEBUG
//        cout<<"Skipping co-planar facet: "<<(f+1)<<" --> "<<(nf+1)<<endl;
//#endif
      }
 
      int max_ne = -1;
      if(nfei >= 0)
      {
        max_ne = uE2E[EMAP(e)][nfei];
      }
 
      if(max_ne>=0)
      {
        // face of neighbor
        const int nf = max_ne%m;
#ifdef IGL_OUTER_HULL_DEBUG
        if(!FH[nf])
        {
          // first time seeing face
          cout<<(f+1)<<" --> "<<(nf+1)<<endl;
        }
#endif
        FH[nf] = true;
        //std::cout << "face " << face_count++ << ": " << nf << std::endl;
        //std::cout << "f " << F.row(nf).array()+1 << std::endl;
        FHcount++;
        // corner of neighbor
        const int nc = max_ne/m;
        const int nd = F(nf,(nc+2)%3);
        const bool cons = (flip(f)?fd:fs) == nd;
        flip(nf) = (cons ? flip(f) : !flip(f));
        //cout<<"flip("<<nf<<") = "<<(flip(nf)?"true":"false")<<endl;
        const int ne1 = nf+((nc+1)%3)*m;
        const int ne2 = nf+((nc+2)%3)*m;
        if(!EH[ne1])
        {
          Q.push(ne1);
        }
        if(!EH[ne2])
        {
          Q.push(ne2);
        }
      }
    }
 
    {
      vG[id].resize(FHcount,3);
      vJ[id].resize(FHcount,1);
      //nG += FHcount;
      size_t h = 0;
      assert(counts(id) == IM.rows());
      for(int i = 0;i<counts(id);i++)
      {
        const size_t f = IM(i);
        //if(f_flip)
        //{
        //  flip(f) = !flip(f);
        //}
        if(FH[f])
        {
          vG[id].row(h) = (flip(f)?F.row(f).reverse().eval():F.row(f));
          vJ[id](h,0) = f;
          h++;
        }
      }
      assert((int)h == FHcount);
    }
  }
 
  // Is A inside B? Assuming A and B are consistently oriented but closed and
  // non-intersecting.
  const auto & has_overlapping_bbox = [](
    const Eigen::PlainObjectBase<DerivedV> & V,
    const MatrixXG & A,
    const MatrixXG & B)->bool
  {
    const auto & bounding_box = [](
      const Eigen::PlainObjectBase<DerivedV> & V,
      const MatrixXG & F)->
        DerivedV
    {
      DerivedV BB(2,3);
      BB<<
         1e26,1e26,1e26,
        -1e26,-1e26,-1e26;
      const size_t m = F.rows();
      for(size_t f = 0;f<m;f++)
      {
        for(size_t c = 0;c<3;c++)
        {
          const auto & vfc = V.row(F(f,c)).eval();
          BB(0,0) = std::min(BB(0,0), vfc(0,0));
          BB(0,1) = std::min(BB(0,1), vfc(0,1));
          BB(0,2) = std::min(BB(0,2), vfc(0,2));
          BB(1,0) = std::max(BB(1,0), vfc(0,0));
          BB(1,1) = std::max(BB(1,1), vfc(0,1));
          BB(1,2) = std::max(BB(1,2), vfc(0,2));
        }
      }
      return BB;
    };
    // A lot of the time we're dealing with unrelated, distant components: cull
    // them.
    DerivedV ABB = bounding_box(V,A);
    DerivedV BBB = bounding_box(V,B);
    if( (BBB.row(0)-ABB.row(1)).maxCoeff()>0  ||
        (ABB.row(0)-BBB.row(1)).maxCoeff()>0 )
    {
      // bounding boxes do not overlap
      return false;
    } else {
      return true;
    }
  };
 
  // Reject components which are completely inside other components
  vector<bool> keep(ncc,true);
  size_t nG = 0;
  // This is O( ncc * ncc * m)
  for(size_t id = 0;id<ncc;id++)
  {
    if (!keep[id]) continue;
    std::vector<size_t> unresolved;
    for(size_t oid = 0;oid<ncc;oid++)
    {
      if(id == oid || !keep[oid])
      {
        continue;
      }
      if (has_overlapping_bbox(V, vG[id], vG[oid])) {
          unresolved.push_back(oid);
      }
    }
    const size_t num_unresolved_components = unresolved.size();
    DerivedV query_points(num_unresolved_components, 3);
    for (size_t i=0; i<num_unresolved_components; i++) {
        const size_t oid = unresolved[i];
        DerivedF f = vG[oid].row(0);
        query_points(i,0) = (V(f(0,0), 0) + V(f(0,1), 0) + V(f(0,2), 0))/3.0;
        query_points(i,1) = (V(f(0,0), 1) + V(f(0,1), 1) + V(f(0,2), 1))/3.0;
        query_points(i,2) = (V(f(0,0), 2) + V(f(0,1), 2) + V(f(0,2), 2))/3.0;
    }
    Eigen::VectorXi inside;
    igl::copyleft::cgal::points_inside_component(V, vG[id], query_points, inside);
    assert((size_t)inside.size() == num_unresolved_components);
    for (size_t i=0; i<num_unresolved_components; i++) {
        if (inside(i, 0)) {
            const size_t oid = unresolved[i];
            keep[oid] = false;
        }
    }
  }
  for (size_t id = 0; id<ncc; id++) {
      if (keep[id]) {
          nG += vJ[id].rows();
      }
  }
 
  // collect G and J across components
  G.resize(nG,3);
  J.resize(nG,1);
  {
    size_t off = 0;
    for(Index id = 0;id<(Index)ncc;id++)
    {
      if(keep[id])
      {
        assert(vG[id].rows() == vJ[id].rows());
        G.block(off,0,vG[id].rows(),vG[id].cols()) = vG[id];
        J.block(off,0,vJ[id].rows(),vJ[id].cols()) = vJ[id];
        off += vG[id].rows();
      }
    }
  }
}

References igl::barycenter(), igl::bounding_box(), igl::facet_components(), order_facets_around_edges(), outer_facet(), points_inside_component(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::PlainObjectBase< Derived >::setConstant(), igl::triangle_triangle_adjacency(), and igl::unique_edge_map().

Referenced by peel_outer_hull_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

outer_vertex()

template<typename DerivedV , typename DerivedF , typename DerivedI , typename IndexType , typename DerivedA >

IGL_INLINE void igl::copyleft::cgal::outer_vertex	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		IndexType &	v_index,
		Eigen::PlainObjectBase< DerivedA > &	A
	)

{
    // Algorithm:
    //    Find an outer vertex (i.e. vertex reachable from infinity)
    //    Return the vertex with the largest X value.
    //    If there is a tie, pick the one with largest Y value.
    //    If there is still a tie, pick the one with the largest Z value.
    //    If there is still a tie, then there are duplicated vertices within the
    //    mesh, which violates the precondition.
    typedef typename DerivedF::Scalar Index;
    const Index INVALID = std::numeric_limits<Index>::max();
    const size_t num_selected_faces = I.rows();
    std::vector<size_t> candidate_faces;
    Index outer_vid = INVALID;
    typename DerivedV::Scalar outer_val = 0;
    for (size_t i=0; i<num_selected_faces; i++)
    {
        size_t f = I(i);
        for (size_t j=0; j<3; j++)
        {
            Index v = F(f, j);
            auto vx = V(v, 0);
            if (outer_vid == INVALID || vx > outer_val)
            {
                outer_val = vx;
                outer_vid = v;
                candidate_faces = {f};
            } else if (v == outer_vid)
            {
                candidate_faces.push_back(f);
            } else if (vx == outer_val)
            {
                // Break tie.
                auto vy = V(v,1);
                auto vz = V(v, 2);
                auto outer_y = V(outer_vid, 1);
                auto outer_z = V(outer_vid, 2);
                assert(!(vy == outer_y && vz == outer_z));
                bool replace = (vy > outer_y) ||
                    ((vy == outer_y) && (vz > outer_z));
                if (replace)
                {
                    outer_val = vx;
                    outer_vid = v;
                    candidate_faces = {f};
                }
            }
        }
    }
 
    assert(outer_vid != INVALID);
    assert(candidate_faces.size() > 0);
    v_index = outer_vid;
    A.resize(candidate_faces.size());
    std::copy(candidate_faces.begin(), candidate_faces.end(), A.data());
}

References Eigen::PlainObjectBase< Derived >::data(), Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::rows().

Referenced by outer_edge().

Here is the call graph for this function:

Here is the caller graph for this function:

peel_outer_hull_layers()

template<typename DerivedV , typename DerivedF , typename DerivedI , typename Derivedflip >

IGL_INLINE size_t igl::copyleft::cgal::peel_outer_hull_layers	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedI > &	I,
		Eigen::PlainObjectBase< Derivedflip > &	flip
	)

{
  using namespace Eigen;
  using namespace std;
  typedef typename DerivedF::Index Index;
  typedef Matrix<typename DerivedF::Scalar,Dynamic,DerivedF::ColsAtCompileTime> MatrixXF;
  typedef Matrix<Index,Dynamic,1> MatrixXI;
  typedef Matrix<typename Derivedflip::Scalar,Dynamic,Derivedflip::ColsAtCompileTime> MatrixXflip;
  const Index m = F.rows();
#ifdef IGL_PEEL_OUTER_HULL_LAYERS_DEBUG
  cout<<"peel outer hull layers..."<<endl;
#endif
#ifdef IGL_PEEL_OUTER_HULL_LAYERS_DEBUG
  cout<<"calling outer hull..."<<endl;
  writePLY(STR("peel-outer-hull-input.ply"),V,F);
#endif
 
#ifdef IGL_PEEL_OUTER_HULL_LAYERS_DEBUG
  cout<<"resize output ..."<<endl;
#endif
  // keep track of iteration parity and whether flipped in hull
  MatrixXF Fr = F;
  I.resize(m,1);
  flip.resize(m,1);
  // Keep track of index map
  MatrixXI IM = igl::LinSpaced<MatrixXI >(m,0,m-1);
  // This is O(n * layers)
  MatrixXI P(m,1);
  Index iter = 0;
  while(Fr.size() > 0)
  {
    assert(Fr.rows() == IM.rows());
    // Compute outer hull of current Fr
    MatrixXF Fo;
    MatrixXI Jo;
    MatrixXflip flipr;
#ifdef IGL_PEEL_OUTER_HULL_LAYERS_DEBUG
  {
      cout<<"calling outer hull..." << iter <<endl;
      std::stringstream ss;
      ss << "outer_hull_" << iter << ".ply";
      Eigen::MatrixXd vertices(V.rows(), V.cols());
      std::transform(V.data(), V.data() + V.rows()*V.cols(),
              vertices.data(),
              [](typename DerivedV::Scalar val)
              {return CGAL::to_double(val); });
      writePLY(ss.str(), vertices, Fr);
  }
#endif
    outer_hull_legacy(V,Fr,Fo,Jo,flipr);
#ifdef IGL_PEEL_OUTER_HULL_LAYERS_DEBUG
  writePLY(STR("outer-hull-output-"<<iter<<".ply"),V,Fo);
  cout<<"reindex, flip..."<<endl;
#endif
    assert(Fo.rows() != 0);
    assert(Fo.rows() == Jo.rows());
    // all faces in Fo of Fr
    vector<bool> in_outer(Fr.rows(),false);
    for(Index g = 0;g<Jo.rows();g++)
    {
      I(IM(Jo(g))) = iter;
      P(IM(Jo(g))) = iter;
      in_outer[Jo(g)] = true;
      flip(IM(Jo(g))) = flipr(Jo(g));
    }
    // Fr = Fr - Fo
    // update IM
    MatrixXF prev_Fr = Fr;
    MatrixXI prev_IM = IM;
    Fr.resize(prev_Fr.rows() - Fo.rows(),F.cols());
    IM.resize(Fr.rows());
    {
      Index g = 0;
      for(Index f = 0;f<prev_Fr.rows();f++)
      {
        if(!in_outer[f])
        {
          Fr.row(g) = prev_Fr.row(f);
          IM(g) = prev_IM(f);
          g++;
        }
      }
    }
    iter++;
  }
  return iter;
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), outer_hull_legacy(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), STR, and igl::writePLY().

Here is the call graph for this function:

peel_winding_number_layers()

template<typename DerivedV , typename DerivedF , typename DerivedW >

IGL_INLINE size_t igl::copyleft::cgal::peel_winding_number_layers	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedW > &	W
	)

                                           {
    const size_t num_faces = F.rows();
    Eigen::VectorXi labels(num_faces);
    labels.setZero();
 
    Eigen::MatrixXi winding_numbers;
    igl::copyleft::cgal::propagate_winding_numbers(V, F, labels, winding_numbers);
    assert(winding_numbers.rows() == num_faces);
    assert(winding_numbers.cols() == 2);
 
    int min_w = winding_numbers.minCoeff();
    int max_w = winding_numbers.maxCoeff();
    assert(max_w > min_w);
 
    W.resize(num_faces, 1);
    for (size_t i=0; i<num_faces; i++) {
        W(i, 0) = winding_numbers(i, 1);
    }
    return max_w - min_w;
}

References propagate_winding_numbers(), and Eigen::PlainObjectBase< Derived >::resize().

Here is the call graph for this function:

piecewise_constant_winding_number()

template<typename DerivedV , typename DerivedF >

IGL_INLINE bool igl::copyleft::cgal::piecewise_constant_winding_number	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  Eigen::Matrix<CGAL::Epeck::FT,Eigen::Dynamic,3> VV;
  Eigen::Matrix<typename DerivedF::Scalar,Eigen::Dynamic,3> FF;
  Eigen::Matrix<typename DerivedF::Index,Eigen::Dynamic,2> IF;
  Eigen::Matrix<typename DerivedF::Index,Eigen::Dynamic,1> J;
  Eigen::Matrix<typename DerivedV::Index,Eigen::Dynamic,1> UIM,IM;
  // resolve intersections
  remesh_self_intersections(V,F,{false,false,true},VV,FF,IF,J,IM);
  return igl::piecewise_constant_winding_number(FF);
}

References igl::piecewise_constant_winding_number(), and remesh_self_intersections().

Here is the call graph for this function:

point_areas() [1/2]

template<typename DerivedP , typename DerivedI , typename DerivedN , typename DerivedA >

IGL_INLINE void igl::copyleft::cgal::point_areas	(	const Eigen::MatrixBase< DerivedP > &	P,
		const Eigen::MatrixBase< DerivedI > &	I,
		const Eigen::MatrixBase< DerivedN > &	N,
		Eigen::PlainObjectBase< DerivedA > &	A
	)

      {
        Eigen::MatrixXd T;
        point_areas(P,I,N,A,T);
      }

References point_areas().

Referenced by fast_winding_number(), and point_areas().

Here is the call graph for this function:

Here is the caller graph for this function:

point_areas() [2/2]

template<typename DerivedP , typename DerivedI , typename DerivedN , typename DerivedA , typename DerivedT >

IGL_INLINE void igl::copyleft::cgal::point_areas	(	const Eigen::MatrixBase< DerivedP > &	P,
		const Eigen::MatrixBase< DerivedI > &	I,
		const Eigen::MatrixBase< DerivedN > &	N,
		Eigen::PlainObjectBase< DerivedA > &	A,
		Eigen::PlainObjectBase< DerivedT > &	T
	)

      {
        typedef typename DerivedP::Scalar real;
        typedef typename DerivedN::Scalar scalarN;
        typedef typename DerivedA::Scalar scalarA;
        typedef Eigen::Matrix<real,1,3> RowVec3;
        typedef Eigen::Matrix<real,1,2> RowVec2;
        
        typedef Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic> MatrixP;
        typedef Eigen::Matrix<scalarN, Eigen::Dynamic, Eigen::Dynamic> MatrixN;
        typedef Eigen::Matrix<typename DerivedN::Scalar,
                  Eigen::Dynamic, Eigen::Dynamic> VecotorO;
        typedef Eigen::Matrix<typename DerivedI::Scalar,
                  Eigen::Dynamic, Eigen::Dynamic> MatrixI;
        
        
        
        const int n = P.rows();
        
        assert(P.cols() == 3 && "P must have exactly 3 columns");
        assert(P.rows() == N.rows()
               && "P and N must have the same number of rows");
        assert(P.rows() == I.rows()
               && "P and I must have the same number of rows");
        
        A.setZero(n,1);
        T.setZero(n,3);
        igl::parallel_for(P.rows(),[&](int i)
        {
          MatrixI neighbor_index = I.row(i);
          MatrixP neighbors;
          igl::slice(P,neighbor_index,1,neighbors);
          if(N.rows() && neighbors.rows() > 1){
            MatrixN neighbor_normals;
            igl::slice(N,neighbor_index,1,neighbor_normals);
            Eigen::Matrix<scalarN,1,3> poi_normal = neighbor_normals.row(0);
            Eigen::Matrix<scalarN,Eigen::Dynamic,1> dotprod =
                            poi_normal(0)*neighbor_normals.col(0)
            + poi_normal(1)*neighbor_normals.col(1)
            + poi_normal(2)*neighbor_normals.col(2);
            Eigen::Array<bool,Eigen::Dynamic,1> keep = dotprod.array() > 0;
            igl::slice_mask(Eigen::MatrixXd(neighbors),keep,1,neighbors);
          }
          if(neighbors.rows() <= 2){
            A(i) = 0;
          } else {
            //subtract the mean from neighbors, then take svd,
            //the scores will be U*S. This is our pca plane fitting
            RowVec3 mean = neighbors.colwise().mean();
            MatrixP mean_centered = neighbors.rowwise() - mean;
            Eigen::JacobiSVD<MatrixP> svd(mean_centered,
                                    Eigen::ComputeThinU | Eigen::ComputeThinV);
            MatrixP scores = svd.matrixU() * svd.singularValues().asDiagonal();
            
            T.row(i) = svd.matrixV().col(2).transpose();
            if(T.row(i).dot(N.row(i)) < 0){
              T.row(i) *= -1;
            }
            
            MatrixP plane;
            igl::slice(scores,igl::colon<int>(0,scores.rows()-1),
                     igl::colon<int>(0,1),plane);
            
            std::vector< std::pair<Point,unsigned> > points;
            //This is where we obtain a delaunay triangulation of the points
            for(unsigned iter = 0; iter < plane.rows(); iter++){
              points.push_back( std::make_pair(
                      Point(plane(iter,0),plane(iter,1)), iter ) );
            }
            Delaunay triangulation;
            triangulation.insert(points.begin(),points.end());
            Eigen::MatrixXi F(triangulation.number_of_faces(),3);
            int f_row = 0;
            for(Delaunay::Finite_faces_iterator fit =
                triangulation.finite_faces_begin();
                fit != triangulation.finite_faces_end(); ++fit) {
              Delaunay::Face_handle face = fit;
              F.row(f_row) = Eigen::RowVector3i((int)face->vertex(0)->info(),
                                                (int)face->vertex(1)->info(),
                                                (int)face->vertex(2)->info());
              f_row++;
            }
            
            //Here we calculate the voronoi area of the point
            scalarA area_accumulator = 0;
            for(int f = 0; f < F.rows(); f++){
              int X = -1;
              for(int face_iter = 0; face_iter < 3; face_iter++){
                if(F(f,face_iter) == 0){
                  X = face_iter;
                }
              }
              if(X >= 0){
              //Triangle XYZ with X being the point we want the area of
                int Y = (X+1)%3;
                int Z = (X+2)%3;
                scalarA x = (plane.row(F(f,Y))-plane.row(F(f,Z))).norm();
                scalarA y = (plane.row(F(f,X))-plane.row(F(f,Z))).norm();
                scalarA z = (plane.row(F(f,Y))-plane.row(F(f,X))).norm();
                scalarA cosX = (z*z + y*y - x*x)/(2*y*z);
                scalarA cosY = (z*z + x*x - y*y)/(2*x*z);
                scalarA cosZ = (x*x + y*y - z*z)/(2*y*x);
                Eigen::Matrix<scalarA,1,3> barycentric;
                barycentric << x*cosX, y*cosY, z*cosZ;
                barycentric /= (barycentric(0)+barycentric(1)+barycentric(2));
                
                //TODO: to make numerically stable, reorder so that x≥y≥z:
                scalarA full_area = 0.25*std::sqrt(
                                    (x+(y+z))*(z-(x-y))*(z+(x-y))*(x+(y-z)));
                Eigen::Matrix<scalarA,1,3> partial_area =
                                                    barycentric * full_area;
                if(cosX < 0){
                  area_accumulator += 0.5*full_area;
                } else if (cosY < 0 || cosZ < 0){
                  area_accumulator += 0.25*full_area;
                } else {
                  area_accumulator += (partial_area(1) + partial_area(2))/2;
                }
              }
            }
            
            if(std::isfinite(area_accumulator)){
              A(i) = area_accumulator;
            } else {
              A(i) = 0;
            }
          }
        },1000);
      }

References Eigen::Dynamic, igl::parallel_for(), real(), Eigen::PlainObjectBase< Derived >::setZero(), and igl::slice().

Here is the call graph for this function:

point_mesh_squared_distance() [1/2]

template<typename Kernel , typename DerivedP , typename DerivedsqrD , typename DerivedI , typename DerivedC >

IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance	(	const Eigen::PlainObjectBase< DerivedP > &	P,
		const CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< CGAL::Triangle_3< Kernel > >::iterator > > > &	tree,
		const std::vector< CGAL::Triangle_3< Kernel > > &	T,
		Eigen::PlainObjectBase< DerivedsqrD > &	sqrD,
		Eigen::PlainObjectBase< DerivedI > &	I,
		Eigen::PlainObjectBase< DerivedC > &	C
	)

{
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  typedef typename std::vector<Triangle_3>::iterator Iterator;
  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
  typedef typename Tree::Point_and_primitive_id Point_and_primitive_id;
  typedef CGAL::Point_3<Kernel>    Point_3;
  assert(P.cols() == 3);
  const int n = P.rows();
  sqrD.resize(n,1);
  I.resize(n,1);
  C.resize(n,P.cols());
  for(int p = 0;p < n;p++)
  {
    Point_3 query(P(p,0),P(p,1),P(p,2));
    // Find closest point and primitive id
    Point_and_primitive_id pp = tree.closest_point_and_primitive(query);
    Point_3 closest_point = pp.first;
    assign_scalar(closest_point[0],C(p,0));
    assign_scalar(closest_point[1],C(p,1));
    assign_scalar(closest_point[2],C(p,2));
    assign_scalar((closest_point-query).squared_length(),sqrD(p));
    I(p) = pp.second - T.begin();
  }
}

References assign_scalar(), Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

point_mesh_squared_distance() [2/2]

template<typename Kernel , typename DerivedP , typename DerivedV , typename DerivedF , typename DerivedsqrD , typename DerivedI , typename DerivedC >

IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance	(	const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedsqrD > &	sqrD,
		Eigen::PlainObjectBase< DerivedI > &	I,
		Eigen::PlainObjectBase< DerivedC > &	C
	)

{
  using namespace std;
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  typedef typename std::vector<Triangle_3>::iterator Iterator;
  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
  Tree tree;
  vector<Triangle_3> T;
  point_mesh_squared_distance_precompute(V,F,tree,T);
  return point_mesh_squared_distance(P,tree,T,sqrD,I,C);
}

References point_mesh_squared_distance(), and point_mesh_squared_distance_precompute().

Referenced by point_mesh_squared_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

point_mesh_squared_distance_precompute()

template<typename Kernel , typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cgal::point_mesh_squared_distance_precompute	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< CGAL::Triangle_3< Kernel > >::iterator > > > &	tree,
		std::vector< CGAL::Triangle_3< Kernel > > &	T
	)

{
  using namespace std;
 
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  typedef CGAL::Point_3<Kernel> Point_3; 
  typedef typename std::vector<Triangle_3>::iterator Iterator;
  typedef CGAL::AABB_triangle_primitive<Kernel, Iterator> Primitive;
  typedef CGAL::AABB_traits<Kernel, Primitive> AABB_triangle_traits;
  typedef CGAL::AABB_tree<AABB_triangle_traits> Tree;
 
  // Must be 3D
  assert(V.cols() == 3);
  // Must be triangles
  assert(F.cols() == 3);
 
  // WTF ALERT!!!! 
  //
  // There's a bug in clang probably or at least in cgal. Without calling this
  // line (I guess invoking some compilation from <vector>), clang will vomit
  // errors inside CGAL.
  //
  // http://stackoverflow.com/questions/27748442/is-clangs-c11-support-reliable
  T.reserve(0);
 
  // Make list of cgal triangles
  mesh_to_cgal_triangle_list(V,F,T);
  tree.clear();
  tree.insert(T.begin(),T.end());
  tree.accelerate_distance_queries();
  // accelerate_distance_queries doesn't seem actually to do _all_ of the
  // precomputation. the tree (despite being const) will still do more
  // precomputation and reorganizing on the first call of `closest_point` or
  // `closest_point_and_primitive`. Therefore, call it once here.
  tree.closest_point_and_primitive(Point_3(0,0,0));
}

References Eigen::PlainObjectBase< Derived >::cols(), and mesh_to_cgal_triangle_list().

Referenced by point_mesh_squared_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

point_segment_squared_distance()

template<typename Kernel >

IGL_INLINE void igl::copyleft::cgal::point_segment_squared_distance	(	const CGAL::Point_3< Kernel > &	P1,
		const CGAL::Segment_3< Kernel > &	S2,
		CGAL::Point_3< Kernel > &	P2,
		typename Kernel::FT &	d
	)

{
  if(S2.is_degenerate())
  {
    P2 = S2.source();
    d = (P1-P2).squared_length();
    return;
  }
  // http://stackoverflow.com/a/1501725/148668
  const auto sqr_len = S2.squared_length();
  assert(sqr_len != 0);
  const auto & V = S2.source();
  const auto & W = S2.target();
  const auto t = (P1-V).dot(W-V)/sqr_len;
  if(t<0)
  {
    P2 = V;
  }else if(t>1)
  {
    P2 = W;
  }else
  {
    P2 = V  + t*(W-V);
  }
  d = (P1-P2).squared_length();
}

References igl::dot().

Referenced by segment_segment_squared_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

point_solid_signed_squared_distance()

template<typename DerivedQ , typename DerivedVB , typename DerivedFB , typename DerivedD >

IGL_INLINE void igl::copyleft::cgal::point_solid_signed_squared_distance	(	const Eigen::PlainObjectBase< DerivedQ > &	Q,
		const Eigen::PlainObjectBase< DerivedVB > &	VB,
		const Eigen::PlainObjectBase< DerivedFB > &	FB,
		Eigen::PlainObjectBase< DerivedD > &	D
	)

{
  // compute unsigned distances
  Eigen::VectorXi I;
  DerivedVB C;
  point_mesh_squared_distance<CGAL::Epeck>(Q,VB,FB,D,I,C);
  // Collect queries that have non-zero distance
  Eigen::Array<bool,Eigen::Dynamic,1> NZ = D.array()!=0;
  // Compute sign for non-zero distance queries
  DerivedQ QNZ;
  slice_mask(Q,NZ,1,QNZ);
  Eigen::Array<bool,Eigen::Dynamic,1> DNZ;
  igl::copyleft::cgal::points_inside_component(VB,FB,QNZ,DNZ);
  // Apply sign to distances
  DerivedD S = DerivedD::Zero(Q.rows(),1);
  {
    int k = 0;
    for(int q = 0;q<Q.rows();q++)
    {
      if(NZ(q))
      {
        D(q) *= DNZ(k++) ? -1. : 1.;
      }
    }
  }
}

References points_inside_component(), Eigen::PlainObjectBase< Derived >::rows(), and igl::slice_mask().

Referenced by trim_with_solid().

Here is the call graph for this function:

Here is the caller graph for this function:

point_triangle_squared_distance()

template<typename Kernel >

IGL_INLINE void igl::copyleft::cgal::point_triangle_squared_distance	(	const CGAL::Point_3< Kernel > &	P1,
		const CGAL::Triangle_3< Kernel > &	T2,
		CGAL::Point_3< Kernel > &	P2,
		typename Kernel::FT &	d
	)

points_inside_component() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedP , typename DerivedB >

IGL_INLINE void igl::copyleft::cgal::points_inside_component	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		Eigen::PlainObjectBase< DerivedB > &	inside
	)

                                                {
    using namespace igl::copyleft::cgal::points_inside_component_helper;
    if (F.rows() <= 0 || I.rows() <= 0) {
        throw "Inside check cannot be done on empty facet component.";
    }
 
    const size_t num_faces = I.rows();
    std::vector<Triangle> triangles;
    for (size_t i=0; i<num_faces; i++) {
        const Eigen::Vector3i f = F.row(I(i, 0));
        triangles.emplace_back(
                Point_3(V(f[0], 0), V(f[0], 1), V(f[0], 2)),
                Point_3(V(f[1], 0), V(f[1], 1), V(f[1], 2)),
                Point_3(V(f[2], 0), V(f[2], 1), V(f[2], 2)));
        if (triangles.back().is_degenerate()) {
            throw "Input facet components contains degenerated triangles";
        }
    }
    Tree tree(triangles.begin(), triangles.end());
    tree.accelerate_distance_queries();
 
    enum ElementType { VERTEX, EDGE, FACE };
    auto determine_element_type = [&](
            size_t fid, const Point_3& p, size_t& element_index) -> ElementType{
        const Eigen::Vector3i f = F.row(I(fid, 0));
        const Point_3 p0(V(f[0], 0), V(f[0], 1), V(f[0], 2));
        const Point_3 p1(V(f[1], 0), V(f[1], 1), V(f[1], 2));
        const Point_3 p2(V(f[2], 0), V(f[2], 1), V(f[2], 2));
 
        if (p == p0) { element_index = 0; return VERTEX; }
        if (p == p1) { element_index = 1; return VERTEX; }
        if (p == p2) { element_index = 2; return VERTEX; }
        if (CGAL::collinear(p0, p1, p)) { element_index = 2; return EDGE; }
        if (CGAL::collinear(p1, p2, p)) { element_index = 0; return EDGE; }
        if (CGAL::collinear(p2, p0, p)) { element_index = 1; return EDGE; }
 
        element_index = 0;
        return FACE;
    };
 
    const size_t num_queries = P.rows();
    inside.resize(num_queries, 1);
    for (size_t i=0; i<num_queries; i++) {
        const Point_3 query(P(i,0), P(i,1), P(i,2));
        auto projection = tree.closest_point_and_primitive(query);
        auto closest_point = projection.first;
        size_t fid = projection.second - triangles.begin();
 
        size_t element_index;
        switch (determine_element_type(fid, closest_point, element_index)) {
            case VERTEX:
                {
                    const size_t s = F(I(fid, 0), element_index);
                    inside(i,0) = determine_point_vertex_orientation(
                            V, F, I, query, s);
                }
                break;
            case EDGE:
                {
                    const size_t s = F(I(fid, 0), (element_index+1)%3);
                    const size_t d = F(I(fid, 0), (element_index+2)%3);
                    inside(i,0) = determine_point_edge_orientation(
                            V, F, I, query, s, d);
                }
                break;
            case FACE:
                inside(i,0) = determine_point_face_orientation(V, F, I, query, fid);
                break;
            default:
                throw "Unknown closest element type!";
        }
    }
}

References Eigen::PlainObjectBase< Derived >::rows().

Referenced by component_inside_component(), outer_hull_legacy(), point_solid_signed_squared_distance(), and points_inside_component().

Here is the call graph for this function:

Here is the caller graph for this function:

points_inside_component() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedB >

IGL_INLINE void igl::copyleft::cgal::points_inside_component	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		Eigen::PlainObjectBase< DerivedB > &	inside
	)

                                                {
    Eigen::VectorXi I = igl::LinSpaced<Eigen::VectorXi>(F.rows(), 0, F.rows()-1);
    igl::copyleft::cgal::points_inside_component(V, F, I, P, inside);
}

References points_inside_component().

Here is the call graph for this function:

polyhedron_to_mesh()

template<typename Polyhedron , typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cgal::polyhedron_to_mesh	(	const Polyhedron &	poly,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  using namespace std;
  V.resize(poly.size_of_vertices(),3);
  F.resize(poly.size_of_facets(),3);
  typedef typename Polyhedron::Vertex_const_iterator Vertex_iterator;
  std::map<Vertex_iterator,size_t> vertex_to_index;
  {
    size_t v = 0;
    for(
      typename Polyhedron::Vertex_const_iterator p = poly.vertices_begin();
      p != poly.vertices_end();
      p++)
    {
      V(v,0) = p->point().x();
      V(v,1) = p->point().y();
      V(v,2) = p->point().z();
      vertex_to_index[p] = v;
      v++;
    }
  }
  {
    size_t f = 0;
    for(
      typename Polyhedron::Facet_const_iterator facet = poly.facets_begin();
      facet != poly.facets_end();
      ++facet)
    {
      typename Polyhedron::Halfedge_around_facet_const_circulator he = 
        facet->facet_begin();
      // Facets in polyhedral surfaces are at least triangles.
      assert(CGAL::circulator_size(he) == 3 && "Facets should be triangles");
      size_t c = 0;
      do {
        // F(f,c) = std::distance(poly.vertices_begin(), he->vertex());
        F(f,c) = vertex_to_index[he->vertex()];
        c++;
      } while ( ++he != facet->facet_begin());
      f++;
    }
  }
}

References Eigen::PlainObjectBase< Derived >::resize().

Referenced by convex_hull().

Here is the call graph for this function:

Here is the caller graph for this function:

projected_cdt() [1/2]

template<typename Kernel , typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cgal::projected_cdt	(	const std::vector< CGAL::Object > &	objects,
		const CGAL::Plane_3< Kernel > &	P,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  std::vector<CGAL::Point_3<Kernel> > vertices;
  std::vector<std::vector<typename DerivedF::Scalar> > faces;
  projected_cdt(objects,P,vertices,faces);
  V.resize(vertices.size(),3);
  for(int v = 0;v<vertices.size();v++)
  {
    for(int d = 0;d<3;d++)
    {
      assign_scalar(vertices[v][d], V(v,d));
    }
  }
  list_to_matrix(faces,F);
}

References assign_scalar(), igl::list_to_matrix(), projected_cdt(), and Eigen::PlainObjectBase< Derived >::resize().

Here is the call graph for this function:

projected_cdt() [2/2]

template<typename Kernel , typename Index >

IGL_INLINE void igl::copyleft::cgal::projected_cdt	(	const std::vector< CGAL::Object > &	objects,
		const CGAL::Plane_3< Kernel > &	P,
		std::vector< CGAL::Point_3< Kernel > > &	vertices,
		std::vector< std::vector< Index > > &	faces
	)

{
  typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
  typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTFB_2;
  typedef CGAL::Triangulation_data_structure_2<TVB_2,CTFB_2> TDS_2;
  typedef CGAL::Exact_intersections_tag Itag;
  typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel,TDS_2,Itag> CDT_2;
  typedef CGAL::Constrained_triangulation_plus_2<CDT_2> CDT_plus_2;
  CDT_plus_2 cdt;
  for(const auto & obj : objects) insert_into_cdt(obj,P,cdt);
  // Read off vertices of the cdt, remembering index
  std::map<typename CDT_plus_2::Vertex_handle,Index> v2i;
  size_t count=0;
  for (
    auto itr = cdt.finite_vertices_begin();
    itr != cdt.finite_vertices_end();
    itr++)
  {
    vertices.push_back(P.to_3d(itr->point()));
    v2i[itr] = count;
    count++;
  }
  // Read off faces and store index triples
  for (
    auto itr = cdt.finite_faces_begin();
    itr != cdt.finite_faces_end();
    itr++)
  {
    faces.push_back(
      { v2i[itr->vertex(0)], v2i[itr->vertex(1)], v2i[itr->vertex(2)] });
  }
}

References igl::count(), and insert_into_cdt().

Referenced by projected_cdt(), and remesh_intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

projected_delaunay()

template<typename Kernel >

IGL_INLINE void igl::copyleft::cgal::projected_delaunay	(	const CGAL::Triangle_3< Kernel > &	A,
		const std::vector< CGAL::Object > &	A_objects_3,
		CGAL::Constrained_triangulation_plus_2< CGAL::Constrained_Delaunay_triangulation_2< Kernel, CGAL::Triangulation_data_structure_2< CGAL::Triangulation_vertex_base_2< Kernel >, CGAL::Constrained_triangulation_face_base_2< Kernel > >, CGAL::Exact_intersections_tag > > &	cdt
	)

{
  using namespace std;
  // 3D Primitives
  typedef CGAL::Point_3<Kernel>    Point_3;
  typedef CGAL::Segment_3<Kernel>  Segment_3; 
  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
  typedef CGAL::Plane_3<Kernel>    Plane_3;
  //typedef CGAL::Tetrahedron_3<Kernel> Tetrahedron_3; 
  typedef CGAL::Point_2<Kernel>    Point_2;
  //typedef CGAL::Segment_2<Kernel>  Segment_2; 
  //typedef CGAL::Triangle_2<Kernel> Triangle_2; 
  typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
  typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTFB_2;
  typedef CGAL::Triangulation_data_structure_2<TVB_2,CTFB_2> TDS_2;
  typedef CGAL::Exact_intersections_tag Itag;
  typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel,TDS_2,Itag> 
    CDT_2;
  typedef CGAL::Constrained_triangulation_plus_2<CDT_2> CDT_plus_2;
 
  // http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Triangulation_2/Chapter_main.html#Section_2D_Triangulations_Constrained_Plus
  // Plane of triangle A
  Plane_3 P(A.vertex(0),A.vertex(1),A.vertex(2));
  // Insert triangle into vertices
  typename CDT_plus_2::Vertex_handle corners[3];
  typedef size_t Index;
  for(Index i = 0;i<3;i++)
  {
    const Point_3 & p3 = A.vertex(i);
    const Point_2 & p2 = P.to_2d(p3);
    typename CDT_plus_2::Vertex_handle corner = cdt.insert(p2);
    corners[i] = corner;
  }
  // Insert triangle edges as constraints
  for(Index i = 0;i<3;i++)
  {
    cdt.insert_constraint( corners[(i+1)%3], corners[(i+2)%3]);
  }
  // Insert constraints for intersection objects
  for( const auto & obj : A_objects_3)
  {
    if(const Segment_3 *iseg = CGAL::object_cast<Segment_3 >(&obj))
    {
      // Add segment constraint
      cdt.insert_constraint(P.to_2d(iseg->vertex(0)),P.to_2d(iseg->vertex(1)));
    }else if(const Point_3 *ipoint = CGAL::object_cast<Point_3 >(&obj))
    {
      // Add point
      cdt.insert(P.to_2d(*ipoint));
    } else if(const Triangle_3 *itri = CGAL::object_cast<Triangle_3 >(&obj))
    {
      // Add 3 segment constraints
      cdt.insert_constraint(P.to_2d(itri->vertex(0)),P.to_2d(itri->vertex(1)));
      cdt.insert_constraint(P.to_2d(itri->vertex(1)),P.to_2d(itri->vertex(2)));
      cdt.insert_constraint(P.to_2d(itri->vertex(2)),P.to_2d(itri->vertex(0)));
    } else if(const std::vector<Point_3 > *polyp = 
        CGAL::object_cast< std::vector<Point_3 > >(&obj))
    {
      //cerr<<REDRUM("Poly...")<<endl;
      const std::vector<Point_3 > & poly = *polyp;
      const Index m = poly.size();
      assert(m>=2);
      for(Index p = 0;p<m;p++)
      {
        const Index np = (p+1)%m;
        cdt.insert_constraint(P.to_2d(poly[p]),P.to_2d(poly[np]));
      }
    }else
    {
      cerr<<REDRUM("What is this object?!")<<endl;
      assert(false);
    }
  }
}

References REDRUM.

propagate_winding_numbers() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedL , typename DerivedW >

IGL_INLINE bool igl::copyleft::cgal::propagate_winding_numbers	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedL > &	labels,
		Eigen::PlainObjectBase< DerivedW > &	W
	)

{
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  const auto & tictoc = []() -> double
  {
    static double t_start = igl::get_seconds();
    double diff = igl::get_seconds()-t_start;
    t_start += diff;
    return diff;
  };
  const auto log_time = [&](const std::string& label) -> void {
    std::cout << "propagate_winding_num." << label << ": "
      << tictoc() << std::endl;
  };
  tictoc();
#endif
 
  Eigen::MatrixXi E, uE;
  Eigen::VectorXi EMAP;
  std::vector<std::vector<size_t> > uE2E;
  igl::unique_edge_map(F, E, uE, EMAP, uE2E);
 
  Eigen::VectorXi P;
  const size_t num_patches = igl::extract_manifold_patches(F, EMAP, uE2E, P);
 
  DerivedW per_patch_cells;
  const size_t num_cells =
    igl::copyleft::cgal::extract_cells(
        V, F, P, E, uE, uE2E, EMAP, per_patch_cells);
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  log_time("cell_extraction");
#endif
 
  return propagate_winding_numbers(V, F,
          uE, uE2E,
          num_patches, P,
          num_cells, per_patch_cells,
          labels, W);
}

References extract_cells(), igl::extract_manifold_patches(), igl::get_seconds(), propagate_winding_numbers(), and igl::unique_edge_map().

Referenced by peel_winding_number_layers(), and propagate_winding_numbers().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_winding_numbers() [2/2]

template<typename DerivedV , typename DerivedF , typename DeriveduE , typename uE2EType , typename DerivedP , typename DerivedC , typename DerivedL , typename DerivedW >

IGL_INLINE bool igl::copyleft::cgal::propagate_winding_numbers	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DeriveduE > &	uE,
		const std::vector< std::vector< uE2EType > > &	uE2E,
		const size_t	num_patches,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const size_t	num_cells,
		const Eigen::PlainObjectBase< DerivedC > &	C,
		const Eigen::PlainObjectBase< DerivedL > &	labels,
		Eigen::PlainObjectBase< DerivedW > &	W
	)

{
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  const auto & tictoc = []() -> double
  {
    static double t_start = igl::get_seconds();
    double diff = igl::get_seconds()-t_start;
    t_start += diff;
    return diff;
  };
  const auto log_time = [&](const std::string& label) -> void {
    std::cout << "propagate_winding_num." << label << ": "
      << tictoc() << std::endl;
  };
  tictoc();
#endif
 
  bool valid = true;
  // https://github.com/libigl/libigl/issues/674
  if (!igl::piecewise_constant_winding_number(F, uE, uE2E)) 
  {
    assert(false && "Input mesh is not PWN");
    std::cerr << "Input mesh is not PWN!" << std::endl;
    valid = false;
  }
 
  const size_t num_faces = F.rows();
  typedef std::tuple<typename DerivedC::Scalar, bool, size_t> CellConnection;
  std::vector<std::set<CellConnection> > cell_adj;
  igl::copyleft::cgal::cell_adjacency(C, num_cells, cell_adj);
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  log_time("cell_connectivity");
#endif
 
  auto save_cell = [&](const std::string& filename, size_t cell_id) -> void{
    std::vector<size_t> faces;
    for (size_t i=0; i<num_patches; i++) {
      if ((C.row(i).array() == cell_id).any()) {
        for (size_t j=0; j<num_faces; j++) {
          if ((size_t)P[j] == i) {
            faces.push_back(j);
          }
        }
      }
    }
    Eigen::MatrixXi cell_faces(faces.size(), 3);
    for (size_t i=0; i<faces.size(); i++) {
      cell_faces.row(i) = F.row(faces[i]);
    }
    Eigen::MatrixXd vertices;
    assign(V,vertices);
    writePLY(filename, vertices, cell_faces);
  };
 
#ifndef NDEBUG
  {
    // Check for odd cycle.
    Eigen::VectorXi cell_labels(num_cells);
    cell_labels.setZero();
    Eigen::VectorXi parents(num_cells);
    parents.setConstant(-1);
    auto trace_parents = [&](size_t idx) -> std::list<size_t> {
      std::list<size_t> path;
      path.push_back(idx);
      while ((size_t)parents[path.back()] != path.back()) {
        path.push_back(parents[path.back()]);
      }
      return path;
    };
    for (size_t i=0; i<num_cells; i++) {
      if (cell_labels[i] == 0) {
        cell_labels[i] = 1;
        std::queue<size_t> Q;
        Q.push(i);
        parents[i] = i;
        while (!Q.empty()) {
          size_t curr_idx = Q.front();
          Q.pop();
          int curr_label = cell_labels[curr_idx];
          for (const auto& neighbor : cell_adj[curr_idx]) {
            if (cell_labels[std::get<0>(neighbor)] == 0) 
            {
              cell_labels[std::get<0>(neighbor)] = curr_label * -1;
              Q.push(std::get<0>(neighbor));
              parents[std::get<0>(neighbor)] = curr_idx;
            } else 
            {
              if (cell_labels[std::get<0>(neighbor)] != curr_label * -1) 
              {
                std::cerr << "Odd cell cycle detected!" << std::endl;
                auto path = trace_parents(curr_idx);
                path.reverse();
                auto path2 = trace_parents(std::get<0>(neighbor));
                path.insert(path.end(), path2.begin(), path2.end());
                for (auto cell_id : path) 
                {
                  std::cout << cell_id << " ";
                  std::stringstream filename;
                  filename << "cell_" << cell_id << ".ply";
                  save_cell(filename.str(), cell_id);
                }
                std::cout << std::endl;
                valid = false;
              }
              // Do not fail when odd cycle is detected because the resulting
              // integer winding number field, although inconsistent, may still
              // be used if the problem region is local and embedded within a
              // valid volume.
              //assert(cell_labels[std::get<0>(neighbor)] == curr_label * -1);
            }
          }
        }
      }
    }
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
    log_time("odd_cycle_check");
#endif
  }
#endif
 
  size_t outer_facet;
  bool flipped;
  Eigen::VectorXi I = igl::LinSpaced<Eigen::VectorXi>(num_faces, 0, num_faces-1);
  igl::copyleft::cgal::outer_facet(V, F, I, outer_facet, flipped);
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  log_time("outer_facet");
#endif
 
  const size_t outer_patch = P[outer_facet];
  const size_t infinity_cell = C(outer_patch, flipped?1:0);
 
  Eigen::VectorXi patch_labels(num_patches);
  const int INVALID = std::numeric_limits<int>::max();
  patch_labels.setConstant(INVALID);
  for (size_t i=0; i<num_faces; i++) {
    if (patch_labels[P[i]] == INVALID) {
      patch_labels[P[i]] = labels[i];
    } else {
      assert(patch_labels[P[i]] == labels[i]);
    }
  }
  assert((patch_labels.array() != INVALID).all());
  const size_t num_labels = patch_labels.maxCoeff()+1;
 
  Eigen::MatrixXi per_cell_W(num_cells, num_labels);
  per_cell_W.setConstant(INVALID);
  per_cell_W.row(infinity_cell).setZero();
  std::queue<size_t> Q;
  Q.push(infinity_cell);
  while (!Q.empty()) {
    size_t curr_cell = Q.front();
    Q.pop();
    for (const auto& neighbor : cell_adj[curr_cell]) {
      size_t neighbor_cell, patch_idx;
      bool direction;
      std::tie(neighbor_cell, direction, patch_idx) = neighbor;
      if ((per_cell_W.row(neighbor_cell).array() == INVALID).any()) {
        per_cell_W.row(neighbor_cell) = per_cell_W.row(curr_cell);
        for (size_t i=0; i<num_labels; i++) {
          int inc = (patch_labels[patch_idx] == (int)i) ?
            (direction ? -1:1) :0;
          per_cell_W(neighbor_cell, i) =
            per_cell_W(curr_cell, i) + inc;
        }
        Q.push(neighbor_cell);
      } else {
#ifndef NDEBUG
        // Checking for winding number consistency.
        // This check would inevitably fail for meshes that contain open
        // boundary or non-orientable.  However, the inconsistent winding number
        // field would still be useful in some cases such as when problem region
        // is local and embedded within the volume.  This, unfortunately, is the
        // best we can do because the problem of computing integer winding
        // number is ill-defined for open and non-orientable surfaces.
        for (size_t i=0; i<num_labels; i++) {
          if ((int)i == patch_labels[patch_idx]) {
            int inc = direction ? -1:1;
            //assert(per_cell_W(neighbor_cell, i) ==
            //    per_cell_W(curr_cell, i) + inc);
          } else {
            //assert(per_cell_W(neighbor_cell, i) ==
            //    per_cell_W(curr_cell, i));
          }
        }
#endif
      }
    }
  }
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  log_time("propagate_winding_number");
#endif
 
  W.resize(num_faces, num_labels*2);
  for (size_t i=0; i<num_faces; i++) 
  {
    const size_t patch = P[i];
    const size_t positive_cell = C(patch, 0);
    const size_t negative_cell = C(patch, 1);
    for (size_t j=0; j<num_labels; j++) {
      W(i,j*2  ) = per_cell_W(positive_cell, j);
      W(i,j*2+1) = per_cell_W(negative_cell, j);
    }
  }
#ifdef PROPAGATE_WINDING_NUMBER_TIMING
  log_time("store_result");
#endif
  return valid;
}

References assign(), cell_adjacency(), igl::get_seconds(), outer_facet(), igl::piecewise_constant_winding_number(), Eigen::PlainObjectBase< Derived >::resize(), and igl::writePLY().

Here is the call graph for this function:

push_result()

template<typename DerivedF >

static IGL_INLINE void igl::copyleft::cgal::push_result ( const Eigen::PlainObjectBase< DerivedF > &  F, const int  f, const int  f_other, const CGAL::Object &  result, std::map< typename DerivedF::Index, std::vector< std::pair< typename DerivedF::Index, CGAL::Object > > > &  offending  )

static

      {
        typedef typename DerivedF::Index Index;
        typedef std::pair<Index,Index> EMK;
        if(offending.count(f) == 0)
        {
          // first time marking, initialize with new id and empty list
          offending[f] = {};
          for(Index e = 0; e<3;e++)
          {
            // append face to edge's list
            Index i = F(f,(e+1)%3) < F(f,(e+2)%3) ? F(f,(e+1)%3) : F(f,(e+2)%3);
            Index j = F(f,(e+1)%3) < F(f,(e+2)%3) ? F(f,(e+2)%3) : F(f,(e+1)%3);
            //edge2faces[EMK(i,j)].push_back(f);
          }
        }
        offending[f].push_back({f_other,result});
      }

Referenced by intersect_other_helper().

Here is the caller graph for this function:

read_triangle_mesh()

template<typename DerivedV , typename DerivedF >

IGL_INLINE bool igl::copyleft::cgal::read_triangle_mesh	(	const std::string	str,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  Eigen::MatrixXd Vd;
  bool ret = igl::read_triangle_mesh(str,Vd,F);
  if(ret)
  {
    assign(Vd,V);
  }
  return ret;
}

References assign(), and igl::read_triangle_mesh().

Here is the call graph for this function:

relabel_small_immersed_cells()

template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedC , typename FT , typename DerivedW >

IGL_INLINE void igl::copyleft::cgal::relabel_small_immersed_cells	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const size_t	num_patches,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const size_t	num_cells,
		const Eigen::PlainObjectBase< DerivedC > &	C,
		const FT	vol_threashold,
		Eigen::PlainObjectBase< DerivedW > &	W
	)

{
  const size_t num_vertices = V.rows();
  const size_t num_faces = F.rows();
  typedef std::tuple<typename DerivedC::Scalar, bool, size_t> CellConnection;
  std::vector<std::set<CellConnection> > cell_adj;
  igl::copyleft::cgal::cell_adjacency(C, num_cells, cell_adj);
 
  Eigen::MatrixXd VV;
  assign(V,VV);
 
  auto compute_cell_volume = [&](size_t cell_id) {
    std::vector<short> is_involved(num_patches, 0);
    for (size_t i=0; i<num_patches; i++) {
      if (C(i,0) == cell_id) {
        // cell is on positive side of patch i.
        is_involved[i] = 1;
      }
      if (C(i,1) == cell_id) {
        // cell is on negative side of patch i.
        is_involved[i] = -1;
      }
    }
 
    std::vector<size_t> involved_positive_faces;
    std::vector<size_t> involved_negative_faces;
    for (size_t i=0; i<num_faces; i++) {
      switch (is_involved[P[i]]) {
        case 1:
          involved_negative_faces.push_back(i);
          break;
        case -1:
          involved_positive_faces.push_back(i);
          break;
      }
    }
 
    const size_t num_positive_faces = involved_positive_faces.size();
    const size_t num_negative_faces = involved_negative_faces.size();
    DerivedF selected_faces(num_positive_faces + num_negative_faces, 3);
    for (size_t i=0; i<num_positive_faces; i++) {
      selected_faces.row(i) = F.row(involved_positive_faces[i]);
    }
    for (size_t i=0; i<num_negative_faces; i++) {
      selected_faces.row(num_positive_faces+i) =
        F.row(involved_negative_faces[i]).reverse();
    }
 
    Eigen::VectorXd c(3);
    double vol;
    igl::centroid(VV, selected_faces, c, vol);
    return vol;
  };
 
  std::vector<typename DerivedV::Scalar> cell_volumes(num_cells);
  for (size_t i=0; i<num_cells; i++) {
    cell_volumes[i] = compute_cell_volume(i);
  }
 
  std::vector<typename DerivedW::Scalar> cell_values(num_cells);
  for (size_t i=0; i<num_faces; i++) {
    cell_values[C(P[i], 0)] = W(i, 0);
    cell_values[C(P[i], 1)] = W(i, 1);
  }
 
  for (size_t i=1; i<num_cells; i++) {
    std::cout << cell_volumes[i] << std::endl;
    if (cell_volumes[i] >= vol_threashold) continue;
    std::set<typename DerivedW::Scalar> neighbor_values;
    const auto neighbors = cell_adj[i];
    for (const auto& entry : neighbors) {
      const auto& j = std::get<0>(entry);
      neighbor_values.insert(cell_values[j]);
    }
    // If cell i is immersed, assign its value to be the immersed value.
    if (neighbor_values.size() == 1) {
      cell_values[i] = *neighbor_values.begin();
    }
  }
 
  for (size_t i=0; i<num_faces; i++) {
    W(i,0) = cell_values[C(P[i], 0)];
    W(i,1) = cell_values[C(P[i], 1)];
  }
}

References assign(), cell_adjacency(), igl::centroid(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

remesh_intersections() [1/2]

template<typename DerivedV , typename DerivedF , typename Kernel , typename DerivedVV , typename DerivedFF , typename DerivedJ , typename DerivedIM >

IGL_INLINE void igl::copyleft::cgal::remesh_intersections	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		const std::vector< CGAL::Triangle_3< Kernel > > &	T,
		const std::map< typename DerivedF::Index, std::vector< std::pair< typename DerivedF::Index, CGAL::Object > > > &	offending,
		bool	stitch_all,
		Eigen::PlainObjectBase< DerivedVV > &	VV,
		Eigen::PlainObjectBase< DerivedFF > &	FF,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< DerivedIM > &	IM
	)

{
 
#ifdef REMESH_INTERSECTIONS_TIMING
    const auto & tictoc = []() -> double
    {
      static double t_start = igl::get_seconds();
      double diff = igl::get_seconds()-t_start;
      t_start += diff;
      return diff;
    };
    const auto log_time = [&](const std::string& label) -> void {
      std::cout << "remesh_intersections." << label << ": "
          << tictoc() << std::endl;
    };
    tictoc();
#endif
 
    typedef CGAL::Point_3<Kernel>    Point_3;
    typedef CGAL::Segment_3<Kernel>  Segment_3; 
    typedef CGAL::Plane_3<Kernel>    Plane_3;
    typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
    typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTFB_2;
    typedef CGAL::Triangulation_data_structure_2<TVB_2,CTFB_2> TDS_2;
    typedef CGAL::Exact_intersections_tag Itag;
    typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel,TDS_2,Itag> 
        CDT_2;
    typedef CGAL::Constrained_triangulation_plus_2<CDT_2> CDT_plus_2;
 
    typedef typename DerivedF::Index Index;
    typedef std::pair<Index, Index> Edge;
    struct EdgeHash {
        size_t operator()(const Edge& e) const {
            return (e.first * 805306457) ^ (e.second * 201326611);
        }
    };
    typedef std::unordered_map<Edge, std::vector<Index>, EdgeHash > EdgeMap;
 
    const size_t num_faces = F.rows();
    const size_t num_base_vertices = V.rows();
    assert(num_faces == T.size());
 
    std::vector<bool> is_offending(num_faces, false);
    for (const auto itr : offending)
    {
      const auto& fid = itr.first;
      is_offending[fid] = true;
    }
 
    // Cluster overlaps so that co-planar clusters are resolved only once
    std::unordered_map<Index, std::vector<Index> > intersecting_and_coplanar;
    for (const auto itr : offending)
    {
      const auto& fi = itr.first;
      const auto P = T[fi].supporting_plane();
      assert(!P.is_degenerate());
      for (const auto jtr : itr.second) 
      {
        const auto& fj = jtr.first;
        const auto& tj = T[fj];
        if (P.has_on(tj[0]) && P.has_on(tj[1]) && P.has_on(tj[2]))
        {
          auto loc = intersecting_and_coplanar.find(fi);
          if (loc == intersecting_and_coplanar.end())
          {
            intersecting_and_coplanar[fi] = {fj};
          } else
          {
            loc->second.push_back(fj);
          }
        }
      }
    }
#ifdef REMESH_INTERSECTIONS_TIMING
    log_time("overlap_analysis");
#endif
 
    std::vector<std::vector<Index> > resolved_faces;
    std::vector<Index> source_faces;
    std::vector<Point_3> new_vertices;
    EdgeMap edge_vertices;
    // face_vertices: Given a face Index, find vertices inside the face
    std::unordered_map<Index, std::vector<Index>> face_vertices;
 
    // Run constraint Delaunay triangulation on the plane.
    // 
    // Inputs:
    //   P  plane to triangulate upone
    //   involved_faces  #F list of indices into triangle of involved faces
    // Outputs:
    //   vertices  #V list of vertex positions of output triangulation
    //   faces   #F list of face indices into vertices of output triangulation
    //
    auto delaunay_triangulation = [&offending, &T](
      const Plane_3& P,
      const std::vector<Index>& involved_faces,
      std::vector<Point_3>& vertices,
      std::vector<std::vector<Index> >& faces) -> void 
    {
      std::vector<CGAL::Object> objects;
 
      CDT_plus_2 cdt;
      // insert each face into a common cdt
      for (const auto& fid : involved_faces)
      {
        const auto itr = offending.find(fid);
        const auto& triangle = T[fid];
        objects.push_back(CGAL::make_object(triangle));
        if (itr == offending.end())
        {
          continue;
        }
        for (const auto& index_obj : itr->second) 
        {
          //const auto& ofid = index_obj.first;
          const auto& obj = index_obj.second;
          objects.push_back(obj);
        }
      }
      projected_cdt(objects,P,vertices,faces);
    };
 
    // Given p on triangle indexed by ori_f, add point to list of vertices return index of p.
    //
    // Input:
    //   p  point to search for
    //   ori_f  index of triangle p is corner of
    // Returns global index of vertex (dependent on whether stitch_all flag is
    // set)
    //
    auto find_or_append_point = [&](
      const Point_3& p, 
      const size_t ori_f) -> Index 
    {
      if (stitch_all) 
      {
        // No need to check if p shared by multiple triangles because all shared
        // vertices would be merged later on.
        const size_t index = num_base_vertices + new_vertices.size();
        new_vertices.push_back(p);
        return index;
      } else 
      {
        // Stitching triangles according to input connectivity.
        // This step is potentially costly.
        const auto& triangle = T[ori_f];
        const auto& f = F.row(ori_f).eval();
 
        // Check if p is one of the triangle corners.
        for (size_t i=0; i<3; i++) 
        {
          if (p == triangle[i]) return f[i];
        }
 
        // Check if p is on one of the edges.
        for (size_t i=0; i<3; i++) {
          const Point_3 curr_corner = triangle[i];
          const Point_3 next_corner = triangle[(i+1)%3];
          const Segment_3 edge(curr_corner, next_corner);
          if (edge.has_on(p)) {
            const Index curr = f[i];
            const Index next = f[(i+1)%3];
            Edge key;
            key.first = curr<next?curr:next;
            key.second = curr<next?next:curr;
            auto itr = edge_vertices.find(key);
            if (itr == edge_vertices.end()) {
              const Index index =
                num_base_vertices + new_vertices.size();
              edge_vertices.insert({key, {index}});
              new_vertices.push_back(p);
              return index;
            } else {
              for (const auto vid : itr->second) {
                if (p == new_vertices[vid - num_base_vertices]) {
                  return vid;
                }
              }
              const size_t index = num_base_vertices + new_vertices.size();
              new_vertices.push_back(p);
              itr->second.push_back(index);
              return index;
            }
          }
        }
 
        // p must be in the middle of the triangle.
        auto & existing_face_vertices = face_vertices[ori_f];
        for(const auto vid : existing_face_vertices) {
          if (p == new_vertices[vid - num_base_vertices]) {
            return vid;
          }
        }
        const size_t index = num_base_vertices + new_vertices.size();
        new_vertices.push_back(p);
        existing_face_vertices.push_back(index);
        return index;
      }
    };
 
    // Determine the vertex indices for each corner of each output triangle.
    // 
    // Inputs:
    //   vertices  #V list of vertices of cdt
    //   faces  #F list of list of face indices into vertices of cdt
    //   involved_faces  list of involved faces on the plane of cdt
    // Side effects:
    //   - add faces to resolved_faces
    //   - add corresponding original face to source_faces
    //   - 
    auto post_triangulation_process = [&](
      const std::vector<Point_3>& vertices,
      const std::vector<std::vector<Index> >& faces,
      const std::vector<Index>& involved_faces) -> void 
    {
      assert(involved_faces.size() > 0);
      // for all faces of the cdt
      for (const auto& f : faces) 
      {
        const Point_3& v0 = vertices[f[0]];
        const Point_3& v1 = vertices[f[1]];
        const Point_3& v2 = vertices[f[2]];
        Point_3 center(
          (v0[0] + v1[0] + v2[0]) / 3.0,
          (v0[1] + v1[1] + v2[1]) / 3.0,
          (v0[2] + v1[2] + v2[2]) / 3.0);
        if (involved_faces.size() == 1) 
        {
          // If only there is only one involved face, all sub-triangles must
          // belong to it and have the correct orientation.
          const auto& ori_f = involved_faces[0];
          std::vector<Index> corners(3);
          corners[0] = find_or_append_point(v0, ori_f);
          corners[1] = find_or_append_point(v1, ori_f);
          corners[2] = find_or_append_point(v2, ori_f);
          resolved_faces.emplace_back(corners);
          source_faces.push_back(ori_f);
        } else 
        {
          for (const auto& ori_f : involved_faces) 
          {
            const auto& triangle = T[ori_f];
            const Plane_3 P = triangle.supporting_plane();
            if (triangle.has_on(center)) {
              std::vector<Index> corners(3);
              corners[0] = find_or_append_point(v0, ori_f);
              corners[1] = find_or_append_point(v1, ori_f);
              corners[2] = find_or_append_point(v2, ori_f);
              if (CGAL::orientation(
                    P.to_2d(v0), P.to_2d(v1), P.to_2d(v2))
                  == CGAL::RIGHT_TURN) {
                std::swap(corners[0], corners[1]);
              }
              resolved_faces.emplace_back(corners);
              source_faces.push_back(ori_f);
            }
          }
        }
      }
    };
 
    // Process un-touched faces.
    for (size_t i=0; i<num_faces; i++) 
    {
      if (!is_offending[i] && !T[i].is_degenerate()) 
      {
        resolved_faces.push_back( { F(i,0), F(i,1), F(i,2) } );
        source_faces.push_back(i);
      }
    }
 
    // Process self-intersecting faces.
    std::vector<bool> processed(num_faces, false);
    std::vector<std::pair<Plane_3, std::vector<Index> > > cdt_inputs;
    for (const auto itr : offending) 
    {
      const auto fid = itr.first;
      if (processed[fid]) continue;
      processed[fid] = true;
 
      const auto loc = intersecting_and_coplanar.find(fid);
      std::vector<Index> involved_faces;
      if (loc == intersecting_and_coplanar.end()) 
      {
        involved_faces.push_back(fid);
      } else 
      {
        std::queue<Index> Q;
        Q.push(fid);
        while (!Q.empty()) 
        {
          const auto index = Q.front();
          involved_faces.push_back(index);
          Q.pop();
 
          const auto overlapping_faces = intersecting_and_coplanar.find(index);
          assert(overlapping_faces != intersecting_and_coplanar.end());
 
          for (const auto other_index : overlapping_faces->second) 
          {
            if (processed[other_index]) continue;
            processed[other_index] = true;
            Q.push(other_index);
          }
        }
      }
 
      Plane_3 P = T[fid].supporting_plane();
      cdt_inputs.emplace_back(P, involved_faces);
    }
#ifdef REMESH_INTERSECTIONS_TIMING
    log_time("preprocess");
#endif
 
    const size_t num_cdts = cdt_inputs.size();
    std::vector<std::vector<Point_3> > cdt_vertices(num_cdts);
    std::vector<std::vector<std::vector<Index> > > cdt_faces(num_cdts);
 
    //igl::parallel_for(num_cdts,[&](int i)
    for (size_t i=0; i<num_cdts; i++) 
    {
      auto& vertices = cdt_vertices[i];
      auto& faces = cdt_faces[i];
      const auto& P = cdt_inputs[i].first;
      const auto& involved_faces = cdt_inputs[i].second;
      delaunay_triangulation(P, involved_faces, vertices, faces);
    }
    //,1000);
#ifdef REMESH_INTERSECTIONS_TIMING
    log_time("cdt");
#endif
 
    for (size_t i=0; i<num_cdts; i++) 
    {
      const auto& vertices = cdt_vertices[i];
      const auto& faces = cdt_faces[i];
      const auto& involved_faces = cdt_inputs[i].second;
      post_triangulation_process(vertices, faces, involved_faces);
    }
#ifdef REMESH_INTERSECTIONS_TIMING
    log_time("stitching");
#endif
 
    // Output resolved mesh.
    const size_t num_out_vertices = new_vertices.size() + num_base_vertices;
    VV.resize(num_out_vertices, 3);
    for (size_t i=0; i<num_base_vertices; i++) 
    {
      assign_scalar(V(i,0), VV(i,0));
      assign_scalar(V(i,1), VV(i,1));
      assign_scalar(V(i,2), VV(i,2));
    }
 
    for (size_t i=num_base_vertices; i<num_out_vertices; i++) 
    {
      assign_scalar(new_vertices[i-num_base_vertices][0], VV(i,0));
      assign_scalar(new_vertices[i-num_base_vertices][1], VV(i,1));
      assign_scalar(new_vertices[i-num_base_vertices][2], VV(i,2));
    }
 
    const size_t num_out_faces = resolved_faces.size();
    FF.resize(num_out_faces, 3);
    for (size_t i=0; i<num_out_faces; i++) 
    {
      FF(i,0) = resolved_faces[i][0];
      FF(i,1) = resolved_faces[i][1];
      FF(i,2) = resolved_faces[i][2];
    }
 
    J.resize(num_out_faces);
    std::copy(source_faces.begin(), source_faces.end(), J.data());
 
    // Extract unique vertex indices.
    const size_t VV_size = VV.rows();
    IM.resize(VV_size,1);
 
    DerivedVV unique_vv;
    Eigen::VectorXi unique_to_vv, vv_to_unique;
    // This is not stable... So even if offending is empty V != VV in
    // general...
    igl::unique_rows(VV, unique_vv, unique_to_vv, vv_to_unique);
    if(stitch_all) 
    {
      // Merge all vertices having the same coordinates into a single vertex
      // and set IM to identity map.
      VV = unique_vv;
      std::transform(FF.data(), FF.data() + FF.rows()*FF.cols(),
          FF.data(), [&vv_to_unique](const typename DerivedFF::Scalar& a)
          { return vv_to_unique[a]; });
      IM.resize(unique_vv.rows());
      // Have to use << instead of = because Eigen's PlainObjectBase is annoying
      IM << igl::LinSpaced<
        Eigen::Matrix<typename DerivedIM::Scalar, Eigen::Dynamic,1 >
        >(unique_vv.rows(), 0, unique_vv.rows()-1);
    }else 
    {
      // Vertices with the same coordinates would be represented by one vertex.
      // The IM value of a vertex is the index of the representative vertex.
      for (Index v=0; v<(Index)VV_size; v++) {
        IM(v) = unique_to_vv[vv_to_unique[v]];
      }
    }
 
#ifdef REMESH_INTERSECTIONS_TIMING
    log_time("store_results");
#endif
}

References assign_scalar(), Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), delaunay_triangulation(), igl::get_seconds(), igl::LinSpaced(), EdgeHash::operator()(), projected_cdt(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), and igl::unique_rows().

Referenced by igl::copyleft::cgal::SelfIntersectMesh< Kernel, DerivedV, DerivedF, DerivedVV, DerivedFF, DerivedIF, DerivedJ, DerivedIM >::SelfIntersectMesh(), intersect_other_helper(), and remesh_intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

remesh_intersections() [2/2]

template<typename DerivedV , typename DerivedF , typename Kernel , typename DerivedVV , typename DerivedFF , typename DerivedJ , typename DerivedIM >

IGL_INLINE void igl::copyleft::cgal::remesh_intersections	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		const std::vector< CGAL::Triangle_3< Kernel > > &	T,
		const std::map< typename DerivedF::Index, std::vector< std::pair< typename DerivedF::Index, CGAL::Object > > > &	offending,
		Eigen::PlainObjectBase< DerivedVV > &	VV,
		Eigen::PlainObjectBase< DerivedFF > &	FF,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< DerivedIM > &	IM
	)

{
  // by default, no stitching
  igl::copyleft::cgal::remesh_intersections(V,F,T,offending,false,VV,FF,J,IM);
}

References remesh_intersections().

Here is the call graph for this function:

remesh_self_intersections()

template<typename DerivedV , typename DerivedF , typename DerivedVV , typename DerivedFF , typename DerivedIF , typename DerivedJ , typename DerivedIM >

IGL_INLINE void igl::copyleft::cgal::remesh_self_intersections	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedF > &	F,
		const RemeshSelfIntersectionsParam &	params,
		Eigen::PlainObjectBase< DerivedVV > &	VV,
		Eigen::PlainObjectBase< DerivedFF > &	FF,
		Eigen::PlainObjectBase< DerivedIF > &	IF,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< DerivedIM > &	IM
	)

{
  using namespace std;
  if(params.detect_only)
  {
 
//#ifdef __APPLE__
//#define IGL_THROW_FPE 11
//    const auto & throw_fpe = [](int e)
//    {
//      throw "IGL_THROW_FPE";
//    };
//    signal(SIGFPE,throw_fpe);
//#endif
 
    typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
    typedef
      SelfIntersectMesh<
        Kernel,
        DerivedV,
        DerivedF,
        DerivedVV,
        DerivedFF,
        DerivedIF,
        DerivedJ,
        DerivedIM>
      SelfIntersectMeshK;
    SelfIntersectMeshK SIM(V,F,params,VV,FF,IF,J,IM);
 
//#ifdef __APPLE__
//    signal(SIGFPE,SIG_DFL);
//#endif
 
  }else
  {
    typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
    typedef
      SelfIntersectMesh<
        Kernel,
        DerivedV,
        DerivedF,
        DerivedVV,
        DerivedFF,
        DerivedIF,
        DerivedJ,
        DerivedIM>
      SelfIntersectMeshK;
    SelfIntersectMeshK SIM(V,F,params,VV,FF,IF,J,IM);
  }
}

References igl::copyleft::cgal::RemeshSelfIntersectionsParam::detect_only.

Referenced by mesh_boolean(), outer_hull(), and piecewise_constant_winding_number().

Here is the caller graph for this function:

resolve_intersections()

template<typename DerivedV , typename DerivedE , typename DerivedVI , typename DerivedEI , typename DerivedJ , typename DerivedIM >

IGL_INLINE void igl::copyleft::cgal::resolve_intersections	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedE > &	E,
		Eigen::PlainObjectBase< DerivedVI > &	VI,
		Eigen::PlainObjectBase< DerivedEI > &	EI,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< DerivedIM > &	IM
	)

{
  using namespace Eigen;
  using namespace igl;
  using namespace std;
  // Exact scalar type
  typedef CGAL::Epeck K;
  typedef K::FT EScalar;
  typedef CGAL::Segment_2<K> Segment_2;
  typedef CGAL::Point_2<K> Point_2;
  typedef Matrix<EScalar,Dynamic,Dynamic>  MatrixXE;
 
  // Convert vertex positions to exact kernel
  MatrixXE VE(V.rows(),V.cols());
  for(int i = 0;i<V.rows();i++)
  {
    for(int j = 0;j<V.cols();j++)
    {
      VE(i,j) = V(i,j);
    }
  }
 
  const int m = E.rows();
  // resolve all intersections: silly O(n²) implementation
  std::vector<std::vector<Point_2> > steiner(m);
  for(int i = 0;i<m;i++)
  {
    Segment_2 si(row_to_point<K>(VE,E(i,0)),row_to_point<K>(VE,E(i,1)));
    steiner[i].push_back(si.vertex(0));
    steiner[i].push_back(si.vertex(1));
    for(int j = i+1;j<m;j++)
    {
      Segment_2 sj(row_to_point<K>(VE,E(j,0)),row_to_point<K>(VE,E(j,1)));
      // do they intersect?
      if(CGAL::do_intersect(si,sj))
      {
        CGAL::Object result = CGAL::intersection(si,sj);
        if(const Point_2 * p = CGAL::object_cast<Point_2 >(&result))
        {
          steiner[i].push_back(*p);
          steiner[j].push_back(*p);
          // add intersection point
        }else if(const Segment_2 * s = CGAL::object_cast<Segment_2 >(&result))
        {
          // add both endpoints
          steiner[i].push_back(s->vertex(0));
          steiner[j].push_back(s->vertex(0));
          steiner[i].push_back(s->vertex(1));
          steiner[j].push_back(s->vertex(1));
        }else
        {
          assert(false && "Unknown intersection type");
        }
      }
    }
  }
 
  subdivide_segments(V,E,steiner,VI,EI,J,IM);
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::rows(), and subdivide_segments().

Referenced by snap_rounding().

Here is the call graph for this function:

Here is the caller graph for this function:

row_to_point()

template<typename Kernel , typename DerivedV >

IGL_INLINE CGAL::Point_2< Kernel > igl::copyleft::cgal::row_to_point	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const typename DerivedV::Index &	i
	)

{
  return CGAL::Point_2<Kernel>(V(i,0),V(i,1));
}

segment_segment_squared_distance()

template<typename Kernel >

IGL_INLINE bool igl::copyleft::cgal::segment_segment_squared_distance	(	const CGAL::Segment_3< Kernel > &	S1,
		const CGAL::Segment_3< Kernel > &	S2,
		CGAL::Point_3< Kernel > &	P1,
		CGAL::Point_3< Kernel > &	P2,
		typename Kernel::FT &	d
	)

{
  typedef CGAL::Point_3<Kernel> Point_3;
  typedef CGAL::Vector_3<Kernel> Vector_3;
  typedef typename Kernel::FT EScalar;
  if(S1.is_degenerate())
  {
    // All points on S1 are the same
    P1 = S1.source();
    point_segment_squared_distance(P1,S2,P2,dst);
    return true;
  }else if(S2.is_degenerate())
  {
    assert(!S1.is_degenerate());
    // All points on S2 are the same
    P2 = S2.source();
    point_segment_squared_distance(P2,S1,P1,dst);
    return true;
  }
 
  assert(!S1.is_degenerate());
  assert(!S2.is_degenerate());
 
  Vector_3 u = S1.target() - S1.source();
  Vector_3 v = S2.target() - S2.source();
  Vector_3 w = S1.source() - S2.source();
 
  const auto a = u.dot(u);         // always >= 0
  const auto b = u.dot(v);
  const auto c = v.dot(v);         // always >= 0
  const auto d = u.dot(w);
  const auto e = v.dot(w);
  const auto D = a*c - b*b;        // always >= 0
  assert(D>=0);
  const auto sc=D, sN=D, sD = D;       // sc = sN / sD, default sD = D >= 0
  const auto tc=D, tN=D, tD = D;       // tc = tN / tD, default tD = D >= 0
 
  bool parallel = false;
  // compute the line parameters of the two closest points
  if (D==0) 
  { 
    // the lines are almost parallel
    parallel = true;
    sN = 0.0;         // force using source point on segment S1
    sD = 1.0;         // to prevent possible division by 0.0 later
    tN = e;
    tD = c;
  } else
  {
    // get the closest points on the infinite lines
    sN = (b*e - c*d);
    tN = (a*e - b*d);
    if (sN < 0.0) 
    { 
      // sc < 0 => the s=0 edge is visible
      sN = 0.0;
      tN = e;
      tD = c;
    } else if (sN > sD) 
    {  // sc > 1  => the s=1 edge is visible
      sN = sD;
      tN = e + b;
      tD = c;
    }
  }
 
  if (tN < 0.0) 
  {
    // tc < 0 => the t=0 edge is visible
    tN = 0.0;
    // recompute sc for this edge
    if (-d < 0.0)
    {
      sN = 0.0;
    }else if (-d > a)
    {
      sN = sD;
    }else 
    {
      sN = -d;
      sD = a;
    }
  }else if (tN > tD) 
  {
    // tc > 1  => the t=1 edge is visible
    tN = tD;
    // recompute sc for this edge
    if ((-d + b) < 0.0)
    {
      sN = 0;
    }else if ((-d + b) > a)
    {
      sN = sD;
    }else
    {
      sN = (-d +  b);
      sD = a;
    }
  }
  // finally do the division to get sc and tc
  sc = (abs(sN) == 0 ? 0.0 : sN / sD);
  tc = (abs(tN) == 0 ? 0.0 : tN / tD);
 
  // get the difference of the two closest points
  P1 = S1.source() + sc*(S1.target()-S1.source());
  P2 = S2.source() + sc*(S2.target()-S2.source());
  Vector_3   dP = w + (sc * u) - (tc * v);  // =  S1(sc) - S2(tc)
  assert(dP == (P1-P2));
 
  dst = dP.squared_length();   // return the closest distance
  return parallel;
}

References point_segment_squared_distance().

Referenced by triangle_triangle_squared_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

signed_distance_isosurface()

IGL_INLINE bool igl::copyleft::cgal::signed_distance_isosurface	(	const Eigen::MatrixXd &	IV,
		const Eigen::MatrixXi &	IF,
		const double	level,
		const double	angle_bound,
		const double	radius_bound,
		const double	distance_bound,
		const SignedDistanceType	sign_type,
		Eigen::MatrixXd &	V,
		Eigen::MatrixXi &	F
	)

{
  using namespace std;
  using namespace Eigen;
 
  // default triangulation for Surface_mesher
  typedef CGAL::Surface_mesh_default_triangulation_3 Tr;
  // c2t3
  typedef CGAL::Complex_2_in_triangulation_3<Tr> C2t3;
  typedef Tr::Geom_traits GT;//Kernel
  typedef GT::Sphere_3 Sphere_3;
  typedef GT::Point_3 Point_3;
  typedef GT::FT FT;
  typedef std::function<FT (Point_3)> Function;
  typedef CGAL::Implicit_surface_3<GT, Function> Surface_3;
 
  AABB<Eigen::MatrixXd,3> tree;
  tree.init(IV,IF);
 
  Eigen::MatrixXd FN,VN,EN;
  Eigen::MatrixXi E;
  Eigen::VectorXi EMAP;
  WindingNumberAABB< Eigen::Vector3d, Eigen::MatrixXd, Eigen::MatrixXi > hier;
  switch(sign_type)
  {
    default:
      assert(false && "Unknown SignedDistanceType");
    case SIGNED_DISTANCE_TYPE_UNSIGNED:
      // do nothing
      break;
    case SIGNED_DISTANCE_TYPE_DEFAULT:
    case SIGNED_DISTANCE_TYPE_WINDING_NUMBER:
      hier.set_mesh(IV,IF);
      hier.grow();
      break;
    case SIGNED_DISTANCE_TYPE_PSEUDONORMAL:
      // "Signed Distance Computation Using the Angle Weighted Pseudonormal"
      // [Bærentzen & Aanæs 2005]
      per_face_normals(IV,IF,FN);
      per_vertex_normals(IV,IF,PER_VERTEX_NORMALS_WEIGHTING_TYPE_ANGLE,FN,VN);
      per_edge_normals(
        IV,IF,PER_EDGE_NORMALS_WEIGHTING_TYPE_UNIFORM,FN,EN,E,EMAP);
      break;
  }
 
  Tr tr;            // 3D-Delaunay triangulation
  C2t3 c2t3 (tr);   // 2D-complex in 3D-Delaunay triangulation
  // defining the surface
  const auto & IVmax = IV.colwise().maxCoeff();
  const auto & IVmin = IV.colwise().minCoeff();
  const double bbd = (IVmax-IVmin).norm();
  const double r = bbd/2.;
  const auto & IVmid = 0.5*(IVmax + IVmin);
  // Supposedly the implict needs to evaluate to <0 at cmid...
  // http://doc.cgal.org/latest/Surface_mesher/classCGAL_1_1Implicit__surface__3.html
  Point_3 cmid(IVmid(0),IVmid(1),IVmid(2));
  Function fun;
  switch(sign_type)
  {
    default:
      assert(false && "Unknown SignedDistanceType");
    case SIGNED_DISTANCE_TYPE_UNSIGNED:
      fun = 
        [&tree,&IV,&IF,&level](const Point_3 & q) -> FT
        {
          int i;
          RowVector3d c;
          const double sd = tree.squared_distance(
            IV,IF,RowVector3d(q.x(),q.y(),q.z()),i,c);
          return sd-level;
        };
    case SIGNED_DISTANCE_TYPE_DEFAULT:
    case SIGNED_DISTANCE_TYPE_WINDING_NUMBER:
      fun = 
        [&tree,&IV,&IF,&hier,&level](const Point_3 & q) -> FT
        {
          const double sd = signed_distance_winding_number(
            tree,IV,IF,hier,Vector3d(q.x(),q.y(),q.z()));
          return sd-level;
        };
      break;
    case SIGNED_DISTANCE_TYPE_PSEUDONORMAL:
      fun = [&tree,&IV,&IF,&FN,&VN,&EN,&EMAP,&level](const Point_3 & q) -> FT
        {
          const double sd = 
            igl::signed_distance_pseudonormal(
              tree,IV,IF,FN,VN,EN,EMAP,RowVector3d(q.x(),q.y(),q.z()));
          return sd- level;
        };
      break;
  }
  Sphere_3 bounding_sphere(cmid, (r+level)*(r+level));
  Surface_3 surface(fun,bounding_sphere);
  CGAL::Surface_mesh_default_criteria_3<Tr> 
    criteria(angle_bound,radius_bound,distance_bound);
  // meshing surface
  CGAL::make_surface_mesh(c2t3, surface, criteria, CGAL::Manifold_tag());
  // complex to (V,F)
  return igl::copyleft::cgal::complex_to_mesh(c2t3,V,F);
}

References complex_to_mesh(), igl::WindingNumberAABB< Point, DerivedV, DerivedF >::grow(), GT, igl::AABB< DerivedV, DIM >::init(), igl::per_edge_normals(), igl::PER_EDGE_NORMALS_WEIGHTING_TYPE_UNIFORM, igl::per_face_normals(), igl::per_vertex_normals(), igl::PER_VERTEX_NORMALS_WEIGHTING_TYPE_ANGLE, igl::WindingNumberAABB< Point, DerivedV, DerivedF >::set_mesh(), igl::signed_distance_pseudonormal(), igl::SIGNED_DISTANCE_TYPE_DEFAULT, igl::SIGNED_DISTANCE_TYPE_PSEUDONORMAL, igl::SIGNED_DISTANCE_TYPE_UNSIGNED, igl::SIGNED_DISTANCE_TYPE_WINDING_NUMBER, igl::signed_distance_winding_number(), and igl::AABB< DerivedV, DIM >::squared_distance().

Here is the call graph for this function:

snap_rounding()

template<typename DerivedV , typename DerivedE , typename DerivedVI , typename DerivedEI , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::snap_rounding	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedE > &	E,
		Eigen::PlainObjectBase< DerivedVI > &	VI,
		Eigen::PlainObjectBase< DerivedEI > &	EI,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  using namespace Eigen;
  using namespace igl;
  using namespace igl::copyleft::cgal;
  using namespace std;
  // Exact scalar type
  typedef CGAL::Epeck Kernel;
  typedef Kernel::FT EScalar;
  typedef CGAL::Segment_2<Kernel> Segment_2;
  typedef CGAL::Point_2<Kernel> Point_2;
  typedef CGAL::Vector_2<Kernel> Vector_2;
  typedef Matrix<EScalar,Dynamic,Dynamic>  MatrixXE;
  // Convert vertex positions to exact kernel
 
  MatrixXE VE;
  {
    VectorXi IM;
    resolve_intersections(V,E,VE,EI,J,IM);
    for_each(
      EI.data(),
      EI.data()+EI.size(),
      [&IM](typename DerivedEI::Scalar& i){i=IM(i);});
    VectorXi _;
    remove_unreferenced( MatrixXE(VE), DerivedEI(EI), VE,EI,_);
  }
 
  // find all hot pixels
  //const RowVector2i SW(
  //  round(VE.col(0).minCoeff()),
  //  round(VE.col(1).minCoeff()));
  //const RowVector2i NE(
  //  round(VE.col(0).maxCoeff()),
  //  round(VE.col(1).maxCoeff()));
 
  // https://github.com/CGAL/cgal/issues/548
  // Round an exact scalar to the nearest integer. A priori can't just round
  // double. Suppose e=0.5+ε but double(e)<0.5
  //
  // Inputs:
  //   e  exact number
  // Outputs:
  //   i  closest integer
  const auto & round = [](const EScalar & e)->int
  {
    const double d = CGAL::to_double(e);
    // get an integer that's near the closest int
    int i = std::round(d);
    EScalar di_sqr = CGAL::square((e-EScalar(i)));
    const auto & search = [&i,&di_sqr,&e](const int dir)
    {
      while(true)
      {
        const int j = i+dir;
        const EScalar dj_sqr = CGAL::square((e-EScalar(j)));
        if(dj_sqr < di_sqr)
        {
          i = j;
          di_sqr = dj_sqr;
        }else
        {
          break;
        }
      }
    };
    // Try to increase/decrease int
    search(1);
    search(-1);
    return i;
  };
  vector<Point_2> hot;
  for(int i = 0;i<VE.rows();i++)
  {
    hot.emplace_back(round(VE(i,0)),round(VE(i,1)));
  }
  {
    std::vector<size_t> _1,_2;
    igl::unique(vector<Point_2>(hot),hot,_1,_2);
  }
 
  // find all segments intersecting hot pixels
  //   split edge at closest point to hot pixel center
  vector<vector<Point_2>>  steiner(EI.rows());
  // initialize each segment with endpoints
  for(int i = 0;i<EI.rows();i++)
  {
    steiner[i].emplace_back(VE(EI(i,0),0),VE(EI(i,0),1));
    steiner[i].emplace_back(VE(EI(i,1),0),VE(EI(i,1),1));
  }
  // silly O(n²) implementation
  for(const Point_2 & h : hot)
  {
    // North, East, South, West
    Segment_2 wall[4] = 
    {
      {h+Vector_2(-0.5, 0.5),h+Vector_2( 0.5, 0.5)},
      {h+Vector_2( 0.5, 0.5),h+Vector_2( 0.5,-0.5)},
      {h+Vector_2( 0.5,-0.5),h+Vector_2(-0.5,-0.5)},
      {h+Vector_2(-0.5,-0.5),h+Vector_2(-0.5, 0.5)}
    };
    // consider all segments
    for(int i = 0;i<EI.rows();i++)
    {
      // endpoints
      const Point_2 s(VE(EI(i,0),0),VE(EI(i,0),1));
      const Point_2 d(VE(EI(i,1),0),VE(EI(i,1),1));
      // if either end-point is in h's pixel then ignore
      const Point_2 rs(round(s.x()),round(s.y()));
      const Point_2 rd(round(d.x()),round(d.y()));
      if(h == rs || h == rd)
      {
        continue;
      }
      // otherwise check for intersections with walls consider all walls
      const Segment_2 si(s,d);
      vector<Point_2> hits;
      for(int j = 0;j<4;j++)
      {
        const Segment_2 & sj = wall[j];
        if(CGAL::do_intersect(si,sj))
        {
          CGAL::Object result = CGAL::intersection(si,sj);
          if(const Point_2 * p = CGAL::object_cast<Point_2 >(&result))
          {
            hits.push_back(*p);
          }else if(const Segment_2 * s = CGAL::object_cast<Segment_2 >(&result))
          {
            // add both endpoints
            hits.push_back(s->vertex(0));
            hits.push_back(s->vertex(1));
          }
        }
      }
      if(hits.size() == 0)
      {
        continue;
      }
      // centroid of hits
      Vector_2 cen(0,0);
      for(const Point_2 & hit : hits)
      {
        cen = Vector_2(cen.x()+hit.x(), cen.y()+hit.y());
      }
      cen = Vector_2(cen.x()/EScalar(hits.size()),cen.y()/EScalar(hits.size()));
      const Point_2 rcen(round(cen.x()),round(cen.y()));
      // after all of that, don't add as a steiner unless it's going to round
      // to h
      if(rcen == h)
      {
        steiner[i].emplace_back(cen.x(),cen.y());
      }
    }
  }
  {
    DerivedJ prevJ = J;
    VectorXi IM;
    subdivide_segments(MatrixXE(VE),MatrixXi(EI),steiner,VE,EI,J,IM);
    for_each(J.data(),J.data()+J.size(),[&prevJ](typename DerivedJ::Scalar & j){j=prevJ(j);});
    for_each(
      EI.data(),
      EI.data()+EI.size(),
      [&IM](typename DerivedEI::Scalar& i){i=IM(i);});
    VectorXi _;
    remove_unreferenced( MatrixXE(VE), DerivedEI(EI), VE,EI,_);
  }
 
 
  VI.resizeLike(VE);
  for(int i = 0;i<VE.rows();i++)
  {
    for(int j = 0;j<VE.cols();j++)
    {
      VI(i,j) = round(CGAL::to_double(VE(i,j)));
    }
  }
}

References _, Eigen::PlainObjectBase< Derived >::data(), igl::for_each(), igl::remove_unreferenced(), resolve_intersections(), round(), subdivide_segments(), and igl::unique().

Here is the call graph for this function:

string_to_mesh_boolean_type() [1/2]

IGL_INLINE igl::MeshBooleanType igl::copyleft::cgal::string_to_mesh_boolean_type

(

const std::string &

s

)

{
  MeshBooleanType type;
#ifndef NDEBUG
  const bool ret = 
#endif
    string_to_mesh_boolean_type(s,type);
  assert(ret && "Unknown MeshBooleanType name");
  return type;
}

References string_to_mesh_boolean_type().

Here is the call graph for this function:

string_to_mesh_boolean_type() [2/2]

IGL_INLINE bool igl::copyleft::cgal::string_to_mesh_boolean_type	(	const std::string &	s,
		MeshBooleanType &	type
	)

{
  using namespace std;
  string eff_s = s;
  transform(eff_s.begin(), eff_s.end(), eff_s.begin(), ::tolower);
  const auto & find_any = 
    [](const vector<string> & haystack, const string & needle)->bool
  {
    return find(haystack.begin(), haystack.end(), needle) != haystack.end();
  };
  if(find_any({"union","unite","u","∪"},eff_s))
  {
    type = MESH_BOOLEAN_TYPE_UNION;
  }else if(find_any({"intersect","intersection","i","∩"},eff_s))
  {
    type = MESH_BOOLEAN_TYPE_INTERSECT;
  }else if(
    find_any(
      {"minus","subtract","difference","relative complement","m","\\"},eff_s))
  {
    type = MESH_BOOLEAN_TYPE_MINUS;
  }else if(find_any({"xor","symmetric difference","x","∆"},eff_s))
  {
    type = MESH_BOOLEAN_TYPE_XOR;
  }else if(find_any({"resolve"},eff_s))
  {
    type = MESH_BOOLEAN_TYPE_RESOLVE;
  }else
  {
    return false;
  }
  return true;
}

References igl::find(), igl::MESH_BOOLEAN_TYPE_INTERSECT, igl::MESH_BOOLEAN_TYPE_MINUS, igl::MESH_BOOLEAN_TYPE_RESOLVE, igl::MESH_BOOLEAN_TYPE_UNION, and igl::MESH_BOOLEAN_TYPE_XOR.

Referenced by mesh_boolean(), and string_to_mesh_boolean_type().

Here is the call graph for this function:

Here is the caller graph for this function:

subdivide_segments()

template<typename DerivedV , typename DerivedE , typename Kernel , typename DerivedVI , typename DerivedEI , typename DerivedJ , typename DerivedIM >

IGL_INLINE void igl::copyleft::cgal::subdivide_segments	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedE > &	E,
		const std::vector< std::vector< CGAL::Point_2< Kernel > > > &	steiner,
		Eigen::PlainObjectBase< DerivedVI > &	VI,
		Eigen::PlainObjectBase< DerivedEI > &	EI,
		Eigen::PlainObjectBase< DerivedJ > &	J,
		Eigen::PlainObjectBase< DerivedIM > &	IM
	)

{
  using namespace Eigen;
  using namespace igl;
  using namespace std;
 
  // Exact scalar type
  typedef Kernel K;
  typedef typename Kernel::FT EScalar;
  typedef CGAL::Segment_2<Kernel> Segment_2;
  typedef CGAL::Point_2<Kernel> Point_2;
  typedef Matrix<EScalar,Dynamic,Dynamic>  MatrixXE;
 
  // non-const copy
  std::vector<std::vector<CGAL::Point_2<Kernel> > > steiner = _steiner;
 
  // Convert vertex positions to exact kernel
  MatrixXE VE(V.rows(),V.cols());
  for(int i = 0;i<V.rows();i++)
  {
    for(int j = 0;j<V.cols();j++)
    {
      VE(i,j) = V(i,j);
    }
  }
 
  // number of original vertices
  const int n = V.rows();
  // number of original segments
  const int m = E.rows();
  // now steiner contains lists of points (unsorted) for each edge. Sort them
  // and count total number of vertices and edges
  int ni = 0;
  int mi = 0;
  // new steiner points
  std::vector<Point_2> S;
  std::vector<std::vector<typename DerivedE::Scalar> > vEI;
  std::vector<typename DerivedJ::Scalar> vJ;
  for(int i = 0;i<m;i++)
  {
    {
      const Point_2 s = row_to_point<K>(VE,E(i,0));
      std::sort(
        steiner[i].begin(),
        steiner[i].end(),
        [&s](const Point_2 & A, const Point_2 & B)->bool
        {
          return (A-s).squared_length() < (B-s).squared_length();
        });
    }
    // remove duplicates
    steiner[i].erase(
      std::unique(steiner[i].begin(), steiner[i].end()), 
      steiner[i].end());
    {
      int s = E(i,0);
      // legs to each steiner in order
      for(int j = 1;j<steiner[i].size()-1;j++)
      {
        int d = n+S.size();
        S.push_back(steiner[i][j]);
        vEI.push_back({s,d});
        vJ.push_back(i);
        s = d;
      }
      // don't forget last (which might only) leg
      vEI.push_back({s,E(i,1)});
      vJ.push_back(i);
    }
  }
  // potentially unnecessary copying ...
  VI.resize(n+S.size(),2);
  for(int i = 0;i<V.rows();i++)
  {
    for(int j = 0;j<V.cols();j++)
    {
      assign_scalar(V(i,j),VI(i,j));
    }
  }
  for(int i = 0;i<S.size();i++)
  {
    assign_scalar(S[i].x(),VI(n+i,0));
    assign_scalar(S[i].y(),VI(n+i,1));
  }
  list_to_matrix(vEI,EI);
  list_to_matrix(vJ,J);
  {
    // Find unique mapping
    std::vector<Point_2> vVES,_1;
    for(int i = 0;i<n;i++)
    {
      vVES.push_back(row_to_point<K>(VE,i));
    }
    vVES.insert(vVES.end(),S.begin(),S.end());
    std::vector<size_t> vA,vIM;
    igl::unique(vVES,_1,vA,vIM);
    // Push indices back into vVES
    for_each(vIM.data(),vIM.data()+vIM.size(),[&vA](size_t & i){i=vA[i];});
    list_to_matrix(vIM,IM);
  }
}

References assign_scalar(), Eigen::PlainObjectBase< Derived >::cols(), igl::for_each(), igl::list_to_matrix(), Eigen::PlainObjectBase< Derived >::rows(), and igl::unique().

Referenced by resolve_intersections(), and snap_rounding().

Here is the call graph for this function:

Here is the caller graph for this function:

submesh_aabb_tree()

template<typename DerivedV , typename DerivedF , typename DerivedI , typename Kernel >

IGL_INLINE void igl::copyleft::cgal::submesh_aabb_tree	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedI > &	I,
		CGAL::AABB_tree< CGAL::AABB_traits< Kernel, CGAL::AABB_triangle_primitive< Kernel, typename std::vector< typename Kernel::Triangle_3 >::iterator > > > &	tree,
		std::vector< typename Kernel::Triangle_3 > &	triangles,
		std::vector< bool > &	in_I
	)

{
  in_I.resize(F.rows(), false);
  const size_t num_faces = I.rows();
  for (size_t i=0; i<num_faces; i++) 
  {
    const Eigen::Vector3i f = F.row(I(i, 0));
    in_I[I(i,0)] = true;
    triangles.emplace_back(
      typename Kernel::Point_3(V(f[0], 0), V(f[0], 1), V(f[0], 2)),
      typename Kernel::Point_3(V(f[1], 0), V(f[1], 1), V(f[1], 2)),
      typename Kernel::Point_3(V(f[2], 0), V(f[2], 1), V(f[2], 2)));
#ifndef NDEBUG
    if (triangles.back().is_degenerate()) 
    {
      throw std::runtime_error(
        "Input facet components contains degenerated triangles");
    }
#endif
  }
  tree.insert(triangles.begin(), triangles.end());
  tree.accelerate_distance_queries();
}

References Eigen::PlainObjectBase< Derived >::rows().

Referenced by closest_facet(), and extract_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

triangle_triangle_squared_distance()

template<typename Kernel >

IGL_INLINE bool igl::copyleft::cgal::triangle_triangle_squared_distance	(	const CGAL::Triangle_3< Kernel > &	T1,
		const CGAL::Triangle_3< Kernel > &	T2,
		CGAL::Point_3< Kernel > &	P1,
		CGAL::Point_3< Kernel > &	P2,
		typename Kernel::FT &	d
	)

{
  typedef CGAL::Point_3<Kernel> Point_3;
  typedef CGAL::Vector_3<Kernel> Vector_3;
  typedef CGAL::Triangle_3<Kernel> Triangle_3;
  typedef CGAL::Segment_3<Kernel> Segment_3;
  typedef typename Kernel::FT EScalar;
  assert(!T1.is_degenerate());
  assert(!T2.is_degenerate());
 
  bool unique = true;
  if(CGAL::do_intersect(T1,T2))
  {
    // intersecting triangles have zero (squared) distance
    CGAL::Object result = CGAL::intersection(T1,T2);
    // Some point on the intersection result
    CGAL::Point_3<Kernel> Q;
    if(const Point_3 * p = CGAL::object_cast<Point_3 >(&result))
    {
      Q = *p;
    }else if(const Segment_3 * s = CGAL::object_cast<Segment_3 >(&result))
    {
      unique = false;
      Q = s->source();
    }else if(const Triangle_3 *itri = CGAL::object_cast<Triangle_3 >(&result))
    {
      Q = s->vertex(0);
      unique = false;
    }else if(const std::vector<Point_3 > *polyp = 
      CGAL::object_cast< std::vector<Point_3 > >(&result))
    {
      assert(polyp->size() > 0 && "intersection poly should not be empty");
      Q = polyp[0];
      unique = false;
    }else
    {
      assert(false && "Unknown intersection result");
    }
    P1 = Q;
    P2 = Q;
    d = 0;
    return unique;
  }
  // triangles do not intersect: the points of closest approach must be on the
  // boundary of one of the triangles
  d = std::numeric_limits<double>::infinity();
  const auto & vertices_face = [&unique](
    const Triangle_3 & T1,
    const Triangle_3 & T2,
    Point_3 & P1,
    Point_3 & P2,
    EScalar & d)
  {
    for(int i = 0;i<3;i++)
    {
      const Point_3 vi = T1.vertex(i);
      Point_3 P2i;
      EScalar di;
      point_triangle_squared_distance(vi,T2,P2i,di);
      if(di<d)
      {
        d = di;
        P1 = vi;
        P2 = P2i;
        unique = true;
      }else if(d == di)
      {
        // edge of T1 floating parallel above T2
        unique = false;
      }
    }
  };
  vertices_face(T1,T2,P1,P2,d);
  vertices_face(T2,T1,P1,P2,d);
  for(int i = 0;i<3;i++)
  {
    const Segment_3 s1( T1.vertex(i+1), T1.vertex(i+2));
    for(int j = 0;j<3;j++)
    {
      const Segment_3 s2( T2.vertex(i+1), T2.vertex(i+2));
      Point_3 P1ij;
      Point_3 P2ij;
      EScalar dij;
      bool uniqueij = segment_segment_squared_distance(s1,s2,P1ij,P2ij,dij);
      if(dij < d)
      {
        P1 = P1ij;
        P2 = P2ij;
        d = dij;
        unique = uniqueij;
      }
    }
  }
  return unique;
}

References point_triangle_squared_distance(), segment_segment_squared_distance(), and igl::unique().

Here is the call graph for this function:

trim_with_solid()

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedV , typename DerivedF , typename DerivedD , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::trim_with_solid	(	const Eigen::PlainObjectBase< DerivedVA > &	VA,
		const Eigen::PlainObjectBase< DerivedFA > &	FA,
		const Eigen::PlainObjectBase< DerivedVB > &	VB,
		const Eigen::PlainObjectBase< DerivedFB > &	FB,
		Eigen::PlainObjectBase< DerivedV > &	Vd,
		Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedD > &	D,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  // resolve intersections using exact representation
  typedef Eigen::Matrix<CGAL::Epeck::FT,Eigen::Dynamic,3> MatrixX3E;
  typedef Eigen::Matrix<CGAL::Epeck::FT,Eigen::Dynamic,1> VectorXE;
  typedef Eigen::Matrix<CGAL::Epeck::FT,1,3> RowVector3E;
  MatrixX3E V;
  Eigen::MatrixXi _1;
  Eigen::VectorXi _2;
  // Intersect A and B meshes and stitch together new faces
  igl::copyleft::cgal::intersect_other(
    VA,FA,VB,FB,{false,false,true},_1,V,F,J,_2);
  // Partition result into manifold patches
  Eigen::VectorXi P;
  const size_t num_patches = igl::extract_manifold_patches(F,P);
  // only keep faces from A
  Eigen::Matrix<bool,Eigen::Dynamic,1> A = J.array()< FA.rows();
  igl::slice_mask(Eigen::MatrixXi(F),A,1,F);
  igl::slice_mask(Eigen::VectorXi(P),A,1,P);
  igl::slice_mask(Eigen::VectorXi(J),A,1,J);
  // Aggregate representative query points for each patch
  std::vector<bool> flag(num_patches);
  std::vector<std::vector<CGAL::Epeck::FT> > vQ;
  Eigen::VectorXi P2Q(num_patches);
  for(int f = 0;f<P.rows();f++)
  {
    const auto p = P(f);
    // if not yet processed this patch
    if(!flag[p])
    {
      P2Q(p) = vQ.size();
      std::vector<CGAL::Epeck::FT> q = {
        (V(F(f,0),0)+ V(F(f,1),0)+ V(F(f,2),0))/3.,
        (V(F(f,0),1)+ V(F(f,1),1)+ V(F(f,2),1))/3.,
        (V(F(f,0),2)+ V(F(f,1),2)+ V(F(f,2),2))/3.};
      vQ.emplace_back(q);
      flag[p] = true;
    }
  }
  MatrixX3E Q;
  igl::list_to_matrix(vQ,Q);
  VectorXE SP;
  point_solid_signed_squared_distance(Q,VB,FB,SP);
  Eigen::Matrix<bool,Eigen::Dynamic,1> DP = SP.array()>0;
  // distribute flag to all faces
  D.resize(F.rows());
  for(int f = 0;f<F.rows();f++)
  {
    D(f) = DP(P2Q(P(f)));
  }
  Eigen::VectorXi _;
  igl::remove_unreferenced(MatrixX3E(V),DerivedF(F),V,F,_);
  assign(V,Vd);
}

References _, assign(), igl::extract_manifold_patches(), intersect_other(), igl::list_to_matrix(), point_solid_signed_squared_distance(), igl::remove_unreferenced(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), and igl::slice_mask().

Here is the call graph for this function:

wire_mesh() [1/2]

template<typename DerivedWV , typename DerivedWE , typename DerivedV , typename DerivedF , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::wire_mesh	(	const Eigen::MatrixBase< DerivedWV > &	WV,
		const Eigen::MatrixBase< DerivedWE > &	WE,
		const double	th,
		const int	poly_size,
		const bool	solid,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
 
  typedef typename DerivedWV::Scalar Scalar;
  // Canonical polygon to place at each endpoint
  typedef Eigen::Matrix<Scalar,Eigen::Dynamic,3> MatrixX3S;
  MatrixX3S PV(poly_size,3);
  for(int p =0;p<PV.rows();p++)
  {
    const Scalar phi = (Scalar(p)/Scalar(PV.rows()))*2.*igl::PI;
    PV(p,0) = 0.5*cos(phi);
    PV(p,1) = 0.5*sin(phi);
    PV(p,2) = 0;
  }
 
  V.resize(WV.rows() + PV.rows() * 2 * WE.rows(),3);
  V.topLeftCorner(WV.rows(),3) = WV;
  // Signed adjacency list
  std::vector<std::vector<std::pair<int,int> > > A(WV.rows());
  // Inputs:
  //   e  index of edge
  //   c  index of endpoint [0,1]
  //   p  index of polygon vertex
  // Returns index of corresponding vertex in V
  const auto index = 
    [&PV,&WV](const int e, const int c, const int p)->int
  {
    return WV.rows() + e*2*PV.rows() + PV.rows()*c + p;
  };
  const auto unindex = 
    [&PV,&WV](int v, int & e, int & c, int & p)
  {
    assert(v>=WV.rows());
    v = v-WV.rows();
    e = v/(2*PV.rows());
    v = v-e*(2*PV.rows());
    c = v/(PV.rows());
    v = v-c*(PV.rows());
    p = v;
  };
  // loop over all edges
  for(int e = 0;e<WE.rows();e++)
  {
    // Fill in adjacency list as we go
    A[WE(e,0)].emplace_back(e,0);
    A[WE(e,1)].emplace_back(e,1);
    typedef Eigen::Matrix<Scalar,1,3> RowVector3S;
    const RowVector3S ev = WV.row(WE(e,1))-WV.row(WE(e,0));
    const Scalar len = ev.norm();
    // Unit edge vector
    const RowVector3S uv = ev.normalized();
    Eigen::Quaternion<Scalar> q;
    q = q.FromTwoVectors(RowVector3S(0,0,1),uv);
    // loop over polygon vertices
    for(int p = 0;p<PV.rows();p++)
    {
      RowVector3S qp = q*(PV.row(p)*th);
      // loop over endpoints
      for(int c = 0;c<2;c++)
      {
        // Direction moving along edge vector
        const Scalar dir = c==0?1:-1;
        // Amount (distance) to move along edge vector
        // Start with factor of thickness;
        // Max out amount at 1/3 of edge length so that there's always some
        // amount of edge
        Scalar dist = std::min(1.*th,len/3.0);
        // Move to endpoint, offset by amount
        V.row(index(e,c,p)) = 
          qp+WV.row(WE(e,c)) + dist*dir*uv;
      }
    }
  }
 
  std::vector<std::vector<typename DerivedF::Index> > vF;
  std::vector<int> vJ;
  const auto append_hull = 
    [&V,&vF,&vJ,&unindex,&WV](const Eigen::VectorXi & I, const int j)
  {
    MatrixX3S Vv;
    igl::slice(V,I,1,Vv);
    Eigen::MatrixXi Fv;
    convex_hull(Vv,Fv);
    for(int f = 0;f<Fv.rows();f++)
    {
      const Eigen::Array<int,1,3> face(I(Fv(f,0)), I(Fv(f,1)), I(Fv(f,2)));
      //const bool on_vertex = (face<WV.rows()).any();
      //if(!on_vertex)
      //{
      //  // This correctly prunes fcaes on the "caps" of convex hulls around
      //  // edges, but for convex hulls around vertices this will only work if
      //  // the incoming edges are not overlapping.
      //  //
      //  // Q: For convex hulls around vertices, is the correct thing to do:
      //  // check if all corners of face lie *on or _outside_* of plane of "cap"?
      //  // 
      //  // H: Maybe, but if there's an intersection then the boundary of the
      //  // incoming convex hulls around edges is still not going to match up
      //  // with the boundary on the convex hull around the vertices.
      //  //
      //  // Might have to bite the bullet and always call self-union.
      //  bool all_same = true;
      //  int e0,c0,p0;
      //  unindex(face(0),e0,c0,p0);
      //  for(int i = 1;i<3;i++)
      //  {
      //    int ei,ci,pi;
      //    unindex(face(i),ei,ci,pi);
      //    all_same = all_same && (e0==ei && c0==ci);
      //  }
      //  if(all_same)
      //  {
      //    // don't add this face
      //    continue;
      //  }
      //}
      vF.push_back( { face(0),face(1),face(2)});
      vJ.push_back(j);
    }
  };
  // loop over each vertex
  for(int v = 0;v<WV.rows();v++)
  {
    // Gather together this vertex and the polygon vertices of all incident
    // edges
    Eigen::VectorXi I(1+A[v].size()*PV.rows());
    // This vertex
    I(0) = v;
    for(int n = 0;n<A[v].size();n++)
    {
      for(int p = 0;p<PV.rows();p++)
      {
        const int e = A[v][n].first;
        const int c = A[v][n].second;
        I(1+n*PV.rows()+p) = index(e,c,p);
      }
    }
    append_hull(I,v);
  }
  // loop over each edge
  for(int e = 0;e<WE.rows();e++)
  {
    // Gether together polygon vertices of both endpoints
    Eigen::VectorXi I(PV.rows()*2);
    for(int c = 0;c<2;c++)
    {
      for(int p = 0;p<PV.rows();p++)
      {
        I(c*PV.rows()+p) = index(e,c,p);
      }
    }
    append_hull(I,WV.rows()+e);
  }
 
  list_to_matrix(vF,F);
  if(solid)
  {
    // Self-union to clean up 
    igl::copyleft::cgal::mesh_boolean(
      Eigen::MatrixXd(V),Eigen::MatrixXi(F),Eigen::MatrixXd(),Eigen::MatrixXi(),
      "union",
      V,F,J);
    for(int j=0;j<J.size();j++) J(j) = vJ[J(j)];
  }else
  {
    list_to_matrix(vJ,J);
  }
}

References convex_hull(), cos(), Eigen::Quaternion< _Scalar, _Options >::FromTwoVectors(), igl::list_to_matrix(), mesh_boolean(), igl::PI, Eigen::PlainObjectBase< Derived >::resize(), sin(), and igl::slice().

Referenced by wire_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

wire_mesh() [2/2]

template<typename DerivedWV , typename DerivedWE , typename DerivedV , typename DerivedF , typename DerivedJ >

IGL_INLINE void igl::copyleft::cgal::wire_mesh	(	const Eigen::MatrixBase< DerivedWV > &	WV,
		const Eigen::MatrixBase< DerivedWE > &	WE,
		const double	th,
		const int	poly_size,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  return wire_mesh(WV,WE,th,poly_size,true,V,F,J);
}

References wire_mesh().

Here is the call graph for this function: