songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Wip group/degroup

This commit is contained in:
Guillaume Damiand 2013-02-11 22:22:14 +01:00
parent fbe2a506d7
commit 0778e0b166
2 changed files with 199 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Combinatorial_map/include/CGAL/Combinatorial_map_operations.h
View File

@ -200,14 +200,13 @@ namespace CGAL {
template < class CMap, unsigned int i > template < class CMap, unsigned int i >
bool is_removable(const CMap& amap, typename CMap::Dart_const_handle adart) bool is_removable(const CMap& amap, typename CMap::Dart_const_handle adart)
{ {
CGAL_assertion(adart != NULL); CGAL_assertion( adart!=NULL );
CGAL_static_assertion(0<=i && i<=CMap::dimension); CGAL_static_assertion( 0<=i && i<=CMap::dimension );
if ( i==CMap::dimension ) return true; if ( i==CMap::dimension ) return true;
if ( i==CMap::dimension-1 ) return true; if ( i==CMap::dimension-1 ) return true;
// TODO ? Optimisation for dim-2, and to not test all // TODO? Optimisation for dim-2, and to not test all the darts of the cell?
// the darts of the cell ?
bool res = true; bool res = true;
for (CMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart); for (CMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart);
res && it.cont(); ++it) res && it.cont(); ++it)
@ -787,13 +786,13 @@ namespace CGAL {
if ( i==0 ) return false; if ( i==0 ) return false;
if ( i==1 ) return true; if ( i==1 ) return true;
// TODO ? Optimisation possible to not test all // TODO ? Optimisation possible to not test all the darts of the cell ?
// the darts of the cell ?
bool res = true; bool res = true;
for (CMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart); for (CMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart);
res && it.cont(); ++it) res && it.cont(); ++it)
{ {
if ( it->beta(i-2)->beta(i-1)!=it->beta(i-1)->beta_inv(i-2) ) if ( it->template beta<i-2>()->template beta<i-1>()!=
it->template beta<i-1>()->template beta_inv<i-2>() )
res = false; res = false;
} }
return res; return res;

400
Combinatorial_map/include/CGAL/internal/Combinatorial_map_functors.h
View File

@ -30,6 +30,12 @@
* attributes are stored in tuple, thus all the access must be done at * attributes are stored in tuple, thus all the access must be done at
* compiling time. * compiling time.
* *
* Call_split_functor<CMap,i> to call the OnSplit functors on two given
* i-attributes.
*
* Call_merge_functor<CMap,i> to call the OnMerge functors on two given
* i-attributes.
*
* Group_attribute_functor_of_dart<CMap> to group the <i>-attributes of two * Group_attribute_functor_of_dart<CMap> to group the <i>-attributes of two
* given darts (except for j-dim). Only the attributes of the two given * given darts (except for j-dim). Only the attributes of the two given
* darts are possibly modified. * darts are possibly modified.
@ -43,11 +49,6 @@
* non NULL, we overide all the i-attribute of the second i-cell to the * non NULL, we overide all the i-attribute of the second i-cell to the
* first i-attribute. * first i-attribute.
* *
* Call_split_functor<CMap,i> to call the OnSplit functor on two given
* i-attributes.
*
** Call_merge_functor<CMap,i> to call the OnMerge functor on two given
* i-attributes.
*/ */
namespace CGAL namespace CGAL
@ -77,82 +78,178 @@ namespace CGAL
{} {}
}; };
// **************************************************************************
// Functor used to call the On_split functor between the two given darts. // Functor used to call the On_split functor between the two given darts.
template<typename Map,unsigned int i, template<typename CMap,unsigned int i,
typename Enabled=typename Map::Helper:: typename Enabled=typename CMap::Helper::
#ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG #ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG
template template
#endif #endif
Attribute_type<i>::type> Attribute_type<i>::type>
struct Call_split_functor struct Call_split_functor
{ {
static void run(typename Map::Dart_handle adart1, static void run(typename CMap::Dart_handle adart1,
typename Map::Dart_handle adart2) typename CMap::Dart_handle adart2)
{ {
Apply_cell_functor Apply_cell_functor
<typename Map::Helper::template Attribute_type<i>::type, <typename CMap::Helper::template Attribute_type<i>::type,
typename Map::Helper::template Attribute_type<i>::type::On_split>:: typename CMap::Helper::
template Attribute_type<i>::type::On_split>::
run(*(adart1->template attribute<i>()), run(*(adart1->template attribute<i>()),
*(adart2->template attribute<i>())); *(adart2->template attribute<i>()));
} }
static void static void
run(typename Map::Helper::template Attribute_handle<i>::type a1, run(typename CMap::Helper::template Attribute_handle<i>::type a1,
typename Map::Helper::template Attribute_handle<i>::type a2) typename CMap::Helper::template Attribute_handle<i>::type a2)
{ {
Apply_cell_functor Apply_cell_functor
<typename Map::Helper::template Attribute_type<i>::type, <typename CMap::Helper::template Attribute_type<i>::type,
typename Map::Helper::template Attribute_type<i>::type::On_split>:: typename CMap::Helper::
template Attribute_type<i>::type::On_split>::
run(*a1, *a2); run(*a1, *a2);
} }
}; };
// Specialization for disabled attributes. // Specialization for disabled attributes.
template<typename Map,unsigned int i> template<typename CMap,unsigned int i>
struct Call_split_functor<Map,i,CGAL::Void> struct Call_split_functor<CMap,i,CGAL::Void>
{ {
static void run(typename Map::Dart_handle, static void run(typename CMap::Dart_handle,
typename Map::Dart_handle) typename CMap::Dart_handle)
{} {}
}; };
// **************************************************************************
// Functor used to call the On_merge functor between the two given darts. // Functor used to call the On_merge functor between the two given darts.
template<typename Map,unsigned int i, template<typename CMap,unsigned int i,
typename Enabled=typename Map::Helper:: typename Enabled=typename CMap::Helper::
#ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG #ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG
template template
#endif #endif
Attribute_type<i>::type> Attribute_type<i>::type>
struct Call_merge_functor struct Call_merge_functor
{ {
static void run(typename Map::Dart_handle adart1, static void run(typename CMap::Dart_handle adart1,
typename Map::Dart_handle adart2) typename CMap::Dart_handle adart2)
{ {
Apply_cell_functor Apply_cell_functor
<typename Map::Helper::template Attribute_type<i>::type, <typename CMap::Helper::template Attribute_type<i>::type,
typename Map::Helper::template Attribute_type<i>::type::On_merge>:: typename CMap::Helper::template Attribute_type<i>::type::On_merge>::
run(*(adart1->template attribute<i>()), run(*(adart1->template attribute<i>()),
*(adart2->template attribute<i>())); *(adart2->template attribute<i>()));
} }
static void static void
run(typename Map::Helper::template Attribute_handle<i>::type a1, run(typename CMap::Helper::template Attribute_handle<i>::type a1,
typename Map::Helper::template Attribute_handle<i>::type a2) typename CMap::Helper::template Attribute_handle<i>::type a2)
{ {
Apply_cell_functor Apply_cell_functor
<typename Map::Helper::template Attribute_type<i>::type, <typename CMap::Helper::template Attribute_type<i>::type,
typename Map::Helper::template Attribute_type<i>::type::On_merge>:: typename CMap::Helper::template Attribute_type<i>::type::On_merge>::
run(*a1, *a2); run(*a1, *a2);
} }
}; };
// Specialization for disabled attributes. // Specialization for disabled attributes.
template<typename Map,unsigned int i> template<typename CMap,unsigned int i>
struct Call_merge_functor<Map,i,CGAL::Void> struct Call_merge_functor<CMap,i,CGAL::Void>
{ {
static void run(typename Map::Dart_handle, static void run(typename CMap::Dart_handle,
typename Map::Dart_handle) typename CMap::Dart_handle)
{} {}
}; };
// **************************************************************************
/// Functor used to reserve one mark for each enabled attribute.
template<typename CMap>
struct Reserve_mark_functor
{
template <unsigned int i>
static void run(const CMap* amap, std::vector<int>* marks)
{ (*marks)[i] = amap->get_new_mark(); }
};
// **************************************************************************
/// Functor used to test if a cell is valid
template<typename CMap>
struct Test_is_valid_attribute_functor
{
template <unsigned int i>
static void run(const CMap* amap,
typename CMap::Dart_const_handle adart,
std::vector<int>* marks, bool *ares)
{
if (!amap->template is_valid_attribute<i>(adart,(*marks)[i]) )
{
(*ares)=false;
std::cerr << "CMap not valid: a "<<i<<"-cell is not correctly "
"associated with an attribute for " << &(*adart)<< std::endl;
}
}
};
// **************************************************************************
/// Functor for counting i-cell
template<typename CMap>
struct Count_cell_functor
{
template <unsigned int i>
static void run( const CMap* amap,
typename CMap::Dart_const_handle adart,
std::vector<int>* amarks,
std::vector<unsigned int>* ares )
{
if ( (*amarks)[i]!=-1 && !amap->is_marked(adart, (*amarks)[i]) )
{
++ (*ares)[i];
mark_cell<CMap,i>(*amap, adart, (*amarks)[i]);
}
}
};
// **************************************************************************
/// Functor for counting the memory occupation of attributes
/// Be careful not reentrant !!! TODO a Foreach_enabled_attributes
/// taking an instance of a functor as argument allowing to compute
/// and return values.
template<typename CMap>
struct Count_bytes_one_attribute_functor
{
template <unsigned int i>
static void run( const CMap* amap )
{
res += amap->template attributes<i>().capacity()*
sizeof(typename CMap::template Attribute_type<i>::type);
}
static typename CMap::size_type res;
};
template<typename CMap>
typename CMap::size_type Count_bytes_one_attribute_functor<CMap>::res = 0;
template<typename CMap>
struct Count_bytes_all_attributes_functor
{
static typename CMap::size_type run( const CMap& amap )
{
Count_bytes_one_attribute_functor<CMap>::res = 0;
CMap::Helper::template Foreach_enabled_attributes
<Count_bytes_one_attribute_functor<CMap> >::run(&amap);
return Count_bytes_one_attribute_functor<CMap>::res;
}
};
// **************************************************************************
/// Functor used to call decrease_attribute_ref_counting<i>
/// on each i-cell attribute enabled
template<typename CMap>
struct Decrease_attribute_functor
{
template <unsigned int i>
static void run(CMap* amap, typename CMap::Dart_handle adart)
{ amap->template
decrease_attribute_ref_counting<i>(adart/*,Tag_true()*/); }
};
// ************************************************************************** // **************************************************************************
/// Functor used for link_beta to update the i-attributes of /// Functor used for link_beta to update the i-attributes of
/// adart2 on the attributes of this dart, except if i=j. /// adart2 on the attributes of this dart, except if i=j.
@ -544,6 +641,7 @@ namespace CGAL
} }
}; };
// **************************************************************************
// Functor used to degroup the two n-attributes of the two darts, except the // Functor used to degroup the two n-attributes of the two darts, except the
// attribute of adim // attribute of adim
template<typename CMap,unsigned int i> template<typename CMap,unsigned int i>
@ -590,14 +688,14 @@ namespace CGAL
} }
} }
}; };
template<typename Map> template<typename CMap>
struct Degroup_attribute_functor struct Degroup_attribute_functor
{ {
template <unsigned int i> template <unsigned int i>
static void run(Map* amap,typename Map::Dart_handle adart1, static void run(CMap* amap,typename CMap::Dart_handle adart1,
typename Map::Dart_handle adart2, int adim) typename CMap::Dart_handle adart2, int adim)
{ {
Degroup_attribute_functor_run<Map,i>::run(amap,adart1,adart2,adim); Degroup_attribute_functor_run<CMap,i>::run(amap,adart1,adart2,adim);
} }
}; };
@ -637,146 +735,34 @@ namespace CGAL
{ return false; } { return false; }
}; };
/* // Functor used to degroup one attribute of one dart
template <typename CMap, unsigned int i, typename Type_attr, typename Range>
struct Degroup_one_attribute_of_dart_functor
{
static bool run(CMap* amap,
typename CMap::Dart_handle adart1,
typename CMap::Dart_handle adart2)
{
CGAL_assertion(amap!=NULL);
return amap->template degroup_enabled_attribute_of_dart
<i, Type_attr, Range>(adart1,adart2);
}
};
// Specialization for i-attributes disabled.
template <typename CMap, unsigned int i, typename Range>
struct Degroup_one_attribute_of_dart_functor<CMap, i, CGAL::Void, Range>
{
static bool run(CMap*,
typename CMap::Dart_handle,
typename CMap::Dart_handle)
{ return false; }
};*/
/// Functor used to call decrease_attribute_ref_counting<i>
/// on each i-cell attribute enabled
template<typename Map>
struct Decrease_attribute_functor
{
template <unsigned int i>
static void run(Map* amap, typename Map::Dart_handle adart)
{ amap->template
decrease_attribute_ref_counting<i>(adart/*,Tag_true()*/); }
};
/// Functor used to call update_dart_of_attribute<i> /// Functor used to call update_dart_of_attribute<i>
/// on each i-cell attribute enabled /// on each i-cell attribute enabled
template<typename Map> template<typename CMap>
struct Update_dart_of_attribute_functor struct Update_dart_of_attribute_functor
{ {
template <unsigned int i> template <unsigned int i>
static void run(Map* amap, typename Map::Dart_handle ah, int amark) static void run(CMap* amap, typename CMap::Dart_handle ah, int amark)
{ amap->template update_dart_of_attribute<i>(ah,amark); } { amap->template update_dart_of_attribute<i>(ah,amark); }
}; };
template<typename Map, unsigned int i, typename Enabled= template<typename CMap, unsigned int i, typename Enabled=
typename Map::Helper:: typename CMap::Helper::
#ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG #ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG
template template
#endif #endif
Attribute_type<i>::type> Attribute_type<i>::type>
struct Update_dart_of_one_attribute_functor struct Update_dart_of_one_attribute_functor
{ {
static void run(Map* amap, typename Map::Dart_handle ah, int amark) static void run(CMap* amap, typename CMap::Dart_handle ah, int amark)
{ amap->template update_dart_of_attribute<i>(ah,amark); } { amap->template update_dart_of_attribute<i>(ah,amark); }
}; };
template<typename Map, unsigned int i> template<typename CMap, unsigned int i>
struct Update_dart_of_one_attribute_functor<Map, i, CGAL::Void> struct Update_dart_of_one_attribute_functor<CMap, i, CGAL::Void>
{ {
static void run(Map*, typename Map::Dart_handle, int) static void run(CMap*, typename CMap::Dart_handle, int)
{} {}
}; };
/// Functor used to reserve one mark for each enabled attribute.
template<typename Map>
struct Reserve_mark_functor
{
template <unsigned int i>
static void run(const Map* amap, std::vector<int>* marks)
{ (*marks)[i] = amap->get_new_mark(); }
};
/// Functor used to test if a cell is valid
template<typename Map>
struct Test_is_valid_attribute_functor
{
template <unsigned int i>
static void run(const Map* amap,
typename Map::Dart_const_handle adart,
std::vector<int>* marks, bool *ares)
{
if (!amap->template is_valid_attribute<i>(adart,(*marks)[i]) )
{
(*ares)=false;
std::cerr << "Map not valid: a "<<i<<"-cell is not correctly "
"associated with an attribute for " << &(*adart)<< std::endl;
}
}
};
/// Functor for counting i-cell
template<typename Map>
struct Count_cell_functor
{
template <unsigned int i>
static void run( const Map* amap,
typename Map::Dart_const_handle adart,
std::vector<int>* amarks,
std::vector<unsigned int>* ares )
{
if ( (*amarks)[i]!=-1 && !amap->is_marked(adart, (*amarks)[i]) )
{
++ (*ares)[i];
mark_cell<Map,i>(*amap, adart, (*amarks)[i]);
}
}
};
/// Functor for counting the memory occupation of attributes
/// Be careful not reentrant !!! TODO a Foreach_enabled_attributes
/// taking an instance of a functor as argument allowing to compute
/// and return values.
template<typename Map>
struct Count_bytes_one_attribute_functor
{
template <unsigned int i>
static void run( const Map* amap )
{
res += amap->template attributes<i>().capacity()*
sizeof(typename Map::template Attribute_type<i>::type);
}
static typename Map::size_type res;
};
template<typename Map>
typename Map::size_type Count_bytes_one_attribute_functor<Map>::res = 0;
template<typename Map>
struct Count_bytes_all_attributes_functor
{
static typename Map::size_type run( const Map& amap )
{
Count_bytes_one_attribute_functor<Map>::res = 0;
Map::Helper::template Foreach_enabled_attributes
<Count_bytes_one_attribute_functor<Map> >::run(&amap);
return Count_bytes_one_attribute_functor<Map>::res;
}
};
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Dart_handle, typename ... Betas> template<typename Dart_handle, typename ... Betas>
struct Beta_functor; struct Beta_functor;
@ -821,23 +807,23 @@ namespace CGAL
}; };
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES #endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map, unsigned int i> template<typename CMap, unsigned int i>
struct Store_incident_cells struct Store_incident_cells
{ {
template <unsigned int j> template <unsigned int j>
static void run( Map* amap, typename Map::Dart_handle adart, static void run( CMap* amap, typename CMap::Dart_handle adart,
int mark_for_icell, int mark_for_icell,
int* mark_for_incident_cells, int* mark_for_incident_cells,
std::deque<std::deque<typename Map::Dart_handle> > std::deque<std::deque<typename CMap::Dart_handle> >
*store ) *store )
{ {
if ( i==j ) return; if ( i==j ) return;
const int mark_for_jcells = mark_for_incident_cells const int mark_for_jcells = mark_for_incident_cells
[Map::Helper::template Dimension_index<j>::value]; [CMap::Helper::template Dimension_index<j>::value];
std::deque<std::deque<typename Map::Dart_handle> >& jcells = std::deque<std::deque<typename CMap::Dart_handle> >& jcells =
store[Map::Helper::template Dimension_index<j>::value]; store[CMap::Helper::template Dimension_index<j>::value];
CGAL_assertion( amap!=NULL ); CGAL_assertion( amap!=NULL );
CGAL_assertion( adart!=NULL ); CGAL_assertion( adart!=NULL );
@ -847,8 +833,8 @@ namespace CGAL
if ( !amap->is_marked(adart, mark_for_jcells) && if ( !amap->is_marked(adart, mark_for_jcells) &&
adart->template attribute<j>()!=NULL ) adart->template attribute<j>()!=NULL )
{ {
jcells.push_back(std::deque<typename Map::Dart_handle>()); jcells.push_back(std::deque<typename CMap::Dart_handle>());
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, adart, mark_for_jcells); itj.cont(); ++itj ) itj(*amap, adart, mark_for_jcells); itj.cont(); ++itj )
{ {
if ( !amap->is_marked(itj, mark_for_icell) ) if ( !amap->is_marked(itj, mark_for_icell) )
@ -862,13 +848,13 @@ namespace CGAL
if ( i!=1 && j==0 ) if ( i!=1 && j==0 )
{ {
typename Map::Dart_handle od = adart->other_extremity(); typename CMap::Dart_handle od = adart->other_extremity();
if ( od!=NULL && !amap->is_marked(od, mark_for_jcells) && if ( od!=NULL && !amap->is_marked(od, mark_for_jcells) &&
od->template attribute<j>()!=NULL ) od->template attribute<j>()!=NULL )
{ {
jcells.push_back(std::deque<typename Map::Dart_handle>()); jcells.push_back(std::deque<typename CMap::Dart_handle>());
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, od, mark_for_jcells); itj.cont(); ++itj ) itj(*amap, od, mark_for_jcells); itj.cont(); ++itj )
{ {
if ( !amap->is_marked(itj, mark_for_icell) ) if ( !amap->is_marked(itj, mark_for_icell) )
@ -883,39 +869,39 @@ namespace CGAL
} }
}; };
template<typename Map, unsigned int i> template<typename CMap, unsigned int i>
struct Test_split_with_deque struct Test_split_with_deque
{ {
template <unsigned int j> template <unsigned int j>
static void run( Map* amap, static void run( CMap* amap,
int* mark_for_incident_cells, int* mark_for_incident_cells,
std::deque<std::deque<typename Map::Dart_handle> > std::deque<std::deque<typename CMap::Dart_handle> >
*store ) *store )
{ {
const int mark_for_jcells = mark_for_incident_cells const int mark_for_jcells = mark_for_incident_cells
[Map::Helper::template Dimension_index<j>::value]; [CMap::Helper::template Dimension_index<j>::value];
amap->negate_mark( mark_for_jcells ); amap->negate_mark( mark_for_jcells );
if ( i==j ) return; if ( i==j ) return;
std::deque<std::deque<typename Map::Dart_handle> >& jcells = std::deque<std::deque<typename CMap::Dart_handle> >& jcells =
store[Map::Helper::template Dimension_index<j>::value]; store[CMap::Helper::template Dimension_index<j>::value];
CGAL_assertion( amap!=NULL ); CGAL_assertion( amap!=NULL );
CGAL_assertion( amap->is_reserved(mark_for_jcells) ); CGAL_assertion( amap->is_reserved(mark_for_jcells) );
int nbofjcell = 0; int nbofjcell = 0;
typename Map::Helper::template Attribute_handle<j>::type typename CMap::Helper::template Attribute_handle<j>::type
a1 = NULL; a1 = NULL;
typename Map::Helper::template Attribute_handle<j>::type typename CMap::Helper::template Attribute_handle<j>::type
a2=NULL; a2=NULL;
int nb=0; int nb=0;
for ( typename std::deque<std::deque<typename Map::Dart_handle> >:: for ( typename std::deque<std::deque<typename CMap::Dart_handle> >::
iterator it=jcells.begin(); it!=jcells.end(); ++it ) iterator it=jcells.begin(); it!=jcells.end(); ++it )
{ {
nbofjcell = 0; nbofjcell = 0;
for ( typename std::deque<typename Map::Dart_handle>::iterator for ( typename std::deque<typename CMap::Dart_handle>::iterator
itj=it->begin(); itj!=it->end(); ++itj ) itj=it->begin(); itj!=it->end(); ++itj )
{ {
if ( !amap->is_marked(*itj, mark_for_jcells) ) if ( !amap->is_marked(*itj, mark_for_jcells) )
@ -934,7 +920,7 @@ namespace CGAL
// std::cout<<"A1 "<<&*a1<<" "<<&**itj<<": "; // std::cout<<"A1 "<<&*a1<<" "<<&**itj<<": ";
} }
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj2(*amap, *itj, mark_for_jcells); itj2(*amap, *itj, mark_for_jcells);
itj2.cont(); ++itj2 ) itj2.cont(); ++itj2 )
{ {
@ -948,8 +934,8 @@ namespace CGAL
if ( nbofjcell>1 ) if ( nbofjcell>1 )
Apply_cell_functor Apply_cell_functor
<typename Map::Helper::template Attribute_type<j>::type, <typename CMap::Helper::template Attribute_type<j>::type,
typename Map::Helper::template Attribute_type<j>::type:: typename CMap::Helper::template Attribute_type<j>::type::
On_split>::run(*a1, *a2); On_split>::run(*a1, *a2);
} }
} }
@ -960,28 +946,28 @@ namespace CGAL
} }
}; };
template<typename Map, unsigned int i> template<typename CMap, unsigned int i>
struct Test2_split_with_deque struct Test2_split_with_deque
{ {
template<unsigned int j> template<unsigned int j>
static void test_one_dart( Map* amap, static void test_one_dart( CMap* amap,
typename Map::Dart_handle adart, typename CMap::Dart_handle adart,
std::set<typename Map::Helper::template std::set<typename CMap::Helper::template
Attribute_handle<j>::type>& found_attributes, Attribute_handle<j>::type>& found_attributes,
int mark) int mark)
{ {
if ( adart->template attribute<j>()!=NULL && if ( adart->template attribute<j>()!=NULL &&
!amap->is_marked(adart, mark) ) !amap->is_marked(adart, mark) )
{ {
typename Map::Helper::template Attribute_handle<j>::type typename CMap::Helper::template Attribute_handle<j>::type
a1 = adart->template attribute<j>(); a1 = adart->template attribute<j>();
if ( !found_attributes.insert(a1).second ) if ( !found_attributes.insert(a1).second )
{ // Here the attribute was already present in the set { // Here the attribute was already present in the set
typename Map::Helper::template Attribute_handle<j>::type typename CMap::Helper::template Attribute_handle<j>::type
a2 = amap->template create_attribute<j>(*a1); a2 = amap->template create_attribute<j>(*a1);
// std::cout<<"A2 "<<&*a2<<" "<<&**itj<<": "; // std::cout<<"A2 "<<&*a2<<" "<<&**itj<<": ";
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, adart, mark); itj(*amap, adart, mark);
itj.cont(); ++itj ) itj.cont(); ++itj )
{ {
@ -991,8 +977,8 @@ namespace CGAL
} }
Apply_cell_functor Apply_cell_functor
<typename Map::Helper::template Attribute_type<j>::type, <typename CMap::Helper::template Attribute_type<j>::type,
typename Map::Helper::template Attribute_type<j>::type:: typename CMap::Helper::template Attribute_type<j>::type::
On_split>::run(*a1, *a2); On_split>::run(*a1, *a2);
} }
else else
@ -1002,7 +988,7 @@ namespace CGAL
a1->set_dart(adart); a1->set_dart(adart);
// std::cout<<"A1 "<<&*a1<<" "<<&**itj<<": "; // std::cout<<"A1 "<<&*a1<<" "<<&**itj<<": ";
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, adart, mark); itj(*amap, adart, mark);
itj.cont(); ++itj ) itj.cont(); ++itj )
{ {
@ -1016,24 +1002,24 @@ namespace CGAL
} }
template <unsigned int j> template <unsigned int j>
static void run( Map* amap, static void run( CMap* amap,
std::deque<typename Map::Dart_handle> std::deque<typename CMap::Dart_handle>
*modified_darts, *modified_darts,
int mark_modified_darts int mark_modified_darts
/*, /*,
std::deque<typename Map::Dart_handle> std::deque<typename CMap::Dart_handle>
*modified_darts2*/) *modified_darts2*/)
{ {
if ( i==j ) return; if ( i==j ) return;
CGAL_assertion( amap!=NULL ); CGAL_assertion( amap!=NULL );
std::set<typename Map::Helper::template std::set<typename CMap::Helper::template
Attribute_handle<j>::type> found_attributes; Attribute_handle<j>::type> found_attributes;
int mark = amap->get_new_mark(); int mark = amap->get_new_mark();
int nb=0; int nb=0;
for ( typename std::deque<typename Map::Dart_handle>:: for ( typename std::deque<typename CMap::Dart_handle>::
iterator it=modified_darts->begin(); iterator it=modified_darts->begin();
it!=modified_darts->end(); ++it ) it!=modified_darts->end(); ++it )
{ {
@ -1041,7 +1027,7 @@ namespace CGAL
if ( i!=1 && j==0 ) if ( i!=1 && j==0 )
{ {
typename Map::Dart_handle od = (*it)->other_extremity(); typename CMap::Dart_handle od = (*it)->other_extremity();
if ( od!=NULL ) if ( od!=NULL )
test_one_dart<j>(amap, od, found_attributes, mark); test_one_dart<j>(amap, od, found_attributes, mark);
} }
@ -1049,7 +1035,7 @@ namespace CGAL
/* if ( i+1==j ) /* if ( i+1==j )
{ {
for ( typename std::deque<typename Map::Dart_handle>:: for ( typename std::deque<typename CMap::Dart_handle>::
iterator it=modified_darts2->begin(); iterator it=modified_darts2->begin();
it!=modified_darts2->end(); ++it ) it!=modified_darts2->end(); ++it )
{ {
@ -1057,7 +1043,7 @@ namespace CGAL
if ( i!=1 && j==0 ) if ( i!=1 && j==0 )
{ {
typename Map::Dart_handle od = (*it)->other_extremity(); typename CMap::Dart_handle od = (*it)->other_extremity();
if ( od!=NULL ) if ( od!=NULL )
test_one_dart<j>(amap, od, found_attributes, mark); test_one_dart<j>(amap, od, found_attributes, mark);
} }
@ -1071,7 +1057,7 @@ namespace CGAL
// Now we unmark all the marked darts. // Now we unmark all the marked darts.
amap->negate_mark(mark); amap->negate_mark(mark);
for ( typename std::deque<typename Map::Dart_handle>:: for ( typename std::deque<typename CMap::Dart_handle>::
iterator it=modified_darts->begin(); iterator it=modified_darts->begin();
it!=modified_darts->end(); ++it ) it!=modified_darts->end(); ++it )
{ {
@ -1079,7 +1065,7 @@ namespace CGAL
amap->unmark(*it, mark_modified_darts); amap->unmark(*it, mark_modified_darts);
if ( !amap->is_marked(*it, mark) ) if ( !amap->is_marked(*it, mark) )
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, *it, mark); itj(*amap, *it, mark);
itj.cont(); ++itj ) itj.cont(); ++itj )
{ {
@ -1088,9 +1074,9 @@ namespace CGAL
if ( i!=1 && j==0 ) if ( i!=1 && j==0 )
{ {
typename Map::Dart_handle od = (*it)->other_extremity(); typename CMap::Dart_handle od = (*it)->other_extremity();
if ( od!=NULL && !amap->is_marked(od, mark) ) if ( od!=NULL && !amap->is_marked(od, mark) )
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, od, mark); itj(*amap, od, mark);
itj.cont(); ++itj ) itj.cont(); ++itj )
{ {
@ -1101,7 +1087,7 @@ namespace CGAL
/* if ( i+1==j ) /* if ( i+1==j )
{ {
for ( typename std::deque<typename Map::Dart_handle>:: for ( typename std::deque<typename CMap::Dart_handle>::
iterator it=modified_darts2->begin(); iterator it=modified_darts2->begin();
it!=modified_darts2->end(); ++it ) it!=modified_darts2->end(); ++it )
{ {
@ -1109,7 +1095,7 @@ namespace CGAL
amap->unmark(*it, mark_modified_darts); amap->unmark(*it, mark_modified_darts);
if ( !amap->is_marked(*it, mark) ) if ( !amap->is_marked(*it, mark) )
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, *it, mark); itj(*amap, *it, mark);
itj.cont(); ++itj ) itj.cont(); ++itj )
{ {
@ -1118,9 +1104,9 @@ namespace CGAL
if ( i!=1 && j==0 ) if ( i!=1 && j==0 )
{ {
typename Map::Dart_handle od = (*it)->other_extremity(); typename CMap::Dart_handle od = (*it)->other_extremity();
if ( od!=NULL && !amap->is_marked(od, mark) ) if ( od!=NULL && !amap->is_marked(od, mark) )
for ( CMap_dart_iterator_basic_of_cell<Map,j> for ( CMap_dart_iterator_basic_of_cell<CMap,j>
itj(*amap, od, mark); itj(*amap, od, mark);
itj.cont(); ++itj ) itj.cont(); ++itj )
{ {