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

cont...

This commit is contained in:
Guillaume Damiand 2013-02-13 22:17:09 +01:00
parent 173f8bc073
commit 6035180c7a
9 changed files with 1578 additions and 1525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Combinatorial_map/include/CGAL/Combinatorial_map.h
View File

@ -22,12 +22,13 @@
#include <CGAL/Compact_container.h> #include <CGAL/Compact_container.h>
#include <CGAL/internal/Combinatorial_map_utility.h> #include <CGAL/internal/Combinatorial_map_utility.h>
#include <CGAL/internal/Combinatorial_map_functors.h>
#include <CGAL/internal/Combinatorial_map_sewable.h> #include <CGAL/internal/Combinatorial_map_sewable.h>
#include <CGAL/Combinatorial_map_functors.h>
#include <CGAL/Combinatorial_map_min_items.h> #include <CGAL/Combinatorial_map_min_items.h>
#include <CGAL/Dart_const_iterators.h> #include <CGAL/Dart_const_iterators.h>
#include <CGAL/Cell_const_iterators.h> #include <CGAL/Cell_const_iterators.h>
#include <CGAL/Combinatorial_map_basic_operations.h> #include <CGAL/Combinatorial_map_basic_operations.h>
#include <CGAL/Combinatorial_map_functors.h>
#include <bitset> #include <bitset>
#include <vector> #include <vector>
#include <deque> #include <deque>
@ -55,6 +56,7 @@ namespace CGAL {
class Alloc_=CGAL_ALLOCATOR(int) > class Alloc_=CGAL_ALLOCATOR(int) >
class Combinatorial_map_base class Combinatorial_map_base
{ {
/*
template<class Map, unsigned int i, unsigned int nmi> template<class Map, unsigned int i, unsigned int nmi>
friend struct Remove_cell_functor; friend struct Remove_cell_functor;
@ -87,7 +89,7 @@ namespace CGAL {
typename Map::Dart_handle typename Map::Dart_handle
insert_cell_0_in_cell_2(Map& amap, typename Map::Dart_handle adart); insert_cell_0_in_cell_2(Map& amap, typename Map::Dart_handle adart);
/*template<typename CMap, unsigned int i, typename Type_attr, typename Range> template<typename CMap, unsigned int i, typename Type_attr, typename Range>
friend struct internal::Degroup_one_attribute_of_dart_functor; friend struct internal::Degroup_one_attribute_of_dart_functor;
template<typename CMap, unsigned int i, typename T> template<typename CMap, unsigned int i, typename T>
@ -101,11 +103,10 @@ namespace CGAL {
template <typename CMap, unsigned int i, typename Type_attr> template <typename CMap, unsigned int i, typename Type_attr>
friend struct internal::Degroup_one_attribute_functor; friend struct internal::Degroup_one_attribute_functor;
*/
template<typename Map> template<typename Map>
friend struct internal::Test_is_valid_attribute_functor; friend struct internal::Test_is_valid_attribute_functor;
template<typename Map> template<typename Map>
friend struct internal::Update_dart_of_attribute_functor; friend struct internal::Update_dart_of_attribute_functor;
@ -114,7 +115,7 @@ namespace CGAL {
template<typename Map, unsigned int i, typename Enabled> template<typename Map, unsigned int i, typename Enabled>
friend struct internal::Update_dart_of_one_attribute_functor; friend struct internal::Update_dart_of_one_attribute_functor;
*/
public: public:
/// Types definition /// Types definition
typedef Combinatorial_map_base<d_, Refs, Items_,Alloc_> Self; typedef Combinatorial_map_base<d_, Refs, Items_,Alloc_> Self;
@ -328,12 +329,12 @@ namespace CGAL {
Dart_const_handle beta(Dart_const_handle ADart, Betas... betas) const Dart_const_handle beta(Dart_const_handle ADart, Betas... betas) const
{ return internal::Beta_functor<Dart_const_handle, Betas ...>:: { return internal::Beta_functor<Dart_const_handle, Betas ...>::
run(ADart, betas...); } run(ADart, betas...); }
template<typename ... Betas> template<int ... Betas>
Dart_handle beta(Dart_handle ADart) const Dart_handle beta(Dart_handle ADart) const
{ return internal::Beta_functor_static<Dart_handle, Betas ...>:: { return internal::Beta_functor_static<Dart_handle, Betas ...>::
run(ADart); } run(ADart); }
template<typename ... Betas> template<int ... Betas>
Dart_const_handle beta(Dart_const_handle ADart, Betas... betas) const Dart_const_handle beta(Dart_const_handle ADart) const
{ return internal::Beta_functor_static<Dart_const_handle, Betas ...>:: { return internal::Beta_functor_static<Dart_const_handle, Betas ...>::
run(ADart); } run(ADart); }
#else #else
@ -707,8 +708,8 @@ namespace CGAL {
marks[i] = -1; marks[i] = -1;
Helper::template Helper::template
Foreach_enabled_attributes<internal::Reserve_mark_functor<Self> >:: Foreach_enabled_attributes<Reserve_mark_functor<Self> >::
run(this,&marks); run(this,&marks);
for ( typename Dart_range::const_iterator it(darts().begin()), for ( typename Dart_range::const_iterator it(darts().begin()),
itend(darts().end()); it!=itend; ++it) itend(darts().end()); it!=itend; ++it)
@ -831,7 +832,7 @@ namespace CGAL {
if ( attribs ) if ( attribs )
{ {
Helper::template Foreach_enabled_attributes Helper::template Foreach_enabled_attributes
<internal::Display_attribute_functor<Self> >::run(this, it); <Display_attribute_functor<Self> >::run(this, it);
} }
os << std::endl; os << std::endl;
++nb; ++nb;

433
Combinatorial_map/include/CGAL/Combinatorial_map_functors.h Normal file
View File

@ -0,0 +1,433 @@
// Copyright (c) 2010-2011 CNRS and LIRIS' Establishments (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 Lesser 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$
//
// Author(s) : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
//
#ifndef CGAL_COMBINATORIAL_MAP_FUNCTORS_H
#define CGAL_COMBINATORIAL_MAP_FUNCTORS_H
#include <CGAL/Dart_const_iterators.h>
#include <CGAL/Cell_const_iterators.h>
#include <CGAL/Combinatorial_map_basic_operations.h>
#include <vector>
/* Definition of functors used to manage attributes (we need functors as
* attributes are stored in tuple, thus all the access must be done at
* compiling time). Some of these functors are used with
* Foreach_enabled_attributes to iterate through all the non void attribs.
* Functors allowing to group/ungroup attributes are defined in
* Combinatorial_map_group_functors.h (included at the end of this file)
*
* Reserve_mark_functor<CMap> to reserve one mark for each non void attribute.
*
* Set_i_attribute_functor<CMap, i> to set the i-attribute of a given
* i-cell.
*
* internal::Call_split_functor<CMap,i> to call the OnSplit functors on two
* given i-attributes.
*
* internal::Call_merge_functor<CMap,i> to call the OnMerge functors on two
* given i-attributes.
*
* internal::Test_is_valid_attribute_functor<CMap> to test if a given i-cell is
* valid (all its darts are linked to the same attribute, no other dart is
* linked with this attribute).
*
* internal::Count_cell_functor<CMap> to count the nuber of i-cells.
*
* internal::Count_bytes_one_attribute_functor<CMap> to count the memory
* occupied by i-attributes.
*
* internal::Decrease_attribute_functor<CMap> to decrease by one the ref
* counting of a given i-attribute.
*
* internal::Beta_functor<Dart, i...> to call several beta on the given dart.
* Indices are given as parameter of the run function.
*
* internal::Beta_functor_static<Dart, i...> to call several beta on the given
* dart. Indices are given as template arguments.
*
* internal::Set_i_attribute_of_dart_functor<CMap, i> to set the i-attribute
* of a given dart.
*/
namespace CGAL
{
/** @file Combinatorial_map_functors.h
* Definition of functors used for dD Combinatorial map.
*/
// **************************************************************************
/// 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 display the address of the i-cell attribute
template<typename CMap>
struct Display_attribute_functor
{
template <unsigned int i>
static void run(const CMap* amap,
typename CMap::Dart_const_handle adart)
{
if ( adart->template attribute<i>()==NULL )
std::cout<<"NULL";
else
std::cout<<&*(adart->template attribute<i>());
}
};
// **************************************************************************
namespace internal
{
// Functor which call Functor::operator() on the two given cell_attributes
template<typename Cell_attribute, typename Functor>
struct Apply_cell_functor
{
static void run(Cell_attribute& acell1, Cell_attribute& acell2)
{
Functor() (acell1,acell2);
}
};
//...except for Null_functor.
template<typename Cell_attribute>
struct Apply_cell_functor<Cell_attribute,Null_functor>
{
static void run(Cell_attribute&, Cell_attribute&)
{}
};
// **************************************************************************
// Functor used to call the On_split functor between the two given darts.
template<typename CMap, unsigned int i,
typename Enabled=typename CMap::Helper::
#ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG
template
#endif
Attribute_type<i>::type>
struct Call_split_functor
{
static void run(typename CMap::Dart_handle adart1,
typename CMap::Dart_handle adart2)
{
Apply_cell_functor
<typename CMap::Helper::template Attribute_type<i>::type,
typename CMap::Helper::
template Attribute_type<i>::type::On_split>::
run(*(adart1->template attribute<i>()),
*(adart2->template attribute<i>()));
}
static void
run(typename CMap::Helper::template Attribute_handle<i>::type a1,
typename CMap::Helper::template Attribute_handle<i>::type a2)
{
Apply_cell_functor
<typename CMap::Helper::template Attribute_type<i>::type,
typename CMap::Helper::
template Attribute_type<i>::type::On_split>::
run(*a1, *a2);
}
};
// Specialization for disabled attributes.
template<typename CMap,unsigned int i>
struct Call_split_functor<CMap,i,CGAL::Void>
{
static void run(typename CMap::Dart_handle,
typename CMap::Dart_handle)
{}
};
// **************************************************************************
// Functor used to call the On_merge functor between the two given darts.
template<typename CMap,unsigned int i,
typename Enabled=typename CMap::Helper::
#ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG
template
#endif
Attribute_type<i>::type>
struct Call_merge_functor
{
static void run(typename CMap::Dart_handle adart1,
typename CMap::Dart_handle adart2)
{
Apply_cell_functor
<typename CMap::Helper::template Attribute_type<i>::type,
typename CMap::Helper::template Attribute_type<i>::type::On_merge>::
run(*(adart1->template attribute<i>()),
*(adart2->template attribute<i>()));
}
static void
run(typename CMap::Helper::template Attribute_handle<i>::type a1,
typename CMap::Helper::template Attribute_handle<i>::type a2)
{
Apply_cell_functor
<typename CMap::Helper::template Attribute_type<i>::type,
typename CMap::Helper::template Attribute_type<i>::type::On_merge>::
run(*a1, *a2);
}
};
// Specialization for disabled attributes.
template<typename CMap,unsigned int i>
struct Call_merge_functor<CMap,i,CGAL::Void>
{
static void run(typename CMap::Dart_handle,
typename CMap::Dart_handle)
{}
};
// **************************************************************************
/// 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;
}
};
// **************************************************************************
/// Decrease the cell attribute reference counting of the given dart.
/// The attribute is removed if there is no more darts linked with it.
template<typename CMap, unsigned int i, typename T=
typename CMap::Helper::template Attribute_type<i>::type>
struct Decrease_attribute_functor_run
{
static void run(CMap* amap, typename CMap::Dart_handle adart)
{
if ( adart->template attribute<i>()!=NULL )
{
adart->template attribute<i>()->dec_nb_refs();
if ( adart->template attribute<i>()->get_nb_refs()==0 )
amap->template erase_attribute<i>(adart->template attribute<i>());
}
}
};
/// Specialization for void attributes.
template<typename CMap, unsigned int i>
struct Decrease_attribute_functor_run<CMap,i,CGAL::Void>
{
static void run(CMap*, typename CMap::Dart_handle)
{}
};
// **************************************************************************
/// 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)
{ Decrease_attribute_functor_run<CMap,i>::run(amap, adart); }
};
// **************************************************************************
/// Functor used to set the i-attribute of a given dart.
template<typename CMap, unsigned int i, typename T=
typename CMap::Helper::template Attribute_type<i>::type>
struct Set_i_attribute_of_dart_functor
{
static void run( CMap* amap, typename CMap::Dart_handle dh,
typename CMap::Helper::template Attribute_handle<i>::type
ah )
{
CGAL_static_assertion(i<=CMap::dimension);
CGAL_assertion( dh!=NULL && dh!=CMap::null_dart_handle );
if ( dh->template attribute<i>()==ah ) return;
Decrease_attribute_functor_run<CMap, i>::run(amap, dh);
dh->template set_attribute<i>(ah);
}
};
/// Specialization for void attributes.
template<typename CMap, unsigned int i>
struct Set_i_attribute_of_dart_functor<CMap,i,CGAL::Void>
{
static void run( CMap*, typename CMap::Dart_handle,
typename CMap::Helper::template Attribute_handle<i>::type)
{}
};
// **************************************************************************
// Beta functor, used to combine several beta.
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Dart_handle, typename ... Betas>
struct Beta_functor;
template<typename Dart_handle, typename ... Betas>
struct Beta_functor<Dart_handle, int, Betas...>
{
static Dart_handle run(Dart_handle ADart, int B, Betas... betas)
{ return Beta_functor<Dart_handle, Betas...>::run(ADart->beta(B),
betas...); }
};
template<typename Dart_handle>
struct Beta_functor<Dart_handle, int>
{
static Dart_handle run(Dart_handle ADart, int B)
{
CGAL_assertion( ADart!=NULL );
return ADart->beta(B);
}
};
// **************************************************************************
template<typename Dart_handle, int ... Betas>
struct Beta_functor_static;
template<typename Dart_handle, int B, int ... Betas>
struct Beta_functor_static<Dart_handle, B, Betas...>
{
static Dart_handle run(Dart_handle ADart)
{ return Beta_functor_static<Dart_handle, Betas...>::
run(ADart->template beta<B>()); }
};
template<typename Dart_handle, int B>
struct Beta_functor_static<Dart_handle, B>
{
static Dart_handle run(Dart_handle ADart)
{
CGAL_assertion( ADart!=NULL );
return ADart->template beta<B>();
}
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
// **************************************************************************
/// Functor used to call update_dart_of_attribute<i>
/// on each i-cell attribute enabled
// TODO REMOVE ?
template<typename CMap>
struct Update_dart_of_attribute_functor
{
template <unsigned int i>
static void run(CMap* amap, typename CMap::Dart_handle ah, int amark)
{ amap->template update_dart_of_attribute<i>(ah,amark); }
};
template<typename CMap, unsigned int i, typename Enabled=
typename CMap::Helper::
#ifndef CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG
template
#endif
Attribute_type<i>::type>
struct Update_dart_of_one_attribute_functor
{
static void run(CMap* amap, typename CMap::Dart_handle ah, int amark)
{ amap->template update_dart_of_attribute<i>(ah,amark); }
};
template<typename CMap, unsigned int i>
struct Update_dart_of_one_attribute_functor<CMap, i, CGAL::Void>
{
static void run(CMap*, typename CMap::Dart_handle, int)
{}
};
// **************************************************************************
} // namespace internal
// **************************************************************************
/// Functor used to set the i-attribute of a given i-cell.
/// We can use any range as Range type, by default we use
/// Dart_of_cell_range<i>
template<typename CMap, unsigned int i,
typename Range=typename CMap::template Dart_of_cell_range<i>,
typename T=typename CMap::Helper::template Attribute_type<i>::type>
struct Set_i_attribute_functor
{
static void run( CMap* amap, typename CMap::Dart_handle dh,
typename CMap::Helper::template Attribute_handle<i>::type
ah )
{
CGAL_static_assertion(i<=CMap::dimension);
CGAL_assertion( dh!=NULL && dh!=CMap::null_dart_handle && ah!=NULL );
for ( typename Range::iterator it(*amap, dh); it.cont(); ++it)
{
if ( it->template attribute<i>()!=ah )
{
internal::Decrease_attribute_functor_run<CMap, i>::run(amap, it);
it->template set_attribute<i>(ah);
}
}
ah->set_dart(dh);
}
};
/// Specialization for void attributes.
template<typename CMap, unsigned int i>
struct Set_i_attribute_functor<CMap,i,CGAL::Void>
{
static void run( CMap*, typename CMap::Dart_handle,
typename CMap::Helper::template Attribute_handle<i>::type)
{}
};
// **************************************************************************
} // namespace CGAL
#include <CGAL/internal/Combinatorial_map_group_functors.h>
#endif // CGAL_COMBINATORIAL_MAP_FUNCTORS_H //
// EOF //

82
Combinatorial_map/include/CGAL/Combinatorial_map_insertions.h
View File

@ -50,7 +50,13 @@ insert_cell_0_in_cell_1( CMap& amap, typename CMap::Dart_handle adart,
} }
} }
amap.link_beta_1(*it, d1); amap.basic_link_beta_1(*it, d1);
// We copy all the attributes except for dim=0
CMap::Helper::template Foreach_enabled_attributes_except
<internal::Group_attribute_functor_of_dart<CMap>, 0>::
run(&amap,*it,d1);
// We initialise the 0-atttrib to ah
internal::Set_i_attribute_of_dart_functor<CMap, 0>::run(&amap, d1, ah); internal::Set_i_attribute_of_dart_functor<CMap, 0>::run(&amap, d1, ah);
amap.mark(*it, mark); amap.mark(*it, mark);
} }
@ -61,6 +67,9 @@ insert_cell_0_in_cell_1( CMap& amap, typename CMap::Dart_handle adart,
amap.unmark(*it, mark); amap.unmark(*it, mark);
} }
CGAL_assertion(amap.is_whole_map_unmarked(m));
CGAL_assertion(amap.is_whole_map_unmarked(mark));
amap.free_mark(m); amap.free_mark(m);
amap.free_mark(mark); amap.free_mark(mark);
@ -102,16 +111,16 @@ insert_cell_0_in_cell_2( CMap& amap, typename CMap::Dart_handle adart,
int treated = amap.get_new_mark(); int treated = amap.get_new_mark();
// Stack of marked darts // Stack of marked darts
std::stack<typename CMap::Dart_handle> tounmark; std::deque<typename CMap::Dart_handle> tounmark;
// Now we run through the facet // Now we run through the facet
for ( CGAL::CMap_dart_iterator_basic_of_orbit<CMap,1> it(amap, first); for ( CGAL::CMap_dart_iterator_basic_of_orbit<CMap, 1> it(amap, first);
it.cont(); ) it.cont(); )
{ {
cur = it; cur = it;
++it; ++it;
amap.mark(cur, treated); amap.mark(cur, treated);
tounmark.push(cur); tounmark.push_back(cur);
if (!cur->template is_free<0>()) if (!cur->template is_free<0>())
{ {
@ -170,7 +179,7 @@ insert_cell_0_in_cell_2( CMap& amap, typename CMap::Dart_handle adart,
(nn1, prev->beta(dim)); (nn1, prev->beta(dim));
amap.mark(cur->beta(dim), treated); amap.mark(cur->beta(dim), treated);
tounmark.push(cur->beta(dim)); tounmark.push_back(cur->beta(dim));
} }
else else
{ {
@ -189,8 +198,8 @@ insert_cell_0_in_cell_2( CMap& amap, typename CMap::Dart_handle adart,
if (n2 != NULL) if (n2 != NULL)
{ {
amap.template basic_link_beta_for_involution<2>(first->template beta<0>(), amap.template basic_link_beta_for_involution<2>
n2); (first->template beta<0>(), n2);
for (unsigned int dim=3; dim<=CMap::dimension; ++dim) for (unsigned int dim=3; dim<=CMap::dimension; ++dim)
{ {
if ( !adart->is_free(dim) ) if ( !adart->is_free(dim) )
@ -203,15 +212,14 @@ insert_cell_0_in_cell_2( CMap& amap, typename CMap::Dart_handle adart,
// Now we unmark all marked darts, and we degroup the new faces with the // Now we unmark all marked darts, and we degroup the new faces with the
// initial one (if 2-attributes are non void). // initial one (if 2-attributes are non void).
while ( !tounmark.empty() ) for ( typename std::deque<typename CMap::Dart_handle>::iterator
itd=tounmark.begin(); itd!=tounmark.end(); ++itd )
{ {
amap.unmark(tounmark.top(), treated); amap.unmark(*itd, treated);
if ( tounmark.top()!=adart ) if ( *itd!=adart )
internal::Degroup_attribute_functor_run<CMap, 2>:: internal::Degroup_attribute_functor_run<CMap, 2>::
run(&amap, adart, tounmark.top()); run(&amap, adart, *itd);
tounmark.pop();
} }
CGAL_assertion(amap.is_whole_map_unmarked(treated)); CGAL_assertion(amap.is_whole_map_unmarked(treated));
@ -250,9 +258,10 @@ insert_dangling_cell_1_in_cell_2( CMap& amap,
typename CMap::Dart_handle d2 = NULL; typename CMap::Dart_handle d2 = NULL;
unsigned int s1 = 0; unsigned int s1 = 0;
int treated = amap.get_new_mark(); int treated=amap.get_new_mark();
CGAL::CMap_dart_iterator_of_involution<CMap,1> it1(amap, adart1); CGAL::CMap_dart_iterator_basic_of_involution<CMap,1>
it1(amap, adart1, treated);
for ( ; it1.cont(); ++it1) for ( ; it1.cont(); ++it1)
{ {
@ -288,25 +297,27 @@ insert_dangling_cell_1_in_cell_2( CMap& amap,
if ( !it1->is_free(dim) && if ( !it1->is_free(dim) &&
amap.is_marked(it1->beta(dim), treated) ) amap.is_marked(it1->beta(dim), treated) )
{ {
amap.basic_link_beta_for_involution(it1->beta(dim)->beta_inv(s1), d1, amap.basic_link_beta_for_involution
dim); (it1->beta(dim)->beta_inv(s1), d1, dim);
amap.basic_link_beta_for_involution amap.basic_link_beta_for_involution
(it1->beta(dim)->beta_inv(s1)->beta(2), d2, dim); (it1->beta(dim)->beta_inv(s1)->beta(2), d2, dim);
} }
} }
internal::Set_i_attribute_of_dart_functor<CMap, 0>::run(&amap, d1, ah); internal::Set_i_attribute_of_dart_functor<CMap, 0>::run(&amap, d1, ah);
amap.mark(it1,treated); amap.mark(it1, treated);
} }
amap.negate_mark(treated);
for ( it1.rewind(); it1.cont(); ++it1 ) for ( it1.rewind(); it1.cont(); ++it1 )
{ amap.unmark(it1,treated); } { amap.mark(it1, treated); }
CGAL_assertion( amap.is_whole_map_unmarked(treated) );
CGAL_assertion( amap.is_whole_map_marked(treated) );
amap.free_mark(treated); amap.free_mark(treated);
typename std::deque<typename CMap::Dart_handle>::iterator it = for ( typename std::deque<typename CMap::Dart_handle>::iterator
to_unmark.begin(); it=to_unmark.begin(); it!=to_unmark.end(); ++it)
for (; it != to_unmark.end(); ++it)
{ amap.unmark(*it, mark1); } { amap.unmark(*it, mark1); }
CGAL_assertion( amap.is_whole_map_unmarked(mark1) ); CGAL_assertion( amap.is_whole_map_unmarked(mark1) );
amap.free_mark(mark1); amap.free_mark(mark1);
@ -353,29 +364,30 @@ insert_cell_1_in_cell_2(CMap& amap,
CGAL_assertion(is_insertable_cell_1_in_cell_2<CMap>(amap, adart1, adart2)); CGAL_assertion(is_insertable_cell_1_in_cell_2<CMap>(amap, adart1, adart2));
int m1 = amap.get_new_mark(); int m1=amap.get_new_mark();
CMap_dart_iterator_basic_of_involution<CMap,1> CMap_dart_iterator_basic_of_involution<CMap,1>
it1 = CMap_dart_iterator_basic_of_involution<CMap,1>(amap, adart1, m1); it1 = CMap_dart_iterator_basic_of_involution<CMap,1>(amap, adart1, m1);
int m2 = amap.get_new_mark();
int m2=amap.get_new_mark();
CMap_dart_iterator_basic_of_involution<CMap,1> CMap_dart_iterator_basic_of_involution<CMap,1>
it2 = CMap_dart_iterator_basic_of_involution<CMap,1>(amap, adart2, m2); it2 = CMap_dart_iterator_basic_of_involution<CMap,1>(amap, adart2, m2);
int mark1 = amap.get_new_mark(); int mark1=amap.get_new_mark();
std::deque<typename CMap::Dart_handle> to_unmark; std::deque<typename CMap::Dart_handle> to_unmark;
{ {
for ( CMap_dart_iterator_basic_of_cell<CMap,0> it(amap,adart1,mark1); for ( CMap_dart_iterator_basic_of_cell<CMap,0> it(amap,adart1,mark1);
it.cont(); ++it ) it.cont(); ++it )
{ {
to_unmark.push_back(it); to_unmark.push_back(it);
amap.mark(it,mark1); amap.mark(it, mark1);
} }
} }
typename CMap::Dart_handle d1 = NULL; typename CMap::Dart_handle d1=NULL;
typename CMap::Dart_handle d2 = NULL; typename CMap::Dart_handle d2=NULL;
unsigned int s1 = 0; unsigned int s1=0;
int treated = amap.get_new_mark(); int treated=amap.get_new_mark();
for ( ; it1.cont(); ++it1, ++it2) for ( ; it1.cont(); ++it1, ++it2)
{ {
@ -388,14 +400,14 @@ insert_cell_1_in_cell_2(CMap& amap,
if ( !it1->is_free(s1) ) if ( !it1->is_free(s1) )
{ {
if ( s1==0 ) amap.basic_link_beta_1(it1->template beta<0>(), d2); if ( s1==0 ) amap.link_beta_1(it1->template beta<0>(), d2);
else amap.basic_link_beta_0(it1->template beta<1>(), d2); else amap.link_beta_0(it1->template beta<1>(), d2);
} }
if ( !it2->is_free(s1) ) if ( !it2->is_free(s1) )
{ {
if ( s1==0 ) amap.basic_link_beta_1(it2->template beta<0>(), d1); if ( s1==0 ) amap.link_beta_1(it2->template beta<0>(), d1);
else amap.basic_link_beta_0(it2->template beta<1>(), d1); else amap.link_beta_0(it2->template beta<1>(), d1);
} }
if ( s1==0 ) if ( s1==0 )

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

File diff suppressed because it is too large Load Diff

1000
Combinatorial_map/include/CGAL/internal/Combinatorial_map_group_functors.h
View File

File diff suppressed because it is too large Load Diff

2
Combinatorial_map/include/CGAL/internal/Combinatorial_map_sewable.h
View File

@ -20,6 +20,8 @@
#ifndef CGAL_COMBINATORIAL_MAP_SEWABLE_H #ifndef CGAL_COMBINATORIAL_MAP_SEWABLE_H
#define CGAL_COMBINATORIAL_MAP_SEWABLE_H #define CGAL_COMBINATORIAL_MAP_SEWABLE_H
#include <CGAL/Dart_const_iterators.h>
/* Definition of functor used to test if two darts are i-sewable /* Definition of functor used to test if two darts are i-sewable
* (we use functors as there are different specializations). * (we use functors as there are different specializations).
*/ */

4
Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h
View File

@ -539,7 +539,7 @@ namespace CGAL
{ {
template <class ...Ts> template <class ...Ts>
static void run(const Ts& ... t) static void run(const Ts& ... t)
{ Foreach_static_restricted<Functor,Attributes >::run(t...); } { Foreach_static_restricted<Functor, Attributes>::run(t...); }
}; };
// To iterate onto each enabled attributes, except j-attributes // To iterate onto each enabled attributes, except j-attributes
template <class Functor, unsigned int j> template <class Functor, unsigned int j>
@ -547,7 +547,7 @@ namespace CGAL
{ {
template <class ...Ts> template <class ...Ts>
static void run(const Ts& ... t) static void run(const Ts& ... t)
{ Foreach_static_restricted_except<Functor,Attributes,j>::run(t...); } { Foreach_static_restricted_except<Functor, j, Attributes>::run(t...); }
}; };
#else #else
// This one cannot be moved in Combinatorial_map_utility_novariadic.h // This one cannot be moved in Combinatorial_map_utility_novariadic.h

3
Linear_cell_complex/demo/Linear_cell_complex/MainWindow.cpp
View File

@ -168,7 +168,8 @@ void MainWindow::clear_all()
void MainWindow::on_new_volume(Dart_handle adart) void MainWindow::on_new_volume(Dart_handle adart)
{ {
assert( adart->attribute<3>()==NULL); assert( adart->attribute<3>()==NULL);
scene.lcc->set_attribute<3>(adart,scene.lcc->create_attribute<3>()); CGAL::Set_i_attribute_functor<LCC, 3>::
run(scene.lcc, adart, scene.lcc->create_attribute<3>());
update_volume_list_add(adart->attribute<3>()); update_volume_list_add(adart->attribute<3>());
} }

2
Linear_cell_complex/include/CGAL/Linear_cell_complex.h
View File

@ -194,7 +194,7 @@ namespace CGAL {
*/ */
void set_vertex_attribute(Dart_handle adart, void set_vertex_attribute(Dart_handle adart,
Vertex_attribute_handle ah) Vertex_attribute_handle ah)
{ return internal::Set_i_attribute_functor<Self, 0>::run(this, adart,ah); } { return Set_i_attribute_functor<Self, 0>::run(this, adart,ah); }
/// @return the Vertex_attribute_range for all vertex_attributes. /// @return the Vertex_attribute_range for all vertex_attributes.
Vertex_attribute_range& vertex_attributes() Vertex_attribute_range& vertex_attributes()