zcy
/
dust3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dust3d/thirdparty/cgal/CGAL-4.13/include/CGAL/intersection_of_Polyhedra_3.h

2188 lines
87 KiB
C++
Executable File
Raw Blame History

// Copyright (c) 2010-2012 GeometryFactory (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// You can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0+
//
//
// Author(s) : Sebastien Loriot
#ifndef CGAL_INTERSECTION_OF_POLYHEDRA_3_H
#define CGAL_INTERSECTION_OF_POLYHEDRA_3_H
#include <CGAL/license/Polygon_mesh_processing.h>
#include <CGAL/disable_warnings.h>
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Cartesian_converter.h>
#include <CGAL/box_intersection_d.h>
#include <CGAL/Bbox_3.h>
#include <CGAL/intersections.h>
#include <boost/next_prior.hpp>
#include <set>
#include <vector>
#include <list>
#include <algorithm>
#include <CGAL/tuple.h>
#include <CGAL/iterator.h>
#include <CGAL/property_map.h>
#include <CGAL/Modifier_base.h>
#include <CGAL/internal/corefinement/Polyhedron_constness_types.h>
#include <CGAL/internal/corefinement/intersection_triangle_segment_3.h>
#include <CGAL/internal/corefinement/intersection_coplanar_triangles_3.h>
#include <CGAL/use.h>
#include <CGAL/Default.h>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/foreach.hpp>
#include <CGAL/Polygon_mesh_processing/self_intersections.h>
#include <boost/dynamic_bitset.hpp>
#ifdef CGAL_COREFINEMENT_DEBUG
#warning look at CGAL/Mesh_3/Robust_intersection_traits.h and the statically filtered decision tree
#endif
namespace CGAL{
//This functor computes the pairwise intersection of polyhedral surfaces.
//Intersection are given as a set of polylines
//The algorithm works as follow:
//From each polyhedral surface we can get it as a set of segments or as a set of triangles.
//We first use Box_intersection_d to filter intersection between all polyhedral
//surface segments and polyhedral triangles.
//From this filtered set, for each pair (segment,triangle), we look at the
//intersection type. If not empty, we can have three different cases
// 1)the segment intersect the interior of the triangle:
// We compute the intersection point and for each triangle incident
// to the segment, we write the fact that the point belong to the intersection
// of these two triangles.
// 2)the segment intersect the triangle on an edge
// We do the same thing as described above but
// for all triangle incident to the edge intersected
// 3)the segment intersect the triangle at a vertex
// for each edge incident to the vertex, we do
// the same operations as in 2)
//
//In case the segment intersect the triangle at one of the segment endpoint,
//we repeat the same procedure for each segment incident to this
//endpoint.
//
//Note that given a pair (segment,triangle)=(S,T), if S belongs
//to the plane of T, we have nothing to do in the following cases:
// -- no triangle T' contains S such that T and T' are coplanar
// -- at least one triangle contains S
// Indeed, the intersection points of S and T will be found using segments
// of T or segments adjacent to S.
//
// -- Sebastien Loriot, 2010/04/07
template <class Polyhedron>
struct Default_polyhedron_ppmap{
typedef typename Polyhedron::Point_3 value_type;
typedef const value_type& reference;
typedef typename Polyhedron::Vertex_handle key_type;
typedef boost::read_write_property_map_tag category;
friend reference get(Default_polyhedron_ppmap, key_type vh) {return vh->point();}
friend reference get(Default_polyhedron_ppmap, typename Polyhedron::Vertex_const_handle vh) {return vh->point();}
friend void put(Default_polyhedron_ppmap,key_type vh, const value_type& v) {vh->point()=v;}
};
namespace internal_IOP {
//an enum do decide which kind of intersection points are needed
struct No_predicates_on_constructions{};
struct Predicates_on_constructions{};
} // namespace internal_IOP
template<class Polyhedron>
struct Empty_node_visitor{
typedef typename Polyhedron::Halfedge_const_handle Halfedge_handle;
void new_node_added(int,internal_IOP::Intersection_type,Halfedge_handle,Halfedge_handle,bool,bool){}
template<class Iterator>
void annotate_graph(Iterator,Iterator){}
void update_terminal_nodes(std::vector<bool>&){}
void set_number_of_intersection_points_from_coplanar_facets(int){}
void input_have_coplanar_facets(){}
void add_filtered_intersection(Halfedge_handle,Halfedge_handle,const Polyhedron&,const Polyhedron&){}
void start_new_polyline(int,int){}
void add_node_to_polyline(int){}
void new_input_polyhedron(const Polyhedron&){}
template<class T>
void finalize(T&){}
typedef internal_IOP::No_predicates_on_constructions Node_storage_type;
typedef Tag_true Is_polyhedron_const;
static const bool do_need_vertex_graph = false;
};
namespace internal_IOP{
template <class Polyhedron,class Is_const>
struct Compare_handles{
typedef typename Polyhedron_types<Polyhedron,Is_const>::Halfedge_handle Halfedge_handle;
typedef typename Polyhedron_types<Polyhedron,Is_const>::Halfedge Halfedge;
typedef typename Polyhedron_types<Polyhedron,Is_const>::Vertex Vertex;
typedef typename Polyhedron_types<Polyhedron,Is_const>::Facet Facet;
typedef typename Polyhedron_types<Polyhedron,Is_const>::Facet_handle Facet_handle;
typedef std::pair<const Vertex*,const Vertex*> Vertex_handle_pair;
static inline Vertex_handle_pair
make_sorted_pair_of_vertices(Halfedge_handle h) {
const Vertex* v1=&(* h->vertex() );
const Vertex* v2=&(* h->opposite()->vertex() );
if ( v1 < v2 )
return Vertex_handle_pair(v1,v2);
return Vertex_handle_pair(v2,v1);
}
bool operator()(Halfedge_handle h1,Halfedge_handle h2) const {
Vertex_handle_pair p1=make_sorted_pair_of_vertices(h1);
Vertex_handle_pair p2=make_sorted_pair_of_vertices(h2);
return p1 < p2;
}
bool operator()(Facet_handle f1,Facet_handle f2) const {
return &(*f1) < &(*f2);
}
bool operator()(const std::pair<Halfedge_handle,Polyhedron*>& p1, const std::pair<Halfedge_handle,Polyhedron*>& p2) const{
Halfedge* h1= (std::min) ( &(*(p1.first)), &(*(p1.first->opposite())) );
Halfedge* h2= (std::min) ( &(*(p2.first)), &(*(p2.first->opposite())) );
return h1<h2;
}
};
//could not put it in the above struct (gcc complains about an ambiguous call)
template <class Polyhedron,class Is_const>
struct Compare_handle_pairs{
typedef typename Polyhedron_types<Polyhedron,Is_const>::Facet Facet;
typedef typename Polyhedron_types<Polyhedron,Is_const>::Facet_handle Facet_handle;
typedef std::pair<Facet_handle,Facet_handle> Facet_pair;
typedef std::pair<Facet_pair,int> Facet_pair_and_int;
bool operator()(const Facet_pair& p1, const Facet_pair& p2) const{
Facet* f1=&(*p1.first);
Facet* f2=&(*p2.first);
if (f1==f2){
f1=&(*p1.second);
f2=&(*p2.second);
}
return f1<f2;
}
bool operator()(const Facet_pair_and_int& p1, const Facet_pair_and_int& p2) const{
Facet* f1=&(*p1.first.first);
Facet* f2=&(*p2.first.first);
if (f1==f2){
f1=&(*p1.first.second);
f2=&(*p2.first.second);
}
if (f1<f2) return true;
if (f1>f2) return false;
return p1.second<p2.second;
}
};
template<class Polyhedron,class PolyhedronPointPMap, class Nodes_vector,class Is_const>
struct Order_along_a_halfedge{
typedef typename Polyhedron_types<Polyhedron,Is_const>::Halfedge_handle Halfedge_handle;
const Nodes_vector& nodes;
Halfedge_handle hedge;
PolyhedronPointPMap ppmap;
Order_along_a_halfedge(Halfedge_handle hedge_,const Nodes_vector& nodes_, PolyhedronPointPMap ppmap):nodes(nodes_),hedge(hedge_), ppmap(ppmap){}
bool operator()(int i,int j) const {
//returns true, iff q lies strictly between p and r.
typename Nodes_vector::Protector p;
try{
CGAL::internal::use(p);
return CGAL::collinear_are_strictly_ordered_along_line(nodes.to_interval(get(ppmap, hedge->vertex())),
nodes.interval_node(j),
nodes.interval_node(i));
}
catch(CGAL::Uncertain_conversion_exception&){
return CGAL::collinear_are_strictly_ordered_along_line(nodes.to_exact(get(ppmap, hedge->vertex())),
nodes.exact_node(j),
nodes.exact_node(i));
}
}
};
template <class HDS>
class Split_halfedge : public CGAL::Modifier_base<HDS> {
typedef typename HDS::Halfedge_handle Halfedge_handle;
typedef typename HDS::Vertex_handle Vertex_handle;
typedef typename HDS::Vertex Vertex;
Halfedge_handle hedge;
typename HDS::Halfedge::Base*
unlock_halfedge(Halfedge_handle h){
return static_cast<typename HDS::Halfedge::Base*>(&(*h));
}
public:
Split_halfedge(Halfedge_handle h) : hedge(h){}
// new_hedge hedge
// -----------> ----------->
// v
// <----------- <-----------
// new_opposite opposite
//
void operator()( HDS& hds) {
Vertex_handle v=hds.vertices_push_back(Vertex());
Halfedge_handle opposite=hedge->opposite();
Halfedge_handle new_hedge=hds.edges_push_back(*hedge);
Halfedge_handle new_opposite=new_hedge->opposite();
//update next relations
unlock_halfedge(new_hedge)->set_next(hedge);
unlock_halfedge(new_hedge->prev())->set_next(new_hedge);
unlock_halfedge(hedge)->set_prev(new_hedge);
unlock_halfedge(opposite)->set_next(new_opposite);
unlock_halfedge(new_opposite)->set_prev(opposite);
unlock_halfedge(new_opposite->next())->set_prev(new_opposite);
unlock_halfedge(opposite)->set_vertex(v);
unlock_halfedge(new_hedge)->set_vertex(v);
v->set_halfedge(new_hedge);
new_opposite->vertex()->set_halfedge(new_opposite);
}
};
} //namespace internal_IOP
//WARNING THIS IS DONE ONLY FOR POLYHEDRON
// Warning this will split only existing edges, newly created edge intersected
// by the intersection polyline won't be split
template<class Polyhedron,class Halfedge_predicate,
class Set_vertex_corner,
class PolyhedronPointPMap=Default_polyhedron_ppmap<Polyhedron>,
class Kernel=typename Kernel_traits< typename boost::property_traits<PolyhedronPointPMap>::value_type>::Kernel >
class Node_visitor_for_polyline_split{
//typedefs
typedef typename Polyhedron::Halfedge_handle Halfedge_handle;
typedef typename Polyhedron::Halfedge Halfedge;
typedef typename Polyhedron::Vertex_handle Vertex_handle;
//Info stores information about a particular intersection on an
//edge or a vertex of a polyhedron. The two first elements in
//the template describe the intersected simplex of the considered
//polyhedron; the two last elements describe the element of the
//second polyhedron (can be either a vertex, an edge of a facet)
//involved in the intersection
typedef CGAL::cpp11::tuple<internal_IOP::Intersection_type,
Halfedge_handle,
internal_IOP::Intersection_type,
Halfedge_handle> Info;
typedef std::map<Halfedge*,Polyhedron*> Hedge_to_polyhedron_map;
typedef std::vector<Info> Infos;
typedef std::map<int,Infos > Node_to_infos_map;
//data members
Node_to_infos_map node_infos;
Hedge_to_polyhedron_map hedge_to_polyhedron;
Halfedge_predicate is_on_polyline;
Set_vertex_corner set_as_corner;
PolyhedronPointPMap ppmap;
//functions
void handle_principal_edge(int node_id,
internal_IOP::Intersection_type type,
Halfedge_handle principal_edge,
Halfedge_handle additional_edge,
bool is_vertex_coplanar,
bool is_vertex_opposite_coplanar)
{
bool coplanar_v=false;
if (is_vertex_coplanar) coplanar_v=true;
else if (is_vertex_opposite_coplanar){
principal_edge=principal_edge->opposite();
coplanar_v=true;
}
if (coplanar_v)
handle_on_vertex(node_id,principal_edge,type,additional_edge);
else{
if ( is_on_polyline(principal_edge) ){
typename Node_to_infos_map::iterator it_res=
node_infos.insert(std::make_pair(node_id,Infos())).first;
it_res->second.push_back( Info(internal_IOP::EDGE,principal_edge,type,additional_edge) );
}
}
}
void handle_on_vertex(int node_id,Halfedge_handle edge,internal_IOP::Intersection_type type,Halfedge_handle additional_edge){
Halfedge_handle current=edge;
do{
if (is_on_polyline(current)){
typename Node_to_infos_map::iterator it_res=
node_infos.insert(std::make_pair(node_id,Infos())).first;
it_res->second.push_back( Info(internal_IOP::VERTEX,current,type,additional_edge) );
break;
}
current=current->next()->opposite();
}
while(current!=edge);
}
Halfedge* make_unique_key(Halfedge_handle h){
if (&(*h) < &(*h->opposite()))
return &(*h);
else
return &(*h->opposite());
}
// new_hedge hedge
// -----------> ----------->
// v
// <----------- <-----------
// new_opposite opposite
//
void split_edge_and_retriangulate(Halfedge_handle hedge,const typename Kernel::Point_3& point,Polyhedron& P){
internal_IOP::Split_halfedge<typename Polyhedron::HalfedgeDS> delegated(hedge);
P.delegate( delegated );
Vertex_handle vh=boost::prior(P.vertices_end());
put(ppmap, vh, point);
CGAL_assertion(get(ppmap,vh)==point);
CGAL_assertion(P.is_valid());
//triangulate the two adjacent facets
if (!hedge->is_border())
P.split_facet(hedge->prev(),hedge->next());
if (!hedge->opposite()->is_border())
P.split_facet(hedge->opposite(),hedge->opposite()->next()->next());
CGAL_assertion(P.is_valid());
}
//sort node ids so that we can split the hedge
//consecutively
template <class Nodes_vector>
void sort_vertices_along_hedge(std::vector<int>& node_ids,Halfedge_handle hedge,const Nodes_vector& nodes)
{
std::sort(node_ids.begin(),
node_ids.end(),
internal_IOP::Order_along_a_halfedge<Polyhedron,PolyhedronPointPMap,Nodes_vector,Is_polyhedron_const>(hedge,nodes,ppmap)
);
}
public:
static const bool do_need_vertex_graph = false;
typedef internal_IOP::Predicates_on_constructions Node_storage_type;
typedef Tag_false Is_polyhedron_const;
Node_visitor_for_polyline_split(){}
Node_visitor_for_polyline_split(const Halfedge_predicate& getting,
const Set_vertex_corner& setting,
PolyhedronPointPMap ppmap)
:is_on_polyline(getting),set_as_corner(setting),ppmap(ppmap){}
void new_node_added(int node_id,
internal_IOP::Intersection_type type,
Halfedge_handle principal_edge,
Halfedge_handle additional_edge,
bool is_vertex_coplanar,
bool is_vertex_opposite_coplanar)
{
switch(type)
{
case internal_IOP::FACET: //Facet intersected by an edge
handle_principal_edge(node_id,type,principal_edge,additional_edge,is_vertex_coplanar,is_vertex_opposite_coplanar);
break;
case internal_IOP::EDGE: //Edge intersected by an edge
handle_principal_edge(node_id,type,principal_edge,additional_edge,is_vertex_coplanar,is_vertex_opposite_coplanar);
if ( is_on_polyline(additional_edge) ){
typename Node_to_infos_map::iterator it_res=
node_infos.insert(std::make_pair(node_id,Infos())).first;
it_res->second.push_back( Info(type,additional_edge,
( is_vertex_coplanar||is_vertex_opposite_coplanar ) ? internal_IOP::VERTEX:internal_IOP::EDGE,
is_vertex_opposite_coplanar?principal_edge->opposite():principal_edge) );
}
break;
case internal_IOP::VERTEX://Vertex intersected by an edge
handle_principal_edge(node_id,type,principal_edge,additional_edge,is_vertex_coplanar,is_vertex_opposite_coplanar);
handle_on_vertex( node_id,additional_edge,
( is_vertex_coplanar||is_vertex_opposite_coplanar ) ? internal_IOP::VERTEX:internal_IOP::EDGE,
is_vertex_opposite_coplanar?principal_edge->opposite():principal_edge);
break;
default:
break;
}
}
template<class Iterator>
void annotate_graph(Iterator begin,Iterator end){
for(Iterator it=begin;it!=end;++it){
typename Node_to_infos_map::iterator it_res=node_infos.find(static_cast<int>(std::distance(begin, it)));
if (it_res!=node_infos.end())
it->make_terminal();
}
}
void update_terminal_nodes(std::vector<bool>& terminal_bools){
for (typename Node_to_infos_map::iterator it=node_infos.begin();it!=node_infos.end();++it){
terminal_bools[it->first]=true;
}
}
void new_input_polyhedron(const Polyhedron&){}
void start_new_polyline(int,int){}
void add_node_to_polyline(int){}
void set_number_of_intersection_points_from_coplanar_facets(int){}
void add_filtered_intersection(Halfedge_handle eh,Halfedge_handle fh,Polyhedron& Pe,Polyhedron& Pf){
hedge_to_polyhedron.insert(std::make_pair(make_unique_key(eh),&Pe));
hedge_to_polyhedron.insert(std::make_pair(make_unique_key(fh),&Pf));
hedge_to_polyhedron.insert(std::make_pair(make_unique_key(fh->next()),&Pf));
hedge_to_polyhedron.insert(std::make_pair(make_unique_key(fh->next()->next()),&Pf));
}
//split_halfedges
template <class Nodes_vector>
void finalize(const Nodes_vector& nodes){
typedef std::map<std::pair<Halfedge_handle,Polyhedron*>,
std::vector<int>,internal_IOP::Compare_handles<Polyhedron,Is_polyhedron_const> > Halfedges_to_split;
Halfedges_to_split halfedges_to_split;
for (typename Node_to_infos_map::iterator it=node_infos.begin();it!=node_infos.end();++it){
int node_id=it->first;
const Infos& infos=it->second;
std::map<Polyhedron*,std::vector<Halfedge_handle> > hedges_to_split;
//collect information about halfedge to split
typename Infos::const_iterator it_info=infos.begin();
for (;it_info!=infos.end();++it_info)
{
typename Hedge_to_polyhedron_map::iterator it_poly=
hedge_to_polyhedron.find(make_unique_key(CGAL::cpp11::get<1>(*it_info)));
CGAL_assertion(it_poly!=hedge_to_polyhedron.end());
//associate information to an intersection point:
//we give which simplex of the other polyhedron intersect the simplex considered
set_as_corner.add_info_to_node(node_id,it_poly->second,*it_info);
switch(CGAL::cpp11::get<0>(*it_info))
{
case internal_IOP::EDGE:
{
halfedges_to_split.insert(
std::make_pair( std::make_pair(CGAL::cpp11::get<1>(*it_info),&(*(it_poly->second))),std::vector<int>() )
).first->second.push_back(node_id);
break;
}
case internal_IOP::VERTEX:
set_as_corner(CGAL::cpp11::get<1>(*it_info)->vertex(),node_id,it_poly->second);
break;
default:
CGAL_assertion(false);
//should never be here
}
}
}
//do the split
for(typename Halfedges_to_split::iterator it=halfedges_to_split.begin();it!=halfedges_to_split.end();++it){
Halfedge_handle hedge=it->first.first;
Polyhedron* P=it->first.second;
std::vector<int>& node_ids=it->second;
sort_vertices_along_hedge(node_ids,hedge,nodes);
for (std::vector<int>::iterator it_id=node_ids.begin();it_id!=node_ids.end();++it_id){
split_edge_and_retriangulate(hedge,nodes[*it_id],*P);
set_as_corner(hedge->opposite()->vertex(),*it_id,(Polyhedron*)(0));
}
}
}
void input_have_coplanar_facets() {}
};
namespace internal_IOP{
template <class Polyhedron, class In_kernel,class Exact_kernel, class PolyhedronPointPMap>
typename Exact_kernel::Point_3
compute_triangle_segment_intersection_point(
typename Polyhedron::Vertex_const_handle vh1,typename Polyhedron::Vertex_const_handle vh2,
typename Polyhedron::Vertex_const_handle vf1,typename Polyhedron::Vertex_const_handle vf2,typename Polyhedron::Vertex_const_handle vf3,
const Exact_kernel& ek,
PolyhedronPointPMap ppmap)
{
CGAL::Cartesian_converter<In_kernel,Exact_kernel> to_exact;
typename Exact_kernel::Triangle_3 t(to_exact( get(ppmap, vf1) ),
to_exact( get(ppmap, vf2) ),
to_exact( get(ppmap, vf3) )
);
typename Exact_kernel::Segment_3 s (to_exact( get(ppmap, vh1) ),
to_exact( get(ppmap, vh2) )
);
typename Exact_kernel::Intersect_3 exact_intersect=ek.intersect_3_object();
CGAL::Object inter=exact_intersect(t,s);
CGAL_assertion(CGAL::do_intersect(t,s));
const typename Exact_kernel::Point_3* e_pt=CGAL::object_cast<typename Exact_kernel::Point_3>(&inter);
CGAL_assertion(e_pt!=NULL);
return *e_pt;
}
template <class Polyhedron, class In_kernel,class Exact_kernel, class PolyhedronPointPMap>
typename Exact_kernel::Point_3
compute_triangle_segment_intersection_point(
typename Polyhedron::Halfedge_const_handle edge,
typename Polyhedron::Facet_const_handle facet,
const Exact_kernel& ek,
PolyhedronPointPMap pmap)
{
return compute_triangle_segment_intersection_point<Polyhedron,In_kernel>(
edge->vertex(),edge->opposite()->vertex(),
facet->halfedge()->vertex(),facet->halfedge()->next()->vertex(),facet->halfedge()->opposite()->vertex(),
ek,
pmap);
}
//A class containing a vector of the intersection points.
//The third template parameter indicates whether an
//exact representation is required
template <class Polyhedron, class PolyhedronPointPMap, class Kernel,class Node_storage,bool Has_exact_constructions=!boost::is_floating_point<typename Kernel::FT>::value>
class Triangle_segment_intersection_points;
//Store only the double version of the intersection points.
template <class Polyhedron, class PolyhedronPointPMap, class Kernel>
class Triangle_segment_intersection_points<Polyhedron,PolyhedronPointPMap,Kernel,No_predicates_on_constructions,false>
{
//typedefs
typedef std::vector <typename Kernel::Point_3> Nodes_vector;
typedef typename Polyhedron::Halfedge_const_handle Halfedge_handle;
typedef typename Polyhedron::Facet_const_handle Facet_handle;
typedef CGAL::Exact_predicates_exact_constructions_kernel Exact_kernel;
typedef CGAL::Cartesian_converter<Exact_kernel,Kernel> Exact_to_double;
//members
Nodes_vector nodes;
Exact_kernel ek;
Exact_to_double exact_to_double;
PolyhedronPointPMap ppmap;
public:
Triangle_segment_intersection_points(PolyhedronPointPMap ppmap):
ppmap(ppmap){}
typedef CGAL::Interval_nt<true>::Protector Protector;
const typename Kernel::Point_3&
operator[](int i) const {
return nodes[i];
}
const typename Kernel::Point_3& exact_node(int i) const {return nodes[i];}
const typename Kernel::Point_3& interval_node(int i) const {return nodes[i];}
const typename Kernel::Point_3& to_exact(const typename Kernel::Point_3& p) const {return p;}
const typename Kernel::Point_3& to_interval(const typename Kernel::Point_3& p) const {return p;}
size_t size() const {return nodes.size();}
void add_new_node(const typename Exact_kernel::Point_3& p)
{
nodes.push_back( exact_to_double(p) );
}
//add a new node in the final graph.
//it is the intersection of the triangle with the segment
void add_new_node(Halfedge_handle edge,Facet_handle facet)
{
add_new_node(
compute_triangle_segment_intersection_point<Polyhedron, Kernel>(edge,facet,ek, ppmap)
);
}
void add_new_node(const typename Kernel::Point_3& p)
{
nodes.push_back(p);
}
}; // end specialization
// Triangle_segment_intersection_points<Polyhedron,Kernel,No_predicates_on_constructions,false>
//second specializations: store an exact copy of the points so that we can answer exactly predicates
//FYI, it used to have two specializations (one in the case the polyhedron
//can be edited and on if it cannot) building exact representation on demand.
//In the former case, we were using facet and halfedge while in the latter
//triple of vertex_handle and pair of vertex_handle
template <class Polyhedron, class PolyhedronPointPMap, class Kernel>
class Triangle_segment_intersection_points<Polyhedron,PolyhedronPointPMap,Kernel,Predicates_on_constructions,false>
{
//typedefs
public:
typedef CGAL::Simple_cartesian<CGAL::Interval_nt<false> > Ikernel;
typedef CGAL::Exact_predicates_exact_constructions_kernel Exact_kernel;
private:
typedef CGAL::Cartesian_converter<Ikernel,Kernel> Interval_to_double;
typedef CGAL::Cartesian_converter<Kernel,Ikernel> Double_to_interval;
typedef CGAL::Cartesian_converter<Exact_kernel,Ikernel> Exact_to_interval;
typedef CGAL::Cartesian_converter<Kernel,Exact_kernel> Double_to_exact;
typedef typename Polyhedron::Vertex_const_handle Vertex_handle;
typedef typename Polyhedron::Halfedge_const_handle Halfedge_handle;
typedef typename Polyhedron::Facet_const_handle Facet_handle;
typedef std::vector <Ikernel::Point_3> Interval_nodes;
typedef std::vector <Exact_kernel::Point_3> Exact_nodes;
//members
Interval_nodes inodes;
Exact_nodes enodes;
Interval_to_double interval_to_double;
Exact_to_interval exact_to_interval;
Double_to_interval double_to_interval;
Double_to_exact double_to_exact;
Exact_kernel ek;
PolyhedronPointPMap ppmap;
public:
Triangle_segment_intersection_points(PolyhedronPointPMap ppmap):
ppmap(ppmap){}
typedef CGAL::Interval_nt<false>::Protector Protector;
typename Kernel::Point_3
operator[](int i) const {
return interval_to_double(inodes[i]);
}
const typename Ikernel::Point_3&
interval_node(int i) const {
return inodes[i];
}
typename Ikernel::Point_3
to_interval(const typename Kernel::Point_3& p) const {
return double_to_interval(p);
}
const Exact_kernel::Point_3
exact_node(int i) const {
return enodes[i];
}
typename Exact_kernel::Point_3
to_exact(const typename Kernel::Point_3& p) const {
return double_to_exact(p);
}
size_t size() const {return enodes.size();}
void add_new_node(const Exact_kernel::Point_3& p){
const Ikernel::Point_3& p_approx=p.approx();
if ( !has_smaller_relative_precision(p_approx.x(),Lazy_exact_nt<typename Exact_kernel::FT>::get_relative_precision_of_to_double()) ||
!has_smaller_relative_precision(p_approx.y(),Lazy_exact_nt<typename Exact_kernel::FT>::get_relative_precision_of_to_double()) ||
!has_smaller_relative_precision(p_approx.z(),Lazy_exact_nt<typename Exact_kernel::FT>::get_relative_precision_of_to_double()) ) p.exact();
enodes.push_back(p);
inodes.push_back( exact_to_interval(p) );
}
void add_new_node(Halfedge_handle edge,Facet_handle facet)
{
add_new_node( compute_triangle_segment_intersection_point<Polyhedron,Kernel>(edge,facet,ek,ppmap) );
}
//the point is an input
void add_new_node(const typename Kernel::Point_3& p){
enodes.push_back(to_exact(p));
inodes.push_back( double_to_interval(p) );
}
}; // end specialization
// Triangle_segment_intersection_points<Polyhedron,Kernel,Predicates_on_constructions,false>
//Third specialization: The kernel already has exact constructions.
template <class Polyhedron,class PolyhedronPointPMap,class Kernel,class Node_storage>
class Triangle_segment_intersection_points<Polyhedron,PolyhedronPointPMap,Kernel,Node_storage,true>
{
//typedefs
typedef std::vector <typename Kernel::Point_3> Nodes_vector;
typedef typename Polyhedron::Halfedge_const_handle Halfedge_handle;
typedef typename Polyhedron::Facet_const_handle Facet_handle;
//members
Nodes_vector nodes;
Kernel k;
PolyhedronPointPMap ppmap;
public:
typedef Kernel Ikernel;
typedef Kernel Exact_kernel;
typedef void* Protector;
Triangle_segment_intersection_points(PolyhedronPointPMap ppmap):
ppmap(ppmap){}
const typename Kernel::Point_3&
operator[](int i) const {
return nodes[i];
}
size_t size() const {return nodes.size();}
const typename Kernel::Point_3& exact_node(int i) const {return nodes[i];}
const typename Kernel::Point_3& interval_node(int i) const {return nodes[i];}
//add a new node in the final graph.
//it is the intersection of the triangle with the segment
void add_new_node(Halfedge_handle edge,Facet_handle facet)
{
nodes.push_back (
compute_triangle_segment_intersection_point<Polyhedron,Kernel>(edge,facet,k,ppmap)
);
}
void add_new_node(const typename Kernel::Point_3& p)
{
nodes.push_back(p);
}
const typename Kernel::Point_3& to_interval(const typename Kernel::Point_3& p) const { return p; }
const typename Kernel::Point_3& to_exact(const typename Kernel::Point_3& p) const { return p; }
}; // end specialization
// Triangle_segment_intersection_points<Polyhedron,Kernel,Node_storage,true>
}
#ifdef CGAL_COREFINEMENT_DO_REPORT_SELF_INTERSECTIONS
struct Intersection_of_Polyhedra_3_self_intersection_exception
: public std::logic_error
{
Intersection_of_Polyhedra_3_self_intersection_exception()
: std::logic_error("Self-intersection found in the facets involved in the intersection")
{}
};
#endif
//TODO an important requirement is that the Polyhedron should be based on a list-based
//HDS. We use a lot of maps that use the address of Facet,Halfedge and a reallocation would
//be dramatic.
template< class Polyhedron,
class Kernel_=Default,
class Node_visitor_=Default,
class Node_storage_type_=Default,
class Use_const_polyhedron_=Default,
class PolyhedronPointPMap_=Default
>
class Intersection_of_Polyhedra_3{
//Default template parameters
typedef typename Default::Get<Node_visitor_, Empty_node_visitor<Polyhedron> >::type Node_visitor;
typedef typename Default::Get<Node_storage_type_, typename Node_visitor::Node_storage_type >::type Node_storage_type;
typedef typename Default::Get<PolyhedronPointPMap_, Default_polyhedron_ppmap<Polyhedron> > ::type PolyhedronPointPMap;
typedef typename Default::Get<Use_const_polyhedron_, typename Node_visitor::Is_polyhedron_const >::type Use_const_polyhedron;
typedef typename Default::Get<Kernel_, typename Kernel_traits< typename boost::property_traits<PolyhedronPointPMap>::value_type >::Kernel >::type Kernel;
//typedefs
typedef typename Kernel::Triangle_3 Triangle;
typedef typename Kernel::Segment_3 Segment;
typedef internal_IOP::
Polyhedron_types<Polyhedron,Use_const_polyhedron> Polyhedron_types;
typedef typename Polyhedron_types::Polyhedron_ref Polyhedron_ref;
typedef typename Polyhedron_types::Halfedge_handle Halfedge_handle;
typedef typename Polyhedron_types::Halfedge_iterator Halfedge_iterator;
typedef typename Polyhedron_types::Facet_iterator Facet_iterator;
typedef typename Polyhedron_types::Facet_handle Facet_handle;
typedef typename Polyhedron_types::Vertex_handle Vertex_handle;
typedef typename Polyhedron_types::Vertex Vertex;
typedef typename Polyhedron_types::Facet Facet;
typedef CGAL::Box_intersection_d::Box_with_handle_d<
double, 3, Halfedge_handle> Box;
typedef std::pair<Facet_handle,Facet_handle> Facet_pair;
typedef std::pair<Facet_pair,int> Facet_pair_and_int;
typedef internal_IOP::
Compare_handles<Polyhedron,Use_const_polyhedron> Compare_handles;
typedef internal_IOP::
Compare_handle_pairs<Polyhedron,Use_const_polyhedron> Compare_handle_pairs;
typedef std::map<Facet_pair_and_int, //we use Facet_pair_and_int and not Facet_pair to handle coplanar case.
std::set<int>,Compare_handle_pairs> Facets_to_nodes_map;//Indeed the boundary of the intersection of two coplanar triangles may contain several segments.
typedef std::set<Facet_pair,Compare_handle_pairs> Coplanar_facets_set;//any insertion should be done with make_sorted_pair_of_facets
typedef typename Kernel::Point_3 Node;
typedef internal_IOP::Triangle_segment_intersection_points
<Polyhedron,PolyhedronPointPMap,Kernel,Node_storage_type> Nodes_vector;
typedef typename internal_IOP::
Intersection_types<Polyhedron,Use_const_polyhedron>
::Intersection_result Intersection_result;
typedef std::set<Facet_handle,Compare_handles> Facet_set;
typedef std::map
<Halfedge_handle,Facet_set,Compare_handles> Edge_to_intersected_facets;
#ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
typedef std::set<Facet_pair,Compare_handle_pairs> Coplanar_duplicated_intersection_set;
#endif
//member data
PolyhedronPointPMap ppmap;
//helper functions
static inline Facet_pair
make_sorted_pair_of_facets(Facet_handle fh1,Facet_handle fh2) {
const Facet* f1=&(*fh1);
const Facet* f2=&(*fh2);
if (f1 < f2)
return Facet_pair(fh1,fh2);
return Facet_pair(fh2,fh1);
}
static inline Facet_pair_and_int
make_sorted_pair_of_facets_with_int(Facet_handle fh1,Facet_handle fh2,int i) {
return std::make_pair(make_sorted_pair_of_facets(fh1,fh2),i);
}
static inline std::pair<void*,void*> make_sorted_void_pair(void* v1,void* v2){
if (v1<v2) return std::make_pair(v1,v2);
return std::make_pair(v2,v1);
}
static inline Halfedge_handle smaller_handle(Halfedge_handle h){
if ( &(*h)<&(*h->opposite()) ) return h;
return h->opposite();
}
//member variables
Edge_to_intersected_facets edge_to_sfacet; //Associate a segment to a filtered set of facets that may be intersected
Facets_to_nodes_map f_to_node; //Associate a pair of triangle to their intersection points
Coplanar_facets_set coplanar_facets;//Contains all pairs of triangular facets intersecting that are coplanar
Nodes_vector nodes; //Contains intersection points of polyhedra
Node_visitor* visitor;
bool is_default_visitor; //indicates whether the visitor need to be deleted
#ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
//this does not occur only when one extremity of an edge is inside a face.
// The problem occur every time an edge or a part of an edge with two incident triangles
// is on the intersection polyline, I choose to direcly filter the output by removing duplicated edges
Coplanar_duplicated_intersection_set coplanar_duplicated_intersection;//Set containing edges that are duplicated because of edges (partially) included in a triangle
#endif
//functions that should come from a traits class
bool has_at_least_two_incident_faces(Halfedge_handle edge)
{
return !edge->is_border_edge();
}
template <class Output_iterator>
void get_incident_facets(Halfedge_handle edge,Output_iterator out){
if (!edge->is_border()) *out++=edge->facet();
if (!edge->opposite()->is_border()) *out++=edge->opposite()->facet();
}
template <class Output_iterator>
void get_incident_edges_to_vertex(Halfedge_handle edge,Output_iterator out){
Halfedge_handle current=edge;
do{
*out++=current;
current=current->next()->opposite();
}
while(current!=edge);
}
//internal functions
class Map_edge_facet_bbox_intersection {
Edge_to_intersected_facets& edge_to_sfacet;
Polyhedron_ref polyhedron_triangle;
Polyhedron_ref polyhedron_edge;
Node_visitor& visitor;
public:
Map_edge_facet_bbox_intersection(Edge_to_intersected_facets& map_,
Polyhedron_ref P,
Polyhedron_ref Q,
Node_visitor& visitor_)
:edge_to_sfacet(map_),polyhedron_triangle(P),polyhedron_edge(Q),visitor(visitor_){}
void operator()( const Box* fb, const Box* eb) const {
Halfedge_handle fh = fb->handle();
Halfedge_handle eh = eb->handle();
// The following call to map::insert() attempts an insertion of a pair
// into 'edge_to_sfacet'. If 'eh' is already inserted in the map,
// then the result 'res' is the current entry in the map for 'eh'.
typename Edge_to_intersected_facets::iterator res=
edge_to_sfacet.insert(std::make_pair(eh,Facet_set())).first;
res->second.insert(fh->facet());
// That could have been shortened to:
//
// edge_to_sfacet[eh].insert(fh->facet())
//
// -- Laurent Rineau, 2012/11/01
visitor.add_filtered_intersection(eh,fh,polyhedron_edge,polyhedron_triangle);
}
};
class Map_edge_facet_bbox_intersection_extract_coplanar {
Edge_to_intersected_facets& edge_to_sfacet;
Coplanar_facets_set& coplanar_facets;
Polyhedron_ref polyhedron_triangle;
Polyhedron_ref polyhedron_edge;
Node_visitor& visitor;
PolyhedronPointPMap ppmap;
public:
Map_edge_facet_bbox_intersection_extract_coplanar(
Edge_to_intersected_facets& map_,
Coplanar_facets_set& coplanar_facets_,
Polyhedron_ref P,
Polyhedron_ref Q,
Node_visitor& visitor_,
PolyhedronPointPMap ppmap)
:edge_to_sfacet(map_),coplanar_facets(coplanar_facets_),polyhedron_triangle(P),polyhedron_edge(Q),visitor(visitor_),ppmap(ppmap)
{}
void operator()( const Box* fb, const Box* eb) const {
Halfedge_handle fh = fb->handle(); //handle for the face
Halfedge_handle eh = eb->handle(); //handle for the edge
if(eh->is_border()) eh = eh->opposite();
CGAL_assertion(!eh->is_border());
//check if the segment intersects the plane of the facet or if it is included in the plane
const typename Kernel::Point_3 & a = get(ppmap, fh->vertex());
const typename Kernel::Point_3 & b = get(ppmap, fh->next()->vertex());
const typename Kernel::Point_3 & c = get(ppmap, fh->next()->next()->vertex());
const Orientation abcp = orientation(a,b,c, get(ppmap, eh->vertex()));
const Orientation abcq = orientation(a,b,c, get(ppmap, eh->opposite()->vertex()));
if (abcp==abcq){
if (abcp!=COPLANAR){
// std::cout << "rejected " << &(*fh->facet()) << "{" << &(*eh->facet()) << " " <<&(*eh->opposite()->facet()) << " "<< get(ppmap, eh->vertex()) << " " << get(eh->opposite()->vertex()) << "}" <<std::endl;
return; //no intersection
}
//WARNING THIS IS DONE ONLY FOR POLYHEDRON (MAX TWO INCIDENT FACETS TO EDGE)
if (/* !eh->is_border() && */ orientation(a,b,c,get(ppmap, eh->next()->vertex()))==COPLANAR){
coplanar_facets.insert(make_sorted_pair_of_facets(eh->facet(),fh->facet()));
}
if (!eh->opposite()->is_border() && orientation(a,b,c,get(ppmap, eh->opposite()->next()->vertex()))==COPLANAR){
coplanar_facets.insert(make_sorted_pair_of_facets(eh->opposite()->facet(),fh->facet()));
}
visitor.add_filtered_intersection(eh,fh,polyhedron_edge,polyhedron_triangle);
//in case only the edge is coplanar, the intersection points will be detected using an incident facet
//(see remark at the beginning of the file)
return;
}
typename Edge_to_intersected_facets::iterator res=
edge_to_sfacet.insert(std::make_pair(eh,Facet_set())).first;
res->second.insert(fh->facet());
visitor.add_filtered_intersection(eh,fh,polyhedron_edge,polyhedron_triangle);
}
};
class Map_edge_facet_bbox_intersection_extract_coplanar_filter_self_intersections {
Polyhedron_ref polyhedron_triangle;
Polyhedron_ref polyhedron_edge;
std::set<Facet_handle>& m_reported_facets;
std::vector<std::pair<const Box*,const Box*> >& m_intersecting_bboxes;
PolyhedronPointPMap ppmap;
public:
Map_edge_facet_bbox_intersection_extract_coplanar_filter_self_intersections(
Polyhedron_ref P,
Polyhedron_ref Q,
std::set<Facet_handle>& reported_facets,
std::vector<std::pair<const Box*,const Box*> >& intersecting_bboxes,
PolyhedronPointPMap ppmap
)
: polyhedron_triangle(P)
, polyhedron_edge(Q)
, m_reported_facets(reported_facets)
, m_intersecting_bboxes(intersecting_bboxes)
, ppmap(ppmap)
{}
void operator()( const Box* fb, const Box* eb) {
m_reported_facets.insert( fb->handle()->facet() );
m_intersecting_bboxes.push_back( std::make_pair(fb, eb) );
}
bool self_intersections_found()
{
try{
typedef typename CGAL::Box_intersection_d::Box_with_info_d<double, 3, Facet_handle> Box;
// make one box per facet
std::vector<Box> boxes;
boxes.reserve(m_reported_facets.size());
BOOST_FOREACH(Facet_handle fh, m_reported_facets)
{
boxes.push_back( Box( fh->halfedge()->vertex()->point().bbox() +
fh->halfedge()->next()->vertex()->point().bbox() +
fh->halfedge()->opposite()->vertex()->point().bbox(), fh )
);
}
// generate box pointers
std::vector<const Box*> box_ptr;
box_ptr.reserve(boxes.size());
typename std::vector<Box>::iterator b;
for(b = boxes.begin();
b != boxes.end();
b++)
box_ptr.push_back(&*b);
// compute self-intersections filtered out by boxes
typedef boost::function_output_iterator<internal::Throw_at_output> OutputIterator;
OutputIterator out;
internal::Intersect_facets<Polyhedron,Kernel,
Box,OutputIterator,
PolyhedronPointPMap>
intersect_facets(polyhedron_triangle, out, ppmap, Kernel());
std::ptrdiff_t cutoff = 2000;
CGAL::box_self_intersection_d(box_ptr.begin(), box_ptr.end(),intersect_facets,cutoff);
return false;
}
catch( internal::Throw_at_output::Throw_at_output_exception& )
{
return true;
}
}
};
// This function tests the intersection of the faces of P with the edges of Q
void filter_intersections( Polyhedron_ref P, Polyhedron_ref Q) {
std::vector<Box> facet_boxes, edge_boxes;
facet_boxes.reserve( P.size_of_facets());
for ( Facet_iterator i = P.facets_begin(); i != P.facets_end(); ++i){
facet_boxes.push_back(
Box( get(ppmap, i->halfedge()->vertex()).bbox()
+ get(ppmap, i->halfedge()->next()->vertex()).bbox()
+ get(ppmap, i->halfedge()->next()->next()->vertex()).bbox(),
i->halfedge()));
}
std::vector<const Box*> facet_box_ptr;
facet_box_ptr.reserve( P.size_of_facets());
for ( typename std::vector<Box>::iterator j = facet_boxes.begin(); j != facet_boxes.end(); ++j){
facet_box_ptr.push_back( &*j);
}
for ( Halfedge_iterator i = Q.halfedges_begin(); i != Q.halfedges_end(); ++i){
if(&*i < &*(i->opposite())){
edge_boxes.push_back(
Box( get(ppmap, i->vertex()).bbox()
+ get(ppmap, i->opposite()->vertex()).bbox(),
i));
}
}
std::vector<const Box*> edge_box_ptr;
edge_box_ptr.reserve( Q.size_of_halfedges()/2);
for ( typename std::vector<Box>::iterator j = edge_boxes.begin(); j != edge_boxes.end(); ++j){
edge_box_ptr.push_back( &*j);
}
#ifdef CGAL_COREFINEMENT_DO_REPORT_SELF_INTERSECTIONS
// this version first collect faces involved in the intersection and first
// check if they are involved in a self-intersection.
std::set<Facet_handle> reported_facets;
std::vector<std::pair<const Box*,const Box*> > intersecting_bboxes;
Map_edge_facet_bbox_intersection_extract_coplanar_filter_self_intersections
inter_functor4selfi(P, Q, reported_facets, intersecting_bboxes, ppmap);
CGAL::box_intersection_d( facet_box_ptr.begin(), facet_box_ptr.end(),
edge_box_ptr.begin(), edge_box_ptr.end(),
inter_functor4selfi, std::ptrdiff_t(2000) );
if (inter_functor4selfi.self_intersections_found()) throw Intersection_of_Polyhedra_3_self_intersection_exception();
#ifdef DO_NOT_HANDLE_COPLANAR_FACETS
Map_edge_facet_bbox_intersection inter_functor(edge_to_sfacet,P,Q,*visitor);
#else // not DO_NOT_HANDLE_COPLANAR_FACETS
Map_edge_facet_bbox_intersection_extract_coplanar inter_functor(edge_to_sfacet,coplanar_facets,P,Q,*visitor,ppmap);
#endif // not DO_NOT_HANDLE_COPLANAR_FACETS
typedef std::pair<const Box*,const Box*> Type_pair;
BOOST_FOREACH(const Type_pair& p, intersecting_bboxes)
inter_functor(p.first, p.second);
#else
CGAL::box_intersection_d( facet_box_ptr.begin(), facet_box_ptr.end(),
edge_box_ptr.begin(), edge_box_ptr.end(),
#ifdef DO_NOT_HANDLE_COPLANAR_FACETS
// Note that 'edge_to_sfacet' is passed by
// non-const reference, here, to be filled.
Map_edge_facet_bbox_intersection(edge_to_sfacet,P,Q,*visitor),
#else // not DO_NOT_HANDLE_COPLANAR_FACETS
Map_edge_facet_bbox_intersection_extract_coplanar(edge_to_sfacet,coplanar_facets,P,Q,*visitor,ppmap),
#endif // not DO_NOT_HANDLE_COPLANAR_FACETS
std::ptrdiff_t(2000)
);
#endif
}
void add_intersection_point_to_facet_and_all_edge_incident_facets(Facet_handle facet,
Halfedge_handle edge,
int node_id)
{
std::vector<Facet_handle> incident_facets;
get_incident_facets(edge,std::back_inserter(incident_facets));
for (typename std::vector<Facet_handle>::iterator it=incident_facets.begin();
it!=incident_facets.end();++it)
{
CGAL_assertion(cgal_do_intersect_debug(facet,*it));
Facet_pair facet_pair = make_sorted_pair_of_facets(facet,*it);
if ( !coplanar_facets.empty() && coplanar_facets.find(facet_pair)!=coplanar_facets.end() ) continue;
typename Facets_to_nodes_map::iterator it_list=
f_to_node.insert( std::make_pair( Facet_pair_and_int(facet_pair,0),std::set<int>()) ).first;
it_list->second.insert(node_id);
}
}
void cip_handle_case_edge(int node_id,
Facet_set* fset,
Halfedge_handle edge,
Halfedge_handle edge_intersected)
{
//associate the intersection point to all facets incident to the intersected edge using edge
std::vector<Facet_handle> incident_facets;
get_incident_facets(edge_intersected,std::back_inserter(incident_facets));
for (typename std::vector<Facet_handle>::iterator it=incident_facets.begin();
it!=incident_facets.end();++it)
{
add_intersection_point_to_facet_and_all_edge_incident_facets(*it,edge,node_id);
if (fset!=NULL) fset->erase(*it);
}
incident_facets.clear();
//associate the intersection point to all facets incident to edge using the intersected edge
//at least one pair of facets is already handle above
typename Edge_to_intersected_facets::iterator it_fset=edge_to_sfacet.find(edge_intersected);
if (it_fset==edge_to_sfacet.end()) return;
Facet_set& fset_bis=it_fset->second;
get_incident_facets(edge,std::back_inserter(incident_facets));
for (typename std::vector<Facet_handle>::iterator it=incident_facets.begin();
it!=incident_facets.end();++it)
{
// add_intersection_point_to_facet_and_all_edge_incident_facets(*it,edge_intersected,node_id); //this call is not needed, already done in the first loop
fset_bis.erase(*it);
}
}
void cip_handle_case_vertex(int node_id,
Facet_set* fset,
Halfedge_handle edge,
Halfedge_handle vertex_intersected)
{
std::vector<Halfedge_handle> incident_halfedges;
get_incident_edges_to_vertex(vertex_intersected,std::back_inserter(incident_halfedges));
for (typename std::vector<Halfedge_handle>::iterator
it=incident_halfedges.begin();it!=incident_halfedges.end();++it)
{
cip_handle_case_edge(node_id,fset,edge,*it);
}
}
//add a new node in the final graph.
//it is the intersection of the triangle with the segment
void add_new_node(Halfedge_handle edge,
Facet_handle facet,
const Intersection_result& inter_res,
Nodes_vector& nodes)
{
bool is_vertex_coplanar = CGAL::cpp11::get<2>(inter_res);
if (is_vertex_coplanar)
nodes.add_new_node(get(ppmap, edge->vertex()));
else{
bool is_opposite_vertex_coplanar = CGAL::cpp11::get<3>(inter_res);
if (is_opposite_vertex_coplanar)
nodes.add_new_node(get(ppmap, edge->opposite()->vertex()));
else
nodes.add_new_node(edge,facet);
}
}
//either the exact or input point can be used to create a node
//with this function
template<class Point>
void add_new_node(const Point& pt)
{
nodes.add_new_node(pt);
}
#ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
void check_coplanar_edge(Halfedge_handle hedge,Facet_handle facet)
{
const typename Kernel::Point_3& p0=get(ppmap, facet->halfedge()->vertex());
const typename Kernel::Point_3& p1=get(ppmap, facet->halfedge()->next()->vertex());
const typename Kernel::Point_3& p2=get(ppmap, facet->halfedge()->opposite()->vertex());
CGAL_precondition( orientation( p0,p1,p2,get(ppmap, hedge->vertex()) ) == COPLANAR );
if ( has_at_least_two_incident_faces(hedge) && orientation( p0,p1,p2,get(ppmap, hedge->opposite()->vertex()) ) == COPLANAR )
{
//In case two facets are incident along such this edge, the intersection
//will be reported twice. We keep track of this so that at the end, we can remove one intersecting edge out of the two
//choose the smaller of the two faces (only one need to de deleted)
Facet_handle smaller=make_sorted_pair_of_facets(hedge->face(),hedge->opposite()->face()).first;
coplanar_duplicated_intersection.insert(make_sorted_pair_of_facets(smaller,facet));
}
}
bool are_incident_facets_coplanar(Halfedge_handle hedge){
const typename Kernel::Point_3& p0=get(ppmap, hedge->vertex());
const typename Kernel::Point_3& p1=get(ppmap, hedge->next()->vertex());
const typename Kernel::Point_3& p2=get(ppmap, hedge->opposite()->vertex());
const typename Kernel::Point_3& p3=get(ppmap, hedge->opposite()->next()->vertex());
return orientation( p0,p1,p2,p3 ) == COPLANAR;
}
void check_coplanar_edge(Halfedge_handle hedge,Halfedge_handle additional_edge,internal_IOP::Intersection_type type)
{
switch(type){
case internal_IOP::FACET:
check_coplanar_edge(hedge,additional_edge->face());
break;
case internal_IOP::EDGE:
if ( !additional_edge->is_border() ){
check_coplanar_edge(hedge,additional_edge->face());
}
if (!additional_edge->opposite()->is_border())
check_coplanar_edge(hedge,additional_edge->opposite()->face());
break;
case internal_IOP::VERTEX:
{
//consider all incident faces
Halfedge_handle current=additional_edge;
do{
if( !current->is_border() )
check_coplanar_edge(hedge,current->face());
current=current->next()->opposite();
}
while(current!=additional_edge);
}
break;
default:
CGAL_assertion(type==internal_IOP::COPLNR);
break;
}
}
void check_coplanar_edge_old(Halfedge_handle hedge,Halfedge_handle additional_edge,internal_IOP::Intersection_type type)
{
switch(type){
case internal_IOP::FACET:
check_coplanar_edge(hedge,additional_edge->face());
break;
case internal_IOP::EDGE:
{
if ( !additional_edge->is_border() ){
if (!additional_edge->opposite()->is_border()){
if ( are_incident_facets_coplanar(additional_edge) )
{
Facet_handle facet=additional_edge->face();
const typename Kernel::Point_3& p0=get(ppmap, facet->halfedge()->vertex());
const typename Kernel::Point_3& p1=get(ppmap, facet->halfedge()->next()->vertex());
const typename Kernel::Point_3& p2=get(ppmap, facet->halfedge()->opposite()->vertex());
CGAL_precondition( orientation( p0,p1,p2, get(ppmap, hedge->vertex()) ) == COPLANAR );
if ( has_at_least_two_incident_faces(hedge) && orientation( p0,p1,p2, get(ppmap, hedge->opposite()->vertex()) ) == COPLANAR )
{
//In case two facets are incident along a common edge of two coplanar triangles.
//We need to remove three out of the four reported pair
Facet_handle smaller=make_sorted_pair_of_facets(hedge->face(),hedge->opposite()->face()).first;
coplanar_duplicated_intersection.insert(make_sorted_pair_of_facets(hedge->face(),facet));
coplanar_duplicated_intersection.insert(make_sorted_pair_of_facets(hedge->opposite()->face(),facet));
coplanar_duplicated_intersection.insert(make_sorted_pair_of_facets(hedge->opposite()->face(),additional_edge->opposite()->face()));
}
}
else
{
check_coplanar_edge(hedge,additional_edge->face());
check_coplanar_edge(hedge,additional_edge->opposite()->face());
}
}
else
check_coplanar_edge(hedge,additional_edge->face());
}
else{
CGAL_assertion(!additional_edge->opposite()->is_border());
check_coplanar_edge(hedge,additional_edge->opposite()->face());
}
}
break;
case internal_IOP::VERTEX:
break;
default:
CGAL_assertion(type==internal_IOP::COPLNR);
break;
}
}
template <class Hedge_iterator>
void check_coplanar_edges(Hedge_iterator begin,Hedge_iterator end,Halfedge_handle additional_edge,internal_IOP::Intersection_type type)
{
for (Hedge_iterator it=begin;it!=end;++it)
check_coplanar_edge(*it,additional_edge,type);
}
#endif // USE_DETECTION_MULTIPLE_DEFINED_EDGES
void print_type_debug(internal_IOP::Intersection_type type,bool cpl,bool opp_cpl)
{
switch(type){
case internal_IOP::COPLNR:
std::cout << "COPLNR " << cpl << " " << opp_cpl << std::endl;
break;
case internal_IOP::EMPTY:
std::cout << "EMPTY " << cpl << " " << opp_cpl << std::endl;
break;
case internal_IOP::FACET:
std::cout << "FACET " << cpl << " " << opp_cpl << std::endl;
break;
case internal_IOP::EDGE:
std::cout << "EDGE " << cpl << " " << opp_cpl << std::endl;
break;
case internal_IOP::VERTEX:
std::cout << "VERTEX " << cpl << " " << opp_cpl << std::endl;
break;
}
}
void handle_coplanar_case_VERTEX_FACET(Halfedge_handle vertex,Halfedge_handle facet,int node_id, bool is_new_node){
if (is_new_node)
visitor->new_node_added(node_id,internal_IOP::FACET,vertex,facet,true,false);
std::vector<Halfedge_handle> all_edges;
get_incident_edges_to_vertex(vertex,std::back_inserter(all_edges));
typename std::vector<Halfedge_handle>::iterator it_edge=all_edges.begin();
for (;it_edge!=all_edges.end();++it_edge){
add_intersection_point_to_facet_and_all_edge_incident_facets(facet->facet(),*it_edge,node_id);
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(*it_edge);
if (it_ets!=edge_to_sfacet.end()) it_ets->second.erase(facet->facet());
}
}
void handle_coplanar_case_VERTEX_EDGE(Halfedge_handle vertex,Halfedge_handle edge,int node_id, bool is_new_node){
if(is_new_node)
visitor->new_node_added(node_id,internal_IOP::VERTEX,edge,vertex,false,false);
std::vector<Halfedge_handle> all_edges;
get_incident_edges_to_vertex(vertex,std::back_inserter(all_edges));
typename std::vector<Halfedge_handle>::iterator it_edge=all_edges.begin();
for (;it_edge!=all_edges.end();++it_edge){
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(*it_edge);
Facet_set* fset = (it_ets!=edge_to_sfacet.end())?&(it_ets->second):NULL;
cip_handle_case_edge(node_id,fset,*it_edge,edge);
}
}
void handle_coplanar_case_VERTEX_VERTEX(Halfedge_handle vertex1,Halfedge_handle vertex2,int node_id, bool is_new_node){
if (is_new_node)
visitor->new_node_added(node_id,internal_IOP::VERTEX,vertex2,vertex1,true,false);
std::vector<Halfedge_handle> all_edges;
get_incident_edges_to_vertex(vertex1,std::back_inserter(all_edges));
typename std::vector<Halfedge_handle>::iterator it_edge=all_edges.begin();
for (;it_edge!=all_edges.end();++it_edge){
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(*it_edge);
Facet_set* fset = (it_ets!=edge_to_sfacet.end())?&(it_ets->second):NULL;
cip_handle_case_vertex(node_id,fset,*it_edge,vertex2);
}
}
template<class Cpl_inter_pt,class Coplanar_node_map>
std::pair<int,bool> get_or_create_node(Cpl_inter_pt& ipt,int& current_node,Coplanar_node_map& coplanar_node_map){
void *v1, *v2;
switch(ipt.type_1){
case internal_IOP::VERTEX: v1=(void*)( &(*(ipt.info_1->vertex())) ); break;
case internal_IOP::EDGE : v1=(void*)( &(*smaller_handle(ipt.info_1)) ); break;
case internal_IOP::FACET : v1=(void*)( &(*(ipt.info_1->facet())) ); break;
default: CGAL_error_msg("Should not get there!");
}
switch(ipt.type_2){
case internal_IOP::VERTEX: v2=(void*)( &(*(ipt.info_2->vertex())) ); break;
case internal_IOP::EDGE : v2=(void*)( &(*smaller_handle(ipt.info_2)) ); break;
case internal_IOP::FACET : v2=(void*)( &(*(ipt.info_2->facet())) ); break;
default: CGAL_error_msg("Should not get there!");
}
std::pair<void*,void*> key=make_sorted_void_pair(v1,v2);
std::pair<typename Coplanar_node_map::iterator,bool> res=coplanar_node_map.insert(std::make_pair(key,current_node+1));
if (res.second){ //insert a new node
if (ipt.type_1==internal_IOP::VERTEX)
add_new_node(get(ppmap, ipt.info_1->vertex()));
else{
if(ipt.type_2==internal_IOP::VERTEX)
add_new_node(get(ppmap, ipt.info_2->vertex()));
else
add_new_node(ipt.point);
}
return std::pair<int,bool>(++current_node, true);
}
return std::pair<int,bool>(res.first->second, false);
}
void compute_intersection_of_coplanar_facets(int& current_node){
typedef std::map<std::pair<void*,void*>,int> Coplanar_node_map;
Coplanar_node_map coplanar_node_map;
for (typename Coplanar_facets_set::iterator it=coplanar_facets.begin();it!=coplanar_facets.end();++it){
Facet_handle f1=it->first;
Facet_handle f2=it->second;
typedef internal_IOP::Intersection_point_with_info<Kernel,Halfedge_handle,PolyhedronPointPMap> Cpl_inter_pt;
std::list<Cpl_inter_pt> inter_pts;
internal_IOP::intersection_coplanar_facets<Kernel>(f1->halfedge(),f2->halfedge(),ppmap,inter_pts);
// std::cout << "found " << inter_pts.size() << " inter pts: ";
std::size_t nb_pts=inter_pts.size();
if (inter_pts.empty()) continue;
std::vector<int> cpln_nodes; cpln_nodes.reserve(nb_pts);
for (typename std::list<Cpl_inter_pt>::iterator iti=inter_pts.begin();iti!=inter_pts.end();++iti){
#ifdef CGAL_COREFINEMENT_DEBUG
//iti->print_debug();
#endif
CGAL_assertion(iti->is_valid());
int node_id;
bool is_new_node;
cpp11::tie(node_id, is_new_node)=get_or_create_node(*iti,current_node,coplanar_node_map);
cpln_nodes.push_back(node_id);
switch(iti->type_1){
case internal_IOP::VERTEX:
{
switch(iti->type_2){
case internal_IOP::VERTEX: handle_coplanar_case_VERTEX_VERTEX(iti->info_1,iti->info_2,node_id, is_new_node); break;
case internal_IOP::EDGE : handle_coplanar_case_VERTEX_EDGE(iti->info_1,iti->info_2,node_id, is_new_node); break;
case internal_IOP::FACET : handle_coplanar_case_VERTEX_FACET(iti->info_1,iti->info_2,node_id, is_new_node); break;
default: CGAL_error_msg("Should not get there!");
}
}
break;
case internal_IOP::EDGE:{
switch(iti->type_2){
case internal_IOP::VERTEX:handle_coplanar_case_VERTEX_EDGE(iti->info_2,iti->info_1,node_id, is_new_node);break;
case internal_IOP::EDGE:
{
if (is_new_node)
visitor->new_node_added(node_id,internal_IOP::EDGE,iti->info_1,iti->info_2,false,false);
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(iti->info_1);
Facet_set* fset = (it_ets!=edge_to_sfacet.end())?&(it_ets->second):NULL;
cip_handle_case_edge(node_id,fset,iti->info_1,iti->info_2);
}
break;
default: CGAL_error_msg("Should not get there!");
}
}
break;
case internal_IOP::FACET:
{
CGAL_assertion(iti->type_2==internal_IOP::VERTEX);
handle_coplanar_case_VERTEX_FACET(iti->info_2,iti->info_1,node_id, is_new_node);
}
break;
default: CGAL_error_msg("Should not get there!");
}
}
switch (nb_pts){
case 0: break;
case 1:
{
typename Facets_to_nodes_map::iterator it_list=
f_to_node.insert( std::make_pair( Facet_pair_and_int(*it,1),std::set<int>()) ).first;
it_list->second.insert(cpln_nodes[0]);
}
break;
default:
{
int i=0;
std::size_t stop=nb_pts + (nb_pts<3?-1:0);
for (std::size_t k=0;k<stop;++k){
typename Facets_to_nodes_map::iterator it_list=
f_to_node.insert( std::make_pair( Facet_pair_and_int(*it,++i),std::set<int>()) ).first;
it_list->second.insert( cpln_nodes[k] );
it_list->second.insert( cpln_nodes[(k+1)%nb_pts] );
}
}
}
// std::cout << std::endl;
}
}
void compute_intersection_points(int& current_node){
for(typename Edge_to_intersected_facets::iterator it=edge_to_sfacet.begin();it!=edge_to_sfacet.end();++it){
Halfedge_handle edge=it->first;
Facet_set& fset=it->second;
while (!fset.empty()){
Facet_handle facet=*fset.begin();
Intersection_result res=internal_IOP::do_intersect<Polyhedron,Kernel,Use_const_polyhedron>(edge,facet,ppmap);
internal_IOP::Intersection_type type=CGAL::cpp11::get<0>(res);
//handle degenerate case: one extremity of edge below to facet
std::vector<Halfedge_handle> all_edges;
if ( CGAL::cpp11::get<2>(res) )
get_incident_edges_to_vertex(edge,std::back_inserter(all_edges));
else{
if ( CGAL::cpp11::get<3>(res) )
get_incident_edges_to_vertex(edge->opposite(),std::back_inserter(all_edges));
else
all_edges.push_back(edge);
}
CGAL_precondition(*all_edges.begin()==edge || *all_edges.begin()==edge->opposite());
// print_type_debug(type,CGAL::cpp11::get<2>(res),CGAL::cpp11::get<3>(res));
#ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
check_coplanar_edges(boost::next(all_edges.begin()),all_edges.end(),CGAL::cpp11::get<1>(res),type);
#endif
typename std::vector<Halfedge_handle>::iterator it_edge=all_edges.begin();
switch(type){
case internal_IOP::COPLNR:
#ifndef DO_NOT_HANDLE_COPLANAR_FACETS
assert(!"COPLNR : this point should never be reached!");
#else
//nothing need to be done, cf. comments at the beginning of the file
#endif
break;
case internal_IOP::EMPTY:
fset.erase(fset.begin());
CGAL_assertion(!cgal_do_intersect_debug(edge,facet));
break;
// Case when the edge pierces the facet in its interior.
case internal_IOP::FACET:
{
CGAL_assertion(cgal_do_intersect_debug(edge,facet));
CGAL_assertion(facet==CGAL::cpp11::get<1>(res)->face());
int node_id=++current_node;
add_new_node(edge,facet,res,nodes);
visitor->new_node_added(node_id,internal_IOP::FACET,edge,facet->halfedge(),CGAL::cpp11::get<2>(res),CGAL::cpp11::get<3>(res));
for (;it_edge!=all_edges.end();++it_edge){
add_intersection_point_to_facet_and_all_edge_incident_facets(facet,*it_edge,node_id);
//erase facet from the list to test intersection with it_edge
if ( it_edge==all_edges.begin() )
fset.erase(fset.begin());
else
{
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(*it_edge);
if(it_ets!=edge_to_sfacet.end()) it_ets->second.erase(facet);
}
}
} // end case FACET
break;
// Case when the edge intersect one edge of the facet.
case internal_IOP::EDGE:
{
CGAL_assertion(cgal_do_intersect_debug(edge,facet));
int node_id=++current_node;
add_new_node(edge,facet,res,nodes);
Halfedge_handle edge_intersected=CGAL::cpp11::get<1>(res);
visitor->new_node_added(node_id,internal_IOP::EDGE,edge,edge_intersected,CGAL::cpp11::get<2>(res),CGAL::cpp11::get<3>(res));
for (;it_edge!=all_edges.end();++it_edge){
if ( it_edge!=all_edges.begin() ){
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(*it_edge);
Facet_set* fset_bis = (it_ets!=edge_to_sfacet.end())?&(it_ets->second):NULL;
cip_handle_case_edge(node_id,fset_bis,*it_edge,edge_intersected);
}
else
cip_handle_case_edge(node_id,&fset,*it_edge,edge_intersected);
}
} // end case EDGE
break;
case internal_IOP::VERTEX:
{
CGAL_assertion(cgal_do_intersect_debug(edge,facet));
int node_id=++current_node;
Halfedge_handle vertex_intersected=CGAL::cpp11::get<1>(res);
add_new_node(get(ppmap, vertex_intersected->vertex())); //we use the original vertex to create the node
//before it was internal_IOP::FACET but do not remember why, probably a bug...
visitor->new_node_added(node_id,internal_IOP::VERTEX,edge,vertex_intersected,CGAL::cpp11::get<2>(res),CGAL::cpp11::get<3>(res));
for (;it_edge!=all_edges.end();++it_edge){
if ( it_edge!=all_edges.begin() ){
typename Edge_to_intersected_facets::iterator it_ets=edge_to_sfacet.find(*it_edge);
Facet_set* fset_bis = (it_ets!=edge_to_sfacet.end())?&(it_ets->second):NULL;
cip_handle_case_vertex(node_id,fset_bis,*it_edge,vertex_intersected);
}
else
cip_handle_case_vertex(node_id,&fset,*it_edge,vertex_intersected);
}
} // end case VERTEX
break;
} // end switch on the type of the intersection
} // end loop on all facets that intersect the edge
} // end loop on all entries (edges) in 'edge_to_sfacet'
CGAL_assertion(nodes.size()==unsigned(current_node+1));
}
#ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
void remove_duplicated_intersecting_edges()
{
for (typename Coplanar_duplicated_intersection_set::iterator
it=coplanar_duplicated_intersection.begin();
it!=coplanar_duplicated_intersection.end();
++it)
{
typename Facets_to_nodes_map::iterator res=f_to_node.find(*it);
//CGAL_assertion(res!=f_to_node.end());
//we cannot use a precondition here: in some cases the coplanarity test is not sufficient.
//if on surface1 we have to coplanar triangle incident along edge e. Then in surface2, take a triangle
//with one edge inside one triangle of surface1 such that one vertex in on e. Then the collinearity test
//return true for both faces but only one implies a duplicated edge
if(res!=f_to_node.end())
f_to_node.erase(res);
}
}
#else // not USE_DETECTION_MULTIPLE_DEFINED_EDGES
void remove_duplicated_intersecting_edges()
{
std::set< std::pair<int,int> > already_seen;
std::list<typename Facets_to_nodes_map::iterator> to_erase;
for (typename Facets_to_nodes_map::iterator
it=f_to_node.begin();
it!=f_to_node.end();
++it
)
{
if (it->second.size()==1) continue;
CGAL_precondition(it->second.size()==2);
//it->second is a set so int are already sorted
bool is_new=already_seen.insert( std::make_pair(
*(it->second.begin()),
*boost::next(it->second.begin()) )
).second;
if (!is_new)
to_erase.push_back(it);
}
for ( typename std::list<typename Facets_to_nodes_map::iterator>::iterator
it=to_erase.begin();it!=to_erase.end();++it
)
f_to_node.erase(*it);
}
#endif // not USE_DETECTION_MULTIPLE_DEFINED_EDGES
struct Graph_node{
std::set<int> neighbors;
unsigned degree;
Graph_node():degree(0){}
void insert(int i){
++degree;
CGAL_assertion(neighbors.find(i)==neighbors.end());
neighbors.insert(i);
}
void erase(int i){
CGAL_assertion(neighbors.find(i)!=neighbors.end());
neighbors.erase(i);
}
void make_terminal() {if (degree==2) degree=45;}
bool is_terminal()const {return degree!=2;}
bool empty() const {return neighbors.empty();}
int top() const {return *neighbors.begin();}
void pop() {
CGAL_assertion(!neighbors.empty());
neighbors.erase(neighbors.begin());
}
};
template <class Output_iterator>
void construct_polylines(Nodes_vector& nodes,Output_iterator out){
std::size_t nb_nodes=nodes.size();
std::vector<Graph_node> graph(nb_nodes);
//counts the number of time each node has been seen
bool isolated_point_seen=false;
for (typename Facets_to_nodes_map::iterator it=f_to_node.begin();it!=f_to_node.end();++it){
const std::set<int>& segment=it->second;
CGAL_assertion(segment.size()==2 || segment.size()==1);
if (segment.size()==2){
int i=*segment.begin();
int j=*boost::next(segment.begin());
graph[i].insert(j);
graph[j].insert(i);
}
else{
CGAL_assertion(segment.size()==1);
isolated_point_seen=true;
}
}
//visitor call
visitor->annotate_graph(graph.begin(),graph.end());
//collect terminal and interior nodes
boost::dynamic_bitset<> terminal_nodes(nb_nodes), interior_nodes(nb_nodes);
for (std::size_t i=0;i<nb_nodes;++i)
if (graph[i].is_terminal())
terminal_nodes.set(i);
else
interior_nodes.set(i);
//handle isolated points
if (isolated_point_seen){
for (std::size_t i=0;i<nb_nodes;++i)
if (graph[i].degree==0){
*out++=std::vector<typename Kernel::Point_3>(1,nodes[static_cast<int>(i)]);
visitor->start_new_polyline(static_cast<int>(i),static_cast<int>(i));
terminal_nodes.reset(i);
}
}
//handle polylines
while(terminal_nodes.any())
{
int i = static_cast<int>(terminal_nodes.find_first());
Graph_node& node_i = graph[i];
std::vector<typename Kernel::Point_3> polyline;
int j=node_i.top();
visitor->start_new_polyline(i,j);
CGAL_assertion(i!=j);
node_i.pop();
if (node_i.empty())
terminal_nodes.reset(i);
polyline.push_back(nodes[i]);
while(true){
Graph_node& node_j=graph[j];
CGAL_assertion(!node_j.empty());
node_j.erase(i);
i=j;
polyline.push_back(nodes[i]);
if (node_j.is_terminal())
{
if (node_j.empty())
terminal_nodes.reset(j);
break;
}
else{
j=node_j.top();
visitor->add_node_to_polyline(j);
node_j.pop();
CGAL_assertion(node_j.empty());
interior_nodes.reset(i);
}
}
*out++=polyline;
}
//handle cycles
while(interior_nodes.any())
{
int i=static_cast<int>(interior_nodes.find_first());
Graph_node& node_i=graph[i];
std::vector<typename Kernel::Point_3> polyline;
int j=node_i.top();
visitor->start_new_polyline(i,j);
interior_nodes.reset(i);
polyline.push_back(nodes[i]);
int first=i;
do{
Graph_node& node_j=graph[j];
interior_nodes.reset(j);
node_j.erase(i);
i=j;
polyline.push_back(nodes[i]);
j=node_j.top();
visitor->add_node_to_polyline(j);
}while(j!=first);
polyline.push_back(nodes[j]);// we duplicate first point for cycles
*out++=polyline;
}
}
int get_other_int(const std::set<int>& s,int i) const {
if (*s.begin()!=i) return *s.begin();
return *boost::next(s.begin());
}
template <class T,class Dispatch_out_it>
bool is_grabbed(const Dispatch_out_it&) const{
return CGAL::Is_in_tuple<T,typename Dispatch_out_it::Value_type_tuple>::value;
}
template <class OutputIterator>
struct Is_dispatch_based_ouput_iterator{
typedef boost::false_type type;
};
template <template<class V_,class O_> class Dispatch_based_output_it,class V,class O>
struct Is_dispatch_based_ouput_iterator<Dispatch_based_output_it<V,O> >{
typedef typename boost::is_base_of< Dispatch_output_iterator<V,O>,
Dispatch_based_output_it<V,O> >::type type;
};
template <class Output_iterator>
inline void construct_polylines_with_info(Nodes_vector& nodes,Output_iterator out){
return construct_polylines_with_info(nodes,out,typename Is_dispatch_based_ouput_iterator<Output_iterator>::type());
}
template <class Output_iterator>
void construct_polylines_with_info(Nodes_vector& nodes,Output_iterator out,boost::false_type){
construct_polylines_with_info(nodes,
dispatch_or_drop_output<std::vector<typename Kernel::Point_3> >(out),boost::true_type());
}
template <template<class V_,class O_> class Dispatch_based_output_it,class V,class O>
void construct_polylines_with_info(Nodes_vector& nodes,
Dispatch_based_output_it<V,O> out,boost::true_type)
{
typedef typename Facets_to_nodes_map::value_type Edge;
typedef std::list<Facet_pair> Polyline_info;
std::size_t nb_nodes=nodes.size();
std::vector<int> node_mult(nb_nodes,0);
std::vector<bool> terminal_bools(nb_nodes,false);
std::vector< std::set<Edge*> > connections(nb_nodes);
// --counts the number of time each node has been seen
// --associate to each node its incident edges. An edge = a pair of Facet_handle+2 indices of intersection points
for (typename Facets_to_nodes_map::iterator it=f_to_node.begin();it!=f_to_node.end();++it){
const std::set<int>& segment=it->second;
CGAL_assertion(segment.size()==2 || segment.size()==1);
if (segment.size()==2){
int i=*segment.begin();
int j=*boost::next(segment.begin());
connections[i].insert(&(*it));
connections[j].insert(&(*it));
++(node_mult[i]);
++(node_mult[j]);
}
}
//detect terminal nodes and isolated nodes
for (unsigned k=0;k<nb_nodes;++k){
if (node_mult[k]!=2) terminal_bools[k]=true;
if (node_mult[k]==0){
*out++=std::vector<typename Kernel::Point_3>(1,nodes[k]);
if ( is_grabbed<std::vector<Facet_pair> >(out))
*out++=std::vector<Facet_pair>();
}
}
//visitor call
visitor->update_terminal_nodes(terminal_bools);
//We start from a node N and recursively walk one edge to find other
// node. If this is a cycle we stop when we are back at the node N;
//otherwise we stop at a terminal node and restart a walk from N
//following another edge (if N is not terminal) until finding a terminal
//node. With this we can associate to each edge the pair of facet_handle
//intersecting that define this edge.
unsigned current_node=0;
while (current_node!=nb_nodes){
if (connections[current_node].empty()){
++current_node;
continue;
}
Edge* edge=*connections[current_node].begin();
connections[current_node].erase(connections[current_node].begin());
Polyline_info polyline_info;
std::list<typename Kernel::Point_3> polyline_embedding;
if ( is_grabbed<std::vector<Facet_pair> >(out))
polyline_info.push_back(edge->first.first);
polyline_embedding.push_back(nodes[current_node]);
unsigned i=current_node;
unsigned start_node=current_node;
bool reverse=false;
while (true){
i=get_other_int(edge->second,i);
connections[i].erase(edge);
if (reverse) polyline_embedding.push_front(nodes[i]);
else polyline_embedding.push_back(nodes[i]);
if (i==start_node) break;
if (terminal_bools[i]){
if (reverse || terminal_bools[current_node]) break;
reverse=true;
i=current_node;
if ( connections[i].empty() ) break;
}
edge=*connections[i].begin();
connections[i].erase(connections[i].begin());
if ( is_grabbed<std::vector<Facet_pair> >(out)){
if (reverse) polyline_info.push_front(edge->first.first);
else polyline_info.push_back(edge->first.first);
}
}
*out++=std::vector<typename Kernel::Point_3>(polyline_embedding.begin(),polyline_embedding.end());
if ( is_grabbed<std::vector<Facet_pair> >(out)){
CGAL_assertion(polyline_embedding.size()==polyline_info.size()+1);
*out++=std::vector<Facet_pair>(polyline_info.begin(),polyline_info.end());
}
}
}
//debug functions
bool cgal_do_intersect_debug(Halfedge_handle eh,Facet_handle fh){
Triangle t( get(ppmap, fh->halfedge()->vertex()),
get(ppmap, fh->halfedge()->next()->vertex()),
get(ppmap, fh->halfedge()->next()->next()->vertex()));
Segment s( get(ppmap, eh->vertex()),
get(ppmap, eh->opposite()->vertex()));
return CGAL::do_intersect( s, t);
}
bool cgal_do_intersect_debug(Facet_handle fh1,Facet_handle fh2){
Triangle t1( get(ppmap, fh1->halfedge()->vertex()),
get(ppmap, fh1->halfedge()->next()->vertex()),
get(ppmap, fh1->halfedge()->next()->next()->vertex()));
Triangle t2( get(ppmap, fh2->halfedge()->vertex()),
get(ppmap, fh2->halfedge()->next()->vertex()),
get(ppmap, fh2->halfedge()->next()->next()->vertex()));
return CGAL::do_intersect( t1, t2);
}
void print_f_to_node_debug(){
std::cout << "print_f_to_node_debug " << &f_to_node << std::endl;
for (typename Facets_to_nodes_map::iterator it=f_to_node.begin();it!=f_to_node.end();++it){
std::cout << &(*(it->first.first.first)) << " " << &(*(it->first.first.second)) << " " << it->first.second << " -> {";
std::copy(it->second.begin(),it->second.end(),std::ostream_iterator<int>(std::cout,","));
std::cout << "}" <<std::endl;
}
}
void print_graph_debug(const std::map<int,Graph_node>& graph){
for (typename std::map<int,Graph_node>::const_iterator it=graph.begin();it!=graph.end();++it){
std::cout << it->first << " -> {";
std::copy(it->second.neighbors.begin(),it->second.neighbors.end(),std::ostream_iterator<int>(std::cout,","));
std::cout << "}" <<std::endl;
}
}
void print_edge_to_sfacet_debug(){
std::cout << "Potential intersection "<< edge_to_sfacet.size() << std::endl;
for(typename Edge_to_intersected_facets::iterator it=edge_to_sfacet.begin();it!=edge_to_sfacet.end();++it){
Facet_set& fset=it->second;
std::cout << &fset << " fset size " << fset.size() << std::endl;
}
}
template <class OutputIterator>
OutputIterator main_run(OutputIterator out,bool build_polylines=true){
// std::cout << edge_to_sfacet.size() << std::endl;
int current_node=-1;
//print_edge_to_sfacet_debug();
#ifndef DO_NOT_HANDLE_COPLANAR_FACETS
//first handle coplanar triangles
compute_intersection_of_coplanar_facets(current_node);
visitor->set_number_of_intersection_points_from_coplanar_facets(current_node+1);
if (!coplanar_facets.empty())
visitor->input_have_coplanar_facets();
#endif // not DO_NOT_HANDLE_COPLANAR_FACETS
//print_edge_to_sfacet_debug();
//compute intersection points of segments and triangles.
//build node of the graph
//build connectivity info
compute_intersection_points(current_node); // 'current_node' is passed by
// non-const reference
if (!build_polylines){
visitor->finalize(nodes);
return out;
}
//remove duplicated intersecting edges:
// In case two facets are incident along such an edge coplanar in a facet of another polyhedron (and one extremity inside the facet), the intersection
// will be reported twice. We kept track (check_coplanar_edge(s)) of this so that, we can remove one intersecting edge out of the two
//print_f_to_node_debug();
remove_duplicated_intersecting_edges();
//std::cout << "f_to_node "<< f_to_node.size() << std::endl;
//print_f_to_node_debug();
//collect connectivity infos and create polylines
if ( Node_visitor::do_need_vertex_graph )
construct_polylines(nodes,out); //using the graph approach (at some point we know all connections between intersection points)
else
construct_polylines_with_info(nodes,out); //direct construction by propagation
visitor->finalize(nodes);
return out;
}
public:
Intersection_of_Polyhedra_3(PolyhedronPointPMap ppmap=PolyhedronPointPMap())
:ppmap(ppmap),nodes(ppmap),
visitor(new Node_visitor()),
is_default_visitor(true){}
Intersection_of_Polyhedra_3(Node_visitor& v,
PolyhedronPointPMap ppmap=PolyhedronPointPMap())
:ppmap(ppmap),nodes(ppmap),visitor(&v),is_default_visitor(false){}
~Intersection_of_Polyhedra_3(){if (is_default_visitor) delete visitor;}
//pairwise intersection between all elements in the range
template <class InputIterator, class OutputIterator>
OutputIterator
operator()(InputIterator begin, InputIterator end, OutputIterator out) {
for(InputIterator it1=begin;it1!=end;++it1){
CGAL_precondition( it1->is_pure_triangle() );
Polyhedron_ref P=*it1;
visitor->new_input_polyhedron(P);
for(InputIterator it2=boost::next(it1);it2!=end;++it2){
CGAL_precondition( it2->is_pure_triangle() );
Polyhedron_ref Q=*it2;
filter_intersections(P, Q);
filter_intersections(Q, P);
}
}
return main_run(out);
}
//pairwise intersection between all elements in the range
//(pointers version)
template <class InputIterator, class OutputIterator>
OutputIterator
operator()(InputIterator begin, InputIterator end, OutputIterator out, int) {
for(InputIterator it1=begin;it1!=end;++it1){
CGAL_precondition( (*it1)->is_pure_triangle() );
Polyhedron_ref P=**it1;
visitor->new_input_polyhedron(P);
for(InputIterator it2=boost::next(it1);it2!=end;++it2){
CGAL_precondition( (*it2)->is_pure_triangle() );
Polyhedron_ref Q=**it2;
filter_intersections(P, Q);
filter_intersections(Q, P);
}
}
return main_run(out);
}
//intersection between P and each element in the range
template <class InputIterator, class OutputIterator>
OutputIterator
operator()( Polyhedron_ref P, InputIterator begin, InputIterator end, OutputIterator out) {
CGAL_precondition( P.is_pure_triangle() );
visitor->new_input_polyhedron(P);
for(InputIterator it=begin;it!=end;++it){
CGAL_precondition( it->is_pure_triangle() );
Polyhedron_ref Q=*it;
visitor->new_input_polyhedron(Q);
filter_intersections(P, Q);
filter_intersections(Q, P);
}
return main_run(out);
}
//intersection between P and each element in the range
//(pointers version)
template <class InputIterator, class OutputIterator>
OutputIterator
operator()(Polyhedron_ref P, InputIterator begin, InputIterator end, OutputIterator out, int) {
CGAL_precondition( P.is_pure_triangle() );
visitor->new_input_polyhedron(P);
for(InputIterator it=begin;it!=end;++it){
CGAL_precondition( (*it)->is_pure_triangle() );
Polyhedron_ref Q=**it;
visitor->new_input_polyhedron(Q);
filter_intersections(P, Q);
filter_intersections(Q, P);
}
return main_run(out);
}
//intersection between P and Q
template <class OutputIterator>
OutputIterator
operator()(Polyhedron_ref P, Polyhedron_ref Q, OutputIterator out) {
visitor->new_input_polyhedron(P);
visitor->new_input_polyhedron(Q);
filter_intersections(P, Q);
filter_intersections(Q, P);
return main_run(out);
}
//intersection between P and Q, only visitor called not polyline is constructed
void operator()(Polyhedron_ref P, Polyhedron_ref Q) {
visitor->new_input_polyhedron(P);
visitor->new_input_polyhedron(Q);
filter_intersections(P, Q);
filter_intersections(Q, P);
main_run(Emptyset_iterator(),false);
}
};
template <typename Polyhedron, typename OutputIterator>
OutputIterator
intersection_Polyhedron_3_Polyhedron_3(const Polyhedron& P, const Polyhedron& Q, OutputIterator out)
{
return Intersection_of_Polyhedra_3<Polyhedron>()(P,Q,out);
}
}// namespace CGAL
#include <CGAL/enable_warnings.h>
#endif //CGAL_INTERSECTION_OF_POLYHEDRA_3_H
/*
// Local variables for Emacs:
// - set special indentation of case labels, compared to usual C/C++
// indentation styles.
Local Variables:
c-file-offsets:((case-label . +))
End:
*/
Reference in New Issue View Git Blame Copy Permalink