diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map.h b/Combinatorial_map/include/CGAL/Combinatorial_map.h index c4089b37ef3..8b2f4a7b861 100644 --- a/Combinatorial_map/include/CGAL/Combinatorial_map.h +++ b/Combinatorial_map/include/CGAL/Combinatorial_map.h @@ -31,6 +31,7 @@ #include #include #include +#include #include #include #include @@ -3735,6 +3736,711 @@ namespace CGAL { this->automatic_attributes_management = newval; } + /** Test if an i-cell can be removed. + * An i-cell can be removed if i==dimension or i==dimension-1, + * or if there are at most two (i+1)-cell incident to it. + * @param adart a dart of the i-cell. + * @return true iff the i-cell can be removed. + */ + template < unsigned int i > + bool is_removable(Dart_const_handle adart) const + { return CGAL::Is_removable_functor::run(*this, adart); } + + /** Remove an i-cell, 0<=i<=dimension. + * @param adart a dart of the i-cell to remove. + * @param update_attributes a boolean to update the enabled attributes + * @return the number of deleted darts. + */ + template < unsigned int i > + size_t remove_cell(Dart_handle adart, bool update_attributes = true) + { + return CGAL::Remove_cell_functor:: + run(*this,adart,update_attributes); + } + + /** Test if an i-cell can be contracted. + * An i-cell can be contracted if i==1 + * or if there are at most two (i-1)-cell incident to it. + * @param adart a dart of the i-cell. + * @return true iff the i-cell can be contracted. + */ + template < unsigned int i > + bool is_contractible(Dart_const_handle adart) + { return CGAL::Is_contractible_functor::run(*this,adart); } + + /** Contract an i-cell, 1<=i<=dimension. + * @param adart a dart of the i-cell to remove. + * @return the number of deleted darts. + */ + template < unsigned int i > + size_t contract_cell(Dart_handle adart, bool update_attributes = true) + { + return CGAL::Contract_cell_functor:: + run(*this,adart, update_attributes); + } + + /** Insert a vertex in a given edge. + * @param adart a dart of the edge (!=NULL && !=null_dart_handle). + * @param update_attributes a boolean to update the enabled attributes + * @return a dart of the new vertex. + */ + Dart_handle insert_cell_0_in_cell_1( Dart_handle adart, + typename Attribute_handle<0>::type + ah=null_handle, + bool update_attributes=true ) + { + Dart_handle d1, d2; + size_type mark=get_new_mark(); + + // 1) We store all the darts of the edge. + std::deque vect; + size_type m=get_new_mark(); + { + for ( typename Dart_of_cell_basic_range<1>::iterator + it=darts_of_cell_basic<1>(adart, m).begin(); + it != darts_of_cell_basic<1>(adart, m).end(); ++it ) + vect.push_back(it); + } + + // 2) For each dart of the cell, we modify link of neighbors. + typename std::deque::iterator it = vect.begin(); + for (; it != vect.end(); ++it) + { + d1 = create_dart(); + + if (!is_free<1>(*it)) + { basic_link_beta_1(d1, beta<1>(*it)); } + + for ( unsigned int dim=2; dim<=dimension; ++dim ) + { + if (!is_free(*it, dim) && is_marked(beta(*it, dim), mark)) + { + basic_link_beta_for_involution(beta(*it, dim), d1, dim); + basic_link_beta_for_involution(*it, beta(*it, dim, 1), dim); + } + } + + basic_link_beta_1(*it, d1); + + if (are_attributes_automatically_managed() && update_attributes) + { + // We copy all the attributes except for dim=0 + Helper::template Foreach_enabled_attributes_except + , 0>:: + run(this,*it,d1); + } + if (ah != null_handle) + { + // We initialise the 0-atttrib to ah + internal::Set_i_attribute_of_dart_functor:: + run(this, d1, ah); + } + mark(*it, mark); + } + + for (it = vect.begin(); it != vect.end(); ++it) + { + unmark(*it, m); + unmark(*it, mark); + } + + CGAL_assertion(is_whole_map_unmarked(m)); + CGAL_assertion(is_whole_map_unmarked(mark)); + + free_mark(m); + free_mark(mark); + + if (are_attributes_automatically_managed() && update_attributes) + { + internal::Degroup_attribute_functor_run:: + run(this, adart, beta<1>(adart)); + } + +#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS + CGAL_assertion( is_valid() ); +#endif + + return beta<1>(adart); + } + + /** Insert a vertex in the given 2-cell which is splitted in triangles, + * once for each inital edge of the facet. + * @param adart a dart of the facet to triangulate. + * @param update_attributes a boolean to update the enabled attributes + * (deprecated, now we use are_attributes_automatically_managed()) + * @return A dart incident to the new vertex. + */ + Dart_handle insert_cell_0_in_cell_2( Dart_handle adart, + typename Attribute_handle<0>::type + ah=null_handle, + bool update_attributes=true ) + { + CGAL_assertion(adart!=null_dart_handle); + + Dart_handle first=adart, prev=null_handle, + cur=null_handle, next=null_handle, + n1=null_handle, n2=null_handle, + nn1=null_handle, nn2=null_handle; + + // If the facet is open, we search the dart 0-free + while ( !this->template is_free<0>(first) && beta<0>(first)!=adart ) + first = this->template beta<0>(first); + + // Mark used to mark darts already treated. + size_type treated = get_new_mark(); + + // Stack of marked darts + std::deque tounmark; + + // Now we run through the facet + cur = first; + do + { + next = this->template beta<1>(cur); + mark(cur, treated); + tounmark.push_back(cur); + + if (!this->template is_free<0>(cur)) + { + n1=create_dart(); + link_beta_0(cur, n1); + } + else n1 = null_handle; + + if (!this->template is_free<1>(cur)) + { + n2 = create_dart(); + link_beta_1(cur, n2); + } + else n2 = null_handle; + + if ( n1!=null_handle ) + { + if ( n2!=null_handle ) + basic_link_beta_0(n1, n2); + + if ( prev!=null_handle ) + this->template basic_link_beta_for_involution<2>(prev, n1); + + if (are_attributes_automatically_managed() && update_attributes) + { + internal::Set_i_attribute_of_dart_functor:: + run(this, n1, ah); + } + } + + for (unsigned int dim=3; dim<=dimension; ++dim) + { + if ( !is_free(adart, dim) ) + { + if ( !is_marked(beta(cur, dim), treated) ) + { + if (n1!=null_handle) + { + nn1=create_dart(); + link_beta_1(beta(cur, dim), nn1); + basic_link_beta_for_involution(n1, nn1, dim); + } + else nn1=null_handle; + + if (n2!=null_handle) + { + nn2=create_dart(); + link_beta_0(beta(cur, dim), nn2); + basic_link_beta_for_involution(n2, nn2, dim); + if (are_attributes_automatically_managed() && update_attributes) + { + internal::Set_i_attribute_of_dart_functor:: + run(this, nn2, ah); + } + } + else nn2=null_handle; + + if (nn1 != null_handle && nn2 != null_handle) + basic_link_beta_1(nn1, nn2); + + if (nn1 != null_handle && prev != null_handle) + this->template basic_link_beta_for_involution<2>(nn1, beta(prev, dim)); + + mark(beta(cur, dim), treated); + } + else + { + if ( n1!=null_handle ) + basic_link_beta_for_involution(n1, + beta(cur, dim, 1), dim); + if ( n2!=null_handle ) + basic_link_beta_for_involution(n2, + beta(cur, dim, 0), dim); + } + } + } + + prev = n2; + cur = next; + } + while(cur!=first && cur!=null_dart_handle); + + if (n2 != null_handle) + { + this->template basic_link_beta_for_involution<2> + (this->template beta<0>(first), n2); + for (unsigned int dim=3; dim<=dimension; ++dim) + { + if ( !is_free(adart, dim) ) + { + this->template basic_link_beta_for_involution<2>(beta(first, 0, dim), + beta(n2, dim)); + } + } + } + + // Now we unmark all marked darts, and we degroup the new faces with the + // initial one (if 2-attributes are non void). + for ( typename std::deque::iterator + itd=tounmark.begin(); itd!=tounmark.end(); ++itd ) + { + unmark(*itd, treated); + for (unsigned int dim=3; dim<=dimension; ++dim) + { + if ( !is_free(*itd, dim) ) + unmark(beta(*itd, dim), treated); + } + if ( *itd!=adart ) + if (are_attributes_automatically_managed() && update_attributes) + { + internal::Degroup_attribute_functor_run:: + run(this, adart, *itd); + } + } + + CGAL_assertion(is_whole_map_unmarked(treated)); + free_mark(treated); + +#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS + CGAL_assertion( is_valid() ); +#endif + + return n1; + } + + /** Insert a dangling edge in a 2-cell between given by a dart. + * @param adart1 a first dart of the facet (!=NULL && !=null_dart_handle). + * @param update_attributes a boolean to update the enabled attributes + * @return a dart of the new edge, not incident to the vertex of adart1. + */ + Dart_handle insert_dangling_cell_1_in_cell_2( Dart_handle adart1, + typename Attribute_handle<0>::type + ah=null_handle, + bool update_attributes=true ) + { + size_type mark1 = get_new_mark(); + std::deque to_unmark; + { + for ( CMap_dart_iterator_basic_of_cell it(*this,adart1,mark1); + it.cont(); ++it ) + { + to_unmark.push_back(it); + mark(it,mark1); + } + } + + Dart_handle d1 = null_handle; + Dart_handle d2 = null_handle; + unsigned int s1 = 0; + + size_type treated=get_new_mark(); + + CMap_dart_iterator_basic_of_involution it1(*this, adart1, treated); + + for ( ; it1.cont(); ++it1) + { + d1 = create_dart(); + d2 = create_dart(); + + if ( is_marked(it1, mark1) ) s1 = 0; + else s1 = 1; + + if ( !is_free(it1, s1) ) + { + if ( s1==0 ) + link_beta_1(beta<0>(it1), d2); + else + link_beta_0(beta<1>(it1), d2); + } + + if (s1==0) + { + link_beta_0(it1, d1); + link_beta_0(d1, d2); + } + else + { + link_beta_1(it1, d1); + link_beta_1(d1, d2); + } + + basic_link_beta_for_involution<2>(d1, d2); + + for ( unsigned int dim=3; dim<=dimension; ++dim) + { + if ( !is_free(it1, dim) && + is_marked(beta(it1, dim), treated) ) + { + basic_link_beta_for_involution + (beta(it1, dim, CGAL_BETAINV(s1)), d1, dim); + basic_link_beta_for_involution + (beta(it1, dim, CGAL_BETAINV(s1), 2), d2, dim); + } + } + if (are_attributes_automatically_managed() && update_attributes) + { + internal::Set_i_attribute_of_dart_functor::run(this, d1, ah); + } + mark(it1, treated); + } + + negate_mark(treated); + for ( it1.rewind(); it1.cont(); ++it1 ) + { mark(it1, treated); } + + CGAL_assertion( is_whole_map_marked(treated) ); + free_mark(treated); + + for ( typename std::deque::iterator it=to_unmark.begin(); + it!=to_unmark.end(); ++it) + { unmark(*it, mark1); } + + CGAL_assertion( is_whole_map_unmarked(mark1) ); + free_mark(mark1); + +#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS + CGAL_assertion( is_valid() ); +#endif + + return this->template beta<0>(adart1); + } + + /** Test if an edge can be inserted onto a 2-cell between two given darts. + * @param adart1 a first dart. + * @param adart2 a second dart. + * @return true iff an edge can be inserted between adart1 and adart2. + */ + bool is_insertable_cell_1_in_cell_2(Dart_const_handle adart1, + Dart_const_handle adart2) const + { + if ( adart1==adart2 ) return false; + for ( CMap_dart_const_iterator_of_orbit it(*this,adart1); + it.cont(); ++it ) + { + if ( it==adart2 ) return true; + } + return false; + } + + /** Insert an edge in a 2-cell between two given darts. + * @param adart1 a first dart of the facet (!=NULL && !=null_dart_handle). + * @param adart2 a second dart of the facet. If NULL insert a dangling edge. + * @param update_attributes a boolean to update the enabled attributes + * @return a dart of the new edge, and not incident to the + * same vertex than adart1. + */ + Dart_handle insert_cell_1_in_cell_2(Dart_handle adart1, + Dart_handle adart2, + bool update_attributes=true) + { + if ( adart2==null_handle ) + return insert_dangling_cell_1_in_cell_2(adart1, null_handle, + update_attributes); + + CGAL_assertion(is_insertable_cell_1_in_cell_2(adart1, adart2)); + + size_type m1=get_new_mark(); + CMap_dart_iterator_basic_of_involution it1(*this, adart1, m1); + + size_type m2=get_new_mark(); + CMap_dart_iterator_basic_of_involution it2(*this, adart2, m2); + + size_type mark1=get_new_mark(); + std::deque to_unmark; + { + for ( CMap_dart_iterator_basic_of_cell it(*this,adart1,mark1); + it.cont(); ++it ) + { + to_unmark.push_back(it); + mark(it, mark1); + } + } + + Dart_handle d1=null_handle; + Dart_handle d2=null_handle; + unsigned int s1=0; + + size_type treated=get_new_mark(); + + for ( ; it1.cont(); ++it1, ++it2) + { + CGAL_assertion ( it2.cont() ); + d1 = create_dart(); + d2 = create_dart(); + + if ( is_marked(it1, mark1) ) s1 = 0; + else s1 = 1; + + if ( !is_free(it1, s1) ) + { + if ( s1==0 ) link_beta_1(this->template beta<0>(it1), d2); + else link_beta_0(this->template beta<1>(it1), d2); + } + + if ( !is_free(it2, s1) ) + { + if ( s1==0 ) link_beta_1(this->template beta<0>(it2), d1); + else link_beta_0(this->template beta<1>(it2), d1); + } + + if ( s1==0 ) + { + link_beta_0(it1, d1); + link_beta_0(it2, d2); + } + else + { + link_beta_1(it1, d1); + link_beta_1(it2, d2); + } + this->template basic_link_beta_for_involution<2>(d2, d1); + + for ( unsigned int dim=3; dim<=dimension; ++dim) + { + if ( !is_free(it1, dim) && + is_marked(beta(it1, dim), treated) ) + { + basic_link_beta_for_involution + (beta(it1, dim, CGAL_BETAINV(s1)), d1, dim); + basic_link_beta_for_involution + (beta(it1, dim, CGAL_BETAINV(s1), 2), d2, dim); + } + } + + mark(it1,treated); + } + + if (are_attributes_automatically_managed() && update_attributes) + { + internal::Degroup_attribute_functor_run::run(this, d1, d2); + } + + negate_mark(m1); + negate_mark(m2); + it1.rewind(); it2.rewind(); + for ( ; it1.cont(); ++it1, ++it2) + { + mark(it1,m1); + unmark(it1,treated); + mark(it2,m2); + } + negate_mark(m1); + negate_mark(m2); + CGAL_assertion( is_whole_map_unmarked(m1) ); + CGAL_assertion( is_whole_map_unmarked(m2) ); + CGAL_assertion( is_whole_map_unmarked(treated) ); + free_mark(m1); + free_mark(m2); + free_mark(treated); + + typename std::deque::iterator it = to_unmark.begin(); + for (; it != to_unmark.end(); ++it) + { unmark(*it, mark1); } + CGAL_assertion( is_whole_map_unmarked(mark1) ); + free_mark(mark1); + +#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS + CGAL_assertion( is_valid() ); +#endif + + return this->template beta<0>(adart1); + } + + /** Test if a 2-cell can be inserted onto a given 3-cell along + * a path of edges. + * @param afirst iterator on the begining of the path. + * @param alast iterator on the end of the path. + * @return true iff a 2-cell can be inserted along the path. + */ + template + bool is_insertable_cell_2_in_cell_3(InputIterator afirst, + InputIterator alast) const + { + CGAL_assertion( dimension>= 3 ); + + // The path must have at least one dart. + if (afirst==alast) return false; + Dart_const_handle prec = null_handle; + Dart_const_handle od = null_handle; + + for (InputIterator it(afirst); it!=alast; ++it) + { + // The path must contain only non empty darts. + if (*it == null_handle || *it==null_dart_handle) return false; + + // Two consecutive darts of the path must belong to two edges + // incident to the same vertex of the same volume. + if (prec != null_handle) + { + od = other_extremity(prec); + if ( od==null_handle ) return false; + + // of and *it must belong to the same vertex of the same volume + if ( !belong_to_same_cell(*this, od, *it) ) + return false; + } + prec = *it; + } + + // The path must be closed. + od = other_extremity(prec); + if ( od==null_handle ) return false; + + if (!belong_to_same_cell(*this, od, *afirst)) + return false; + + return true; + } + + /** Insert a 2-cell in a given 3-cell along a path of darts. + * @param afirst iterator on the begining of the path. + * @param alast iterator on the end of the path. + * @param update_attributes a boolean to update the enabled attributes + * @return a dart of the new 2-cell. + */ + template + Dart_handle insert_cell_2_in_cell_3(InputIterator afirst, InputIterator alast, + bool update_attributes=true) + { + CGAL_assertion(is_insertable_cell_2_in_cell_3(afirst,alast)); + + Dart_handle prec = null_handle, d = null_handle, + dd = null_handle, first = null_handle; + bool withBeta3 = false; + + { + for (InputIterator it(afirst); !withBeta3 && it!=alast; ++it) + { + if (!this->template is_free<2>(*it)) withBeta3 = true; + } + } + + { + for (InputIterator it(afirst); it!=alast; ++it) + { + d = create_dart(); + if ( withBeta3 ) + dd = create_dart(); + + if (prec != null_handle) + { + basic_link_beta_0(prec, d); + if (withBeta3) + basic_link_beta_1(this->template beta<3>(prec), dd); + } + else first = d; + + if ( !this->template is_free<2>((*it)) ) + basic_link_beta_for_involution<2>(this->template beta<2>(*it), dd); + + this->template link_beta_for_involution<2>(*it, d); + if ( withBeta3 ) + this->template link_beta_for_involution<3>(d, dd); + + prec = d; + } + } + + basic_link_beta_0(prec, first); + if ( withBeta3 ) + { + basic_link_beta_1(this->template beta<3>(prec), + this->template beta<3>(first)); + } + + // Make copies of the new facet for dimension >=4 + for ( unsigned int dim=4; dim<=dimension; ++dim ) + { + if ( !is_free(first, dim) ) + { + Dart_handle first2 = null_handle; + prec = null_handle; + for ( CMap_dart_iterator_basic_of_orbit it(*this, first); + it.cont(); ++it ) + { + d = create_dart(); + basic_link_beta_for_involution(this->template beta<2>(it), d, dim); + if ( withBeta3 ) + { + dd = create_dart(); + basic_link_beta_for_involution(this->template beta<2,3>(it), dd, dim); + this->template basic_link_beta_for_involution<3>(d, dd); + } + if ( prec!=null_handle ) + { + link_beta_0(prec, d); + if ( withBeta3 ) + { + basic_link_beta_1(this->template beta<3>(prec), dd); + } + } + else first2 = prec; + + // We consider dim2=2 out of the loop to use link_beta instead of + // basic _link_beta (to modify non void attributes only once). + if ( !this->template is_free<2>(it) && is_free(this->template beta<2>(it), dim) ) + this->template link_beta_for_involution<2>(beta(it,2,dim), d); + if ( withBeta3 && !this->template is_free<2>(this->template beta<3>(it)) && + is_free(this->template beta<3,2>(it), dim) ) + this->template link_beta_for_involution<2>(beta(it,3,2,dim), dd); + + for ( unsigned int dim2=3; dim2<=dimension; ++dim2 ) + { + if ( dim2+1!=dim && dim2!=dim && dim2!=dim+1 ) + { + if ( !is_free(it, dim2) && is_free(beta(it, dim2), dim) ) + basic_link_beta_for_involution(beta(it, dim2, dim), + d, dim2); + if ( withBeta3 && !is_free(this->template beta<3>(it), dim2) && + is_free(beta(it, 3, dim2), dim) ) + basic_link_beta_for_involution(beta(it, 3, dim2, dim), dd, + dim2); + } + } + prec = d; + } + basic_link_beta_0( prec, first2 ); + if ( withBeta3 ) + { + basic_link_beta_1( this->template beta<3>(prec), this->template beta<3>(first2) ); + } + } + } + + // Degroup the attributes + if ( withBeta3 ) + { // Here we cannot use Degroup_attribute_functor_run as new darts do not + // have their 3-attribute + if (are_attributes_automatically_managed() && update_attributes) + { + CGAL::internal::Degroup_attribute_functor_run:: + run(this, first, this->template beta<3>(first)); + } + } + +#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS + CGAL_assertion( is_valid() ); +#endif + + return first; + } + protected: /// Number of times each mark is reserved. 0 if the mark is free. mutable size_type mnb_times_reserved_marks[NB_MARKS]; diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map_insertions.h b/Combinatorial_map/include/CGAL/Combinatorial_map_insertions.h index 613188a498e..6313ceef2cd 100644 --- a/Combinatorial_map/include/CGAL/Combinatorial_map_insertions.h +++ b/Combinatorial_map/include/CGAL/Combinatorial_map_insertions.h @@ -28,6 +28,8 @@ namespace CGAL * Insertion operations on combinatorial map. */ +#ifndef CGAL_NO_DEPRECATED_CODE + /** Insert a vertex in a given edge. * @param amap the used combinatorial map. * @param adart a dart of the edge (!=NULL && !=null_dart_handle). @@ -36,84 +38,13 @@ namespace CGAL * @return a dart of the new vertex. */ template -typename CMap::Dart_handle +CGAL_DEPRECATED typename CMap::Dart_handle insert_cell_0_in_cell_1( CMap& amap, typename CMap::Dart_handle adart, typename CMap::template Attribute_handle<0>::type ah=CMap::null_handle, bool update_attributes=true ) { - typename CMap::Dart_handle d1, d2; - typename CMap::size_type mark=amap.get_new_mark(); - - // 1) We store all the darts of the edge. - std::deque vect; - typename CMap::size_type m=amap.get_new_mark(); - { - for ( typename CMap::template Dart_of_cell_basic_range<1>::iterator - it=amap.template darts_of_cell_basic<1>(adart, m).begin(); - it != amap.template darts_of_cell_basic<1>(adart, m).end(); ++it ) - vect.push_back(it); - } - - // 2) For each dart of the cell, we modify link of neighbors. - typename std::deque::iterator it = vect.begin(); - for (; it != vect.end(); ++it) - { - d1 = amap.create_dart(); - - if (!amap.template is_free<1>(*it)) - { amap.basic_link_beta_1(d1, amap.template beta<1>(*it)); } - - for ( unsigned int dim=2; dim<=CMap::dimension; ++dim ) - { - if (!amap.is_free(*it, dim) && amap.is_marked(amap.beta(*it, dim), mark)) - { - amap.basic_link_beta_for_involution(amap.beta(*it, dim), d1, dim); - amap.basic_link_beta_for_involution(*it, amap.beta(*it, dim, 1), dim); - } - } - - amap.basic_link_beta_1(*it, d1); - - if (amap.are_attributes_automatically_managed() && update_attributes) - { - // We copy all the attributes except for dim=0 - CMap::Helper::template Foreach_enabled_attributes_except - , 0>:: - run(&amap,*it,d1); - } - if (ah != CMap::null_handle) - { - // We initialise the 0-atttrib to ah - CGAL::internal::Set_i_attribute_of_dart_functor:: - run(&amap, d1, ah); - } - amap.mark(*it, mark); - } - - for (it = vect.begin(); it != vect.end(); ++it) - { - amap.unmark(*it, m); - 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(mark); - - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Degroup_attribute_functor_run:: - run(&amap, adart, amap.template beta<1>(adart)); - } - -#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS - CGAL_assertion( amap.is_valid() ); -#endif - - return amap.template beta<1>(adart); + return amap.insert_cell_0_in_cell_1(adart, ah, update_attributes); } /** Insert a vertex in the given 2-cell which is splitted in triangles, @@ -125,161 +56,13 @@ insert_cell_0_in_cell_1( CMap& amap, typename CMap::Dart_handle adart, * @return A dart incident to the new vertex. */ template < class CMap > -typename CMap::Dart_handle +CGAL_DEPRECATED typename CMap::Dart_handle insert_cell_0_in_cell_2( CMap& amap, typename CMap::Dart_handle adart, typename CMap::template Attribute_handle<0>::type ah=CMap::null_handle, bool update_attributes=true ) { - CGAL_assertion(adart!=amap.null_dart_handle); - - typename CMap::Dart_handle first=adart, prev=amap.null_handle, - cur=amap.null_handle, next=amap.null_handle, - n1=amap.null_handle, n2=amap.null_handle, - nn1=amap.null_handle, nn2=amap.null_handle; - - // If the facet is open, we search the dart 0-free - while ( !amap.template is_free<0>(first) && - amap.template beta<0>(first)!=adart ) - first = amap.template beta<0>(first); - - // Mark used to mark darts already treated. - typename CMap::size_type treated = amap.get_new_mark(); - - // Stack of marked darts - std::deque tounmark; - - // Now we run through the facet - cur = first; - do - { - next = amap.template beta<1>(cur); - amap.mark(cur, treated); - tounmark.push_back(cur); - - if (!amap.template is_free<0>(cur)) - { - n1=amap.create_dart(); - amap.link_beta_0(cur, n1); - } - else n1 = amap.null_handle; - - if (!amap.template is_free<1>(cur)) - { - n2 = amap.create_dart(); - amap.link_beta_1(cur, n2); - } - else n2 = amap.null_handle; - - if ( n1!=amap.null_handle ) - { - if ( n2!=amap.null_handle ) - amap.basic_link_beta_0(n1, n2); - - if ( prev!=amap.null_handle ) - amap.template basic_link_beta_for_involution<2>(prev, n1); - - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Set_i_attribute_of_dart_functor:: - run(&amap, n1, ah); - } - } - - for (unsigned int dim=3; dim<=CMap::dimension; ++dim) - { - if ( !amap.is_free(adart, dim) ) - { - if ( !amap.is_marked(amap.beta(cur, dim), treated) ) - { - if (n1!=amap.null_handle) - { - nn1=amap.create_dart(); - amap.link_beta_1(amap.beta(cur, dim), nn1); - amap.basic_link_beta_for_involution(n1, nn1, dim); - } - else nn1=amap.null_handle; - - if (n2!=amap.null_handle) - { - nn2=amap.create_dart(); - amap.link_beta_0(amap.beta(cur, dim), nn2); - amap.basic_link_beta_for_involution(n2, nn2, dim); - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Set_i_attribute_of_dart_functor:: - run(&amap, nn2, ah); - } - } - else nn2=amap.null_handle; - - if (nn1 != amap.null_handle && nn2 != amap.null_handle) - amap.basic_link_beta_1(nn1, nn2); - - if (nn1 != amap.null_handle && prev != amap.null_handle) - amap.template basic_link_beta_for_involution<2> - (nn1, amap.beta(prev, dim)); - - amap.mark(amap.beta(cur, dim), treated); - } - else - { - if ( n1!=amap.null_handle ) - amap.basic_link_beta_for_involution(n1, - amap.beta(cur, dim, 1), dim); - if ( n2!=amap.null_handle ) - amap.basic_link_beta_for_involution(n2, - amap.beta(cur, dim, 0), dim); - } - } - } - - prev = n2; - cur = next; - } - while(cur!=first && cur!=amap.null_dart_handle); - - if (n2 != amap.null_handle) - { - amap.template basic_link_beta_for_involution<2> - (amap.template beta<0>(first), n2); - for (unsigned int dim=3; dim<=CMap::dimension; ++dim) - { - if ( !amap.is_free(adart, dim) ) - { - amap.template basic_link_beta_for_involution<2> - (amap.beta(first, 0, dim), amap.beta(n2, dim)); - } - } - } - - // Now we unmark all marked darts, and we degroup the new faces with the - // initial one (if 2-attributes are non void). - for ( typename std::deque::iterator - itd=tounmark.begin(); itd!=tounmark.end(); ++itd ) - { - amap.unmark(*itd, treated); - for (unsigned int dim=3; dim<=CMap::dimension; ++dim) - { - if ( !amap.is_free(*itd, dim) ) - amap.unmark(amap.beta(*itd, dim), treated); - } - if ( *itd!=adart ) - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Degroup_attribute_functor_run:: - run(&amap, adart, *itd); - } - } - - CGAL_assertion(amap.is_whole_map_unmarked(treated)); - amap.free_mark(treated); - -#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS - CGAL_assertion( amap.is_valid() ); -#endif - - return n1; + return amap.insert_cell_0_in_cell_2(adart, ah, update_attributes); } /** Insert a dangling edge in a 2-cell between given by a dart. * @param amap the used combinatorial map. @@ -289,100 +72,15 @@ insert_cell_0_in_cell_2( CMap& amap, typename CMap::Dart_handle adart, * @return a dart of the new edge, not incident to the vertex of adart1. */ template -typename CMap::Dart_handle +CGAL_DEPRECATED typename CMap::Dart_handle insert_dangling_cell_1_in_cell_2( CMap& amap, typename CMap::Dart_handle adart1, typename CMap::template Attribute_handle<0>::type ah=CMap::null_handle, bool update_attributes=true ) { - typename CMap::size_type mark1 = amap.get_new_mark(); - std::deque to_unmark; - { - for ( CMap_dart_iterator_basic_of_cell it(amap,adart1,mark1); - it.cont(); ++it ) - { - to_unmark.push_back(it); - amap.mark(it,mark1); - } - } - - typename CMap::Dart_handle d1 = amap.null_handle; - typename CMap::Dart_handle d2 = amap.null_handle; - unsigned int s1 = 0; - - typename CMap::size_type treated=amap.get_new_mark(); - - CGAL::CMap_dart_iterator_basic_of_involution - it1(amap, adart1, treated); - - for ( ; it1.cont(); ++it1) - { - d1 = amap.create_dart(); - d2 = amap.create_dart(); - - if ( amap.is_marked(it1, mark1) ) s1 = 0; - else s1 = 1; - - if ( !amap.is_free(it1, s1) ) - { - if ( s1==0 ) - amap.link_beta_1(amap.template beta<0>(it1), d2); - else - amap.link_beta_0(amap.template beta<1>(it1), d2); - } - - if (s1==0) - { - amap.link_beta_0(it1, d1); - amap.link_beta_0(d1, d2); - } - else - { - amap.link_beta_1(it1, d1); - amap.link_beta_1(d1, d2); - } - - amap.template basic_link_beta_for_involution<2>(d1, d2); - - for ( unsigned int dim=3; dim<=CMap::dimension; ++dim) - { - if ( !amap.is_free(it1, dim) && - amap.is_marked(amap.beta(it1, dim), treated) ) - { - amap.basic_link_beta_for_involution - (amap.beta(it1, dim, CGAL_BETAINV(s1)), d1, dim); - amap.basic_link_beta_for_involution - (amap.beta(it1, dim, CGAL_BETAINV(s1), 2), d2, dim); - } - } - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Set_i_attribute_of_dart_functor:: - run(&amap, d1, ah); - } - amap.mark(it1, treated); - } - - amap.negate_mark(treated); - for ( it1.rewind(); it1.cont(); ++it1 ) - { amap.mark(it1, treated); } - - CGAL_assertion( amap.is_whole_map_marked(treated) ); - amap.free_mark(treated); - - for ( typename std::deque::iterator - it=to_unmark.begin(); it!=to_unmark.end(); ++it) - { amap.unmark(*it, mark1); } - - CGAL_assertion( amap.is_whole_map_unmarked(mark1) ); - amap.free_mark(mark1); - -#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS - CGAL_assertion( amap.is_valid() ); -#endif - - return amap.template beta<0>(adart1); + return amap.insert_dangling_cell_1_in_cell_2(adart1, + ah, update_attributes); } /** Test if an edge can be inserted onto a 2-cell between two given darts. @@ -392,17 +90,11 @@ insert_dangling_cell_1_in_cell_2( CMap& amap, * @return true iff an edge can be inserted between adart1 and adart2. */ template < class CMap > -bool is_insertable_cell_1_in_cell_2(const CMap& amap, - typename CMap::Dart_const_handle adart1, - typename CMap::Dart_const_handle adart2) +CGAL_DEPRECATED bool is_insertable_cell_1_in_cell_2 +(const CMap& amap, typename CMap::Dart_const_handle adart1, + typename CMap::Dart_const_handle adart2) { - if ( adart1==adart2 ) return false; - for ( CGAL::CMap_dart_const_iterator_of_orbit it(amap,adart1); - it.cont(); ++it ) - { - if ( it==adart2 ) return true; - } - return false; + return amap.is_insertable_cell_1_in_cell_2(adart1, adart2); } /** Insert an edge in a 2-cell between two given darts. @@ -415,123 +107,14 @@ bool is_insertable_cell_1_in_cell_2(const CMap& amap, * same vertex than adart1. */ template -typename CMap::Dart_handle +CGAL_DEPRECATED typename CMap::Dart_handle insert_cell_1_in_cell_2(CMap& amap, typename CMap::Dart_handle adart1, typename CMap::Dart_handle adart2, bool update_attributes=true) { - if ( adart2==amap.null_handle ) - return insert_dangling_cell_1_in_cell_2(amap,adart1); - - CGAL_assertion(is_insertable_cell_1_in_cell_2(amap, adart1, adart2)); - - typename CMap::size_type m1=amap.get_new_mark(); - CGAL::CMap_dart_iterator_basic_of_involution it1(amap, adart1, m1); - - typename CMap::size_type m2=amap.get_new_mark(); - CGAL::CMap_dart_iterator_basic_of_involution it2(amap, adart2, m2); - - typename CMap::size_type mark1=amap.get_new_mark(); - std::deque to_unmark; - { - for ( CGAL::CMap_dart_iterator_basic_of_cell it(amap,adart1,mark1); - it.cont(); ++it ) - { - to_unmark.push_back(it); - amap.mark(it, mark1); - } - } - - typename CMap::Dart_handle d1=amap.null_handle; - typename CMap::Dart_handle d2=amap.null_handle; - unsigned int s1=0; - - typename CMap::size_type treated=amap.get_new_mark(); - - for ( ; it1.cont(); ++it1, ++it2) - { - CGAL_assertion (it2.cont() ); - d1 = amap.create_dart(); - d2 = amap.create_dart(); - - if ( amap.is_marked(it1, mark1) ) s1 = 0; - else s1 = 1; - - if ( !amap.is_free(it1, s1) ) - { - if ( s1==0 ) amap.link_beta_1(amap.template beta<0>(it1), d2); - else amap.link_beta_0(amap.template beta<1>(it1), d2); - } - - if ( !amap.is_free(it2, s1) ) - { - if ( s1==0 ) amap.link_beta_1(amap.template beta<0>(it2), d1); - else amap.link_beta_0(amap.template beta<1>(it2), d1); - } - - if ( s1==0 ) - { - amap.link_beta_0(it1, d1); - amap.link_beta_0(it2, d2); - } - else - { - amap.link_beta_1(it1, d1); - amap.link_beta_1(it2, d2); - } - amap.template basic_link_beta_for_involution<2>(d2, d1); - - for ( unsigned int dim=3; dim<=CMap::dimension; ++dim) - { - if ( !amap.is_free(it1, dim) && - amap.is_marked(amap.beta(it1, dim), treated) ) - { - amap.basic_link_beta_for_involution - (amap.beta(it1, dim, CGAL_BETAINV(s1)), d1, dim); - amap.basic_link_beta_for_involution - (amap.beta(it1, dim, CGAL_BETAINV(s1), 2), d2, dim); - } - } - - amap.mark(it1,treated); - } - - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Degroup_attribute_functor_run::run(&amap, d1, d2); - } - - amap.negate_mark(m1); - amap.negate_mark(m2); - it1.rewind(); it2.rewind(); - for ( ; it1.cont(); ++it1, ++it2) - { - amap.mark(it1,m1); - amap.unmark(it1,treated); - amap.mark(it2,m2); - } - amap.negate_mark(m1); - amap.negate_mark(m2); - CGAL_assertion( amap.is_whole_map_unmarked(m1) ); - CGAL_assertion( amap.is_whole_map_unmarked(m2) ); - CGAL_assertion( amap.is_whole_map_unmarked(treated) ); - amap.free_mark(m1); - amap.free_mark(m2); - amap.free_mark(treated); - - typename std::deque::iterator it = - to_unmark.begin(); - for (; it != to_unmark.end(); ++it) - { amap.unmark(*it, mark1); } - CGAL_assertion( amap.is_whole_map_unmarked(mark1) ); - amap.free_mark(mark1); - -#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS - CGAL_assertion( amap.is_valid() ); -#endif - - return amap.template beta<0>(adart1); + return amap.insert_cell_1_in_cell_2(adart1, adart2, + update_attributes); } /** Test if a 2-cell can be inserted onto a given 3-cell along @@ -542,44 +125,10 @@ insert_cell_1_in_cell_2(CMap& amap, * @return true iff a 2-cell can be inserted along the path. */ template -bool is_insertable_cell_2_in_cell_3(const CMap& amap, - InputIterator afirst, - InputIterator alast) +CGAL_DEPRECATED bool is_insertable_cell_2_in_cell_3 +(const CMap& amap, InputIterator afirst, InputIterator alast) { - CGAL_assertion( CMap::dimension>= 3 ); - - // The path must have at least one dart. - if (afirst==alast) return false; - typename CMap::Dart_const_handle prec = amap.null_handle; - typename CMap::Dart_const_handle od = amap.null_handle; - - for (InputIterator it(afirst); it!=alast; ++it) - { - // The path must contain only non empty darts. - if (*it == amap.null_handle || *it==amap.null_dart_handle) return false; - - // Two consecutive darts of the path must belong to two edges - // incident to the same vertex of the same volume. - if (prec != amap.null_handle) - { - od = amap.other_extremity(prec); - if ( od==amap.null_handle ) return false; - - // of and *it must belong to the same vertex of the same volume - if ( !CGAL::belong_to_same_cell(amap, od, *it) ) - return false; - } - prec = *it; - } - - // The path must be closed. - od = amap.other_extremity(prec); - if ( od==amap.null_handle ) return false; - - if (!CGAL::belong_to_same_cell(amap, od, *afirst)) - return false; - - return true; + return amap.is_insertable_cell_2_in_cell_3(afirst, alast); } /** Insert a 2-cell in a given 3-cell along a path of darts. @@ -591,139 +140,15 @@ bool is_insertable_cell_2_in_cell_3(const CMap& amap, * @return a dart of the new 2-cell. */ template -typename CMap::Dart_handle +CGAL_DEPRECATED typename CMap::Dart_handle insert_cell_2_in_cell_3(CMap& amap, InputIterator afirst, InputIterator alast, bool update_attributes=true) { - CGAL_assertion(is_insertable_cell_2_in_cell_3(amap,afirst,alast)); - - typename CMap::Dart_handle prec = amap.null_handle, d = amap.null_handle, - dd = amap.null_handle, first = amap.null_handle; - bool withBeta3 = false; - - { - for (InputIterator it(afirst); !withBeta3 && it!=alast; ++it) - { - if (!amap.template is_free<2>(*it)) withBeta3 = true; - } - } - - { - for (InputIterator it(afirst); it!=alast; ++it) - { - d = amap.create_dart(); - if ( withBeta3 ) - dd = amap.create_dart(); - - if (prec != amap.null_handle) - { - amap.basic_link_beta_0(prec, d); - if (withBeta3) - amap.basic_link_beta_1(amap.template beta<3>(prec), dd); - } - else first = d; - - if ( !amap.template is_free<2>((*it)) ) - amap.template basic_link_beta_for_involution<2> - (amap.template beta<2>(*it), dd); - - amap.template link_beta_for_involution<2>(*it, d); - if ( withBeta3 ) - amap.template link_beta_for_involution<3>(d, dd); - - prec = d; - } - } - - amap.basic_link_beta_0(prec, first); - if ( withBeta3 ) - { - amap.basic_link_beta_1(amap.template beta<3>(prec), - amap.template beta<3>(first)); - } - - // Make copies of the new facet for dimension >=4 - for ( unsigned int dim=4; dim<=CMap::dimension; ++dim ) - { - if ( !amap.is_free(first, dim) ) - { - typename CMap::Dart_handle first2 = amap.null_handle; - prec = amap.null_handle; - for ( CMap_dart_iterator_basic_of_orbit it(amap, first); - it.cont(); ++it ) - { - d = amap.create_dart(); - amap.basic_link_beta_for_involution(amap.template beta<2>(it), d, dim); - if ( withBeta3 ) - { - dd = amap.create_dart(); - amap.basic_link_beta_for_involution - (amap.template beta<2,3>(it), dd, dim); - amap.template basic_link_beta_for_involution<3>(d, dd); - } - if ( prec!=amap.null_handle ) - { - amap.link_beta_0(prec, d); - if ( withBeta3 ) - { - amap.basic_link_beta_1(amap.template beta<3>(prec), dd); - } - } - else first2 = prec; - - // We consider dim2=2 out of the loop to use link_beta instead of - // basic _link_beta (to modify non void attributes only once). - if ( !amap.template is_free<2>(it) && - amap.is_free(amap.template beta<2>(it), dim) ) - amap.template link_beta_for_involution<2> - (amap.beta(it,2,dim), d); - if ( withBeta3 && - !amap.template is_free<2>(amap.template beta<3>(it)) && - amap.is_free(amap.template beta<3,2>(it), dim) ) - amap.template link_beta_for_involution<2>(amap.beta(it,3,2,dim), dd); - - for ( unsigned int dim2=3; dim2<=CMap::dimension; ++dim2 ) - { - if ( dim2+1!=dim && dim2!=dim && dim2!=dim+1 ) - { - if ( !amap.is_free(it, dim2) && amap.is_free(amap.beta(it, dim2), dim) ) - amap.basic_link_beta_for_involution(amap.beta(it, dim2, dim), - d, dim2); - if ( withBeta3 && !amap.is_free(amap.template beta<3>(it), dim2) && - amap.is_free(amap.beta(it, 3, dim2), dim) ) - amap.basic_link_beta_for_involution - (amap.beta(it, 3, dim2, dim), dd, dim2); - } - } - prec = d; - } - amap.basic_link_beta_0( prec, first2 ); - if ( withBeta3 ) - { - amap.basic_link_beta_1( amap.template beta<3>(prec), - amap.template beta<3>(first2) ); - } - } - } - - // Degroup the attributes - if ( withBeta3 ) - { // Here we cannot use Degroup_attribute_functor_run as new darts do not - // have their 3-attribute - if (amap.are_attributes_automatically_managed() && update_attributes) - { - CGAL::internal::Degroup_attribute_functor_run:: - run(&amap, first, amap.template beta<3>(first)); - } - } - -#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS - CGAL_assertion( amap.is_valid() ); -#endif - - return first; + return amap.insert_cell_2_in_cell_3(afirst, alast, update_attributes); } +#endif // CGAL_NO_DEPRECATED_CODE + } // namespace CGAL #endif // CGAL_COMBINATORIAL_MAP_INSERTIONS_H diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h b/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h index 4481c2e1874..e495811330e 100644 --- a/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h +++ b/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h @@ -74,10 +74,13 @@ namespace CGAL * @param adart a dart of the i-cell. * @return true iff the i-cell can be removed. */ +#ifndef CGAL_NO_DEPRECATED_CODE template < class CMap, unsigned int i > - bool is_removable(const CMap& amap, typename CMap::Dart_const_handle adart) + CGAL_DEPRECATED bool is_removable(const CMap& amap, + typename CMap::Dart_const_handle adart) { return CGAL::Is_removable_functor::run(amap,adart); } - +#endif // CGAL_NO_DEPRECATED_CODE + /** Remove an i-cell, 0 struct Remove_cell_functor { - static size_t run(CMap& amap, typename CMap::Dart_handle adart, bool update_attributes) + static size_t run(CMap& amap, typename CMap::Dart_handle adart, + bool update_attributes) { CGAL_static_assertion ( 1<=i && i(amap, adart)) ); + CGAL_assertion( (amap.is_removable(adart)) ); size_t res = 0; @@ -278,7 +282,8 @@ namespace CGAL template struct Remove_cell_functor { - static size_t run(CMap& amap, typename CMap::Dart_handle adart, bool update_attributes) + static size_t run(CMap& amap, typename CMap::Dart_handle adart, + bool update_attributes) { typename CMap::size_type mark = amap.get_new_mark(); std::deque to_erase; @@ -348,7 +353,7 @@ namespace CGAL static size_t run(CMap& amap, typename CMap::Dart_handle adart, bool update_attributes) { - CGAL_assertion( (is_removable(amap,adart)) ); + CGAL_assertion( (amap.is_removable<0>(adart)) ); size_t res = 0; @@ -470,12 +475,15 @@ namespace CGAL * @param update_attributes a boolean to update the enabled attributes * @return the number of deleted darts. */ +#ifndef CGAL_NO_DEPRECATED_CODE template < class CMap, unsigned int i > - size_t remove_cell(CMap& amap, typename CMap::Dart_handle adart, bool update_attributes = true) + CGAL_DEPRECATED size_t remove_cell(CMap& amap, typename CMap::Dart_handle adart, + bool update_attributes = true) { - return - CGAL::Remove_cell_functor::run(amap,adart,update_attributes); + return CGAL::Remove_cell_functor:: + run(amap,adart,update_attributes); } +#endif // CGAL_NO_DEPRECATED_CODE /** Test if an i-cell can be contracted. * An i-cell can be contracted if i==1 @@ -533,7 +541,8 @@ namespace CGAL template struct Contract_cell_functor { - static size_t run(CMap& amap, typename CMap::Dart_handle adart) + static size_t run(CMap& amap, typename CMap::Dart_handle adart, + bool update_attributes) { CGAL_static_assertion ( 2<=i && i<=CMap::dimension ); CGAL_assertion( (is_contractible(amap, adart)) ); @@ -560,7 +569,7 @@ namespace CGAL ++res; } - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { // We group the two (i+1)-cells incident if they exist. if ( dg1!=amap.null_handle ) @@ -643,7 +652,7 @@ namespace CGAL } } - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { // We test the split of all the incident cells for all the non // void attributes. @@ -689,7 +698,8 @@ namespace CGAL template struct Contract_cell_functor { - static size_t run(CMap& amap, typename CMap::Dart_handle adart) + static size_t run(CMap& amap, typename CMap::Dart_handle adart, + bool update_attributes) { CGAL_assertion( (is_contractible(amap,adart)) ); @@ -713,7 +723,7 @@ namespace CGAL ++res; } - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { // We group the two vertices incident if they exist. if ( dg1!=amap.null_handle ) @@ -740,7 +750,7 @@ namespace CGAL { /*modified_darts2.push_back((*it)->template beta<0>()); if ( (*it)->beta(0)!=(*it)->beta(1) )*/ - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { modified_darts.push_back(amap.template beta<1>(*it)); } @@ -750,7 +760,7 @@ namespace CGAL } else { - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { modified_darts2.push_back(amap.template beta<0>(*it)); } @@ -761,7 +771,7 @@ namespace CGAL { if ( !amap.template is_free<1>(*it) ) { - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { modified_darts.push_back(amap.template beta<1>(*it)); } @@ -777,7 +787,7 @@ namespace CGAL CGAL_assertion( amap.is_whole_map_unmarked(mark) ); amap.free_mark(mark); - if ( amap.are_attributes_automatically_managed() ) + if ( amap.are_attributes_automatically_managed() && update_attributes ) { // We test the split of all the incident cells for all the non // void attributes. @@ -799,9 +809,12 @@ namespace CGAL * @param adart a dart of the i-cell to remove. * @return the number of deleted darts. */ +#ifndef CGAL_NO_DEPRECATED_CODE template < class CMap, unsigned int i > - size_t contract_cell(CMap& amap, typename CMap::Dart_handle adart) - { return CGAL::Contract_cell_functor::run(amap,adart); } + CGAL_DEPRECATED size_t contract_cell(CMap& amap, typename CMap::Dart_handle adart, + bool update_attributes) + { return CGAL::Contract_cell_functor::run(amap,adart, update_attributes); } +#endif // CGAL_NO_DEPRECATED_CODE } // namespace CGAL